OgreInstancedGeometry.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-2013 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 __InstancedGeometry_H__
#define __InstancedGeometry_H__

#include "OgrePrerequisites.h"
#include "OgreMovableObject.h"
#include "OgreSimpleRenderable.h"
#include "OgreSkeleton.h"
#include "OgreSkeletonInstance.h"
#include "OgreAnimationTrack.h"
#include "OgreBone.h"
#include "OgreIteratorWrappers.h"
#include "OgreMesh.h"
#include "OgreHeaderPrefix.h"

namespace Ogre {

    class _OgreExport  InstancedGeometry : public BatchedGeometryAlloc
    {
    public:
        class _OgrePrivate OptimisedSubMeshGeometry : public BatchedGeometryAlloc
        {
        public:
            OptimisedSubMeshGeometry() :vertexData(0), indexData(0) {}
            ~OptimisedSubMeshGeometry() 
            {
                delete vertexData;
                delete indexData;
            }
            VertexData *vertexData;
            IndexData *indexData;
        };
        typedef list<OptimisedSubMeshGeometry*>::type OptimisedSubMeshGeometryList;
        struct SubMeshLodGeometryLink
        {
            VertexData* vertexData;
            IndexData* indexData;
        };
        typedef vector<SubMeshLodGeometryLink>::type SubMeshLodGeometryLinkList;
        typedef map<SubMesh*, SubMeshLodGeometryLinkList*>::type SubMeshGeometryLookup;
        struct QueuedSubMesh : public BatchedGeometryAlloc
        {
            SubMesh* submesh;
            SubMeshLodGeometryLinkList* geometryLodList;
            String materialName;
            Vector3 position;
            Quaternion orientation;
            Vector3 scale;
            AxisAlignedBox worldBounds;
            unsigned int ID;
        };
        typedef vector<QueuedSubMesh*>::type QueuedSubMeshList;
        typedef vector<String>::type QueuedSubMeshOriginList;
        struct QueuedGeometry : public BatchedGeometryAlloc
        {
            SubMeshLodGeometryLink* geometry;
            Vector3 position;
            Quaternion orientation;
            Vector3 scale;
            unsigned int ID;
        };
        typedef vector<QueuedGeometry*>::type QueuedGeometryList;
        
        // forward declarations
        class LODBucket;
        class MaterialBucket;
        class BatchInstance;
        class InstancedObject;

        class _OgreExport  GeometryBucket : public SimpleRenderable
        {
        protected:
            
            QueuedGeometryList mQueuedGeometry;
            InstancedGeometry*mBatch;
            MaterialBucket* mParent;
            String mFormatString;
            VertexData* mVertexData;
            IndexData* mIndexData;
            HardwareIndexBuffer::IndexType mIndexType;
            size_t mMaxVertexIndex;
            unsigned short mTexCoordIndex;
            AxisAlignedBox mAABB;

            template<typename T>
            void copyIndexes(const T* src, T* dst, size_t count, size_t indexOffset)
            {
                if (indexOffset == 0)
                {
                    memcpy(dst, src, sizeof(T) * count);
                }
                else
                {
                    while(count--)
                    {
                        *dst++ = static_cast<T>(*src++ + indexOffset);
                    }
                }
            }

            void _initGeometryBucket(const VertexData* vData, const IndexData* iData);
            void _initGeometryBucket(GeometryBucket* bucket);

        public:
            GeometryBucket(MaterialBucket* parent, const String& formatString, 
                const VertexData* vData, const IndexData* iData);
            GeometryBucket(const String& name, MaterialBucket* parent, const String& formatString, 
                const VertexData* vData, const IndexData* iData);
            GeometryBucket(MaterialBucket* parent,const String& formatString,GeometryBucket*bucket);
            GeometryBucket(const String& name, MaterialBucket* parent,const String& formatString,GeometryBucket*bucket);
            virtual ~GeometryBucket();
            MaterialBucket* getParent(void) { return mParent; }
            Real getBoundingRadius(void) const;
            const VertexData* getVertexData(void) const { return mVertexData; }
            const IndexData* getIndexData(void) const { return mIndexData; }
            const MaterialPtr& getMaterial(void) const;
            Technique* getTechnique(void) const;
            void getWorldTransforms(Matrix4* xform) const;
            virtual unsigned short getNumWorldTransforms(void) const ;
            Real getSquaredViewDepth(const Camera* cam) const;
            const LightList& getLights(void) const;
            bool getCastsShadows(void) const;
            String getFormatString(void) const;
            bool assign(QueuedGeometry* qsm);
            void build();
            void dump(std::ofstream& of) const;
            AxisAlignedBox & getAABB(void){return mAABB;}
            void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);

        };
        class _OgreExport  InstancedObject : public BatchedGeometryAlloc
        {
            friend class GeometryBucket;
        public:
             enum TransformSpace
        {
            TS_LOCAL,
            TS_PARENT,
            TS_WORLD
        };
            typedef vector<GeometryBucket*>::type GeometryBucketList;
        protected:
            GeometryBucketList mGeometryBucketList;
            unsigned short mIndex;
            Matrix4  mTransformation;
            Quaternion mOrientation;
            Vector3 mScale;
            Vector3 mPosition;
            SkeletonInstance* mSkeletonInstance;
            Matrix4 *mBoneWorldMatrices;
            Matrix4 *mBoneMatrices;
            AnimationStateSet* mAnimationState;
            unsigned short mNumBoneMatrices;
            unsigned long mFrameAnimationLastUpdated;
        public:
            InstancedObject(unsigned short index);
            InstancedObject(unsigned short index,SkeletonInstance *skeleton,AnimationStateSet*animations);
            ~InstancedObject();
            void setPosition( Vector3  position);
            const Vector3& getPosition(void) const;
            void yaw(const Radian& angle);
            void pitch(const Radian& angle);
            void roll(const Radian& angle);
            void rotate(const Quaternion& q);
            void setScale(const Vector3& scale);
            const Vector3& getScale() const;
            void setOrientation(const Quaternion& q);
            void setPositionAndOrientation(Vector3 p, const Quaternion& q);
            Quaternion & getOrientation(void);
            void addBucketToList(GeometryBucket* bucket);
            void needUpdate();
            GeometryBucketList&getGeometryBucketList(void){return mGeometryBucketList;}
            void translate(const Matrix3& axes, const Vector3& move);
            void translate(const Vector3& d);
            Matrix3 getLocalAxes(void) const;
            void updateAnimation(void);
            AnimationState* getAnimationState(const String& name) const;
            SkeletonInstance*getSkeletonInstance(void){return mSkeletonInstance;}

        };
        class _OgreExport  MaterialBucket : public BatchedGeometryAlloc
        {
        public:
            typedef vector<GeometryBucket*>::type GeometryBucketList;
        protected:
            LODBucket* mParent;
            String mMaterialName;
            MaterialPtr mMaterial;
            Technique* mTechnique;
            int mLastIndex;
            GeometryBucketList mGeometryBucketList;
            // index to current Geometry Buckets for a given geometry format
            typedef map<String, GeometryBucket*>::type CurrentGeometryMap;
            CurrentGeometryMap mCurrentGeometryMap;
            String getGeometryFormatString(SubMeshLodGeometryLink* geom);
            
        public:
            MaterialBucket(LODBucket* parent, const String& materialName);
            virtual ~MaterialBucket();
            LODBucket* getParent(void) { return mParent; }
            const String& getMaterialName(void) const { return mMaterialName; }
            void assign(QueuedGeometry* qsm);
            void build();
            void addRenderables(RenderQueue* queue, uint8 group, 
                Real lodValue);
            const MaterialPtr& getMaterial(void) const { return mMaterial; }
            typedef VectorIterator<GeometryBucketList> GeometryIterator;
            GeometryIterator getGeometryIterator(void);
            Technique* getCurrentTechnique(void) const { return mTechnique; }
            void dump(std::ofstream& of) const;
            MaterialBucket::CurrentGeometryMap* getMaterialBucketMap(void) const;
            MaterialBucket::GeometryBucketList*getGeometryBucketList(void) const;
            void updateContainers(GeometryBucket* bucket, const String &format);
            void setLastIndex(int index){mLastIndex=index;}
            int getLastIndex(){return mLastIndex;}
            void setMaterial(const String & name);
            void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
        
        };
        class _OgreExport  LODBucket : public BatchedGeometryAlloc
        {
        public:
            typedef map<String, MaterialBucket*>::type MaterialBucketMap;
        protected:
            BatchInstance* mParent;
            unsigned short mLod;
            Real mLodValue;
            MaterialBucketMap mMaterialBucketMap;
            QueuedGeometryList mQueuedGeometryList;
        public:
            LODBucket(BatchInstance* parent, unsigned short lod, Real lodValue);
            virtual ~LODBucket();
            BatchInstance* getParent(void) { return mParent; }
            ushort getLod(void) const { return mLod; }
            Real getLodValue(void) const { return mLodValue; }
            void assign(QueuedSubMesh* qsm, ushort atLod);
            void build();
            void addRenderables(RenderQueue* queue, uint8 group, 
                Real lodValue);
            typedef MapIterator<MaterialBucketMap> MaterialIterator;
            MaterialIterator getMaterialIterator(void);
            void dump(std::ofstream& of) const;
            void updateContainers(MaterialBucket* bucket, String& name );
            void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
            
        };
        class _OgreExport  BatchInstance : public MovableObject
        {
            friend class MaterialBucket;
            public:
        

            typedef vector<LODBucket*>::type LODBucketList;
            typedef map<unsigned short, InstancedObject*>::type ObjectsMap;
            typedef MapIterator<ObjectsMap> InstancedObjectIterator;
        protected:
            
            InstancedGeometry* mParent;
            SceneManager* mSceneMgr;
            SceneNode* mNode;
            QueuedSubMeshList mQueuedSubMeshes;
            uint32 mBatchInstanceID;

            ObjectsMap mInstancesMap;
        public:
            Mesh::LodValueList mLodValues;
            AxisAlignedBox mAABB;
            Real mBoundingRadius;
            ushort mCurrentLod;
            Real mLodValue;
            Camera *mCamera;
            Real mSquaredViewDepth;
        protected:
            LODBucketList mLodBucketList;
            const LodStrategy *mLodStrategy;

        public:
            BatchInstance(InstancedGeometry* parent, const String& name, SceneManager* mgr, 
                uint32 BatchInstanceID);
            virtual ~BatchInstance();
            // more fields can be added in subclasses
            InstancedGeometry* getParent(void) const { return mParent;}
            void assign(QueuedSubMesh* qmesh);
            void build();
            uint32 getID(void) const { return mBatchInstanceID; }
//          const Vector3& getCentre(void) const { return mCentre; }
            const String& getMovableType(void) const;
            void _notifyCurrentCamera(Camera* cam);
            const AxisAlignedBox& getBoundingBox(void) const;
            void  setBoundingBox(AxisAlignedBox& box);
            Real getBoundingRadius(void) const;
            void _updateRenderQueue(RenderQueue* queue);
            bool isVisible(void) const;
            void visitRenderables(Renderable::Visitor* visitor, 
                bool debugRenderables = false);

        //  uint32 getTypeFlags(void) const;

            typedef VectorIterator<LODBucketList> LODIterator;
            LODIterator getLODIterator(void);
            const LightList& getLights(void) const;

            void updateBoundingBox();

            void dump(std::ofstream& of) const;
            void updateContainers(LODBucket* bucket );
            void attachToScene();
            void addInstancedObject(unsigned short index, InstancedObject* object);
            InstancedObject*  isInstancedObjectPresent(unsigned short index);
            InstancedObjectIterator getObjectIterator();
            SceneNode*getSceneNode(void){return mNode;}
            ObjectsMap& getInstancesMap(void){return  mInstancesMap;}
            
        };
        typedef map<uint32, BatchInstance*>::type BatchInstanceMap;
        typedef vector<RenderOperation*>::type RenderOperationVector;
    protected:
        // General state & settings
        SceneManager* mOwner;
        String mName;
        bool mBuilt;
        Real mUpperDistance;
        Real mSquaredUpperDistance;
        bool mCastShadows;
        Vector3 mBatchInstanceDimensions;
        Vector3 mHalfBatchInstanceDimensions;
        Vector3 mOrigin;
        bool mVisible;
        bool mProvideWorldInverses;
        uint8 mRenderQueueID;
        bool mRenderQueueIDSet;
        unsigned int mObjectCount;
        QueuedSubMeshList mQueuedSubMeshes;
        BatchInstance*mInstancedGeometryInstance;
        SkeletonPtr mBaseSkeleton;
        SkeletonInstance *mSkeletonInstance;
        AnimationStateSet* mAnimationState;
        OptimisedSubMeshGeometryList mOptimisedSubMeshGeometryList;

        SubMeshGeometryLookup mSubMeshGeometryLookup;
            
        BatchInstanceMap mBatchInstanceMap;
        RenderOperationVector mRenderOps;
        virtual BatchInstance* getBatchInstance(const AxisAlignedBox& bounds, bool autoCreate);
        virtual BatchInstance* getBatchInstance(const Vector3& point, bool autoCreate);
        virtual BatchInstance* getBatchInstance(ushort x, ushort y, ushort z, bool autoCreate);
        virtual BatchInstance* getBatchInstance(uint32 index);
        virtual void getBatchInstanceIndexes(const Vector3& point, 
            ushort& x, ushort& y, ushort& z);
        virtual BatchInstance* getInstancedGeometryInstance(void);
        virtual uint32 packIndex(ushort x, ushort y, ushort z);
        virtual Real getVolumeIntersection(const AxisAlignedBox& box,  
            ushort x, ushort y, ushort z);
        virtual AxisAlignedBox getBatchInstanceBounds(ushort x, ushort y, ushort z);
        virtual Vector3 getBatchInstanceCentre(ushort x, ushort y, ushort z);
        virtual AxisAlignedBox calculateBounds(VertexData* vertexData, 
            const Vector3& position, const Quaternion& orientation, 
            const Vector3& scale);
        SubMeshLodGeometryLinkList* determineGeometry(SubMesh* sm);
        void splitGeometry(VertexData* vd, IndexData* id, 
            SubMeshLodGeometryLink* targetGeomLink);

        typedef map<size_t, size_t>::type IndexRemap;
        template <typename T>
        void buildIndexRemap(T* pBuffer, size_t numIndexes, IndexRemap& remap)
        {
            remap.clear();
            for (size_t i = 0; i < numIndexes; ++i)
            {
                // use insert since duplicates are silently discarded
                remap.insert(IndexRemap::value_type(*pBuffer++, remap.size()));
                // this will have mapped oldindex -> new index IF oldindex
                // wasn't already there
            }
        }
        template <typename T>
        void remapIndexes(T* src, T* dst, const IndexRemap& remap, 
                size_t numIndexes)
        {
            for (size_t i = 0; i < numIndexes; ++i)
            {
                // look up original and map to target
                IndexRemap::const_iterator ix = remap.find(*src++);
                assert(ix != remap.end());
                *dst++ = static_cast<T>(ix->second);
            }
        }
        
    public:
        InstancedGeometry(SceneManager* owner, const String& name);
        virtual ~InstancedGeometry();

        const String& getName(void) const { return mName; }
        virtual void addEntity(Entity* ent, const Vector3& position,
            const Quaternion& orientation = Quaternion::IDENTITY, 
            const Vector3& scale = Vector3::UNIT_SCALE);

        virtual void addSceneNode(const SceneNode* node);

        virtual void build(void);
        void addBatchInstance(void);
        virtual void destroy(void);

        virtual void reset(void);

        virtual void setRenderingDistance(Real dist) { 
            mUpperDistance = dist; 
            mSquaredUpperDistance = mUpperDistance * mUpperDistance;
        }

        virtual Real getRenderingDistance(void) const { return mUpperDistance; }

        virtual Real getSquaredRenderingDistance(void) const 
        { return mSquaredUpperDistance; }

        virtual void setVisible(bool visible);

        virtual bool isVisible(void) const { return mVisible; }

        virtual void setCastShadows(bool castShadows);
        virtual bool getCastShadows(void) { return mCastShadows; }

        virtual void setBatchInstanceDimensions(const Vector3& size) { 
            mBatchInstanceDimensions = size; 
            mHalfBatchInstanceDimensions = size * 0.5;
        }
        virtual const Vector3& getBatchInstanceDimensions(void) const { return mBatchInstanceDimensions; }
        virtual void setOrigin(const Vector3& origin) { mOrigin = origin; }
        virtual const Vector3& getOrigin(void) const { return mOrigin; }

        virtual void setRenderQueueGroup(uint8 queueID);

        virtual uint8 getRenderQueueGroup(void) const;
        typedef MapIterator<BatchInstanceMap> BatchInstanceIterator;
        BatchInstanceIterator getBatchInstanceIterator(void);
        RenderOperationVector& getRenderOperationVector(){return mRenderOps;}
        void visitRenderables(Renderable::Visitor* visitor, 
            bool debugRenderables = false);

        virtual void dump(const String& filename) const;
        SkeletonInstance *getBaseSkeletonInstance(void){return mSkeletonInstance;}
        SkeletonPtr getBaseSkeleton(void){return mBaseSkeleton;}
        AnimationStateSet* getBaseAnimationState(void){return mAnimationState;}
        unsigned int getObjectCount(void){return mObjectCount;}

        virtual void setProvideWorldInverses(bool flag);

        virtual bool getProvideWorldInverses(void) const { return mProvideWorldInverses; }
    };

}

#include "OgreHeaderSuffix.h"

#endif