include/CIndexBuffer.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_INDEX_BUFFER_H_INCLUDED__\r
   6 #define __C_INDEX_BUFFER_H_INCLUDED__\r
   7 \r
   8 #include "IIndexBuffer.h"\r
   9 \r
  10 namespace irr\r
  11 {\r
  12 namespace scene\r
  13 {\r
  14 \r
  15         class CIndexBuffer : public IIndexBuffer\r
  16         {\r
  17 \r
  18                 class IIndexList\r
  19                 {\r
  20                 public:\r
  21                         virtual ~IIndexList(){};\r
  22 \r
  23                         virtual u32 stride() const =0;\r
  24                         virtual u32 size() const =0;\r
  25                         virtual void push_back(const u32 &element) =0;\r
  26                         virtual u32 operator [](u32 index) const =0;\r
  27                         virtual u32 getLast() =0;\r
  28                         virtual void setValue(u32 index, u32 value) =0;\r
  29                         virtual void set_used(u32 usedNow) =0;\r
  30                         virtual void reallocate(u32 new_size) =0;\r
  31                         virtual u32 allocated_size() const =0;\r
  32                         virtual void* pointer() =0;\r
  33                         virtual video::E_INDEX_TYPE getType() const =0;\r
  34                 };\r
  35 \r
  36                 template <class T>\r
  37                 class CSpecificIndexList : public IIndexList\r
  38                 {\r
  39                 public:\r
  40                         core::array<T> Indices;\r
  41 \r
  42                         virtual u32 stride() const _IRR_OVERRIDE_ {return sizeof(T);}\r
  43 \r
  44                         virtual u32 size() const _IRR_OVERRIDE_ {return Indices.size();}\r
  45 \r
  46                         virtual void push_back(const u32 &element) _IRR_OVERRIDE_\r
  47                         {\r
  48                                 // push const ref due to compiler problem with gcc 4.6, big endian\r
  49                                 Indices.push_back((const T&)element);\r
  50                         }\r
  51 \r
  52                         virtual u32 operator [](u32 index) const _IRR_OVERRIDE_\r
  53                         {\r
  54                                 return (u32)(Indices[index]);\r
  55                         }\r
  56 \r
  57                         virtual u32 getLast() _IRR_OVERRIDE_ {return (u32)Indices.getLast();}\r
  58 \r
  59                         virtual void setValue(u32 index, u32 value) _IRR_OVERRIDE_\r
  60                         {\r
  61                                 Indices[index]=(T)value;\r
  62                         }\r
  63 \r
  64                         virtual void set_used(u32 usedNow) _IRR_OVERRIDE_\r
  65                         {\r
  66                                 Indices.set_used(usedNow);\r
  67                         }\r
  68 \r
  69                         virtual void reallocate(u32 new_size) _IRR_OVERRIDE_\r
  70                         {\r
  71                                 Indices.reallocate(new_size);\r
  72                         }\r
  73 \r
  74                         virtual u32 allocated_size() const _IRR_OVERRIDE_\r
  75                         {\r
  76                                 return Indices.allocated_size();\r
  77                         }\r
  78 \r
  79                         virtual void* pointer() _IRR_OVERRIDE_  {return Indices.pointer();}\r
  80 \r
  81                         virtual video::E_INDEX_TYPE getType() const _IRR_OVERRIDE_\r
  82                         {\r
  83                                 if (sizeof(T)==sizeof(u16))\r
  84                                         return video::EIT_16BIT;\r
  85                                 else\r
  86                                         return video::EIT_32BIT;\r
  87                         }\r
  88                 };\r
  89 \r
  90         public:\r
  91                 IIndexList *Indices;\r
  92 \r
  93                 CIndexBuffer(video::E_INDEX_TYPE IndexType) :Indices(0), MappingHint(EHM_NEVER), ChangedID(1)\r
  94                 {\r
  95                         setType(IndexType);\r
  96                 }\r
  97 \r
  98                 CIndexBuffer(const IIndexBuffer &IndexBufferCopy) :Indices(0), MappingHint(EHM_NEVER), ChangedID(1)\r
  99                 {\r
 100                         setType(IndexBufferCopy.getType());\r
 101                         reallocate(IndexBufferCopy.size());\r
 102 \r
 103                         for (u32 n=0;n<IndexBufferCopy.size();++n)\r
 104                                 push_back(IndexBufferCopy[n]);\r
 105                 }\r
 106 \r
 107                 virtual ~CIndexBuffer()\r
 108                 {\r
 109                         delete Indices;\r
 110                 }\r
 111 \r
 112                 //virtual void setType(video::E_INDEX_TYPE IndexType);\r
 113                 virtual void setType(video::E_INDEX_TYPE IndexType) _IRR_OVERRIDE_\r
 114                 {\r
 115                         IIndexList *NewIndices=0;\r
 116 \r
 117                         switch (IndexType)\r
 118                         {\r
 119                                 case video::EIT_16BIT:\r
 120                                 {\r
 121                                         NewIndices=new CSpecificIndexList<u16>;\r
 122                                         break;\r
 123                                 }\r
 124                                 case video::EIT_32BIT:\r
 125                                 {\r
 126                                         NewIndices=new CSpecificIndexList<u32>;\r
 127                                         break;\r
 128                                 }\r
 129                         }\r
 130 \r
 131                         if (Indices)\r
 132                         {\r
 133                                 NewIndices->reallocate( Indices->size() );\r
 134 \r
 135                                 for(u32 n=0;n<Indices->size();++n)\r
 136                                         NewIndices->push_back((*Indices)[n]);\r
 137 \r
 138                                 delete Indices;\r
 139                         }\r
 140 \r
 141                         Indices=NewIndices;\r
 142                 }\r
 143 \r
 144                 virtual void* getData() _IRR_OVERRIDE_ {return Indices->pointer();}\r
 145 \r
 146                 virtual video::E_INDEX_TYPE getType() const _IRR_OVERRIDE_ {return Indices->getType();}\r
 147 \r
 148                 virtual u32 stride() const _IRR_OVERRIDE_ {return Indices->stride();}\r
 149 \r
 150                 virtual u32 size() const _IRR_OVERRIDE_\r
 151                 {\r
 152                         return Indices->size();\r
 153                 }\r
 154 \r
 155                 virtual void push_back(const u32 &element) _IRR_OVERRIDE_\r
 156                 {\r
 157                         Indices->push_back(element);\r
 158                 }\r
 159 \r
 160                 virtual u32 operator [](u32 index) const _IRR_OVERRIDE_\r
 161                 {\r
 162                         return (*Indices)[index];\r
 163                 }\r
 164 \r
 165                 virtual u32 getLast() _IRR_OVERRIDE_\r
 166                 {\r
 167                         return Indices->getLast();\r
 168                 }\r
 169 \r
 170                 virtual void setValue(u32 index, u32 value) _IRR_OVERRIDE_\r
 171                 {\r
 172                         Indices->setValue(index, value);\r
 173                 }\r
 174 \r
 175                 virtual void set_used(u32 usedNow) _IRR_OVERRIDE_\r
 176                 {\r
 177                         Indices->set_used(usedNow);\r
 178                 }\r
 179 \r
 180                 virtual void reallocate(u32 new_size) _IRR_OVERRIDE_\r
 181                 {\r
 182                         Indices->reallocate(new_size);\r
 183                 }\r
 184 \r
 185                 virtual u32 allocated_size() const _IRR_OVERRIDE_\r
 186                 {\r
 187                         return Indices->allocated_size();\r
 188                 }\r
 189 \r
 190                 virtual void* pointer() _IRR_OVERRIDE_\r
 191                 {\r
 192                         return Indices->pointer();\r
 193                 }\r
 194 \r
 195                 //! get the current hardware mapping hint\r
 196                 virtual E_HARDWARE_MAPPING getHardwareMappingHint() const _IRR_OVERRIDE_\r
 197                 {\r
 198                         return MappingHint;\r
 199                 }\r
 200 \r
 201                 //! set the hardware mapping hint, for driver\r
 202                 virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint ) _IRR_OVERRIDE_\r
 203                 {\r
 204                         MappingHint=NewMappingHint;\r
 205                 }\r
 206 \r
 207                 //! flags the mesh as changed, reloads hardware buffers\r
 208                 virtual void setDirty() _IRR_OVERRIDE_\r
 209                 {\r
 210                         ++ChangedID;\r
 211                 }\r
 212 \r
 213                 //! Get the currently used ID for identification of changes.\r
 214                 /** This shouldn't be used for anything outside the VideoDriver. */\r
 215                 virtual u32 getChangedID() const _IRR_OVERRIDE_ {return ChangedID;}\r
 216 \r
 217                 E_HARDWARE_MAPPING MappingHint;\r
 218                 u32 ChangedID;\r
 219         };\r
 220 \r
 221 \r
 222 } // end namespace scene\r
 223 } // end namespace irr\r
 224 \r
 225 #endif\r
 226 \r