StdMeshSkeletonLoader Class Reference

#include <StdMeshLoader.h>

Public Types
typedef std::map< StdCopyStrBuf, std::shared_ptr< StdMeshSkeleton > >	SkeletonMap
typedef SkeletonMap::const_iterator	skeleton_iterator

Public Member Functions
virtual	~StdMeshSkeletonLoader ()=default
void	StoreSkeleton (const char *groupname, const char *filename, std::shared_ptr< StdMeshSkeleton > skeleton)
void	RemoveSkeleton (const StdCopyStrBuf &filepath)
void	RemoveSkeleton (const char *groupname, const char *filename)
void	RemoveSkeletonsInGroup (const char *groupname)
virtual StdMeshSkeleton *	GetSkeletonByDefinition (const char *definition) const =0
std::shared_ptr< StdMeshSkeleton >	GetSkeletonByName (const StdStrBuf &name) const
void	LoadSkeletonXml (const char *groupname, const char *filename, const char *sourcefile, size_t size)
void	LoadSkeletonBinary (const char *groupname, const char *filename, const char *sourcefile, size_t size)
void	ResolveIncompleteSkeletons ()
void	Clear ()
skeleton_iterator	skeletons_begin () const
skeleton_iterator	skeletons_end () const

Static Public Member Functions
static void	MakeFullSkeletonPath (StdCopyStrBuf &out, const char *groupname, const char *filename)

Detailed Description

Definition at line 49 of file StdMeshLoader.h.

Member Typedef Documentation

skeleton_iterator

typedef SkeletonMap::const_iterator StdMeshSkeletonLoader::skeleton_iterator

Definition at line 83 of file StdMeshLoader.h.

SkeletonMap

typedef std::map<StdCopyStrBuf, std::shared_ptr<StdMeshSkeleton> > StdMeshSkeletonLoader::SkeletonMap

Definition at line 82 of file StdMeshLoader.h.

Constructor & Destructor Documentation

~StdMeshSkeletonLoader()

virtual StdMeshSkeletonLoader::~StdMeshSkeletonLoader ( )

virtualdefault

Member Function Documentation

Clear()

void StdMeshSkeletonLoader::Clear ( )

inline

Definition at line 74 of file StdMeshLoader.h.

    {
        Skeletons.clear();
        AppendtoSkeletons.clear();
        IncludeSkeletons.clear();
    }

GetSkeletonByDefinition()

virtual StdMeshSkeleton* StdMeshSkeletonLoader::GetSkeletonByDefinition ( const char *  definition ) const

pure virtual

GetSkeletonByName()

std::shared_ptr< StdMeshSkeleton > StdMeshSkeletonLoader::GetSkeletonByName

(

const StdStrBuf &

name

)

const

Definition at line 295 of file StdMeshLoaderBinary.cpp.

{
    StdCopyStrBuf filename(name);
 
    std::map<StdCopyStrBuf, std::shared_ptr<StdMeshSkeleton>>::const_iterator iter = Skeletons.find(filename);
    if (iter == Skeletons.end()) return nullptr;
    return iter->second;
}

Referenced by StdMeshLoader::LoadMeshBinary(), and StdMeshLoader::LoadMeshXml().

Here is the caller graph for this function:

LoadSkeletonBinary()

void StdMeshSkeletonLoader::LoadSkeletonBinary	(	const char *	groupname,
		const char *	filename,
		const char *	sourcefile,
		size_t	size
	)

Definition at line 304 of file StdMeshLoaderBinary.cpp.

{
    std::unique_ptr<Ogre::Skeleton::Chunk> chunk;
    Ogre::DataStream stream(sourcefile, size);
 
    std::shared_ptr<StdMeshSkeleton> Skeleton(new StdMeshSkeleton);
 
    // First chunk must be the header
    chunk = Ogre::Skeleton::Chunk::Read(&stream);
    if (chunk->GetType() != Ogre::Skeleton::CID_Header)
        throw Ogre::Skeleton::InvalidVersion();
 
    std::map<uint16_t, std::unique_ptr<StdMeshBone>> bones;
    unique_ptr_vector<Ogre::Skeleton::ChunkAnimation> animations;
    for (Ogre::Skeleton::ChunkID id = Ogre::Skeleton::Chunk::Peek(&stream);
        id == Ogre::Skeleton::CID_BlendMode || id == Ogre::Skeleton::CID_Bone || id == Ogre::Skeleton::CID_Bone_Parent || id == Ogre::Skeleton::CID_Animation;
        id = Ogre::Skeleton::Chunk::Peek(&stream)
        )
    {
        std::unique_ptr<Ogre::Skeleton::Chunk> chunk(Ogre::Skeleton::Chunk::Read(&stream));
        switch (chunk->GetType())
        {
        case Ogre::Skeleton::CID_BlendMode:
        {
            Ogre::Skeleton::ChunkBlendMode& cblend = *static_cast<Ogre::Skeleton::ChunkBlendMode*>(chunk.get());
            // TODO: Handle it
            if (cblend.blend_mode != 0) // 0 is average, 1 is cumulative. I'm actually not sure what the difference really is... anyway we implement only one method yet. I think it's average, but not 100% sure.
                LogF("StdMeshLoader: CID_BlendMode not implemented.");
        }
        break;
        case Ogre::Skeleton::CID_Bone:
        {
            Ogre::Skeleton::ChunkBone &cbone = *static_cast<Ogre::Skeleton::ChunkBone*>(chunk.get());
            // Check that the bone ID is unique
            if (bones.find(cbone.handle) != bones.end())
                throw Ogre::Skeleton::IdNotUnique();
            auto bone = std::make_unique<StdMeshBone>();
            bone->Parent = nullptr;
            bone->ID = cbone.handle;
            bone->Name = cbone.name.c_str();
            bone->Transformation.translate = cbone.position;
            bone->Transformation.rotate = cbone.orientation;
            bone->Transformation.scale = cbone.scale;
            bone->InverseTransformation = StdMeshTransformation::Inverse(bone->Transformation);
            bones.insert(std::make_pair(cbone.handle, std::move(bone)));
        }
        break;
        case Ogre::Skeleton::CID_Bone_Parent:
        {
            Ogre::Skeleton::ChunkBoneParent &cbparent = *static_cast<Ogre::Skeleton::ChunkBoneParent*>(chunk.get());
            if (bones.find(cbparent.parentHandle) == bones.end() || bones.find(cbparent.childHandle) == bones.end())
                throw Ogre::Skeleton::BoneNotFound();
            bones[cbparent.parentHandle]->Children.push_back(bones[cbparent.childHandle].get());
            bones[cbparent.childHandle]->Parent = bones[cbparent.parentHandle].get();
        }
        break;
        case Ogre::Skeleton::CID_Animation:
            // Collect animations for later (need bone table index, which we don't know yet)
            animations.emplace_back(static_cast<Ogre::Skeleton::ChunkAnimation*>(chunk.release()));
            break;
        default:
            assert(!"Unexpected enum value");
            break;
        }
        if (stream.AtEof()) break;
    }
 
    // Find master bone (i.e., the one without a parent)
    StdMeshBone *master = nullptr;
    for (auto& b: bones)
    {
        if (!b.second->Parent)
        {
            master = b.second.get();
            Skeleton->AddMasterBone(master);
        }
    }
    if (!master)
        throw Ogre::Skeleton::MissingMasterBone();
 
    // Transfer bone ownership to mesh
    for (auto& b: bones) b.second.release();
    bones.clear();
 
    // Build handle->index quick access table
    std::map<uint16_t, size_t> handle_lookup;
    for (size_t i = 0; i < Skeleton->GetNumBones(); ++i)
    {
        handle_lookup[Skeleton->GetBone(i).ID] = i;
    }
 
    // Fixup animations
    for(auto &canim: animations)
    {
        StdMeshAnimation &anim = Skeleton->Animations[StdCopyStrBuf(canim->name.c_str())];
        anim.Name = canim->name.c_str();
        anim.Length = canim->duration;
        anim.Tracks.resize(Skeleton->GetNumBones());
        anim.OriginSkeleton = &(*Skeleton);
 
        for(auto &catrack: canim->tracks)
        {
            const StdMeshBone &bone = Skeleton->GetBone(handle_lookup[catrack->bone]);
            StdMeshTrack *&track = anim.Tracks[bone.Index];
            if (track != nullptr)
                throw Ogre::Skeleton::MultipleBoneTracks();
            track = new StdMeshTrack;
            for(auto &catkf: catrack->keyframes)
            {
                StdMeshKeyFrame &kf = track->Frames[catkf->time];
                kf.Transformation.rotate = catkf->rotation;
                kf.Transformation.scale = catkf->scale;
                kf.Transformation.translate = bone.InverseTransformation.rotate * (bone.InverseTransformation.scale * catkf->translation);
                kf.Transformation = OgreToClonk::TransformTransformation(kf.Transformation);
            }
        }
    }
 
    // Fixup bone transforms
    for(StdMeshBone *bone: Skeleton->Bones)
    {
        if (bone->Parent)
            bone->Transformation = bone->Parent->Transformation * OgreToClonk::TransformTransformation(bone->Transformation);
        else
            bone->Transformation = OgreToClonk::TransformTransformation(bone->Transformation);
 
        bone->InverseTransformation = StdMeshTransformation::Inverse(bone->Transformation);
    }
 
    StoreSkeleton(groupname, filename, Skeleton);
}

References Ogre::DataStream::AtEof(), b, Ogre::Skeleton::ChunkBlendMode::blend_mode, Ogre::Skeleton::ChunkBoneParent::childHandle, Ogre::Skeleton::CID_Animation, Ogre::Skeleton::CID_BlendMode, Ogre::Skeleton::CID_Bone, Ogre::Skeleton::CID_Bone_Parent, Ogre::Skeleton::CID_Header, Ogre::Skeleton::ChunkBone::handle, StdMeshBone::Index, StdMeshTransformation::Inverse(), StdMeshBone::InverseTransformation, StdMeshAnimation::Length, LogF(), StdMeshAnimation::Name, Ogre::Skeleton::ChunkBone::name, Ogre::Skeleton::ChunkBone::orientation, Ogre::Skeleton::ChunkBoneParent::parentHandle, Ogre::ChunkBase< ChunkID >::Peek(), Ogre::Skeleton::ChunkBone::position, Ogre::Skeleton::Chunk::Read(), StdMeshTransformation::rotate, Ogre::Skeleton::ChunkBone::scale, StdMeshTransformation::scale, StoreSkeleton(), StdMeshBone::Transformation, StdMeshKeyFrame::Transformation, OgreToClonk::TransformTransformation(), and StdMeshTransformation::translate.

Referenced by C4DefGraphics::LoadSkeleton().

Here is the call graph for this function:

Here is the caller graph for this function:

LoadSkeletonXml()

void StdMeshSkeletonLoader::LoadSkeletonXml	(	const char *	groupname,
		const char *	filename,
		const char *	sourcefile,
		size_t	size
	)

Definition at line 381 of file StdMeshLoaderXml.cpp.

{
    if (sourcefile == nullptr)
    {
        throw Ogre::InsufficientData(FormatString("Failed to load '%s/%s'", groupname, filename).getData());
    }
 
    std::shared_ptr<StdMeshLoader::StdMeshXML> skeleton(new StdMeshLoader::StdMeshXML(filename, sourcefile));
 
    TiXmlElement* skeleton_elem = skeleton->RequireFirstChild(nullptr, "skeleton");
    TiXmlElement* bones_elem = skeleton->RequireFirstChild(skeleton_elem, "bones");
 
    // Read bones. Don't insert into Master bone table yet, as the master bone
    // table is sorted hierarchically, and we will read the hierarchy only
    // afterwards.
    std::vector<StdMeshBone*> bones;
    for (TiXmlElement* bone_elem = bones_elem->FirstChildElement("bone"); bone_elem != nullptr; bone_elem = bone_elem->NextSiblingElement("bone"))
    {
        StdMeshBone* bone = new StdMeshBone;
        bones.push_back(bone);
 
        bone->ID = skeleton->RequireIntAttribute(bone_elem, "id");
        bone->Name = skeleton->RequireStrAttribute(bone_elem, "name");
        // TODO: Make sure ID and name are unique
 
        bone->Parent = nullptr;
        // Index of bone will be set when building Master Bone Table later
 
        TiXmlElement* position_elem = skeleton->RequireFirstChild(bone_elem, "position");
        TiXmlElement* rotation_elem = skeleton->RequireFirstChild(bone_elem, "rotation");
        TiXmlElement* axis_elem = skeleton->RequireFirstChild(rotation_elem, "axis");
 
        StdMeshVector d, r;
        d.x = skeleton->RequireFloatAttribute(position_elem, "x");
        d.y = skeleton->RequireFloatAttribute(position_elem, "y");
        d.z = skeleton->RequireFloatAttribute(position_elem, "z");
        float angle = skeleton->RequireFloatAttribute(rotation_elem, "angle");
        r.x = skeleton->RequireFloatAttribute(axis_elem, "x");
        r.y = skeleton->RequireFloatAttribute(axis_elem, "y");
        r.z = skeleton->RequireFloatAttribute(axis_elem, "z");
 
        bone->Transformation.scale = StdMeshVector::UnitScale();
        bone->Transformation.rotate = StdMeshQuaternion::AngleAxis(angle, r);
        bone->Transformation.translate = d;
 
        // We need this later for applying animations, and attaching meshes, therefore cache it here
        bone->InverseTransformation = StdMeshTransformation::Inverse(bone->Transformation);
    }
 
    // Bone hierarchy
    TiXmlElement* bonehierarchy_elem = skeleton->RequireFirstChild(skeleton_elem, "bonehierarchy");
    for (TiXmlElement* boneparent_elem = bonehierarchy_elem->FirstChildElement("boneparent"); boneparent_elem != nullptr; boneparent_elem = boneparent_elem->NextSiblingElement("boneparent"))
    {
        const char* child_name = skeleton->RequireStrAttribute(boneparent_elem, "bone");
        const char* parent_name = skeleton->RequireStrAttribute(boneparent_elem, "parent");
 
        // Lookup the two bones
        StdMeshBone* child = nullptr;
        StdMeshBone* parent = nullptr;
        for (unsigned int i = 0; i < bones.size() && (!child || !parent); ++i)
        {
            if (!child && bones[i]->Name == child_name)
                child = bones[i];
            if (!parent && bones[i]->Name == parent_name)
                parent = bones[i];
        }
 
        if (!child) skeleton->Error(FormatString("There is no such bone with name '%s'", child_name), boneparent_elem);
        if (!parent) skeleton->Error(FormatString("There is no such bone with name '%s'", parent_name), boneparent_elem);
 
        child->Parent = parent;
        parent->Children.push_back(child);
    }
 
    std::shared_ptr<StdMeshSkeleton> Skeleton(new StdMeshSkeleton);
 
    // Fill master bone table in hierarchical order:
    for (auto & bone : bones)
        if (bone->Parent == nullptr)
            Skeleton->AddMasterBone(bone);
 
    // Load Animations
    TiXmlElement* animations_elem = skeleton_elem->FirstChildElement("animations");
    if (animations_elem)
    {
        for (TiXmlElement* animation_elem = animations_elem->FirstChildElement("animation"); animation_elem != nullptr; animation_elem = animation_elem->NextSiblingElement("animation"))
        {
            StdCopyStrBuf name(skeleton->RequireStrAttribute(animation_elem, "name"));
            if (Skeleton->Animations.find(name) != Skeleton->Animations.end())
                skeleton->Error(FormatString("There is already an animation with name '%s'", name.getData()), animation_elem);
 
            StdMeshAnimation& animation = Skeleton->Animations.insert(std::make_pair(name, StdMeshAnimation())).first->second;
            animation.Name = name;
            animation.Length = skeleton->RequireFloatAttribute(animation_elem, "length");
            animation.Tracks.resize(Skeleton->GetNumBones());
            animation.OriginSkeleton = &(*Skeleton);
 
            TiXmlElement* tracks_elem = skeleton->RequireFirstChild(animation_elem, "tracks");
            for (TiXmlElement* track_elem = tracks_elem->FirstChildElement("track"); track_elem != nullptr; track_elem = track_elem->NextSiblingElement("track"))
            {
                const char* bone_name = skeleton->RequireStrAttribute(track_elem, "bone");
                StdMeshBone* bone = nullptr;
                for (unsigned int i = 0; !bone && i < Skeleton->GetNumBones(); ++i)
                    if (Skeleton->Bones[i]->Name == bone_name)
                        bone = Skeleton->Bones[i];
                if (!bone) skeleton->Error(FormatString("There is no such bone with name '%s'", bone_name), track_elem);
 
                if (animation.Tracks[bone->Index] != nullptr) skeleton->Error(FormatString("There is already a track for bone '%s' in animation '%s'", bone_name, animation.Name.getData()), track_elem);
 
                StdMeshTrack* track = new StdMeshTrack;
                animation.Tracks[bone->Index] = track;
 
                TiXmlElement* keyframes_elem = skeleton->RequireFirstChild(track_elem, "keyframes");
                for (TiXmlElement* keyframe_elem = keyframes_elem->FirstChildElement("keyframe"); keyframe_elem != nullptr; keyframe_elem = keyframe_elem->NextSiblingElement("keyframe"))
                {
                    float time = skeleton->RequireFloatAttribute(keyframe_elem, "time");
                    StdMeshKeyFrame& frame = track->Frames[time];
 
                    TiXmlElement* translate_elem = keyframe_elem->FirstChildElement("translate");
                    TiXmlElement* rotate_elem = keyframe_elem->FirstChildElement("rotate");
                    TiXmlElement* scale_elem = keyframe_elem->FirstChildElement("scale");
 
                    StdMeshVector d, s, r;
                    d.x = d.y = d.z = 0.0f;
                    s = StdMeshVector::UnitScale();
                    r.x = r.y = 0.0f; r.z = 1.0f;
                    float angle = 0.0f;
 
                    if (translate_elem)
                    {
                        d.x = skeleton->RequireFloatAttribute(translate_elem, "x");
                        d.y = skeleton->RequireFloatAttribute(translate_elem, "y");
                        d.z = skeleton->RequireFloatAttribute(translate_elem, "z");
                    }
 
                    if (rotate_elem)
                    {
                        TiXmlElement* axis_elem = skeleton->RequireFirstChild(rotate_elem, "axis");
                        angle = skeleton->RequireFloatAttribute(rotate_elem, "angle");
                        r.x = skeleton->RequireFloatAttribute(axis_elem, "x");
                        r.y = skeleton->RequireFloatAttribute(axis_elem, "y");
                        r.z = skeleton->RequireFloatAttribute(axis_elem, "z");
                    }
 
                    if (scale_elem)
                    {
                        s.x = skeleton->RequireFloatAttribute(scale_elem, "x");
                        s.y = skeleton->RequireFloatAttribute(scale_elem, "y");
                        s.z = skeleton->RequireFloatAttribute(scale_elem, "z");
                    }
 
                    frame.Transformation.scale = s;
                    frame.Transformation.rotate = StdMeshQuaternion::AngleAxis(angle, r);
                    frame.Transformation.translate = bone->InverseTransformation.rotate * (bone->InverseTransformation.scale * d);
                    frame.Transformation = OgreToClonk::TransformTransformation(frame.Transformation);
                }
            }
        }
    }
 
    // is there even any xml file that we load from?
    // it looks like this could never work: if the mesh has no skeleton, then the code below will fail because of a null pointer...
 
    // Apply parent transformation to each bone transformation. We need to
    // do this late since animation keyframe computation needs the bone
    // transformations, not bone+parent.
    for (unsigned int i = 0; i < Skeleton->GetNumBones(); ++i)
    {
        // Apply parent transformation
        if (Skeleton->Bones[i]->Parent)
            Skeleton->Bones[i]->Transformation = Skeleton->Bones[i]->Parent->Transformation * OgreToClonk::TransformTransformation(Skeleton->Bones[i]->Transformation);
        else
            Skeleton->Bones[i]->Transformation = OgreToClonk::TransformTransformation(Skeleton->Bones[i]->Transformation);
 
        // Update inverse
        Skeleton->Bones[i]->InverseTransformation = StdMeshTransformation::Inverse(Skeleton->Bones[i]->Transformation);
    }
 
    StoreSkeleton(groupname, filename, Skeleton);
}

References StdMeshQuaternion::AngleAxis(), FormatString(), StdStrBuf::getData(), StdMeshBone::ID, StdMeshBone::Index, StdMeshTransformation::Inverse(), StdMeshBone::InverseTransformation, StdMeshAnimation::Length, StdMeshBone::Name, StdMeshAnimation::Name, StdMeshTransformation::rotate, s, StdMeshTransformation::scale, StdMeshBone::Transformation, StdMeshKeyFrame::Transformation, OgreToClonk::TransformTransformation(), StdMeshTransformation::translate, StdMeshVector::UnitScale(), StdMeshVector::x, StdMeshVector::y, and StdMeshVector::z.

Referenced by C4DefGraphics::LoadSkeleton().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeFullSkeletonPath()

static void StdMeshSkeletonLoader::MakeFullSkeletonPath ( StdCopyStrBuf &  out, const char *  groupname, const char *  filename  )

inlinestatic

Definition at line 66 of file StdMeshLoader.h.

    {
        out = StdCopyStrBuf(groupname);
        out.AppendBackslash();
        out.Append(filename);
        out.ToLowerCase();
    }

References StdStrBuf::Append(), StdStrBuf::AppendBackslash(), and StdStrBuf::ToLowerCase().

Referenced by StdMeshLoader::LoadMeshBinary(), StdMeshLoader::LoadMeshXml(), RemoveSkeleton(), and StoreSkeleton().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveSkeleton() [1/2]

void StdMeshSkeletonLoader::RemoveSkeleton	(	const char *	groupname,
		const char *	filename
	)

Definition at line 254 of file StdMeshLoaderBinary.cpp.

{
    StdCopyStrBuf filepath;
    MakeFullSkeletonPath(filepath, groupname, filename);
    RemoveSkeleton(filepath);
}

References MakeFullSkeletonPath(), and RemoveSkeleton().

Here is the call graph for this function:

RemoveSkeleton() [2/2]

void StdMeshSkeletonLoader::RemoveSkeleton

(

const StdCopyStrBuf &

filepath

)

Definition at line 261 of file StdMeshLoaderBinary.cpp.

{
    std::map<StdCopyStrBuf, std::shared_ptr<StdMeshSkeleton>>::iterator existing_skeleton = Skeletons.find(filepath);
    if (existing_skeleton != Skeletons.end())
    {
        Skeletons.erase(existing_skeleton);
    }
 
    std::map<StdCopyStrBuf, StdCopyStrBuf>::iterator appendto_skeleton = AppendtoSkeletons.find(filepath);
    if (appendto_skeleton != AppendtoSkeletons.end())
    {
        AppendtoSkeletons.erase(appendto_skeleton);
    }
 
    std::map<StdCopyStrBuf, StdCopyStrBuf>::iterator include_skeleton = IncludeSkeletons.find(filepath);
    if (include_skeleton != IncludeSkeletons.end())
    {
        IncludeSkeletons.erase(include_skeleton);
    }
}

Referenced by C4DefGraphics::LoadSkeleton(), RemoveSkeleton(), and RemoveSkeletonsInGroup().

Here is the caller graph for this function:

RemoveSkeletonsInGroup()

void StdMeshSkeletonLoader::RemoveSkeletonsInGroup

(

const char *

groupname

)

Definition at line 224 of file StdMeshLoaderBinary.cpp.

{
    // DebugLogF("Removing skeletons in group: %s", groupname);
 
    std::vector<StdCopyStrBuf> delete_skeletons;
 
    std::map<StdCopyStrBuf, std::shared_ptr<StdMeshSkeleton>>::iterator it;
    for (it = Skeletons.begin(); it != Skeletons.end(); it++)
    {
        StdCopyStrBuf skeletonpath(it->first.getData());
        StdCopyStrBuf group(groupname);
        group.ToLowerCase();
 
        StdCopyStrBuf skeletongroup;
        GetParentPath(skeletonpath.getData(), &skeletongroup);
        
        if (skeletongroup == group)
        {
            // DebugLogF("Found skeleton in group: %s", it->first.getData());
 
            delete_skeletons.push_back(skeletonpath);
        }
    }
 
    for (const auto & delete_skeleton : delete_skeletons)
    {
        RemoveSkeleton(delete_skeleton);
    }
}

References StdStrBuf::getData(), GetParentPath(), RemoveSkeleton(), and StdStrBuf::ToLowerCase().

Here is the call graph for this function:

ResolveIncompleteSkeletons()

void StdMeshSkeletonLoader::ResolveIncompleteSkeletons

(

)

Definition at line 597 of file StdMeshLoaderBinary.cpp.

{
    DoResetSkeletons();
    DoAppendSkeletons();
    DoIncludeSkeletons();
}

skeletons_begin()

skeleton_iterator StdMeshSkeletonLoader::skeletons_begin ( ) const

inline

Definition at line 85 of file StdMeshLoader.h.

{ return Skeletons.begin(); }

Referenced by StdMeshAnimationUpdate::StdMeshAnimationUpdate().

Here is the caller graph for this function:

skeletons_end()

skeleton_iterator StdMeshSkeletonLoader::skeletons_end ( ) const

inline

Definition at line 86 of file StdMeshLoader.h.

{ return Skeletons.end(); }

Referenced by StdMeshAnimationUpdate::StdMeshAnimationUpdate().

Here is the caller graph for this function:

StoreSkeleton()

void StdMeshSkeletonLoader::StoreSkeleton	(	const char *	groupname,
		const char *	filename,
		std::shared_ptr< StdMeshSkeleton >	skeleton
	)

Definition at line 181 of file StdMeshLoaderBinary.cpp.

{
    assert(groupname != nullptr);
    assert(filename != nullptr);
    assert(skeleton != nullptr);
 
    // Create mirrored animations (#401)
    // this is still going to be somewhere else, but for now it will keep moving around
    skeleton->PostInit();
 
    
    // save in map
    StdCopyStrBuf filepath;
    MakeFullSkeletonPath(filepath, groupname, filename);
    
    AddSkeleton(filepath, skeleton);
 
    // memorize which skeletons can be appended
    // skins get broken down to their original definition, which is a little messy at the moment.
    StdCopyStrBuf buf_filename(GetFilenameOnly(filename));
    StdCopyStrBuf command_with_definition(GetFilenameOnly(buf_filename.getData())); // include.Clonk becomes include, include.Clonk.Farmer becomes include.Clonk
    StdCopyStrBuf command(GetFilenameOnly(command_with_definition.getData()));      // include stays include, include.Clonk becomes include
    StdCopyStrBuf definition(GetExtension(buf_filename.getData())); // include.Clonk becomes Clonk, include.Clonk.Farmer becomes Farmer
 
    if (!(command_with_definition == command)) // include.Clonk != include?
    {
        definition = StdCopyStrBuf(GetExtension(command_with_definition.getData())); // change definition to the part behind the .: Clonk
    }
 
    const char* appendto = "appendto"; // has to be a constant
    const char* include = "include";   // dito
 
    // check where to store
    if (command == appendto)
    {
        AppendtoSkeletons.insert(std::make_pair(filepath, definition));
    }
    else if (command == include)
    {
        IncludeSkeletons.insert(std::make_pair(filepath, definition));
    }
}

References StdStrBuf::getData(), GetExtension(), GetFilenameOnly(), and MakeFullSkeletonPath().

Referenced by LoadSkeletonBinary().

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• StdMeshLoader.h
• StdMeshLoaderBinary.cpp
• StdMeshLoaderXml.cpp