Add test for non-contiguous case (newton-physics#1549)

Author: jvonmuralt

newton/tests/test_selection.py

@@ -148,6 +148,73 @@ def test_selection_shapes(self):
             multi_ant_per_world_view.get_attribute("shape_thickness", multi_ant_per_world_model).shape, (W, A, S)
         )
 
+    def test_selection_shape_values_noncontiguous(self):
+        """Test that shape attribute values are correct when shape selection is non-contiguous."""
+        # Build a 3-link chain: base -> link1 -> link2
+        # Each link has one shape with a distinct thickness value
+        robot = newton.ModelBuilder()
+
+        thicknesses = [0.001, 0.002, 0.003]
+
+        base = robot.add_link(xform=wp.transform([0, 0, 0], wp.quat_identity()), mass=1.0, key="base")
+        robot.add_shape_box(
+            base,
+            hx=0.1,
+            hy=0.1,
+            hz=0.1,
+            cfg=newton.ModelBuilder.ShapeConfig(thickness=thicknesses[0]),
+            key="shape_base",
+        )
+
+        link1 = robot.add_link(xform=wp.transform([0, 0, 0.5], wp.quat_identity()), mass=0.5, key="link1")
+        robot.add_shape_capsule(
+            link1,
+            radius=0.05,
+            half_height=0.2,
+            cfg=newton.ModelBuilder.ShapeConfig(thickness=thicknesses[1]),
+            key="shape_link1",
+        )
+
+        link2 = robot.add_link(xform=wp.transform([0, 0, 1.0], wp.quat_identity()), mass=0.3, key="link2")
+        robot.add_shape_sphere(
+            link2,
+            radius=0.05,
+            cfg=newton.ModelBuilder.ShapeConfig(thickness=thicknesses[2]),
+            key="shape_link2",
+        )
+
+        j0 = robot.add_joint_free(child=base)
+        j1 = robot.add_joint_revolute(parent=base, child=link1, axis=[0, 1, 0])
+        j2 = robot.add_joint_revolute(parent=link1, child=link2, axis=[0, 1, 0])
+        robot.add_articulation([j0, j1, j2], key="robot")
+
+        W = 3
+        scene = newton.ModelBuilder()
+        # add a ground plane first so shape indices are offset
+        scene.add_shape_plane()
+        scene.replicate(robot, num_worlds=W)
+        model = scene.finalize()
+
+        # exclude the middle link to make shape indices non-contiguous: [0, 2]
+        view = ArticulationView(model, "robot", exclude_links=["link1"])
+        self.assertFalse(view.shapes_contiguous, "Expected non-contiguous shape selection")
+        self.assertEqual(view.shape_count, 2)
+
+        # read shape_thickness through ArticulationView and check values
+        vals = view.get_attribute("shape_thickness", model)
+        self.assertEqual(vals.shape, (W, 1, 2))
+        vals_np = vals.numpy()
+
+        expected = [thicknesses[0], thicknesses[2]]  # base and link2 (link1 excluded)
+        for w in range(W):
+            for s, expected_thickness in enumerate(expected):
+                self.assertAlmostEqual(
+                    float(vals_np[w, 0, s]),
+                    expected_thickness,
+                    places=6,
+                    msg=f"world={w}, shape={s}",
+                )
+
     def test_selection_mask(self):
         # load articulation
         ant = newton.ModelBuilder()