OgreStaticGeometry.h
Go to the documentation of this file.
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4(Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2013 Torus Knot Software Ltd
8
9Permission is hereby granted, free of charge, to any person obtaining a copy
10of this software and associated documentation files (the "Software"), to deal
11in the Software without restriction, including without limitation the rights
12to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13copies of the Software, and to permit persons to whom the Software is
14furnished to do so, subject to the following conditions:
15
16The above copyright notice and this permission notice shall be included in
17all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25THE SOFTWARE.
26-----------------------------------------------------------------------------
27*/
28#ifndef __StaticGeometry_H__
29#define __StaticGeometry_H__
30
31#include "OgrePrerequisites.h"
32#include "OgreMovableObject.h"
33#include "OgreRenderable.h"
34#include "OgreMesh.h"
35#include "OgreLodStrategy.h"
36#include "OgreHeaderPrefix.h"
37
38namespace Ogre {
39
122 {
123 public:
137 {
138 public:
139 OptimisedSubMeshGeometry() :vertexData(0), indexData(0) {}
141 {
142 OGRE_DELETE vertexData;
143 OGRE_DELETE indexData;
144 }
147 };
152 {
155 };
160 {
170 };
174 {
179 };
181
182 // forward declarations
183 class LODBucket;
184 class MaterialBucket;
185 class Region;
186
192 {
193 protected:
210
211 template<typename T>
212 void copyIndexes(const T* src, T* dst, size_t count, size_t indexOffset)
213 {
214 if (indexOffset == 0)
215 {
216 memcpy(dst, src, sizeof(T) * count);
217 }
218 else
219 {
220 while(count--)
221 {
222 *dst++ = static_cast<T>(*src++ + indexOffset);
223 }
224 }
225 }
226 public:
228 const VertexData* vData, const IndexData* iData);
230 MaterialBucket* getParent(void) { return mParent; }
232 const VertexData* getVertexData(void) const { return mVertexData; }
234 const IndexData* getIndexData(void) const { return mIndexData; }
236 const MaterialPtr& getMaterial(void) const;
241 const LightList& getLights(void) const;
242 bool getCastsShadows(void) const;
243
251 void dump(std::ofstream& of) const;
252 };
256 {
257 public:
260 protected:
269
272 // index to current Geometry Buckets for a given geometry format
277
278 public:
279 MaterialBucket(LODBucket* parent, const String& materialName);
281 LODBucket* getParent(void) { return mParent; }
283 const String& getMaterialName(void) const { return mMaterialName; }
290 Real lodValue);
292 const MaterialPtr& getMaterial(void) const { return mMaterial; }
298 Technique* getCurrentTechnique(void) const { return mTechnique; }
300 void dump(std::ofstream& of) const;
302 };
309 {
310 public:
313 protected:
316 {
317 protected:
319 // Shared link to position buffer
321 // Shared link to w-coord buffer (optional)
323
324 public:
326 HardwareIndexBufferSharedPtr* indexBuffer, const VertexData* vertexData,
327 bool createSeparateLightCap, bool isLightCap = false);
331 HardwareVertexBufferSharedPtr getPositionBuffer(void) { return mPositionBuffer; }
332 HardwareVertexBufferSharedPtr getWBuffer(void) { return mWBuffer; }
334 virtual void rebindIndexBuffer(const HardwareIndexBufferSharedPtr& indexBuffer);
335
336 };
340 unsigned short mLod;
353 public:
354 LODBucket(Region* parent, unsigned short lod, Real lodValue);
355 virtual ~LODBucket();
356 Region* getParent(void) { return mParent; }
358 ushort getLod(void) const { return mLod; }
360 Real getLodValue(void) const { return mLodValue; }
367 Real lodValue);
373 void dump(std::ofstream& of) const;
375 EdgeData* getEdgeList() const { return mEdgeList; }
377 bool isVertexProgramInUse() const { return mVertexProgramInUse; }
380 HardwareIndexBufferSharedPtr* indexBuffer,
381 bool extrudeVertices, Real extrusionDistance, unsigned long flags = 0 );
382
383 };
393 {
394 friend class MaterialBucket;
395 friend class GeometryBucket;
396 public:
399 protected:
434
435 public:
436 Region(StaticGeometry* parent, const String& name, SceneManager* mgr,
437 uint32 regionID, const Vector3& centre);
438 virtual ~Region();
439 // more fields can be added in subclasses
440 StaticGeometry* getParent(void) const { return mParent;}
446 uint32 getID(void) const { return mRegionID; }
448 const Vector3& getCentre(void) const { return mCentre; }
449 const String& getMovableType(void) const;
451 const AxisAlignedBox& getBoundingBox(void) const;
456 bool debugRenderables = false);
457 bool isVisible(void) const;
458 uint32 getTypeFlags(void) const;
459
467 bool extrudeVertices, Real extrusionDistance, unsigned long flags = 0 );
471 bool hasEdgeList(void);
472
474 void dump(std::ofstream& of) const;
475
476 };
485 protected:
486 // General state & settings
489 bool mBuilt;
503
505
509
515
518
524 virtual Region* getRegion(const Vector3& point, bool autoCreate);
528 virtual Region* getRegion(uint32 index);
531 virtual void getRegionIndexes(const Vector3& point,
532 ushort& x, ushort& y, ushort& z);
539 ushort x, ushort y, ushort z);
548 const Vector3& position, const Quaternion& orientation,
549 const Vector3& scale);
555
561 template <typename T>
563 {
564 remap.clear();
565 for (size_t i = 0; i < numIndexes; ++i)
566 {
567 // use insert since duplicates are silently discarded
568 remap.insert(IndexRemap::value_type(*pBuffer++, remap.size()));
569 // this will have mapped oldindex -> new index IF oldindex
570 // wasn't already there
571 }
572 }
574 template <typename T>
575 void remapIndexes(T* src, T* dst, const IndexRemap& remap,
576 size_t numIndexes)
577 {
578 for (size_t i = 0; i < numIndexes; ++i)
579 {
580 // look up original and map to target
581 IndexRemap::const_iterator ix = remap.find(*src++);
582 assert(ix != remap.end());
583 *dst++ = static_cast<T>(ix->second);
584 }
585 }
586
587 public:
592
594 const String& getName(void) const { return mName; }
613 virtual void addEntity(Entity* ent, const Vector3& position,
614 const Quaternion& orientation = Quaternion::IDENTITY,
615 const Vector3& scale = Vector3::UNIT_SCALE);
616
635 virtual void addSceneNode(const SceneNode* node);
636
647 virtual void build(void);
648
654 virtual void destroy(void);
655
659 virtual void reset(void);
660
671 mUpperDistance = dist;
672 mSquaredUpperDistance = mUpperDistance * mUpperDistance;
673 }
674
676 virtual Real getRenderingDistance(void) const { return mUpperDistance; }
677
680 { return mSquaredUpperDistance; }
681
683 virtual void setVisible(bool visible);
684
686 virtual bool isVisible(void) const { return mVisible; }
687
705 virtual void setCastShadows(bool castShadows);
707 virtual bool getCastShadows(void) { return mCastShadows; }
708
719 virtual void setRegionDimensions(const Vector3& size) {
720 mRegionDimensions = size;
721 mHalfRegionDimensions = size * 0.5;
722 }
724 virtual const Vector3& getRegionDimensions(void) const { return mRegionDimensions; }
736 virtual void setOrigin(const Vector3& origin) { mOrigin = origin; }
738 virtual const Vector3& getOrigin(void) const { return mOrigin; }
739
744
757
759 virtual uint8 getRenderQueueGroup(void) const;
762 bool debugRenderables = false);
763
768
772 virtual void dump(const String& filename) const;
773
774
775 };
779}
780
781#include "OgreHeaderSuffix.h"
782
783#endif
784
#define _OgreExport
#define _OgrePrivate
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
A 3D box aligned with the x/y/z axes.
A viewpoint from which the scene will be rendered.
Definition OgreCamera.h:87
This class contains the information required to describe the edge connectivity of a given set of vert...
Defines an instance of a discrete, movable object based on a Mesh.
Definition OgreEntity.h:83
Shared pointer implementation used to share index buffers.
Shared pointer implementation used to share vertex buffers.
Summary class collecting together index data source information.
Representation of a dynamic light source in the scene.
Definition OgreLight.h:74
Strategy for determining level of detail.
Class encapsulating a standard 4x4 homogeneous matrix.
Definition OgreMatrix4.h:79
Abstract class defining a movable object in a scene.
Implementation of a Quaternion, i.e.
'New' rendering operation using vertex buffers.
Class to manage the scene object rendering queue.
Visitor object that can be used to iterate over a collection of Renderable instances abstractly.
Abstract class defining the interface all renderable objects must implement.
Manages the organisation and rendering of a 'scene' i.e.
Class representing a node in the scene graph.
Class which represents the renderable aspects of a set of shadow volume faces.
Reference-counted shared pointer, used for objects where implicit destruction is required.
A GeometryBucket is a the lowest level bucket where geometry with the same vertex & index format is s...
void build(bool stencilShadows)
Build.
VertexData * mVertexData
Vertex information, includes current number of vertices committed to be a part of this bucket.
const IndexData * getIndexData(void) const
Get the index data for this geometry.
QueuedGeometryList mQueuedGeometry
Geometry which has been queued up pre-build (not for deallocation)
bool assign(QueuedGeometry *qsm)
Try to assign geometry to this bucket.
void dump(std::ofstream &of) const
Dump contents for diagnostics.
void getRenderOperation(RenderOperation &op)
Gets the render operation required to send this object to the frame buffer.
const LightList & getLights(void) const
Gets a list of lights, ordered relative to how close they are to this renderable.
const MaterialPtr & getMaterial(void) const
Retrieves a weak reference to the material this renderable object uses.
Real getSquaredViewDepth(const Camera *cam) const
Returns the camera-relative squared depth of this renderable.
HardwareIndexBuffer::IndexType mIndexType
Size of indexes.
Technique * getTechnique(void) const
Retrieves a pointer to the Material Technique this renderable object uses.
bool getCastsShadows(void) const
Method which reports whether this renderable would normally cast a shadow.
String mFormatString
String identifying the vertex / index format.
IndexData * mIndexData
Index information, includes index type which limits the max number of vertices which are allowed in o...
const VertexData * getVertexData(void) const
Get the vertex data for this geometry.
GeometryBucket(MaterialBucket *parent, const String &formatString, const VertexData *vData, const IndexData *iData)
void copyIndexes(const T *src, T *dst, size_t count, size_t indexOffset)
void getWorldTransforms(Matrix4 *xform) const
Gets the world transform matrix / matrices for this renderable object.
MaterialBucket * mParent
Pointer to parent bucket.
size_t mMaxVertexIndex
Maximum vertex indexable.
virtual void rebindIndexBuffer(const HardwareIndexBufferSharedPtr &indexBuffer)
Overridden from ShadowRenderable.
LODShadowRenderable(LODBucket *parent, HardwareIndexBufferSharedPtr *indexBuffer, const VertexData *vertexData, bool createSeparateLightCap, bool isLightCap=false)
HardwareVertexBufferSharedPtr getPositionBuffer(void)
void getWorldTransforms(Matrix4 *xform) const
Overridden from ShadowRenderable.
A LODBucket is a collection of smaller buckets with the same LOD.
LODBucket(Region *parent, unsigned short lod, Real lodValue)
QueuedGeometryList mQueuedGeometryList
Geometry queued for a single LOD (deallocated here)
Region * mParent
Pointer to parent region.
bool mVertexProgramInUse
Is a vertex program in use somewhere in this group?
ShadowCaster::ShadowRenderableList & getShadowRenderableList()
void dump(std::ofstream &of) const
Dump contents for diagnostics.
map< String, MaterialBucket * >::type MaterialBucketMap
Lookup of Material Buckets in this region.
void assign(QueuedSubMesh *qsm, ushort atLod)
Assign a queued submesh to this bucket, using specified mesh LOD.
MapIterator< MaterialBucketMap > MaterialIterator
Iterator over the materials in this LOD.
void addRenderables(RenderQueue *queue, uint8 group, Real lodValue)
Add children to the render queue.
unsigned short mLod
LOD level (0 == full LOD)
EdgeData * mEdgeList
Edge list, used if stencil shadow casting is enabled.
ushort getLod(void) const
Get the LOD index.
ShadowCaster::ShadowRenderableList mShadowRenderables
List of shadow renderables.
Real mLodValue
LOD value at which this LOD starts to apply (squared)
void updateShadowRenderables(ShadowTechnique shadowTechnique, const Vector4 &lightPos, HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Real extrusionDistance, unsigned long flags=0)
void build(bool stencilShadows)
Build.
MaterialIterator getMaterialIterator(void)
Get an iterator over the materials in this LOD.
void visitRenderables(Renderable::Visitor *visitor, bool debugRenderables)
Real getLodValue(void) const
Get the LOD value.
MaterialBucketMap mMaterialBucketMap
Lookup of Material Buckets in this region.
A MaterialBucket is a collection of smaller buckets with the same Material (and implicitly the same L...
void dump(std::ofstream &of) const
Dump contents for diagnostics.
map< String, GeometryBucket * >::type CurrentGeometryMap
Technique * getCurrentTechnique(void) const
Get the current Technique.
Technique * mTechnique
Active technique.
const String & getMaterialName(void) const
Get the material name.
void assign(QueuedGeometry *qsm)
Assign geometry to this bucket.
LODBucket * mParent
Pointer to parent LODBucket.
GeometryBucketList mGeometryBucketList
list of Geometry Buckets in this region
MaterialPtr mMaterial
Pointer to material being used.
void build(bool stencilShadows)
Build.
VectorIterator< GeometryBucketList > GeometryIterator
Iterator over geometry.
vector< GeometryBucket * >::type GeometryBucketList
list of Geometry Buckets in this region
void visitRenderables(Renderable::Visitor *visitor, bool debugRenderables)
String getGeometryFormatString(SubMeshLodGeometryLink *geom)
Get a packed string identifying the geometry format.
const MaterialPtr & getMaterial(void) const
Get the material for this bucket.
void addRenderables(RenderQueue *queue, uint8 group, Real lodValue)
Add children to the render queue.
String mMaterialName
Material being used.
MaterialBucket(LODBucket *parent, const String &materialName)
GeometryIterator getGeometryIterator(void)
Get an iterator over the contained geometry.
Struct holding geometry optimised per SubMesh / LOD level, ready for copying to instances.
The details of a topological region which is the highest level of partitioning for this class.
Real mSquaredViewDepth
Cached squared view depth value to avoid recalculation by GeometryBucket.
bool isVisible(void) const
Returns whether or not this object is supposed to be visible or not.
AxisAlignedBox mAABB
Local AABB relative to region centre.
ushort mCurrentLod
The current LOD level, as determined from the last camera.
vector< LODBucket * >::type LODBucketList
list of LOD Buckets in this region
LODBucketList mLodBucketList
List of LOD buckets
EdgeData * getEdgeList(void)
Overridden from MovableObject.
const String & getMovableType(void) const
Returns the type name of this object.
void _updateRenderQueue(RenderQueue *queue)
Internal method by which the movable object must add Renderable subclass instances to the rendering q...
Vector3 mCentre
Center of the region.
ulong mLightListUpdated
The last frame that this light list was updated in.
SceneManager * mSceneMgr
Scene manager link.
LODIterator getLODIterator(void)
Get an iterator over the LODs in this region.
StaticGeometry * mParent
Parent static geometry.
void dump(std::ofstream &of) const
Dump contents for diagnostics.
bool hasEdgeList(void)
Overridden member from ShadowCaster.
Real getBoundingRadius(void) const
Retrieves the radius of the origin-centered bounding sphere for this object.
VectorIterator< LODBucketList > LODIterator
uint32 mRegionID
Unique identifier for the region.
QueuedSubMeshList mQueuedSubMeshes
Local list of queued meshes (not used for deallocation)
ShadowRenderableListIterator getShadowVolumeRenderableIterator(ShadowTechnique shadowTechnique, const Light *light, HardwareIndexBufferSharedPtr *indexBuffer, size_t *indexBufferUsedSize, bool extrudeVertices, Real extrusionDistance, unsigned long flags=0)
Gets an iterator over the renderables required to render the shadow volume.
Camera * mCamera
Current camera.
void _notifyCurrentCamera(Camera *cam)
Internal method to notify the object of the camera to be used for the next rendering operation.
StaticGeometry * getParent(void) const
LightList mLightList
List of lights for this region.
void assign(QueuedSubMesh *qmesh)
Assign a queued mesh to this region, read for final build.
Real mLodValue
Current LOD value, passed on to do material LOD later.
Region(StaticGeometry *parent, const String &name, SceneManager *mgr, uint32 regionID, const Vector3 &centre)
const Vector3 & getCentre(void) const
Get the centre point of the region.
const LodStrategy * mLodStrategy
LOD strategy reference.
uint32 getTypeFlags(void) const
Get the 'type flags' for this MovableObject.
Mesh::LodValueList mLodValues
LOD values as built up - use the max at each level.
void visitRenderables(Renderable::Visitor *visitor, bool debugRenderables=false)
Method to allow a caller to abstractly iterate over the Renderable instances that this MovableObject ...
const AxisAlignedBox & getBoundingBox(void) const
Retrieves the local axis-aligned bounding box for this object.
void build(bool stencilShadows)
Build this region.
uint32 getID(void) const
Get the region ID of this region.
Real mBoundingRadius
Local bounding radius.
Pre-transforms and batches up meshes for efficient use as static geometry in a scene.
void setVisibilityFlags(uint32 flags)
Sets the visibility flags of all the regions at once.
virtual void build(void)
Build the geometry.
StaticGeometry(SceneManager *owner, const String &name)
Constructor; do not use directly (.
RegionMap mRegionMap
Map of regions.
virtual void reset(void)
Clears any of the entities / nodes added to this geometry and destroys anything which has already bee...
bool mRenderQueueIDSet
Flags whether the RenderQueue's default should be used.
uint32 mVisibilityFlags
Stores the visibility flags for the regions.
virtual uint8 getRenderQueueGroup(void) const
Gets the queue group for this entity, see setRenderQueueGroup for full details.
virtual Region * getRegion(const Vector3 &point, bool autoCreate)
Get the region within which a point lies.
void remapIndexes(T *src, T *dst, const IndexRemap &remap, size_t numIndexes)
Method for altering indexes based on a remap.
SubMeshLodGeometryLinkList * determineGeometry(SubMesh *sm)
Look up or calculate the geometry data to use for this SubMesh.
virtual const Vector3 & getOrigin(void) const
Gets the origin of this geometry.
virtual void setRenderingDistance(Real dist)
Sets the distance at which batches are no longer rendered.
virtual bool getCastShadows(void)
Will the geometry from this object cast shadows?
virtual const Vector3 & getRegionDimensions(void) const
Gets the size of a single batch of geometry.
uint8 mRenderQueueID
The render queue to use when rendering this object.
virtual void getRegionIndexes(const Vector3 &point, ushort &x, ushort &y, ushort &z)
Get the region indexes for a point.
RegionIterator getRegionIterator(void)
Get an iterator over the regions in this geometry.
map< uint32, Region * >::type RegionMap
Indexed region map based on packed x/y/z region index, 10 bits for each axis.
virtual void destroy(void)
Destroys all the built geometry state (reverse of build).
virtual Real getVolumeIntersection(const AxisAlignedBox &box, ushort x, ushort y, ushort z)
Get the volume intersection for an indexed region with some bounds.
uint32 getVisibilityFlags() const
Returns the visibility flags of the regions.
const String & getName(void) const
Get the name of this object.
virtual uint32 packIndex(ushort x, ushort y, ushort z)
Pack 3 indexes into a single index value.
OptimisedSubMeshGeometryList mOptimisedSubMeshGeometryList
List of geometry which has been optimised for SubMesh use This is the primary storage used for cleani...
virtual ~StaticGeometry()
Destructor.
virtual void setCastShadows(bool castShadows)
Sets whether this geometry should cast shadows.
map< SubMesh *, SubMeshLodGeometryLinkList * >::type SubMeshGeometryLookup
virtual void setOrigin(const Vector3 &origin)
Sets the origin of the geometry.
QueuedSubMeshList mQueuedSubMeshes
void visitRenderables(Renderable::Visitor *visitor, bool debugRenderables=false)
Method to allow a caller to abstractly iterate over the Renderable instances that this MovableObject ...
virtual void setRenderQueueGroup(uint8 queueID)
Sets the render queue group this object will be rendered through.
virtual void setRegionDimensions(const Vector3 &size)
Sets the size of a single region of geometry.
map< size_t, size_t >::type IndexRemap
virtual void addEntity(Entity *ent, const Vector3 &position, const Quaternion &orientation=Quaternion::IDENTITY, const Vector3 &scale=Vector3::UNIT_SCALE)
Adds an Entity to the static geometry.
virtual Region * getRegion(const AxisAlignedBox &bounds, bool autoCreate)
Virtual method for getting a region most suitable for the passed in bounds.
vector< QueuedGeometry * >::type QueuedGeometryList
virtual void addSceneNode(const SceneNode *node)
Adds all the Entity objects attached to a SceneNode and all it's children to the static geometry.
virtual void setVisible(bool visible)
Hides or shows all the batches.
virtual Real getSquaredRenderingDistance(void) const
Gets the squared distance at which batches are no longer rendered.
virtual AxisAlignedBox calculateBounds(VertexData *vertexData, const Vector3 &position, const Quaternion &orientation, const Vector3 &scale)
Calculate world bounds from a set of vertex data.
MapIterator< RegionMap > RegionIterator
Iterator for iterating over contained regions.
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...
void splitGeometry(VertexData *vd, IndexData *id, SubMeshLodGeometryLink *targetGeomLink)
Split some shared geometry into dedicated geometry.
virtual void dump(const String &filename) const
Dump the contents of this StaticGeometry to a file for diagnostic purposes.
vector< QueuedSubMesh * >::type QueuedSubMeshList
virtual Region * getRegion(uint32 index)
Get the region using a packed index, returns null if it doesn't exist.
virtual bool isVisible(void) const
Are the batches visible?
virtual AxisAlignedBox getRegionBounds(ushort x, ushort y, ushort z)
Get the bounds of an indexed region.
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.
vector< SubMeshLodGeometryLink >::type SubMeshLodGeometryLinkList
virtual Vector3 getRegionCentre(ushort x, ushort y, ushort z)
Get the centre of an indexed region.
virtual Region * getRegion(ushort x, ushort y, ushort z, bool autoCreate)
Get the region using indexes.
list< OptimisedSubMeshGeometry * >::type OptimisedSubMeshGeometryList
Defines a part of a complete mesh.
Definition OgreSubMesh.h:63
Class representing an approach to rendering this particular Material.
Standard 3-dimensional vector.
Definition OgreVector3.h:52
4-dimensional homogeneous vector.
Definition OgreVector4.h:46
Summary class collecting together vertex source information.
ShadowTechnique
An enumeration of broad shadow techniques.
Definition OgreCommon.h:191
#define OGRE_DELETE
float Real
Software floating point type.
_StringBase String
Structure recording a queued geometry for low level builds.
Structure recording a queued submesh for the build.
SubMeshLodGeometryLinkList * geometryLodList
Link to LOD list of geometry, potentially optimised.
AxisAlignedBox worldBounds
Pre-transformed world AABB.
std::list< T, A > type
std::map< K, V, P, A > type
std::vector< T, A > type

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