Enhancements

* Drop redundant `fabric_device` local in `_initialize_fabric` — every
  assignment was `fabric_device = self._device`, so just use `self._device`
  directly. `self._fabric_device` (the persistent attribute) is preserved.
* Drop the explicit `_fabric_usd_sync_done = True` at the end of
  `_sync_fabric_from_usd_once`. Both `set_world_poses` and `set_scales`
  already set it on success, so the trailing assignment is dead under the
  happy path and would mask a partial failure if either write raised.
* Tighten the no-writeback assertion in
  `test_fabric_set_world_does_not_write_back_to_usd` from `atol=0.1` to
  `atol=0.0`. USD literally must not have moved — any drift indicates a
  residual writeback path, and the loose tolerance would hide a 0.099-unit
  regression.
* Add `test_fabric_rebuild_after_topology_change` covering the
  `_prepare_for_reuse` → `_rebuild_fabric_arrays` branch, which is the
  load-bearing replacement for the removed `sync_usd_on_fabric_write`.
  The test monkeypatches `_prepare_for_reuse` to always take the rebuild
  branch (real Fabric topology changes are hard to provoke from a unit
  test) and verifies that a subsequent write/read still produces correct
  data, proving `_view_to_fabric` and `_fabric_world_matrices` are still
  consistent after the rebuild.

Author: pv-nvidia

source/isaaclab/isaaclab/sensors/camera/camera.py

@@ -18,9 +18,9 @@
 import isaaclab.sim as sim_utils
 import isaaclab.utils.sensors as sensor_utils
 from isaaclab.app.settings_manager import get_settings_manager
-from isaaclab.renderers import BaseRenderer, Renderer
+from isaaclab.renderers import BaseRenderer, CameraRenderSpec
 from isaaclab.sim.views import FrameView
-from isaaclab.utils import has_kit, to_camel_case
+from isaaclab.utils import to_camel_case
 from isaaclab.utils.math import (
     convert_camera_frame_orientation_convention,
     create_rotation_matrix_from_view,

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

@@ -394,24 +394,22 @@ def _initialize_fabric(self) -> None:
         # The constructor should have taken care of this, but double check here to avoid regressions
         assert self._device in _fabric_supported_devices
 
-        fabric_device = self._device
-
         self._fabric_selection = fabric_stage.SelectPrims(
             require_attrs=[
                 (usdrt.Sdf.ValueTypeNames.UInt, self._view_index_attr, usdrt.Usd.Access.Read),
                 (usdrt.Sdf.ValueTypeNames.Matrix4d, "omni:fabric:worldMatrix", usdrt.Usd.Access.ReadWrite),
             ],
-            device=fabric_device,
+            device=self._device,
         )
 
-        self._view_to_fabric = wp.zeros((self.count,), dtype=wp.uint32, device=fabric_device)
+        self._view_to_fabric = wp.zeros((self.count,), dtype=wp.uint32, device=self._device)
         self._fabric_to_view = wp.fabricarray(self._fabric_selection, self._view_index_attr)
 
         wp.launch(
             kernel=fabric_utils.set_view_to_fabric_array,
             dim=self._fabric_to_view.shape[0],
             inputs=[self._fabric_to_view, self._view_to_fabric],
-            device=fabric_device,
+            device=self._device,
         )
         wp.synchronize()
 
@@ -423,13 +421,17 @@ def _initialize_fabric(self) -> None:
         self._fabric_dummy_buffer = wp.zeros((0, 3), dtype=wp.float32, device=self._device)
         self._fabric_world_matrices = wp.fabricarray(self._fabric_selection, "omni:fabric:worldMatrix")
         self._fabric_stage = fabric_stage
-        self._fabric_device = fabric_device
+        self._fabric_device = self._device
 
         self._fabric_initialized = True
         self._fabric_usd_sync_done = False
 
     def _sync_fabric_from_usd_once(self) -> None:
-        """Sync Fabric world matrices from USD once, on the first read."""
+        """Sync Fabric world matrices from USD once, on the first read.
+
+        ``set_world_poses`` and ``set_scales`` each set ``_fabric_usd_sync_done``
+        themselves, so no explicit flag assignment is needed here.
+        """
         if not self._fabric_initialized:
             self._initialize_fabric()
 
@@ -441,8 +443,6 @@ def _sync_fabric_from_usd_once(self) -> None:
         self.set_world_poses(positions_usd, orientations_usd)
         self.set_scales(scales_usd)
 
-        self._fabric_usd_sync_done = True
-
     def _resolve_indices_wp(self, indices: wp.array | None) -> wp.array:
         """Resolve view indices as a Warp uint32 array."""
         if indices is None or indices == slice(None):

source/isaaclab_physx/test/sim/test_views_xform_prim_fabric.py

@@ -174,12 +174,62 @@ def test_fabric_set_world_does_not_write_back_to_usd(device, view_factory):
         f"Fabric should have new position, got {pos_torch}"
     )
 
-    # Verify USD still has the ORIGINAL position (no writeback)
+    # Verify USD still has the ORIGINAL position (no writeback). Equality, not
+    # approximate — USD should literally not have moved, so any drift would
+    # indicate a residual writeback path.
     xform_cache_after = UsdGeom.XformCache()
     usd_tf_after = xform_cache_after.GetLocalToWorldTransform(prim)
     usd_t_after = usd_tf_after.ExtractTranslation()
     usd_pos_after = torch.tensor([float(usd_t_after[0]), float(usd_t_after[1]), float(usd_t_after[2])])
-    assert torch.allclose(usd_pos_after, orig_usd_pos, atol=0.1), (
+    assert torch.allclose(usd_pos_after, orig_usd_pos, atol=0.0), (
         f"USD should still have original position {orig_usd_pos}, but got {usd_pos_after}. "
         f"sync_usd_on_fabric_write may not have been fully removed."
     )
+
+
+@pytest.mark.parametrize("device", ["cpu", "cuda:0"])
+def test_fabric_rebuild_after_topology_change(device, view_factory, monkeypatch):
+    """Forcing the topology-changed branch on a write triggers
+    :meth:`_rebuild_fabric_arrays` and leaves the view in a state where
+    subsequent writes/reads still produce correct data.
+
+    Real ``PrimSelection.PrepareForReuse`` reports topology change only when
+    Fabric reallocates internally, which is hard to provoke from a unit test.
+    Instead we monkeypatch ``_prepare_for_reuse`` on the instance to always
+    take the rebuild branch and verify the view remains usable.
+    """
+    bundle = view_factory(2, device)
+    view = bundle.view
+
+    # First write — initializes Fabric and binds _fabric_selection.
+    initial = wp.zeros((2, 3), dtype=wp.float32, device=device)
+    wp.launch(kernel=_fill_position, dim=2, inputs=[initial, 1.0, 2.0, 3.0], device=device)
+    view.set_world_poses(positions=initial)
+
+    rebuild_calls = []
+    real_rebuild = view._rebuild_fabric_arrays
+
+    def spy_rebuild():
+        rebuild_calls.append(True)
+        real_rebuild()
+
+    def force_topology_changed():
+        if view._fabric_selection is not None:
+            view._fabric_selection.PrepareForReuse()
+            spy_rebuild()
+
+    monkeypatch.setattr(view, "_prepare_for_reuse", force_topology_changed)
+
+    # Trigger another write — goes through the forced topology-change branch.
+    new = wp.zeros((2, 3), dtype=wp.float32, device=device)
+    wp.launch(kernel=_fill_position, dim=2, inputs=[new, 4.0, 5.0, 6.0], device=device)
+    view.set_world_poses(positions=new)
+
+    assert rebuild_calls, "Forced topology-change branch did not invoke _rebuild_fabric_arrays"
+
+    # Read back — proves the rebuilt _view_to_fabric and _fabric_world_matrices
+    # are still consistent.
+    ret_pos, _ = view.get_world_poses()
+    pos_torch = wp.to_torch(ret_pos)
+    expected = torch.tensor([[4.0, 5.0, 6.0], [4.0, 5.0, 6.0]], device=device)
+    assert torch.allclose(pos_torch, expected, atol=1e-7), f"Read after rebuild failed on {device}: {pos_torch}"