OgreSkeleton.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/

#ifndef __Skeleton_H__
#define __Skeleton_H__

#include "OgrePrerequisites.h"
#include "OgreResource.h"
#include "OgreQuaternion.h"
#include "OgreVector3.h"
#include "OgreIteratorWrappers.h"

namespace Ogre {

    enum SkeletonAnimationBlendMode {
        ANIMBLEND_AVERAGE,
        ANIMBLEND_CUMULATIVE
    };

#define OGRE_MAX_NUM_BONES 256

    
    struct LinkedSkeletonAnimationSource;

    class _OgreExport Skeleton : public Resource
    {
        friend class SkeletonInstance;
    protected:
        Skeleton();

    public:
        Skeleton(ResourceManager* creator, const String& name, ResourceHandle handle,
            const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
        virtual ~Skeleton();


        virtual Bone* createBone(void);

        virtual Bone* createBone(unsigned short handle);

        virtual Bone* createBone(const String& name);

        virtual Bone* createBone(const String& name, unsigned short handle);

        virtual unsigned short getNumBones(void) const;

        virtual Bone* getRootBone(void) const;

        typedef std::vector<Bone*> BoneList;
        typedef VectorIterator<BoneList> BoneIterator;
        virtual BoneIterator getRootBoneIterator(void);
        virtual BoneIterator getBoneIterator(void);

        virtual Bone* getBone(unsigned short handle) const;

        virtual Bone* getBone(const String& name) const;

        virtual void setBindingPose(void);

        virtual void reset(bool resetManualBones = false);

        virtual Animation* createAnimation(const String& name, Real length);

        virtual Animation* getAnimation(const String& name, 
            const LinkedSkeletonAnimationSource** linker = 0) const;

        Animation* _getAnimationImpl(const String& name, 
            const LinkedSkeletonAnimationSource** linker = 0) const;


        virtual bool hasAnimation(const String& name);

        virtual void removeAnimation(const String& name);

        virtual void setAnimationState(const AnimationStateSet& animSet);


        virtual void _initAnimationState(AnimationStateSet* animSet);

        virtual void _refreshAnimationState(AnimationStateSet* animSet);

        virtual void _getBoneMatrices(Matrix4* pMatrices);

        virtual unsigned short getNumAnimations(void) const;

        virtual Animation* getAnimation(unsigned short index) const;


        virtual SkeletonAnimationBlendMode getBlendMode() const;
        virtual void setBlendMode(SkeletonAnimationBlendMode state);

        virtual void _updateTransforms(void);

        virtual void optimiseAllAnimations(void);

        virtual void addLinkedSkeletonAnimationSource(const String& skelName, 
            Real scale = 1.0f);
        virtual void removeAllLinkedSkeletonAnimationSources(void);
        
        typedef std::vector<LinkedSkeletonAnimationSource> 
            LinkedSkeletonAnimSourceList;
        typedef ConstVectorIterator<LinkedSkeletonAnimSourceList> 
            LinkedSkeletonAnimSourceIterator;
        virtual LinkedSkeletonAnimSourceIterator 
            getLinkedSkeletonAnimationSourceIterator(void) const;

        virtual void _notifyManualBonesDirty(void);
        virtual void _notifyManualBoneStateChange(Bone* bone);

        virtual bool getManualBonesDirty(void) const { return mManualBonesDirty; }
        virtual bool hasManualBones(void) const { return !mManualBones.empty(); }

    protected:
        SkeletonAnimationBlendMode mBlendState;
        BoneList mBoneList;
        typedef std::map<String, Bone*> BoneListByName;
        BoneListByName mBoneListByName;


        mutable BoneList mRootBones;
        unsigned short mNextAutoHandle;
        typedef std::set<Bone*> BoneSet;
        BoneSet mManualBones;
        bool mManualBonesDirty;


        typedef std::map<String, Animation*> AnimationList;
        AnimationList mAnimationsList;

        mutable LinkedSkeletonAnimSourceList mLinkedSkeletonAnimSourceList;

        void deriveRootBone(void) const;

        void _dumpContents(const String& filename);

        void loadImpl(void);

        void unloadImpl(void);
        size_t calculateSize(void) const { return 0; } // TODO 

    };

    class _OgreExport SkeletonPtr : public SharedPtr<Skeleton> 
    {
    public:
        SkeletonPtr() : SharedPtr<Skeleton>() {}
        explicit SkeletonPtr(Skeleton* rep) : SharedPtr<Skeleton>(rep) {}
        SkeletonPtr(const SkeletonPtr& r) : SharedPtr<Skeleton>(r) {} 
        SkeletonPtr(const ResourcePtr& r) : SharedPtr<Skeleton>()
        {
            // lock & copy other mutex pointer
            OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
            OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
            pRep = static_cast<Skeleton*>(r.getPointer());
            pUseCount = r.useCountPointer();
            if (pUseCount)
            {
                ++(*pUseCount);
            }
        }

        SkeletonPtr& operator=(const ResourcePtr& r)
        {
            if (pRep == static_cast<Skeleton*>(r.getPointer()))
                return *this;
            release();
            // lock & copy other mutex pointer
            OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
            OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
            pRep = static_cast<Skeleton*>(r.getPointer());
            pUseCount = r.useCountPointer();
            if (pUseCount)
            {
                ++(*pUseCount);
            }
            return *this;
        }
    };

    struct LinkedSkeletonAnimationSource
    {
        String skeletonName;
        SkeletonPtr pSkeleton;
        Real scale;
        LinkedSkeletonAnimationSource(const String& skelName, Real scl)
            : skeletonName(skelName), scale(scl) {}
            LinkedSkeletonAnimationSource(const String& skelName, Real scl, 
                SkeletonPtr skelPtr)
                : skeletonName(skelName), pSkeleton(skelPtr), scale(scl) {}
    };
}


#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:50 2006