Refactor: Merge [IC]SkinnedMesh into SkinnedMesh (#15511)

irr/include/SkinnedMesh.h

@@ -0,0 +1,339 @@
+// 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
+
+#pragma once
+
+#include "IAnimatedMesh.h"
+#include "ISceneManager.h"
+#include "SMeshBuffer.h"
+#include "SSkinMeshBuffer.h"
+#include "quaternion.h"
+
+#include <optional>
+#include <string>
+
+namespace irr
+{
+namespace scene
+{
+
+enum E_INTERPOLATION_MODE
+{
+	// constant does use the current key-values without interpolation
+	EIM_CONSTANT = 0,
+
+	// linear interpolation
+	EIM_LINEAR,
+
+	//! count of all available interpolation modes
+	EIM_COUNT
+};
+
+class IAnimatedMeshSceneNode;
+class IBoneSceneNode;
+class ISceneManager;
+
+class SkinnedMesh : public IAnimatedMesh
+{
+public:
+	//! constructor
+	SkinnedMesh();
+
+	//! destructor
+	virtual ~SkinnedMesh();
+
+	//! If the duration is 0, it is a static (=non animated) mesh.
+	f32 getMaxFrameNumber() const override;
+
+	//! Gets the default animation speed of the animated mesh.
+	/** \return Amount of frames per second. If the amount is 0, it is a static, non animated mesh. */
+	f32 getAnimationSpeed() const override;
+
+	//! Gets the frame count of the animated mesh.
+	/** \param fps Frames per second to play the animation with. If the amount is 0, it is not animated.
+	The actual speed is set in the scene node the mesh is instantiated in.*/
+	void setAnimationSpeed(f32 fps) override;
+
+	//! returns the animated mesh for the given frame
+	IMesh *getMesh(f32) override;
+
+	//! Animates this mesh's joints based on frame input
+	//! blend: {0-old position, 1-New position}
+	void animateMesh(f32 frame, f32 blend);
+
+	//! Performs a software skin on this mesh based of joint positions
+	void skinMesh();
+
+	//! returns amount of mesh buffers.
+	u32 getMeshBufferCount() const override;
+
+	//! returns pointer to a mesh buffer
+	IMeshBuffer *getMeshBuffer(u32 nr) const override;
+
+	//! Returns pointer to a mesh buffer which fits a material
+	/** \param material: material to search for
+	\return Returns the pointer to the mesh buffer or
+	NULL if there is no such mesh buffer. */
+	IMeshBuffer *getMeshBuffer(const video::SMaterial &material) const override;
+
+	u32 getTextureSlot(u32 meshbufNr) const override;
+
+	void setTextureSlot(u32 meshbufNr, u32 textureSlot);
+
+	//! returns an axis aligned bounding box
+	const core::aabbox3d<f32> &getBoundingBox() const override;
+
+	//! set user axis aligned bounding box
+	void setBoundingBox(const core::aabbox3df &box) override;
+
+	//! set the hardware mapping hint, for driver
+	void setHardwareMappingHint(E_HARDWARE_MAPPING newMappingHint, E_BUFFER_TYPE buffer = EBT_VERTEX_AND_INDEX) override;
+
+	//! flags the meshbuffer as changed, reloads hardware buffers
+	void setDirty(E_BUFFER_TYPE buffer = EBT_VERTEX_AND_INDEX) override;
+
+	//! Returns the type of the animated mesh.
+	E_ANIMATED_MESH_TYPE getMeshType() const override;
+
+	//! Gets joint count.
+	u32 getJointCount() const;
+
+	//! Gets the name of a joint.
+	/** \param number: Zero based index of joint.
+	\return Name of joint and null if an error happened. */
+	const std::optional<std::string> &getJointName(u32 number) const;
+
+	//! Gets a joint number from its name
+	/** \param name: Name of the joint.
+	\return Number of the joint or std::nullopt if not found. */
+	std::optional<u32> getJointNumber(const std::string &name) const;
+
+	//! Update Normals when Animating
+	/** \param on If false don't animate, which is faster.
+	Else update normals, which allows for proper lighting of
+	animated meshes. */
+	void updateNormalsWhenAnimating(bool on);
+
+	//! Sets Interpolation Mode
+	void setInterpolationMode(E_INTERPOLATION_MODE mode);
+
+	//! converts the vertex type of all meshbuffers to tangents.
+	/** E.g. used for bump mapping. */
+	void convertMeshToTangents();
+
+	//! Does the mesh have no animation
+	bool isStatic() const;
+
+	//! Allows to enable hardware skinning.
+	/* This feature is not implemented in Irrlicht yet */
+	bool setHardwareSkinning(bool on);
+
+	//! Refreshes vertex data cached in joints such as positions and normals
+	void refreshJointCache();
+
+	//! Moves the mesh into static position.
+	void resetAnimation();
+
+	virtual void updateBoundingBox();
+
+	//! Recovers the joints from the mesh
+	void recoverJointsFromMesh(core::array<IBoneSceneNode *> &jointChildSceneNodes);
+
+	//! Transfers the joint data to the mesh
+	void transferJointsToMesh(const core::array<IBoneSceneNode *> &jointChildSceneNodes);
+
+	//! Transfers the joint hints to the mesh
+	void transferOnlyJointsHintsToMesh(const core::array<IBoneSceneNode *> &jointChildSceneNodes);
+
+	//! Creates an array of joints from this mesh as children of node
+	void addJoints(core::array<IBoneSceneNode *> &jointChildSceneNodes,
+			IAnimatedMeshSceneNode *node,
+			ISceneManager *smgr);
+
+	//! A vertex weight
+	struct SWeight
+	{
+		//! Index of the mesh buffer
+		u16 buffer_id; // I doubt 32bits is needed
+
+		//! Index of the vertex
+		u32 vertex_id; // Store global ID here
+
+		//! Weight Strength/Percentage (0-1)
+		f32 strength;
+
+	private:
+		//! Internal members used by SkinnedMesh
+		friend class SkinnedMesh;
+		char *Moved;
+		core::vector3df StaticPos;
+		core::vector3df StaticNormal;
+	};
+
+	//! Animation keyframe which describes a new position
+	struct SPositionKey
+	{
+		f32 frame;
+		core::vector3df position;
+	};
+
+	//! Animation keyframe which describes a new scale
+	struct SScaleKey
+	{
+		f32 frame;
+		core::vector3df scale;
+	};
+
+	//! Animation keyframe which describes a new rotation
+	struct SRotationKey
+	{
+		f32 frame;
+		core::quaternion rotation;
+	};
+
+	//! Joints
+	struct SJoint
+	{
+		SJoint() :
+				UseAnimationFrom(0), GlobalSkinningSpace(false),
+				positionHint(-1), scaleHint(-1), rotationHint(-1)
+		{
+		}
+
+		//! The name of this joint
+		std::optional<std::string> Name;
+
+		//! Local matrix of this joint
+		core::matrix4 LocalMatrix;
+
+		//! List of child joints
+		core::array<SJoint *> Children;
+
+		//! List of attached meshes
+		core::array<u32> AttachedMeshes;
+
+		//! Animation keys causing translation change
+		core::array<SPositionKey> PositionKeys;
+
+		//! Animation keys causing scale change
+		core::array<SScaleKey> ScaleKeys;
+
+		//! Animation keys causing rotation change
+		core::array<SRotationKey> RotationKeys;
+
+		//! Skin weights
+		core::array<SWeight> Weights;
+
+		//! Unnecessary for loaders, will be overwritten on finalize
+		core::matrix4 GlobalMatrix; // loaders may still choose to set this (temporarily) to calculate absolute vertex data.
+		core::matrix4 GlobalAnimatedMatrix;
+		core::matrix4 LocalAnimatedMatrix;
+
+		//! These should be set by loaders.
+		core::vector3df Animatedposition;
+		core::vector3df Animatedscale;
+		core::quaternion Animatedrotation;
+
+		// The .x and .gltf formats pre-calculate this
+		std::optional<core::matrix4> GlobalInversedMatrix;
+	private:
+		//! Internal members used by SkinnedMesh
+		friend class SkinnedMesh;
+
+		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
+
+	//! exposed for loaders to add mesh buffers
+	core::array<SSkinMeshBuffer *> &getMeshBuffers();
+
+	//! alternative method for adding joints
+	core::array<SJoint *> &getAllJoints();
+
+	//! alternative method for reading joints
+	const core::array<SJoint *> &getAllJoints() const;
+
+	//! loaders should call this after populating the mesh
+	void finalize();
+
+	//! Adds a new meshbuffer to the mesh, access it as last one
+	SSkinMeshBuffer *addMeshBuffer();
+
+	//! Adds a new meshbuffer to the mesh, access it as last one
+	void addMeshBuffer(SSkinMeshBuffer *meshbuf);
+
+	//! Adds a new joint to the mesh, access it as last one
+	SJoint *addJoint(SJoint *parent = 0);
+
+	//! Adds a new position key to the mesh, access it as last one
+	SPositionKey *addPositionKey(SJoint *joint);
+	//! Adds a new rotation key to the mesh, access it as last one
+	SRotationKey *addRotationKey(SJoint *joint);
+	//! Adds a new scale key to the mesh, access it as last one
+	SScaleKey *addScaleKey(SJoint *joint);
+
+	//! Adds a new weight to the mesh, access it as last one
+	SWeight *addWeight(SJoint *joint);
+
+private:
+	void checkForAnimation();
+
+	void normalizeWeights();
+
+	void buildAllLocalAnimatedMatrices();
+
+	void buildAllGlobalAnimatedMatrices(SJoint *Joint = 0, SJoint *ParentJoint = 0);
+
+	void getFrameData(f32 frame, SJoint *Node,
+			core::vector3df &position, s32 &positionHint,
+			core::vector3df &scale, s32 &scaleHint,
+			core::quaternion &rotation, s32 &rotationHint);
+
+	void calculateGlobalMatrices(SJoint *Joint, SJoint *ParentJoint);
+
+	void skinJoint(SJoint *Joint, SJoint *ParentJoint);
+
+	void calculateTangents(core::vector3df &normal,
+			core::vector3df &tangent, core::vector3df &binormal,
+			const core::vector3df &vt1, const core::vector3df &vt2, const core::vector3df &vt3,
+			const core::vector2df &tc1, const core::vector2df &tc2, const core::vector2df &tc3);
+
+	core::array<SSkinMeshBuffer *> *SkinningBuffers; // Meshbuffer to skin, default is to skin localBuffers
+
+	core::array<SSkinMeshBuffer *> LocalBuffers;
+	//! Mapping from meshbuffer number to bindable texture slot
+	std::vector<u32> TextureSlots;
+
+	core::array<SJoint *> AllJoints;
+	core::array<SJoint *> RootJoints;
+
+	// bool can't be used here because std::vector<bool>
+	// doesn't allow taking a reference to individual elements.
+	core::array<core::array<char>> Vertices_Moved;
+
+	core::aabbox3d<f32> BoundingBox;
+
+	f32 EndFrame;
+	f32 FramesPerSecond;
+
+	f32 LastAnimatedFrame;
+	bool SkinnedLastFrame;
+
+	E_INTERPOLATION_MODE InterpolationMode : 8;
+
+	bool HasAnimation;
+	bool PreparedForSkinning;
+	bool AnimateNormals;
+	bool HardwareSkinning;
+};
+
+} // end namespace scene
+} // end namespace irr