Irrlicht 3D Engine: SSkinMeshBuffer.h Source File

| Irrlicht 3D Engine |

SSkinMeshBuffer.h
Go to the documentation of this file.

    00001 // Copyright (C) 2002-2012 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 __I_SKIN_MESH_BUFFER_H_INCLUDED__
    00006 #define __I_SKIN_MESH_BUFFER_H_INCLUDED__
    00007
    00008 #include "IMeshBuffer.h"
    00009 #include "S3DVertex.h"
    00010
    00011
    00012 namespace irr
    00013 {
    00014 namespace scene
    00015 {
    00016
    00017
    00019 struct SSkinMeshBuffer : public IMeshBuffer
    00020 {
    00022     SSkinMeshBuffer(video::E_VERTEX_TYPE vt=video::EVT_STANDARD) :
    00023         ChangedID_Vertex(1), ChangedID_Index(1), VertexType(vt),
    00024         MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER),
    00025         BoundingBoxNeedsRecalculated(true)
    00026     {
    00027         #ifdef _DEBUG
    00028         setDebugName("SSkinMeshBuffer");
    00029         #endif
    00030     }
    00031
    00033     virtual const video::SMaterial& getMaterial() const
    00034     {
    00035         return Material;
    00036     }
    00037
    00039     virtual video::SMaterial& getMaterial()
    00040     {
    00041         return Material;
    00042     }
    00043
    00045     virtual video::S3DVertex *getVertex(u32 index)
    00046     {
    00047         switch (VertexType)
    00048         {
    00049             case video::EVT_2TCOORDS:
    00050                 return (video::S3DVertex*)&Vertices_2TCoords[index];
    00051             case video::EVT_TANGENTS:
    00052                 return (video::S3DVertex*)&Vertices_Tangents[index];
    00053             default:
    00054                 return &Vertices_Standard[index];
    00055         }
    00056     }
    00057
    00059     virtual const void* getVertices() const
    00060     {
    00061         switch (VertexType)
    00062         {
    00063             case video::EVT_2TCOORDS:
    00064                 return Vertices_2TCoords.const_pointer();
    00065             case video::EVT_TANGENTS:
    00066                 return Vertices_Tangents.const_pointer();
    00067             default:
    00068                 return Vertices_Standard.const_pointer();
    00069         }
    00070     }
    00071
    00073     virtual void* getVertices()
    00074     {
    00075         switch (VertexType)
    00076         {
    00077             case video::EVT_2TCOORDS:
    00078                 return Vertices_2TCoords.pointer();
    00079             case video::EVT_TANGENTS:
    00080                 return Vertices_Tangents.pointer();
    00081             default:
    00082                 return Vertices_Standard.pointer();
    00083         }
    00084     }
    00085
    00087     virtual u32 getVertexCount() const
    00088     {
    00089         switch (VertexType)
    00090         {
    00091             case video::EVT_2TCOORDS:
    00092                 return Vertices_2TCoords.size();
    00093             case video::EVT_TANGENTS:
    00094                 return Vertices_Tangents.size();
    00095             default:
    00096                 return Vertices_Standard.size();
    00097         }
    00098     }
    00099
    00101
    00102     virtual video::E_INDEX_TYPE getIndexType() const
    00103     {
    00104         return video::EIT_16BIT;
    00105     }
    00106
    00108     virtual const u16* getIndices() const
    00109     {
    00110         return Indices.const_pointer();
    00111     }
    00112
    00114     virtual u16* getIndices()
    00115     {
    00116         return Indices.pointer();
    00117     }
    00118
    00120     virtual u32 getIndexCount() const
    00121     {
    00122         return Indices.size();
    00123     }
    00124
    00126     virtual const core::aabbox3d<f32>& getBoundingBox() const
    00127     {
    00128         return BoundingBox;
    00129     }
    00130
    00132     virtual void setBoundingBox( const core::aabbox3df& box)
    00133     {
    00134         BoundingBox = box;
    00135     }
    00136
    00138     virtual void recalculateBoundingBox()
    00139     {
    00140         if(!BoundingBoxNeedsRecalculated)
    00141             return;
    00142
    00143         BoundingBoxNeedsRecalculated = false;
    00144
    00145         switch (VertexType)
    00146         {
    00147             case video::EVT_STANDARD:
    00148             {
    00149                 if (Vertices_Standard.empty())
    00150                     BoundingBox.reset(0,0,0);
    00151                 else
    00152                 {
    00153                     BoundingBox.reset(Vertices_Standard[0].Pos);
    00154                     for (u32 i=1; i<Vertices_Standard.size(); ++i)
    00155                         BoundingBox.addInternalPoint(Vertices_Standard[i].Pos);
    00156                 }
    00157                 break;
    00158             }
    00159             case video::EVT_2TCOORDS:
    00160             {
    00161                 if (Vertices_2TCoords.empty())
    00162                     BoundingBox.reset(0,0,0);
    00163                 else
    00164                 {
    00165                     BoundingBox.reset(Vertices_2TCoords[0].Pos);
    00166                     for (u32 i=1; i<Vertices_2TCoords.size(); ++i)
    00167                         BoundingBox.addInternalPoint(Vertices_2TCoords[i].Pos);
    00168                 }
    00169                 break;
    00170             }
    00171             case video::EVT_TANGENTS:
    00172             {
    00173                 if (Vertices_Tangents.empty())
    00174                     BoundingBox.reset(0,0,0);
    00175                 else
    00176                 {
    00177                     BoundingBox.reset(Vertices_Tangents[0].Pos);
    00178                     for (u32 i=1; i<Vertices_Tangents.size(); ++i)
    00179                         BoundingBox.addInternalPoint(Vertices_Tangents[i].Pos);
    00180                 }
    00181                 break;
    00182             }
    00183         }
    00184     }
    00185
    00187     virtual video::E_VERTEX_TYPE getVertexType() const
    00188     {
    00189         return VertexType;
    00190     }
    00191
    00193     virtual void convertTo2TCoords()
    00194     {
    00195         if (VertexType==video::EVT_STANDARD)
    00196         {
    00197             for(u32 n=0;n<Vertices_Standard.size();++n)
    00198             {
    00199                 video::S3DVertex2TCoords Vertex;
    00200                 Vertex.Color=Vertices_Standard[n].Color;
    00201                 Vertex.Pos=Vertices_Standard[n].Pos;
    00202                 Vertex.Normal=Vertices_Standard[n].Normal;
    00203                 Vertex.TCoords=Vertices_Standard[n].TCoords;
    00204                 Vertices_2TCoords.push_back(Vertex);
    00205             }
    00206             Vertices_Standard.clear();
    00207             VertexType=video::EVT_2TCOORDS;
    00208         }
    00209     }
    00210
    00212     virtual void convertToTangents()
    00213     {
    00214         if (VertexType==video::EVT_STANDARD)
    00215         {
    00216             for(u32 n=0;n<Vertices_Standard.size();++n)
    00217             {
    00218                 video::S3DVertexTangents Vertex;
    00219                 Vertex.Color=Vertices_Standard[n].Color;
    00220                 Vertex.Pos=Vertices_Standard[n].Pos;
    00221                 Vertex.Normal=Vertices_Standard[n].Normal;
    00222                 Vertex.TCoords=Vertices_Standard[n].TCoords;
    00223                 Vertices_Tangents.push_back(Vertex);
    00224             }
    00225             Vertices_Standard.clear();
    00226             VertexType=video::EVT_TANGENTS;
    00227         }
    00228         else if (VertexType==video::EVT_2TCOORDS)
    00229         {
    00230             for(u32 n=0;n<Vertices_2TCoords.size();++n)
    00231             {
    00232                 video::S3DVertexTangents Vertex;
    00233                 Vertex.Color=Vertices_2TCoords[n].Color;
    00234                 Vertex.Pos=Vertices_2TCoords[n].Pos;
    00235                 Vertex.Normal=Vertices_2TCoords[n].Normal;
    00236                 Vertex.TCoords=Vertices_2TCoords[n].TCoords;
    00237                 Vertices_Tangents.push_back(Vertex);
    00238             }
    00239             Vertices_2TCoords.clear();
    00240             VertexType=video::EVT_TANGENTS;
    00241         }
    00242     }
    00243
    00245     virtual const core::vector3df& getPosition(u32 i) const
    00246     {
    00247         switch (VertexType)
    00248         {
    00249             case video::EVT_2TCOORDS:
    00250                 return Vertices_2TCoords[i].Pos;
    00251             case video::EVT_TANGENTS:
    00252                 return Vertices_Tangents[i].Pos;
    00253             default:
    00254                 return Vertices_Standard[i].Pos;
    00255         }
    00256     }
    00257
    00259     virtual core::vector3df& getPosition(u32 i)
    00260     {
    00261         switch (VertexType)
    00262         {
    00263             case video::EVT_2TCOORDS:
    00264                 return Vertices_2TCoords[i].Pos;
    00265             case video::EVT_TANGENTS:
    00266                 return Vertices_Tangents[i].Pos;
    00267             default:
    00268                 return Vertices_Standard[i].Pos;
    00269         }
    00270     }
    00271
    00273     virtual const core::vector3df& getNormal(u32 i) const
    00274     {
    00275         switch (VertexType)
    00276         {
    00277             case video::EVT_2TCOORDS:
    00278                 return Vertices_2TCoords[i].Normal;
    00279             case video::EVT_TANGENTS:
    00280                 return Vertices_Tangents[i].Normal;
    00281             default:
    00282                 return Vertices_Standard[i].Normal;
    00283         }
    00284     }
    00285
    00287     virtual core::vector3df& getNormal(u32 i)
    00288     {
    00289         switch (VertexType)
    00290         {
    00291             case video::EVT_2TCOORDS:
    00292                 return Vertices_2TCoords[i].Normal;
    00293             case video::EVT_TANGENTS:
    00294                 return Vertices_Tangents[i].Normal;
    00295             default:
    00296                 return Vertices_Standard[i].Normal;
    00297         }
    00298     }
    00299
    00301     virtual const core::vector2df& getTCoords(u32 i) const
    00302     {
    00303         switch (VertexType)
    00304         {
    00305             case video::EVT_2TCOORDS:
    00306                 return Vertices_2TCoords[i].TCoords;
    00307             case video::EVT_TANGENTS:
    00308                 return Vertices_Tangents[i].TCoords;
    00309             default:
    00310                 return Vertices_Standard[i].TCoords;
    00311         }
    00312     }
    00313
    00315     virtual core::vector2df& getTCoords(u32 i)
    00316     {
    00317         switch (VertexType)
    00318         {
    00319             case video::EVT_2TCOORDS:
    00320                 return Vertices_2TCoords[i].TCoords;
    00321             case video::EVT_TANGENTS:
    00322                 return Vertices_Tangents[i].TCoords;
    00323             default:
    00324                 return Vertices_Standard[i].TCoords;
    00325         }
    00326     }
    00327
    00329     virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) {}
    00330
    00332     virtual void append(const IMeshBuffer* const other) {}
    00333
    00335     virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const
    00336     {
    00337         return MappingHint_Vertex;
    00338     }
    00339
    00341     virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const
    00342     {
    00343         return MappingHint_Index;
    00344     }
    00345
    00347     virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX )
    00348     {
    00349         if (Buffer==EBT_VERTEX)
    00350             MappingHint_Vertex=NewMappingHint;
    00351         else if (Buffer==EBT_INDEX)
    00352             MappingHint_Index=NewMappingHint;
    00353         else if (Buffer==EBT_VERTEX_AND_INDEX)
    00354         {
    00355             MappingHint_Vertex=NewMappingHint;
    00356             MappingHint_Index=NewMappingHint;
    00357         }
    00358     }
    00359
    00361     virtual void setDirty(E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX)
    00362     {
    00363         if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_VERTEX)
    00364             ++ChangedID_Vertex;
    00365         if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX)
    00366             ++ChangedID_Index;
    00367     }
    00368
    00369     virtual u32 getChangedID_Vertex() const {return ChangedID_Vertex;}
    00370
    00371     virtual u32 getChangedID_Index() const {return ChangedID_Index;}
    00372
    00374     void boundingBoxNeedsRecalculated(void) { BoundingBoxNeedsRecalculated = true; }
    00375
    00376     core::array<video::S3DVertexTangents> Vertices_Tangents;
    00377     core::array<video::S3DVertex2TCoords> Vertices_2TCoords;
    00378     core::array<video::S3DVertex> Vertices_Standard;
    00379     core::array<u16> Indices;
    00380
    00381     u32 ChangedID_Vertex;
    00382     u32 ChangedID_Index;
    00383
    00384     //ISkinnedMesh::SJoint *AttachedJoint;
    00385     core::matrix4 Transformation;
    00386
    00387     video::SMaterial Material;
    00388     video::E_VERTEX_TYPE VertexType;
    00389
    00390     core::aabbox3d<f32> BoundingBox;
    00391
    00392     // hardware mapping hint
    00393     E_HARDWARE_MAPPING MappingHint_Vertex:3;
    00394     E_HARDWARE_MAPPING MappingHint_Index:3;
    00395
    00396     bool BoundingBoxNeedsRecalculated:1;
    00397 };
    00398
    00399
    00400 } // end namespace scene
    00401 } // end namespace irr
    00402
    00403 #endif
    00404