OgreBillboardChain.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.
-----------------------------------------------------------------------------
*/

// Thanks to Vincent Cantin (karmaGfa) for the original implementation of this
// class, although it has now been mostly rewritten

#ifndef _BillboardChain_H__
#define _BillboardChain_H__

#include "OgrePrerequisites.h"

#include "OgreMovableObject.h"
#include "OgreRenderable.h"

namespace Ogre {


    class _OgreExport BillboardChain : public MovableObject, public Renderable
    {

    public:

        class _OgreExport Element
        {

        public:

            Element();

            Element(Vector3 position,
                Real width,
                Real texCoord,
                ColourValue colour);

            Vector3 position;
            Real width;
            Real texCoord;
            ColourValue colour;

        };
        typedef std::vector<Element> ElementList;

        BillboardChain(const String& name, size_t maxElements = 20, size_t numberOfChains = 1, 
            bool useTextureCoords = true, bool useColours = true, bool dynamic = true);
        virtual ~BillboardChain();

        virtual void setMaxChainElements(size_t maxElements);
        virtual size_t getMaxChainElements(void) const { return mMaxElementsPerChain; }
        virtual void setNumberOfChains(size_t numChains);
        virtual size_t getNumberOfChains(void) const { return mChainCount; }

        virtual void setUseTextureCoords(bool use);
        virtual bool getUseTextureCoords(void) const { return mUseTexCoords; }

        enum TexCoordDirection
        {
            TCD_U,
            TCD_V,
        };
        virtual void setTextureCoordDirection(TexCoordDirection dir);
        virtual TexCoordDirection getTextureCoordDirection(void) { return mTexCoordDir; }

        virtual void setOtherTextureCoordRange(Real start, Real end);
        virtual const Real* getOtherTextureCoordRange(void) const { return mOtherTexCoordRange; }

        virtual void setUseVertexColours(bool use);
        virtual bool getUseVertexColours(void) const { return mUseVertexColour; }

        virtual void setDynamic(bool dyn);

        virtual bool getDynamic(void) const { return mDynamic; }
        
        virtual void addChainElement(size_t chainIndex, 
            const Element& billboardChainElement);
        virtual void removeChainElement(size_t chainIndex);
        virtual void updateChainElement(size_t chainIndex, size_t elementIndex, 
            const Element& billboardChainElement);
        virtual const Element& getChainElement(size_t chainIndex, size_t elementIndex) const;
        virtual const String& getMaterialName(void) const { return mMaterialName; }
        virtual void setMaterialName(const String& name);


        // Overridden members follow
        void _notifyCurrentCamera(Camera* cam);
        Real getSquaredViewDepth(const Camera* cam) const;
        Real getBoundingRadius(void) const;
        const AxisAlignedBox& getBoundingBox(void) const;
        const MaterialPtr& getMaterial(void) const;
        const String& getMovableType(void) const;
        void _updateRenderQueue(RenderQueue *);
        void getRenderOperation(RenderOperation &);
        void getWorldTransforms(Matrix4 *) const;
        const Quaternion& getWorldOrientation(void) const;
        const Vector3& getWorldPosition(void) const;
        const LightList& getLights(void) const;



    protected:

        size_t mMaxElementsPerChain;
        size_t mChainCount;
        bool mUseTexCoords;
        bool mUseVertexColour;
        bool mDynamic;
        VertexData* mVertexData;
        IndexData* mIndexData;
        bool mVertexDeclDirty;
        bool mBuffersNeedRecreating;
        mutable bool mBoundsDirty;
        bool mIndexContentDirty;
        mutable AxisAlignedBox mAABB;
        mutable Real mRadius;
        String mMaterialName;
        MaterialPtr mMaterial;
        TexCoordDirection mTexCoordDir;
        Real mOtherTexCoordRange[2];


        ElementList mChainElementList;

        struct ChainSegment
        {
            size_t start;
            size_t head;
            size_t tail;
        };
        typedef std::vector<ChainSegment> ChainSegmentList;
        ChainSegmentList mChainSegmentList;

        virtual void setupChainContainers(void);
        virtual void setupVertexDeclaration(void);
        // Setup buffers
        virtual void setupBuffers(void);
        virtual void updateVertexBuffer(Camera* cam);
        virtual void updateIndexBuffer(void);
        virtual void updateBoundingBox(void) const;

        static const size_t SEGMENT_EMPTY;
    };


    class _OgreExport BillboardChainFactory : public MovableObjectFactory
    {
    protected:
        MovableObject* createInstanceImpl( const String& name, const NameValuePairList* params);
    public:
        BillboardChainFactory() {}
        ~BillboardChainFactory() {}

        static String FACTORY_TYPE_NAME;

        const String& getType(void) const;
        void destroyInstance( MovableObject* obj);  

    };


} // namespace

#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