- Main Page
- Namespaces
- Classes
- Files
- Directories
- Related Pages

# OgreHardwareVertexBuffer.h

Go to the documentation of this file.

    00001 /*
    00002 -----------------------------------------------------------------------------
    00003 This source file is part of OGRE
    00004     (Object-oriented Graphics Rendering Engine)
    00005 For the latest info, see http://www.ogre3d.org/
    00006
    00007 Copyright (c) 2000-2006 Torus Knot Software Ltd
    00008 Also see acknowledgements in Readme.html
    00009
    00010 This program is free software; you can redistribute it and/or modify it under
    00011 the terms of the GNU Lesser General Public License as published by the Free Software
    00012 Foundation; either version 2 of the License, or (at your option) any later
    00013 version.
    00014
    00015 This program is distributed in the hope that it will be useful, but WITHOUT
    00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
    00018
    00019 You should have received a copy of the GNU Lesser General Public License along with
    00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
    00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
    00022 http://www.gnu.org/copyleft/lesser.txt.
    00023
    00024 You may alternatively use this source under the terms of a specific version of
    00025 the OGRE Unrestricted License provided you have obtained such a license from
    00026 Torus Knot Software Ltd.
    00027 -----------------------------------------------------------------------------
    00028 */
    00029 #ifndef __HardwareVertexBuffer__
    00030 #define __HardwareVertexBuffer__
    00031
    00032 // Precompiler options
    00033 #include "OgrePrerequisites.h"
    00034 #include "OgreHardwareBuffer.h"
    00035 #include "OgreSharedPtr.h"
    00036 #include "OgreColourValue.h"
    00037
    00038 namespace Ogre {
    00040     class _OgreExport HardwareVertexBuffer : public HardwareBuffer
    00041     {
    00042         protected:
    00043
    00044             size_t mNumVertices;
    00045             size_t mVertexSize;
    00046
    00047         public:
    00049             HardwareVertexBuffer(size_t vertexSize, size_t numVertices,
    00050                 HardwareBuffer::Usage usage, bool useSystemMemory, bool useShadowBuffer);
    00051             ~HardwareVertexBuffer();
    00053             size_t getVertexSize(void) const { return mVertexSize; }
    00055             size_t getNumVertices(void) const { return mNumVertices; }
    00056
    00057
    00058
    00059             // NB subclasses should override lock, unlock, readData, writeData
    00060
    00061     };
    00062
    00064     class _OgreExport HardwareVertexBufferSharedPtr : public SharedPtr<HardwareVertexBuffer>
    00065     {
    00066     public:
    00067         HardwareVertexBufferSharedPtr() : SharedPtr<HardwareVertexBuffer>() {}
    00068         explicit HardwareVertexBufferSharedPtr(HardwareVertexBuffer* buf);
    00069
    00070
    00071     };
    00072
    00074     enum VertexElementSemantic {
    00076         VES_POSITION = 1,
    00078         VES_BLEND_WEIGHTS = 2,
    00080         VES_BLEND_INDICES = 3,
    00082         VES_NORMAL = 4,
    00084         VES_DIFFUSE = 5,
    00086         VES_SPECULAR = 6,
    00088         VES_TEXTURE_COORDINATES = 7,
    00090         VES_BINORMAL = 8,
    00092         VES_TANGENT = 9
    00093
    00094     };
    00095
    00097     enum VertexElementType
    00098     {
    00099         VET_FLOAT1 = 0,
    00100         VET_FLOAT2 = 1,
    00101         VET_FLOAT3 = 2,
    00102         VET_FLOAT4 = 3,
    00104         VET_COLOUR = 4,
    00105         VET_SHORT1 = 5,
    00106         VET_SHORT2 = 6,
    00107         VET_SHORT3 = 7,
    00108         VET_SHORT4 = 8,
    00109         VET_UBYTE4 = 9,
    00111         VET_COLOUR_ARGB = 10,
    00113         VET_COLOUR_ABGR = 11
    00114     };
    00115
    00125     class _OgreExport VertexElement
    00126     {
    00127     protected:
    00129         unsigned short mSource;
    00131         size_t mOffset;
    00133         VertexElementType mType;
    00135         VertexElementSemantic mSemantic;
    00137         unsigned short mIndex;
    00138     public:
    00140         VertexElement(unsigned short source, size_t offset, VertexElementType theType,
    00141             VertexElementSemantic semantic, unsigned short index = 0);
    00143         unsigned short getSource(void) const { return mSource; }
    00145         size_t getOffset(void) const { return mOffset; }
    00147         VertexElementType getType(void) const { return mType; }
    00149         VertexElementSemantic getSemantic(void) const { return mSemantic; }
    00151         unsigned short getIndex(void) const { return mIndex; }
    00153         size_t getSize(void) const;
    00155         static size_t getTypeSize(VertexElementType etype);
    00157         static unsigned short getTypeCount(VertexElementType etype);
    00161         static VertexElementType multiplyTypeCount(VertexElementType baseType, unsigned short count);
    00165         static VertexElementType getBaseType(VertexElementType multiType);
    00166
    00173         static void convertColourValue(VertexElementType srcType,
    00174             VertexElementType dstType, uint32* ptr);
    00175
    00181         static uint32 convertColourValue(const ColourValue& src,
    00182             VertexElementType dst);
    00183
    00185         static VertexElementType getBestColourVertexElementType(void);
    00186
    00187         inline bool operator== (const VertexElement& rhs) const
    00188         {
    00189             if (mType != rhs.mType ||
    00190                 mIndex != rhs.mIndex ||
    00191                 mOffset != rhs.mOffset ||
    00192                 mSemantic != rhs.mSemantic ||
    00193                 mSource != rhs.mSource)
    00194                 return false;
    00195             else
    00196                 return true;
    00197
    00198         }
    00206         inline void baseVertexPointerToElement(void* pBase, void** pElem) const
    00207         {
    00208             // The only way we can do this is to cast to char* in order to use byte offset
    00209             // then cast back to void*.
    00210             *pElem = static_cast<void*>(
    00211                 static_cast<unsigned char*>(pBase) + mOffset);
    00212         }
    00220         inline void baseVertexPointerToElement(void* pBase, float** pElem) const
    00221         {
    00222             // The only way we can do this is to cast to char* in order to use byte offset
    00223             // then cast back to float*. However we have to go via void* because casting
    00224             // directly is not allowed
    00225             *pElem = static_cast<float*>(
    00226                 static_cast<void*>(
    00227                     static_cast<unsigned char*>(pBase) + mOffset));
    00228         }
    00229
    00237         inline void baseVertexPointerToElement(void* pBase, RGBA** pElem) const
    00238         {
    00239             *pElem = static_cast<RGBA*>(
    00240                 static_cast<void*>(
    00241                     static_cast<unsigned char*>(pBase) + mOffset));
    00242         }
    00250         inline void baseVertexPointerToElement(void* pBase, unsigned char** pElem) const
    00251         {
    00252             *pElem = static_cast<unsigned char*>(pBase) + mOffset;
    00253         }
    00254
    00262         inline void baseVertexPointerToElement(void* pBase, unsigned short** pElem) const
    00263         {
    00264             *pElem = static_cast<unsigned short*>(pBase) + mOffset;
    00265         }
    00266
    00267
    00268     };
    00291     class _OgreExport VertexDeclaration
    00292     {
    00293     public:
    00295         typedef std::list<VertexElement> VertexElementList;
    00297         static bool vertexElementLess(const VertexElement& e1, const VertexElement& e2);
    00298     protected:
    00299         VertexElementList mElementList;
    00300     public:
    00302         VertexDeclaration();
    00303         virtual ~VertexDeclaration();
    00304
    00306         size_t getElementCount(void) { return mElementList.size(); }
    00308         const VertexElementList& getElements(void) const;
    00310         const VertexElement* getElement(unsigned short index);
    00311
    00320         void sort(void);
    00321
    00332         void closeGapsInSource(void);
    00333
    00344         VertexDeclaration* getAutoOrganisedDeclaration(bool skeletalAnimation,
    00345             bool vertexAnimation);
    00346
    00348         unsigned short getMaxSource(void) const;
    00349
    00350
    00351
    00365         virtual const VertexElement& addElement(unsigned short source, size_t offset, VertexElementType theType,
    00366             VertexElementSemantic semantic, unsigned short index = 0);
    00380         virtual const VertexElement& insertElement(unsigned short atPosition,
    00381             unsigned short source, size_t offset, VertexElementType theType,
    00382             VertexElementSemantic semantic, unsigned short index = 0);
    00383
    00385         virtual void removeElement(unsigned short elem_index);
    00386
    00393         virtual void removeElement(VertexElementSemantic semantic, unsigned short index = 0);
    00394
    00396         virtual void removeAllElements(void);
    00397
    00403         virtual void modifyElement(unsigned short elem_index, unsigned short source, size_t offset, VertexElementType theType,
    00404             VertexElementSemantic semantic, unsigned short index = 0);
    00405
    00411         virtual const VertexElement* findElementBySemantic(VertexElementSemantic sem, unsigned short index = 0);
    00421         virtual VertexElementList findElementsBySource(unsigned short source);
    00422
    00424         virtual size_t getVertexSize(unsigned short source);
    00425
    00427         virtual VertexDeclaration* clone(void);
    00428
    00429         inline bool operator== (const VertexDeclaration& rhs) const
    00430         {
    00431             if (mElementList.size() != rhs.mElementList.size())
    00432                 return false;
    00433
    00434             VertexElementList::const_iterator i, iend, rhsi, rhsiend;
    00435             iend = mElementList.end();
    00436             rhsiend = rhs.mElementList.end();
    00437             rhsi = rhs.mElementList.begin();
    00438             for (i = mElementList.begin(); i != iend && rhsi != rhsiend; ++i, ++rhsi)
    00439             {
    00440                 if ( !(*i == *rhsi) )
    00441                     return false;
    00442             }
    00443
    00444             return true;
    00445         }
    00446         inline bool operator!= (const VertexDeclaration& rhs) const
    00447         {
    00448             return !(*this == rhs);
    00449         }
    00450
    00451     };
    00452
    00466     class _OgreExport VertexBufferBinding
    00467     {
    00468     public:
    00470         typedef std::map<unsigned short, HardwareVertexBufferSharedPtr> VertexBufferBindingMap;
    00471     protected:
    00472         VertexBufferBindingMap mBindingMap;
    00473         mutable unsigned short mHighIndex;
    00474     public:
    00476         VertexBufferBinding();
    00477         virtual ~VertexBufferBinding();
    00486         virtual void setBinding(unsigned short index, const HardwareVertexBufferSharedPtr& buffer);
    00488         virtual void unsetBinding(unsigned short index);
    00489
    00491         virtual void unsetAllBindings(void);
    00492
    00494         virtual const VertexBufferBindingMap& getBindings(void) const;
    00495
    00497         virtual const HardwareVertexBufferSharedPtr& getBuffer(unsigned short index) const;
    00499         virtual bool isBufferBound(unsigned short index) const;
    00500
    00501         virtual size_t getBufferCount(void) const { return mBindingMap.size(); }
    00502
    00508         virtual unsigned short getNextIndex(void) const { return mHighIndex++; }
    00509
    00512         virtual unsigned short getLastBoundIndex(void) const;
    00513
    00514         typedef std::map<ushort, ushort> BindingIndexMap;
    00515
    00518         virtual bool hasGaps(void) const;
    00519
    00532         virtual void closeGaps(BindingIndexMap& bindingIndexMap);
    00533
    00534
    00535     };
    00536
    00537
    00538
    00539 }
    00540 #endif
    00541

Copyright © 2000-2005 by The OGRE Team
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Mon Jun 16 12:48:51 2008