Transpose: Use vector of structs

instead of struct of unique pointers

Author: appgurueu

irr/include/WeightBuffer.h

@@ -18,9 +18,15 @@ 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;
+	// ID-weight pairs for a joint
+	struct VertexWeights {
+		std::array<u16, MAX_WEIGHTS_PER_VERTEX> joint_ids = {};
+		std::array<f32, MAX_WEIGHTS_PER_VERTEX> strengths = {};
+		void addWeight(u16 joint_id, f32 weight);
+		void skinVertex(core::vector3df &pos, core::vector3df &normal,
+				const std::vector<core::matrix4> &joint_transforms) const;
+	};
+	std::vector<VertexWeights> weights;
 
 	std::optional<std::vector<u32>> animated_vertices;
 
@@ -29,17 +35,16 @@ struct WeightBuffer
 	std::unique_ptr<core::vector3df[]> static_positions;
 	std::unique_ptr<core::vector3df[]> static_normals;
 
-	WeightBuffer(size_t n_verts);
+	WeightBuffer(size_t n_verts) : weights(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]; }
+	const std::array<u16, MAX_WEIGHTS_PER_VERTEX> &getJointIds(u32 vertex_id) const
+	{ return weights[vertex_id].joint_ids; }
 
-	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]; }
+	const std::array<f32, MAX_WEIGHTS_PER_VERTEX> &getWeights(u32 vertex_id) const
+	{ return weights[vertex_id].strengths; }
+
+	size_t size() const
+	{ return weights.size(); }
 
 	void addWeight(u32 vertex_id, u16 joint_id, f32 weight);
 
@@ -50,8 +55,7 @@ struct WeightBuffer
 	void skin(IVertexBuffer *dst,
 			const std::vector<core::matrix4> &joint_transforms) const;
 
-	/// Normalizes weights so that they sum to 1.0 per vertex,
-	/// stores which vertices are animated.
+	/// Prepares this buffer for use in skinning.
 	void finalize();
 
 	void updateStaticPose(const IVertexBuffer *vbuf);

irr/src/SkinnedMesh.cpp

@@ -292,7 +292,7 @@ void SkinnedMesh::calculateJointBoundingBoxes()
 			continue;
 		for (u32 vert_id : weights->animated_vertices.value()) {
 			for (u16 j = 0; j < WeightBuffer::MAX_WEIGHTS_PER_VERTEX; j++) {
-				const auto joint_id = weights->getJointIndices(vert_id)[j];
+				const auto joint_id = weights->getJointIds(vert_id)[j];
 				const auto *joint = AllJoints[joint_id];
 				const auto strength = weights->getWeights(vert_id)[j];
 				if (strength < 1e-6)
@@ -411,7 +411,7 @@ SkinnedMesh *SkinnedMeshBuilder::finalize() &&
 		auto *buf = mesh->LocalBuffers.at(weight.buffer_id);
 		if (!buf->Weights)
 			buf->Weights = WeightBuffer(buf->getVertexCount());
-		if (weight.vertex_id >= buf->Weights->n_verts) {
+		if (weight.vertex_id >= buf->Weights->size()) {
 			throw std::out_of_range("vertex id out of range");
 		}
 		buf->Weights->addWeight(weight.vertex_id, weight.joint_id, weight.strength);

irr/src/WeightBuffer.cpp

@@ -5,38 +5,31 @@
 
 namespace scene {
 
-WeightBuffer::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))
-{}
-
-void WeightBuffer::addWeight(u32 vertex_id, u16 joint_id, f32 weight)
+void WeightBuffer::VertexWeights::addWeight(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);
+	assert(weight >= 0.0f);
+	auto min_weight = std::min_element(strengths.begin(), strengths.end());
 	if (*min_weight > weight)
 		return;
 
 	*min_weight = weight;
-	getJointIndices(vertex_id)[min_weight - weights] = joint_id;
+	joint_ids[std::distance(strengths.begin(), min_weight)] = joint_id;
 }
 
-void WeightBuffer::skinVertex(u32 vertex_id, core::vector3df &pos, core::vector3df &normal,
+void WeightBuffer::addWeight(u32 vertex_id, u16 joint_id, f32 weight)
+{
+	weights[vertex_id].addWeight(joint_id, weight);
+}
+
+void WeightBuffer::VertexWeights::skinVertex(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;
+	f32 total_weight = 0.0f;
 	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;
+		u16 joint_id = joint_ids[i];
+		f32 weight = strengths[i];
 
 		const auto &transform = joint_transforms[joint_id];
 		core::vector3df transformed_pos = pos;
@@ -45,15 +38,20 @@ void WeightBuffer::skinVertex(u32 vertex_id, core::vector3df &pos, core::vector3
 		skinned_normal += weight * transform.rotateAndScaleVect(normal);
 		total_weight += weight;
 	}
-	if (core::equals(total_weight, 0.f))
+	if (core::equals(total_weight, 0.0f))
 		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 WeightBuffer::skinVertex(u32 vertex_id, core::vector3df &pos, core::vector3df &normal,
+		const std::vector<core::matrix4> &joint_transforms) const
+{
+	return weights[vertex_id].skinVertex(pos, normal, joint_transforms);
+}
+
 void WeightBuffer::skin(IVertexBuffer *dst,
 		const std::vector<core::matrix4> &joint_transforms) const
 {
@@ -71,24 +69,24 @@ void WeightBuffer::skin(IVertexBuffer *dst,
 		dst->setDirty();
 }
 
-/// Normalizes weights so that they sum to 1.0 per vertex,
-/// stores which vertices are animated.
 void WeightBuffer::finalize()
 {
+	// Normalizes weights so that they sum to 1.0 per vertex,
+	// stores which vertices are animated.
 	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);
+	for (u32 i = 0; i < size(); ++i) {
+		auto &strengths = weights[i].strengths;
+		f32 total_weight = std::accumulate(strengths.begin(), strengths.end(), 0.0f);
 		if (core::equals(total_weight, 0.0f)) {
-			std::fill(weights_i, weights_i + MAX_WEIGHTS_PER_VERTEX, 0.0f);
+			std::fill(strengths.begin(), strengths.end(), 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;
+		for (auto &strength : strengths)
+			strength /= total_weight;
 	}
 	animated_vertices->shrink_to_fit();
 }

src/unittest/test_irr_gltf_mesh_loader.cpp

@@ -438,12 +438,11 @@ SECTION("simple skin")
 		REQUIRE(buf->Weights.has_value());
 		std::vector<f32> weights(buf->getVertexCount(), 0.0f);
 		for (size_t i = 0; i < buf->getVertexCount(); ++i) {
-			const auto *joint_ids = buf->Weights->getJointIndices(i);
-			const auto *joint_ids_end = joint_ids + scene::WeightBuffer::MAX_WEIGHTS_PER_VERTEX;
-			auto *it = std::find(joint_ids, joint_ids_end, joint->JointID);
-			if (it == joint_ids_end)
+			const auto &joint_ids = buf->Weights->getJointIds(i);
+			const auto it = std::find(joint_ids.begin(), joint_ids.end(), joint->JointID);
+			if (it == joint_ids.end())
 				continue;
-			weights[i] = buf->Weights->getWeights(i)[it - joint_ids];
+			weights[i] = buf->Weights->getWeights(i)[std::distance(joint_ids.begin(), it)];
 		}
 		return weights;
 	};