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 implemented 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;

                virtual void setSkinnedLastFrame(bool lastframe) = 0;
                virtual void setLastAnimatedFrame(f32 frame) = 0;
                virtual bool isSkinnedLastFrame() const = 0;
                virtual f32  getLastAnimatedFrame() const = 0;

        };

} // end namespace scene
} // end namespace irr

#endif