OgreMesh.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 __Mesh_H__
#define __Mesh_H__

#include "OgrePrerequisites.h"

#include "OgreResource.h"
#include "OgreVertexIndexData.h"
#include "OgreAxisAlignedBox.h"
#include "OgreVertexBoneAssignment.h"
#include "OgreIteratorWrappers.h"
#include "OgreProgressiveMesh.h"
#include "OgreHardwareVertexBuffer.h"
#include "OgreSkeleton.h"
#include "OgreAnimationTrack.h"
#include "OgrePose.h"


namespace Ogre {


    struct MeshLodUsage;

    class _OgreExport Mesh: public Resource
    {
        friend class SubMesh;
        friend class MeshSerializerImpl;
        friend class MeshSerializerImpl_v1_2;
        friend class MeshSerializerImpl_v1_1;

    public:
        typedef std::vector<Real> LodDistanceList;
        typedef std::multimap<size_t, VertexBoneAssignment> VertexBoneAssignmentList;
        typedef MapIterator<VertexBoneAssignmentList> BoneAssignmentIterator;
        typedef std::vector<SubMesh*> SubMeshList;
        typedef std::vector<unsigned short> IndexMap;

    protected:
        SubMeshList mSubMeshList;
    
        void organiseTangentsBuffer(VertexData *vertexData, unsigned short destCoordSet);

    public:
        typedef HashMap<String, ushort> SubMeshNameMap ;

        
    protected:
        SubMeshNameMap mSubMeshNameMap ;

        AxisAlignedBox mAABB;
        Real mBoundRadius;

        String mSkeletonName;
        SkeletonPtr mSkeleton;

       
        VertexBoneAssignmentList mBoneAssignments;

        bool mBoneAssignmentsOutOfDate;

        void buildIndexMap(const VertexBoneAssignmentList& boneAssignments,
            IndexMap& boneIndexToBlendIndexMap, IndexMap& blendIndexToBoneIndexMap);
        void compileBoneAssignments(const VertexBoneAssignmentList& boneAssignments,
            unsigned short numBlendWeightsPerVertex, 
            IndexMap& blendIndexToBoneIndexMap,
            VertexData* targetVertexData);

        bool mIsLodManual;
        ushort mNumLods;
        typedef std::vector<MeshLodUsage> MeshLodUsageList;
        MeshLodUsageList mMeshLodUsageList;

        HardwareBuffer::Usage mVertexBufferUsage;
        HardwareBuffer::Usage mIndexBufferUsage;
        bool mVertexBufferShadowBuffer;
        bool mIndexBufferShadowBuffer;


        bool mPreparedForShadowVolumes;
        bool mEdgeListsBuilt;
        bool mAutoBuildEdgeLists;

        typedef std::map<String, Animation*> AnimationList;
        AnimationList mAnimationsList;
        mutable VertexAnimationType mSharedVertexDataAnimationType;
        mutable bool mAnimationTypesDirty;

        PoseList mPoseList;


        void loadImpl(void);
        void unloadImpl(void);
        size_t calculateSize(void) const;



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

        void load(void);

        // NB All methods below are non-virtual since they will be
        // called in the rendering loop - speed is of the essence.

        SubMesh* createSubMesh(void);

        SubMesh* createSubMesh(const String& name);
        
        void nameSubMesh(const String& name, ushort index);
        
        ushort _getSubMeshIndex(const String& name) const;

        unsigned short getNumSubMeshes(void) const;

        SubMesh* getSubMesh(unsigned short index) const;

        SubMesh* getSubMesh(const String& name) const ;

        typedef VectorIterator<SubMeshList> SubMeshIterator;
        SubMeshIterator getSubMeshIterator(void)
        { return SubMeshIterator(mSubMeshList.begin(), mSubMeshList.end()); }
      
        VertexData *sharedVertexData;

        IndexMap sharedBlendIndexToBoneIndexMap;

        MeshPtr clone(const String& newName, const String& newGroup = StringUtil::BLANK);

        const AxisAlignedBox& getBounds(void) const;

        Real getBoundingSphereRadius(void) const;

        void _setBounds(const AxisAlignedBox& bounds, bool pad = true);

        void _setBoundingSphereRadius(Real radius);

        void setSkeletonName(const String& skelName);

        bool hasSkeleton(void) const;

        bool hasVertexAnimation(void) const;

        const SkeletonPtr& getSkeleton(void) const;

        const String& getSkeletonName(void) const;
        void _initAnimationState(AnimationStateSet* animSet);

        void addBoneAssignment(const VertexBoneAssignment& vertBoneAssign);

        void clearBoneAssignments(void);

        void _notifySkeleton(SkeletonPtr& pSkel);


        BoneAssignmentIterator getBoneAssignmentIterator(void);


        void generateLodLevels(const LodDistanceList& lodDistances, 
            ProgressiveMesh::VertexReductionQuota reductionMethod, Real reductionValue);

        ushort getNumLodLevels(void) const;
        const MeshLodUsage& getLodLevel(ushort index) const;
        void createManualLodLevel(Real fromDepth, const String& meshName);

        void updateManualLodLevel(ushort index, const String& meshName);

        ushort getLodIndex(Real depth) const;

        ushort getLodIndexSquaredDepth(Real squaredDepth) const;

        bool isLodManual(void) const { return mIsLodManual; }

        void _setLodInfo(unsigned short numLevels, bool isManual);
        void _setLodUsage(unsigned short level, MeshLodUsage& usage);
        void _setSubMeshLodFaceList(unsigned short subIdx, unsigned short level, IndexData* facedata);

        void removeLodLevels(void);

        void setVertexBufferPolicy(HardwareBuffer::Usage usage, bool shadowBuffer = false);
        void setIndexBufferPolicy(HardwareBuffer::Usage usage, bool shadowBuffer = false);
        HardwareBuffer::Usage getVertexBufferUsage(void) const { return mVertexBufferUsage; }
        HardwareBuffer::Usage getIndexBufferUsage(void) const { return mIndexBufferUsage; }
        bool isVertexBufferShadowed(void) const { return mVertexBufferShadowBuffer; }
        bool isIndexBufferShadowed(void) const { return mIndexBufferShadowBuffer; }
       

        unsigned short _rationaliseBoneAssignments(size_t vertexCount, VertexBoneAssignmentList& assignments);

        void _compileBoneAssignments(void);

        void _updateCompiledBoneAssignments(void);

        void buildTangentVectors(unsigned short sourceTexCoordSet = 0, unsigned short destTexCoordSet = 1);

        bool suggestTangentVectorBuildParams(unsigned short& outSourceCoordSet, unsigned short& outDestCoordSet);

        void buildEdgeList(void);
        void freeEdgeList(void);

        void prepareForShadowVolume(void);

        EdgeData* getEdgeList(unsigned int lodIndex = 0);

        const EdgeData* getEdgeList(unsigned int lodIndex = 0) const;

        bool isPreparedForShadowVolumes(void) const { return mPreparedForShadowVolumes; }

        bool isEdgeListBuilt(void) const { return mEdgeListsBuilt; }

        static void softwareVertexBlend(const VertexData* sourceVertexData, 
            const VertexData* targetVertexData, const Matrix4* pMatrices, 
            const unsigned short* pIndexMap,
            bool blendNormals);

        static void softwareVertexMorph(Real t, 
            const HardwareVertexBufferSharedPtr& b1, 
            const HardwareVertexBufferSharedPtr& b2, 
            VertexData* targetVertexData);

        static void softwareVertexPoseBlend(Real weight, 
            const std::map<size_t, Vector3>& vertexOffsetMap,
            VertexData* targetVertexData);
        const SubMeshNameMap& getSubMeshNameMap(void) const { return mSubMeshNameMap; }

        void setAutoBuildEdgeLists(bool autobuild) { mAutoBuildEdgeLists = autobuild; }
        bool getAutoBuildEdgeLists(void) const { return mAutoBuildEdgeLists; }

        virtual VertexAnimationType getSharedVertexDataAnimationType(void) const;

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

        virtual Animation* getAnimation(const String& name) const;

        virtual Animation* _getAnimationImpl(const String& name) const;

        virtual bool hasAnimation(const String& name);

        virtual void removeAnimation(const String& name);

        virtual unsigned short getNumAnimations(void) const;

        virtual Animation* getAnimation(unsigned short index) const;

        virtual void removeAllAnimations(void);
        VertexData* getVertexDataByTrackHandle(unsigned short handle);
        void updateMaterialForAllSubMeshes(void);

        void _determineAnimationTypes(void) const;
        bool _getAnimationTypesDirty(void) const { return mAnimationTypesDirty; }

        Pose* createPose(ushort target, const String& name = StringUtil::BLANK);
        size_t getPoseCount(void) const { return mPoseList.size(); }
        Pose* getPose(ushort index);
        Pose* getPose(const String& name);
        void removePose(ushort index);
        void removePose(const String& name);
        void removeAllPoses(void);

        typedef VectorIterator<PoseList> PoseIterator;
        typedef ConstVectorIterator<PoseList> ConstPoseIterator;

        PoseIterator getPoseIterator(void);
        ConstPoseIterator getPoseIterator(void) const;
        const PoseList& getPoseList(void) const;

    };

    class _OgreExport MeshPtr : public SharedPtr<Mesh> 
    {
    public:
        MeshPtr() : SharedPtr<Mesh>() {}
        explicit MeshPtr(Mesh* rep) : SharedPtr<Mesh>(rep) {}
        MeshPtr(const MeshPtr& r) : SharedPtr<Mesh>(r) {} 
        MeshPtr(const ResourcePtr& r);
        MeshPtr& operator=(const ResourcePtr& r);
    protected:
        void destroy(void);
    };

    struct MeshLodUsage
    {
        Real fromDepthSquared;
        String manualName;
        mutable MeshPtr manualMesh;
        mutable EdgeData* edgeData;
    };



} // namespace

#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:44 2006