tests: L3 regression guards for the 3D object subsystem

12 Catch2 suites pinning the fixes made while building out the 3D
processes: animation speed and skinned-mesh deformation, camera state
release, cubemap face clamping, compute-extraction SRB layout,
extraction index and buffer lifetime, HDR extension handling, instancer
clamping and stale buffers, OBJ parse crashes and shader string
generation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014rZgzE8JjWvHDtaVUhxpLE

Author: 2 people

tests/CMakeLists.txt

@@ -14,3 +14,8 @@ add_subdirectory(hardware)
 if(TARGET score_plugin_gfx)
   add_subdirectory(gfx)
 endif()
+
+# L3 regression guards for the 3D object subsystem.
+if(TARGET score_plugin_threedim)
+  add_subdirectory(threedim)
+endif()

tests/threedim/AnimationSkinning.cpp

@@ -0,0 +1,130 @@
+// L3 regression guard — split/threedim finding #9 (AnimationPlayer never
+// deforms skinned meshes: it wrote an ignored buffer and left joint TRS at
+// bind pose).
+//
+// The skinning block recomputed joint_matrix = world x inverse_bind into
+// skeleton_component::joint_matrices_buffer, but the sole skinning consumer
+// (SceneGPUState) ALWAYS derives its joint matrices from joints[].{translation,
+// rotation,scale} via its own forward kinematics and never reads
+// joint_matrices_buffer. AnimationPlayer meanwhile animated only the rigid
+// scene_transform payloads and never touched joints[] — so the animated pose
+// never reached the skinning path and skinned meshes stayed frozen in bind
+// pose.
+//
+// The fix writes each sampled TRS override (keyed by scene_node id) into the
+// cloned skeleton's joints[] local TRS, mapped joint -> node via
+// joint_node_ids, and bumps the skeleton dirty_index.
+//
+// This is a pure state test (no GPU): we build a scene with one animated
+// rotation channel targeting the node that backs joint 0, tick once, and read
+// the OUTPUT scene's skeleton. Post-fix, joints[0].rotation has moved off the
+// bind-pose identity quaternion to the sampled value; pre-fix it stays at the
+// bind pose (0,0,0,1) (RED). We observe the published skeleton_component state,
+// not a rendered image.
+
+#include <Threedim/AnimationPlayer.hpp>
+
+#include <ossia/dataflow/geometry_port.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <cmath>
+#include <memory>
+#include <vector>
+
+namespace
+{
+// scene_node id that backs the animated joint.
+constexpr uint64_t kJointNodeId = 77;
+
+// A 90 degrees rotation about +Z as a glTF (x,y,z,w) quaternion.
+constexpr float kQz = 0.70710678f; // sin(45deg) == cos(45deg)
+
+std::shared_ptr<ossia::scene_state> makeSkinnedScene()
+{
+  // Minimal non-empty root (scene_state::empty() gates AnimationPlayer). The
+  // root does not need to be the joint node — the skinning path resolves joints
+  // via joint_node_ids against the sampled overrides, independent of the tree.
+  auto root = std::make_shared<ossia::scene_node>();
+  root->id.value = 1;
+  auto roots = std::make_shared<std::vector<ossia::scene_node_ptr>>();
+  roots->push_back(root);
+
+  // One rotation channel on node 77, constant 90deg-about-Z at both keyframes,
+  // so any sampled t yields the same non-identity quaternion.
+  auto anim = std::make_shared<ossia::animation_component>();
+  anim->duration = 1.f;
+  ossia::animation_channel ch;
+  ch.target_node_id = kJointNodeId;
+  ch.target_path = ossia::animation_target::rotation;
+  ch.interpolation = ossia::animation_interpolation::linear;
+  ch.times = std::make_shared<std::vector<float>>(std::vector<float>{0.f, 1.f});
+  ch.values = std::make_shared<std::vector<float>>(
+      std::vector<float>{0.f, 0.f, kQz, kQz, 0.f, 0.f, kQz, kQz});
+  anim->channels.push_back(ch);
+  auto anims
+      = std::make_shared<std::vector<ossia::animation_component_ptr>>();
+  anims->push_back(anim);
+
+  // One skeleton, one joint at bind pose (identity rotation), mapped to node 77.
+  auto skel = std::make_shared<ossia::skeleton_component>();
+  ossia::skeleton_joint joint; // defaults: rotation {0,0,0,1}, scale {1,1,1}
+  joint.name = "j0";
+  skel->joints.push_back(joint);
+  skel->joint_node_ids.push_back(ossia::scene_node_id{kJointNodeId});
+  skel->dirty_index = 0;
+  auto skels
+      = std::make_shared<std::vector<ossia::skeleton_component_ptr>>();
+  skels->push_back(skel);
+
+  auto st = std::make_shared<ossia::scene_state>();
+  st->roots = roots;
+  st->animations = anims;
+  st->skeletons = skels;
+  return st;
+}
+
+const ossia::skeleton_component*
+outputSkeleton(Threedim::AnimationPlayer& node)
+{
+  const auto& out = node.outputs.scene_out.scene.state;
+  if(!out || !out->skeletons || out->skeletons->empty())
+    return nullptr;
+  return (*out->skeletons)[0].get();
+}
+} // namespace
+
+TEST_CASE(
+    "AnimationPlayer writes sampled TRS into skeleton joints",
+    "[threedim][animation][f9]")
+{
+  Threedim::AnimationPlayer node;
+  node.inputs.scene_in.scene.state = makeSkinnedScene();
+  node.inputs.time.value = 0.f;
+  node.inputs.speed.value = 1.f;
+  node.inputs.loop.value = false;
+  node.inputs.clip_index.value = -1;
+
+  node();
+
+  const ossia::skeleton_component* skel = outputSkeleton(node);
+  REQUIRE(skel != nullptr);
+  REQUIRE(skel->joints.size() == 1u);
+
+  // The fix: the joint's LOCAL rotation TRS (the data SceneGPUState's forward
+  // kinematics actually consumes) is now the sampled 90deg-about-Z quaternion,
+  // no longer the bind-pose identity. Pre-fix the joint stays at bind pose and
+  // both component checks fail (RED).
+  const auto& r = skel->joints[0].rotation; // (x,y,z,w)
+  CHECK(std::abs(r[2] - kQz) < 1e-4f);
+  CHECK(std::abs(r[3] - kQz) < 1e-4f);
+
+  // It has genuinely moved off the bind-pose identity (0,0,0,1).
+  const bool movedFromBind
+      = std::abs(r[0]) > 1e-4f || std::abs(r[1]) > 1e-4f
+        || std::abs(r[2]) > 1e-4f || std::abs(r[3] - 1.f) > 1e-4f;
+  CHECK(movedFromBind);
+
+  // And the skeleton is flagged dirty so the renderer re-runs FK.
+  CHECK(skel->dirty_index > 0);
+}

tests/threedim/AnimationSpeed.cpp

@@ -0,0 +1,111 @@
+// L3 regression guard — split/threedim finding #10 (AnimationPlayer Speed
+// never advances / ping-pongs).
+//
+// The Speed integration gated on `t == m_prev_time` but then overwrote
+// m_prev_time with the freshly-advanced t. With Time held at 0 and Speed set,
+// playback ping-ponged 0 -> speed/60 -> 0 forever instead of accumulating. The
+// fix keeps a dedicated m_playback_time accumulator decoupled from the change-
+// detection value.
+//
+// This drives the node directly (no GPU) with a one-node scene animated by a
+// single linear translation channel whose X maps t -> t over [0,10]. Leaving
+// Time at 0 and Speed at 2, we tick N frames and read the OUTPUT scene's
+// animated translation. Post-fix it advances monotonically; the pre-fix engine
+// alternates it back to ~0 every other frame (RED). We assert against the
+// public OUTPUT (not m_playback_time) so the test compiles against BOTH the
+// fixed and reverted headers — only the assertion flips.
+
+#include <Threedim/AnimationPlayer.hpp>
+
+#include <ossia/dataflow/geometry_port.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <memory>
+#include <vector>
+
+namespace
+{
+// Build a scene: one node (id 42) with an identity scene_transform child, plus
+// one animation clip translating node 42's X from 0 to 10 across t in [0,10].
+std::shared_ptr<ossia::scene_state> makeAnimatedScene()
+{
+  auto root = std::make_shared<ossia::scene_node>();
+  root->id.value = 42;
+
+  ossia::scene_transform xf{};
+  xf.rotation[3] = 1.f;
+  xf.scale[0] = xf.scale[1] = xf.scale[2] = 1.f;
+
+  auto children = std::make_shared<std::vector<ossia::scene_payload>>();
+  children->push_back(xf);
+  root->children = children;
+
+  auto roots = std::make_shared<std::vector<ossia::scene_node_ptr>>();
+  roots->push_back(root);
+
+  auto anim = std::make_shared<ossia::animation_component>();
+  anim->duration = 10.f;
+  ossia::animation_channel ch;
+  ch.target_node_id = 42;
+  ch.target_path = ossia::animation_target::translation;
+  ch.interpolation = ossia::animation_interpolation::linear;
+  ch.times = std::make_shared<std::vector<float>>(std::vector<float>{0.f, 10.f});
+  ch.values = std::make_shared<std::vector<float>>(
+      std::vector<float>{0.f, 0.f, 0.f, 10.f, 0.f, 0.f});
+  anim->channels.push_back(ch);
+
+  auto anims
+      = std::make_shared<std::vector<ossia::animation_component_ptr>>();
+  anims->push_back(anim);
+
+  auto st = std::make_shared<ossia::scene_state>();
+  st->roots = roots;
+  st->animations = anims;
+  return st;
+}
+
+// Pull the animated node's translation.x out of the emitted output scene.
+float outputTranslationX(Threedim::AnimationPlayer& node)
+{
+  const auto& out = node.outputs.scene_out.scene.state;
+  REQUIRE(out);
+  REQUIRE(out->roots);
+  REQUIRE(!out->roots->empty());
+  const auto& n0 = (*out->roots)[0];
+  REQUIRE(n0);
+  REQUIRE(n0->children);
+  REQUIRE(!n0->children->empty());
+  const auto* tf = ossia::get_if<ossia::scene_transform>(&(*n0->children)[0]);
+  REQUIRE(tf);
+  return tf->translation[0];
+}
+} // namespace
+
+TEST_CASE(
+    "AnimationPlayer Speed advances playback monotonically",
+    "[threedim][animation][f10]")
+{
+  Threedim::AnimationPlayer node;
+  node.inputs.scene_in.scene.state = makeAnimatedScene();
+  node.inputs.time.value = 0.f;   // Time held constant at 0
+  node.inputs.speed.value = 2.f;  // Speed engaged (2x)
+  node.inputs.loop.value = false;
+  node.inputs.clip_index.value = -1;
+
+  constexpr int frames = 12;
+  std::vector<float> xs;
+  xs.reserve(frames);
+  for(int i = 0; i < frames; ++i)
+  {
+    node();
+    xs.push_back(outputTranslationX(node));
+  }
+
+  // Strictly monotonic increase: each frame must be past the previous one.
+  for(std::size_t i = 1; i < xs.size(); ++i)
+    CHECK(xs[i] > xs[i - 1]);
+
+  // And it must have genuinely progressed, not jittered at the very start.
+  CHECK(xs.back() > xs.front() + 0.1f);
+}