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                         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                         setType(VertexBufferCopy.getType());\r
  86                         reallocate(VertexBufferCopy.size());\r
  87 \r
  88                         for (u32 n=0;n<VertexBufferCopy.size();++n)\r
  89                                 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                         IVertexList *NewVertices=0;\r
 101 \r
 102                         switch (vertexType)\r
 103                         {\r
 104                                 case video::EVT_STANDARD:\r
 105                                 {\r
 106                                         NewVertices=new CSpecificVertexList<video::S3DVertex>;\r
 107                                         break;\r
 108                                 }\r
 109                                 case video::EVT_2TCOORDS:\r
 110                                 {\r
 111                                         NewVertices=new CSpecificVertexList<video::S3DVertex2TCoords>;\r
 112                                         break;\r
 113                                 }\r
 114                                 case video::EVT_TANGENTS:\r
 115                                 {\r
 116                                         NewVertices=new CSpecificVertexList<video::S3DVertexTangents>;\r
 117                                         break;\r
 118                                 }\r
 119                         }\r
 120                         if (Vertices)\r
 121                         {\r
 122                                 NewVertices->reallocate( Vertices->size() );\r
 123 \r
 124                                 for(u32 n=0;n<Vertices->size();++n)\r
 125                                         NewVertices->push_back((*Vertices)[n]);\r
 126 \r
 127                                 delete Vertices;\r
 128                         }\r
 129 \r
 130                         Vertices=NewVertices;\r
 131                 }\r
 132 \r
 133                 void* getData() override {return Vertices->pointer();}\r
 134 \r
 135                 video::E_VERTEX_TYPE getType() const override {return Vertices->getType();}\r
 136 \r
 137                 u32 stride() const override {return Vertices->stride();}\r
 138 \r
 139                 u32 size() const override\r
 140                 {\r
 141                         return Vertices->size();\r
 142                 }\r
 143 \r
 144                 void push_back (const video::S3DVertex &element) override\r
 145                 {\r
 146                         Vertices->push_back(element);\r
 147                 }\r
 148 \r
 149                 video::S3DVertex& operator [](const u32 index) const override\r
 150                 {\r
 151                         return (*Vertices)[index];\r
 152                 }\r
 153 \r
 154                 video::S3DVertex& getLast() override\r
 155                 {\r
 156                         return Vertices->getLast();\r
 157                 }\r
 158 \r
 159                 void set_used(u32 usedNow) override\r
 160                 {\r
 161                         Vertices->set_used(usedNow);\r
 162                 }\r
 163 \r
 164                 void reallocate(u32 new_size) override\r
 165                 {\r
 166                         Vertices->reallocate(new_size);\r
 167                 }\r
 168 \r
 169                 u32 allocated_size() const override\r
 170                 {\r
 171                         return Vertices->allocated_size();\r
 172                 }\r
 173 \r
 174                 video::S3DVertex* pointer() override\r
 175                 {\r
 176                         return Vertices->pointer();\r
 177                 }\r
 178 \r
 179                 //! get the current hardware mapping hint\r
 180                 E_HARDWARE_MAPPING getHardwareMappingHint() const override\r
 181                 {\r
 182                         return MappingHint;\r
 183                 }\r
 184 \r
 185                 //! set the hardware mapping hint, for driver\r
 186                 void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) override\r
 187                 {\r
 188                         MappingHint=NewMappingHint;\r
 189                 }\r
 190 \r
 191                 //! flags the mesh as changed, reloads hardware buffers\r
 192                 void setDirty() override\r
 193                 {\r
 194                         ++ChangedID;\r
 195                 }\r
 196 \r
 197                 //! Get the currently used ID for identification of changes.\r
 198                 /** This shouldn't be used for anything outside the VideoDriver. */\r
 199                 u32 getChangedID() const override  {return ChangedID;}\r
 200 \r
 201                 E_HARDWARE_MAPPING MappingHint;\r
 202                 u32 ChangedID;\r
 203         };\r
 204 \r
 205 \r
 206 } // end namespace scene\r
 207 } // end namespace irr\r
 208 \r
 209 #endif\r
 210 \r