Home | Namespaces | Hierarchy | Alphabetical List | Class list | Files | Namespace Members | Class members | File members | Tutorials

CVertexBuffer.h

Go to the documentation of this file.
00001 // Copyright (C) 2008-2010 Nikolaus Gebhardt
00002 // This file is part of the "Irrlicht Engine".
00003 // For conditions of distribution and use, see copyright notice in irrlicht.h
00004 
00005 #ifndef __C_VERTEX_BUFFER_H_INCLUDED__
00006 #define __C_VERTEX_BUFFER_H_INCLUDED__
00007 
00008 #include "IVertexBuffer.h"
00009 
00010 
00011 namespace irr
00012 {
00013 namespace scene
00014 {
00015 
00016         class CVertexBuffer : public IVertexBuffer
00017         {
00018                 class IVertexList
00019                 {
00020                 public:
00021                         virtual ~IVertexList(){};
00022 
00023                         virtual u32 stride() const =0;
00024 
00025                         virtual u32 size() const =0;
00026 
00027                         virtual void push_back (const video::S3DVertex &element) =0;
00028                         virtual video::S3DVertex& operator [](const u32 index) const =0;
00029                         virtual video::S3DVertex& getLast() =0;
00030                         virtual void set_used(u32 usedNow) =0;
00031                         virtual void reallocate(u32 new_size) =0;
00032                         virtual u32 allocated_size() const =0;
00033                         virtual video::S3DVertex* pointer() =0;
00034                         virtual video::E_VERTEX_TYPE getType() const =0;
00035                 };
00036 
00037                 template <class T>
00038                 class CSpecificVertexList : public IVertexList
00039                 {
00040                 public:
00041                         core::array<T> Vertices;
00042 
00043                         virtual u32 stride() const {return sizeof(T);}
00044 
00045                         virtual u32 size() const {return Vertices.size();}
00046 
00047                         virtual void push_back (const video::S3DVertex &element)
00048                         {Vertices.push_back((T&)element);}
00049 
00050                         virtual video::S3DVertex& operator [](const u32 index) const
00051                         {return (video::S3DVertex&)Vertices[index];}
00052 
00053                         virtual video::S3DVertex& getLast()
00054                         {return (video::S3DVertex&)Vertices.getLast();}
00055 
00056                         virtual void set_used(u32 usedNow)
00057                         {Vertices.set_used(usedNow);}
00058 
00059                         virtual void reallocate(u32 new_size)
00060                         {Vertices.reallocate(new_size);}
00061 
00062                         virtual u32 allocated_size() const
00063                         {
00064                                 return Vertices.allocated_size();
00065                         }
00066 
00067                         virtual video::S3DVertex* pointer() {return Vertices.pointer();}
00068 
00069                         virtual video::E_VERTEX_TYPE getType() const {return T().getType();}
00070                 };
00071 
00072         public:
00073                 IVertexList *Vertices;
00074 
00075                 CVertexBuffer(video::E_VERTEX_TYPE vertexType) : Vertices(0),
00076                                 MappingHint(EHM_NEVER), ChangedID(1)
00077                 {
00078                         setType(vertexType);
00079                 }
00080 
00081                 CVertexBuffer(const IVertexBuffer &VertexBufferCopy) :
00082                                 Vertices(0), MappingHint(EHM_NEVER),
00083                                 ChangedID(1)
00084                 {
00085                         setType(VertexBufferCopy.getType());
00086                         reallocate(VertexBufferCopy.size());
00087 
00088                         for (u32 n=0;n<VertexBufferCopy.size();++n)
00089                                 push_back(VertexBufferCopy[n]);
00090                 }
00091 
00092                 virtual ~CVertexBuffer()
00093                 {
00094                         delete Vertices;
00095                 }
00096 
00097 
00098                 virtual void setType(video::E_VERTEX_TYPE vertexType)
00099                 {
00100                         IVertexList *NewVertices=0;
00101 
00102                         switch (vertexType)
00103                         {
00104                                 case video::EVT_STANDARD:
00105                                 {
00106                                         NewVertices=new CSpecificVertexList<video::S3DVertex>;
00107                                         break;
00108                                 }
00109                                 case video::EVT_2TCOORDS:
00110                                 {
00111                                         NewVertices=new CSpecificVertexList<video::S3DVertex2TCoords>;
00112                                         break;
00113                                 }
00114                                 case video::EVT_TANGENTS:
00115                                 {
00116                                         NewVertices=new CSpecificVertexList<video::S3DVertexTangents>;
00117                                         break;
00118                                 }
00119                         }
00120                         if (Vertices)
00121                         {
00122                                 NewVertices->reallocate( Vertices->size() );
00123 
00124                                 for(u32 n=0;n<Vertices->size();++n)
00125                                         NewVertices->push_back((*Vertices)[n]);
00126 
00127                                 delete Vertices;
00128                         }
00129 
00130                         Vertices=NewVertices;
00131                 }
00132 
00133                 virtual void* getData() {return Vertices->pointer();}
00134 
00135                 virtual video::E_VERTEX_TYPE getType() const {return Vertices->getType();}
00136 
00137                 virtual u32 stride() const {return Vertices->stride();}
00138 
00139                 virtual u32 size() const
00140                 {
00141                         return Vertices->size();
00142                 }
00143 
00144                 virtual void push_back (const video::S3DVertex &element)
00145                 {
00146                         Vertices->push_back(element);
00147                 }
00148 
00149                 virtual video::S3DVertex& operator [](const u32 index) const
00150                 {
00151                         return (*Vertices)[index];
00152                 }
00153 
00154                 virtual video::S3DVertex& getLast()
00155                 {
00156                         return Vertices->getLast();
00157                 }
00158 
00159                 virtual void set_used(u32 usedNow)
00160                 {
00161                         Vertices->set_used(usedNow);
00162                 }
00163 
00164                 virtual void reallocate(u32 new_size)
00165                 {
00166                         Vertices->reallocate(new_size);
00167                 }
00168 
00169                 virtual u32 allocated_size() const
00170                 {
00171                         return Vertices->allocated_size();
00172                 }
00173 
00174                 virtual video::S3DVertex* pointer()
00175                 {
00176                         return Vertices->pointer();
00177                 }
00178 
00180                 virtual E_HARDWARE_MAPPING getHardwareMappingHint() const
00181                 {
00182                         return MappingHint;
00183                 }
00184 
00186                 virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint )
00187                 {
00188                         MappingHint=NewMappingHint;
00189                 }
00190 
00192                 virtual void setDirty()
00193                 {
00194                         ++ChangedID;
00195                 }
00196 
00198 
00199                 virtual u32 getChangedID() const {return ChangedID;}
00200 
00201                 E_HARDWARE_MAPPING MappingHint;
00202                 u32 ChangedID;
00203         };
00204 
00205 
00206 } // end namespace scene
00207 } // end namespace irr
00208 
00209 #endif
00210 

The Irrlicht Engine
The Irrlicht Engine Documentation © 2003-2010 by Nikolaus Gebhardt. Generated on Sun Oct 24 12:41:56 2010 by Doxygen (1.6.2)