Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

OgreInstancedGeometry.h @ 148

Last change on this file since 148 was 148, checked in by patricwi, 6 years ago
Added new dependencies for ogre1.9 and cegui0.8
File size: 35.8 KB

Line
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 __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	#include "OgreHeaderPrefix.h"
41
42	namespace Ogre {
43
44	/** \addtogroup Core
45	* @{
46	*/
47	/** \addtogroup Scene
48	* @{
49	*/
50	/** Pre-transforms and batches up meshes for efficient use as instanced geometry
51	in a scene
52	@remarks
53	Shader instancing allows to save both memory and draw calls. While
54	StaticGeometry stores 500 times the same object in a batch to display 500
55	objects, this shader instancing implementation stores only 80 times the object,
56	and then re-uses the vertex data with different shader parameter.
57	Although you save memory, you make more draw call. However, you still
58	make less draw calls than if you were rendering each object independently.
59	Plus, you can move the batched objects independently of one another which
60	you cannot do with StaticGeometry.
61	@par
62	Therefore it is important when you are rendering a lot of geometry to
63	batch things up into as few rendering calls as possible. This
64	class allows you to build a batched object from a series of entities
65	in order to benefit from this behaviour.
66	Batching has implications of it's own though:
67	@li Batched geometry cannot be subdivided; that means that the whole
68	group will be displayed, or none of it will. This obivously has
69	culling issues.
70	@li A single material must apply for each batch. In fact this class
71	allows you to use multiple materials, but you should be aware that
72	internally this means that there is one batch per material.
73	Therefore you won't gain as much benefit from the batching if you
74	use many different materials; try to keep the number down.
75	@par
76	The bounding box information is computed with object position only.
77	It doesn't take account of the object orientation.
78	@par
79	The LOD settings of both the Mesh and the Materials used in
80	constructing this instanced geometry will be respected. This means that
81	if you use meshes/materials which have LOD, batches in the distance
82	will have a lower polygon count or material detail to those in the
83	foreground. Since each mesh might have different LOD distances, during
84	build the furthest distance at each LOD level from all meshes
85	in that BatchInstance is used. This means all the LOD levels change at the
86	same time, but at the furthest distance of any of them (so quality is
87	not degraded). Be aware that using Mesh LOD in this class will
88	further increase the memory required. Only generated LOD
89	is supported for meshes.
90	@par
91	There are 2 ways you can add geometry to this class; you can add
92	Entity objects directly with predetermined positions, scales and
93	orientations, or you can add an entire SceneNode and it's subtree,
94	including all the objects attached to it. Once you've added everything
95	you need to, you have to call build() the fix the geometry in place.
96	@par
97	You should not construct instances of this class directly; instead, call
98	SceneManager::createInstancedGeometry, which gives the SceneManager the
99	option of providing you with a specialised version of this class if it
100	wishes, and also handles the memory management for you like other
101	classes.
102	@note
103	Warning: this class only works with indexed triangle lists at the moment, do not pass it triangle strips, fans or lines / points, or unindexed geometry.
104	*/
105	class _OgreExport InstancedGeometry : public BatchedGeometryAlloc
106	{
107	public:
108	/** Struct holding geometry optimised per SubMesh / LOD level, ready
109	for copying to instances.
110	@remarks
111	Since we're going to be duplicating geometry lots of times, it's
112	far more important that we don't have redundant vertex data. If a
113	SubMesh uses shared geometry, or we're looking at a lower LOD, not
114	all the vertices are being referenced by faces on that submesh.
115	Therefore to duplicate them, potentially hundreds or even thousands
116	of times, would be extremely wasteful. Therefore, if a SubMesh at
117	a given LOD has wastage, we create an optimised version of it's
118	geometry which is ready for copying with no wastage.
119	*/
120	class _OgrePrivate OptimisedSubMeshGeometry : public BatchedGeometryAlloc
121	{
122	public:
123	OptimisedSubMeshGeometry() :vertexData(0), indexData(0) {}
124	~OptimisedSubMeshGeometry()
125	{
126	delete vertexData;
127	delete indexData;
128	}
129	VertexData *vertexData;
130	IndexData *indexData;
131	};
132	typedef list<OptimisedSubMeshGeometry*>::type OptimisedSubMeshGeometryList;
133	/// Saved link between SubMesh at a LOD and vertex/index data
134	/// May point to original or optimised geometry
135	struct SubMeshLodGeometryLink
136	{
137	VertexData* vertexData;
138	IndexData* indexData;
139	};
140	typedef vector<SubMeshLodGeometryLink>::type SubMeshLodGeometryLinkList;
141	typedef map<SubMesh, SubMeshLodGeometryLinkList>::type SubMeshGeometryLookup;
142	/// Structure recording a queued submesh for the build
143	struct QueuedSubMesh : public BatchedGeometryAlloc
144	{
145	SubMesh* submesh;
146	/// Link to LOD list of geometry, potentially optimised
147	SubMeshLodGeometryLinkList* geometryLodList;
148	String materialName;
149	Vector3 position;
150	Quaternion orientation;
151	Vector3 scale;
152	/// Pre-transformed world AABB
153	AxisAlignedBox worldBounds;
154	unsigned int ID;
155	};
156	typedef vector<QueuedSubMesh*>::type QueuedSubMeshList;
157	typedef vector<String>::type QueuedSubMeshOriginList;
158	/// Structure recording a queued geometry for low level builds
159	struct QueuedGeometry : public BatchedGeometryAlloc
160	{
161	SubMeshLodGeometryLink* geometry;
162	Vector3 position;
163	Quaternion orientation;
164	Vector3 scale;
165	unsigned int ID;
166	};
167	typedef vector<QueuedGeometry*>::type QueuedGeometryList;
168
169	// forward declarations
170	class LODBucket;
171	class MaterialBucket;
172	class BatchInstance;
173	class InstancedObject;
174
175	/** A GeometryBucket is a the lowest level bucket where geometry with
176	the same vertex & index format is stored. It also acts as the
177	renderable.
178	*/
179	class _OgreExport GeometryBucket : public SimpleRenderable
180	{
181	protected:
182
183	/// Geometry which has been queued up pre-build (not for deallocation)
184	QueuedGeometryList mQueuedGeometry;
185	/// Pointer to the Batch
186	InstancedGeometry*mBatch;
187	/// Pointer to parent bucket
188	MaterialBucket* mParent;
189	/// String identifying the vertex / index format
190	String mFormatString;
191	/// Vertex information, includes current number of vertices
192	/// committed to be a part of this bucket
193	VertexData* mVertexData;
194	/// Index information, includes index type which limits the max
195	/// number of vertices which are allowed in one bucket
196	IndexData* mIndexData;
197	/// Size of indexes
198	HardwareIndexBuffer::IndexType mIndexType;
199	/// Maximum vertex indexable
200	size_t mMaxVertexIndex;
201	/// Index of the Texcoord where the index is stored
202	unsigned short mTexCoordIndex;
203	AxisAlignedBox mAABB;
204
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	}
220
221	void _initGeometryBucket(const VertexData* vData, const IndexData* iData);
222	void _initGeometryBucket(GeometryBucket* bucket);
223
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;
234	/// Get the vertex data for this geometry
235	const VertexData* getVertexData(void) const { return mVertexData; }
236	/// Get the index data for this geometry
237	const IndexData* getIndexData(void) const { return mIndexData; }
238	/// @copydoc Renderable::getMaterial
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;
247	/** Try to assign geometry to this bucket.
248	@return false if there is no room left in this bucket
249	*/
250	bool assign(QueuedGeometry* qsm);
251	/// Build
252	void build();
253	/// Dump contents for diagnostics
254	void dump(std::ofstream& of) const;
255	/// Return the BoundingBox information. Useful when cloning the batch instance.
256	AxisAlignedBox & getAABB(void){return mAABB;}
257	/// @copydoc MovableObject::visitRenderables
258	void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
259
260	};
261	class _OgreExport InstancedObject : public BatchedGeometryAlloc
262	{
263	friend class GeometryBucket;
264	public:
265	enum TransformSpace
266	{
267	/// Transform is relative to the local space
268	TS_LOCAL,
269	/// Transform is relative to the space of the parent node
270	TS_PARENT,
271	/// Transform is relative to world space
272	TS_WORLD
273	};
274	/// list of Geometry Buckets that contains the instanced object
275	typedef vector<GeometryBucket*>::type GeometryBucketList;
276	protected:
277	GeometryBucketList mGeometryBucketList;
278	unsigned short mIndex;
279	Matrix4 mTransformation;
280	Quaternion mOrientation;
281	Vector3 mScale;
282	Vector3 mPosition;
283	SkeletonInstance* mSkeletonInstance;
284	/// Cached bone matrices, including any world transform
285	Matrix4 *mBoneWorldMatrices;
286	/// Cached bone matrices in skeleton local space
287	Matrix4 *mBoneMatrices;
288	/// State of animation for animable meshes
289	AnimationStateSet* mAnimationState;
290	unsigned short mNumBoneMatrices;
291	/// Records the last frame in which animation was updated
292	unsigned long mFrameAnimationLastUpdated;
293	public:
294	InstancedObject(unsigned short index);
295	InstancedObject(unsigned short index,SkeletonInstance skeleton,AnimationStateSetanimations);
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;}
317
318	};
319	/** A MaterialBucket is a collection of smaller buckets with the same
320	Material (and implicitly the same LOD). */
321	class _OgreExport MaterialBucket : public BatchedGeometryAlloc
322	{
323	public:
324	/// list of Geometry Buckets in this BatchInstance
325	typedef vector<GeometryBucket*>::type GeometryBucketList;
326	protected:
327	/// Pointer to parent LODBucket
328	LODBucket* mParent;
329	/// Material being used
330	String mMaterialName;
331	/// Pointer to material being used
332	MaterialPtr mMaterial;
333	/// Active technique
334	Technique* mTechnique;
335	int mLastIndex;
336	/// list of Geometry Buckets in this BatchInstance
337	GeometryBucketList mGeometryBucketList;
338	// index to current Geometry Buckets for a given geometry format
339	typedef map<String, GeometryBucket*>::type CurrentGeometryMap;
340	CurrentGeometryMap mCurrentGeometryMap;
341	/// Get a packed string identifying the geometry format
342	String getGeometryFormatString(SubMeshLodGeometryLink* geom);
343
344	public:
345	MaterialBucket(LODBucket* parent, const String& materialName);
346	virtual ~MaterialBucket();
347	LODBucket* getParent(void) { return mParent; }
348	/// Get the material name
349	const String& getMaterialName(void) const { return mMaterialName; }
350	/// Assign geometry to this bucket
351	void assign(QueuedGeometry* qsm);
352	/// Build
353	void build();
354	/// Add children to the render queue
355	void addRenderables(RenderQueue* queue, uint8 group,
356	Real lodValue);
357	/// Get the material for this bucket
358	const MaterialPtr& getMaterial(void) const { return mMaterial; }
359	/// Iterator over geometry
360	typedef VectorIterator<GeometryBucketList> GeometryIterator;
361	/// Get an iterator over the contained geometry
362	GeometryIterator getGeometryIterator(void);
363	/// Get the current Technique
364	Technique* getCurrentTechnique(void) const { return mTechnique; }
365	/// Dump contents for diagnostics
366	void dump(std::ofstream& of) const;
367	/// Return the geometry map
368	MaterialBucket::CurrentGeometryMap* getMaterialBucketMap(void) const;
369	/// Return the geometry list
370	MaterialBucket::GeometryBucketList*getGeometryBucketList(void) const;
371	/// fill in the map and the list
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);
377
378	};
379	/** A LODBucket is a collection of smaller buckets with the same LOD.
380	@remarks
381	LOD refers to Mesh LOD here. Material LOD can change separately
382	at the next bucket down from this.
383	*/
384	class _OgreExport LODBucket : public BatchedGeometryAlloc
385	{
386	public:
387	/// Lookup of Material Buckets in this BatchInstance
388	typedef map<String, MaterialBucket*>::type MaterialBucketMap;
389	protected:
390	/// Pointer to parent BatchInstance
391	BatchInstance* mParent;
392	/// LOD level (0 == full LOD)
393	unsigned short mLod;
394	/// LOD value at which this LOD starts to apply (squared)
395	Real mLodValue;
396	/// Lookup of Material Buckets in this BatchInstance
397	MaterialBucketMap mMaterialBucketMap;
398	/// Geometry queued for a single LOD (deallocated here)
399	QueuedGeometryList mQueuedGeometryList;
400	public:
401	LODBucket(BatchInstance* parent, unsigned short lod, Real lodValue);
402	virtual ~LODBucket();
403	BatchInstance* getParent(void) { return mParent; }
404	/// Get the LOD index
405	ushort getLod(void) const { return mLod; }
406	/// Get the LOD value
407	Real getLodValue(void) const { return mLodValue; }
408	/// Assign a queued submesh to this bucket, using specified mesh LOD
409	void assign(QueuedSubMesh* qsm, ushort atLod);
410	/// Build
411	void build();
412	/// Add children to the render queue
413	void addRenderables(RenderQueue* queue, uint8 group,
414	Real lodValue);
415	/// Iterator over the materials in this LOD
416	typedef MapIterator<MaterialBucketMap> MaterialIterator;
417	/// Get an iterator over the materials in this LOD
418	MaterialIterator getMaterialIterator(void);
419	/// Dump contents for diagnostics
420	void dump(std::ofstream& of) const;
421	/// fill the map
422	void updateContainers(MaterialBucket* bucket, String& name );
423	void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables);
424
425	};
426	/** The details of a topological BatchInstance which is the highest level of
427	partitioning for this class.
428	@remarks
429	The size & shape of BatchInstances entirely depends on the SceneManager
430	specific implementation. It is a MovableObject since it will be
431	attached to a node based on the local centre - in practice it
432	won't actually move (although in theory it could).
433	*/
434	class _OgreExport BatchInstance : public MovableObject
435	{
436	friend class MaterialBucket;
437	public:
438
439
440	/// list of LOD Buckets in this BatchInstance
441	typedef vector<LODBucket*>::type LODBucketList;
442	typedef map<unsigned short, InstancedObject*>::type ObjectsMap;
443	typedef MapIterator<ObjectsMap> InstancedObjectIterator;
444	protected:
445
446	/// Parent static geometry
447	InstancedGeometry* mParent;
448	/// Scene manager link
449	SceneManager* mSceneMgr;
450	/// Scene node
451	SceneNode* mNode;
452	/// Local list of queued meshes (not used for deallocation)
453	QueuedSubMeshList mQueuedSubMeshes;
454	/// Unique identifier for the BatchInstance
455	uint32 mBatchInstanceID;
456
457	ObjectsMap mInstancesMap;
458	public:
459	/// LOD values as built up - use the max at each level
460	Mesh::LodValueList mLodValues;
461	/// Local AABB relative to BatchInstance centre
462	AxisAlignedBox mAABB;
463	/// Local bounding radius
464	Real mBoundingRadius;
465	/// The current LOD level, as determined from the last camera
466	ushort mCurrentLod;
467	/// Current LOD value, passed on to do material LOD later
468	Real mLodValue;
469	/// Current camera, passed on to do material LOD later
470	Camera *mCamera;
471	/// Cached squared view depth value to avoid recalculation by GeometryBucket
472	Real mSquaredViewDepth;
473	protected:
474	/// List of LOD buckets
475	LODBucketList mLodBucketList;
476	/// LOD strategy reference
477	const LodStrategy *mLodStrategy;
478
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;}
485	/// Assign a queued mesh to this BatchInstance, read for final build
486	void assign(QueuedSubMesh* qmesh);
487	/// Build this BatchInstance
488	void build();
489	/// Get the BatchInstance ID of this BatchInstance
490	uint32 getID(void) const { return mBatchInstanceID; }
491	/// Get the centre point of the BatchInstance
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;
500	/// @copydoc MovableObject::visitRenderables
501	void visitRenderables(Renderable::Visitor* visitor,
502	bool debugRenderables = false);
503
504	// uint32 getTypeFlags(void) const;
505
506	typedef VectorIterator<LODBucketList> LODIterator;
507	/// Get an iterator over the LODs in this BatchInstance
508	LODIterator getLODIterator(void);
509	/// Shared set of lights for all GeometryBuckets
510	const LightList& getLights(void) const;
511
512	/// update the bounding box of the BatchInstance according to the positions of the objects
513	void updateBoundingBox();
514
515	/// Dump contents for diagnostics
516	void dump(std::ofstream& of) const;
517	/// fill in the list
518	void updateContainers(LODBucket* bucket );
519	/// attach the BatchInstance to the scene
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;}
526	/// change the shader used to render the batch instance
527
528	};
529	/** Indexed BatchInstance map based on packed x/y/z BatchInstance index, 10 bits for
530	each axis.
531	*/
532	typedef map<uint32, BatchInstance*>::type BatchInstanceMap;
533	/** Simple vectors where are stored all the render operations of the Batch.
534	This vector is used when we want to delete the batch, in order to delete only one time each
535	render operation.
536
537	*/
538	typedef vector<RenderOperation*>::type RenderOperationVector;
539	protected:
540	// General state & settings
541	SceneManager* mOwner;
542	String mName;
543	bool mBuilt;
544	Real mUpperDistance;
545	Real mSquaredUpperDistance;
546	bool mCastShadows;
547	Vector3 mBatchInstanceDimensions;
548	Vector3 mHalfBatchInstanceDimensions;
549	Vector3 mOrigin;
550	bool mVisible;
551	/// Flags to indicate whether the World Transform Inverse matrices are passed to the shaders
552	bool mProvideWorldInverses;
553	/// The render queue to use when rendering this object
554	uint8 mRenderQueueID;
555	/// Flags whether the RenderQueue's default should be used.
556	bool mRenderQueueIDSet;
557	/// number of objects in the batch
558	unsigned int mObjectCount;
559	QueuedSubMeshList mQueuedSubMeshes;
560	BatchInstance*mInstancedGeometryInstance;
561	/**this is just a pointer to the base skeleton that will be used for each animated object in the batches
562	This pointer has a value only during the creation of the InstancedGeometry
563	*/
564	SkeletonPtr mBaseSkeleton;
565	SkeletonInstance *mSkeletonInstance;
566	/**This is the main animation state. All "objects" in the batch will use an instance of this animation
567	state
568	*/
569	AnimationStateSet* mAnimationState;
570	/// List of geometry which has been optimised for SubMesh use
571	/// This is the primary storage used for cleaning up later
572	OptimisedSubMeshGeometryList mOptimisedSubMeshGeometryList;
573
574	/** Cached links from SubMeshes to (potentially optimised) geometry
575	This is not used for deletion since the lookup may reference
576	original vertex data
577	*/
578	SubMeshGeometryLookup mSubMeshGeometryLookup;
579
580	/// Map of BatchInstances
581	BatchInstanceMap mBatchInstanceMap;
582	/** This vector stores all the renderOperation used in the batch.
583	See the type definition for more details.
584	*/
585	RenderOperationVector mRenderOps;
586	/** Virtual method for getting a BatchInstance most suitable for the
587	passed in bounds. Can be overridden by subclasses.
588	*/
589	virtual BatchInstance* getBatchInstance(const AxisAlignedBox& bounds, bool autoCreate);
590	/** Get the BatchInstance within which a point lies */
591	virtual BatchInstance* getBatchInstance(const Vector3& point, bool autoCreate);
592	/** Get the BatchInstance using indexes */
593	virtual BatchInstance* getBatchInstance(ushort x, ushort y, ushort z, bool autoCreate);
594	/** Get the BatchInstance using a packed index, returns null if it doesn't exist. */
595	virtual BatchInstance* getBatchInstance(uint32 index);
596	/** Get the BatchInstance indexes for a point.
597	*/
598	virtual void getBatchInstanceIndexes(const Vector3& point,
599	ushort& x, ushort& y, ushort& z);
600	/** get the first BatchInstance or create on if it does not exists.
601	*/
602	virtual BatchInstance* getInstancedGeometryInstance(void);
603	/** Pack 3 indexes into a single index value
604	*/
605	virtual uint32 packIndex(ushort x, ushort y, ushort z);
606	/** Get the volume intersection for an indexed BatchInstance with some bounds.
607	*/
608	virtual Real getVolumeIntersection(const AxisAlignedBox& box,
609	ushort x, ushort y, ushort z);
610	/** Get the bounds of an indexed BatchInstance.
611	*/
612	virtual AxisAlignedBox getBatchInstanceBounds(ushort x, ushort y, ushort z);
613	/** Get the centre of an indexed BatchInstance.
614	*/
615	virtual Vector3 getBatchInstanceCentre(ushort x, ushort y, ushort z);
616	/** Calculate world bounds from a set of vertex data. */
617	virtual AxisAlignedBox calculateBounds(VertexData* vertexData,
618	const Vector3& position, const Quaternion& orientation,
619	const Vector3& scale);
620	/** Look up or calculate the geometry data to use for this SubMesh */
621	SubMeshLodGeometryLinkList* determineGeometry(SubMesh* sm);
622	/** Split some shared geometry into dedicated geometry. */
623	void splitGeometry(VertexData* vd, IndexData* id,
624	SubMeshLodGeometryLink* targetGeomLink);
625
626	typedef map<size_t, size_t>::type IndexRemap;
627	/** Method for figuring out which vertices are used by an index buffer
628	and calculating a remap lookup for a vertex buffer just containing
629	those vertices.
630	*/
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	}
643	/** Method for altering indexes based on a remap. */
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	}
656
657	public:
658	/// Constructor; do not use directly (@see SceneManager::createInstancedGeometry)
659	InstancedGeometry(SceneManager* owner, const String& name);
660	/// Destructor
661	virtual ~InstancedGeometry();
662
663	/// Get the name of this object
664	const String& getName(void) const { return mName; }
665	/** Adds an Entity to the static geometry.
666	@remarks
667	This method takes an existing Entity and adds its details to the
668	list of elements to include when building. Note that the Entity
669	itself is not copied or referenced in this method; an Entity is
670	passed simply so that you can change the materials of attached
671	SubEntity objects if you want. You can add the same Entity
672	instance multiple times with different material settings
673	completely safely, and destroy the Entity before destroying
674	this InstancedGeometry if you like. The Entity passed in is simply
675	used as a definition.
676	@note Must be called before 'build'.
677	@note All added entities must use the same LOD strategy.
678	@param ent The Entity to use as a definition (the Mesh and Materials
679	referenced will be recorded for the build call).
680	@param position The world position at which to add this Entity
681	@param orientation The world orientation at which to add this Entity
682	@param scale The scale at which to add this entity
683	*/
684	virtual void addEntity(Entity* ent, const Vector3& position,
685	const Quaternion& orientation = Quaternion::IDENTITY,
686	const Vector3& scale = Vector3::UNIT_SCALE);
687
688	/** Adds all the Entity objects attached to a SceneNode and all it's
689	children to the static geometry.
690	@remarks
691	This method performs just like addEntity, except it adds all the
692	entities attached to an entire sub-tree to the geometry.
693	The position / orientation / scale parameters are taken from the
694	node structure instead of being specified manually.
695	@note
696	The SceneNode you pass in will not be automatically detached from
697	it's parent, so if you have this node already attached to the scene
698	graph, you will need to remove it if you wish to avoid the overhead
699	of rendering <i>both</i> the original objects and their new static
700	versions! We don't do this for you incase you are preparing this
701	in advance and so don't want the originals detached yet.
702	@note Must be called before 'build'.
703	@note All added entities must use the same LOD strategy.
704	@param node Pointer to the node to use to provide a set of Entity
705	templates
706	*/
707	virtual void addSceneNode(const SceneNode* node);
708
709	/** Build the geometry.
710	@remarks
711	Based on all the entities which have been added, and the batching
712	options which have been set, this method constructs the batched
713	geometry structures required. The batches are added to the scene
714	and will be rendered unless you specifically hide them.
715	@note
716	Once you have called this method, you can no longer add any more
717	entities.
718	*/
719	virtual void build(void);
720	/** Add a new batch instance
721	@remarks
722	This method add a new instance of the whole batch, by creating a new
723	BatchInstance, containing new LOD buckets, material buckets and geometry buckets.
724	The new geometry buckets will use the same buffers as the base bucket.
725	@note
726	no note
727	*/
728	void addBatchInstance(void);
729	/** Destroys all the built geometry state (reverse of build).
730	@remarks
731	You can call build() again after this and it will pick up all the
732	same entities / nodes you queued last time.
733	*/
734	virtual void destroy(void);
735
736	/** Clears any of the entities / nodes added to this geometry and
737	destroys anything which has already been built.
738	*/
739	virtual void reset(void);
740
741	/** Sets the distance at which batches are no longer rendered.
742	@remarks
743	This lets you turn off batches at a given distance. This can be
744	useful for things like detail meshes (grass, foliage etc) and could
745	be combined with a shader which fades the geometry out beforehand
746	to lessen the effect.
747	@param dist Distance beyond which the batches will not be rendered
748	(the default is 0, which means batches are always rendered).
749	*/
750	virtual void setRenderingDistance(Real dist) {
751	mUpperDistance = dist;
752	mSquaredUpperDistance = mUpperDistance * mUpperDistance;
753	}
754
755	/** Gets the distance at which batches are no longer rendered. */
756	virtual Real getRenderingDistance(void) const { return mUpperDistance; }
757
758	/** Gets the squared distance at which batches are no longer rendered. */
759	virtual Real getSquaredRenderingDistance(void) const
760	{ return mSquaredUpperDistance; }
761
762	/** Hides or shows all the batches. */
763	virtual void setVisible(bool visible);
764
765	/** Are the batches visible? */
766	virtual bool isVisible(void) const { return mVisible; }
767
768	/** Sets whether this geometry should cast shadows.
769	@remarks
770	No matter what the settings on the original entities,
771	the InstancedGeometry class defaults to not casting shadows.
772	This is because, being static, unless you have moving lights
773	you'd be better to use precalculated shadows of some sort.
774	However, if you need them, you can enable them using this
775	method. If the SceneManager is set up to use stencil shadows,
776	edge lists will be copied from the underlying meshes on build.
777	It is essential that all meshes support stencil shadows in this
778	case.
779	@note If you intend to use stencil shadows, you must set this to
780	true before calling 'build' as well as making sure you set the
781	scene's shadow type (that should always be the first thing you do
782	anyway). You can turn shadows off temporarily but they can never
783	be turned on if they were not at the time of the build.
784	*/
785	virtual void setCastShadows(bool castShadows);
786	/// Will the geometry from this object cast shadows?
787	virtual bool getCastShadows(void) { return mCastShadows; }
788
789	/** Sets the size of a single BatchInstance of geometry.
790	@remarks
791	This method allows you to configure the physical world size of
792	each BatchInstance, so you can balance culling against batch size. Entities
793	will be fitted within the batch they most closely fit, and the
794	eventual bounds of each batch may well be slightly larger than this
795	if they overlap a little. The default is Vector3(1000, 1000, 1000).
796	@note Must be called before 'build'.
797	@param size Vector3 expressing the 3D size of each BatchInstance.
798	*/
799	virtual void setBatchInstanceDimensions(const Vector3& size) {
800	mBatchInstanceDimensions = size;
801	mHalfBatchInstanceDimensions = size * 0.5;
802	}
803	/** Gets the size of a single batch of geometry. */
804	virtual const Vector3& getBatchInstanceDimensions(void) const { return mBatchInstanceDimensions; }
805	/** Sets the origin of the geometry.
806	@remarks
807	This method allows you to configure the world centre of the geometry,
808	thus the place which all BatchInstances surround. You probably don't need
809	to mess with this unless you have a seriously large world, since the
810	default set up can handle an area 1024 * mBatchInstanceDimensions, and
811	the sparseness of population is no issue when it comes to rendering.
812	The default is Vector3(0,0,0).
813	@note Must be called before 'build'.
814	@param origin Vector3 expressing the 3D origin of the geometry.
815	*/
816	virtual void setOrigin(const Vector3& origin) { mOrigin = origin; }
817	/** Gets the origin of this geometry. */
818	virtual const Vector3& getOrigin(void) const { return mOrigin; }
819
820	/** Sets the render queue group this object will be rendered through.
821	@remarks
822	Render queues are grouped to allow you to more tightly control the ordering
823	of rendered objects. If you do not call this method, all objects default
824	to the default queue (RenderQueue::getDefaultQueueGroup), which is fine for
825	most objects. You may want to alter this if you want to perform more complex
826	rendering.
827	@par
828	See RenderQueue for more details.
829	@param queueID Enumerated value of the queue group to use.
830	*/
831	virtual void setRenderQueueGroup(uint8 queueID);
832
833	/** Gets the queue group for this entity, see setRenderQueueGroup for full details. */
834	virtual uint8 getRenderQueueGroup(void) const;
835	/// Iterator for iterating over contained BatchInstances
836	typedef MapIterator<BatchInstanceMap> BatchInstanceIterator;
837	/// Get an iterator over the BatchInstances in this geometry
838	BatchInstanceIterator getBatchInstanceIterator(void);
839	/// get the mRenderOps vector.
840	RenderOperationVector& getRenderOperationVector(){return mRenderOps;}
841	/// @copydoc MovableObject::visitRenderables
842	void visitRenderables(Renderable::Visitor* visitor,
843	bool debugRenderables = false);
844
845	/** Dump the contents of this InstancedGeometry to a file for diagnostic
846	purposes.
847	*/
848	virtual void dump(const String& filename) const;
849	/**
850	@remarks
851	Return the skeletonInstance that will be used
852	*/
853	SkeletonInstance *getBaseSkeletonInstance(void){return mSkeletonInstance;}
854	/**
855	@remarks
856	Return the skeleton that is shared by all instanced objects.
857	*/
858	SkeletonPtr getBaseSkeleton(void){return mBaseSkeleton;}
859	/**
860	@remarks
861	Return the animation state that will be cloned each time an InstancedObject is made
862	*/
863	AnimationStateSet* getBaseAnimationState(void){return mAnimationState;}
864	/**
865	@remarks
866	return the total number of object that are in all the batches
867	*/
868	unsigned int getObjectCount(void){return mObjectCount;}
869
870	/**
871	@remarks
872	Allows World Transform Inverse matrices to be passed as shader constants along with the world
873	transform matrix list. Reduces the number of usable geometries in an instance to 40 instead of 80.
874	The inverse matrices are interleaved with the world matrices at n+1.
875	*/
876	virtual void setProvideWorldInverses(bool flag);
877
878	/**
879	@remarks
880	Returns the toggle state indicating whether the World Transform INVERSE matrices would
881	be passed to the shaders.
882	*/
883	virtual bool getProvideWorldInverses(void) const { return mProvideWorldInverses; }
884	};
885
886	/** @} */
887	/** @} */
888	}
889
890	#include "OgreHeaderSuffix.h"
891
892	#endif
893

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: downloads/ogre_src_v1-9-0/OgreMain/include/OgreInstancedGeometry.h @ 148

Download in other formats: