OGRE  1.7
Object-Oriented Graphics Rendering Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
OgreInstancedGeometry.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-2011 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 __InstancedGeometry_H__
29 #define __InstancedGeometry_H__
30 
31 #include "OgrePrerequisites.h"
32 #include "OgreMovableObject.h"
33 #include "OgreSimpleRenderable.h"
34 #include "OgreSkeleton.h"
35 #include "OgreSkeletonInstance.h"
36 #include "OgreAnimationTrack.h"
37 #include "OgreBone.h"
38 #include "OgreIteratorWrappers.h"
39 #include "OgreMesh.h"
40 
41 namespace Ogre {
42 
105  {
106  public:
120  {
121  public:
122  OptimisedSubMeshGeometry() :vertexData(0), indexData(0) {}
124  {
125  delete vertexData;
126  delete indexData;
127  }
130  };
135  {
138  };
143  {
153  unsigned int ID;
154  };
159  {
164  unsigned int ID;
165  };
167 
168  // forward declarations
169  class LODBucket;
170  class MaterialBucket;
171  class BatchInstance;
172  class InstancedObject;
173 
179  {
180  protected:
181 
201  unsigned short mTexCoordIndex;
203 
204  template<typename T>
205  void copyIndexes(const T* src, T* dst, size_t count, size_t indexOffset)
206  {
207  if (indexOffset == 0)
208  {
209  memcpy(dst, src, sizeof(T) * count);
210  }
211  else
212  {
213  while(count--)
214  {
215  *dst++ = static_cast<T>(*src++ + indexOffset);
216  }
217  }
218  }
219  public:
220  GeometryBucket(MaterialBucket* parent, const String& formatString,
221  const VertexData* vData, const IndexData* iData);
222  GeometryBucket(MaterialBucket* parent,const String& formatString,GeometryBucket*bucket);
223  virtual ~GeometryBucket();
224  MaterialBucket* getParent(void) { return mParent; }
225  Real getBoundingRadius(void) const;
227  const VertexData* getVertexData(void) const { return mVertexData; }
229  const IndexData* getIndexData(void) const { return mIndexData; }
231  const MaterialPtr& getMaterial(void) const;
232  Technique* getTechnique(void) const;
233  void getWorldTransforms(Matrix4* xform) const;
234  virtual unsigned short getNumWorldTransforms(void) const ;
235  Real getSquaredViewDepth(const Camera* cam) const;
236  const LightList& getLights(void) const;
237  bool getCastsShadows(void) const;
238  String getFormatString(void) const;
242  bool assign(QueuedGeometry* qsm);
244  void build();
246  void dump(std::ofstream& of) const;
248  AxisAlignedBox & getAABB(void){return mAABB;}
250  void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
251 
252  };
254  {
255  friend class GeometryBucket;
256  public:
258  {
264  TS_WORLD
265  };
268  protected:
270  unsigned short mIndex;
282  unsigned short mNumBoneMatrices;
285  public:
286  InstancedObject(unsigned short index);
287  InstancedObject(unsigned short index,SkeletonInstance *skeleton,AnimationStateSet*animations);
288  ~InstancedObject();
289  void setPosition( Vector3 position);
290  const Vector3& getPosition(void) const;
291  void yaw(const Radian& angle);
292  void pitch(const Radian& angle);
293  void roll(const Radian& angle);
294  void rotate(const Quaternion& q);
295  void setScale(const Vector3& scale);
296  const Vector3& getScale() const;
297  void setOrientation(const Quaternion& q);
298  void setPositionAndOrientation(Vector3 p, const Quaternion& q);
299  Quaternion & getOrientation(void);
300  void addBucketToList(GeometryBucket* bucket);
301  void needUpdate();
302  GeometryBucketList&getGeometryBucketList(void){return mGeometryBucketList;}
303  void translate(const Matrix3& axes, const Vector3& move);
304  void translate(const Vector3& d);
305  Matrix3 getLocalAxes(void) const;
306  void updateAnimation(void);
307  AnimationState* getAnimationState(const String& name) const;
308  SkeletonInstance*getSkeletonInstance(void){return mSkeletonInstance;}
309 
310  };
314  {
315  public:
318  protected:
330  // index to current Geometry Buckets for a given geometry format
334  String getGeometryFormatString(SubMeshLodGeometryLink* geom);
335 
336  public:
337  MaterialBucket(LODBucket* parent, const String& materialName);
338  virtual ~MaterialBucket();
339  LODBucket* getParent(void) { return mParent; }
341  const String& getMaterialName(void) const { return mMaterialName; }
343  void assign(QueuedGeometry* qsm);
345  void build();
347  void addRenderables(RenderQueue* queue, uint8 group,
348  Real lodValue);
350  const MaterialPtr& getMaterial(void) const { return mMaterial; }
354  GeometryIterator getGeometryIterator(void);
356  Technique* getCurrentTechnique(void) const { return mTechnique; }
358  void dump(std::ofstream& of) const;
360  MaterialBucket::CurrentGeometryMap* getMaterialBucketMap(void) const;
362  MaterialBucket::GeometryBucketList*getGeometryBucketList(void) const;
364  void updateContainers(GeometryBucket* bucket, const String &format);
365  void setLastIndex(int index){mLastIndex=index;}
366  int getLastIndex(){return mLastIndex;}
367  void setMaterial(const String & name);
368  void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
369 
370  };
377  {
378  public:
381  protected:
385  unsigned short mLod;
392  public:
393  LODBucket(BatchInstance* parent, unsigned short lod, Real lodValue);
394  virtual ~LODBucket();
395  BatchInstance* getParent(void) { return mParent; }
397  ushort getLod(void) const { return mLod; }
399  Real getLodValue(void) const { return mLodValue; }
401  void assign(QueuedSubMesh* qsm, ushort atLod);
403  void build();
405  void addRenderables(RenderQueue* queue, uint8 group,
406  Real lodValue);
410  MaterialIterator getMaterialIterator(void);
412  void dump(std::ofstream& of) const;
414  void updateContainers(MaterialBucket* bucket, String& name );
415  void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
416 
417  };
427  {
428  friend class MaterialBucket;
429  public:
430 
431 
436  protected:
437 
448 
450  public:
465  protected:
470 
471  public:
472  BatchInstance(InstancedGeometry* parent, const String& name, SceneManager* mgr,
473  uint32 BatchInstanceID);
474  virtual ~BatchInstance();
475  // more fields can be added in subclasses
476  InstancedGeometry* getParent(void) const { return mParent;}
478  void assign(QueuedSubMesh* qmesh);
480  void build();
482  uint32 getID(void) const { return mBatchInstanceID; }
484 // const Vector3& getCentre(void) const { return mCentre; }
485  const String& getMovableType(void) const;
486  void _notifyCurrentCamera(Camera* cam);
487  const AxisAlignedBox& getBoundingBox(void) const;
488  void setBoundingBox(AxisAlignedBox& box);
489  Real getBoundingRadius(void) const;
490  void _updateRenderQueue(RenderQueue* queue);
491  bool isVisible(void) const;
493  void visitRenderables(Renderable::Visitor* visitor,
494  bool debugRenderables = false);
495 
496  // uint32 getTypeFlags(void) const;
497 
500  LODIterator getLODIterator(void);
502  const LightList& getLights(void) const;
503 
505  void updateBoundingBox();
506 
508  void dump(std::ofstream& of) const;
510  void updateContainers(LODBucket* bucket );
512  void attachToScene();
513  void addInstancedObject(unsigned short index, InstancedObject* object);
514  InstancedObject* isInstancedObjectPresent(unsigned short index);
515  InstancedObjectIterator getObjectIterator();
516  SceneNode*getSceneNode(void){return mNode;}
517  ObjectsMap& getInstancesMap(void){return mInstancesMap;}
519 
520  };
531  protected:
532  // General state & settings
535  bool mBuilt;
542  bool mVisible;
550  unsigned int mObjectCount;
565 
571 
581  virtual BatchInstance* getBatchInstance(const AxisAlignedBox& bounds, bool autoCreate);
583  virtual BatchInstance* getBatchInstance(const Vector3& point, bool autoCreate);
585  virtual BatchInstance* getBatchInstance(ushort x, ushort y, ushort z, bool autoCreate);
587  virtual BatchInstance* getBatchInstance(uint32 index);
590  virtual void getBatchInstanceIndexes(const Vector3& point,
591  ushort& x, ushort& y, ushort& z);
594  virtual BatchInstance* getInstancedGeometryInstance(void);
597  virtual uint32 packIndex(ushort x, ushort y, ushort z);
600  virtual Real getVolumeIntersection(const AxisAlignedBox& box,
601  ushort x, ushort y, ushort z);
604  virtual AxisAlignedBox getBatchInstanceBounds(ushort x, ushort y, ushort z);
607  virtual Vector3 getBatchInstanceCentre(ushort x, ushort y, ushort z);
609  virtual AxisAlignedBox calculateBounds(VertexData* vertexData,
610  const Vector3& position, const Quaternion& orientation,
611  const Vector3& scale);
613  SubMeshLodGeometryLinkList* determineGeometry(SubMesh* sm);
615  void splitGeometry(VertexData* vd, IndexData* id,
616  SubMeshLodGeometryLink* targetGeomLink);
617 
623  template <typename T>
624  void buildIndexRemap(T* pBuffer, size_t numIndexes, IndexRemap& remap)
625  {
626  remap.clear();
627  for (size_t i = 0; i < numIndexes; ++i)
628  {
629  // use insert since duplicates are silently discarded
630  remap.insert(IndexRemap::value_type(*pBuffer++, remap.size()));
631  // this will have mapped oldindex -> new index IF oldindex
632  // wasn't already there
633  }
634  }
636  template <typename T>
637  void remapIndexes(T* src, T* dst, const IndexRemap& remap,
638  size_t numIndexes)
639  {
640  for (size_t i = 0; i < numIndexes; ++i)
641  {
642  // look up original and map to target
643  IndexRemap::const_iterator ix = remap.find(*src++);
644  assert(ix != remap.end());
645  *dst++ = static_cast<T>(ix->second);
646  }
647  }
648 
649  public:
651  InstancedGeometry(SceneManager* owner, const String& name);
653  virtual ~InstancedGeometry();
654 
656  const String& getName(void) const { return mName; }
676  virtual void addEntity(Entity* ent, const Vector3& position,
677  const Quaternion& orientation = Quaternion::IDENTITY,
678  const Vector3& scale = Vector3::UNIT_SCALE);
679 
699  virtual void addSceneNode(const SceneNode* node);
700 
711  virtual void build(void);
720  void addBatchInstance(void);
726  virtual void destroy(void);
727 
731  virtual void reset(void);
732 
742  virtual void setRenderingDistance(Real dist) {
743  mUpperDistance = dist;
744  mSquaredUpperDistance = mUpperDistance * mUpperDistance;
745  }
746 
748  virtual Real getRenderingDistance(void) const { return mUpperDistance; }
749 
751  virtual Real getSquaredRenderingDistance(void) const
752  { return mSquaredUpperDistance; }
753 
755  virtual void setVisible(bool visible);
756 
758  virtual bool isVisible(void) const { return mVisible; }
759 
777  virtual void setCastShadows(bool castShadows);
779  virtual bool getCastShadows(void) { return mCastShadows; }
780 
791  virtual void setBatchInstanceDimensions(const Vector3& size) {
792  mBatchInstanceDimensions = size;
793  mHalfBatchInstanceDimensions = size * 0.5;
794  }
796  virtual const Vector3& getBatchInstanceDimensions(void) const { return mBatchInstanceDimensions; }
808  virtual void setOrigin(const Vector3& origin) { mOrigin = origin; }
810  virtual const Vector3& getOrigin(void) const { return mOrigin; }
811 
823  virtual void setRenderQueueGroup(uint8 queueID);
824 
826  virtual uint8 getRenderQueueGroup(void) const;
830  BatchInstanceIterator getBatchInstanceIterator(void);
834  void visitRenderables(Renderable::Visitor* visitor,
835  bool debugRenderables = false);
836 
840  virtual void dump(const String& filename) const;
845  SkeletonInstance *getBaseSkeletonInstance(void){return mSkeletonInstance;}
850  SkeletonPtr getBaseSkeleton(void){return mBaseSkeleton;}
855  AnimationStateSet* getBaseAnimationState(void){return mAnimationState;}
860  unsigned int getObjectCount(void){return mObjectCount;}
861 
868  virtual void setProvideWorldInverses(bool flag);
869 
875  virtual bool getProvideWorldInverses(void) const { return mProvideWorldInverses; }
876  };
877 
880 }
881 
882 #endif
883 
MaterialPtr mMaterial
Pointer to material being used.
Class encapsulating a set of AnimationState objects.
Real mLodValue
Current lod value, passed on to do material lod later.
unsigned char uint8
Definition: OgrePlatform.h:248
QueuedGeometryList mQueuedGeometry
Geometry which has been queued up pre-build (not for deallocation)
AnimationStateSet * mAnimationState
This is the main animation state.
A viewpoint from which the scene will be rendered.
Definition: OgreCamera.h:85
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
BatchInstanceMap mBatchInstanceMap
Map of BatchInstances.
QueuedSubMeshList mQueuedSubMeshes
AxisAlignedBox & getAABB(void)
retun the BoundingBox information. Usefull when cloning the batch instance.
float Real
Software floating point type.
SceneManager * mSceneMgr
Scene manager link.
unsigned int uint32
Definition: OgrePlatform.h:246
#define _OgreExport
Definition: OgrePlatform.h:203
Pre-transforms and batches up meshes for efficient use as instanced geometry in a scene...
SkeletonPtr mBaseSkeleton
this is just a pointer to the base skeleton that will be used for each animated object in the batches...
std::vector< T, A > type
vector< GeometryBucket * >::type GeometryBucketList
list of Geometry Buckets that contains the instanced object
map< String, MaterialBucket * >::type MaterialBucketMap
Lookup of Material Buckets in this BatchInstance.
Matrix4 * mBoneMatrices
Cached bone matrices in skeleton local space.
unsigned short mLod
LOD level (0 == full LOD)
String mFormatString
String identifying the vertex / index format.
vector< QueuedSubMesh * >::type QueuedSubMeshList
virtual bool isVisible(void) const
Are the batches visible?
VertexData * mVertexData
Vertex information, includes current number of vertices committed to be a part of this bucket...
Manages the organisation and rendering of a 'scene' i.e.
const VertexData * getVertexData(void) const
Get the vertex data for this geometry.
vector< QueuedGeometry * >::type QueuedGeometryList
Real mBoundingRadius
Local bounding radius.
InstancedGeometry * getParent(void) const
A LODBucket is a collection of smaller buckets with the same LOD.
virtual Real getSquaredRenderingDistance(void) const
Gets the squared distance at which batches are no longer rendered.
Simple implementation of MovableObject and Renderable for single-part custom objects.
A 3D box aligned with the x/y/z axes.
A 3x3 matrix which can represent rotations around axes.
Definition: OgreMatrix3.h:68
Represents the state of an animation and the weight of it's influence.
virtual bool getProvideWorldInverses(void) const
SkeletonPtr getBaseSkeleton(void)
map< SubMesh *, SubMeshLodGeometryLinkList * >::type SubMeshGeometryLookup
MaterialBucket * mParent
Pointer to parent bucket.
Class representing an approach to rendering this particular Material.
Definition: OgreTechnique.h:53
RenderOperationVector & getRenderOperationVector()
get the mRenderOps vector.
Strategy for determining level of detail.
Matrix4 * mBoneWorldMatrices
Cached bone matrices, including any world transform.
RenderOperationVector mRenderOps
This vector stores all the renderOperation used in the batch.
void copyIndexes(const T *src, T *dst, size_t count, size_t indexOffset)
Technique * mTechnique
Active technique.
ushort getLod(void) const
Get the lod index.
Abstract class defining a movable object in a scene.
vector< String >::type QueuedSubMeshOriginList
Class representing a node in the scene graph.
Definition: OgreSceneNode.h:57
SkeletonInstance * mSkeletonInstance
const MaterialPtr & getMaterial(void) const
Get the material for this bucket.
Implementation of a Quaternion, i.e.
Concrete IteratorWrapper for nonconst access to the underlying key-value container.
Structure recording a queued submesh for the build.
The details of a topological BatchInstance which is the highest level of partitioning for this class...
AxisAlignedBox worldBounds
Pre-transformed world AABB.
IndexData * mIndexData
Index information, includes index type which limits the max number of vertices which are allowed in o...
OptimisedSubMeshGeometryList mOptimisedSubMeshGeometryList
List of geometry which has been optimised for SubMesh use This is the primary storage used for cleani...
map< uint32, BatchInstance * >::type BatchInstanceMap
Indexed BatchInstance map based on packed x/y/z BatchInstance index, 10 bits for each axis...
MapIterator< MaterialBucketMap > MaterialIterator
Iterator over the materials in this LOD.
SubMeshGeometryLookup mSubMeshGeometryLookup
Cached links from SubMeshes to (potentially optimised) geometry This is not used for deletion since t...
virtual Real getRenderingDistance(void) const
Gets the distance at which batches are no longer rendered.
static const Quaternion IDENTITY
AnimationStateSet * mAnimationState
State of animation for animable meshes.
vector< RenderOperation * >::type RenderOperationVector
Simple vectors where are stored all the renderoperations of the Batch.
list< OptimisedSubMeshGeometry * >::type OptimisedSubMeshGeometryList
virtual void setRenderingDistance(Real dist)
Sets the distance at which batches are no longer rendered.
size_t mMaxVertexIndex
Maximum vertex indexable.
QueuedSubMeshList mQueuedSubMeshes
Local list of queued meshes (not used for deallocation)
Struct holding geometry optimised per SubMesh / lod level, ready for copying to instances.
unsigned short mTexCoordIndex
Index of the Texcoord where the index is stored.
ushort mCurrentLod
The current lod level, as determined from the last camera.
#define _OgrePrivate
Definition: OgrePlatform.h:204
uint32 getID(void) const
Get the BatchInstance ID of this BatchInstance.
Mesh::LodValueList mLodValues
Lod values as built up - use the max at each level.
Defines an instance of a discrete, movable object based on a Mesh.
Definition: OgreEntity.h:81
InstancedGeometry * mBatch
Pointer to the Batch.
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
virtual const Vector3 & getBatchInstanceDimensions(void) const
Gets the size of a single batch of geometry.
bool mProvideWorldInverses
Flags to indicate whether the World Transform Inverse matrices are passed to the shaders.
Summary class collecting together index data source information.
Transform is relative to the space of the parent node.
Camera * mCamera
Current camera, passed on to do material lod later.
Visitor object that can be used to iterate over a collection of Renderable instances abstractly...
unsigned int getObjectCount(void)
A MaterialBucket is a collection of smaller buckets with the same Material (and implicitly the same L...
Real getLodValue(void) const
Get the lod value.
Structure recording a queued geometry for low level builds.
map< String, GeometryBucket * >::type CurrentGeometryMap
GeometryBucketList mGeometryBucketList
list of Geometry Buckets in this BatchInstance
Real mLodValue
lod value at which this LOD starts to apply (squared)
Defines a part of a complete mesh.
Definition: OgreSubMesh.h:62
void buildIndexRemap(T *pBuffer, size_t numIndexes, IndexRemap &remap)
Method for figuring out which vertices are used by an index buffer and calculating a remap lookup for...
uint8 mRenderQueueID
The render queue to use when rendering this object.
vector< GeometryBucket * >::type GeometryBucketList
list of Geometry Buckets in this BatchInstance
VectorIterator< LODBucketList > LODIterator
LODBucketList mLodBucketList
List of LOD buckets.
Transform is relative to the local space.
Standard 3-dimensional vector.
Definition: OgreVector3.h:51
GeometryBucketList & getGeometryBucketList(void)
HardwareIndexBuffer::IndexType mIndexType
Size of indexes.
std::map< K, V, P, A > type
map< unsigned short, InstancedObject * >::type ObjectsMap
unsigned short ushort
Summary class collecting together vertex source information.
A GeometryBucket is a the lowest level bucket where geometry with the same vertex & index format is s...
const String & getMaterialName(void) const
Get the material name.
MapIterator< BatchInstanceMap > BatchInstanceIterator
Iterator for iterating over contained BatchInstances.
vector< Real >::type LodValueList
Definition: OgreMesh.h:100
map< size_t, size_t >::type IndexRemap
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:46
InstancedGeometry * mParent
Parent static geometry.
BatchInstance * mInstancedGeometryInstance
const String & getName(void) const
Get the name of this object.
Class to manage the scene object rendering queue.
SubMeshLodGeometryLinkList * geometryLodList
Link to LOD list of geometry, potentially optimised.
void remapIndexes(T *src, T *dst, const IndexRemap &remap, size_t numIndexes)
Method for altering indexes based on a remap.
LODBucket * mParent
Pointer to parent LODBucket.
virtual void setOrigin(const Vector3 &origin)
Sets the origin of the geometry.
MapIterator< ObjectsMap > InstancedObjectIterator
const LodStrategy * mLodStrategy
Lod strategy reference.
Specialisation of SharedPtr to allow SharedPtr to be assigned to SkeletonPtr.
Definition: OgreSkeleton.h:461
QueuedGeometryList mQueuedGeometryList
Geometry queued for a single LOD (deallocated here)
_StringBase String
Technique * getCurrentTechnique(void) const
Get the current Technique.
Real mSquaredViewDepth
Cached squared view depth value to avoid recalculation by GeometryBucket.
AxisAlignedBox mAABB
Local AABB relative to BatchInstance centre.
vector< SubMeshLodGeometryLink >::type SubMeshLodGeometryLinkList
uint32 mBatchInstanceID
Unique identifier for the BatchInstance.
Specialisation of SharedPtr to allow SharedPtr to be assigned to MaterialPtr.
Definition: OgreMaterial.h:677
BatchInstance * mParent
Pointer to parent BatchInstance.
virtual const Vector3 & getOrigin(void) const
Gets the origin of this geometry.
AnimationStateSet * getBaseAnimationState(void)
SkeletonInstance * getBaseSkeletonInstance(void)
Concrete IteratorWrapper for nonconst access to the underlying container.
virtual void setBatchInstanceDimensions(const Vector3 &size)
Sets the size of a single BatchInstance of geometry.
unsigned int mObjectCount
number of objects in the batch
bool mRenderQueueIDSet
Flags whether the RenderQueue's default should be used.
unsigned long mFrameAnimationLastUpdated
Records the last frame in which animation was updated.
const IndexData * getIndexData(void) const
Get the index data for this geometry.
static const Vector3 UNIT_SCALE
Definition: OgreVector3.h:781
virtual bool getCastShadows(void)
Will the geometry from this object cast shadows?
vector< LODBucket * >::type LODBucketList
list of LOD Buckets in this BatchInstance
A SkeletonInstance is a single instance of a Skeleton used by a world object.
MaterialBucketMap mMaterialBucketMap
Lookup of Material Buckets in this BatchInstance.
VectorIterator< GeometryBucketList > GeometryIterator
Iterator over geometry.