include/CVertexBuffer.h

   1 // Copyright (C) 2008-2012 Nikolaus Gebhardt\r
   2 // This file is part of the "Irrlicht Engine".\r
   3 // For conditions of distribution and use, see copyright notice in irrlicht.h\r
   4 \r
   5 #ifndef __C_VERTEX_BUFFER_H_INCLUDED__\r
   6 #define __C_VERTEX_BUFFER_H_INCLUDED__\r
   7 \r
   8 #include "IVertexBuffer.h"\r
   9 \r
  10 \r
  11 namespace irr\r
  12 {\r
  13 namespace scene\r
  14 {\r
  15 \r
  16         class CVertexBuffer : public IVertexBuffer\r
  17         {\r
  18                 class IVertexList\r
  19                 {\r
  20                 public:\r
  21                         virtual ~IVertexList(){};\r
  22 \r
  23                         virtual u32 stride() const =0;\r
  24 \r
  25                         virtual u32 size() const =0;\r
  26 \r
  27                         virtual void push_back (const video::S3DVertex &element) =0;\r
  28                         virtual video::S3DVertex& operator [](const u32 index) const =0;\r
  29                         virtual video::S3DVertex& getLast() =0;\r
  30                         virtual void set_used(u32 usedNow) =0;\r
  31                         virtual void reallocate(u32 new_size) =0;\r
  32                         virtual u32 allocated_size() const =0;\r
  33                         virtual video::S3DVertex* pointer() =0;\r
  34                         virtual video::E_VERTEX_TYPE getType() const =0;\r
  35                 };\r
  36 \r
  37                 template <class T>\r
  38                 class CSpecificVertexList : public IVertexList\r
  39                 {\r
  40                 public:\r
  41                         core::array<T> Vertices;\r
  42 \r
  43                         u32 stride() const override {return sizeof(T);}\r
  44 \r
  45                         u32 size() const override {return Vertices.size();}\r
  46 \r
  47                         void push_back (const video::S3DVertex &element) override\r
  48                         {Vertices.push_back((T&)element);}\r
  49 \r
  50                         video::S3DVertex& operator [](const u32 index) const override\r
  51                         {return (video::S3DVertex&)Vertices[index];}\r
  52 \r
  53                         video::S3DVertex& getLast() override\r
  54                         {return (video::S3DVertex&)Vertices.getLast();}\r
  55 \r
  56                         void set_used(u32 usedNow) override\r
  57                         {Vertices.set_used(usedNow);}\r
  58 \r
  59                         void reallocate(u32 new_size) override\r
  60                         {Vertices.reallocate(new_size);}\r
  61 \r
  62                         u32 allocated_size() const override\r
  63                         {\r
  64                                 return Vertices.allocated_size();\r
  65                         }\r
  66 \r
  67                         video::S3DVertex* pointer() override {return Vertices.pointer();}\r
  68 \r
  69                         video::E_VERTEX_TYPE getType() const override {return T::getType();}\r
  70                 };\r
  71 \r
  72         public:\r
  73                 IVertexList *Vertices;\r
  74 \r
  75                 CVertexBuffer(video::E_VERTEX_TYPE vertexType) : Vertices(0),\r
  76                                 MappingHint(EHM_NEVER), ChangedID(1)\r
  77                 {\r
  78                         CVertexBuffer::setType(vertexType);\r
  79                 }\r
  80 \r
  81                 CVertexBuffer(const IVertexBuffer &VertexBufferCopy) :\r
  82                                 Vertices(0), MappingHint(EHM_NEVER),\r
  83                                 ChangedID(1)\r
  84                 {\r
  85                         CVertexBuffer::setType(VertexBufferCopy.getType());\r
  86                         CVertexBuffer::reallocate(VertexBufferCopy.size());\r
  87 \r
  88                         for (u32 n=0;n<VertexBufferCopy.size();++n)\r
  89                                 CVertexBuffer::push_back(VertexBufferCopy[n]);\r
  90                 }\r
  91 \r
  92                 virtual ~CVertexBuffer()\r
  93                 {\r
  94                         delete Vertices;\r
  95                 }\r
  96 \r
  97 \r
  98                 void setType(video::E_VERTEX_TYPE vertexType) override\r
  99                 {\r
 100                         if ( Vertices && Vertices->getType() == vertexType )\r
 101                                 return;\r
 102 \r
 103                         IVertexList *NewVertices=0;\r
 104 \r
 105                         switch (vertexType)\r
 106                         {\r
 107                                 case video::EVT_STANDARD:\r
 108                                 {\r
 109                                         NewVertices=new CSpecificVertexList<video::S3DVertex>;\r
 110                                         break;\r
 111                                 }\r
 112                                 case video::EVT_2TCOORDS:\r
 113                                 {\r
 114                                         NewVertices=new CSpecificVertexList<video::S3DVertex2TCoords>;\r
 115                                         break;\r
 116                                 }\r
 117                                 case video::EVT_TANGENTS:\r
 118                                 {\r
 119                                         NewVertices=new CSpecificVertexList<video::S3DVertexTangents>;\r
 120                                         break;\r
 121                                 }\r
 122                         }\r
 123                         if (Vertices)\r
 124                         {\r
 125                                 NewVertices->reallocate( Vertices->size() );\r
 126 \r
 127                                 for(u32 n=0;n<Vertices->size();++n)\r
 128                                         NewVertices->push_back((*Vertices)[n]);\r
 129 \r
 130                                 delete Vertices;\r
 131                         }\r
 132 \r
 133                         Vertices=NewVertices;\r
 134                 }\r
 135 \r
 136                 void* getData() override {return Vertices->pointer();}\r
 137 \r
 138                 video::E_VERTEX_TYPE getType() const override {return Vertices->getType();}\r
 139 \r
 140                 u32 stride() const override {return Vertices->stride();}\r
 141 \r
 142                 u32 size() const override\r
 143                 {\r
 144                         return Vertices->size();\r
 145                 }\r
 146 \r
 147                 void push_back (const video::S3DVertex &element) override\r
 148                 {\r
 149                         Vertices->push_back(element);\r
 150                 }\r
 151 \r
 152                 video::S3DVertex& operator [](const u32 index) const override\r
 153                 {\r
 154                         return (*Vertices)[index];\r
 155                 }\r
 156 \r
 157                 video::S3DVertex& getLast() override\r
 158                 {\r
 159                         return Vertices->getLast();\r
 160                 }\r
 161 \r
 162                 void set_used(u32 usedNow) override\r
 163                 {\r
 164                         Vertices->set_used(usedNow);\r
 165                 }\r
 166 \r
 167                 void reallocate(u32 new_size) override\r
 168                 {\r
 169                         Vertices->reallocate(new_size);\r
 170                 }\r
 171 \r
 172                 u32 allocated_size() const override\r
 173                 {\r
 174                         return Vertices->allocated_size();\r
 175                 }\r
 176 \r
 177                 video::S3DVertex* pointer() override\r
 178                 {\r
 179                         return Vertices->pointer();\r
 180                 }\r
 181 \r
 182                 //! get the current hardware mapping hint\r
 183                 E_HARDWARE_MAPPING getHardwareMappingHint() const override\r
 184                 {\r
 185                         return MappingHint;\r
 186                 }\r
 187 \r
 188                 //! set the hardware mapping hint, for driver\r
 189                 void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) override\r
 190                 {\r
 191                         MappingHint=NewMappingHint;\r
 192                 }\r
 193 \r
 194                 //! flags the mesh as changed, reloads hardware buffers\r
 195                 void setDirty() override\r
 196                 {\r
 197                         ++ChangedID;\r
 198                 }\r
 199 \r
 200                 //! Get the currently used ID for identification of changes.\r
 201                 /** This shouldn't be used for anything outside the VideoDriver. */\r
 202                 u32 getChangedID() const override  {return ChangedID;}\r
 203 \r
 204                 E_HARDWARE_MAPPING MappingHint;\r
 205                 u32 ChangedID;\r
 206         };\r
 207 \r
 208 \r
 209 } // end namespace scene\r
 210 } // end namespace irr\r
 211 \r
 212 #endif\r
 213 \r