CDynamicMeshBuffer.hpp

// Copyright (C) 2008-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_C_DYNAMIC_MESHBUFFER_HPP_INCLUDED
#define NIRT_C_DYNAMIC_MESHBUFFER_HPP_INCLUDED
 
#include <nirtcpp/core/engine/IDynamicMeshBuffer.hpp>
 
#include <nirtcpp/core/engine/CVertexBuffer.hpp>
#include <nirtcpp/core/engine/CIndexBuffer.hpp>
 
namespace nirt
{
namespace scene
{
    class CDynamicMeshBuffer: public IDynamicMeshBuffer
    {
    public:
        CDynamicMeshBuffer(video::E_VERTEX_TYPE vertexType, video::E_INDEX_TYPE indexType)
        : PrimitiveType(EPT_TRIANGLES)
        {
            VertexBuffer=new CVertexBuffer(vertexType);
            IndexBuffer=new CIndexBuffer(indexType);
        }
 
        virtual ~CDynamicMeshBuffer()
        {
            if (VertexBuffer)
                VertexBuffer->drop();
            if (IndexBuffer)
                IndexBuffer->drop();
        }
 
        virtual IVertexBuffer& getVertexBuffer() const override
        {
            return *VertexBuffer;
        }
 
        virtual IIndexBuffer& getIndexBuffer() const override
        {
            return *IndexBuffer;
        }
 
        virtual void setVertexBuffer(IVertexBuffer *newVertexBuffer) override
        {
            if (newVertexBuffer)
                newVertexBuffer->grab();
            if (VertexBuffer)
                VertexBuffer->drop();
 
            VertexBuffer=newVertexBuffer;
        }
 
        virtual void setIndexBuffer(IIndexBuffer *newIndexBuffer) override
        {
            if (newIndexBuffer)
                newIndexBuffer->grab();
            if (IndexBuffer)
                IndexBuffer->drop();
 
            IndexBuffer=newIndexBuffer;
        }
 
        virtual const video::SMaterial& getMaterial() const override
        {
            return Material;
        }
 
        virtual video::SMaterial& getMaterial() override
        {
            return Material;
        }
 
        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 (!getVertexBuffer().size())
                BoundingBox.reset(0,0,0);
            else
            {
                BoundingBox.reset(getVertexBuffer()[0].Pos);
                for (u32 i=1; i<getVertexBuffer().size(); ++i)
                    BoundingBox.addInternalPoint(getVertexBuffer()[i].Pos);
            }
        }
 
 
        virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) override
        {
            // TODO
        }
 
 
        virtual void append(const IMeshBuffer* const other) override
        {
            // TODO
        }
 
 
        virtual void setPrimitiveType(E_PRIMITIVE_TYPE type) override
        {
            PrimitiveType = type;
        }
 
        virtual E_PRIMITIVE_TYPE getPrimitiveType() const override
        {
            return PrimitiveType;
        }
 
        virtual EMESH_BUFFER_TYPE getType() const  override
        {
            return EMBT_DYNAMIC;
        }
 
        virtual IMeshBuffer* createClone(int cloneFlags) const override
        {
            CDynamicMeshBuffer* clone = new CDynamicMeshBuffer(VertexBuffer->getType(), IndexBuffer->getType());
 
            if (cloneFlags & ECF_VERTICES)
            {
                const u32 numVertices = VertexBuffer->size();
                clone->VertexBuffer->reallocate(numVertices);
                for ( u32 i=0; i<numVertices; ++i )
                {
                    clone->VertexBuffer->push_back((*VertexBuffer)[i]);
                }
                clone->BoundingBox = BoundingBox;
            }
 
            if (cloneFlags & ECF_INDICES)
            {
                const u32 numIndices = IndexBuffer->size();
                clone->IndexBuffer->reallocate(numIndices);
                for ( u32 i=0; i<numIndices; ++i )
                {
                    clone->IndexBuffer->push_back((*IndexBuffer)[i]);
                }
            }
 
            clone->VertexBuffer->setHardwareMappingHint(VertexBuffer->getHardwareMappingHint());
            clone->IndexBuffer->setHardwareMappingHint(clone->IndexBuffer->getHardwareMappingHint());
            clone->Material = Material;
            clone->PrimitiveType = PrimitiveType;
 
            return clone;
        }
 
        video::SMaterial Material;
        core::aabbox3d<f32> BoundingBox;
        E_PRIMITIVE_TYPE PrimitiveType;
    private:
        CDynamicMeshBuffer(const CDynamicMeshBuffer&); // = delete in c++11, prevent copying
 
        IVertexBuffer *VertexBuffer;
        IIndexBuffer *IndexBuffer;
    };
 
 
} // end namespace scene
} // end namespace nirt
 
#endif