CMeshBuffer.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h

#ifndef __T_MESH_BUFFER_H_INCLUDED__
#define __T_MESH_BUFFER_H_INCLUDED__

#include "irrArray.h"
#include "IMeshBuffer.h"

namespace irr
{
namespace scene
{
        template <class T>
        class CMeshBuffer : public IMeshBuffer
        {
        public:
                CMeshBuffer()
                        : ChangedID_Vertex(1), ChangedID_Index(1)
                        , MappingHint_Vertex(EHM_NEVER), MappingHint_Index(EHM_NEVER)
                        , PrimitiveType(EPT_TRIANGLES)
                {
                        #ifdef _DEBUG
                        setDebugName("CMeshBuffer");
                        #endif
                }



                virtual const video::SMaterial& getMaterial() const _IRR_OVERRIDE_
                {
                        return Material;
                }



                virtual video::SMaterial& getMaterial() _IRR_OVERRIDE_
                {
                        return Material;
                }



                virtual const void* getVertices() const _IRR_OVERRIDE_
                {
                        return Vertices.const_pointer();
                }



                virtual void* getVertices() _IRR_OVERRIDE_
                {
                        return Vertices.pointer();
                }



                virtual u32 getVertexCount() const _IRR_OVERRIDE_
                {
                        return Vertices.size();
                }


                virtual video::E_INDEX_TYPE getIndexType() const _IRR_OVERRIDE_
                {
                        return video::EIT_16BIT;
                }


                virtual const u16* getIndices() const _IRR_OVERRIDE_
                {
                        return Indices.const_pointer();
                }



                virtual u16* getIndices() _IRR_OVERRIDE_
                {
                        return Indices.pointer();
                }



                virtual u32 getIndexCount() const _IRR_OVERRIDE_
                {
                        return Indices.size();
                }



                virtual const core::aabbox3d<f32>& getBoundingBox() const _IRR_OVERRIDE_
                {
                        return BoundingBox;
                }



                virtual void setBoundingBox(const core::aabbox3df& box) _IRR_OVERRIDE_
                {
                        BoundingBox = box;
                }



                virtual void recalculateBoundingBox() _IRR_OVERRIDE_
                {
                        if (!Vertices.empty())
                        {
                                BoundingBox.reset(Vertices[0].Pos);
                                const irr::u32 vsize = Vertices.size();
                                for (u32 i=1; i<vsize; ++i)
                                        BoundingBox.addInternalPoint(Vertices[i].Pos);
                        }
                        else
                                BoundingBox.reset(0,0,0);

                }



                virtual video::E_VERTEX_TYPE getVertexType() const _IRR_OVERRIDE_
                {
                        return T::getType();
                }

                virtual const core::vector3df& getPosition(u32 i) const _IRR_OVERRIDE_
                {
                        return Vertices[i].Pos;
                }

                virtual core::vector3df& getPosition(u32 i) _IRR_OVERRIDE_
                {
                        return Vertices[i].Pos;
                }

                virtual const core::vector3df& getNormal(u32 i) const _IRR_OVERRIDE_
                {
                        return Vertices[i].Normal;
                }

                virtual core::vector3df& getNormal(u32 i) _IRR_OVERRIDE_
                {
                        return Vertices[i].Normal;
                }

                virtual const core::vector2df& getTCoords(u32 i) const _IRR_OVERRIDE_
                {
                        return Vertices[i].TCoords;
                }

                virtual core::vector2df& getTCoords(u32 i) _IRR_OVERRIDE_
                {
                        return Vertices[i].TCoords;
                }



                virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) _IRR_OVERRIDE_
                {
                        if (vertices == getVertices())
                                return;

                        const u32 vertexCount = getVertexCount();
                        u32 i;

                        Vertices.reallocate(vertexCount+numVertices);
                        for (i=0; i<numVertices; ++i)
                        {
                                Vertices.push_back(reinterpret_cast<const T*>(vertices)[i]);
                                BoundingBox.addInternalPoint(reinterpret_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) _IRR_OVERRIDE_
                {
                        /*
                        if (this==other)
                                return;

                        const u32 vertexCount = getVertexCount();
                        u32 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 _IRR_OVERRIDE_
                {
                        return MappingHint_Vertex;
                }

                virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const _IRR_OVERRIDE_
                {
                        return MappingHint_Index;
                }

                virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX ) _IRR_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) _IRR_OVERRIDE_
                {
                        PrimitiveType = type;
                }

                virtual E_PRIMITIVE_TYPE getPrimitiveType() const _IRR_OVERRIDE_
                {
                        return PrimitiveType;
                }

                virtual void setDirty(E_BUFFER_TYPE Buffer=EBT_VERTEX_AND_INDEX) _IRR_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 _IRR_OVERRIDE_ {return ChangedID_Vertex;}


                virtual u32 getChangedID_Index() const _IRR_OVERRIDE_ {return ChangedID_Index;}

                u32 ChangedID_Vertex;
                u32 ChangedID_Index;

                E_HARDWARE_MAPPING MappingHint_Vertex;
                E_HARDWARE_MAPPING MappingHint_Index;

                video::SMaterial Material;
                core::array<T> Vertices;
                core::array<u16> Indices;
                core::aabbox3d<f32> BoundingBox;
                E_PRIMITIVE_TYPE PrimitiveType;
        };

        typedef CMeshBuffer<video::S3DVertex> SMeshBuffer;
        typedef CMeshBuffer<video::S3DVertex2TCoords> SMeshBufferLightMap;
        typedef CMeshBuffer<video::S3DVertexTangents> SMeshBufferTangents;
} // end namespace scene
} // end namespace irr

#endif