SAnimatedMesh.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_ANIMATED_MESH_HPP_INCLUDED
#define S_ANIMATED_MESH_HPP_INCLUDED
 
#include <duckcpp/core/engine/IAnimatedMesh.hpp>
#include <duckcpp/core/engine/IMesh.hpp>
#include <duckcpp/core/engine/aabbox3d.hpp>
#include <duckcpp/core/engine/irrArray.hpp>
 
namespace dcpp
{
namespace scene
{
 
    class SAnimatedMesh : public IAnimatedMesh
    {
    public:
        SAnimatedMesh(dcpp::scene::IMesh* mesh=0, dcpp::scene::E_ANIMATED_MESH_TYPE type=dcpp::scene::EAMT_UNKNOWN) : IAnimatedMesh(), FramesPerSecond(25.f), Type(type)
        {
            #ifdef _DEBUG
            setDebugName("SAnimatedMesh");
            #endif
            addMesh(mesh);
            recalculateBoundingBox();
        }
 
    public:
        virtual ~SAnimatedMesh()
        {
            // drop meshes
            for (dcpp::uint32_kt i=0; i<Meshes.size(); ++i)
                Meshes[i]->drop();
        }
 
    public:
 
        virtual dcpp::uint32_kt getFrameCount() const override
        {
            return Meshes.size();
        }
 
 
        virtual dcpp::float32_kt getAnimationSpeed() const override
        {
            return FramesPerSecond;
        }
 
 
        virtual void setAnimationSpeed(dcpp::float32_kt fps) override
        {
            FramesPerSecond=fps;
        }
 
 
        virtual IMesh* getMesh(dcpp::int32_kt frame, dcpp::int32_kt detailLevel=255, dcpp::int32_kt startFrameLoop=-1, dcpp::int32_kt endFrameLoop=-1) override
        {
            if (Meshes.empty())
                return 0;
 
            return Meshes[frame];
        }
 
        void addMesh(IMesh* mesh)
        {
            if (mesh)
            {
                mesh->grab();
                Meshes.push_back(mesh);
            }
        }
 
 
        virtual const dcpp::nub::aabbox3df& getBoundingBox() const override
        {
            return Box;
        }
 
        virtual void setBoundingBox(const dcpp::nub::aabbox3df& box) override
        {
            Box = box;
        }
 
        void recalculateBoundingBox()
        {
            Box.reset(0,0,0);
 
            if (Meshes.empty())
                return;
 
            Box = Meshes[0]->getBoundingBox();
 
            for (dcpp::uint32_kt i=1; i<Meshes.size(); ++i)
                Box.addInternalBox(Meshes[i]->getBoundingBox());
        }
 
        virtual E_ANIMATED_MESH_TYPE getMeshType() const override
        {
            return Type;
        }
 
        virtual dcpp::uint32_kt getMeshBufferCount() const override
        {
            if (Meshes.empty())
                return 0;
 
            return Meshes[0]->getMeshBufferCount();
        }
 
        virtual IMeshBuffer* getMeshBuffer(dcpp::uint32_kt nr) const override
        {
            if (Meshes.empty())
                return 0;
 
            return Meshes[0]->getMeshBuffer(nr);
        }
 
 
        virtual IMeshBuffer* getMeshBuffer( const dcpp::video::SMaterial &material) const override
        {
            if (Meshes.empty())
                return 0;
 
            return Meshes[0]->getMeshBuffer(material);
        }
 
        virtual void setMaterialFlag(dcpp::video::E_MATERIAL_FLAG flag, bool newvalue) override
        {
            for (dcpp::uint32_kt i=0; i<Meshes.size(); ++i)
                Meshes[i]->setMaterialFlag(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<Meshes.size(); ++i)
                Meshes[i]->setHardwareMappingHint(newMappingHint, buffer);
        }
 
        virtual void setDirty(E_BUFFER_TYPE buffer=EBT_VERTEX_AND_INDEX) override
        {
            for (dcpp::uint32_kt i=0; i<Meshes.size(); ++i)
                Meshes[i]->setDirty(buffer);
        }
 
    public:
        dcpp::nub::array<IMesh*> Meshes;
 
        dcpp::nub::aabbox3df Box;
 
        dcpp::float32_kt FramesPerSecond;
 
        E_ANIMATED_MESH_TYPE Type;
    };
 
 
} // end namespace scene
} // end namespace dcpp
 
#endif