Fix Fabric seed for scaled parents and scaled children

_sync_fabric_from_usd_initial had two scale-related bugs in the
USD->Fabric seed path that produced silently wrong matrices whenever a
parent or child had a non-unit scale.  Both kernels that recompute
world<->local consistency read those seeded matrices, so the error
propagated.

* Parent worldMatrix was composed with a hardcoded (1, 1, 1) scale.
  Orthonormalize() strips scale from the local-to-world transform, so
  we now extract the scale via Gf.Transform.GetScale() *before*
  orthonormalizing and pass it through to the compose kernel.

* Child localMatrix was composed with the empty-array sentinel for the
  scale slot, leaving the kernel-side scale at the identity default.
  We now pass the locally-authored scale (already fetched via
  _usd_view.get_scales()) so the matrix carries the right scale.

* Child worldMatrix is still composed from get_world_poses() position
  and orientation plus the child's local scale, which is wrong when a
  parent has non-unit world scale.  Instead of fixing the seed by hand
  (would require per-child world-scale lookups), mark the view dirty at
  the end of the seed.  The very next world read fires
  _sync_world_from_local_if_dirty, which computes
  child_world = parent_world * child_local on the GPU - and with both
  matrices now correctly scaled, the multiply produces the right
  world-space scale automatically.

Added test_initial_seed_with_scaled_parent regression test: parent
world scale (2, 1, 1), child local scale (3, 1, 1).  Locally verified
the test fails when either fix is reverted in isolation.

Author: pv-nvidia

source/isaaclab_physx/isaaclab_physx/sim/views/fabric_frame_view.py

@@ -34,7 +34,7 @@
 import torch
 import warp as wp
 
-from pxr import Usd, UsdGeom
+from pxr import Gf, Usd, UsdGeom
 
 import isaaclab.sim as sim_utils
 from isaaclab.app.settings_manager import SettingsManager
@@ -769,15 +769,18 @@ def _sync_fabric_from_usd_initial(self) -> None:
             ],
             device=self._device,
         )
-        # Compose into child localMatrix.
+        # Compose into child localMatrix.  Pass the locally-authored scale so
+        # that a subsequent ``_sync_world_from_local_if_dirty`` produces the
+        # right world-space scale (``world = parent_world * local`` carries
+        # ``local``'s scale through the multiply).
         wp.launch(
             kernel=fabric_utils.compose_indexed_fabric_transforms,
             dim=self.count,
             inputs=[
                 self._local_ifa_rw,
                 _to_float32_2d(local_pos_ta.warp),
                 _to_float32_2d(local_ori_ta.warp),
-                self._fabric_empty_2d_array_sentinel,
+                _to_float32_2d(scales_wp),
                 False,
                 False,
                 False,
@@ -793,23 +796,25 @@ def _sync_fabric_from_usd_initial(self) -> None:
             xform_cache = UsdGeom.XformCache(Usd.TimeCode.Default())
             world_pos_rows: list[list[float]] = []
             world_ori_rows: list[list[float]] = []
+            world_scale_rows: list[list[float]] = []
+            decomposer = Gf.Transform()
             for path in unique_parent_paths:
                 prim = usd_stage.GetPrimAtPath(path)
                 tf = xform_cache.GetLocalToWorldTransform(prim)
+                # Extract scale before ``Orthonormalize`` strips it from the rows.
+                decomposer.SetMatrix(tf)
+                s = decomposer.GetScale()
                 tf.Orthonormalize()
                 t = tf.ExtractTranslation()
                 q = tf.ExtractRotationQuat()
                 img, real = q.GetImaginary(), q.GetReal()
                 world_pos_rows.append([float(t[0]), float(t[1]), float(t[2])])
                 world_ori_rows.append([float(img[0]), float(img[1]), float(img[2]), float(real)])
+                world_scale_rows.append([float(s[0]), float(s[1]), float(s[2])])
             parent_view_indices = wp.array(list(range(len(unique_parent_paths))), dtype=wp.uint32, device=self._device)
             parent_pos_wp = wp.array(world_pos_rows, dtype=wp.float32, device=self._device)
             parent_ori_wp = wp.array(world_ori_rows, dtype=wp.float32, device=self._device)
-            parent_unit_scale = wp.array(
-                [[1.0, 1.0, 1.0]] * len(unique_parent_paths),
-                dtype=wp.float32,
-                device=self._device,
-            )
+            parent_scale_wp = wp.array(world_scale_rows, dtype=wp.float32, device=self._device)
             # Compose worldMatrix for parents (use a one-shot indexed array against
             # ``world_sel_rw`` keyed on the unique parent paths).
             parent_world_rw = wp.indexedfabricarray(
@@ -823,7 +828,7 @@ def _sync_fabric_from_usd_initial(self) -> None:
                     parent_world_rw,
                     parent_pos_wp,
                     parent_ori_wp,
-                    parent_unit_scale,
+                    parent_scale_wp,
                     False,
                     False,
                     False,
@@ -833,6 +838,14 @@ def _sync_fabric_from_usd_initial(self) -> None:
             )
         wp.synchronize()
 
+        # The child worldMatrix above was composed with the child's *local* scale,
+        # which is wrong whenever a parent has a non-unit world scale.  Mark the
+        # view dirty so the next world read fires ``_sync_world_from_local_if_dirty``
+        # and recomputes ``child_world = parent_world * child_local`` — that
+        # multiply produces the correct world-space scale because the parent and
+        # local matrices now both carry the right scale (seeded above).
+        self._world_dirty = True
+
     def _compute_fabric_indices_for(self, selection, paths: list[str]) -> wp.array:
         """Path-dict lookup helper used to build one-shot indexed arrays for a custom path set."""
         fabric_paths = selection.GetPaths()

source/isaaclab_physx/test/sim/test_views_xform_prim_fabric.py

@@ -357,3 +357,51 @@ def test_set_world_then_get_local_with_rotated_parent(device):
     local_pos, _ = view.get_local_poses()
     expected = torch.tensor([[0.0, -5.0, 1.0]], dtype=torch.float32, device=device)
     torch.testing.assert_close(local_pos.torch, expected, atol=1e-5, rtol=0)
+
+
+@pytest.mark.parametrize("device", ["cpu", "cuda:0"])
+def test_initial_seed_with_scaled_parent(device):
+    """Verify the initial USD→Fabric seed handles non-unit scales correctly.
+
+    Sets up a parent with world scale (2, 1, 1) and a child with local scale
+    (3, 1, 1) at local translation (1, 0, 0).  Expected world-space values for
+    the child:
+
+    * world scale = parent_scale * child_local_scale = (6, 1, 1)
+    * world position = parent_pos + parent_scale * child_local_pos
+                     = (0, 0, 1) + (2 * 1, 0, 0) = (2, 0, 1)
+
+    If the parent's worldMatrix is seeded with a hardcoded unit scale,
+    ``get_scales`` returns (3, 1, 1) instead of (6, 1, 1) and ``get_world_poses``
+    returns (1, 0, 1) instead of (2, 0, 1).  If the child's localMatrix is
+    seeded without scale, after ``_sync_world_from_local_if_dirty`` the world
+    scale collapses to (2, 1, 1).  This test catches both regressions.
+    """
+    _skip_if_unavailable(device)
+    stage = sim_utils.get_current_stage()
+    sim_utils.create_prim("/World/Parent_0", "Xform", translation=(0.0, 0.0, 1.0), scale=(2.0, 1.0, 1.0), stage=stage)
+    sim_utils.create_prim(
+        "/World/Parent_0/Child",
+        "Camera",
+        translation=(1.0, 0.0, 0.0),
+        scale=(3.0, 1.0, 1.0),
+        stage=stage,
+    )
+    sim_utils.SimulationContext(sim_utils.SimulationCfg(dt=0.01, device=device, use_fabric=True))
+    view = FrameView("/World/Parent_.*/Child", device=device)
+
+    world_pos, _ = view.get_world_poses()
+    torch.testing.assert_close(
+        world_pos.torch,
+        torch.tensor([[2.0, 0.0, 1.0]], dtype=torch.float32, device=device),
+        atol=1e-5,
+        rtol=0,
+    )
+
+    scales = wp.to_torch(view.get_scales())
+    torch.testing.assert_close(
+        scales,
+        torch.tensor([[6.0, 1.0, 1.0]], dtype=torch.float32, device=device),
+        atol=1e-5,
+        rtol=0,
+    )