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-2013 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 __Mesh_H__
#define __Mesh_H__
#include "OgrePrerequisites.h"
#include "OgreResource.h"
#include "OgreVertexIndexData.h"
#include "OgreAxisAlignedBox.h"
#include "OgreVertexBoneAssignment.h"
#include "OgreIteratorWrappers.h"
#include "OgreHardwareVertexBuffer.h"
#include "OgreSkeleton.h"
#include "OgreAnimation.h"
#include "OgreAnimationTrack.h"
#include "OgrePose.h"
#include "OgreDataStream.h"
#include "OgreHeaderPrefix.h"
namespace Ogre {
struct MeshLodUsage;
struct LodConfig;
class LodStrategy;
class _OgreExport Mesh: public Resource, public AnimationContainer
{
friend class SubMesh;
friend class MeshSerializerImpl;
friend class MeshSerializerImpl_v1_4;
friend class MeshSerializerImpl_v1_2;
friend class MeshSerializerImpl_v1_1;
public:
typedef vector<Real>::type LodValueList;
typedef vector<MeshLodUsage>::type MeshLodUsageList;
typedef multimap<size_t, VertexBoneAssignment>::type VertexBoneAssignmentList;
typedef MapIterator<VertexBoneAssignmentList> BoneAssignmentIterator;
typedef vector<SubMesh*>::type SubMeshList;
typedef vector<unsigned short>::type IndexMap;
protected:
SubMeshList mSubMeshList;
void organiseTangentsBuffer(VertexData *vertexData,
VertexElementSemantic targetSemantic, unsigned short index,
unsigned short sourceTexCoordSet);
public:
typedef HashMap<String, ushort> SubMeshNameMap ;
protected:
DataStreamPtr mFreshFromDisk;
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);
const LodStrategy *mLodStrategy;
bool mIsLodManual;
ushort mNumLods;
MeshLodUsageList mMeshLodUsageList;
HardwareBuffer::Usage mVertexBufferUsage;
HardwareBuffer::Usage mIndexBufferUsage;
bool mVertexBufferShadowBuffer;
bool mIndexBufferShadowBuffer;
bool mPreparedForShadowVolumes;
bool mEdgeListsBuilt;
bool mAutoBuildEdgeLists;
typedef map<String, Animation*>::type AnimationList;
AnimationList mAnimationsList;
mutable VertexAnimationType mSharedVertexDataAnimationType;
mutable bool mSharedVertexDataAnimationIncludesNormals;
mutable bool mAnimationTypesDirty;
PoseList mPoseList;
mutable bool mPosesIncludeNormals;
void prepareImpl(void);
void unprepareImpl(void);
void loadImpl(void);
void postLoadImpl(void);
void unloadImpl(void);
size_t calculateSize(void) const;
void mergeAdjacentTexcoords( unsigned short finalTexCoordSet,
unsigned short texCoordSetToDestroy, VertexData *vertexData );
public:
Mesh(ResourceManager* creator, const String& name, ResourceHandle handle,
const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
~Mesh();
// 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);
void unnameSubMesh(const String& name);
ushort _getSubMeshIndex(const String& name) const;
unsigned short getNumSubMeshes(void) const;
SubMesh* getSubMesh(unsigned short index) const;
SubMesh* getSubMesh(const String& name) const ;
void destroySubMesh(unsigned short index);
void destroySubMesh(const String& name);
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 _refreshAnimationState(AnimationStateSet* animSet);
void addBoneAssignment(const VertexBoneAssignment& vertBoneAssign);
void clearBoneAssignments(void);
void _notifySkeleton(SkeletonPtr& pSkel);
BoneAssignmentIterator getBoneAssignmentIterator(void);
const VertexBoneAssignmentList& getBoneAssignments() const { return mBoneAssignments; }
ushort getNumLodLevels(void) const;
const MeshLodUsage& getLodLevel(ushort index) const;
void createManualLodLevel(Real value, const String& meshName, const String& groupName = Ogre::String());
void updateManualLodLevel(ushort index, const String& meshName);
ushort getLodIndex(Real value) 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 mergeAdjacentTexcoords( unsigned short finalTexCoordSet, unsigned short texCoordSetToDestroy );
void _configureMeshLodUsage(const LodConfig& lodConfig);
void buildTangentVectors(VertexElementSemantic targetSemantic = VES_TANGENT,
unsigned short sourceTexCoordSet = 0, unsigned short index = 0,
bool splitMirrored = false, bool splitRotated = false, bool storeParityInW = false);
bool suggestTangentVectorBuildParams(VertexElementSemantic targetSemantic,
unsigned short& outSourceCoordSet, unsigned short& outIndex);
void buildEdgeList(void);
void freeEdgeList(void);
void prepareForShadowVolume(void);
EdgeData* getEdgeList(unsigned short lodIndex = 0);
const EdgeData* getEdgeList(unsigned short lodIndex = 0) const;
bool isPreparedForShadowVolumes(void) const { return mPreparedForShadowVolumes; }
bool isEdgeListBuilt(void) const { return mEdgeListsBuilt; }
static void prepareMatricesForVertexBlend(const Matrix4** blendMatrices,
const Matrix4* boneMatrices, const IndexMap& indexMap);
static void softwareVertexBlend(const VertexData* sourceVertexData,
const VertexData* targetVertexData,
const Matrix4* const* blendMatrices, size_t numMatrices,
bool blendNormals);
static void softwareVertexMorph(Real t,
const HardwareVertexBufferSharedPtr& b1,
const HardwareVertexBufferSharedPtr& b2,
VertexData* targetVertexData);
static void softwareVertexPoseBlend(Real weight,
const map<size_t, Vector3>::type& vertexOffsetMap,
const map<size_t, Vector3>::type& normalsMap,
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;
bool getSharedVertexDataAnimationIncludesNormals() const { return mSharedVertexDataAnimationIncludesNormals; }
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) const;
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;
const LodStrategy *getLodStrategy() const;
void setLodStrategy(LodStrategy *lodStrategy);
};
struct MeshLodUsage
{
Real userValue;
Real value;
String manualName;
String manualGroup;
mutable MeshPtr manualMesh;
mutable EdgeData* edgeData;
MeshLodUsage() : userValue(0.0), value(0.0), edgeData(0) {}
};
} // namespace Ogre
#include "OgreHeaderSuffix.h"
#endif // __Mesh_H__
Ogre::Mesh::sharedBlendIndexToBoneIndexMap
IndexMap sharedBlendIndexToBoneIndexMap
Shared index map for translating blend index to bone index.
Definition: OgreMesh.h:315
Ogre::MeshLodUsage
A way of recording the way each LODs is recorded this Mesh.
Definition: OgreMesh.h:946
Ogre::Mesh::isLodManual
bool isLodManual(void) const
Returns true if this mesh is using manual LOD.
Definition: OgreMesh.h:483
OgreSkeleton.h
Ogre::VectorIterator
Concrete IteratorWrapper for nonconst access to the underlying container.
Definition: OgreIteratorWrapper.h:186
Ogre::Mesh::setAutoBuildEdgeLists
void setAutoBuildEdgeLists(bool autobuild)
Sets whether or not this Mesh should automatically build edge lists when asked for them...
Definition: OgreMesh.h:822
Ogre::Mesh::isEdgeListBuilt
bool isEdgeListBuilt(void) const
Returns whether this mesh has an attached edge list.
Definition: OgreMesh.h:718
OgreAxisAlignedBox.h
_OgreExport
#define _OgreExport
Definition: OgrePlatform.h:257
Ogre::MeshLodUsage::manualName
String manualName
Only relevant if mIsLodManual is true, the name of the alternative mesh to use.
Definition: OgreMesh.h:962
Ogre::MeshLodUsage::value
Real value
Value used by to determine when this LOD applies.
Definition: OgreMesh.h:959
OgreResource.h
Ogre::LodStrategy
Strategy for determining level of detail.
Definition: OgreLodStrategy.h:54
Ogre::Mesh::mSharedVertexDataAnimationType
VertexAnimationType mSharedVertexDataAnimationType
The vertex animation type associated with the shared vertex data.
Definition: OgreMesh.h:180
Ogre::PoseList
vector< Pose * >::type PoseList
Definition: OgrePose.h:135
Ogre::Mesh::getSubMeshIterator
SubMeshIterator getSubMeshIterator(void)
Gets an iterator over the available submeshes.
Definition: OgreMesh.h:282
Ogre::Mesh::PoseIterator
VectorIterator< PoseList > PoseIterator
Definition: OgreMesh.h:928
Ogre::Mesh::mPreparedForShadowVolumes
bool mPreparedForShadowVolumes
Definition: OgreMesh.h:172
Ogre::VertexData
Summary class collecting together vertex source information.
Definition: OgreVertexIndexData.h:49
Ogre::Mesh::mNumLods
ushort mNumLods
Definition: OgreMesh.h:163
Ogre::Mesh::mBoundRadius
Real mBoundRadius
Local bounding sphere radius (centered on object).
Definition: OgreMesh.h:140
Ogre::MapIterator
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
Definition: OgreIteratorWrapper.h:319
Ogre::Mesh::SubMeshList
vector< SubMesh * >::type SubMeshList
Definition: OgreMesh.h:107
Ogre::Mesh::mSkeleton
SkeletonPtr mSkeleton
Definition: OgreMesh.h:144
Ogre::Mesh::mIndexBufferUsage
HardwareBuffer::Usage mIndexBufferUsage
Definition: OgreMesh.h:167
Ogre::Mesh::VertexBoneAssignmentList
multimap< size_t, VertexBoneAssignment >::type VertexBoneAssignmentList
Multimap of vertex bone assignments (orders by vertex index).
Definition: OgreMesh.h:105
Ogre::Real
float Real
Software floating point type.
Definition: OgrePrerequisites.h:70
Ogre::Mesh::mSubMeshList
SubMeshList mSubMeshList
A list of submeshes which make up this mesh.
Definition: OgreMesh.h:117
Ogre::IndexData
Summary class collecting together index data source information.
Definition: OgreVertexIndexData.h:242
Ogre::Mesh::isVertexBufferShadowed
bool isVertexBufferShadowed(void) const
Gets whether or not this meshes vertex buffers are shadowed.
Definition: OgreMesh.h:550
Ogre::Resource
Abstract class representing a loadable resource (e.g.
Definition: OgreResource.h:79
Ogre::Mesh::getSharedVertexDataAnimationIncludesNormals
bool getSharedVertexDataAnimationIncludesNormals() const
Returns whether animation on shared vertex data includes normals.
Definition: OgreMesh.h:834
Ogre::MeshSerializerImpl_v1_2
Class for providing backwards-compatibility for loading version 1.2 of the .mesh format.
Definition: OgreMeshSerializerImpl.h:238
Ogre::ManualResourceLoader
Interface describing a manual resource loader.
Definition: OgreResource.h:514
OgreDataStream.h
Ogre::ResourceHandle
unsigned long long int ResourceHandle
Definition: OgreResource.h:41
OgreAnimationTrack.h
Ogre::Mesh::mPosesIncludeNormals
bool mPosesIncludeNormals
Definition: OgreMesh.h:188
Ogre::EdgeData
This class contains the information required to describe the edge connectivity of a given set of vert...
Definition: OgreEdgeListBuilder.h:52
OgreVertexBoneAssignment.h
Ogre::Mesh::getBoneAssignments
const VertexBoneAssignmentList & getBoneAssignments() const
Gets a const reference to the list of bone assignments.
Definition: OgreMesh.h:431
Ogre::Mesh::mIsLodManual
bool mIsLodManual
Definition: OgreMesh.h:162
Ogre::SubMesh
Defines a part of a complete mesh.
Definition: OgreSubMesh.h:62
Ogre::Mesh::SubMeshIterator
VectorIterator< SubMeshList > SubMeshIterator
Definition: OgreMesh.h:280
Ogre::AnimationContainer
An animation container interface, which allows generic access to sibling animations.
Definition: OgreAnimation.h:58
Ogre::AnimationStateSet
Class encapsulating a set of AnimationState objects.
Definition: OgreAnimationState.h:196
Ogre::Mesh::mPoseList
PoseList mPoseList
List of available poses for shared and dedicated geometryPoseList.
Definition: OgreMesh.h:187
OgreVertexIndexData.h
Ogre::Matrix4
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
Ogre::Mesh::mAnimationTypesDirty
bool mAnimationTypesDirty
Do we need to scan animations for animation types?
Definition: OgreMesh.h:184
Ogre::Mesh::mBoneAssignments
VertexBoneAssignmentList mBoneAssignments
Definition: OgreMesh.h:147
Ogre::HardwareVertexBufferSharedPtr
Shared pointer implementation used to share vertex buffers.
Definition: OgreHardwareVertexBuffer.h:86
Ogre::Mesh::sharedVertexData
VertexData * sharedVertexData
Shared vertex data.
Definition: OgreMesh.h:293
Ogre::VertexAnimationType
VertexAnimationType
Type of vertex animation.
Definition: OgreAnimationTrack.h:467
OgrePrerequisites.h
Ogre::MeshSerializerImpl_v1_4
Class for providing backwards-compatibility for loading version 1.4 of the .mesh format.
Definition: OgreMeshSerializerImpl.h:204
Ogre::Mesh::MeshLodUsageList
vector< MeshLodUsage >::type MeshLodUsageList
Definition: OgreMesh.h:103
Ogre::Mesh::mAutoBuildEdgeLists
bool mAutoBuildEdgeLists
Definition: OgreMesh.h:174
Ogre::MeshLodUsage::manualGroup
String manualGroup
Only relevant if mIsLodManual is true, the name of the group of the alternative mesh.
Definition: OgreMesh.h:964
Ogre::Mesh::isIndexBufferShadowed
bool isIndexBufferShadowed(void) const
Gets whether or not this meshes index buffers are shadowed.
Definition: OgreMesh.h:552
Ogre::MeshSerializerImpl_v1_1
Class for providing backwards-compatibility for loading version 1.1 of the .mesh format.
Definition: OgreMeshSerializerImpl.h:259
Ogre::Mesh::LodValueList
vector< Real >::type LodValueList
Definition: OgreMesh.h:102
Ogre::Mesh::mBoneAssignmentsOutOfDate
bool mBoneAssignmentsOutOfDate
Flag indicating that bone assignments need to be recompiled.
Definition: OgreMesh.h:150
Ogre::Animation
An animation sequence.
Definition: OgreAnimation.h:92
Ogre::Mesh::mMeshLodUsageList
MeshLodUsageList mMeshLodUsageList
Definition: OgreMesh.h:164
Ogre::Mesh::SubMeshNameMap
HashMap< String, ushort > SubMeshNameMap
A hashmap used to store optional SubMesh names.
Definition: OgreMesh.h:128
Ogre::Mesh
Resource holding data about 3D mesh.
Definition: OgreMesh.h:93
Ogre::HardwareBuffer::Usage
Usage
Enums describing buffer usage; not mutually exclusive.
Definition: OgreHardwareBuffer.h:79
OgreHardwareVertexBuffer.h
Ogre::Mesh::mSharedVertexDataAnimationIncludesNormals
bool mSharedVertexDataAnimationIncludesNormals
Whether vertex animation includes normals.
Definition: OgreMesh.h:182
Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:439
Ogre::VertexElementSemantic
VertexElementSemantic
Vertex element semantics, used to identify the meaning of vertex buffer contents. ...
Definition: OgreHardwareVertexBuffer.h:99
Ogre::Mesh::mAnimationsList
AnimationList mAnimationsList
Definition: OgreMesh.h:178
Ogre::Mesh::getSubMeshNameMap
const SubMeshNameMap & getSubMeshNameMap(void) const
Gets a reference to the optional name assignments of the SubMeshes.
Definition: OgreMesh.h:810
Ogre::Mesh::mVertexBufferUsage
HardwareBuffer::Usage mVertexBufferUsage
Definition: OgreMesh.h:166
Ogre::Mesh::mEdgeListsBuilt
bool mEdgeListsBuilt
Definition: OgreMesh.h:173
Ogre::VES_TANGENT
Tangent (X axis if normal is Z)
Definition: OgreHardwareVertexBuffer.h:117
Ogre::MeshLodUsage::edgeData
EdgeData * edgeData
Edge list for this LOD level (may be derived from manual mesh).
Definition: OgreMesh.h:968
OgreHeaderSuffix.h
Ogre::ResourceManager
Defines a generic resource handler.
Definition: OgreResourceManager.h:122
Ogre::Mesh::mSkeletonName
String mSkeletonName
Optional linked skeleton.
Definition: OgreMesh.h:143
OgreIteratorWrappers.h
Ogre::MeshLodUsage::MeshLodUsage
MeshLodUsage()
Definition: OgreMesh.h:970
Ogre
Definition: OgreAndroidLogListener.h:34
Ogre::Mesh::AnimationList
map< String, Animation * >::type AnimationList
Storage of morph animations, lookup by name.
Definition: OgreMesh.h:177
Ogre::Mesh::mLodStrategy
const LodStrategy * mLodStrategy
Definition: OgreMesh.h:161
Ogre::MeshSerializerImpl
Internal implementation of Mesh reading / writing for the latest version of the .mesh format...
Definition: OgreMeshSerializerImpl.h:61
Ogre::LodConfig
Definition: OgreLodConfig.h:104
Ogre::Mesh::mIndexBufferShadowBuffer
bool mIndexBufferShadowBuffer
Definition: OgreMesh.h:169
Ogre::Mesh::ConstPoseIterator
ConstVectorIterator< PoseList > ConstPoseIterator
Definition: OgreMesh.h:929
Ogre::Mesh::getAutoBuildEdgeLists
bool getAutoBuildEdgeLists(void) const
Sets whether or not this Mesh should automatically build edge lists when asked for them...
Definition: OgreMesh.h:827
OgrePose.h
Ogre::SharedPtr< DataStream >
Ogre::ConstVectorIterator
Concrete IteratorWrapper for const access to the underlying container.
Definition: OgreIteratorWrapper.h:217
Ogre::vector
Definition: OgrePrerequisites.h:491
Ogre::Mesh::mSubMeshNameMap
SubMeshNameMap mSubMeshNameMap
Definition: OgreMesh.h:135
OgreAnimation.h
Ogre::MeshLodUsage::userValue
Real userValue
User-supplied values used to determine when th is LOD applies.
Definition: OgreMesh.h:952
OgreHeaderPrefix.h
Ogre::VertexBoneAssignment_s
Records the assignment of a single vertex to a single bone with the corresponding weight...
Definition: OgreVertexBoneAssignment.h:50
Ogre::Mesh::BoneAssignmentIterator
MapIterator< VertexBoneAssignmentList > BoneAssignmentIterator
Definition: OgreMesh.h:106
Ogre::map
Definition: OgrePrerequisites.h:533
Ogre::ushort
unsigned short ushort
Definition: OgrePrerequisites.h:113
Ogre::Mesh::mAABB
AxisAlignedBox mAABB
Local bounding box volume.
Definition: OgreMesh.h:138
Ogre::Mesh::_getAnimationTypesDirty
bool _getAnimationTypesDirty(void) const
Are the derived animation types out of date?
Definition: OgreMesh.h:897
Ogre::Mesh::IndexMap
vector< unsigned short >::type IndexMap
Definition: OgreMesh.h:108
Ogre::Mesh::getPoseCount
size_t getPoseCount(void) const
Get the number of poses.
Definition: OgreMesh.h:910
Ogre::Mesh::getIndexBufferUsage
HardwareBuffer::Usage getIndexBufferUsage(void) const
Gets the usage setting for this meshes index buffers.
Definition: OgreMesh.h:548
Ogre::Mesh::mVertexBufferShadowBuffer
bool mVertexBufferShadowBuffer
Definition: OgreMesh.h:168
Ogre::AxisAlignedBox
A 3D box aligned with the x/y/z axes.
Definition: OgreAxisAlignedBox.h:54
Ogre::Mesh::isPreparedForShadowVolumes
bool isPreparedForShadowVolumes(void) const
Returns whether this mesh has already had it&#39;s geometry prepared for use in rendering shadow volumes...
Definition: OgreMesh.h:715
Ogre::Mesh::mFreshFromDisk
DataStreamPtr mFreshFromDisk
Definition: OgreMesh.h:133
Ogre::StringUtil::BLANK
static const String BLANK
Constant blank string, useful for returning by ref where local does not exist.
Definition: OgreString.h:196
Ogre::Mesh::getVertexBufferUsage
HardwareBuffer::Usage getVertexBufferUsage(void) const
Gets the usage setting for this meshes vertex buffers.
Definition: OgreMesh.h:546
Ogre::Pose
A pose is a linked set of vertex offsets applying to one set of vertex data.
Definition: OgrePose.h:55
Ogre::multimap
Definition: OgrePrerequisites.h:547
Ogre::MeshLodUsage::manualMesh
MeshPtr manualMesh
Hard link to mesh to avoid looking up each time.
Definition: OgreMesh.h:966

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