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 : public VertexDataAlloc
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 : public VertexDataAlloc
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 : public VertexDataAlloc
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 © 2008 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Sep 27 22:02:23 2009