OgreEntity.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-2012 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __Entity_H__
#define __Entity_H__

#include "OgrePrerequisites.h"
#include "OgreCommon.h"

#include "OgreString.h"
#include "OgreMovableObject.h"
#include "OgreQuaternion.h"
#include "OgreVector3.h"
#include "OgreHardwareBufferManager.h"
#include "OgreMesh.h"
#include "OgreRenderable.h"
#include "OgreResourceGroupManager.h"

namespace Ogre {
    class _OgreExport Entity: public MovableObject, public Resource::Listener
    {
        // Allow EntityFactory full access
        friend class EntityFactory;
        friend class SubEntity;
    public:
        
        typedef set<Entity*>::type EntitySet;
        typedef map<unsigned short, bool>::type SchemeHardwareAnimMap;

    protected:

        Entity();
        Entity( const String& name, const MeshPtr& mesh);

        MeshPtr mMesh;

        typedef vector<SubEntity*>::type SubEntityList;
        SubEntityList mSubEntityList;


        AnimationStateSet* mAnimationState;


        TempBlendedBufferInfo mTempSkelAnimInfo;
        VertexData* mSkelAnimVertexData;
        TempBlendedBufferInfo mTempVertexAnimInfo;
        VertexData* mSoftwareVertexAnimVertexData;
        VertexData* mHardwareVertexAnimVertexData;
        bool mVertexAnimationAppliedThisFrame;
        bool mPreparedForShadowVolumes;

        const VertexData* findBlendedVertexData(const VertexData* orig);
        SubEntity* findSubEntityForVertexData(const VertexData* orig);

        void extractTempBufferInfo(VertexData* sourceData, TempBlendedBufferInfo* info);
        VertexData* cloneVertexDataRemoveBlendInfo(const VertexData* source);
        void prepareTempBlendBuffers(void);
        void markBuffersUnusedForAnimation(void);
        void restoreBuffersForUnusedAnimation(bool hardwareAnimation);

        void bindMissingHardwarePoseBuffers(const VertexData* srcData, 
            VertexData* destData);
            
        void initialisePoseVertexData(const VertexData* srcData, VertexData* destData, 
            bool animateNormals);

        void finalisePoseNormals(const VertexData* srcData, VertexData* destData);

        Matrix4 *mBoneWorldMatrices;
        Matrix4 *mBoneMatrices;
        unsigned short mNumBoneMatrices;
        unsigned long mFrameAnimationLastUpdated;

        void updateAnimation(void);

        unsigned long *mFrameBonesLastUpdated;

        EntitySet* mSharedSkeletonEntities;

        bool cacheBoneMatrices(void);

        bool mDisplaySkeleton;
        SchemeHardwareAnimMap mSchemeHardwareAnim;

        bool mCurrentHWAnimationState;

        ushort mHardwarePoseCount;
        bool mVertexProgramInUse;
        int mSoftwareAnimationRequests;
        int mSoftwareAnimationNormalsRequests;
        bool mSkipAnimStateUpdates;
        bool mAlwaysUpdateMainSkeleton;


        ushort mMeshLodIndex;

        Real mMeshLodFactorTransformed;
        ushort mMinMeshLodIndex;
        ushort mMaxMeshLodIndex;

        Real mMaterialLodFactor;
        Real mMaterialLodFactorTransformed;
        ushort mMinMaterialLodIndex;
        ushort mMaxMaterialLodIndex;

        typedef vector<Entity*>::type LODEntityList;
        LODEntityList mLodEntityList;

        SkeletonInstance* mSkeletonInstance;

        bool mInitialised;

        Matrix4 mLastParentXform;

        size_t mMeshStateCount;

        void buildSubEntityList(MeshPtr& mesh, SubEntityList* sublist);

        void attachObjectImpl(MovableObject *pMovable, TagPoint *pAttachingPoint);

        void detachObjectImpl(MovableObject* pObject);

        void detachAllObjectsImpl(void);

        void reevaluateVertexProcessing(void);

        bool calcVertexProcessing(void);
    
        void applyVertexAnimation(bool hardwareAnimation, bool stencilShadows);
        ushort initHardwareAnimationElements(VertexData* vdata,
            ushort numberOfElements, bool animateNormals);
        bool tempVertexAnimBuffersBound(void) const;
        bool tempSkelAnimBuffersBound(bool requestNormals) const;

    public:
        typedef map<String, MovableObject*>::type ChildObjectList;
    protected:
        ChildObjectList mChildObjectList;


        mutable AxisAlignedBox mFullBoundingBox;

        ShadowRenderableList mShadowRenderables;

        class _OgreExport EntityShadowRenderable : public ShadowRenderable
        {
        protected:
            Entity* mParent;
            HardwareVertexBufferSharedPtr mPositionBuffer;
            HardwareVertexBufferSharedPtr mWBuffer;
            const VertexData* mCurrentVertexData;
            unsigned short mOriginalPosBufferBinding;
            SubEntity* mSubEntity;


        public:
            EntityShadowRenderable(Entity* parent,
                HardwareIndexBufferSharedPtr* indexBuffer, const VertexData* vertexData,
                bool createSeparateLightCap, SubEntity* subent, bool isLightCap = false);
            ~EntityShadowRenderable();
            
            void _createSeparateLightCap();
            void getWorldTransforms(Matrix4* xform) const;
            HardwareVertexBufferSharedPtr getPositionBuffer(void) { return mPositionBuffer; }
            HardwareVertexBufferSharedPtr getWBuffer(void) { return mWBuffer; }
            void rebindPositionBuffer(const VertexData* vertexData, bool force);
            bool isVisible(void) const;
            virtual void rebindIndexBuffer(const HardwareIndexBufferSharedPtr& indexBuffer);
        };
    public:
        ~Entity();

        const MeshPtr& getMesh(void) const;

        SubEntity* getSubEntity(unsigned int index) const;

        SubEntity* getSubEntity( const String& name ) const;

        unsigned int getNumSubEntities(void) const;

        Entity* clone( const String& newName ) const;

        void setMaterialName( const String& name, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );

        
        void setMaterial(const MaterialPtr& material);

        void _notifyCurrentCamera(Camera* cam);

        void setRenderQueueGroup(uint8 queueID);

        void setRenderQueueGroupAndPriority(uint8 queueID, ushort priority);

        const AxisAlignedBox& getBoundingBox(void) const;

        AxisAlignedBox getChildObjectsBoundingBox(void) const;

        void _updateRenderQueue(RenderQueue* queue);

        const String& getMovableType(void) const;

        AnimationState* getAnimationState(const String& name) const;
        bool hasAnimationState(const String& name) const;
        AnimationStateSet* getAllAnimationStates(void) const;

        void setDisplaySkeleton(bool display);

        bool getDisplaySkeleton(void) const;


        Entity* getManualLodLevel(size_t index) const;

        size_t getNumManualLodLevels(void) const;

        ushort getCurrentLodIndex() { return mMeshLodIndex; }

        void setMeshLodBias(Real factor, ushort maxDetailIndex = 0, ushort minDetailIndex = 99);

        void setMaterialLodBias(Real factor, ushort maxDetailIndex = 0, ushort minDetailIndex = 99);

        void setPolygonModeOverrideable(bool PolygonModeOverrideable);
        TagPoint* attachObjectToBone(const String &boneName,
            MovableObject *pMovable,
            const Quaternion &offsetOrientation = Quaternion::IDENTITY,
            const Vector3 &offsetPosition = Vector3::ZERO);

        MovableObject* detachObjectFromBone(const String &movableName);

        void detachObjectFromBone(MovableObject* obj);

        void detachAllObjectsFromBone(void);

        typedef MapIterator<ChildObjectList> ChildObjectListIterator;
        ChildObjectListIterator getAttachedObjectIterator(void);
        Real getBoundingRadius(void) const;

        const AxisAlignedBox& getWorldBoundingBox(bool derive = false) const;
        const Sphere& getWorldBoundingSphere(bool derive = false) const;

        EdgeData* getEdgeList(void);
        bool hasEdgeList(void);
        ShadowRenderableListIterator getShadowVolumeRenderableIterator(
            ShadowTechnique shadowTechnique, const Light* light,
            HardwareIndexBufferSharedPtr* indexBuffer,
            bool extrudeVertices, Real extrusionDistance, unsigned long flags = 0 );

        const Matrix4* _getBoneMatrices(void) const { return mBoneMatrices;}
        unsigned short _getNumBoneMatrices(void) const { return mNumBoneMatrices; }
        bool hasSkeleton(void) const { return mSkeletonInstance != 0; }
        SkeletonInstance* getSkeleton(void) const { return mSkeletonInstance; }
        bool isHardwareAnimationEnabled(void);

        void _notifyAttached(Node* parent, bool isTagPoint = false);
        int getSoftwareAnimationRequests(void) const { return mSoftwareAnimationRequests; }
        int getSoftwareAnimationNormalsRequests(void) const { return mSoftwareAnimationNormalsRequests; }
        void addSoftwareAnimationRequest(bool normalsAlso);
        void removeSoftwareAnimationRequest(bool normalsAlso);

        void shareSkeletonInstanceWith(Entity* entity);

        bool hasVertexAnimation(void) const;


        void stopSharingSkeletonInstance();


        inline bool sharesSkeletonInstance() const { return mSharedSkeletonEntities != NULL; }

        inline const EntitySet* getSkeletonInstanceSharingSet() const { return mSharedSkeletonEntities; }

        void refreshAvailableAnimationState(void);

        void _updateAnimation(void);

        bool _isAnimated(void) const;

        bool _isSkeletonAnimated(void) const;

        VertexData* _getSkelAnimVertexData(void) const;
        VertexData* _getSoftwareVertexAnimVertexData(void) const;
        VertexData* _getHardwareVertexAnimVertexData(void) const;
        TempBlendedBufferInfo* _getSkelAnimTempBufferInfo(void);
        TempBlendedBufferInfo* _getVertexAnimTempBufferInfo(void);
        uint32 getTypeFlags(void) const;
        VertexData* getVertexDataForBinding(void);

        enum VertexDataBindChoice
        {
            BIND_ORIGINAL,
            BIND_SOFTWARE_SKELETAL,
            BIND_SOFTWARE_MORPH,
            BIND_HARDWARE_MORPH
        };
        VertexDataBindChoice chooseVertexDataForBinding(bool hasVertexAnim);

        bool _getBuffersMarkedForAnimation(void) const { return mVertexAnimationAppliedThisFrame; }
        void _markBuffersUsedForAnimation(void);

        bool isInitialised(void) const { return mInitialised; }

        void _initialise(bool forceReinitialise = false);
        void _deinitialise(void);

        void backgroundLoadingComplete(Resource* res);

        void visitRenderables(Renderable::Visitor* visitor, 
            bool debugRenderables = false);

        Real _getMeshLodFactorTransformed() const;
        
        void setSkipAnimationStateUpdate(bool skip) {
            mSkipAnimStateUpdates = skip;
        }
        
        bool getSkipAnimationStateUpdate() const {
            return mSkipAnimStateUpdates;
        }


        void setAlwaysUpdateMainSkeleton(bool update) {
            mAlwaysUpdateMainSkeleton = update;
        }

        bool getAlwaysUpdateMainSkeleton() const {
            return mAlwaysUpdateMainSkeleton;
        }

        
    };

    class _OgreExport EntityFactory : public MovableObjectFactory
    {
    protected:
        MovableObject* createInstanceImpl( const String& name, const NameValuePairList* params);
    public:
        EntityFactory() {}
        ~EntityFactory() {}

        static String FACTORY_TYPE_NAME;

        const String& getType(void) const;
        void destroyInstance( MovableObject* obj);

    };
} // namespace

#endif