Refactor skinned mesh weight data structure

in preparation for GPU-based skinning

Author: appgurueu

irr/include/SSkinMeshBuffer.h

@@ -7,12 +7,153 @@
 #include "IMeshBuffer.h"
 #include "CVertexBuffer.h"
 #include "CIndexBuffer.h"
+#include "IVertexBuffer.h"
 #include "S3DVertex.h"
+#include "vector3d.h"
+#include <algorithm>
 #include <cassert>
+#include <memory>
+#include <numeric>
+#include <optional>
 
 namespace scene
 {
 
+struct WeightBuffer
+{
+	constexpr static u16 MAX_WEIGHTS_PER_VERTEX = 4;
+	size_t n_verts;
+	std::unique_ptr<u16[]> joint_idxs;
+	std::unique_ptr<f32[]> weights;
+
+	std::optional<std::vector<u32>> animated_vertices;
+
+	// A bit of a hack for now: Store static positions here so we can use them for skinning.
+	// Ideally we might want a design where we do not mutate the original vertex buffer at all.
+	std::unique_ptr<core::vector3df[]> static_positions;
+	std::unique_ptr<core::vector3df[]> static_normals;
+
+	WeightBuffer(size_t n_verts) :
+		n_verts(n_verts),
+		joint_idxs(std::make_unique<u16[]>(MAX_WEIGHTS_PER_VERTEX * n_verts)),
+		weights(std::make_unique<f32[]>(MAX_WEIGHTS_PER_VERTEX * n_verts))
+	{}
+
+	u16 *getJointIndices(u32 vertex_id)
+	{ return &joint_idxs[vertex_id * MAX_WEIGHTS_PER_VERTEX]; }
+	const u16 *getJointIndices(u32 vertex_id) const
+	{ return &joint_idxs[vertex_id * MAX_WEIGHTS_PER_VERTEX]; }
+
+	f32 *getWeights(u32 vertex_id)
+	{ return &weights[vertex_id * MAX_WEIGHTS_PER_VERTEX]; }
+	const f32 *getWeights(u32 vertex_id) const
+	{ return &weights[vertex_id * MAX_WEIGHTS_PER_VERTEX]; }
+
+	void addWeight(u32 vertex_id, u16 joint_id, f32 weight)
+	{
+		assert(vertex_id < n_verts);
+		assert(weight >= 0.f);
+		f32 *weights = getWeights(vertex_id);
+		f32 *min_weight = std::min_element(weights, weights + MAX_WEIGHTS_PER_VERTEX);
+		if (*min_weight > weight)
+			return;
+
+		*min_weight = weight;
+		getJointIndices(vertex_id)[min_weight - weights] = joint_id;
+	}
+
+	void skinVertex(u32 vertex_id, core::vector3df &pos, core::vector3df &normal,
+			const std::vector<core::matrix4> &joint_transforms) const
+	{
+		const u16 *joint_idxs = getJointIndices(vertex_id);
+		const f32 *weights = getWeights(vertex_id);
+		f32 total_weight = 0.f;
+		core::vector3df skinned_pos;
+		core::vector3df skinned_normal;
+		for (u16 i = 0; i < MAX_WEIGHTS_PER_VERTEX; ++i) {
+			u16 joint_id = joint_idxs[i];
+			f32 weight = weights[i];
+			if (weight <= 0.f)
+				continue;
+
+			const auto &transform = joint_transforms[joint_id];
+			core::vector3df transformed_pos = pos;
+			transform.transformVect(transformed_pos);
+			skinned_pos += weight * transformed_pos;
+			skinned_normal += weight * transform.rotateAndScaleVect(normal);
+			total_weight += weight;
+		}
+		if (core::equals(total_weight, 0.f))
+			return;
+
+		pos = skinned_pos;
+		// Need to renormalize normal after potentially scaling
+		normal = skinned_normal.normalize();
+	}
+
+	/// @note src and dst can be the same buffer
+	void skin(IVertexBuffer *dst,
+			const std::vector<core::matrix4> &joint_transforms) const
+	{
+		assert(animated_vertices.has_value());
+		for (u32 i = 0; i < animated_vertices->size(); ++i) {
+
+			u32 vertex_id = (*animated_vertices)[i];
+			auto pos = static_positions[i];
+			auto normal = static_normals[i];
+			skinVertex(vertex_id, pos, normal, joint_transforms);
+			dst->getPosition(vertex_id) = pos;
+			dst->getNormal(vertex_id) = normal;
+		}
+		if (!animated_vertices->empty())
+			dst->setDirty();
+	}
+
+	/// Normalizes weights so that they sum to 1.0 per vertex,
+	/// stores which vertices are animated.
+	void finalize() {
+		assert(!animated_vertices.has_value());
+		animated_vertices.emplace();
+		for (u32 i = 0; i < n_verts; ++i) {
+			auto *weights_i = getWeights(i);
+			f32 total_weight = std::accumulate(weights_i, weights_i + MAX_WEIGHTS_PER_VERTEX, 0.0f);
+			if (core::equals(total_weight, 0.0f)) {
+				std::fill(weights_i, weights_i + MAX_WEIGHTS_PER_VERTEX, 0.0f);
+				continue;
+			}
+			animated_vertices->emplace_back(i);
+			if (core::equals(total_weight, 1.0f))
+				continue;
+			for (u16 j = 0; j < MAX_WEIGHTS_PER_VERTEX; ++j)
+				weights_i[j] /= total_weight;
+		}
+		animated_vertices->shrink_to_fit();
+	}
+
+	void updateStaticPose(const IVertexBuffer *vbuf)
+	{
+		static_normals = std::make_unique<core::vector3df[]>(animated_vertices->size());
+		static_positions = std::make_unique<core::vector3df[]>(animated_vertices->size());
+		for (size_t idx = 0; idx < animated_vertices->size(); ++idx) {
+			u32 vertex_id = (*animated_vertices)[idx];
+			static_positions[idx] = vbuf->getPosition(vertex_id);
+			static_normals[idx] = vbuf->getNormal(vertex_id);
+		}
+	}
+
+	void resetToStatic(IVertexBuffer *vbuf) const
+	{
+		assert(animated_vertices.has_value());
+		for (size_t idx = 0; idx < animated_vertices->size(); ++idx) {
+			u32 vertex_id = (*animated_vertices)[idx];
+			vbuf->getPosition(vertex_id) = static_positions[idx];
+			vbuf->getNormal(vertex_id) = static_normals[idx];
+		}
+		if (!animated_vertices->empty())
+			vbuf->setDirty();
+	}
+};
+
 //! A mesh buffer able to choose between S3DVertex2TCoords, S3DVertex and S3DVertexTangents at runtime
 struct SSkinMeshBuffer final : public IMeshBuffer
 {
@@ -222,6 +363,8 @@ struct SSkinMeshBuffer final : public IMeshBuffer
 	SVertexBuffer *Vertices_Standard;
 	SIndexBuffer *Indices;
 
+	std::optional<WeightBuffer> Weights;
+
 	core::matrix4 Transformation;
 
 	video::SMaterial Material;

irr/include/SkinnedMesh.h

@@ -43,7 +43,6 @@ class SkinnedMesh : public IAnimatedMesh
 	SkinnedMesh(SourceFormat src_format) :
 		EndFrame(0.f), FramesPerSecond(25.f),
 		HasAnimation(false), PreparedForSkinning(false),
-		AnimateNormals(true),
 		SrcFormat(src_format)
 	{
 		SkinningBuffers = &LocalBuffers;
@@ -126,14 +125,6 @@ class SkinnedMesh : public IAnimatedMesh
 	\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 (default). */
-	void updateNormalsWhenAnimating(bool on) {
-		AnimateNormals = on;
-	}
-
 	//! converts the vertex type of all meshbuffers to tangents.
 	/** E.g. used for bump mapping. */
 	void convertMeshToTangents();
@@ -143,8 +134,8 @@ class SkinnedMesh : public IAnimatedMesh
 		return !HasAnimation;
 	}
 
-	//! Refreshes vertex data cached in joints such as positions and normals
-	void refreshJointCache();
+	//! Back up static pose after local buffers have been modified directly
+	void updateStaticPose();
 
 	//! Moves the mesh into static position.
 	void resetAnimation();
@@ -153,26 +144,6 @@ class SkinnedMesh : public IAnimatedMesh
 	std::vector<IBoneSceneNode *> addJoints(
 			AnimatedMeshSceneNode *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;
-	};
-
 	template <class T>
 	struct Channel {
 		struct Frame {
@@ -329,13 +300,11 @@ class SkinnedMesh : public IAnimatedMesh
 
 		//! List of attached meshes
 		std::vector<u32> AttachedMeshes;
+		// TODO ^ should turn this into optional meshbuffer parent field?
 
 		// Animation keyframes for translation, rotation, scale
 		Keys keys;
 
-		//! Skin weights
-		std::vector<SWeight> Weights;
-
 		//! Bounding box of all affected vertices, in local space
 		core::aabbox3df LocalBoundingBox{{0, 0, 0}};
 
@@ -369,16 +338,12 @@ class SkinnedMesh : public IAnimatedMesh
 protected:
 	bool checkForAnimation() const;
 
-	void topoSortJoints();
-
 	void prepareForSkinning();
 
 	void calculateStaticBoundingBox();
 	void calculateJointBoundingBoxes();
 	void calculateBufferBoundingBoxes();
 
-	void normalizeWeights();
-
 	void calculateTangents(core::vector3df &normal,
 			core::vector3df &tangent, core::vector3df &binormal,
 			const core::vector3df &vt1, const core::vector3df &vt2, const core::vector3df &vt3,
@@ -387,16 +352,13 @@ class SkinnedMesh : public IAnimatedMesh
 	std::vector<SSkinMeshBuffer *> *SkinningBuffers; // Meshbuffer to skin, default is to skin localBuffers
 
 	std::vector<SSkinMeshBuffer *> LocalBuffers;
+
 	//! Mapping from meshbuffer number to bindable texture slot
 	std::vector<u32> TextureSlots;
 
 	//! Joints, topologically sorted (parents come before their children).
 	std::vector<SJoint *> AllJoints;
 
-	// bool can't be used here because std::vector<bool>
-	// doesn't allow taking a reference to individual elements.
-	std::vector<std::vector<char>> Vertices_Moved;
-
 	//! Bounding box of just the static parts of the mesh
 	core::aabbox3df StaticPartsBox{{0, 0, 0}};
 
@@ -408,7 +370,6 @@ class SkinnedMesh : public IAnimatedMesh
 
 	bool HasAnimation;
 	bool PreparedForSkinning;
-	bool AnimateNormals;
 
 	SourceFormat SrcFormat;
 };
@@ -440,8 +401,22 @@ class SkinnedMeshBuilder : public SkinnedMesh {
 	void addRotationKey(SJoint *joint, f32 frame, core::quaternion rotation);
 	void addScaleKey(SJoint *joint, f32 frame, core::vector3df scale);
 
-	//! Adds a new weight to the mesh, access it as last one
-	SWeight *addWeight(SJoint *joint);
+	//! Adds a new weight to the mesh
+	void addWeight(SJoint *joint, u16 buf, u32 vert_id, f32 strength);
+
+private:
+
+	void topoSortJoints();
+
+	struct Weight {
+		u16 joint_id;
+		u16 buffer_id;
+		u32 vertex_id;
+		f32 strength;
+	};
+
+	std::vector<Weight> Weights;
+
 };
 
 } // end namespace scene

irr/src/CB3DMeshFileLoader.cpp

@@ -541,11 +541,10 @@ bool CB3DMeshFileLoader::readChunkBONE(SkinnedMesh::SJoint *inJoint)
 			if (AnimatedVertices_VertexID[globalVertexID] == -1) {
 				os::Printer::log("B3dMeshLoader: Weight has bad vertex id (no link to meshbuffer index found)");
 			} else if (strength > 0) {
-				SkinnedMesh::SWeight *weight = AnimatedMesh->addWeight(inJoint);
-				weight->strength = strength;
-				// Find the meshbuffer and Vertex index from the Global Vertex ID:
-				weight->vertex_id = AnimatedVertices_VertexID[globalVertexID];
-				weight->buffer_id = AnimatedVertices_BufferID[globalVertexID];
+				AnimatedMesh->addWeight(inJoint,
+						AnimatedVertices_BufferID[globalVertexID],
+						AnimatedVertices_VertexID[globalVertexID],
+						strength);
 			}
 		}
 	}

irr/src/CGLTFMeshFileLoader.cpp

@@ -501,10 +501,8 @@ void SelfType::MeshExtractor::addPrimitive(
 				if (strength <= 0)
 					continue; // note: also ignores negative weights
 
-				SkinnedMesh::SWeight *weight = m_irr_model->addWeight(m_loaded_nodes.at(skin.joints.at(jointIdx)));
-				weight->buffer_id = meshbufNr;
-				weight->vertex_id = v;
-				weight->strength = strength;
+				m_irr_model->addWeight(m_loaded_nodes.at(skin.joints.at(jointIdx)),
+						meshbufNr, v, strength);
 			}
 		}
 		if (negative_weights)

irr/src/CMeshManipulator.cpp

@@ -110,7 +110,7 @@ void CMeshManipulator::recalculateNormals(scene::IMesh *mesh, bool smooth, bool
 
 	if (mesh->getMeshType() == EAMT_SKINNED) {
 		auto *smesh = (SkinnedMesh *)mesh;
-		smesh->refreshJointCache();
+		smesh->updateStaticPose();
 	}
 }