SSharedMeshBuffer.h

Go to the documentation of this file.

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

#ifndef __S_SHARED_MESH_BUFFER_H_INCLUDED__
#define __S_SHARED_MESH_BUFFER_H_INCLUDED__

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

namespace irr
{
namespace scene
{
        struct SSharedMeshBuffer : public IMeshBuffer
        {
                SSharedMeshBuffer() : IMeshBuffer(), Vertices(0), ChangedID_Vertex(1), ChangedID_Index(1), MappingHintVertex(EHM_NEVER), MappingHintIndex(EHM_NEVER)
                {
                        #ifdef _DEBUG
                        setDebugName("SSharedMeshBuffer");
                        #endif
                }

                SSharedMeshBuffer(core::array<video::S3DVertex> *vertices) : IMeshBuffer(), Vertices(vertices)
                {
                        #ifdef _DEBUG
                        setDebugName("SSharedMeshBuffer");
                        #endif
                }

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

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

                virtual const void* getVertices() const
                {
                        if (Vertices)
                                return Vertices->const_pointer();
                        else
                                return 0;
                }

                virtual void* getVertices()
                {
                        if (Vertices)
                                return Vertices->pointer();
                        else
                                return 0;
                }

                virtual u32 getVertexCount() const
                {
                        if (Vertices)
                                return Vertices->size();
                        else
                                return 0;
                }

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

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

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

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

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

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

                virtual video::E_VERTEX_TYPE getVertexType() const
                {
                        return video::EVT_STANDARD;
                }

                virtual void recalculateBoundingBox()
                {
                        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
                {
                        _IRR_DEBUG_BREAK_IF(!Vertices);
                        return (*Vertices)[Indices[i]].Pos;
                }

                virtual core::vector3df& getPosition(u32 i)
                {
                        _IRR_DEBUG_BREAK_IF(!Vertices);
                        return (*Vertices)[Indices[i]].Pos;
                }

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

                virtual core::vector3df& getNormal(u32 i)
                {
                        _IRR_DEBUG_BREAK_IF(!Vertices);
                        return (*Vertices)[Indices[i]].Normal;
                }

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

                virtual core::vector2df& getTCoords(u32 i)
                {
                        _IRR_DEBUG_BREAK_IF(!Vertices);
                        return (*Vertices)[Indices[i]].TCoords;
                }

                virtual void append(const void* const vertices, u32 numVertices, const u16* const indices, u32 numIndices) {}

                virtual void append(const IMeshBuffer* const other) {}

                virtual E_HARDWARE_MAPPING getHardwareMappingHint_Vertex() const
                {
                        return MappingHintVertex;
                }

                virtual E_HARDWARE_MAPPING getHardwareMappingHint_Index() const
                {
                        return MappingHintIndex;
                }

                virtual void setHardwareMappingHint( E_HARDWARE_MAPPING NewMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX )
                {
                        if (buffer==EBT_VERTEX_AND_INDEX || buffer==EBT_VERTEX)
                                MappingHintVertex=NewMappingHint;
                        if (buffer==EBT_VERTEX_AND_INDEX || buffer==EBT_INDEX)
                                MappingHintIndex=NewMappingHint;
                }

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


                virtual u32 getChangedID_Index() const {return ChangedID_Index;}

                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;
        };


} // end namespace scene
} // end namespace irr

#endif