OGRE  1.8
Object-Oriented Graphics Rendering Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
OgreMesh.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4  (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2013 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __Mesh_H__
29 #define __Mesh_H__
30 
31 #include "OgrePrerequisites.h"
32 
33 #include "OgreResource.h"
34 #include "OgreVertexIndexData.h"
35 #include "OgreAxisAlignedBox.h"
37 #include "OgreIteratorWrappers.h"
39 #include "OgreSkeleton.h"
40 #include "OgreAnimation.h"
41 #include "OgreAnimationTrack.h"
42 #include "OgrePose.h"
43 #include "OgreDataStream.h"
44 #include "OgreHeaderPrefix.h"
45 
46 
47 namespace Ogre {
48 
49 
89  struct MeshLodUsage;
90  class LodStrategy;
91 
93  {
94  friend class SubMesh;
95  friend class MeshSerializerImpl;
99 
100  public:
108 
109  protected:
117 
119  void organiseTangentsBuffer(VertexData *vertexData,
120  VertexElementSemantic targetSemantic, unsigned short index,
121  unsigned short sourceTexCoordSet);
122 
123  public:
127  typedef HashMap<String, ushort> SubMeshNameMap ;
128 
129 
130  protected:
131 
133 
135 
140 
144 
145 
147 
150 
152  void buildIndexMap(const VertexBoneAssignmentList& boneAssignments,
153  IndexMap& boneIndexToBlendIndexMap, IndexMap& blendIndexToBoneIndexMap);
155  void compileBoneAssignments(const VertexBoneAssignmentList& boneAssignments,
156  unsigned short numBlendWeightsPerVertex,
157  IndexMap& blendIndexToBoneIndexMap,
158  VertexData* targetVertexData);
159 
164 
169 
170 
174 
183  mutable bool mAnimationTypesDirty;
184 
187  mutable bool mPosesIncludeNormals;
188 
189 
195  void prepareImpl(void);
198  void unprepareImpl(void);
200  void loadImpl(void);
202  void postLoadImpl(void);
204  void unloadImpl(void);
206  size_t calculateSize(void) const;
207 
208 
209 
210  public:
215  Mesh(ResourceManager* creator, const String& name, ResourceHandle handle,
216  const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
217  ~Mesh();
218 
219  // NB All methods below are non-virtual since they will be
220  // called in the rendering loop - speed is of the essence.
221 
228  SubMesh* createSubMesh(void);
229 
232  SubMesh* createSubMesh(const String& name);
233 
236  void nameSubMesh(const String& name, ushort index);
237 
240  void unnameSubMesh(const String& name);
241 
247  ushort _getSubMeshIndex(const String& name) const;
248 
251  unsigned short getNumSubMeshes(void) const;
252 
255  SubMesh* getSubMesh(unsigned short index) const;
256 
259  SubMesh* getSubMesh(const String& name) const ;
260 
266  void destroySubMesh(unsigned short index);
267 
273  void destroySubMesh(const String& name);
274 
278  { return SubMeshIterator(mSubMeshList.begin(), mSubMeshList.end()); }
279 
289 
311 
321  MeshPtr clone(const String& newName, const String& newGroup = StringUtil::BLANK);
322 
325  const AxisAlignedBox& getBounds(void) const;
326 
328  Real getBoundingSphereRadius(void) const;
329 
338  void _setBounds(const AxisAlignedBox& bounds, bool pad = true);
339 
347  void _setBoundingSphereRadius(Real radius);
348 
359  void setSkeletonName(const String& skelName);
360 
362  bool hasSkeleton(void) const;
363 
366  bool hasVertexAnimation(void) const;
367 
371  const SkeletonPtr& getSkeleton(void) const;
372 
374  const String& getSkeletonName(void) const;
379  void _initAnimationState(AnimationStateSet* animSet);
380 
385  void _refreshAnimationState(AnimationStateSet* animSet);
398  void addBoneAssignment(const VertexBoneAssignment& vertBoneAssign);
399 
405  void clearBoneAssignments(void);
406 
413  void _notifySkeleton(SkeletonPtr& pSkel);
414 
415 
418  BoneAssignmentIterator getBoneAssignmentIterator(void);
419 
422  const VertexBoneAssignmentList& getBoneAssignments() const { return mBoneAssignments; }
423 
424 
429  ushort getNumLodLevels(void) const;
431  const MeshLodUsage& getLodLevel(ushort index) const;
445  void createManualLodLevel(Real value, const String& meshName, const String& groupName = Ogre::String());
446 
454  void updateManualLodLevel(ushort index, const String& meshName);
455 
461  ushort getLodIndex(Real value) const;
462 
469  bool isLodManual(void) const { return mIsLodManual; }
470 
472  void _setLodInfo(unsigned short numLevels, bool isManual);
474  void _setLodUsage(unsigned short level, MeshLodUsage& usage);
476  void _setSubMeshLodFaceList(unsigned short subIdx, unsigned short level, IndexData* facedata);
477 
479  void removeLodLevels(void);
480 
503  void setVertexBufferPolicy(HardwareBuffer::Usage usage, bool shadowBuffer = false);
526  void setIndexBufferPolicy(HardwareBuffer::Usage usage, bool shadowBuffer = false);
528  HardwareBuffer::Usage getVertexBufferUsage(void) const { return mVertexBufferUsage; }
530  HardwareBuffer::Usage getIndexBufferUsage(void) const { return mIndexBufferUsage; }
532  bool isVertexBufferShadowed(void) const { return mVertexBufferShadowBuffer; }
534  bool isIndexBufferShadowed(void) const { return mIndexBufferShadowBuffer; }
535 
536 
550  unsigned short _rationaliseBoneAssignments(size_t vertexCount, VertexBoneAssignmentList& assignments);
551 
559  void _compileBoneAssignments(void);
560 
566  void _updateCompiledBoneAssignments(void);
567 
594  void buildTangentVectors(VertexElementSemantic targetSemantic = VES_TANGENT,
595  unsigned short sourceTexCoordSet = 0, unsigned short index = 0,
596  bool splitMirrored = false, bool splitRotated = false, bool storeParityInW = false);
597 
616  bool suggestTangentVectorBuildParams(VertexElementSemantic targetSemantic,
617  unsigned short& outSourceCoordSet, unsigned short& outIndex);
618 
622  void buildEdgeList(void);
624  void freeEdgeList(void);
625 
644  void prepareForShadowVolume(void);
645 
652  EdgeData* getEdgeList(unsigned short lodIndex = 0);
653 
660  const EdgeData* getEdgeList(unsigned short lodIndex = 0) const;
661 
664  bool isPreparedForShadowVolumes(void) const { return mPreparedForShadowVolumes; }
665 
667  bool isEdgeListBuilt(void) const { return mEdgeListsBuilt; }
668 
680  static void prepareMatricesForVertexBlend(const Matrix4** blendMatrices,
681  const Matrix4* boneMatrices, const IndexMap& indexMap);
682 
701  static void softwareVertexBlend(const VertexData* sourceVertexData,
702  const VertexData* targetVertexData,
703  const Matrix4* const* blendMatrices, size_t numMatrices,
704  bool blendNormals);
705 
718  static void softwareVertexMorph(Real t,
721  VertexData* targetVertexData);
722 
738  static void softwareVertexPoseBlend(Real weight,
739  const map<size_t, Vector3>::type& vertexOffsetMap,
740  const map<size_t, Vector3>::type& normalsMap,
741  VertexData* targetVertexData);
743  const SubMeshNameMap& getSubMeshNameMap(void) const { return mSubMeshNameMap; }
744 
755  void setAutoBuildEdgeLists(bool autobuild) { mAutoBuildEdgeLists = autobuild; }
760  bool getAutoBuildEdgeLists(void) const { return mAutoBuildEdgeLists; }
761 
764  virtual VertexAnimationType getSharedVertexDataAnimationType(void) const;
765 
767  bool getSharedVertexDataAnimationIncludesNormals() const { return mSharedVertexDataAnimationIncludesNormals; }
768 
773  virtual Animation* createAnimation(const String& name, Real length);
774 
778  virtual Animation* getAnimation(const String& name) const;
779 
784  virtual Animation* _getAnimationImpl(const String& name) const;
785 
787  virtual bool hasAnimation(const String& name) const;
788 
790  virtual void removeAnimation(const String& name);
791 
793  virtual unsigned short getNumAnimations(void) const;
794 
797  virtual Animation* getAnimation(unsigned short index) const;
798 
800  virtual void removeAllAnimations(void);
806  VertexData* getVertexDataByTrackHandle(unsigned short handle);
818  void updateMaterialForAllSubMeshes(void);
819 
824  void _determineAnimationTypes(void) const;
826  bool _getAnimationTypesDirty(void) const { return mAnimationTypesDirty; }
827 
834  Pose* createPose(ushort target, const String& name = StringUtil::BLANK);
836  size_t getPoseCount(void) const { return mPoseList.size(); }
838  Pose* getPose(ushort index);
840  Pose* getPose(const String& name);
844  void removePose(ushort index);
848  void removePose(const String& name);
850  void removeAllPoses(void);
851 
854 
856  PoseIterator getPoseIterator(void);
858  ConstPoseIterator getPoseIterator(void) const;
860  const PoseList& getPoseList(void) const;
861 
863  const LodStrategy *getLodStrategy() const;
865  void setLodStrategy(LodStrategy *lodStrategy);
866 
867  };
868 
875  class _OgreExport MeshPtr : public SharedPtr<Mesh>
876  {
877  public:
879  explicit MeshPtr(Mesh* rep) : SharedPtr<Mesh>(rep) {}
880  MeshPtr(const MeshPtr& r) : SharedPtr<Mesh>(r) {}
881  MeshPtr(const ResourcePtr& r);
883  MeshPtr& operator=(const ResourcePtr& r);
884  protected:
886  void destroy(void);
887  };
888 
891  {
897 
904 
912  mutable EdgeData* edgeData;
913 
914  MeshLodUsage() : userValue(0.0), value(0.0), edgeData(0) {}
915  };
916 
921 } // namespace
922 
923 #include "OgreHeaderSuffix.h"
924 
925 #endif
Class encapsulating a set of AnimationState objects.
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
bool mPosesIncludeNormals
Definition: OgreMesh.h:187
bool mEdgeListsBuilt
Definition: OgreMesh.h:172
SkeletonPtr mSkeleton
Definition: OgreMesh.h:143
float Real
Software floating point type.
vector< unsigned short >::type IndexMap
Definition: OgreMesh.h:107
#define _OgreExport
Definition: OgrePlatform.h:233
AxisAlignedBox mAABB
Local bounding box volume.
Definition: OgreMesh.h:137
bool _getAnimationTypesDirty(void) const
Are the derived animation types out of date?
Definition: OgreMesh.h:826
HardwareBuffer::Usage mIndexBufferUsage
Definition: OgreMesh.h:166
Real mBoundRadius
Local bounding sphere radius (centered on object)
Definition: OgreMesh.h:139
ushort mNumLods
Definition: OgreMesh.h:162
Tangent (X axis if normal is Z)
A way of recording the way each LODs is recorded this Mesh.
Definition: OgreMesh.h:890
MapIterator< VertexBoneAssignmentList > BoneAssignmentIterator
Definition: OgreMesh.h:105
bool mSharedVertexDataAnimationIncludesNormals
Whether vertex animation includes normals.
Definition: OgreMesh.h:181
const LodStrategy * mLodStrategy
Definition: OgreMesh.h:160
bool mAnimationTypesDirty
Do we need to scan animations for animation types?
Definition: OgreMesh.h:183
bool getSharedVertexDataAnimationIncludesNormals() const
Returns whether animation on shared vertex data includes normals.
Definition: OgreMesh.h:767
IndexMap sharedBlendIndexToBoneIndexMap
Shared index map for translating blend index to bone index.
Definition: OgreMesh.h:310
A pose is a linked set of vertex offsets applying to one set of vertex data.
Definition: OgrePose.h:55
Shared pointer implementation used to share index buffers.
A 3D box aligned with the x/y/z axes.
bool mPreparedForShadowVolumes
Definition: OgreMesh.h:171
map< String, Animation * >::type AnimationList
Storage of morph animations, lookup by name.
Definition: OgreMesh.h:176
Interface describing a manual resource loader.
Definition: OgreResource.h:513
VertexElementSemantic
Vertex element semantics, used to identify the meaning of vertex buffer contents. ...
SubMeshList mSubMeshList
A list of submeshes which make up this mesh.
Definition: OgreMesh.h:116
Strategy for determining level of detail.
MeshLodUsageList mMeshLodUsageList
Definition: OgreMesh.h:163
HardwareBuffer::Usage mVertexBufferUsage
Definition: OgreMesh.h:165
bool mIndexBufferShadowBuffer
Definition: OgreMesh.h:168
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
bool mVertexBufferShadowBuffer
Definition: OgreMesh.h:167
vector< Pose * >::type PoseList
Definition: OgrePose.h:135
bool mAutoBuildEdgeLists
Definition: OgreMesh.h:173
const SubMeshNameMap & getSubMeshNameMap(void) const
Gets a reference to the optional name assignments of the SubMeshes.
Definition: OgreMesh.h:743
bool isIndexBufferShadowed(void) const
Gets whether or not this meshes index buffers are shadowed.
Definition: OgreMesh.h:534
MeshPtr(Mesh *rep)
Definition: OgreMesh.h:879
bool getAutoBuildEdgeLists(void) const
Sets whether or not this Mesh should automatically build edge lists when asked for them...
Definition: OgreMesh.h:760
VertexData * sharedVertexData
Shared vertex data.
Definition: OgreMesh.h:288
void setAutoBuildEdgeLists(bool autobuild)
Sets whether or not this Mesh should automatically build edge lists when asked for them...
Definition: OgreMesh.h:755
DataStreamPtr mFreshFromDisk
Definition: OgreMesh.h:132
String manualGroup
Only relevant if mIsLodManual is true, the name of the group of the alternative mesh.
Definition: OgreMesh.h:908
MeshPtr(const MeshPtr &r)
Definition: OgreMesh.h:880
bool isPreparedForShadowVolumes(void) const
Returns whether this mesh has already had it's geometry prepared for use in rendering shadow volumes...
Definition: OgreMesh.h:664
Concrete IteratorWrapper for const access to the underlying container.
vector< SubMesh * >::type SubMeshList
Definition: OgreMesh.h:106
Internal implementation of Mesh reading / writing for the latest version of the .mesh format...
HardwareBuffer::Usage getVertexBufferUsage(void) const
Gets the usage setting for this meshes vertex buffers.
Definition: OgreMesh.h:528
Summary class collecting together index data source information.
Usage
Enums describing buffer usage; not mutually exclusive.
EdgeData * edgeData
Edge list for this LOD level (may be derived from manual mesh)
Definition: OgreMesh.h:912
HashMap< String, ushort > SubMeshNameMap
A hashmap used to store optional SubMesh names.
Definition: OgreMesh.h:127
Defines a part of a complete mesh.
Definition: OgreSubMesh.h:62
Real value
Value used by to determine when this lod applies.
Definition: OgreMesh.h:903
SubMeshIterator getSubMeshIterator(void)
Gets an iterator over the available submeshes.
Definition: OgreMesh.h:277
MeshPtr manualMesh
Hard link to mesh to avoid looking up each time.
Definition: OgreMesh.h:910
unsigned short ushort
const VertexBoneAssignmentList & getBoneAssignments() const
Gets a const reference to the list of bone assignments.
Definition: OgreMesh.h:422
Real userValue
User-supplied values used to determine when th is lod applies.
Definition: OgreMesh.h:896
Abstract class representing a loadable resource (e.g.
Definition: OgreResource.h:78
unsigned long long int ResourceHandle
Definition: OgreResource.h:40
static const String BLANK
Constant blank string, useful for returning by ref where local does not exist.
Definition: OgreString.h:196
Summary class collecting together vertex source information.
String manualName
Only relevant if mIsLodManual is true, the name of the alternative mesh to use.
Definition: OgreMesh.h:906
bool mBoneAssignmentsOutOfDate
Flag indicating that bone assignments need to be recompiled.
Definition: OgreMesh.h:149
PoseList mPoseList
List of available poses for shared and dedicated geometryPoseList.
Definition: OgreMesh.h:186
multimap< size_t, VertexBoneAssignment >::type VertexBoneAssignmentList
Multimap of vertex bone assignments (orders by vertex index)
Definition: OgreMesh.h:104
vector< Real >::type LodValueList
Definition: OgreMesh.h:101
An animation container interface, which allows generic access to sibling animations.
Definition: OgreAnimation.h:58
Class for providing backwards-compatibility for loading version 1.2 of the .mesh format.
AnimationList mAnimationsList
Definition: OgreMesh.h:177
ConstVectorIterator< PoseList > ConstPoseIterator
Definition: OgreMesh.h:853
Class for providing backwards-compatibility for loading version 1.4 of the .mesh format.
This class contains the information required to describe the edge connectivity of a given set of vert...
Defines a generic resource handler.
Specialisation of SharedPtr to allow SharedPtr to be assigned to SkeletonPtr.
Definition: OgreSkeleton.h:471
bool isVertexBufferShadowed(void) const
Gets whether or not this meshes vertex buffers are shadowed.
Definition: OgreMesh.h:532
VertexBoneAssignmentList mBoneAssignments
Definition: OgreMesh.h:146
_StringBase String
bool isLodManual(void) const
Returns true if this mesh is using manual LOD.
Definition: OgreMesh.h:469
HardwareBuffer::Usage getIndexBufferUsage(void) const
Gets the usage setting for this meshes index buffers.
Definition: OgreMesh.h:530
size_t getPoseCount(void) const
Get the number of poses.
Definition: OgreMesh.h:836
bool mIsLodManual
Definition: OgreMesh.h:161
VectorIterator< SubMeshList > SubMeshIterator
Definition: OgreMesh.h:275
Concrete IteratorWrapper for nonconst access to the underlying container.
Specialisation of SharedPtr to allow SharedPtr to be assigned to MeshPtr.
Definition: OgreMesh.h:875
vector< MeshLodUsage >::type MeshLodUsageList
Definition: OgreMesh.h:102
bool isEdgeListBuilt(void) const
Returns whether this mesh has an attached edge list.
Definition: OgreMesh.h:667
VertexAnimationType
Type of vertex animation.
VectorIterator< PoseList > PoseIterator
Definition: OgreMesh.h:852
String mSkeletonName
Optional linked skeleton.
Definition: OgreMesh.h:142
An animation sequence.
Definition: OgreAnimation.h:90
SubMeshNameMap mSubMeshNameMap
Definition: OgreMesh.h:134
Records the assignment of a single vertex to a single bone with the corresponding weight...
Class for providing backwards-compatibility for loading version 1.1 of the .mesh format.
VertexAnimationType mSharedVertexDataAnimationType
The vertex animation type associated with the shared vertex data.
Definition: OgreMesh.h:179