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 nirtcpp/nirtcpp.hpp
 
#ifndef S_SHARED_MESH_BUFFER_HPP_INCLUDED
#define S_SHARED_MESH_BUFFER_HPP_INCLUDED
 
#include <nirtcpp/core/engine/irrArray.hpp>
#include <nirtcpp/core/engine/IMeshBuffer.hpp>
 
namespace nirt
{
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(core::array<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 video::SMaterial& getMaterial() const override
        {
            return Material;
        }
 
        virtual 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 u32 getVertexCount() const override
        {
            if (Vertices)
                return Vertices->size();
            else
                return 0;
        }
 
        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 video::E_INDEX_TYPE getIndexType() const override
        {
            return video::EIT_16BIT;
        }
 
        virtual const core::aabbox3d<f32>& getBoundingBox() const override
        {
            return BoundingBox;
        }
 
        virtual void setBoundingBox( const core::aabbox3df& box) override
        {
            BoundingBox = box;
        }
 
        virtual video::E_VERTEX_TYPE getVertexType() const override
        {
            return 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 (u32 i=1; i<Indices.size(); ++i)
                    BoundingBox.addInternalPoint((*Vertices)[Indices[i]].Pos);
            }
        }
 
        virtual const core::vector3df& getPosition(u32 i) const override
        {
            NIRT_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Pos;
        }
 
        virtual core::vector3df& getPosition(u32 i) override
        {
            NIRT_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Pos;
        }
 
        virtual const core::vector3df& getNormal(u32 i) const override
        {
            NIRT_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Normal;
        }
 
        virtual core::vector3df& getNormal(u32 i) override
        {
            NIRT_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Normal;
        }
 
        virtual const core::vector2df& getTCoords(u32 i) const override
        {
            NIRT_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].TCoords;
        }
 
        virtual core::vector2df& getTCoords(u32 i) override
        {
            NIRT_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].TCoords;
        }
 
        virtual video::SColor& getColor(u32 i) override
        {
            NIRT_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Color;
        }
 
        virtual const video::SColor& getColor(u32 i) const override
        {
            NIRT_DEBUG_BREAK_IF(!Vertices);
            return (*Vertices)[Indices[i]].Color;
        }
 
 
        virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 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 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 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:
        video::SMaterial Material;
 
        core::array<video::S3DVertex> *Vertices;
 
        core::array<u16> Indices;
 
        u32 ChangedID_Vertex;
 
        u32 ChangedID_Index;
 
        core::aabbox3df BoundingBox;
 
        E_HARDWARE_MAPPING MappingHintVertex;
        E_HARDWARE_MAPPING MappingHintIndex;
 
        E_PRIMITIVE_TYPE PrimitiveType;
    };
 
} // end namespace scene
} // end namespace nirt
 
#endif