Fall back to SW skinning

appgurueu · appgurueu · commit b43befc7acd2 · 2025-12-06T17:48:51.000+01:00
fixme seems to cause a segfault in opengl driver? (if that isn't an earlier regression...)
diff --git a/irr/include/AnimatedMeshSceneNode.h b/irr/include/AnimatedMeshSceneNode.h
@@ -157,8 +157,6 @@ class AnimatedMeshSceneNode : public ISceneNode
 	void setRenderFromIdentity(bool On);
 
 private:
-	//! Get a static mesh for the current frame of this animated mesh
-	IMesh *getMeshForCurrentFrame();
 
 	void buildFrameNr(u32 timeMs);
 	void checkJoints();
diff --git a/irr/include/CVertexBuffer.h b/irr/include/CVertexBuffer.h
@@ -6,6 +6,7 @@
 
 #include <memory>
 #include <vector>
+#include "EHardwareBufferFlags.h"
 #include "IVertexBuffer.h"
 #include "WeightBuffer.h"
 #include "irr_ptr.h"
@@ -77,14 +78,24 @@ struct CVertexBuffer final : public IVertexBuffer
 
 	const WeightBuffer *getWeightBuffer() const override
 	{
-		return Weights.get();
+		return UseSwSkinning ? nullptr : Weights.get();
+	}
+
+	void useSwSkinning() override
+	{
+		if (!Weights || UseSwSkinning)
+			return;
+		UseSwSkinning = true;
+		MappingHint = EHM_STREAM;
+		Weights->updateStaticPose(this);
 	}
 
 	//! Vertices of this buffer
 	std::vector<T> Data;
 
 	//! Optional weights for skinning
 	irr_ptr<WeightBuffer> Weights;
+	bool UseSwSkinning = false;
 };
 
 //! Standard buffer
diff --git a/irr/include/IAnimatedMesh.h b/irr/include/IAnimatedMesh.h
@@ -19,6 +19,8 @@ class IAnimatedMesh : public IMesh
 	//! Gets the maximum frame number, 0 if the mesh is static.
 	virtual f32 getMaxFrameNumber() const = 0;
 
+	virtual void prepareForAnimation(u16 max_hw_joints) = 0;
+
 	//! Returns the type of the animated mesh. Useful for safe downcasts.
 	E_ANIMATED_MESH_TYPE getMeshType() const = 0;
 };
diff --git a/irr/include/IVertexBuffer.h b/irr/include/IVertexBuffer.h
@@ -50,8 +50,10 @@ class IVertexBuffer : public virtual IReferenceCounted, public HWBuffer
 	//! returns texture coord of vertex i
 	virtual core::vector2df &getTCoords(u32 i) = 0;
 
-	//! Get weight buffer associated with this vertex buffer, if any
+	//! Get weight buffer for upload to the GPU, if any
 	virtual const WeightBuffer *getWeightBuffer() const = 0;
+	//! Enable software skinning
+	virtual void useSwSkinning() = 0;
 };
 
 } // end namespace scene
diff --git a/irr/include/SMesh.h b/irr/include/SMesh.h
@@ -137,7 +137,8 @@ struct SMesh final : public IAnimatedMesh
 	// Slightly hacky: Eventually should be consolidated with SSkinnedMesh,
 	// with all the animation-related parts behind an optional.
 
-	virtual f32 getMaxFrameNumber() const override { return 0.0f; }
+	f32 getMaxFrameNumber() const override { return 0.0f; }
+	void prepareForAnimation(u16 max_hw_joints) override {}
 	E_ANIMATED_MESH_TYPE getMeshType() const override { return EAMT_STATIC; }
 };
 
diff --git a/irr/include/SkinnedMesh.h b/irr/include/SkinnedMesh.h
@@ -59,6 +59,10 @@ class SkinnedMesh : public IAnimatedMesh
 	//! If the duration is 0, it is a static (=non animated) mesh.
 	f32 getMaxFrameNumber() const override;
 
+	void prepareForAnimation(u16 max_hw_joints) override;
+
+	bool useSoftwareSkinning() const { return UseSwSkinning; }
+
 	//! Turns the given array of local matrices into an array of global matrices
 	//! by multiplying with respective parent matrices.
 	void calculateGlobalMatrices(std::vector<core::matrix4> &matrices) const;
@@ -366,6 +370,7 @@ class SkinnedMesh : public IAnimatedMesh
 
 	bool HasAnimation;
 	bool PreparedForSkinning;
+	bool UseSwSkinning = false;
 
 	SourceFormat SrcFormat;
 };
diff --git a/irr/include/WeightBuffer.h b/irr/include/WeightBuffer.h
@@ -33,10 +33,13 @@ struct WeightBuffer final : public HWBuffer
 
 	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.
+	// A bit of a hack for now: Back up static pose here so we can use it for software 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;
+	struct VertexGeometry {
+		core::vector3df pos;
+		core::vector3df normal;
+	};
+	std::unique_ptr<VertexGeometry[]> static_pose;
 
 	WeightBuffer(size_t n_verts) : weights(n_verts)
 	{ MappingHint = scene::EHM_STATIC; }
@@ -64,14 +67,14 @@ struct WeightBuffer final : public HWBuffer
 
 	/// @note src and dst can be the same buffer
 	void skin(IVertexBuffer *dst,
-			const std::vector<core::matrix4> &joint_transforms) const;
+			const std::vector<core::matrix4> &joint_transforms);
 
 	/// Prepares this buffer for use in skinning.
 	void finalize();
 
 	void updateStaticPose(const IVertexBuffer *vbuf);
 
-	void resetToStatic(IVertexBuffer *vbuf) const;
+	void resetToStaticPose(IVertexBuffer *vbuf) const;
 };
 
 } // end namespace scene
diff --git a/irr/src/AnimatedMeshSceneNode.cpp b/irr/src/AnimatedMeshSceneNode.cpp
@@ -147,23 +147,6 @@ void AnimatedMeshSceneNode::OnRegisterSceneNode()
 	}
 }
 
-IMesh *AnimatedMeshSceneNode::getMeshForCurrentFrame()
-{
-	if (Mesh->getMeshType() != EAMT_SKINNED) {
-		return Mesh;
-	}
-
-	// As multiple scene nodes may be sharing the same skinned mesh, we have to
-	// re-animate it every frame to ensure that this node gets the mesh that it needs.
-
-	auto *skinnedMesh = static_cast<SkinnedMesh *>(Mesh);
-
-	// Matrices have already been calculated in OnAnimate
-	// TODO skinnedMesh->skinMesh(PerJoint.GlobalMatrices);
-
-	return skinnedMesh;
-}
-
 //! OnAnimate() is called just before rendering the whole scene.
 void AnimatedMeshSceneNode::OnAnimate(u32 timeMs)
 {
@@ -213,23 +196,25 @@ void AnimatedMeshSceneNode::render()
 
 	++PassCount;
 
-	scene::IMesh *m = getMeshForCurrentFrame();
-	assert(m);
-
 	if (auto *sm = dynamic_cast<SkinnedMesh *>(Mesh)) {
-		// TODO check whether there are any weights to make use of these joint transforms
-		driver->setJointTransforms(sm->calculateSkinMatrices(PerJoint.GlobalMatrices));
 		sm->rigidAnimation(PerJoint.GlobalMatrices);
+		// TODO check whether there are any weights to make use of these joint transforms
+		if (sm->useSoftwareSkinning()) {
+			// Perform software skinning; matrices have already been calculated in OnAnimate
+			sm->skinMesh(PerJoint.GlobalMatrices);
+		} else {
+			driver->setJointTransforms(sm->calculateSkinMatrices(PerJoint.GlobalMatrices));
+		}
 	}
 	driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
 
-	for (u32 i = 0; i < m->getMeshBufferCount(); ++i) {
+	for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i) {
 		const bool transparent = driver->needsTransparentRenderPass(Materials[i]);
 
 		// only render transparent buffer if this is the transparent render pass
 		// and solid only in solid pass
 		if (transparent == isTransparentPass) {
-			scene::IMeshBuffer *mb = m->getMeshBuffer(i);
+			scene::IMeshBuffer *mb = Mesh->getMeshBuffer(i);
 			const video::SMaterial &material = ReadOnlyMaterials ? mb->getMaterial() : Materials[i];
 			if (RenderFromIdentity)
 				driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
@@ -252,11 +237,11 @@ void AnimatedMeshSceneNode::render()
 		if (DebugDataVisible & scene::EDS_NORMALS) {
 			const f32 debugNormalLength = 1.f;
 			const video::SColor debugNormalColor = video::SColor(255, 34, 221, 221);
-			const u32 count = m->getMeshBufferCount();
+			const u32 count = Mesh->getMeshBufferCount();
 
 			// draw normals
 			for (u32 g = 0; g < count; ++g) {
-				scene::IMeshBuffer *mb = m->getMeshBuffer(g);
+				scene::IMeshBuffer *mb = Mesh->getMeshBuffer(g);
 				if (RenderFromIdentity)
 					driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
 				else if (Mesh->getMeshType() == EAMT_SKINNED)
@@ -271,8 +256,8 @@ void AnimatedMeshSceneNode::render()
 
 		// show bounding box
 		if (DebugDataVisible & scene::EDS_BBOX_BUFFERS) {
-			for (u32 g = 0; g < m->getMeshBufferCount(); ++g) {
-				const IMeshBuffer *mb = m->getMeshBuffer(g);
+			for (u32 g = 0; g < Mesh->getMeshBufferCount(); ++g) {
+				const IMeshBuffer *mb = Mesh->getMeshBuffer(g);
 
 				if (Mesh->getMeshType() == EAMT_SKINNED)
 					driver->setTransform(video::ETS_WORLD, AbsoluteTransformation * ((SSkinMeshBuffer *)mb)->Transformation);
@@ -305,8 +290,8 @@ void AnimatedMeshSceneNode::render()
 			debug_mat.ZBuffer = video::ECFN_DISABLED;
 			driver->setMaterial(debug_mat);
 
-			for (u32 g = 0; g < m->getMeshBufferCount(); ++g) {
-				const IMeshBuffer *mb = m->getMeshBuffer(g);
+			for (u32 g = 0; g < Mesh->getMeshBufferCount(); ++g) {
+				const IMeshBuffer *mb = Mesh->getMeshBuffer(g);
 				if (RenderFromIdentity)
 					driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
 				else if (Mesh->getMeshType() == EAMT_SKINNED)
diff --git a/irr/src/CSceneManager.cpp b/irr/src/CSceneManager.cpp
@@ -137,6 +137,7 @@ IAnimatedMesh *CSceneManager::getUncachedMesh(io::IReadFile *file, const io::pat
 			file->seek(0);
 			IAnimatedMesh *msh = (*it)->createMesh(file);
 			if (msh) {
+				msh->prepareForAnimation(Driver->getMaxJointTransforms());
 				MeshCache->addMesh(cachename, msh);
 				msh->drop();
 				os::Printer::log("Loaded mesh", filename, ELL_DEBUG);
diff --git a/irr/src/OpenGL/BufferObject.cpp b/irr/src/OpenGL/BufferObject.cpp
@@ -34,7 +34,7 @@ void OGLBufferObject::upload(const void *data, size_t size, size_t offset,
 		GL.BufferSubData(m_target, offset, size, data);
 	}
 
-	// TODO binding should perhaps be a separate step from the upload?
+	// In the future, binding should perhaps be a separate step from the upload?
 	if (m_target == TARGET_UBO)
 		GL.BindBufferBase(GL_UNIFORM_BUFFER, 0, m_name);
 	else
diff --git a/irr/src/SkinnedMesh.cpp b/irr/src/SkinnedMesh.cpp
@@ -37,6 +37,36 @@ f32 SkinnedMesh::getMaxFrameNumber() const
 	return EndFrame;
 }
 
+void SkinnedMesh::prepareForAnimation(u16 max_hw_joints)
+{
+	if (getJointCount() <= max_hw_joints)
+		return;
+
+	for (auto *buf : LocalBuffers)
+		buf->getVertexBuffer()->useSwSkinning();
+	UseSwSkinning = true;
+}
+
+void SkinnedMesh::updateStaticPose()
+{
+	if (!UseSwSkinning)
+		return;
+	for (auto *buf : LocalBuffers) {
+		if (auto *weights = buf->getWeights())
+			weights->updateStaticPose(buf->getVertexBuffer());
+	}
+}
+
+void SkinnedMesh::resetAnimation()
+{
+	if (!UseSwSkinning)
+		return;
+	for (auto *buf : LocalBuffers) {
+		if (auto *weights = buf->getWeights())
+			weights->resetToStaticPose(buf->getVertexBuffer());
+	}
+}
+
 // Keyframe Animation
 
 
@@ -115,7 +145,7 @@ void SkinnedMesh::skinMesh(const std::vector<core::matrix4> &global_matrices)
 	}
 
 	for (auto *buffer : *SkinningBuffers) {
-		if (const auto *weights = buffer->getWeights())
+		if (auto *weights = buffer->getWeights())
 			weights->skin(buffer->getVertexBuffer(), joint_transforms);
 	}
 }
@@ -192,23 +222,6 @@ void SkinnedMesh::setDirty(E_BUFFER_TYPE buffer)
 		LocalBuffers[i]->setDirty(buffer);
 }
 
-void SkinnedMesh::updateStaticPose()
-{
-	for (auto *buf : LocalBuffers) {
-		if (auto *weights = buf->getWeights())
-			weights->updateStaticPose(buf->getVertexBuffer());
-	}
-}
-
-void SkinnedMesh::resetAnimation()
-{
-	// copy from the cache to the mesh...
-	for (auto *buf : LocalBuffers) {
-		if (auto *weights = buf->getWeights())
-			weights->resetToStatic(buf->getVertexBuffer());
-	}
-}
-
 //! Turns the given array of local matrices into an array of global matrices
 //! by multiplying with respective parent matrices.
 void SkinnedMesh::calculateGlobalMatrices(std::vector<core::matrix4> &matrices) const
@@ -423,13 +436,11 @@ SkinnedMesh *SkinnedMeshBuilder::finalize() &&
 	}
 
 	for (auto *buffer : mesh->LocalBuffers) {
-		// With GPU skinning, the VBOs should be static
-		// TODO fallback to software skinning
+		// With HW skinning, the VBOs should be static by default
 		buffer->setHardwareMappingHint(EHM_STATIC);
 		if (auto *weights = buffer->getWeights())
 			weights->finalize();
 	}
-	mesh->updateStaticPose();
 
 	mesh->recalculateBaseBoundingBoxes();
 	mesh->StaticPoseBox = mesh->calculateBoundingBox(matrices);
diff --git a/irr/src/WeightBuffer.cpp b/irr/src/WeightBuffer.cpp
@@ -58,14 +58,14 @@ void WeightBuffer::skinVertex(u32 vertex_id, core::vector3df &pos, core::vector3
 }
 
 void WeightBuffer::skin(IVertexBuffer *dst,
-		const std::vector<core::matrix4> &joint_transforms) const
+		const std::vector<core::matrix4> &joint_transforms)
 {
 	assert(animated_vertices.has_value());
+	assert(static_pose);
 	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];
+		auto pos = static_pose[i].pos;
+		auto normal = static_pose[i].normal;
 		skinVertex(vertex_id, pos, normal, joint_transforms);
 		dst->getPosition(vertex_id) = pos;
 		dst->getNormal(vertex_id) = normal;
@@ -98,24 +98,24 @@ void WeightBuffer::finalize()
 
 void WeightBuffer::updateStaticPose(const IVertexBuffer *vbuf)
 {
-	if (!static_normals)
-		static_normals = std::make_unique<core::vector3df[]>(animated_vertices->size());
-	if (!static_positions)
-		static_positions = std::make_unique<core::vector3df[]>(animated_vertices->size());
+	if (!static_pose)
+		static_pose = std::make_unique<VertexGeometry[]>(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);
+		static_pose[idx].pos = vbuf->getPosition(vertex_id);
+		static_pose[idx].normal = vbuf->getNormal(vertex_id);
 	}
 }
 
-void WeightBuffer::resetToStatic(IVertexBuffer *vbuf) const
+void WeightBuffer::resetToStaticPose(IVertexBuffer *vbuf) const
 {
 	assert(animated_vertices.has_value());
+	if (!static_pose)
+		return;
 	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];
+		vbuf->getPosition(vertex_id) = static_pose[idx].pos;
+		vbuf->getNormal(vertex_id) = static_pose[idx].normal;
 	}
 	if (!animated_vertices->empty())
 		vbuf->setDirty();
diff --git a/src/client/content_cao.cpp b/src/client/content_cao.cpp

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ void OGLBufferObject::upload(const void *data, size_t size, size_t offset,`
`34`	`34`	`GL.BufferSubData(m_target, offset, size, data);`
`35`	`35`	`}`
`36`	`36`
`37`		`- // TODO binding should perhaps be a separate step from the upload?`
	`37`	`+ // In the future, binding should perhaps be a separate step from the upload?`
`38`	`38`	`if (m_target == TARGET_UBO)`
`39`	`39`	`GL.BindBufferBase(GL_UNIFORM_BUFFER, 0, m_name);`
`40`	`40`	`else`