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;

        // Use 'true' billboard to cam position facing, rather than camera direcion
        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;
        // 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* mIndexes;
        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);

        // Number of visible billboards (will be == getNumBillboards if mCullIndividual == false)
        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);  

    };
}

#include "OgreHeaderSuffix.h"

#endif