OGRE  1.9
Object-Oriented Graphics Rendering Engine
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
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/
7 Copyright (c) 2000-2014 Torus Knot Software Ltd
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:
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __InstancedGeometry_H__
29 #define __InstancedGeometry_H__
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 #include "OgreHeaderPrefix.h"
42 namespace Ogre {
106  {
107  public:
121  {
122  public:
123  OptimisedSubMeshGeometry() :vertexData(0), indexData(0) {}
125  {
126  delete vertexData;
127  delete indexData;
128  }
131  };
136  {
139  };
144  {
154  unsigned int ID;
155  };
160  {
165  unsigned int ID;
166  };
169  // forward declarations
170  class LODBucket;
171  class MaterialBucket;
172  class BatchInstance;
173  class InstancedObject;
180  {
181  protected:
202  unsigned short mTexCoordIndex;
205  template<typename T>
206  void copyIndexes(const T* src, T* dst, size_t count, size_t indexOffset)
207  {
208  if (indexOffset == 0)
209  {
210  memcpy(dst, src, sizeof(T) * count);
211  }
212  else
213  {
214  while(count--)
215  {
216  *dst++ = static_cast<T>(*src++ + indexOffset);
217  }
218  }
219  }
221  void _initGeometryBucket(const VertexData* vData, const IndexData* iData);
222  void _initGeometryBucket(GeometryBucket* bucket);
224  public:
225  GeometryBucket(MaterialBucket* parent, const String& formatString,
226  const VertexData* vData, const IndexData* iData);
227  GeometryBucket(const String& name, MaterialBucket* parent, const String& formatString,
228  const VertexData* vData, const IndexData* iData);
229  GeometryBucket(MaterialBucket* parent,const String& formatString,GeometryBucket*bucket);
230  GeometryBucket(const String& name, MaterialBucket* parent,const String& formatString,GeometryBucket*bucket);
231  virtual ~GeometryBucket();
232  MaterialBucket* getParent(void) { return mParent; }
233  Real getBoundingRadius(void) const;
235  const VertexData* getVertexData(void) const { return mVertexData; }
237  const IndexData* getIndexData(void) const { return mIndexData; }
239  const MaterialPtr& getMaterial(void) const;
240  Technique* getTechnique(void) const;
241  void getWorldTransforms(Matrix4* xform) const;
242  virtual unsigned short getNumWorldTransforms(void) const ;
243  Real getSquaredViewDepth(const Camera* cam) const;
244  const LightList& getLights(void) const;
245  bool getCastsShadows(void) const;
246  String getFormatString(void) const;
250  bool assign(QueuedGeometry* qsm);
252  void build();
254  void dump(std::ofstream& of) const;
256  AxisAlignedBox & getAABB(void){return mAABB;}
258  void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
260  };
262  {
263  friend class GeometryBucket;
264  public:
266  {
273  };
276  protected:
278  unsigned short mIndex;
290  unsigned short mNumBoneMatrices;
293  public:
294  InstancedObject(unsigned short index);
295  InstancedObject(unsigned short index,SkeletonInstance *skeleton,AnimationStateSet*animations);
296  ~InstancedObject();
297  void setPosition( Vector3 position);
298  const Vector3& getPosition(void) const;
299  void yaw(const Radian& angle);
300  void pitch(const Radian& angle);
301  void roll(const Radian& angle);
302  void rotate(const Quaternion& q);
303  void setScale(const Vector3& scale);
304  const Vector3& getScale() const;
305  void setOrientation(const Quaternion& q);
306  void setPositionAndOrientation(Vector3 p, const Quaternion& q);
307  Quaternion & getOrientation(void);
308  void addBucketToList(GeometryBucket* bucket);
309  void needUpdate();
310  GeometryBucketList&getGeometryBucketList(void){return mGeometryBucketList;}
311  void translate(const Matrix3& axes, const Vector3& move);
312  void translate(const Vector3& d);
313  Matrix3 getLocalAxes(void) const;
314  void updateAnimation(void);
315  AnimationState* getAnimationState(const String& name) const;
316  SkeletonInstance*getSkeletonInstance(void){return mSkeletonInstance;}
318  };
322  {
323  public:
326  protected:
338  // index to current Geometry Buckets for a given geometry format
342  String getGeometryFormatString(SubMeshLodGeometryLink* geom);
344  public:
345  MaterialBucket(LODBucket* parent, const String& materialName);
346  virtual ~MaterialBucket();
347  LODBucket* getParent(void) { return mParent; }
349  const String& getMaterialName(void) const { return mMaterialName; }
351  void assign(QueuedGeometry* qsm);
353  void build();
355  void addRenderables(RenderQueue* queue, uint8 group,
356  Real lodValue);
358  const MaterialPtr& getMaterial(void) const { return mMaterial; }
362  GeometryIterator getGeometryIterator(void);
364  Technique* getCurrentTechnique(void) const { return mTechnique; }
366  void dump(std::ofstream& of) const;
368  MaterialBucket::CurrentGeometryMap* getMaterialBucketMap(void) const;
370  MaterialBucket::GeometryBucketList*getGeometryBucketList(void) const;
372  void updateContainers(GeometryBucket* bucket, const String &format);
373  void setLastIndex(int index){mLastIndex=index;}
374  int getLastIndex(){return mLastIndex;}
375  void setMaterial(const String & name);
376  void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
378  };
385  {
386  public:
389  protected:
393  unsigned short mLod;
400  public:
401  LODBucket(BatchInstance* parent, unsigned short lod, Real lodValue);
402  virtual ~LODBucket();
403  BatchInstance* getParent(void) { return mParent; }
405  ushort getLod(void) const { return mLod; }
407  Real getLodValue(void) const { return mLodValue; }
409  void assign(QueuedSubMesh* qsm, ushort atLod);
411  void build();
413  void addRenderables(RenderQueue* queue, uint8 group,
414  Real lodValue);
418  MaterialIterator getMaterialIterator(void);
420  void dump(std::ofstream& of) const;
422  void updateContainers(MaterialBucket* bucket, String& name );
423  void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
425  };
435  {
436  friend class MaterialBucket;
437  public:
444  protected:
458  public:
473  protected:
479  public:
480  BatchInstance(InstancedGeometry* parent, const String& name, SceneManager* mgr,
481  uint32 BatchInstanceID);
482  virtual ~BatchInstance();
483  // more fields can be added in subclasses
484  InstancedGeometry* getParent(void) const { return mParent;}
486  void assign(QueuedSubMesh* qmesh);
488  void build();
490  uint32 getID(void) const { return mBatchInstanceID; }
492 // const Vector3& getCentre(void) const { return mCentre; }
493  const String& getMovableType(void) const;
494  void _notifyCurrentCamera(Camera* cam);
495  const AxisAlignedBox& getBoundingBox(void) const;
496  void setBoundingBox(AxisAlignedBox& box);
497  Real getBoundingRadius(void) const;
498  void _updateRenderQueue(RenderQueue* queue);
499  bool isVisible(void) const;
501  void visitRenderables(Renderable::Visitor* visitor,
502  bool debugRenderables = false);
504  // uint32 getTypeFlags(void) const;
508  LODIterator getLODIterator(void);
510  const LightList& getLights(void) const;
513  void updateBoundingBox();
516  void dump(std::ofstream& of) const;
518  void updateContainers(LODBucket* bucket );
520  void attachToScene();
521  void addInstancedObject(unsigned short index, InstancedObject* object);
522  InstancedObject* isInstancedObjectPresent(unsigned short index);
523  InstancedObjectIterator getObjectIterator();
524  SceneNode*getSceneNode(void){return mNode;}
525  ObjectsMap& getInstancesMap(void){return mInstancesMap;}
528  };
539  protected:
540  // General state & settings
543  bool mBuilt;
550  bool mVisible;
558  unsigned int mObjectCount;
589  virtual BatchInstance* getBatchInstance(const AxisAlignedBox& bounds, bool autoCreate);
591  virtual BatchInstance* getBatchInstance(const Vector3& point, bool autoCreate);
593  virtual BatchInstance* getBatchInstance(ushort x, ushort y, ushort z, bool autoCreate);
595  virtual BatchInstance* getBatchInstance(uint32 index);
598  virtual void getBatchInstanceIndexes(const Vector3& point,
599  ushort& x, ushort& y, ushort& z);
602  virtual BatchInstance* getInstancedGeometryInstance(void);
605  virtual uint32 packIndex(ushort x, ushort y, ushort z);
608  virtual Real getVolumeIntersection(const AxisAlignedBox& box,
609  ushort x, ushort y, ushort z);
612  virtual AxisAlignedBox getBatchInstanceBounds(ushort x, ushort y, ushort z);
615  virtual Vector3 getBatchInstanceCentre(ushort x, ushort y, ushort z);
617  virtual AxisAlignedBox calculateBounds(VertexData* vertexData,
618  const Vector3& position, const Quaternion& orientation,
619  const Vector3& scale);
621  SubMeshLodGeometryLinkList* determineGeometry(SubMesh* sm);
623  void splitGeometry(VertexData* vd, IndexData* id,
624  SubMeshLodGeometryLink* targetGeomLink);
631  template <typename T>
632  void buildIndexRemap(T* pBuffer, size_t numIndexes, IndexRemap& remap)
633  {
634  remap.clear();
635  for (size_t i = 0; i < numIndexes; ++i)
636  {
637  // use insert since duplicates are silently discarded
638  remap.insert(IndexRemap::value_type(*pBuffer++, remap.size()));
639  // this will have mapped oldindex -> new index IF oldindex
640  // wasn't already there
641  }
642  }
644  template <typename T>
645  void remapIndexes(T* src, T* dst, const IndexRemap& remap,
646  size_t numIndexes)
647  {
648  for (size_t i = 0; i < numIndexes; ++i)
649  {
650  // look up original and map to target
651  IndexRemap::const_iterator ix = remap.find(*src++);
652  assert(ix != remap.end());
653  *dst++ = static_cast<T>(ix->second);
654  }
655  }
657  public:
659  InstancedGeometry(SceneManager* owner, const String& name);
661  virtual ~InstancedGeometry();
664  const String& getName(void) const { return mName; }
684  virtual void addEntity(Entity* ent, const Vector3& position,
685  const Quaternion& orientation = Quaternion::IDENTITY,
686  const Vector3& scale = Vector3::UNIT_SCALE);
707  virtual void addSceneNode(const SceneNode* node);
719  virtual void build(void);
728  void addBatchInstance(void);
734  virtual void destroy(void);
739  virtual void reset(void);
750  virtual void setRenderingDistance(Real dist) {
751  mUpperDistance = dist;
752  mSquaredUpperDistance = mUpperDistance * mUpperDistance;
753  }
756  virtual Real getRenderingDistance(void) const { return mUpperDistance; }
759  virtual Real getSquaredRenderingDistance(void) const
760  { return mSquaredUpperDistance; }
763  virtual void setVisible(bool visible);
766  virtual bool isVisible(void) const { return mVisible; }
785  virtual void setCastShadows(bool castShadows);
787  virtual bool getCastShadows(void) { return mCastShadows; }
799  virtual void setBatchInstanceDimensions(const Vector3& size) {
800  mBatchInstanceDimensions = size;
801  mHalfBatchInstanceDimensions = size * 0.5;
802  }
804  virtual const Vector3& getBatchInstanceDimensions(void) const { return mBatchInstanceDimensions; }
816  virtual void setOrigin(const Vector3& origin) { mOrigin = origin; }
818  virtual const Vector3& getOrigin(void) const { return mOrigin; }
831  virtual void setRenderQueueGroup(uint8 queueID);
834  virtual uint8 getRenderQueueGroup(void) const;
838  BatchInstanceIterator getBatchInstanceIterator(void);
842  void visitRenderables(Renderable::Visitor* visitor,
843  bool debugRenderables = false);
848  virtual void dump(const String& filename) const;
853  SkeletonInstance *getBaseSkeletonInstance(void){return mSkeletonInstance;}
858  SkeletonPtr getBaseSkeleton(void){return mBaseSkeleton;}
863  AnimationStateSet* getBaseAnimationState(void){return mAnimationState;}
868  unsigned int getObjectCount(void){return mObjectCount;}
876  virtual void setProvideWorldInverses(bool flag);
883  virtual bool getProvideWorldInverses(void) const { return mProvideWorldInverses; }
884  };
888 }
890 #include "OgreHeaderSuffix.h"
892 #endif
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:346
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:86
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
BatchInstanceMap mBatchInstanceMap
Map of BatchInstances.
QueuedSubMeshList mQueuedSubMeshes
AxisAlignedBox & getAABB(void)
Return the BoundingBox information. Useful when cloning the batch instance.
float Real
Software floating point type.
SceneManager * mSceneMgr
Scene manager link.
unsigned int uint32
Definition: OgrePlatform.h:344
#define _OgreExport
Definition: OgrePlatform.h:260
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 its 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:58
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 render operations 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:261
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:82
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:102
map< size_t, size_t >::type IndexRemap
Wrapper class which indicates a given angle value is in Radians.
Definition: OgreMath.h:47
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.
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.
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:807
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.