SSkinMeshBuffer.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __I_SKIN_MESH_BUFFER_H_INCLUDED__
#define __I_SKIN_MESH_BUFFER_H_INCLUDED__

#include "IMeshBuffer.h"
#include "S3DVertex.h"


namespace irr
{
namespace scene
{


struct SSkinMeshBuffer : public IMeshBuffer
{
        SSkinMeshBuffer(video::E_VERTEX_TYPE vt=video::EVT_STANDARD) :
                ChangedID_Vertex(1), ChangedID_Index(1), VertexType(vt),
                PrimitiveType(EPT_TRIANGLES),
                MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER),
                BoundingBoxNeedsRecalculated(true)
        {
                #ifdef _DEBUG
                setDebugName("SSkinMeshBuffer");
                #endif
        }

        virtual const video::SMaterial& getMaterial() const _IRR_OVERRIDE_
        {
                return Material;
        }

        virtual video::SMaterial& getMaterial() _IRR_OVERRIDE_
        {
                return Material;
        }

        virtual video::S3DVertex *getVertex(u32 index)
        {
                switch (VertexType)
                {
                        case video::EVT_2TCOORDS:
                                return (video::S3DVertex*)&Vertices_2TCoords[index];
                        case video::EVT_TANGENTS:
                                return (video::S3DVertex*)&Vertices_Tangents[index];
                        default:
                                return &Vertices_Standard[index];
                }
        }

        virtual const void* getVertices() const _IRR_OVERRIDE_
        {
                switch (VertexType)
                {
                        case video::EVT_2TCOORDS:
                                return Vertices_2TCoords.const_pointer();
                        case video::EVT_TANGENTS:
                                return Vertices_Tangents.const_pointer();
                        default:
                                return Vertices_Standard.const_pointer();
                }
        }

        virtual void* getVertices() _IRR_OVERRIDE_
        {
                switch (VertexType)
                {
                        case video::EVT_2TCOORDS:
                                return Vertices_2TCoords.pointer();
                        case video::EVT_TANGENTS:
                                return Vertices_Tangents.pointer();
                        default:
                                return Vertices_Standard.pointer();
                }
        }

        virtual u32 getVertexCount() const _IRR_OVERRIDE_
        {
                switch (VertexType)
                {
                        case video::EVT_2TCOORDS:
                                return Vertices_2TCoords.size();
                        case video::EVT_TANGENTS:
                                return Vertices_Tangents.size();
                        default:
                                return Vertices_Standard.size();
                }
        }


        virtual video::E_INDEX_TYPE getIndexType() const _IRR_OVERRIDE_
        {
                return video::EIT_16BIT;
        }

        virtual const u16* getIndices() const _IRR_OVERRIDE_
        {
                return Indices.const_pointer();
        }

        virtual u16* getIndices() _IRR_OVERRIDE_
        {
                return Indices.pointer();
        }

        virtual u32 getIndexCount() const _IRR_OVERRIDE_
        {
                return Indices.size();
        }

        virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_
        {
                return BoundingBox;
        }

        virtual void setBoundingBox( const core::aabbox3df& box) _IRR_OVERRIDE_
        {
                BoundingBox = box;
        }

        virtual void recalculateBoundingBox() _IRR_OVERRIDE_
        {
                if(!BoundingBoxNeedsRecalculated)
                        return;

                BoundingBoxNeedsRecalculated = false;

                switch (VertexType)
                {
                        case video::EVT_STANDARD:
                        {
                                if (Vertices_Standard.empty())
                                        BoundingBox.reset(0,0,0);
                                else
                                {
                                        BoundingBox.reset(Vertices_Standard[0].Pos);
                                        for (u32 i=1; i<Vertices_Standard.size(); ++i)
                                                BoundingBox.addInternalPoint(Vertices_Standard[i].Pos);
                                }
                                break;
                        }
                        case video::EVT_2TCOORDS:
                        {
                                if (Vertices_2TCoords.empty())
                                        BoundingBox.reset(0,0,0);
                                else
                                {
                                        BoundingBox.reset(Vertices_2TCoords[0].Pos);
                                        for (u32 i=1; i<Vertices_2TCoords.size(); ++i)
                                                BoundingBox.addInternalPoint(Vertices_2TCoords[i].Pos);
                                }
                                break;
                        }
                        case video::EVT_TANGENTS:
                        {
                                if (Vertices_Tangents.empty())
                                        BoundingBox.reset(0,0,0);
                                else
                                {
                                        BoundingBox.reset(Vertices_Tangents[0].Pos);
                                        for (u32 i=1; i<Vertices_Tangents.size(); ++i)
                                                BoundingBox.addInternalPoint(Vertices_Tangents[i].Pos);
                                }
                                break;
                        }
                }
        }

        virtual video::E_VERTEX_TYPE getVertexType() const _IRR_OVERRIDE_
        {
                return VertexType;
        }

        void convertTo2TCoords()
        {
                if (VertexType==video::EVT_STANDARD)
                {
                        for(u32 n=0;n<Vertices_Standard.size();++n)
                        {
                                video::S3DVertex2TCoords Vertex;
                                Vertex.Color=Vertices_Standard[n].Color;
                                Vertex.Pos=Vertices_Standard[n].Pos;
                                Vertex.Normal=Vertices_Standard[n].Normal;
                                Vertex.TCoords=Vertices_Standard[n].TCoords;
                                Vertices_2TCoords.push_back(Vertex);
                        }
                        Vertices_Standard.clear();
                        VertexType=video::EVT_2TCOORDS;
                }
        }

        void convertToTangents()
        {
                if (VertexType==video::EVT_STANDARD)
                {
                        for(u32 n=0;n<Vertices_Standard.size();++n)
                        {
                                video::S3DVertexTangents Vertex;
                                Vertex.Color=Vertices_Standard[n].Color;
                                Vertex.Pos=Vertices_Standard[n].Pos;
                                Vertex.Normal=Vertices_Standard[n].Normal;
                                Vertex.TCoords=Vertices_Standard[n].TCoords;
                                Vertices_Tangents.push_back(Vertex);
                        }
                        Vertices_Standard.clear();
                        VertexType=video::EVT_TANGENTS;
                }
                else if (VertexType==video::EVT_2TCOORDS)
                {
                        for(u32 n=0;n<Vertices_2TCoords.size();++n)
                        {
                                video::S3DVertexTangents Vertex;
                                Vertex.Color=Vertices_2TCoords[n].Color;
                                Vertex.Pos=Vertices_2TCoords[n].Pos;
                                Vertex.Normal=Vertices_2TCoords[n].Normal;
                                Vertex.TCoords=Vertices_2TCoords[n].TCoords;
                                Vertices_Tangents.push_back(Vertex);
                        }
                        Vertices_2TCoords.clear();
                        VertexType=video::EVT_TANGENTS;
                }
        }

        virtual const core::vector3df& getPosition(u32 i) const _IRR_OVERRIDE_
        {
                switch (VertexType)
                {
                        case video::EVT_2TCOORDS:
                                return Vertices_2TCoords[i].Pos;
                        case video::EVT_TANGENTS:
                                return Vertices_Tangents[i].Pos;
                        default:
                                return Vertices_Standard[i].Pos;
                }
        }

        virtual core::vector3df& getPosition(u32 i) _IRR_OVERRIDE_
        {
                switch (VertexType)
                {
                        case video::EVT_2TCOORDS:
                                return Vertices_2TCoords[i].Pos;
                        case video::EVT_TANGENTS:
                                return Vertices_Tangents[i].Pos;
                        default:
                                return Vertices_Standard[i].Pos;
                }
        }

        virtual const core::vector3df& getNormal(u32 i) const _IRR_OVERRIDE_
        {
                switch (VertexType)
                {
                        case video::EVT_2TCOORDS:
                                return Vertices_2TCoords[i].Normal;
                        case video::EVT_TANGENTS:
                                return Vertices_Tangents[i].Normal;
                        default:
                                return Vertices_Standard[i].Normal;
                }
        }

        virtual core::vector3df& getNormal(u32 i) _IRR_OVERRIDE_
        {
                switch (VertexType)
                {
                        case video::EVT_2TCOORDS:
                                return Vertices_2TCoords[i].Normal;
                        case video::EVT_TANGENTS:
                                return Vertices_Tangents[i].Normal;
                        default:
                                return Vertices_Standard[i].Normal;
                }
        }

        virtual const core::vector2df& getTCoords(u32 i) const _IRR_OVERRIDE_
        {
                switch (VertexType)
                {
                        case video::EVT_2TCOORDS:
                                return Vertices_2TCoords[i].TCoords;
                        case video::EVT_TANGENTS:
                                return Vertices_Tangents[i].TCoords;
                        default:
                                return Vertices_Standard[i].TCoords;
                }
        }

        virtual core::vector2df& getTCoords(u32 i) _IRR_OVERRIDE_
        {
                switch (VertexType)
                {
                        case video::EVT_2TCOORDS:
                                return Vertices_2TCoords[i].TCoords;
                        case video::EVT_TANGENTS:
                                return Vertices_Tangents[i].TCoords;
                        default:
                                return Vertices_Standard[i].TCoords;
                }
        }

        virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) _IRR_OVERRIDE_ {}

        virtual void append(const IMeshBuffer* const other) _IRR_OVERRIDE_ {}

        virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const _IRR_OVERRIDE_
        {
                return MappingHint_Vertex;
        }

        virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const _IRR_OVERRIDE_
        {
                return MappingHint_Index;
        }

        virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX ) _IRR_OVERRIDE_
        {
                if (Buffer==EBT_VERTEX)
                        MappingHint_Vertex=NewMappingHint;
                else if (Buffer==EBT_INDEX)
                        MappingHint_Index=NewMappingHint;
                else if (Buffer==EBT_VERTEX_AND_INDEX)
                {
                        MappingHint_Vertex=NewMappingHint;
                        MappingHint_Index=NewMappingHint;
                }
        }

        virtual void setPrimitiveType(E_PRIMITIVE_TYPE type) _IRR_OVERRIDE_
        {
                PrimitiveType = type;
        }

        virtual E_PRIMITIVE_TYPE getPrimitiveType() const _IRR_OVERRIDE_
        {
                return PrimitiveType;
        }

        virtual void setDirty(E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX) _IRR_OVERRIDE_
        {
                if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_VERTEX)
                        ++ChangedID_Vertex;
                if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX)
                        ++ChangedID_Index;
        }

        virtual u32 getChangedID_Vertex() const _IRR_OVERRIDE_ {return ChangedID_Vertex;}

        virtual u32 getChangedID_Index() const _IRR_OVERRIDE_ {return ChangedID_Index;}

        void boundingBoxNeedsRecalculated(void) { BoundingBoxNeedsRecalculated = true; }

        core::array<video::S3DVertexTangents> Vertices_Tangents;
        core::array<video::S3DVertex2TCoords> Vertices_2TCoords;
        core::array<video::S3DVertex> Vertices_Standard;
        core::array<u16> Indices;

        u32 ChangedID_Vertex;
        u32 ChangedID_Index;

        //ISkinnedMesh::SJoint *AttachedJoint;
        core::matrix4 Transformation;

        video::SMaterial Material;
        video::E_VERTEX_TYPE VertexType;

        core::aabbox3d<f32> BoundingBox;

        E_PRIMITIVE_TYPE PrimitiveType;

        // hardware mapping hint
        E_HARDWARE_MAPPING MappingHint_Vertex:3;
        E_HARDWARE_MAPPING MappingHint_Index:3;

        bool BoundingBoxNeedsRecalculated:1;
};


} // end namespace scene
} // end namespace irr

#endif