OgreBillboardSet.h
Go to the documentation of this file.
/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/
Copyright (c) 2000-2013 Torus Knot Software Ltd
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __BillboardSet_H__
#define __BillboardSet_H__
#include "OgrePrerequisites.h"
#include "OgreMovableObject.h"
#include "OgreRenderable.h"
#include "OgreRadixSort.h"
#include "OgreCommon.h"
#include "OgreResourceGroupManager.h"
#include "OgreHeaderPrefix.h"
namespace Ogre {
enum BillboardOrigin
{
BBO_TOP_LEFT,
BBO_TOP_CENTER,
BBO_TOP_RIGHT,
BBO_CENTER_LEFT,
BBO_CENTER,
BBO_CENTER_RIGHT,
BBO_BOTTOM_LEFT,
BBO_BOTTOM_CENTER,
BBO_BOTTOM_RIGHT
};
enum BillboardRotationType
{
BBR_VERTEX,
BBR_TEXCOORD
};
enum BillboardType
{
BBT_POINT,
BBT_ORIENTED_COMMON,
BBT_ORIENTED_SELF,
BBT_PERPENDICULAR_COMMON,
BBT_PERPENDICULAR_SELF
};
class _OgreExport BillboardSet : public MovableObject, public Renderable
{
protected:
BillboardSet();
AxisAlignedBox mAABB;
Real mBoundingRadius;
BillboardOrigin mOriginType;
BillboardRotationType mRotationType;
Real mDefaultWidth;
Real mDefaultHeight;
String mMaterialName;
MaterialPtr mMaterial;
bool mAllDefaultSize;
bool mAutoExtendPool;
bool mSortingEnabled;
bool mAccurateFacing;
bool mAllDefaultRotation;
bool mWorldSpace;
typedef list<Billboard*>::type ActiveBillboardList;
typedef list<Billboard*>::type FreeBillboardList;
typedef vector<Billboard*>::type BillboardPool;
ActiveBillboardList mActiveBillboards;
FreeBillboardList mFreeBillboards;
BillboardPool mBillboardPool;
VertexData* mVertexData;
HardwareVertexBufferSharedPtr mMainBuf;
float* mLockPtr;
Vector3 mVOffset[4];
Camera* mCurrentCamera;
Real mLeftOff, mRightOff, mTopOff, mBottomOff;
Vector3 mCamX, mCamY;
Vector3 mCamDir;
Quaternion mCamQ;
Vector3 mCamPos;
IndexData* mIndexData;
bool mCullIndividual;
typedef vector< Ogre::FloatRect >::type TextureCoordSets;
TextureCoordSets mTextureCoords;
BillboardType mBillboardType;
Vector3 mCommonDirection;
Vector3 mCommonUpVector;
inline bool billboardVisible(Camera* cam, const Billboard& bill);
unsigned short mNumVisibleBillboards;
virtual void increasePool(size_t size);
//-----------------------------------------------------------------------
// The internal methods which follow are here to allow maximum flexibility as to
// when various components of the calculation are done. Depending on whether the
// billboards are of fixed size and whether they are point or oriented type will
// determine how much calculation has to be done per-billboard. NOT a one-size fits all approach.
//-----------------------------------------------------------------------
void genBillboardAxes(Vector3* pX, Vector3 *pY, const Billboard* pBill = 0);
void getParametricOffsets(Real& left, Real& right, Real& top, Real& bottom);
void genVertices(const Vector3* const offsets, const Billboard& pBillboard);
void genVertOffsets(Real inleft, Real inright, Real intop, Real inbottom,
Real width, Real height,
const Vector3& x, const Vector3& y, Vector3* pDestVec);
struct SortByDirectionFunctor
{
Vector3 sortDir;
SortByDirectionFunctor(const Vector3& dir);
float operator()(Billboard* bill) const;
};
struct SortByDistanceFunctor
{
Vector3 sortPos;
SortByDistanceFunctor(const Vector3& pos);
float operator()(Billboard* bill) const;
};
static RadixSort<ActiveBillboardList, Billboard*, float> mRadixSorter;
bool mPointRendering;
private:
bool mBuffersCreated;
size_t mPoolSize;
bool mExternalData;
bool mAutoUpdate;
bool mBillboardDataChanged;
void _createBuffers(void);
void _destroyBuffers(void);
public:
BillboardSet( const String& name, unsigned int poolSize = 20,
bool externalDataSource = false);
virtual ~BillboardSet();
Billboard* createBillboard(
const Vector3& position,
const ColourValue& colour = ColourValue::White );
Billboard* createBillboard(
Real x, Real y, Real z,
const ColourValue& colour = ColourValue::White );
virtual int getNumBillboards(void) const;
virtual void setAutoextend(bool autoextend);
virtual bool getAutoextend(void) const;
virtual void setSortingEnabled(bool sortenable);
virtual bool getSortingEnabled(void) const;
virtual void setPoolSize(size_t size);
virtual unsigned int getPoolSize(void) const;
virtual void clear();
virtual Billboard* getBillboard(unsigned int index) const;
virtual void removeBillboard(unsigned int index);
virtual void removeBillboard(Billboard* pBill);
virtual void setBillboardOrigin(BillboardOrigin origin);
virtual BillboardOrigin getBillboardOrigin(void) const;
virtual void setBillboardRotationType(BillboardRotationType rotationType);
virtual BillboardRotationType getBillboardRotationType(void) const;
virtual void setDefaultDimensions(Real width, Real height);
virtual void setDefaultWidth(Real width);
virtual Real getDefaultWidth(void) const;
virtual void setDefaultHeight(Real height);
virtual Real getDefaultHeight(void) const;
virtual void setMaterialName( const String& name, const String& groupName = ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME );
virtual const String& getMaterialName(void) const;
virtual void _notifyCurrentCamera(Camera* cam);
void beginBillboards(size_t numBillboards = 0);
void injectBillboard(const Billboard& bb);
void endBillboards(void);
void setBounds(const AxisAlignedBox& box, Real radius);
virtual const AxisAlignedBox& getBoundingBox(void) const;
virtual Real getBoundingRadius(void) const;
virtual void _updateRenderQueue(RenderQueue* queue);
virtual const MaterialPtr& getMaterial(void) const;
virtual void setMaterial( const MaterialPtr& material );
virtual void getRenderOperation(RenderOperation& op);
virtual void getWorldTransforms(Matrix4* xform) const;
virtual void _notifyBillboardResized(void);
virtual void _notifyBillboardRotated(void);
virtual bool getCullIndividually(void) const;
virtual void setCullIndividually(bool cullIndividual);
virtual void setBillboardType(BillboardType bbt);
virtual BillboardType getBillboardType(void) const;
virtual void setCommonDirection(const Vector3& vec);
virtual const Vector3& getCommonDirection(void) const;
virtual void setCommonUpVector(const Vector3& vec);
virtual const Vector3& getCommonUpVector(void) const;
virtual void setUseAccurateFacing(bool acc) { mAccurateFacing = acc; }
virtual bool getUseAccurateFacing(void) const { return mAccurateFacing; }
virtual const String& getMovableType(void) const;
Real getSquaredViewDepth(const Camera* cam) const;
virtual void _updateBounds(void);
const LightList& getLights(void) const;
void visitRenderables(Renderable::Visitor* visitor,
bool debugRenderables = false);
virtual void _sortBillboards( Camera* cam);
virtual SortMode _getSortMode(void) const;
virtual void setBillboardsInWorldSpace(bool ws) { mWorldSpace = ws; }
virtual void setTextureCoords( Ogre::FloatRect const * coords, uint16 numCoords );
virtual void setTextureStacksAndSlices( uchar stacks, uchar slices );
virtual Ogre::FloatRect const * getTextureCoords( uint16 * oNumCoords );
virtual void setPointRenderingEnabled(bool enabled);
virtual bool isPointRenderingEnabled(void) const
{ return mPointRendering; }
uint32 getTypeFlags(void) const;
void setAutoUpdate(bool autoUpdate);
bool getAutoUpdate(void) const { return mAutoUpdate; }
void notifyBillboardDataChanged(void) { mBillboardDataChanged = true; }
};
class _OgreExport BillboardSetFactory : public MovableObjectFactory
{
protected:
MovableObject* createInstanceImpl( const String& name, const NameValuePairList* params);
public:
BillboardSetFactory() {}
~BillboardSetFactory() {}
static String FACTORY_TYPE_NAME;
const String& getType(void) const;
void destroyInstance( MovableObject* obj);
};
} // namespace Ogre
#include "OgreHeaderSuffix.h"
#endif // __BillboardSet_H__
Ogre::BillboardSet::mBoundingRadius
Real mBoundingRadius
Bounding radius.
Definition: OgreBillboardSet.h:120
Ogre::BillboardSet::mRadixSorter
static RadixSort< ActiveBillboardList, Billboard *, float > mRadixSorter
Definition: OgreBillboardSet.h:285
OgreRadixSort.h
Ogre::BBT_PERPENDICULAR_SELF
Billboards are perpendicular to their own direction vector (their own Z axis, the facing direction) a...
Definition: OgreBillboardSet.h:86
Ogre::BillboardSet::mAllDefaultSize
bool mAllDefaultSize
True if no billboards in this set have been resized - greater efficiency.
Definition: OgreBillboardSet.h:138
Ogre::Renderable
Abstract class defining the interface all renderable objects must implement.
Definition: OgreRenderable.h:63
Ogre::BBO_BOTTOM_LEFT
Definition: OgreBillboardSet.h:62
Ogre::BillboardSet::mCamQ
Quaternion mCamQ
Camera orientation in billboard space.
Definition: OgreBillboardSet.h:200
_OgreExport
#define _OgreExport
Definition: OgrePlatform.h:257
Ogre::BillboardSet::getAutoUpdate
bool getAutoUpdate(void) const
Return the auto update state of this billboard set.
Definition: OgreBillboardSet.h:848
Ogre::list
Definition: OgrePrerequisites.h:505
Ogre::MovableObject
Abstract class defining a movable object in a scene.
Definition: OgreMovableObject.h:60
Ogre::BillboardSet::mRotationType
BillboardRotationType mRotationType
Rotation type of each billboard.
Definition: OgreBillboardSet.h:125
Ogre::BillboardSet::BillboardPool
vector< Billboard * >::type BillboardPool
Definition: OgreBillboardSet.h:154
Ogre::BillboardSet::mWorldSpace
bool mWorldSpace
Definition: OgreBillboardSet.h:150
Ogre::BillboardSet::mCommonUpVector
Vector3 mCommonUpVector
Common up-vector for billboards of type BBT_PERPENDICULAR_SELF and BBT_PERPENDICULAR_COMMON.
Definition: OgreBillboardSet.h:219
Ogre::BillboardSet::mAutoUpdate
bool mAutoUpdate
Tell if vertex buffer should be update automatically.
Definition: OgreBillboardSet.h:300
Ogre::BillboardSet::mNumVisibleBillboards
unsigned short mNumVisibleBillboards
Number of visible billboards (will be == getNumBillboards if mCullIndividual == false) ...
Definition: OgreBillboardSet.h:225
OgreRenderable.h
OgreMovableObject.h
Ogre::BillboardSet::mOriginType
BillboardOrigin mOriginType
Origin of each billboard.
Definition: OgreBillboardSet.h:123
Ogre::VertexData
Summary class collecting together vertex source information.
Definition: OgreVertexIndexData.h:49
Ogre::BBO_BOTTOM_CENTER
Definition: OgreBillboardSet.h:63
Ogre::Quaternion
Implementation of a Quaternion, i.e.
Definition: OgreQuaternion.h:57
Ogre::BillboardSet::mCamY
Vector3 mCamY
Definition: OgreBillboardSet.h:196
Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME
static String AUTODETECT_RESOURCE_GROUP_NAME
Special resource group name which causes resource group to be automatically determined based on searc...
Definition: OgreResourceGroupManager.h:270
Ogre::BillboardSet::mTopOff
Real mTopOff
Definition: OgreBillboardSet.h:194
Ogre::ColourValue
Class representing colour.
Definition: OgreColourValue.h:57
Ogre::BBO_CENTER_LEFT
Definition: OgreBillboardSet.h:59
Ogre::Real
float Real
Software floating point type.
Definition: OgrePrerequisites.h:70
Ogre::BillboardSet::mVertexData
VertexData * mVertexData
The vertex position data for all billboards in this set.
Definition: OgreBillboardSet.h:182
Ogre::BillboardSet::getUseAccurateFacing
virtual bool getUseAccurateFacing(void) const
Gets whether or not billboards use an &#39;accurate&#39; facing model based on the vector from each billboard...
Definition: OgreBillboardSet.h:717
Ogre::BillboardSet::mCommonDirection
Vector3 mCommonDirection
Common direction for billboards of type BBT_ORIENTED_COMMON and BBT_PERPENDICULAR_COMMON.
Definition: OgreBillboardSet.h:217
Ogre::BBO_CENTER_RIGHT
Definition: OgreBillboardSet.h:61
Ogre::RenderQueue
Class to manage the scene object rendering queue.
Definition: OgreRenderQueue.h:92
Ogre::BBR_VERTEX
Rotate the billboard&#39;s vertices around their facing direction.
Definition: OgreBillboardSet.h:70
Ogre::BillboardSet::setBillboardsInWorldSpace
virtual void setBillboardsInWorldSpace(bool ws)
Sets whether billboards should be treated as being in world space.
Definition: OgreBillboardSet.h:745
Ogre::IndexData
Summary class collecting together index data source information.
Definition: OgreVertexIndexData.h:242
Ogre::TRect< float >
Ogre::BillboardOrigin
BillboardOrigin
Enum covering what exactly a billboard&#39;s position means (center, top-left etc).
Definition: OgreBillboardSet.h:54
Ogre::uchar
unsigned char uchar
In order to avoid finger-aches :)
Definition: OgrePrerequisites.h:112
Ogre::BillboardSet::mCurrentCamera
Camera * mCurrentCamera
Current camera.
Definition: OgreBillboardSet.h:192
Ogre::BillboardSet::mActiveBillboards
ActiveBillboardList mActiveBillboards
Active billboard list.
Definition: OgreBillboardSet.h:164
Ogre::BillboardSet::mPoolSize
size_t mPoolSize
The number of billboard in the pool.
Definition: OgreBillboardSet.h:296
Ogre::BillboardSet::mMainBuf
HardwareVertexBufferSharedPtr mMainBuf
Shortcut to main buffer (positions, colours, texture coords)
Definition: OgreBillboardSet.h:184
Ogre::BillboardSet::mAllDefaultRotation
bool mAllDefaultRotation
Definition: OgreBillboardSet.h:149
Ogre::BBT_PERPENDICULAR_COMMON
Billboards are perpendicular to a shared direction vector (used as Z axis, the facing direction) and ...
Definition: OgreBillboardSet.h:84
Ogre::BBO_TOP_CENTER
Definition: OgreBillboardSet.h:57
Ogre::BillboardSet::mBillboardType
BillboardType mBillboardType
The type of billboard to render.
Definition: OgreBillboardSet.h:214
Ogre::ColourValue::White
static const ColourValue White
Definition: OgreColourValue.h:62
OgreCommon.h
Ogre::BillboardRotationType
BillboardRotationType
The rotation type of billboard.
Definition: OgreBillboardSet.h:67
Ogre::BillboardSet::SortByDirectionFunctor
Sort by direction functor.
Definition: OgreBillboardSet.h:266
Ogre::BillboardSet::isPointRenderingEnabled
virtual bool isPointRenderingEnabled(void) const
Returns whether point rendering is enabled.
Definition: OgreBillboardSet.h:830
Ogre::Matrix4
Class encapsulating a standard 4x4 homogeneous matrix.
Definition: OgreMatrix4.h:78
Ogre::Vector3
Standard 3-dimensional vector.
Definition: OgreVector3.h:51
Ogre::BillboardSet::SortByDirectionFunctor::sortDir
Vector3 sortDir
Direction to sort in.
Definition: OgreBillboardSet.h:269
Ogre::BillboardSet::mCamDir
Vector3 mCamDir
Camera direction in billboard space.
Definition: OgreBillboardSet.h:198
Ogre::SortMode
SortMode
Sort mode for billboard-set and particle-system.
Definition: OgreCommon.h:286
Ogre::HardwareVertexBufferSharedPtr
Shared pointer implementation used to share vertex buffers.
Definition: OgreHardwareVertexBuffer.h:86
Ogre::BillboardSet::FreeBillboardList
list< Billboard * >::type FreeBillboardList
Definition: OgreBillboardSet.h:153
OgrePrerequisites.h
Ogre::BillboardSet::mPointRendering
bool mPointRendering
Use point rendering?
Definition: OgreBillboardSet.h:288
Ogre::BillboardSet::SortByDistanceFunctor::sortPos
Vector3 sortPos
Position to sort in.
Definition: OgreBillboardSet.h:279
Ogre::HashedVector
A hashed vector.
Definition: OgreCommon.h:332
Ogre::Renderable::Visitor
Visitor object that can be used to iterate over a collection of Renderable instances abstractly...
Definition: OgreRenderable.h:377
Ogre::BBT_POINT
Standard point billboard (default), always faces the camera completely and is always upright...
Definition: OgreBillboardSet.h:78
Ogre::BillboardSet::TextureCoordSets
vector< Ogre::FloatRect >::type TextureCoordSets
Definition: OgreBillboardSet.h:210
Ogre::BBO_BOTTOM_RIGHT
Definition: OgreBillboardSet.h:64
Ogre::BillboardSet::mCamPos
Vector3 mCamPos
Camera position in billboard space.
Definition: OgreBillboardSet.h:202
Ogre::NameValuePairList
map< String, String >::type NameValuePairList
Name / value parameter pair (first = name, second = value)
Definition: OgreCommon.h:550
Ogre::BillboardSetFactory::FACTORY_TYPE_NAME
static String FACTORY_TYPE_NAME
Definition: OgreBillboardSet.h:867
Ogre::String
_StringBase String
Definition: OgrePrerequisites.h:439
Ogre::BBT_ORIENTED_COMMON
Billboards are oriented around a shared direction vector (used as Y axis) and only rotate around this...
Definition: OgreBillboardSet.h:80
Ogre::BillboardSet::mCullIndividual
bool mCullIndividual
Flag indicating whether each billboard should be culled separately (default: false) ...
Definition: OgreBillboardSet.h:208
Ogre::BillboardSet::mMaterial
MaterialPtr mMaterial
Pointer to the material to use.
Definition: OgreBillboardSet.h:135
Ogre::BillboardSet::notifyBillboardDataChanged
void notifyBillboardDataChanged(void)
When billboard set is not auto updating its GPU buffer, the user is responsible to inform it about an...
Definition: OgreBillboardSet.h:854
Ogre::BillboardSet::mTextureCoords
TextureCoordSets mTextureCoords
Definition: OgreBillboardSet.h:211
Ogre::BillboardSet::mBillboardPool
BillboardPool mBillboardPool
Pool of billboard instances for use and reuse in the active billboard list.
Definition: OgreBillboardSet.h:179
Ogre::BillboardSet::mAABB
AxisAlignedBox mAABB
Bounds of all billboards in this set.
Definition: OgreBillboardSet.h:118
Ogre::BillboardSetFactory::BillboardSetFactory
BillboardSetFactory()
Definition: OgreBillboardSet.h:864
Ogre::Camera
A viewpoint from which the scene will be rendered.
Definition: OgreCamera.h:86
OgreHeaderSuffix.h
Ogre::BillboardSet::setUseAccurateFacing
virtual void setUseAccurateFacing(bool acc)
Sets whether or not billboards should use an &#39;accurate&#39; facing model based on the vector from each bi...
Definition: OgreBillboardSet.h:712
Ogre::RadixSort
Class for performing a radix sort (fast comparison-less sort based on byte value) on various standard...
Definition: OgreRadixSort.h:88
Ogre::BillboardSet::mFreeBillboards
FreeBillboardList mFreeBillboards
Free billboard queue.
Definition: OgreBillboardSet.h:173
Ogre::BillboardSetFactory
Factory object for creating BillboardSet instances.
Definition: OgreBillboardSet.h:859
Ogre::BillboardSet::mExternalData
bool mExternalData
Is external billboard data in use?
Definition: OgreBillboardSet.h:298
Ogre::uint32
unsigned int uint32
Definition: OgrePlatform.h:359
Ogre::BillboardSet::mDefaultHeight
Real mDefaultHeight
Default height of each billboard.
Definition: OgreBillboardSet.h:130
Ogre::BillboardSet::mMaterialName
String mMaterialName
Name of the material to use.
Definition: OgreBillboardSet.h:133
Ogre::BillboardSetFactory::~BillboardSetFactory
~BillboardSetFactory()
Definition: OgreBillboardSet.h:865
Ogre::BillboardSet::mAccurateFacing
bool mAccurateFacing
Use &#39;true&#39; billboard to cam position facing, rather than camera direcion.
Definition: OgreBillboardSet.h:147
Ogre
Definition: OgreAndroidLogListener.h:34
Ogre::BillboardSet::mLockPtr
float * mLockPtr
Locked pointer to buffer.
Definition: OgreBillboardSet.h:186
Ogre::BillboardSet::mBuffersCreated
bool mBuffersCreated
Flag indicating whether the HW buffers have been created.
Definition: OgreBillboardSet.h:294
Ogre::BBT_ORIENTED_SELF
Billboards are oriented around their own direction vector (their own Y axis) and only rotate around t...
Definition: OgreBillboardSet.h:82
Ogre::BBO_TOP_LEFT
Definition: OgreBillboardSet.h:56
Ogre::SharedPtr< Material >
Ogre::BillboardSet::mDefaultWidth
Real mDefaultWidth
Default width of each billboard.
Definition: OgreBillboardSet.h:128
Ogre::BBR_TEXCOORD
Rotate the billboard&#39;s texture coordinates.
Definition: OgreBillboardSet.h:72
Ogre::vector
Definition: OgrePrerequisites.h:491
OgreHeaderPrefix.h
Ogre::BBO_CENTER
Definition: OgreBillboardSet.h:60
Ogre::RenderOperation
&#39;New&#39; rendering operation using vertex buffers.
Definition: OgreRenderOperation.h:45
Ogre::BillboardSet
A collection of billboards (faces which are always facing the given direction) with the same (default...
Definition: OgreBillboardSet.h:110
OgreResourceGroupManager.h
Ogre::MovableObjectFactory
Interface definition for a factory class which produces a certain kind of MovableObject, and can be registered with Root in order to allow all clients to produce new instances of this object, integrated with the standard Ogre processing.
Definition: OgreMovableObject.h:578
Ogre::BillboardSet::mSortingEnabled
bool mSortingEnabled
Flag indicating whether the billboards has to be sorted.
Definition: OgreBillboardSet.h:144
Ogre::BillboardType
BillboardType
The type of billboard to use.
Definition: OgreBillboardSet.h:75
Ogre::AxisAlignedBox
A 3D box aligned with the x/y/z axes.
Definition: OgreAxisAlignedBox.h:54
Ogre::BillboardSet::mBillboardDataChanged
bool mBillboardDataChanged
True if the billboard data changed. Will cause vertex buffer update.
Definition: OgreBillboardSet.h:302
Ogre::Billboard
A billboard is a primitive which always faces the camera in every frame.
Definition: OgreBillboard.h:67
Ogre::BillboardSet::mAutoExtendPool
bool mAutoExtendPool
Flag indicating whether to autoextend pool.
Definition: OgreBillboardSet.h:141
Ogre::BillboardSet::SortByDistanceFunctor
Sort by distance functor.
Definition: OgreBillboardSet.h:276
Ogre::BillboardSet::mIndexData
IndexData * mIndexData
The vertex index data for all billboards in this set (1 set only)
Definition: OgreBillboardSet.h:205
Ogre::uint16
unsigned short uint16
Definition: OgrePlatform.h:360
Ogre::BillboardSet::ActiveBillboardList
list< Billboard * >::type ActiveBillboardList
Definition: OgreBillboardSet.h:152
Ogre::BBO_TOP_RIGHT
Definition: OgreBillboardSet.h:58

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