Irrlicht Engine: CMeshBuffer.h Source File

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

# CMeshBuffer.h

Go to the documentation of this file.

    00001 // Copyright (C) 2002-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 __T_MESH_BUFFER_H_INCLUDED__
    00006 #define __T_MESH_BUFFER_H_INCLUDED__
    00007
    00008 #include "irrArray.h"
    00009 #include "IMeshBuffer.h"
    00010
    00011 namespace irr
    00012 {
    00013 namespace scene
    00014 {
    00016         template <class T>
    00017         class CMeshBuffer : public IMeshBuffer
    00018         {
    00019         public:
    00021                 CMeshBuffer():ChangedID_Vertex(1),ChangedID_Index(1),MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER)
    00022                 {
    00023                         #ifdef _DEBUG
    00024                         setDebugName("SMeshBuffer");
    00025                         #endif
    00026                 }
    00027
    00028
    00030
    00031                 virtual const video::SMaterial& getMaterial() const
    00032                 {
    00033                         return Material;
    00034                 }
    00035
    00036
    00038
    00039                 virtual video::SMaterial& getMaterial()
    00040                 {
    00041                         return Material;
    00042                 }
    00043
    00044
    00046
    00047                 virtual const void* getVertices() const
    00048                 {
    00049                         return Vertices.const_pointer();
    00050                 }
    00051
    00052
    00054
    00055                 virtual void* getVertices()
    00056                 {
    00057                         return Vertices.pointer();
    00058                 }
    00059
    00060
    00062
    00063                 virtual u32 getVertexCount() const
    00064                 {
    00065                         return Vertices.size();
    00066                 }
    00067
    00069
    00070                 virtual video::E_INDEX_TYPE getIndexType() const
    00071                 {
    00072                         return video::EIT_16BIT;
    00073                 }
    00074
    00076
    00077                 virtual const u16* getIndices() const
    00078                 {
    00079                         return Indices.const_pointer();
    00080                 }
    00081
    00082
    00084
    00085                 virtual u16* getIndices()
    00086                 {
    00087                         return Indices.pointer();
    00088                 }
    00089
    00090
    00092
    00093                 virtual u32 getIndexCount() const
    00094                 {
    00095                         return Indices.size();
    00096                 }
    00097
    00098
    00100
    00101                 virtual const core::aabbox3d<f32>& getBoundingBox() const
    00102                 {
    00103                         return BoundingBox;
    00104                 }
    00105
    00106
    00108
    00109
    00110                 virtual void setBoundingBox(const core::aabbox3df& box)
    00111                 {
    00112                         BoundingBox = box;
    00113                 }
    00114
    00115
    00117
    00118                 virtual void recalculateBoundingBox()
    00119                 {
    00120                         if (Vertices.empty())
    00121                                 BoundingBox.reset(0,0,0);
    00122                         else
    00123                         {
    00124                                 BoundingBox.reset(Vertices[0].Pos);
    00125                                 for (u32 i=1; i<Vertices.size(); ++i)
    00126                                         BoundingBox.addInternalPoint(Vertices[i].Pos);
    00127                         }
    00128                 }
    00129
    00130
    00132
    00133                 virtual video::E_VERTEX_TYPE getVertexType() const
    00134                 {
    00135                         return T().getType();
    00136                 }
    00137
    00139                 virtual const core::vector3df& getPosition(u32 i) const
    00140                 {
    00141                         return Vertices[i].Pos;
    00142                 }
    00143
    00145                 virtual core::vector3df& getPosition(u32 i)
    00146                 {
    00147                         return Vertices[i].Pos;
    00148                 }
    00149
    00151                 virtual const core::vector3df& getNormal(u32 i) const
    00152                 {
    00153                         return Vertices[i].Normal;
    00154                 }
    00155
    00157                 virtual core::vector3df& getNormal(u32 i)
    00158                 {
    00159                         return Vertices[i].Normal;
    00160                 }
    00161
    00163                 virtual const core::vector2df& getTCoords(u32 i) const
    00164                 {
    00165                         return Vertices[i].TCoords;
    00166                 }
    00167
    00169                 virtual core::vector2df& getTCoords(u32 i)
    00170                 {
    00171                         return Vertices[i].TCoords;
    00172                 }
    00173
    00174
    00176
    00180                 virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices)
    00181                 {
    00182                         if (vertices == getVertices())
    00183                                 return;
    00184
    00185                         const u32 vertexCount = getVertexCount();
    00186                         u32 i;
    00187
    00188                         Vertices.reallocate(vertexCount+numVertices);
    00189                         for (i=0; i<numVertices; ++i)
    00190                         {
    00191                                 Vertices.push_back(reinterpret_cast<const T*>(vertices)[i]);
    00192                                 BoundingBox.addInternalPoint(reinterpret_cast<const T*>(vertices)[i].Pos);
    00193                         }
    00194
    00195                         Indices.reallocate(getIndexCount()+numIndices);
    00196                         for (i=0; i<numIndices; ++i)
    00197                         {
    00198                                 Indices.push_back(indices[i]+vertexCount);
    00199                         }
    00200                 }
    00201
    00202
    00204
    00209                 virtual void append(const IMeshBuffer* const other)
    00210                 {
    00211                         /*
    00212                         if (this==other)
    00213                                 return;
    00214
    00215                         const u32 vertexCount = getVertexCount();
    00216                         u32 i;
    00217
    00218                         Vertices.reallocate(vertexCount+other->getVertexCount());
    00219                         for (i=0; i<other->getVertexCount(); ++i)
    00220                         {
    00221                                 Vertices.push_back(reinterpret_cast<const T*>(other->getVertices())[i]);
    00222                         }
    00223
    00224                         Indices.reallocate(getIndexCount()+other->getIndexCount());
    00225                         for (i=0; i<other->getIndexCount(); ++i)
    00226                         {
    00227                                 Indices.push_back(other->getIndices()[i]+vertexCount);
    00228                         }
    00229                         BoundingBox.addInternalBox(other->getBoundingBox());
    00230                         */
    00231                 }
    00232
    00233
    00235                 virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const
    00236                 {
    00237                         return MappingHint_Vertex;
    00238                 }
    00239
    00241                 virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const
    00242                 {
    00243                         return MappingHint_Index;
    00244                 }
    00245
    00247                 virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX )
    00248                 {
    00249                         if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_VERTEX)
    00250                                 MappingHint_Vertex=NewMappingHint;
    00251                         if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX)
    00252                                 MappingHint_Index=NewMappingHint;
    00253                 }
    00254
    00255
    00257                 virtual void setDirty(E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX)
    00258                 {
    00259                         if (Buffer==EBT_VERTEX_AND_INDEX ||Buffer==EBT_VERTEX)
    00260                                 ++ChangedID_Vertex;
    00261                         if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX)
    00262                                 ++ChangedID_Index;
    00263                 }
    00264
    00266
    00267                 virtual u32 getChangedID_Vertex() const {return ChangedID_Vertex;}
    00268
    00270
    00271                 virtual u32 getChangedID_Index() const {return ChangedID_Index;}
    00272
    00273                 u32 ChangedID_Vertex;
    00274                 u32 ChangedID_Index;
    00275
    00277                 E_HARDWARE_MAPPING MappingHint_Vertex;
    00278                 E_HARDWARE_MAPPING MappingHint_Index;
    00279
    00281                 video::SMaterial Material;
    00283                 core::array<T> Vertices;
    00285                 core::array<u16> Indices;
    00287                 core::aabbox3d<f32> BoundingBox;
    00288         };
    00289
    00291         typedef CMeshBuffer<video::S3DVertex> SMeshBuffer;
    00293         typedef CMeshBuffer<video::S3DVertex2TCoords> SMeshBufferLightMap;
    00295         typedef CMeshBuffer<video::S3DVertexTangents> SMeshBufferTangents;
    00296 } // end namespace scene
    00297 } // end namespace irr
    00298
    00299 #endif
    00300
    00301

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