SSkinMeshBuffer.hpp

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in nirtcpp/nirtcpp.hpp
 
#ifndef S_SKIN_MESH_BUFFER_HPP_INCLUDED
#define S_SKIN_MESH_BUFFER_HPP_INCLUDED
 
#include <nirtcpp/core/engine/IMeshBuffer.hpp>
#include <nirtcpp/core/engine/S3DVertex.hpp>
 
 
namespace nirt
{
namespace scene
{
 
 
class SSkinMeshBuffer : public IMeshBuffer
{
public:
    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 override
    {
        return Material;
    }
 
    virtual video::SMaterial& getMaterial() 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 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() 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 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 override
    {
        return video::EIT_16BIT;
    }
 
    virtual const u16* getIndices() const override
    {
        return Indices.const_pointer();
    }
 
    virtual u16* getIndices() override
    {
        return Indices.pointer();
    }
 
    virtual u32 getIndexCount() const override
    {
        return Indices.size();
    }
 
    virtual const core::aabbox3d<f32>& getBoundingBox() const override
    {
        return BoundingBox;
    }
 
    virtual void setBoundingBox( const core::aabbox3df& box) override
    {
        BoundingBox = box;
    }
 
    virtual void recalculateBoundingBox() 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 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 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) 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 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) 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 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) 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 video::SColor& getColor(u32 i) override
    {
        switch (VertexType)
        {
            case video::EVT_2TCOORDS:
                return Vertices_2TCoords[i].Color;
            case video::EVT_TANGENTS:
                return Vertices_Tangents[i].Color;
            default:
                return Vertices_Standard[i].Color;
        }
    }
 
    virtual const video::SColor& getColor(u32 i) const override
    {
        switch (VertexType)
        {
            case video::EVT_2TCOORDS:
                return Vertices_2TCoords[i].Color;
            case video::EVT_TANGENTS:
                return Vertices_Tangents[i].Color;
            default:
                return Vertices_Standard[i].Color;
        }
    }
 
    virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) override {}
 
    virtual void append(const IMeshBuffer* const other) override {}
 
    virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const override
    {
        return MappingHint_Vertex;
    }
 
    virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const override
    {
        return MappingHint_Index;
    }
 
    virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX ) 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) override
    {
        PrimitiveType = type;
    }
 
    virtual E_PRIMITIVE_TYPE getPrimitiveType() const override
    {
        return PrimitiveType;
    }
 
    virtual void setDirty(E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX) 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 override {return ChangedID_Vertex;}
 
    virtual u32 getChangedID_Index() const override {return ChangedID_Index;}
 
    virtual EMESH_BUFFER_TYPE getType() const  override
    {
        return EMBT_SKIN;
    }
 
    virtual IMeshBuffer* createClone(int cloneFlags) const override
    {
        SSkinMeshBuffer* clone = new SSkinMeshBuffer(VertexType);
 
        if (cloneFlags & ECF_VERTICES)
        {
            clone->Vertices_Tangents = Vertices_Tangents;
            clone->Vertices_2TCoords = Vertices_2TCoords;
            clone->Vertices_Standard = Vertices_Standard;
 
            clone->BoundingBox = BoundingBox;
            clone->BoundingBoxNeedsRecalculated = BoundingBoxNeedsRecalculated;
        }
 
        if (cloneFlags & ECF_INDICES)
        {
            clone->Indices = Indices;
        }
 
        clone->Transformation = Transformation;
        clone->Material = getMaterial();
        clone->PrimitiveType = PrimitiveType;
        clone->MappingHint_Vertex = MappingHint_Vertex;
        clone->MappingHint_Index = MappingHint_Index;
 
        return clone;
    }
 
    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 nirt
 
#endif