SSharedMeshBuffer.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 S_SHARED_MESH_BUFFER_HPP_INCLUDED
#define S_SHARED_MESH_BUFFER_HPP_INCLUDED
 
#include <duckcpp/core/engine/irrArray.hpp>
#include <duckcpp/core/engine/IMeshBuffer.hpp>
 
namespace dcpp
{
namespace scene
{
    class SSharedMeshBuffer : public IMeshBuffer
    {
    public:
        SSharedMeshBuffer() 
            : IMeshBuffer()
            , Vertices(0), ChangedID_Vertex(1), ChangedID_Index(1)
            , MappingHintVertex(EHM_NEVER), MappingHintIndex(EHM_NEVER)
            , PrimitiveType(EPT_TRIANGLES)
        {
            #ifdef _DEBUG
            setDebugName("SSharedMeshBuffer");
            #endif
        }
 
        SSharedMeshBuffer(dcpp::nub::array<dcpp::video::S3DVertex> *vertices) : IMeshBuffer(), Vertices(vertices), ChangedID_Vertex(1), ChangedID_Index(1), MappingHintVertex(EHM_NEVER), MappingHintIndex(EHM_NEVER)
        {
            #ifdef _DEBUG
            setDebugName("SSharedMeshBuffer");
            #endif
        }
 
    public:
        virtual const dcpp::video::SMaterial& getMaterial() const override
        {
            return Material;
        }
 
        virtual dcpp::video::SMaterial& getMaterial() override
        {
            return Material;
        }
 
        virtual const void* getVertices() const override
        {
            if (Vertices)
                return Vertices->const_pointer();
            else
                return 0;
        }
 
        virtual void* getVertices() override
        {
            if (Vertices)
                return Vertices->pointer();
            else
                return 0;
        }
 
        virtual dcpp::uint32_kt getVertexCount() const override
        {
            if (Vertices)
                return Vertices->size();
            else
                return 0;
        }
 
        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 dcpp::video::E_INDEX_TYPE getIndexType() const override
        {
            return dcpp::video::EIT_16BIT;
        }
 
        virtual const dcpp::nub::aabbox3df& getBoundingBox() const override
        {
            return BoundingBox;
        }
 
        virtual void setBoundingBox( const dcpp::nub::aabbox3df& box) override
        {
            BoundingBox = box;
        }
 
        virtual dcpp::video::E_VERTEX_TYPE getVertexType() const override
        {
            return dcpp::video::EVT_STANDARD;
        }
 
        virtual void recalculateBoundingBox() override
        {
            if (!Vertices || Vertices->empty() || Indices.empty())
                BoundingBox.reset(0,0,0);
            else
            {
                BoundingBox.reset((*Vertices)[Indices[0]].Pos);
                for (dcpp::uint32_kt i=1; i<Indices.size(); ++i)
                    BoundingBox.addInternalPoint((*Vertices)[Indices[i]].Pos);
            }
        }
 
        virtual const dcpp::nub::vector3df& getPosition(dcpp::uint32_kt i) const override
        {
            DCPP_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Pos;
        }
 
        virtual dcpp::nub::vector3df& getPosition(dcpp::uint32_kt i) override
        {
            DCPP_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Pos;
        }
 
        virtual const dcpp::nub::vector3df& getNormal(dcpp::uint32_kt i) const override
        {
            DCPP_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Normal;
        }
 
        virtual dcpp::nub::vector3df& getNormal(dcpp::uint32_kt i) override
        {
            DCPP_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Normal;
        }
 
        virtual const dcpp::nub::vector2df& getTCoords(dcpp::uint32_kt i) const override
        {
            DCPP_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].TCoords;
        }
 
        virtual dcpp::nub::vector2df& getTCoords(dcpp::uint32_kt i) override
        {
            DCPP_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].TCoords;
        }
 
        virtual dcpp::video::SColor& getColor(dcpp::uint32_kt i) override
        {
            DCPP_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Color;
        }
 
        virtual const dcpp::video::SColor& getColor(dcpp::uint32_kt i) const override
        {
            DCPP_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Color;
        }
 
 
        virtual void append(const void* const vertices, dcpp::uint32_kt numVertices, const dcpp::uint16_kt* const indices, dcpp::uint32_kt numIndices)  override 
        {
            // can't do that as it doesn't own the vertex memory
        }
 
        virtual void append(const IMeshBuffer* const other) override 
        {
            // can't do that as it doesn't own the vertex memory
        }
 
        virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const override
        {
            return MappingHintVertex;
        }
 
        virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const override
        {
            return MappingHintIndex;
        }
 
        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)
                MappingHintVertex=NewMappingHint;
            if (buffer==EBT_VERTEX_AND_INDEX || buffer==EBT_INDEX)
                MappingHintIndex=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 EMBT_SHARED;
        }
 
        virtual IMeshBuffer* createClone(int cloneFlags) const override
        {
            SSharedMeshBuffer * clone = new SSharedMeshBuffer();
 
            if (cloneFlags & ECF_VERTICES)
            {
                clone->Vertices = Vertices;
                clone->BoundingBox = BoundingBox;
            }
 
            if (cloneFlags & ECF_INDICES)
            {
                clone->Indices = Indices;
            }
 
            clone->Material = Material;
            clone->MappingHintVertex = MappingHintVertex;
            clone->MappingHintIndex = MappingHintIndex;
            clone->PrimitiveType = PrimitiveType;
 
            return clone;
        }
 
    public:
        dcpp::video::SMaterial Material;
 
        dcpp::nub::array<dcpp::video::S3DVertex> *Vertices;
 
        dcpp::nub::array<dcpp::uint16_kt> Indices;
 
        dcpp::uint32_kt ChangedID_Vertex;
 
        dcpp::uint32_kt ChangedID_Index;
 
        dcpp::nub::aabbox3df BoundingBox;
 
        E_HARDWARE_MAPPING MappingHintVertex;
        E_HARDWARE_MAPPING MappingHintIndex;
 
        E_PRIMITIVE_TYPE PrimitiveType;
    };
 
} // end namespace scene
} // end namespace dcpp
 
#endif