PMeshBuffer.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 duckcpp/duckcpp.hpp
 
#ifndef DCPP_T_MESH_BUFFER_HPP_INCLUDED
#define DCPP_T_MESH_BUFFER_HPP_INCLUDED
 
#include <duckcpp/core/engine/irrArray.hpp>
#include <duckcpp/core/engine/IMeshBuffer.hpp>
 
namespace dcpp
{
namespace scene
{
    template <class T>
    class PMeshBuffer : public IMeshBuffer
    {
    public:
        PMeshBuffer()
            : ChangedID_Vertex(1), ChangedID_Index(1)
            , MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER)
            , PrimitiveType(EPT_TRIANGLES)
        {
            #ifdef _DEBUG
            setDebugName("PMeshBuffer");
            #endif
        }
 
 
 
        virtual const dcpp::video::SMaterial& getMaterial() const override
        {
            return Material;
        }
 
 
 
        virtual dcpp::video::SMaterial& getMaterial() override
        {
            return Material;
        }
 
 
 
        virtual const void* getVertices() const override
        {
            return Vertices.const_pointer();
        }
 
 
 
        virtual void* getVertices() override
        {
            return Vertices.pointer();
        }
 
 
 
        virtual dcpp::uint32_kt getVertexCount() const override
        {
            return Vertices.size();
        }
 
 
        virtual dcpp::video::E_INDEX_TYPE getIndexType() const override
        {
            return dcpp::video::EIT_16BIT;
        }
 
 
        virtual const dcpp::uint16_kt* getIndices() const override
        {
            return Indices.const_pointer();
        }
 
 
 
        virtual dcpp::uint16_kt* getIndices() override
        {
            return Indices.pointer();
        }
 
 
 
        virtual dcpp::uint32_kt getIndexCount() const override
        {
            return Indices.size();
        }
 
 
 
        virtual const dcpp::nub::aabbox3df& getBoundingBox() const override
        {
            return BoundingBox;
        }
 
 
 
        virtual void setBoundingBox(const dcpp::nub::aabbox3df& box) override
        {
            BoundingBox = box;
        }
 
 
 
        virtual void recalculateBoundingBox() override
        {
            if (!Vertices.empty())
            {
                BoundingBox.reset(Vertices[0].Pos);
                const dcpp::uint32_kt vsize = Vertices.size();
                for (dcpp::uint32_kt i=1; i<vsize; ++i)
                    BoundingBox.addInternalPoint(Vertices[i].Pos);
            }
            else
                BoundingBox.reset(0,0,0);
 
        }
 
 
 
        virtual dcpp::video::E_VERTEX_TYPE getVertexType() const override
        {
            return T::getType();
        }
 
        virtual const dcpp::nub::vector3df& getPosition(dcpp::uint32_kt i) const override
        {
            return Vertices[i].Pos;
        }
 
        virtual dcpp::nub::vector3df& getPosition(dcpp::uint32_kt i) override
        {
            return Vertices[i].Pos;
        }
 
        virtual const dcpp::nub::vector3df& getNormal(dcpp::uint32_kt i) const override
        {
            return Vertices[i].Normal;
        }
 
        virtual dcpp::nub::vector3df& getNormal(dcpp::uint32_kt i) override
        {
            return Vertices[i].Normal;
        }
 
        virtual const dcpp::nub::vector2df& getTCoords(dcpp::uint32_kt i) const override
        {
            return Vertices[i].TCoords;
        }
 
        virtual dcpp::nub::vector2df& getTCoords(dcpp::uint32_kt i) override
        {
            return Vertices[i].TCoords;
        }
 
        virtual dcpp::video::SColor& getColor(dcpp::uint32_kt i) override
        {
            return Vertices[i].Color;
        }
 
        virtual const dcpp::video::SColor& getColor(dcpp::uint32_kt i) const override
        {
            return Vertices[i].Color;
        }
 
 
        virtual void append(const void* const vertices, dcpp::uint32_kt numVertices, const dcpp::uint16_kt* const indices, dcpp::uint32_kt numIndices) override
        {
            if (vertices == getVertices())
                return;
 
            const dcpp::uint32_kt vertexCount = getVertexCount();
            dcpp::uint32_kt 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 dcpp::uint32_kt vertexCount = getVertexCount();
            dcpp::uint32_kt 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 dcpp::uint32_kt getChangedID_Vertex() const override {return ChangedID_Vertex;}
 
 
        virtual dcpp::uint32_kt getChangedID_Index() const override {return ChangedID_Index;}
 
        virtual EMESH_BUFFER_TYPE getType() const  override
        {
            return getTypeT();
        }
 
        virtual IMeshBuffer* createClone(int cloneFlags) const override
        {
            PMeshBuffer<T> * clone = new PMeshBuffer<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;
 
        dcpp::uint32_kt ChangedID_Vertex;
        dcpp::uint32_kt ChangedID_Index;
 
        E_HARDWARE_MAPPING MappingHint_Vertex;
        E_HARDWARE_MAPPING MappingHint_Index;
 
        dcpp::video::SMaterial Material;
        dcpp::nub::array<T> Vertices;
        dcpp::nub::array<dcpp::uint16_kt> Indices;
        dcpp::nub::aabbox3df BoundingBox;
        E_PRIMITIVE_TYPE PrimitiveType;
    };
 
    using SMeshBuffer = dcpp::scene::PMeshBuffer<dcpp::video::S3DVertex>;
    using SMeshBufferLightMap = dcpp::scene::PMeshBuffer<dcpp::video::S3DVertex2TCoords>;
    using SMeshBufferTangents = dcpp::scene::PMeshBuffer<dcpp::video::S3DVertexTangents>;
 
    template <>
    inline EMESH_BUFFER_TYPE PMeshBuffer<dcpp::video::S3DVertex>::getTypeT() const
    {
        return EMBT_STANDARD;
    }
    template <>
    inline EMESH_BUFFER_TYPE PMeshBuffer<dcpp::video::S3DVertex2TCoords>::getTypeT() const
    {
        return EMBT_LIGHTMAP;
    }
    template <>
    inline EMESH_BUFFER_TYPE PMeshBuffer<dcpp::video::S3DVertexTangents>::getTypeT() const
    {
        return EMBT_TANGENTS;
    }
 
 
} // end namespace scene
} // end namespace dcpp
 
#endif