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