CMeshBuffer.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 NIRT_T_MESH_BUFFER_HPP_INCLUDED
#define NIRT_T_MESH_BUFFER_HPP_INCLUDED
 
#include <nirtcpp/core/engine/irrArray.hpp>
#include <nirtcpp/core/engine/IMeshBuffer.hpp>
 
namespace nirt
{
namespace scene
{
    template <class T>
    class CMeshBuffer : public IMeshBuffer
    {
    public:
        CMeshBuffer()
            : ChangedID_Vertex(1), ChangedID_Index(1)
            , MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER)
            , PrimitiveType(EPT_TRIANGLES)
        {
            #ifdef _DEBUG
            setDebugName("CMeshBuffer");
            #endif
        }
 
 
 
        virtual const video::SMaterial& getMaterial() const override
        {
            return Material;
        }
 
 
 
        virtual video::SMaterial& getMaterial() override
        {
            return Material;
        }
 
 
 
        virtual const void* getVertices() const override
        {
            return Vertices.const_pointer();
        }
 
 
 
        virtual void* getVertices() override
        {
            return Vertices.pointer();
        }
 
 
 
        virtual u32 getVertexCount() const override
        {
            return Vertices.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 (!Vertices.empty())
            {
                BoundingBox.reset(Vertices[0].Pos);
                const nirt::u32 vsize = Vertices.size();
                for (u32 i=1; i<vsize; ++i)
                    BoundingBox.addInternalPoint(Vertices[i].Pos);
            }
            else
                BoundingBox.reset(0,0,0);
 
        }
 
 
 
        virtual video::E_VERTEX_TYPE getVertexType() const override
        {
            return T::getType();
        }
 
        virtual const core::vector3df& getPosition(u32 i) const override
        {
            return Vertices[i].Pos;
        }
 
        virtual core::vector3df& getPosition(u32 i) override
        {
            return Vertices[i].Pos;
        }
 
        virtual const core::vector3df& getNormal(u32 i) const override
        {
            return Vertices[i].Normal;
        }
 
        virtual core::vector3df& getNormal(u32 i) override
        {
            return Vertices[i].Normal;
        }
 
        virtual const core::vector2df& getTCoords(u32 i) const override
        {
            return Vertices[i].TCoords;
        }
 
        virtual core::vector2df& getTCoords(u32 i) override
        {
            return Vertices[i].TCoords;
        }
 
        virtual video::SColor& getColor(u32 i) override
        {
            return Vertices[i].Color;
        }
 
        virtual const video::SColor& getColor(u32 i) const override
        {
            return Vertices[i].Color;
        }
 
 
        virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) override
        {
            if (vertices == getVertices())
                return;
 
            const u32 vertexCount = getVertexCount();
            u32 i;
 
            Vertices.reallocate(vertexCount+numVertices);
            for (i=0; i<numVertices; ++i)
            {
                Vertices.push_back(static_cast<const T*>(vertices)[i]);
                BoundingBox.addInternalPoint(static_cast<const T*>(vertices)[i].Pos);
            }
 
            Indices.reallocate(getIndexCount()+numIndices);
            for (i=0; i<numIndices; ++i)
            {
                Indices.push_back(indices[i]+vertexCount);
            }
        }
 
 
 
        virtual void append(const IMeshBuffer* const other) override
        {
            /*
            if (this==other)
                return;
 
            const u32 vertexCount = getVertexCount();
            u32 i;
 
            Vertices.reallocate(vertexCount+other->getVertexCount());
            for (i=0; i<other->getVertexCount(); ++i)
            {
                Vertices.push_back(reinterpret_cast<const T*>(other->getVertices())[i]);
            }
 
            Indices.reallocate(getIndexCount()+other->getIndexCount());
            for (i=0; i<other->getIndexCount(); ++i)
            {
                Indices.push_back(other->getIndices()[i]+vertexCount);
            }
            BoundingBox.addInternalBox(other->getBoundingBox());
            */
        }
 
 
        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_AND_INDEX || Buffer==EBT_VERTEX)
                MappingHint_Vertex=NewMappingHint;
            if (Buffer==EBT_VERTEX_AND_INDEX || Buffer==EBT_INDEX)
                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 getTypeT();
        }
 
        virtual IMeshBuffer* createClone(int cloneFlags) const override
        {
            CMeshBuffer<T> * clone = new CMeshBuffer<T>();
 
            if (cloneFlags & ECF_VERTICES)
            {
                clone->Vertices = Vertices;
                clone->BoundingBox = BoundingBox;
            }
 
            if (cloneFlags & ECF_INDICES)
            {
                clone->Indices = Indices;
            }
 
            clone->PrimitiveType = PrimitiveType;
            clone->Material = getMaterial();
            clone->MappingHint_Vertex = MappingHint_Vertex;
            clone->MappingHint_Index = MappingHint_Index;
 
            return clone;
        }
 
        // Minor note: Some compilers (VS) allow directly specializing the virtual function,
        // but this will fail on other compilers (GCC). So using a helper function.
        EMESH_BUFFER_TYPE getTypeT() const;
 
        u32 ChangedID_Vertex;
        u32 ChangedID_Index;
 
        E_HARDWARE_MAPPING MappingHint_Vertex;
        E_HARDWARE_MAPPING MappingHint_Index;
 
        video::SMaterial Material;
        core::array<T> Vertices;
        core::array<u16> Indices;
        core::aabbox3d<f32> BoundingBox;
        E_PRIMITIVE_TYPE PrimitiveType;
    };
 
    using SMeshBuffer = CMeshBuffer<video::S3DVertex>;
    using SMeshBufferLightMap = CMeshBuffer<video::S3DVertex2TCoords>;
    using SMeshBufferTangents = CMeshBuffer<video::S3DVertexTangents>;
 
    template <>
    inline EMESH_BUFFER_TYPE CMeshBuffer<video::S3DVertex>::getTypeT() const
    {
        return EMBT_STANDARD;
    }
    template <>
    inline EMESH_BUFFER_TYPE CMeshBuffer<video::S3DVertex2TCoords>::getTypeT() const
    {
        return EMBT_LIGHTMAP;
    }
    template <>
    inline EMESH_BUFFER_TYPE CMeshBuffer<video::S3DVertexTangents>::getTypeT() const
    {
        return EMBT_TANGENTS;
    }
 
 
} // end namespace scene
} // end namespace nirt
 
#endif