OgreMesh.h

Go to the documentation of this file.
00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OGRE
00004     (Object-oriented Graphics Rendering Engine)
00005 For the latest info, see http://www.ogre3d.org/
00006 
00007 Copyright (c) 2000-2009 Torus Knot Software Ltd
00008 
00009 Permission is hereby granted, free of charge, to any person obtaining a copy
00010 of this software and associated documentation files (the "Software"), to deal
00011 in the Software without restriction, including without limitation the rights
00012 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00013 copies of the Software, and to permit persons to whom the Software is
00014 furnished to do so, subject to the following conditions:
00015 
00016 The above copyright notice and this permission notice shall be included in
00017 all copies or substantial portions of the Software.
00018 
00019 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00020 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00021 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
00022 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
00023 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
00024 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
00025 THE SOFTWARE.
00026 -----------------------------------------------------------------------------
00027 */
00028 #ifndef __Mesh_H__
00029 #define __Mesh_H__
00030 
00031 #include "OgrePrerequisites.h"
00032 
00033 #include "OgreResource.h"
00034 #include "OgreVertexIndexData.h"
00035 #include "OgreAxisAlignedBox.h"
00036 #include "OgreVertexBoneAssignment.h"
00037 #include "OgreIteratorWrappers.h"
00038 #include "OgreProgressiveMesh.h"
00039 #include "OgreHardwareVertexBuffer.h"
00040 #include "OgreSkeleton.h"
00041 #include "OgreAnimationTrack.h"
00042 #include "OgrePose.h"
00043 #include "OgreDataStream.h"
00044 
00045 
00046 namespace Ogre {
00047 
00048 
00088     struct MeshLodUsage;
00089     class LodStrategy;
00090 
00091     class _OgreExport Mesh: public Resource
00092     {
00093         friend class SubMesh;
00094         friend class MeshSerializerImpl;
00095         friend class MeshSerializerImpl_v1_4;
00096         friend class MeshSerializerImpl_v1_2;
00097         friend class MeshSerializerImpl_v1_1;
00098 
00099     public:
00100         typedef vector<Real>::type LodValueList;
00101         typedef vector<MeshLodUsage>::type MeshLodUsageList;
00103         typedef multimap<size_t, VertexBoneAssignment>::type VertexBoneAssignmentList;
00104         typedef MapIterator<VertexBoneAssignmentList> BoneAssignmentIterator;
00105         typedef vector<SubMesh*>::type SubMeshList;
00106         typedef vector<unsigned short>::type IndexMap;
00107 
00108     protected:
00115         SubMeshList mSubMeshList;
00116     
00118         void organiseTangentsBuffer(VertexData *vertexData, 
00119             VertexElementSemantic targetSemantic, unsigned short index, 
00120             unsigned short sourceTexCoordSet);
00121 
00122     public:
00126         typedef HashMap<String, ushort> SubMeshNameMap ;
00127 
00128         
00129     protected:
00130 
00131         DataStreamPtr mFreshFromDisk;
00132 
00133         SubMeshNameMap mSubMeshNameMap ;
00134 
00136         AxisAlignedBox mAABB;
00138         Real mBoundRadius;
00139 
00141         String mSkeletonName;
00142         SkeletonPtr mSkeleton;
00143 
00144        
00145         VertexBoneAssignmentList mBoneAssignments;
00146 
00148         bool mBoneAssignmentsOutOfDate;
00149 
00151         void buildIndexMap(const VertexBoneAssignmentList& boneAssignments,
00152             IndexMap& boneIndexToBlendIndexMap, IndexMap& blendIndexToBoneIndexMap);
00154         void compileBoneAssignments(const VertexBoneAssignmentList& boneAssignments,
00155             unsigned short numBlendWeightsPerVertex, 
00156             IndexMap& blendIndexToBoneIndexMap,
00157             VertexData* targetVertexData);
00158 
00159         const LodStrategy *mLodStrategy;
00160         bool mIsLodManual;
00161         ushort mNumLods;
00162         MeshLodUsageList mMeshLodUsageList;
00163 
00164         HardwareBuffer::Usage mVertexBufferUsage;
00165         HardwareBuffer::Usage mIndexBufferUsage;
00166         bool mVertexBufferShadowBuffer;
00167         bool mIndexBufferShadowBuffer;
00168 
00169 
00170         bool mPreparedForShadowVolumes;
00171         bool mEdgeListsBuilt;
00172         bool mAutoBuildEdgeLists;
00173 
00175         typedef map<String, Animation*>::type AnimationList;
00176         AnimationList mAnimationsList;
00178         mutable VertexAnimationType mSharedVertexDataAnimationType;
00180         mutable bool mAnimationTypesDirty;
00181 
00183         PoseList mPoseList;
00184 
00185 
00191         void prepareImpl(void);
00194         void unprepareImpl(void);
00196         void loadImpl(void);
00198         void postLoadImpl(void);
00200         void unloadImpl(void);
00202         size_t calculateSize(void) const;
00203 
00204 
00205 
00206     public:
00211         Mesh(ResourceManager* creator, const String& name, ResourceHandle handle,
00212             const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
00213         ~Mesh();
00214 
00215         // NB All methods below are non-virtual since they will be
00216         // called in the rendering loop - speed is of the essence.
00217 
00224         SubMesh* createSubMesh(void);
00225 
00228         SubMesh* createSubMesh(const String& name);
00229         
00232         void nameSubMesh(const String& name, ushort index);
00233 
00236         void unnameSubMesh(const String& name);
00237         
00243         ushort _getSubMeshIndex(const String& name) const;
00244 
00247         unsigned short getNumSubMeshes(void) const;
00248 
00251         SubMesh* getSubMesh(unsigned short index) const;
00252 
00255         SubMesh* getSubMesh(const String& name) const ;
00256         
00262         void destroySubMesh(unsigned short index);
00263 
00269         void destroySubMesh(const String& name);
00270         
00271         typedef VectorIterator<SubMeshList> SubMeshIterator;
00273         SubMeshIterator getSubMeshIterator(void)
00274         { return SubMeshIterator(mSubMeshList.begin(), mSubMeshList.end()); }
00275       
00284         VertexData *sharedVertexData;
00285 
00306         IndexMap sharedBlendIndexToBoneIndexMap;
00307 
00317         MeshPtr clone(const String& newName, const String& newGroup = StringUtil::BLANK);
00318 
00321         const AxisAlignedBox& getBounds(void) const;
00322 
00324         Real getBoundingSphereRadius(void) const;
00325 
00334         void _setBounds(const AxisAlignedBox& bounds, bool pad = true);
00335 
00343         void _setBoundingSphereRadius(Real radius);
00344 
00355         void setSkeletonName(const String& skelName);
00356 
00358         bool hasSkeleton(void) const;
00359 
00362         bool hasVertexAnimation(void) const;
00363 
00367         const SkeletonPtr& getSkeleton(void) const;
00368 
00370         const String& getSkeletonName(void) const;
00375         void _initAnimationState(AnimationStateSet* animSet);
00376 
00381         void _refreshAnimationState(AnimationStateSet* animSet);
00394         void addBoneAssignment(const VertexBoneAssignment& vertBoneAssign);
00395 
00401         void clearBoneAssignments(void);
00402 
00409         void _notifySkeleton(SkeletonPtr& pSkel);
00410 
00411 
00414         BoneAssignmentIterator getBoneAssignmentIterator(void);
00415 
00418         const VertexBoneAssignmentList& getBoneAssignments() const { return mBoneAssignments; }
00419 
00420 
00446         void generateLodLevels(const LodValueList& lodValues, 
00447             ProgressiveMesh::VertexReductionQuota reductionMethod, Real reductionValue);
00448 
00453         ushort getNumLodLevels(void) const;
00455         const MeshLodUsage& getLodLevel(ushort index) const;
00469         void createManualLodLevel(Real value, const String& meshName, const String& groupName = Ogre::String());
00470 
00478         void updateManualLodLevel(ushort index, const String& meshName);
00479 
00485         ushort getLodIndex(Real value) const;
00486 
00493         bool isLodManual(void) const { return mIsLodManual; }
00494 
00496         void _setLodInfo(unsigned short numLevels, bool isManual);
00498         void _setLodUsage(unsigned short level, MeshLodUsage& usage);
00500         void _setSubMeshLodFaceList(unsigned short subIdx, unsigned short level, IndexData* facedata);
00501 
00503         void removeLodLevels(void);
00504 
00527         void setVertexBufferPolicy(HardwareBuffer::Usage usage, bool shadowBuffer = false);
00550         void setIndexBufferPolicy(HardwareBuffer::Usage usage, bool shadowBuffer = false);
00552         HardwareBuffer::Usage getVertexBufferUsage(void) const { return mVertexBufferUsage; }
00554         HardwareBuffer::Usage getIndexBufferUsage(void) const { return mIndexBufferUsage; }
00556         bool isVertexBufferShadowed(void) const { return mVertexBufferShadowBuffer; }
00558         bool isIndexBufferShadowed(void) const { return mIndexBufferShadowBuffer; }
00559        
00560 
00574         unsigned short _rationaliseBoneAssignments(size_t vertexCount, VertexBoneAssignmentList& assignments);
00575 
00583         void _compileBoneAssignments(void);
00584 
00590         void _updateCompiledBoneAssignments(void);
00591 
00618         void buildTangentVectors(VertexElementSemantic targetSemantic = VES_TANGENT,
00619             unsigned short sourceTexCoordSet = 0, unsigned short index = 0, 
00620             bool splitMirrored = false, bool splitRotated = false, bool storeParityInW = false);
00621 
00640         bool suggestTangentVectorBuildParams(VertexElementSemantic targetSemantic,
00641             unsigned short& outSourceCoordSet, unsigned short& outIndex);
00642 
00646         void buildEdgeList(void);
00648         void freeEdgeList(void);
00649 
00668         void prepareForShadowVolume(void);
00669 
00676         EdgeData* getEdgeList(unsigned short lodIndex = 0);
00677 
00684         const EdgeData* getEdgeList(unsigned short lodIndex = 0) const;
00685 
00688         bool isPreparedForShadowVolumes(void) const { return mPreparedForShadowVolumes; }
00689 
00691         bool isEdgeListBuilt(void) const { return mEdgeListsBuilt; }
00692 
00704         static void prepareMatricesForVertexBlend(const Matrix4** blendMatrices,
00705             const Matrix4* boneMatrices, const IndexMap& indexMap);
00706 
00725         static void softwareVertexBlend(const VertexData* sourceVertexData, 
00726             const VertexData* targetVertexData,
00727             const Matrix4* const* blendMatrices, size_t numMatrices,
00728             bool blendNormals);
00729 
00742         static void softwareVertexMorph(Real t, 
00743             const HardwareVertexBufferSharedPtr& b1, 
00744             const HardwareVertexBufferSharedPtr& b2, 
00745             VertexData* targetVertexData);
00746 
00761         static void softwareVertexPoseBlend(Real weight, 
00762             const map<size_t, Vector3>::type& vertexOffsetMap,
00763             VertexData* targetVertexData);
00765         const SubMeshNameMap& getSubMeshNameMap(void) const { return mSubMeshNameMap; }
00766 
00777         void setAutoBuildEdgeLists(bool autobuild) { mAutoBuildEdgeLists = autobuild; }
00782         bool getAutoBuildEdgeLists(void) const { return mAutoBuildEdgeLists; }
00783 
00786         virtual VertexAnimationType getSharedVertexDataAnimationType(void) const;
00787 
00792         virtual Animation* createAnimation(const String& name, Real length);
00793 
00797         virtual Animation* getAnimation(const String& name) const;
00798 
00803         virtual Animation* _getAnimationImpl(const String& name) const;
00804 
00806         virtual bool hasAnimation(const String& name);
00807 
00809         virtual void removeAnimation(const String& name);
00810 
00812         virtual unsigned short getNumAnimations(void) const;
00813 
00816         virtual Animation* getAnimation(unsigned short index) const;
00817 
00819         virtual void removeAllAnimations(void);
00825         VertexData* getVertexDataByTrackHandle(unsigned short handle);
00837         void updateMaterialForAllSubMeshes(void);
00838 
00843         void _determineAnimationTypes(void) const;
00845         bool _getAnimationTypesDirty(void) const { return mAnimationTypesDirty; }
00846 
00853         Pose* createPose(ushort target, const String& name = StringUtil::BLANK);
00855         size_t getPoseCount(void) const { return mPoseList.size(); }
00857         Pose* getPose(ushort index);
00859         Pose* getPose(const String& name);
00863         void removePose(ushort index);
00867         void removePose(const String& name);
00869         void removeAllPoses(void);
00870 
00871         typedef VectorIterator<PoseList> PoseIterator;
00872         typedef ConstVectorIterator<PoseList> ConstPoseIterator;
00873 
00875         PoseIterator getPoseIterator(void);
00877         ConstPoseIterator getPoseIterator(void) const;
00879         const PoseList& getPoseList(void) const;
00880 
00882         const LodStrategy *getLodStrategy() const;
00884         void setLodStrategy(LodStrategy *lodStrategy);
00885 
00886     };
00887 
00894     class _OgreExport MeshPtr : public SharedPtr<Mesh> 
00895     {
00896     public:
00897         MeshPtr() : SharedPtr<Mesh>() {}
00898         explicit MeshPtr(Mesh* rep) : SharedPtr<Mesh>(rep) {}
00899         MeshPtr(const MeshPtr& r) : SharedPtr<Mesh>(r) {} 
00900         MeshPtr(const ResourcePtr& r);
00902         MeshPtr& operator=(const ResourcePtr& r);
00903     protected:
00905         void destroy(void);
00906     };
00907 
00909     struct MeshLodUsage
00910     {
00915         Real userValue;
00916 
00922         Real value;
00923         
00925         String manualName;
00927         String manualGroup;
00929         mutable MeshPtr manualMesh;
00931         mutable EdgeData* edgeData;
00932 
00933         MeshLodUsage() : userValue(0.0), value(0.0), edgeData(0) {}
00934     };
00935 
00940 } // namespace
00941 
00942 #endif

Copyright © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Wed Nov 3 2010 19:24:52