ISkinnedMesh.h

Go to the documentation of this file.

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

#ifndef __I_SKINNED_MESH_H_INCLUDED__
#define __I_SKINNED_MESH_H_INCLUDED__

#include "irrArray.h"
#include "IBoneSceneNode.h"
#include "IAnimatedMesh.h"
#include "SSkinMeshBuffer.h"

namespace irr
{
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 implementated in Irrlicht yet */
        virtual bool setHardwareSkinning(bool on) = 0;

        struct SWeight
        {
            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;
        };


        struct SPositionKey
        {
            f32 frame;
            core::vector3df position;
        };

        struct SScaleKey
        {
            f32 frame;
            core::vector3df scale;
        };

        struct SRotationKey
        {
            f32 frame;
            core::quaternion rotation;
        };

        struct SJoint
        {
            SJoint() : UseAnimationFrom(0), GlobalSkinningSpace(false),
                positionHint(-1),scaleHint(-1),rotationHint(-1)
            {
            }

            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 irr

#endif