Rework FabricFrameView to use indexedfabricarray + Fabric localMatrix

Adopts the prototype design from bareya/pbarejko/camera-update for
FabricFrameView's transform handling, and replaces the previous
software composition of local poses (which forced a Python USD parent
loop and made get_local_poses 3x slower than USD).

Architecture changes:

* Three persistent ``PrimSelection`` instances (trans_ro, world_rw,
  local_rw), differing only in per-attribute access mode.  Replaces
  the single selection that required a custom ``isaaclab:view_index``
  attribute on every prim.
* Path-based view -> fabric index computation: the integer mapping is
  derived once from ``selection.GetPaths()`` and stored as a Warp
  array.  No prim attributes are added to the stage.
* All transform reads and writes go through ``wp.indexedfabricarray``,
  so kernels just dereference ``ifa[view_index]`` without a separate
  mapping argument.  The two new indexed kernels live next to the
  existing ones in ``isaaclab.utils.warp.fabric``.
* Stage-level ``IFabricHierarchy`` cache and dirty-stage set: multiple
  FabricFrameView instances on the same stage share one hierarchy.

Local-pose path:

* ``set_local_poses`` writes ``omni:fabric:localMatrix`` directly
  through Fabric and marks the stage dirty.  The next ``get_world_poses``
  fires a Warp kernel that recomputes ``child_world = parent_world *
  child_local`` (we cannot rely on ``IFabricHierarchy.update_world_xforms``
  -- in practice it re-reads USD's authored xformOps and overwrites the
  Fabric matrices we just authored).
* Symmetrically, ``set_world_poses`` runs a kernel that recomputes
  ``child_local = inv(parent_world) * child_world`` so subsequent
  ``get_local_poses`` calls return consistent values.
* Initial Fabric population reads through the internal ``UsdFrameView``
  (children) and ``UsdGeom.XformCache`` (parents) and writes via the
  same compose kernel set used at runtime.  ``SetWorldXformFromUsd`` /
  ``SetLocalXformFromUsd`` are no-ops on author-then-query stages, so
  we do this manually.

Performance impact (1024 prims, 50 iterations, A6000):

  Operation             USD (ms)   Fabric (ms)   Speedup
  Get World Poses        13.56       0.067        201x
  Set World Poses        29.97       0.123        244x
  Interleaved Set->Get   43.78       0.159        276x
  Get Local Poses         6.15       0.064         96x  (was 0.31x SLOWER)
  Set Local Poses         8.61       0.053        163x  (was 0.42x SLOWER)

The two new indexed kernels added to ``isaaclab.utils.warp.fabric``:

* ``decompose_indexed_fabric_transforms``  -- like the existing
  ``decompose_fabric_transformation_matrix_to_warp_arrays`` but takes a
  ``wp.indexedfabricarray`` so the view->fabric mapping is baked in.
* ``compose_indexed_fabric_transforms``  -- mirror.
* ``update_indexed_local_matrix_from_world``  -- new: recomputes
  ``child_local = inv(parent_world) * child_world`` per child.
* ``update_indexed_world_matrix_from_local``  -- new: mirror.

Tests updated:

* ``test_fabric_rebuild_after_topology_change`` no longer monkey-patches
  the removed ``_prepare_for_reuse`` / ``_rebuild_fabric_arrays`` helpers;
  it now exercises ``_compute_fabric_indices`` and ``_build_indexed_array``
  directly to simulate a rebuild.
* ``test_prepare_for_reuse_detects_topology_change`` verifies all three
  persistent selections respond to ``PrepareForReuse`` (instead of the
  removed single ``_fabric_selection``).

All 41 tests in ``test_views_xform_prim_fabric.py`` pass.

Author: pv-nvidia

source/isaaclab/isaaclab/utils/warp/fabric.py

@@ -18,12 +18,14 @@
 if TYPE_CHECKING:
     FabricArrayUInt32 = Any
     FabricArrayMat44d = Any
+    IndexedFabricArrayMat44d = Any
     ArrayUInt32 = Any
     ArrayUInt32_1d = Any
     ArrayFloat32_2d = Any
 else:
     FabricArrayUInt32 = wp.fabricarray(dtype=wp.uint32)
     FabricArrayMat44d = wp.fabricarray(dtype=wp.mat44d)
+    IndexedFabricArrayMat44d = wp.indexedfabricarray(dtype=wp.mat44d)
     ArrayUInt32 = wp.array(ndim=1, dtype=wp.uint32)
     ArrayUInt32_1d = wp.array(dtype=wp.uint32)
     ArrayFloat32_2d = wp.array(ndim=2, dtype=wp.float32)
@@ -163,6 +165,178 @@ def compose_fabric_transformation_matrix_from_warp_arrays(
     )
 
 
+@wp.kernel(enable_backward=False)
+def decompose_indexed_fabric_transforms(
+    fabric_matrices: IndexedFabricArrayMat44d,
+    array_positions: ArrayFloat32_2d,
+    array_orientations: ArrayFloat32_2d,
+    array_scales: ArrayFloat32_2d,
+    indices: ArrayUInt32,
+):
+    """Decompose indexed Fabric transformation matrices into position, orientation, and scale.
+
+    Like :func:`decompose_fabric_transformation_matrix_to_warp_arrays` but operates on a
+    :class:`wp.indexedfabricarray` that already encodes the view-to-fabric mapping, removing
+    the need for a separate ``mapping`` array.
+
+    Args:
+        fabric_matrices: Indexed fabric array containing 4x4 transformation matrices.
+        array_positions: Output array for positions [m], shape (N, 3).
+        array_orientations: Output array for quaternions in xyzw format, shape (N, 4).
+        array_scales: Output array for scales, shape (N, 3).
+        indices: View indices to process (subset selection).
+    """
+    output_index = wp.tid()
+    view_index = indices[output_index]
+
+    position, rotation, scale = _decompose_transformation_matrix(wp.mat44f(fabric_matrices[view_index]))
+
+    if array_positions.shape[0] > 0:
+        array_positions[output_index, 0] = position[0]
+        array_positions[output_index, 1] = position[1]
+        array_positions[output_index, 2] = position[2]
+    if array_orientations.shape[0] > 0:
+        array_orientations[output_index, 0] = rotation[0]
+        array_orientations[output_index, 1] = rotation[1]
+        array_orientations[output_index, 2] = rotation[2]
+        array_orientations[output_index, 3] = rotation[3]
+    if array_scales.shape[0] > 0:
+        array_scales[output_index, 0] = scale[0]
+        array_scales[output_index, 1] = scale[1]
+        array_scales[output_index, 2] = scale[2]
+
+
+@wp.kernel(enable_backward=False)
+def compose_indexed_fabric_transforms(
+    fabric_matrices: IndexedFabricArrayMat44d,
+    array_positions: ArrayFloat32_2d,
+    array_orientations: ArrayFloat32_2d,
+    array_scales: ArrayFloat32_2d,
+    broadcast_positions: bool,
+    broadcast_orientations: bool,
+    broadcast_scales: bool,
+    indices: ArrayUInt32,
+):
+    """Compose indexed Fabric transformation matrices from position, orientation, and scale.
+
+    Like :func:`compose_fabric_transformation_matrix_from_warp_arrays` but operates on a
+    :class:`wp.indexedfabricarray` that already encodes the view-to-fabric mapping, removing
+    the need for a separate ``mapping`` array.
+
+    Args:
+        fabric_matrices: Indexed fabric array containing 4x4 transformation matrices to update.
+        array_positions: Input array for positions [m], shape (N, 3).
+        array_orientations: Input array for quaternions in xyzw format, shape (N, 4).
+        array_scales: Input array for scales, shape (N, 3).
+        broadcast_positions: If True, use first position for all prims.
+        broadcast_orientations: If True, use first orientation for all prims.
+        broadcast_scales: If True, use first scale for all prims.
+        indices: View indices to process (subset selection).
+    """
+    i = wp.tid()
+    view_index = indices[i]
+    position, rotation, scale = _decompose_transformation_matrix(wp.mat44f(fabric_matrices[view_index]))
+
+    if array_positions.shape[0] > 0:
+        if broadcast_positions:
+            index = 0
+        else:
+            index = i
+        position[0] = array_positions[index, 0]
+        position[1] = array_positions[index, 1]
+        position[2] = array_positions[index, 2]
+    if array_orientations.shape[0] > 0:
+        if broadcast_orientations:
+            index = 0
+        else:
+            index = i
+        rotation[0] = array_orientations[index, 0]
+        rotation[1] = array_orientations[index, 1]
+        rotation[2] = array_orientations[index, 2]
+        rotation[3] = array_orientations[index, 3]
+    if array_scales.shape[0] > 0:
+        if broadcast_scales:
+            index = 0
+        else:
+            index = i
+        scale[0] = array_scales[index, 0]
+        scale[1] = array_scales[index, 1]
+        scale[2] = array_scales[index, 2]
+
+    fabric_matrices[view_index] = wp.mat44d(  # type: ignore[arg-type]
+        wp.transpose(wp.transform_compose(position, rotation, scale))  # type: ignore[arg-type]
+    )
+
+
+@wp.kernel(enable_backward=False)
+def update_indexed_local_matrix_from_world(
+    child_world_matrices: IndexedFabricArrayMat44d,
+    parent_world_matrices: IndexedFabricArrayMat44d,
+    child_local_matrices: IndexedFabricArrayMat44d,
+    indices: ArrayUInt32,
+):
+    """Recompute child localMatrix from (parent worldMatrix, child worldMatrix).
+
+    Computes ``child_local = inv(parent_world) * child_world`` per prim and writes the
+    result back to the child's :data:`omni:fabric:localMatrix` so that subsequent
+    ``get_local_poses`` calls see consistent values after a world-pose write.
+
+    All three indexed arrays are expected to be indexed by the same per-view indices
+    (i.e. ``view_to_child_fabric``, ``view_to_parent_fabric``, ``view_to_child_fabric``)
+    so the kernel only needs the view-side indices.
+
+    Storage convention: Fabric matrices are stored as the transpose of the standard
+    column-major math convention (translation in the bottom row).  We transpose into
+    math convention, do the inverse-multiply, and transpose back when writing.
+
+    Args:
+        child_world_matrices: Indexed fabric array of child world matrices (read).
+        parent_world_matrices: Indexed fabric array of parent world matrices (read).
+        child_local_matrices: Indexed fabric array of child local matrices (written).
+        indices: View indices to process.
+    """
+    i = wp.tid()
+    view_index = indices[i]
+    child_world_storage = wp.mat44f(child_world_matrices[view_index])
+    parent_world_storage = wp.mat44f(parent_world_matrices[view_index])
+    # Transpose into standard math convention (translation in the right column).
+    child_world = wp.transpose(child_world_storage)
+    parent_world = wp.transpose(parent_world_storage)
+    child_local = wp.inverse(parent_world) * child_world
+    # Transpose back to Fabric storage convention.
+    child_local_matrices[view_index] = wp.mat44d(wp.transpose(child_local))  # type: ignore[arg-type]
+
+
+@wp.kernel(enable_backward=False)
+def update_indexed_world_matrix_from_local(
+    child_local_matrices: IndexedFabricArrayMat44d,
+    parent_world_matrices: IndexedFabricArrayMat44d,
+    child_world_matrices: IndexedFabricArrayMat44d,
+    indices: ArrayUInt32,
+):
+    """Recompute child worldMatrix from (parent worldMatrix, child localMatrix).
+
+    Computes ``child_world = parent_world * child_local`` per prim and writes the
+    result back to the child's :data:`omni:fabric:worldMatrix`.  Used after a
+    ``set_local_poses`` write so that subsequent ``get_world_poses`` calls see
+    consistent values.  Mirror of :func:`update_indexed_local_matrix_from_world`.
+
+    Args:
+        child_local_matrices: Indexed fabric array of child local matrices (read).
+        parent_world_matrices: Indexed fabric array of parent world matrices (read).
+        child_world_matrices: Indexed fabric array of child world matrices (written).
+        indices: View indices to process.
+    """
+    i = wp.tid()
+    view_index = indices[i]
+    child_local_storage = wp.mat44f(child_local_matrices[view_index])
+    parent_world_storage = wp.mat44f(parent_world_matrices[view_index])
+    child_local = wp.transpose(child_local_storage)
+    parent_world = wp.transpose(parent_world_storage)
+    child_world = parent_world * child_local
+    child_world_matrices[view_index] = wp.mat44d(wp.transpose(child_world))  # type: ignore[arg-type]
+
+
 @wp.func
 def _decompose_transformation_matrix(m: Any):  # -> tuple[wp.vec3f, wp.quatf, wp.vec3f]
     """Decompose a 4x4 transformation matrix into position, orientation, and scale.

source/isaaclab_physx/changelog.d/fabric-frame-view-local-poses.rst

@@ -2,14 +2,24 @@ Fixed
 ^^^^^
 
 * Fixed :meth:`~isaaclab_physx.sim.views.FabricFrameView.get_local_poses`
-  returning stale USD values after Fabric world-pose writes. Local poses are
-  now computed from Fabric world matrices using the parent prim's USD world
-  transform.
+  returning stale USD values after Fabric world-pose writes.  Local poses
+  are now read directly from Fabric's ``omni:fabric:localMatrix`` via
+  :class:`wp.indexedfabricarray`, and are kept consistent with worldMatrix
+  through Warp kernels that propagate either direction on writes.
 
 Changed
 ^^^^^^^
 
+* Reworked :class:`~isaaclab_physx.sim.views.FabricFrameView` to follow
+  the prototype design from ``bareya/pbarejko/camera-update``: three
+  persistent ``PrimSelection`` instances (one per access mode), path-based
+  view → fabric index mapping (no custom prim attributes), and Warp kernels
+  that operate on :class:`wp.indexedfabricarray` so the kernels just index
+  ``ifa[view_index]`` instead of taking a separate mapping array.
 * :meth:`~isaaclab_physx.sim.views.FabricFrameView.set_local_poses` now
-  composes ``child_world = parent_world * local`` and writes the result
-  through Fabric, instead of routing the write to USD when Fabric is active
-  and synchronized.
+  writes ``omni:fabric:localMatrix`` directly through Fabric.  The next
+  ``get_world_poses`` runs a Warp kernel that recomputes
+  ``child_world = parent_world * child_local``.  Symmetrically,
+  ``set_world_poses`` runs a kernel that recomputes
+  ``child_local = inv(parent_world) * child_world`` so subsequent
+  ``get_local_poses`` calls return consistent values.