OgreStaticGeometry.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 __StaticGeometry_H__
#define __StaticGeometry_H__

#include "OgrePrerequisites.h"
#include "OgreMovableObject.h"
#include "OgreRenderable.h"
#include "OgreMesh.h"
#include "OgreLodStrategy.h"

namespace Ogre {

    class _OgreExport StaticGeometry : public BatchedGeometryAlloc
    {
    public:
        class _OgrePrivate OptimisedSubMeshGeometry : public BatchedGeometryAlloc
        {
        public:
            OptimisedSubMeshGeometry() :vertexData(0), indexData(0) {}
            ~OptimisedSubMeshGeometry() 
            {
                OGRE_DELETE vertexData;
                OGRE_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;
        };
        typedef vector<QueuedSubMesh*>::type QueuedSubMeshList;
        struct QueuedGeometry : public BatchedGeometryAlloc
        {
            SubMeshLodGeometryLink* geometry;
            Vector3 position;
            Quaternion orientation;
            Vector3 scale;
        };
        typedef vector<QueuedGeometry*>::type QueuedGeometryList;
        
        // forward declarations
        class LODBucket;
        class MaterialBucket;
        class Region;

        class _OgreExport GeometryBucket :  public Renderable,  public BatchedGeometryAlloc
        {
        protected:
            QueuedGeometryList mQueuedGeometry;
            MaterialBucket* mParent;
            String mFormatString;
            VertexData* mVertexData;
            IndexData* mIndexData;
            HardwareIndexBuffer::IndexType mIndexType;
            size_t mMaxVertexIndex;

            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);
                    }
                }
            }
        public:
            GeometryBucket(MaterialBucket* parent, const String& formatString, 
                const VertexData* vData, const IndexData* iData);
            virtual ~GeometryBucket();
            MaterialBucket* getParent(void) { return mParent; }
            const VertexData* getVertexData(void) const { return mVertexData; }
            const IndexData* getIndexData(void) const { return mIndexData; }
            const MaterialPtr& getMaterial(void) const;
            Technique* getTechnique(void) const;
            void getRenderOperation(RenderOperation& op);
            void getWorldTransforms(Matrix4* xform) const;
            Real getSquaredViewDepth(const Camera* cam) const;
            const LightList& getLights(void) const;
            bool getCastsShadows(void) const;
            
            bool assign(QueuedGeometry* qsm);
            void build(bool stencilShadows);
            void dump(std::ofstream& of) const;
        };
        class _OgreExport MaterialBucket : public BatchedGeometryAlloc
        {
        public:
            typedef vector<GeometryBucket*>::type GeometryBucketList;
        protected:
            LODBucket* mParent;
            String mMaterialName;
            MaterialPtr mMaterial;
            Technique* mTechnique;

            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(bool stencilShadows);
            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;
            void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
        };
        class _OgreExport LODBucket : public BatchedGeometryAlloc
        {
        public:
            typedef map<String, MaterialBucket*>::type MaterialBucketMap;
        protected:
            class _OgreExport LODShadowRenderable : public ShadowRenderable
            {
            protected:
                LODBucket* mParent;
                // Shared link to position buffer
                HardwareVertexBufferSharedPtr mPositionBuffer;
                // Shared link to w-coord buffer (optional)
                HardwareVertexBufferSharedPtr mWBuffer;

            public:
                LODShadowRenderable(LODBucket* parent, 
                    HardwareIndexBufferSharedPtr* indexBuffer, const VertexData* vertexData, 
                    bool createSeparateLightCap, bool isLightCap = false);
                ~LODShadowRenderable();
                void getWorldTransforms(Matrix4* xform) const;
                HardwareVertexBufferSharedPtr getPositionBuffer(void) { return mPositionBuffer; }
                HardwareVertexBufferSharedPtr getWBuffer(void) { return mWBuffer; }
                virtual void rebindIndexBuffer(const HardwareIndexBufferSharedPtr& indexBuffer);

            };
            Region* mParent;
            unsigned short mLod;
            Real mLodValue;
            MaterialBucketMap mMaterialBucketMap;
            QueuedGeometryList mQueuedGeometryList;
            EdgeData* mEdgeList;
            bool mVertexProgramInUse;
            ShadowCaster::ShadowRenderableList mShadowRenderables;
        public:
            LODBucket(Region* parent, unsigned short lod, Real lodValue);
            virtual ~LODBucket();
            Region* getParent(void) { return mParent; }
            ushort getLod(void) const { return mLod; }
            Real getLodValue(void) const { return mLodValue; }
            void assign(QueuedSubMesh* qsm, ushort atLod);
            void build(bool stencilShadows);
            void addRenderables(RenderQueue* queue, uint8 group, 
                Real lodValue);
            typedef MapIterator<MaterialBucketMap> MaterialIterator;
            MaterialIterator getMaterialIterator(void);
            void dump(std::ofstream& of) const;
            void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
            EdgeData* getEdgeList() const { return mEdgeList; }
            ShadowCaster::ShadowRenderableList& getShadowRenderableList() { return mShadowRenderables; }
            bool isVertexProgramInUse() const { return mVertexProgramInUse; }
            void updateShadowRenderables(
                ShadowTechnique shadowTechnique, const Vector4& lightPos, 
                HardwareIndexBufferSharedPtr* indexBuffer, 
                bool extrudeVertices, Real extrusionDistance, unsigned long flags = 0 );
            
        };
        class _OgreExport Region : public MovableObject
        {
            friend class MaterialBucket;
            friend class GeometryBucket;
        public:
            typedef vector<LODBucket*>::type LODBucketList;
        protected:
            StaticGeometry* mParent;
            SceneManager* mSceneMgr;
            SceneNode* mNode;
            QueuedSubMeshList mQueuedSubMeshes;
            uint32 mRegionID;
            Vector3 mCentre;
            Mesh::LodValueList mLodValues;
            AxisAlignedBox mAABB;
            Real mBoundingRadius;
            ushort mCurrentLod;
            Real mLodValue;
            LODBucketList mLodBucketList;
            mutable LightList mLightList;
            mutable ulong mLightListUpdated;
            const LodStrategy *mLodStrategy;
            Camera *mCamera;
            Real mSquaredViewDepth;

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

            typedef VectorIterator<LODBucketList> LODIterator;
            LODIterator getLODIterator(void);
            ShadowRenderableListIterator getShadowVolumeRenderableIterator(
                ShadowTechnique shadowTechnique, const Light* light, 
                HardwareIndexBufferSharedPtr* indexBuffer, 
                bool extrudeVertices, Real extrusionDistance, unsigned long flags = 0 );
            EdgeData* getEdgeList(void);
            bool hasEdgeList(void);

            void dump(std::ofstream& of) const;
            
        };
        typedef map<uint32, Region*>::type RegionMap;
    protected:
        // General state & settings
        SceneManager* mOwner;
        String mName;
        bool mBuilt;
        Real mUpperDistance;
        Real mSquaredUpperDistance;
        bool mCastShadows;
        Vector3 mRegionDimensions;
        Vector3 mHalfRegionDimensions;
        Vector3 mOrigin;
        bool mVisible;
        uint8 mRenderQueueID;
        bool mRenderQueueIDSet;
        uint32 mVisibilityFlags;

        QueuedSubMeshList mQueuedSubMeshes;

        OptimisedSubMeshGeometryList mOptimisedSubMeshGeometryList;

        SubMeshGeometryLookup mSubMeshGeometryLookup;
            
        RegionMap mRegionMap;

        virtual Region* getRegion(const AxisAlignedBox& bounds, bool autoCreate);
        virtual Region* getRegion(const Vector3& point, bool autoCreate);
        virtual Region* getRegion(ushort x, ushort y, ushort z, bool autoCreate);
        virtual Region* getRegion(uint32 index);
        virtual void getRegionIndexes(const Vector3& point, 
            ushort& x, ushort& y, ushort& z);
        virtual uint32 packIndex(ushort x, ushort y, ushort z);
        virtual Real getVolumeIntersection(const AxisAlignedBox& box,  
            ushort x, ushort y, ushort z);
        virtual AxisAlignedBox getRegionBounds(ushort x, ushort y, ushort z);
        virtual Vector3 getRegionCentre(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:
        StaticGeometry(SceneManager* owner, const String& name);
        virtual ~StaticGeometry();

        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);

        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 setRegionDimensions(const Vector3& size) { 
            mRegionDimensions = size; 
            mHalfRegionDimensions = size * 0.5;
        }
        virtual const Vector3& getRegionDimensions(void) const { return mRegionDimensions; }
        virtual void setOrigin(const Vector3& origin) { mOrigin = origin; }
        virtual const Vector3& getOrigin(void) const { return mOrigin; }

        void setVisibilityFlags(uint32 flags);
        uint32 getVisibilityFlags() const;

        virtual void setRenderQueueGroup(uint8 queueID);

        virtual uint8 getRenderQueueGroup(void) const;
        void visitRenderables(Renderable::Visitor* visitor, 
            bool debugRenderables = false);
        
        typedef MapIterator<RegionMap> RegionIterator;
        RegionIterator getRegionIterator(void);

        virtual void dump(const String& filename) const;


    };
}

#endif