PDynamicMeshBuffer.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 duckcpp/duckcpp.hpp
 
#ifndef DCPP_P_DYNAMIC_MESHBUFFER_HPP_INCLUDED
#define DCPP_P_DYNAMIC_MESHBUFFER_HPP_INCLUDED
 
#include <duckcpp/core/engine/IDynamicMeshBuffer.hpp>
 
#include <duckcpp/core/engine/PVertexBuffer.hpp>
#include <duckcpp/core/engine/PIndexBuffer.hpp>
 
namespace dcpp
{
namespace scene
{
    class PDynamicMeshBuffer: public IDynamicMeshBuffer
    {
    public:
        PDynamicMeshBuffer(dcpp::video::E_VERTEX_TYPE vertexType, dcpp::video::E_INDEX_TYPE indexType)
        : PrimitiveType(EPT_TRIANGLES)
        {
            VertexBuffer=new PVertexBuffer(vertexType);
            IndexBuffer=new PIndexBuffer(indexType);
        }
 
        virtual ~PDynamicMeshBuffer()
        {
            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 dcpp::video::SMaterial& getMaterial() const override
        {
            return Material;
        }
 
        virtual dcpp::video::SMaterial& getMaterial() override
        {
            return Material;
        }
 
        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 (!getVertexBuffer().size())
                BoundingBox.reset(0,0,0);
            else
            {
                BoundingBox.reset(getVertexBuffer()[0].Pos);
                for (dcpp::uint32_kt i=1; i<getVertexBuffer().size(); ++i)
                    BoundingBox.addInternalPoint(getVertexBuffer()[i].Pos);
            }
        }
 
 
        virtual void append(const void* const vertices, dcpp::uint32_kt numVertices, const dcpp::uint16_kt* const indices, dcpp::uint32_kt 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
        {
            PDynamicMeshBuffer* clone = new PDynamicMeshBuffer(VertexBuffer->getType(), IndexBuffer->getType());
 
            if (cloneFlags & ECF_VERTICES)
            {
                const dcpp::uint32_kt numVertices = VertexBuffer->size();
                clone->VertexBuffer->reallocate(numVertices);
                for ( dcpp::uint32_kt i=0; i<numVertices; ++i )
                {
                    clone->VertexBuffer->push_back((*VertexBuffer)[i]);
                }
                clone->BoundingBox = BoundingBox;
            }
 
            if (cloneFlags & ECF_INDICES)
            {
                const dcpp::uint32_kt numIndices = IndexBuffer->size();
                clone->IndexBuffer->reallocate(numIndices);
                for ( dcpp::uint32_kt 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;
        }
 
        dcpp::video::SMaterial Material;
        dcpp::nub::aabbox3df BoundingBox;
        E_PRIMITIVE_TYPE PrimitiveType;
    private:
        PDynamicMeshBuffer(const PDynamicMeshBuffer&); // = delete in c++11, prevent copying
 
        IVertexBuffer *VertexBuffer;
        IIndexBuffer *IndexBuffer;
    };
 
 
} // end namespace scene
} // end namespace dcpp
 
#endif