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-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/

#ifndef __BillboardSet_H__
#define __BillboardSet_H__

#include "OgrePrerequisites.h"

#include "OgreMovableObject.h"
#include "OgreRenderable.h"
#include "OgreRadixSort.h"
#include "OgreCommon.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 mpMaterial;

        bool mAllDefaultSize;

        bool mAutoExtendPool;

        bool mSortingEnabled;

        // Use 'true' billboard to cam position facing, rather than camera direcion
        bool mAccurateFacing;

        bool mAllDefaultRotation;
        bool mWorldSpace;

        typedef std::list<Billboard*> ActiveBillboardList;
        typedef std::list<Billboard*> FreeBillboardList;
        typedef std::vector<Billboard*> BillboardPool;

        ActiveBillboardList mActiveBillboards;

        FreeBillboardList mFreeBillboards;

        BillboardPool mBillboardPool;

        VertexData* mVertexData;
        HardwareVertexBufferSharedPtr mMainBuf;
        float* mLockPtr;
        Vector3 mVOffset[4];
        Camera* mCurrentCamera;
        // Parametric offsets of origin
        Real mLeftOff, mRightOff, mTopOff, mBottomOff;
        // Camera axes in billboard space
        Vector3 mCamX, mCamY;
        // Camera direction in billboard space
        Vector3 mCamDir;
        // Camera orientation in billboard space
        Quaternion mCamQ;
        // Camera position in billboard space
        Vector3 mCamPos;

        //unsigned short* mpIndexes;
        IndexData* mIndexData;

        bool mCullIndividual;

        typedef std::vector< Ogre::FloatRect > TextureCoordSets;
        TextureCoordSets mTextureCoords;

        BillboardType mBillboardType;

        Vector3 mCommonDirection;
        Vector3 mCommonUpVector;

        inline bool billboardVisible(Camera* cam, const Billboard& bill);

        // Number of visible billboards (will be == getNumBillboards if mCullIndividual == false)
        unsigned short mNumVisibleBillboards;

        virtual void increasePool(unsigned int 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;
        unsigned int mPoolSize;
        bool mExternalData;

        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(unsigned int 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);

        virtual const String& getMaterialName(void) const;

        virtual void _notifyCurrentCamera(Camera* cam);

        void beginBillboards(void);
        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 getRenderOperation(RenderOperation& op);

        virtual void getWorldTransforms(Matrix4* xform) const;

        const Quaternion& getWorldOrientation(void) const;
        const Vector3& getWorldPosition(void) 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;

        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;

    };

    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);  

    };


}


#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:37 2006