ISkinnedMesh.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 NIRT_I_SKINNED_MESH_HPP_INCLUDED
#define NIRT_I_SKINNED_MESH_HPP_INCLUDED
 
#include <nirtcpp/core/engine/irrArray.hpp>
#include <nirtcpp/core/engine/IBoneSceneNode.hpp>
#include <nirtcpp/core/engine/IAnimatedMesh.hpp>
#include <nirtcpp/core/engine/SSkinMeshBuffer.hpp>
 
namespace nirt
{
namespace scene
{
 
    enum E_INTERPOLATION_MODE
    {
        // constant does use the current key-values without interpolation
        EIM_CONSTANT = 0,
 
        // linear interpolation
        EIM_LINEAR,
 
        EIM_COUNT
    };
 
 
    class ISkinnedMesh : public IAnimatedMesh
    {
    public:
 
 
        virtual u32 getJointCount() const = 0;
 
 
        virtual const c8* getJointName(u32 number) const = 0;
 
 
        virtual s32 getJointNumber(const c8* name) const = 0;
 
 
        virtual bool useAnimationFrom(const ISkinnedMesh *mesh) = 0;
 
 
        virtual void updateNormalsWhenAnimating(bool on) = 0;
 
        virtual void setInterpolationMode(E_INTERPOLATION_MODE mode) = 0;
 
        virtual void animateMesh(f32 frame, f32 blend)=0;
 
        virtual void skinMesh() = 0;
 
 
        virtual void convertMeshToTangents() = 0;
 
        /* This feature is not implemented in Nirtcpp yet */
        virtual bool setHardwareSkinning(bool on) = 0;
 
        class SWeight
        {
        public:
            u16 buffer_id; //I doubt 32bits is needed
 
            u32 vertex_id; //Store global ID here
 
            f32 strength;
 
        private:
            friend class CSkinnedMesh;
            bool *Moved;
            core::vector3df StaticPos;
            core::vector3df StaticNormal;
        };
 
 
        class SPositionKey
        {
        public:
            f32 frame;
            core::vector3df position;
        };
 
        class SScaleKey
        {
        public:
            f32 frame;
            core::vector3df scale;
        };
 
        class SRotationKey
        {
        public:
            f32 frame;
            core::quaternion rotation;
        };
 
        class SJoint
        {
        public:
            SJoint() : UseAnimationFrom(0), GlobalSkinningSpace(false),
                positionHint(-1),scaleHint(-1),rotationHint(-1)
            {
            }
 
        public:
            core::stringc Name;
 
            core::matrix4 LocalMatrix;
 
            core::array<SJoint*> Children;
 
            core::array<u32> AttachedMeshes;
 
            core::array<SPositionKey> PositionKeys;
 
            core::array<SScaleKey> ScaleKeys;
 
            core::array<SRotationKey> RotationKeys;
 
            core::array<SWeight> Weights;
 
            core::matrix4 GlobalMatrix;
            core::matrix4 GlobalAnimatedMatrix;
            core::matrix4 LocalAnimatedMatrix;
            core::vector3df Animatedposition;
            core::vector3df Animatedscale;
            core::quaternion Animatedrotation;
 
            core::matrix4 GlobalInversedMatrix; //the x format pre-calculates this
 
        private:
            friend class CSkinnedMesh;
 
            SJoint *UseAnimationFrom;
            bool GlobalSkinningSpace;
 
            s32 positionHint;
            s32 scaleHint;
            s32 rotationHint;
        };
 
 
        //Interface for the mesh loaders (finalize should lock these functions, and they should have some prefix like loader_
 
        //these functions will use the needed arrays, set values, etc to help the loaders
 
        virtual core::array<SSkinMeshBuffer*>& getMeshBuffers() = 0;
 
        virtual core::array<SJoint*>& getAllJoints() = 0;
 
        virtual const core::array<SJoint*>& getAllJoints() const = 0;
 
        virtual void finalize() = 0;
 
        virtual SSkinMeshBuffer* addMeshBuffer() = 0;
 
        virtual SJoint* addJoint(SJoint *parent=0) = 0;
 
        virtual SWeight* addWeight(SJoint *joint) = 0;
 
        virtual SPositionKey* addPositionKey(SJoint *joint) = 0;
        virtual SScaleKey* addScaleKey(SJoint *joint) = 0;
        virtual SRotationKey* addRotationKey(SJoint *joint) = 0;
 
        virtual bool isStatic()=0;
    };
 
} // end namespace scene
} // end namespace nirt
 
#endif