OgreHardwareVertexBuffer.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 __HardwareVertexBuffer__
#define __HardwareVertexBuffer__

// Precompiler options
#include "OgrePrerequisites.h"
#include "OgreHardwareBuffer.h"
#include "OgreSharedPtr.h"
#include "OgreColourValue.h"

namespace Ogre {
    class _OgreExport HardwareVertexBuffer : public HardwareBuffer
    {
        protected:
            
            size_t mNumVertices;
            size_t mVertexSize;

        public:
            HardwareVertexBuffer(size_t vertexSize, size_t numVertices, 
                HardwareBuffer::Usage usage, bool useSystemMemory, bool useShadowBuffer);
            ~HardwareVertexBuffer();
            size_t getVertexSize(void) const { return mVertexSize; }
            size_t getNumVertices(void) const { return mNumVertices; }
            


            // NB subclasses should override lock, unlock, readData, writeData
        
    };

    class _OgreExport HardwareVertexBufferSharedPtr : public SharedPtr<HardwareVertexBuffer>
    {
    public:
        HardwareVertexBufferSharedPtr() : SharedPtr<HardwareVertexBuffer>() {}
        explicit HardwareVertexBufferSharedPtr(HardwareVertexBuffer* buf);


    };

    enum VertexElementSemantic {
        VES_POSITION = 1,
        VES_BLEND_WEIGHTS = 2,
        VES_BLEND_INDICES = 3,
        VES_NORMAL = 4,
        VES_DIFFUSE = 5,
        VES_SPECULAR = 6,
        VES_TEXTURE_COORDINATES = 7,
        VES_BINORMAL = 8,
        VES_TANGENT = 9

    };

    enum VertexElementType
    {
        VET_FLOAT1,
        VET_FLOAT2,
        VET_FLOAT3,
        VET_FLOAT4,
        VET_COLOUR,
        VET_SHORT1,
        VET_SHORT2,
        VET_SHORT3,
        VET_SHORT4, 
        VET_UBYTE4
    };

    class _OgreExport VertexElement
    {
    protected:
        unsigned short mSource;
        size_t mOffset;
        VertexElementType mType;
        VertexElementSemantic mSemantic;
        unsigned short mIndex;
    public:
        VertexElement(unsigned short source, size_t offset, VertexElementType theType,
            VertexElementSemantic semantic, unsigned short index = 0);
        unsigned short getSource(void) const { return mSource; }
        size_t getOffset(void) const { return mOffset; }
        VertexElementType getType(void) const { return mType; }
        VertexElementSemantic getSemantic(void) const { return mSemantic; }
        unsigned short getIndex(void) const { return mIndex; }
        size_t getSize(void) const;
        static size_t getTypeSize(VertexElementType etype);
        static unsigned short getTypeCount(VertexElementType etype);
        static VertexElementType multiplyTypeCount(VertexElementType baseType, unsigned short count);
        static VertexElementType getBaseType(VertexElementType multiType);

        inline bool operator== (const VertexElement& rhs) const
        {
            if (mType != rhs.mType || 
                mIndex != rhs.mIndex ||
                mOffset != rhs.mOffset ||
                mSemantic != rhs.mSemantic ||
                mSource != rhs.mSource)
                return false;
            else
                return true;

        }
        inline void baseVertexPointerToElement(void* pBase, void** pElem) const
        {
            // The only way we can do this is to cast to char* in order to use byte offset
            // then cast back to void*.
            *pElem = static_cast<void*>(
                static_cast<unsigned char*>(pBase) + mOffset);
        }
        inline void baseVertexPointerToElement(void* pBase, float** pElem) const
        {
            // The only way we can do this is to cast to char* in order to use byte offset
            // then cast back to float*. However we have to go via void* because casting  
            // directly is not allowed
            *pElem = static_cast<float*>(
                static_cast<void*>(
                    static_cast<unsigned char*>(pBase) + mOffset));
        }

        inline void baseVertexPointerToElement(void* pBase, RGBA** pElem) const
        {
            *pElem = static_cast<RGBA*>(
                static_cast<void*>(
                    static_cast<unsigned char*>(pBase) + mOffset));
        }
        inline void baseVertexPointerToElement(void* pBase, unsigned char** pElem) const
        {
            *pElem = static_cast<unsigned char*>(pBase) + mOffset;
        }

        inline void baseVertexPointerToElement(void* pBase, unsigned short** pElem) const
        {
            *pElem = static_cast<unsigned short*>(pBase) + mOffset;
        }


    };
    class _OgreExport VertexDeclaration
    {
    public:
        typedef std::list<VertexElement> VertexElementList;
        static bool vertexElementLess(const VertexElement& e1, const VertexElement& e2);
    protected:
        VertexElementList mElementList;
    public:
        VertexDeclaration();
        virtual ~VertexDeclaration();
        
        size_t getElementCount(void) { return mElementList.size(); }
        const VertexElementList& getElements(void) const;
        const VertexElement* getElement(unsigned short index);

        void sort(void);

        void closeGapsInSource(void);

        VertexDeclaration* getAutoOrganisedDeclaration(bool animated);

        unsigned short getMaxSource(void) const;



        virtual const VertexElement& addElement(unsigned short source, size_t offset, VertexElementType theType,
            VertexElementSemantic semantic, unsigned short index = 0);
        virtual const VertexElement& insertElement(unsigned short atPosition,
            unsigned short source, size_t offset, VertexElementType theType,
            VertexElementSemantic semantic, unsigned short index = 0);

        virtual void removeElement(unsigned short elem_index);

        virtual void removeElement(VertexElementSemantic semantic, unsigned short index = 0);

        virtual void modifyElement(unsigned short elem_index, unsigned short source, size_t offset, VertexElementType theType,
            VertexElementSemantic semantic, unsigned short index = 0);

        virtual const VertexElement* findElementBySemantic(VertexElementSemantic sem, unsigned short index = 0);
        virtual VertexElementList findElementsBySource(unsigned short source);
        
        virtual size_t getVertexSize(unsigned short source);

        virtual VertexDeclaration* clone(void);

        inline bool operator== (const VertexDeclaration& rhs) const
        {
            if (mElementList.size() != rhs.mElementList.size())
                return false;

            VertexElementList::const_iterator i, iend, rhsi, rhsiend;
            iend = mElementList.end();
            rhsiend = rhs.mElementList.end();
            rhsi = rhs.mElementList.begin();
            for (i = mElementList.begin(); i != iend && rhsi != rhsiend; ++i, ++rhsi)
            {
                if ( !(*i == *rhsi) )
                    return false;
            }

            return true;
        }
        inline bool operator!= (const VertexDeclaration& rhs) const
        {
            return !(*this == rhs);
        }

    };

    class _OgreExport VertexBufferBinding
    {
    public:
        typedef std::map<unsigned short, HardwareVertexBufferSharedPtr> VertexBufferBindingMap;
    protected:
        VertexBufferBindingMap mBindingMap;
        mutable unsigned short mHighIndex;
    public:
        VertexBufferBinding();
        virtual ~VertexBufferBinding();
        virtual void setBinding(unsigned short index, HardwareVertexBufferSharedPtr buffer);
        virtual void unsetBinding(unsigned short index);

        virtual void unsetAllBindings(void);

        virtual const VertexBufferBindingMap& getBindings(void) const;

        virtual HardwareVertexBufferSharedPtr getBuffer(unsigned short index);

        virtual size_t getBufferCount(void) const { return mBindingMap.size(); }

        virtual unsigned short getNextIndex(void) const { return mHighIndex++; }




    };



}
#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:46 2006