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 
57  struct MeshLodUsage;
58  struct LodConfig;
59  class LodStrategy;
60 
94  {
95  friend class SubMesh;
96  friend class MeshSerializerImpl;
100 
101  public:
109 
110  protected:
118 
121  VertexElementSemantic targetSemantic, unsigned short index,
122  unsigned short sourceTexCoordSet);
123 
124  public:
128  typedef HashMap<String, ushort> SubMeshNameMap ;
129 
130 
131  protected:
132 
134 
136 
141 
145 
146 
148 
151 
153  void buildIndexMap(const VertexBoneAssignmentList& boneAssignments,
154  IndexMap& boneIndexToBlendIndexMap, IndexMap& blendIndexToBoneIndexMap);
157  unsigned short numBlendWeightsPerVertex,
158  IndexMap& blendIndexToBoneIndexMap,
159  VertexData* targetVertexData);
160 
165 
170 
171 
175 
184  mutable bool mAnimationTypesDirty;
185 
188  mutable bool mPosesIncludeNormals;
189 
190 
196  void prepareImpl(void);
199  void unprepareImpl(void);
201  void loadImpl(void);
203  void postLoadImpl(void);
205  void unloadImpl(void);
207  size_t calculateSize(void) const;
208 
209  void mergeAdjacentTexcoords( unsigned short finalTexCoordSet,
210  unsigned short texCoordSetToDestroy, VertexData *vertexData );
211 
212 
213  public:
218  Mesh(ResourceManager* creator, const String& name, ResourceHandle handle,
219  const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
220  ~Mesh();
221 
222  // NB All methods below are non-virtual since they will be
223  // called in the rendering loop - speed is of the essence.
224 
232 
235  SubMesh* createSubMesh(const String& name);
236 
239  void nameSubMesh(const String& name, ushort index);
240 
243  void unnameSubMesh(const String& name);
244 
250  ushort _getSubMeshIndex(const String& name) const;
251 
254  unsigned short getNumSubMeshes(void) const;
255 
258  SubMesh* getSubMesh(unsigned short index) const;
259 
262  SubMesh* getSubMesh(const String& name) const ;
263 
270  void destroySubMesh(unsigned short index);
271 
278  void destroySubMesh(const String& name);
279 
283  { return SubMeshIterator(mSubMeshList.begin(), mSubMeshList.end()); }
284 
294 
316 
328  MeshPtr clone(const String& newName, const String& newGroup = StringUtil::BLANK);
329 
332  const AxisAlignedBox& getBounds(void) const;
333 
336 
345  void _setBounds(const AxisAlignedBox& bounds, bool pad = true);
346 
355 
367  void setSkeletonName(const String& skelName);
368 
370  bool hasSkeleton(void) const;
371 
374  bool hasVertexAnimation(void) const;
375 
380  const SkeletonPtr& getSkeleton(void) const;
381 
383  const String& getSkeletonName(void) const;
389 
407  void addBoneAssignment(const VertexBoneAssignment& vertBoneAssign);
408 
415 
423 
424 
428 
431  const VertexBoneAssignmentList& getBoneAssignments() const { return mBoneAssignments; }
432 
433 
438  ushort getNumLodLevels(void) const;
440  const MeshLodUsage& getLodLevel(ushort index) const;
456  void createManualLodLevel(Real value, const String& meshName, const String& groupName = Ogre::String());
457 
467  void updateManualLodLevel(ushort index, const String& meshName);
468 
475  ushort getLodIndex(Real value) const;
476 
483  bool isLodManual(void) const { return mIsLodManual; }
484 
486  void _setLodInfo(unsigned short numLevels, bool isManual);
488  void _setLodUsage(unsigned short level, MeshLodUsage& usage);
490  void _setSubMeshLodFaceList(unsigned short subIdx, unsigned short level, IndexData* facedata);
491 
493  void removeLodLevels(void);
494 
519  void setVertexBufferPolicy(HardwareBuffer::Usage usage, bool shadowBuffer = false);
544  void setIndexBufferPolicy(HardwareBuffer::Usage usage, bool shadowBuffer = false);
546  HardwareBuffer::Usage getVertexBufferUsage(void) const { return mVertexBufferUsage; }
548  HardwareBuffer::Usage getIndexBufferUsage(void) const { return mIndexBufferUsage; }
550  bool isVertexBufferShadowed(void) const { return mVertexBufferShadowBuffer; }
552  bool isIndexBufferShadowed(void) const { return mIndexBufferShadowBuffer; }
553 
554 
571  unsigned short _rationaliseBoneAssignments(size_t vertexCount, VertexBoneAssignmentList& assignments);
572 
581 
588 
604  void mergeAdjacentTexcoords( unsigned short finalTexCoordSet, unsigned short texCoordSetToDestroy );
605 
606  void _configureMeshLodUsage(const LodConfig& lodConfig);
607 
641  unsigned short sourceTexCoordSet = 0, unsigned short index = 0,
642  bool splitMirrored = false, bool splitRotated = false, bool storeParityInW = false);
643 
666  unsigned short& outSourceCoordSet, unsigned short& outIndex);
667 
671  void buildEdgeList(void);
673  void freeEdgeList(void);
674 
694 
702  EdgeData* getEdgeList(unsigned short lodIndex = 0);
703 
711  const EdgeData* getEdgeList(unsigned short lodIndex = 0) const;
712 
715  bool isPreparedForShadowVolumes(void) const { return mPreparedForShadowVolumes; }
716 
718  bool isEdgeListBuilt(void) const { return mEdgeListsBuilt; }
719 
734  static void prepareMatricesForVertexBlend(const Matrix4** blendMatrices,
735  const Matrix4* boneMatrices, const IndexMap& indexMap);
736 
760  static void softwareVertexBlend(const VertexData* sourceVertexData,
761  const VertexData* targetVertexData,
762  const Matrix4* const* blendMatrices, size_t numMatrices,
763  bool blendNormals);
764 
781  static void softwareVertexMorph(Real t,
784  VertexData* targetVertexData);
785 
805  static void softwareVertexPoseBlend(Real weight,
806  const map<size_t, Vector3>::type& vertexOffsetMap,
807  const map<size_t, Vector3>::type& normalsMap,
808  VertexData* targetVertexData);
810  const SubMeshNameMap& getSubMeshNameMap(void) const { return mSubMeshNameMap; }
811 
822  void setAutoBuildEdgeLists(bool autobuild) { mAutoBuildEdgeLists = autobuild; }
827  bool getAutoBuildEdgeLists(void) const { return mAutoBuildEdgeLists; }
828 
832 
834  bool getSharedVertexDataAnimationIncludesNormals() const { return mSharedVertexDataAnimationIncludesNormals; }
835 
842  virtual Animation* createAnimation(const String& name, Real length);
843 
848  virtual Animation* getAnimation(const String& name) const;
849 
855  virtual Animation* _getAnimationImpl(const String& name) const;
856 
858  virtual bool hasAnimation(const String& name) const;
859 
861  virtual void removeAnimation(const String& name);
862 
864  virtual unsigned short getNumAnimations(void) const;
865 
868  virtual Animation* getAnimation(unsigned short index) const;
869 
871  virtual void removeAllAnimations(void);
877  VertexData* getVertexDataByTrackHandle(unsigned short handle);
890 
895  void _determineAnimationTypes(void) const;
897  bool _getAnimationTypesDirty(void) const { return mAnimationTypesDirty; }
898 
908  Pose* createPose(ushort target, const String& name = StringUtil::BLANK);
910  size_t getPoseCount(void) const { return mPoseList.size(); }
912  Pose* getPose(ushort index);
914  Pose* getPose(const String& name);
919  void removePose(ushort index);
924  void removePose(const String& name);
926  void removeAllPoses(void);
927 
930 
936  const PoseList& getPoseList(void) const;
937 
939  const LodStrategy *getLodStrategy() const;
941  void setLodStrategy(LodStrategy *lodStrategy);
942 
943  };
944 
947  {
953 
960 
968  mutable EdgeData* edgeData;
969 
970  MeshLodUsage() : userValue(0.0), value(0.0), edgeData(0) {}
971  };
972 
977 } // namespace Ogre
978 
979 #include "OgreHeaderSuffix.h"
980 
981 #endif // __Mesh_H__
#define _OgreExport
Definition: OgrePlatform.h:257
An animation container interface, which allows generic access to sibling animations.
Definition: OgreAnimation.h:59
Class encapsulating a set of AnimationState objects.
An animation sequence.
Definition: OgreAnimation.h:93
A 3D box aligned with the x/y/z axes.
Concrete IteratorWrapper for const access to the underlying container.
This class contains the information required to describe the edge connectivity of a given set of vert...
Usage
Enums describing buffer usage; not mutually exclusive.
Shared pointer implementation used to share vertex buffers.
Summary class collecting together index data source information.
Strategy for determining level of detail.
Interface describing a manual resource loader.
Definition: OgreResource.h:515
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:79
Class for providing backwards-compatibility for loading version 1.1 of the .mesh format.
Class for providing backwards-compatibility for loading version 1.2 of the .mesh format.
Class for providing backwards-compatibility for loading version 1.4 of the .mesh format.
Internal implementation of Mesh reading / writing for the latest version of the .mesh format.
Resource holding data about 3D mesh.
Definition: OgreMesh.h:94
HashMap< String, ushort > SubMeshNameMap
A hashmap used to store optional SubMesh names.
Definition: OgreMesh.h:128
Mesh(ResourceManager *creator, const String &name, ResourceHandle handle, const String &group, bool isManual=false, ManualResourceLoader *loader=0)
Default constructor - used by MeshManager.
void _configureMeshLodUsage(const LodConfig &lodConfig)
const EdgeData * getEdgeList(unsigned short lodIndex=0) const
Return the edge list for this mesh, building it if required.
VertexData * getVertexDataByTrackHandle(unsigned short handle)
Gets a pointer to a vertex data element based on a morph animation track handle.
bool isLodManual(void) const
Returns true if this mesh is using manual LOD.
Definition: OgreMesh.h:483
size_t getPoseCount(void) const
Get the number of poses.
Definition: OgreMesh.h:910
const VertexBoneAssignmentList & getBoneAssignments() const
Gets a const reference to the list of bone assignments.
Definition: OgreMesh.h:431
void removeLodLevels(void)
Removes all LOD data from this Mesh.
void loadImpl(void)
Internal implementation of the meat of the 'load' action, only called if this resource is not being l...
void addBoneAssignment(const VertexBoneAssignment &vertBoneAssign)
Assigns a vertex to a bone with a given weight, for skeletal animation.
const AxisAlignedBox & getBounds(void) const
Get the axis-aligned bounding box for this mesh.
Pose * getPose(ushort index)
Retrieve an existing Pose by index.
SubMeshIterator getSubMeshIterator(void)
Gets an iterator over the available submeshes.
Definition: OgreMesh.h:282
Pose * getPose(const String &name)
Retrieve an existing Pose by name.
ConstVectorIterator< PoseList > ConstPoseIterator
Definition: OgreMesh.h:929
void _setLodInfo(unsigned short numLevels, bool isManual)
Internal methods for loading LOD, do not use.
MeshPtr clone(const String &newName, const String &newGroup=StringUtil::BLANK)
Makes a copy of this mesh object and gives it a new name.
void removeAllPoses(void)
Destroy all poses.
SkeletonPtr mSkeleton
Definition: OgreMesh.h:144
vector< SubMesh * >::type SubMeshList
Definition: OgreMesh.h:107
VertexData * sharedVertexData
Shared vertex data.
Definition: OgreMesh.h:293
bool mPosesIncludeNormals
Definition: OgreMesh.h:188
virtual VertexAnimationType getSharedVertexDataAnimationType(void) const
Gets the type of vertex animation the shared vertex data of this mesh supports.
void setSkeletonName(const String &skelName)
Sets the name of the skeleton this Mesh uses for animation.
SubMesh * createSubMesh(void)
Creates a new SubMesh.
void destroySubMesh(unsigned short index)
Destroy a SubMesh with the given index.
SubMesh * getSubMesh(unsigned short index) const
Gets a pointer to the submesh indicated by the index.
SubMesh * getSubMesh(const String &name) const
Gets a SubMesh by name.
void prepareForShadowVolume(void)
This method prepares the mesh for generating a renderable shadow volume.
virtual Animation * _getAnimationImpl(const String &name) const
Internal access to the named vertex Animation object - returns null if it does not exist.
DataStreamPtr mFreshFromDisk
Definition: OgreMesh.h:133
bool isEdgeListBuilt(void) const
Returns whether this mesh has an attached edge list.
Definition: OgreMesh.h:718
PoseIterator getPoseIterator(void)
Get an iterator over all the poses defined.
const LodStrategy * getLodStrategy() const
Get LOD strategy used by this mesh.
void buildEdgeList(void)
Builds an edge list for this mesh, which can be used for generating a shadow volume among other thing...
void _compileBoneAssignments(void)
Internal method, be called once to compile bone assignments into geometry buffer.
void _notifySkeleton(SkeletonPtr &pSkel)
Internal notification, used to tell the Mesh which Skeleton to use without loading it.
const SkeletonPtr & getSkeleton(void) const
Gets a pointer to any linked Skeleton.
void _setLodUsage(unsigned short level, MeshLodUsage &usage)
Internal methods for loading LOD, do not use.
bool isPreparedForShadowVolumes(void) const
Returns whether this mesh has already had it's geometry prepared for use in rendering shadow volumes.
Definition: OgreMesh.h:715
virtual void removeAnimation(const String &name)
Removes vertex Animation from this mesh.
bool mVertexBufferShadowBuffer
Definition: OgreMesh.h:168
vector< unsigned short >::type IndexMap
Definition: OgreMesh.h:108
HardwareBuffer::Usage mVertexBufferUsage
Definition: OgreMesh.h:166
map< String, Animation * >::type AnimationList
Storage of morph animations, lookup by name.
Definition: OgreMesh.h:177
void _setBoundingSphereRadius(Real radius)
Manually set the bounding radius.
ushort mNumLods
Definition: OgreMesh.h:163
void setIndexBufferPolicy(HardwareBuffer::Usage usage, bool shadowBuffer=false)
Sets the policy for the index buffers to be used when loading this Mesh.
static void softwareVertexBlend(const VertexData *sourceVertexData, const VertexData *targetVertexData, const Matrix4 *const *blendMatrices, size_t numMatrices, bool blendNormals)
Performs a software indexed vertex blend, of the kind used for skeletal animation although it can be ...
SubMeshNameMap mSubMeshNameMap
Definition: OgreMesh.h:135
const String & getSkeletonName(void) const
Gets the name of any linked Skeleton.
void _setSubMeshLodFaceList(unsigned short subIdx, unsigned short level, IndexData *facedata)
Internal methods for loading LOD, do not use.
virtual Animation * getAnimation(unsigned short index) const
Gets a single morph animation by index.
Real getBoundingSphereRadius(void) const
Gets the radius of the bounding sphere surrounding this mesh.
void unnameSubMesh(const String &name)
Removes a name from a SubMesh.
SubMesh * createSubMesh(const String &name)
Creates a new SubMesh and gives it a name.
bool suggestTangentVectorBuildParams(VertexElementSemantic targetSemantic, unsigned short &outSourceCoordSet, unsigned short &outIndex)
Ask the mesh to suggest parameters to a future buildTangentVectors call, should you wish to use textu...
VertexAnimationType mSharedVertexDataAnimationType
The vertex animation type associated with the shared vertex data.
Definition: OgreMesh.h:180
bool _getAnimationTypesDirty(void) const
Are the derived animation types out of date?
Definition: OgreMesh.h:897
void setLodStrategy(LodStrategy *lodStrategy)
Set the LOD strategy used by this mesh.
bool mPreparedForShadowVolumes
Definition: OgreMesh.h:172
void removePose(const String &name)
Destroy a pose by name.
unsigned short _rationaliseBoneAssignments(size_t vertexCount, VertexBoneAssignmentList &assignments)
Rationalises the passed in bone assignment list.
BoneAssignmentIterator getBoneAssignmentIterator(void)
Gets an iterator for access all bone assignments.
Pose * createPose(ushort target, const String &name=StringUtil::BLANK)
Create a new Pose for this mesh or one of its submeshes.
HardwareBuffer::Usage getVertexBufferUsage(void) const
Gets the usage setting for this meshes vertex buffers.
Definition: OgreMesh.h:546
const SubMeshNameMap & getSubMeshNameMap(void) const
Gets a reference to the optional name assignments of the SubMeshes.
Definition: OgreMesh.h:810
void _refreshAnimationState(AnimationStateSet *animSet)
Refresh an animation set suitable for use with this mesh.
VectorIterator< PoseList > PoseIterator
Definition: OgreMesh.h:928
void organiseTangentsBuffer(VertexData *vertexData, VertexElementSemantic targetSemantic, unsigned short index, unsigned short sourceTexCoordSet)
Internal method for making the space for a vertex element to hold tangents.
virtual bool hasAnimation(const String &name) const
Returns whether this mesh contains the named vertex animation.
SubMeshList mSubMeshList
A list of submeshes which make up this mesh.
Definition: OgreMesh.h:117
vector< Real >::type LodValueList
Definition: OgreMesh.h:102
void postLoadImpl(void)
Internal hook to perform actions after the load process, but before the resource has been marked as f...
unsigned short getNumSubMeshes(void) const
Gets the number of sub meshes which comprise this mesh.
virtual Animation * createAnimation(const String &name, Real length)
Creates a new Animation object for vertex animating this mesh.
void removePose(ushort index)
Destroy a pose by index.
bool getAutoBuildEdgeLists(void) const
Sets whether or not this Mesh should automatically build edge lists when asked for them,...
Definition: OgreMesh.h:827
PoseList mPoseList
List of available poses for shared and dedicated geometryPoseList.
Definition: OgreMesh.h:187
void _initAnimationState(AnimationStateSet *animSet)
Initialise an animation set suitable for use with this mesh.
void unloadImpl(void)
Internal implementation of the 'unload' action; called regardless of whether this resource is being l...
MapIterator< VertexBoneAssignmentList > BoneAssignmentIterator
Definition: OgreMesh.h:106
void _setBounds(const AxisAlignedBox &bounds, bool pad=true)
Manually set the bounding box for this Mesh.
bool mEdgeListsBuilt
Definition: OgreMesh.h:173
bool mSharedVertexDataAnimationIncludesNormals
Whether vertex animation includes normals.
Definition: OgreMesh.h:182
virtual unsigned short getNumAnimations(void) const
Gets the number of morph animations in this mesh.
bool isVertexBufferShadowed(void) const
Gets whether or not this meshes vertex buffers are shadowed.
Definition: OgreMesh.h:550
void unprepareImpl(void)
Destroys data cached by prepareImpl.
void nameSubMesh(const String &name, ushort index)
Gives a name to a SubMesh.
AxisAlignedBox mAABB
Local bounding box volume.
Definition: OgreMesh.h:138
virtual Animation * getAnimation(const String &name) const
Returns the named vertex Animation object.
bool mIsLodManual
Definition: OgreMesh.h:162
EdgeData * getEdgeList(unsigned short lodIndex=0)
Return the edge list for this mesh, building it if required.
void mergeAdjacentTexcoords(unsigned short finalTexCoordSet, unsigned short texCoordSetToDestroy)
This method collapses two texcoords into one for all submeshes where this is possible.
void updateMaterialForAllSubMeshes(void)
Iterates through all submeshes and requests them to apply their texture aliases to the material they ...
void createManualLodLevel(Real value, const String &meshName, const String &groupName=Ogre::String())
Adds a new manual level-of-detail entry to this Mesh.
ushort _getSubMeshIndex(const String &name) const
Gets the index of a submesh with a given name.
void destroySubMesh(const String &name)
Destroy a SubMesh with the given name.
ConstPoseIterator getPoseIterator(void) const
Get an iterator over all the poses defined.
IndexMap sharedBlendIndexToBoneIndexMap
Shared index map for translating blend index to bone index.
Definition: OgreMesh.h:315
const LodStrategy * mLodStrategy
Definition: OgreMesh.h:161
size_t calculateSize(void) const
Calculate the size of a resource; this will only be called after 'load'.
void mergeAdjacentTexcoords(unsigned short finalTexCoordSet, unsigned short texCoordSetToDestroy, VertexData *vertexData)
void compileBoneAssignments(const VertexBoneAssignmentList &boneAssignments, unsigned short numBlendWeightsPerVertex, IndexMap &blendIndexToBoneIndexMap, VertexData *targetVertexData)
Compile bone assignments into blend index and weight buffers.
void buildTangentVectors(VertexElementSemantic targetSemantic=VES_TANGENT, unsigned short sourceTexCoordSet=0, unsigned short index=0, bool splitMirrored=false, bool splitRotated=false, bool storeParityInW=false)
This method builds a set of tangent vectors for a given mesh into a 3D texture coordinate buffer.
bool hasSkeleton(void) const
Returns true if this Mesh has a linked Skeleton.
bool mIndexBufferShadowBuffer
Definition: OgreMesh.h:169
String mSkeletonName
Optional linked skeleton.
Definition: OgreMesh.h:143
bool hasVertexAnimation(void) const
Returns whether or not this mesh has some kind of vertex animation.
void _updateCompiledBoneAssignments(void)
Internal method, be called once to update the compiled bone assignments.
VectorIterator< SubMeshList > SubMeshIterator
Definition: OgreMesh.h:280
void setAutoBuildEdgeLists(bool autobuild)
Sets whether or not this Mesh should automatically build edge lists when asked for them,...
Definition: OgreMesh.h:822
void prepareImpl(void)
Loads the mesh from disk.
AnimationList mAnimationsList
Definition: OgreMesh.h:178
static void softwareVertexPoseBlend(Real weight, const map< size_t, Vector3 >::type &vertexOffsetMap, const map< size_t, Vector3 >::type &normalsMap, VertexData *targetVertexData)
Performs a software vertex pose blend, of the kind used for morph animation although it can be used f...
void updateManualLodLevel(ushort index, const String &meshName)
Changes the alternate mesh to use as a manual LOD at the given index.
multimap< size_t, VertexBoneAssignment >::type VertexBoneAssignmentList
Multimap of vertex bone assignments (orders by vertex index).
Definition: OgreMesh.h:105
bool mAnimationTypesDirty
Do we need to scan animations for animation types?
Definition: OgreMesh.h:184
void _determineAnimationTypes(void) const
Internal method which, if animation types have not been determined, scans any vertex animations and d...
const MeshLodUsage & getLodLevel(ushort index) const
Gets details of the numbered level of detail entry.
ushort getLodIndex(Real value) const
Retrieves the level of detail index for the given LOD value.
MeshLodUsageList mMeshLodUsageList
Definition: OgreMesh.h:164
void buildIndexMap(const VertexBoneAssignmentList &boneAssignments, IndexMap &boneIndexToBlendIndexMap, IndexMap &blendIndexToBoneIndexMap)
Build the index map between bone index and blend index.
void clearBoneAssignments(void)
Removes all bone assignments for this mesh.
void setVertexBufferPolicy(HardwareBuffer::Usage usage, bool shadowBuffer=false)
Sets the policy for the vertex buffers to be used when loading this Mesh.
virtual void removeAllAnimations(void)
Removes all morph Animations from this mesh.
bool getSharedVertexDataAnimationIncludesNormals() const
Returns whether animation on shared vertex data includes normals.
Definition: OgreMesh.h:834
HardwareBuffer::Usage mIndexBufferUsage
Definition: OgreMesh.h:167
bool mBoneAssignmentsOutOfDate
Flag indicating that bone assignments need to be recompiled.
Definition: OgreMesh.h:150
bool mAutoBuildEdgeLists
Definition: OgreMesh.h:174
void freeEdgeList(void)
Destroys and frees the edge lists this mesh has built.
VertexBoneAssignmentList mBoneAssignments
Definition: OgreMesh.h:147
ushort getNumLodLevels(void) const
Returns the number of levels of detail that this mesh supports.
const PoseList & getPoseList(void) const
Get pose list.
bool isIndexBufferShadowed(void) const
Gets whether or not this meshes index buffers are shadowed.
Definition: OgreMesh.h:552
static void softwareVertexMorph(Real t, const HardwareVertexBufferSharedPtr &b1, const HardwareVertexBufferSharedPtr &b2, VertexData *targetVertexData)
Performs a software vertex morph, of the kind used for morph animation although it can be used for ot...
HardwareBuffer::Usage getIndexBufferUsage(void) const
Gets the usage setting for this meshes index buffers.
Definition: OgreMesh.h:548
static void prepareMatricesForVertexBlend(const Matrix4 **blendMatrices, const Matrix4 *boneMatrices, const IndexMap &indexMap)
Prepare matrices for software indexed vertex blend.
Real mBoundRadius
Local bounding sphere radius (centered on object).
Definition: OgreMesh.h:140
vector< MeshLodUsage >::type MeshLodUsageList
Definition: OgreMesh.h:103
A pose is a linked set of vertex offsets applying to one set of vertex data.
Definition: OgrePose.h:56
Defines a generic resource handler.
Abstract class representing a loadable resource (e.g.
Definition: OgreResource.h:80
static const String BLANK
Constant blank string, useful for returning by ref where local does not exist.
Definition: OgreString.h:196
Defines a part of a complete mesh.
Definition: OgreSubMesh.h:63
Concrete IteratorWrapper for nonconst access to the underlying container.
Summary class collecting together vertex source information.
vector< Pose * >::type PoseList
Definition: OgrePose.h:135
VertexAnimationType
Type of vertex animation.
VertexElementSemantic
Vertex element semantics, used to identify the meaning of vertex buffer contents.
@ VES_TANGENT
Tangent (X axis if normal is Z)
float Real
Software floating point type.
unsigned long long int ResourceHandle
Definition: OgreResource.h:41
_StringBase String
unsigned short ushort
A way of recording the way each LODs is recorded this Mesh.
Definition: OgreMesh.h:947
Real userValue
User-supplied values used to determine when th is LOD applies.
Definition: OgreMesh.h:952
MeshPtr manualMesh
Hard link to mesh to avoid looking up each time.
Definition: OgreMesh.h:966
Real value
Value used by to determine when this LOD applies.
Definition: OgreMesh.h:959
String manualName
Only relevant if mIsLodManual is true, the name of the alternative mesh to use.
Definition: OgreMesh.h:962
String manualGroup
Only relevant if mIsLodManual is true, the name of the group of the alternative mesh.
Definition: OgreMesh.h:964
EdgeData * edgeData
Edge list for this LOD level (may be derived from manual mesh).
Definition: OgreMesh.h:968
Records the assignment of a single vertex to a single bone with the corresponding weight.

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.