SMesh.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 duckcpp/duckcpp.hpp
 
#ifndef S_MESH_HPP_INCLUDED
#define S_MESH_HPP_INCLUDED
 
#include <duckcpp/core/engine/IMesh.hpp>
#include <duckcpp/core/engine/IMeshBuffer.hpp>
#include <duckcpp/core/engine/aabbox3d.hpp>
#include <duckcpp/core/engine/irrArray.hpp>
 
namespace dcpp
{
namespace scene
{
    class SMesh : public IMesh
    {
    public:
        SMesh()
        {
            #ifdef _DEBUG
            setDebugName("SMesh");
            #endif
        }
 
    public:
        virtual ~SMesh()
        {
            // drop buffers
            for (dcpp::uint32_kt i=0; i<MeshBuffers.size(); ++i)
                MeshBuffers[i]->drop();
        }
 
    public:
        virtual void clear()
        {
            for (dcpp::uint32_kt i=0; i<MeshBuffers.size(); ++i)
                MeshBuffers[i]->drop();
            MeshBuffers.clear();
            BoundingBox.reset ( 0.f, 0.f, 0.f );
        }
 
 
        virtual dcpp::uint32_kt getMeshBufferCount() const override
        {
            return MeshBuffers.size();
        }
 
        virtual IMeshBuffer* getMeshBuffer(dcpp::uint32_kt nr) const override
        {
            return MeshBuffers[nr];
        }
 
 
        virtual IMeshBuffer* getMeshBuffer( const dcpp::video::SMaterial & material) const override
        {
            for (dcpp::int32_kt i = (dcpp::int32_kt)MeshBuffers.size()-1; i >= 0; --i)
            {
                if ( material == MeshBuffers[i]->getMaterial())
                    return MeshBuffers[i];
            }
 
            return 0;
        }
 
        virtual const dcpp::nub::aabbox3df& getBoundingBox() const override
        {
            return BoundingBox;
        }
 
        virtual void setBoundingBox( const dcpp::nub::aabbox3df& box) override
        {
            BoundingBox = box;
        }
 
        void recalculateBoundingBox()
        {
            bool hasMeshBufferBBox = false;
            for (dcpp::uint32_kt i=0; i<MeshBuffers.size(); ++i)
            {
                const dcpp::nub::aabbox3df& bb = MeshBuffers[i]->getBoundingBox();
                if ( !bb.isEmpty() )
                {
                    if ( !hasMeshBufferBBox )
                    {
                        hasMeshBufferBBox = true;
                        BoundingBox = bb;
                    }
                    else
                    {
                        BoundingBox.addInternalBox(bb);
                    }
 
                }
            }
 
            if ( !hasMeshBufferBBox )
                BoundingBox.reset(0.0f, 0.0f, 0.0f);
        }
 
 
        void addMeshBuffer(IMeshBuffer* buf)
        {
            if (buf)
            {
                buf->grab();
                MeshBuffers.push_back(buf);
            }
        }
 
        virtual void setMaterialFlag(dcpp::video::E_MATERIAL_FLAG flag, bool newvalue) override
        {
            for (dcpp::uint32_kt i=0; i<MeshBuffers.size(); ++i)
                MeshBuffers[i]->getMaterial().setFlag(flag, newvalue);
        }
 
        virtual void setHardwareMappingHint( E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX ) override
        {
            for (dcpp::uint32_kt i=0; i<MeshBuffers.size(); ++i)
                MeshBuffers[i]->setHardwareMappingHint(newMappingHint, buffer);
        }
 
        virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX) override
        {
            for (dcpp::uint32_kt i=0; i<MeshBuffers.size(); ++i)
                MeshBuffers[i]->setDirty(buffer);
        }
 
    public:
        dcpp::nub::array<IMeshBuffer*> MeshBuffers;
 
        dcpp::nub::aabbox3df BoundingBox;
    };
 
} // end namespace scene
} // end namespace dcpp
 
#endif