feat: [Remote rendering 3.2a] server-tracked camera: record, load-path write, and re-serialization

doc/changelog.d/110.added.md

@@ -0,0 +1 @@
+[Remote rendering 3.2a] server-tracked camera: record, load-path write, and re-serialization

src/ansys/visor/viewer/renderer/base.py

@@ -179,18 +179,45 @@ def refresh_color_variable_range(
 
     @abstractmethod
     def reset_camera(self, bounds: list[float]) -> None:
-        """Reset the camera to fit *bounds*."""
+        """Reset the camera to fit *bounds*, and write the result to the record.
+
+        An implementation with no pipeline camera leaves the record at its
+        previous value rather than clearing it, so that a reset cannot destroy
+        a camera the frontend reported.
+        """
 
     @abstractmethod
     def get_camera_state(self) -> "VisorCameraState | None":
         """
-        Return the last camera state synced from the frontend, or ``None`` if
-        none has been received.
+        Return the camera record, or ``None`` if nothing has written one yet.
         """
 
     @abstractmethod
     def sync_camera(self, camera_state: "VisorCameraState") -> None:
-        """Store the camera state synced back from the frontend."""
+        """
+        Write *camera_state* to the record and project it onto the pipeline
+        camera.
+
+        The record stores the object as given, without copying: callers rely
+        on object identity through :meth:`get_camera_state`.
+        """
+
+    @abstractmethod
+    def serialize_camera_state(self) -> None:
+        """Make the state served to the client current for the camera.
+
+        The camera alone; the node pipelines are
+        :meth:`serialize_pipeline_states`'s job.  Writing the pipeline camera
+        makes the server correct: it does not make the state the client is
+        served correct, and the two are separate steps that can each silently
+        do nothing.
+
+        **Serialize only; do not notify.**  Pushing to the client is
+        :meth:`flush_wasm_state`'s job and carries a rebuild race that the
+        load path deliberately refuses.
+
+        No-op on a renderer that serves the client no VTK object state.
+        """
 
     # ------------------------------------------------------------------------
     # Widget control (cross-section, bounding box)

src/ansys/visor/viewer/renderer/local_renderer.py

@@ -28,6 +28,7 @@
 from ansys.visor.viewer.core.perf_timer import PerfTimer
 from ansys.visor.viewer.core.visor_colors import VisorColors
 from ansys.visor.viewer.core.visor_logging import VisorDefaultLogger
+from ansys.visor.viewer.models.common.visor_camera_state import VisorCameraState
 from ansys.visor.viewer.models.runtime.vtk.renderer_annotation import (
     WasmNodeHandles,
     WasmRendererAnnotation,
@@ -40,7 +41,6 @@
 from ansys.visor.viewer.vtk.widgets.visor_orientation import VisorOrientationWidget
 
 if TYPE_CHECKING:
-    from ansys.visor.viewer.models.common.visor_camera_state import VisorCameraState
     from ansys.visor.viewer.vtk.scene_graph import VisorSceneGraphPartNode
 
 logger = VisorDefaultLogger(__name__)
@@ -287,22 +287,82 @@ def refresh_color_variable_range(
     def reset_camera(self, bounds: list[float]) -> None:
         """See :meth:`IRenderer.reset_camera`."""
         self._vtk_renderer.ResetCamera(bounds)
+        self._last_camera_state = self._read_pipeline_camera()
 
     def get_camera_state(self) -> Optional["VisorCameraState"]:
-        """See :meth:`IRenderer.get_camera_state`.
-
-        Returns ``None`` on this branch: no coordinator caller and no
-        frontend round-trip populates the store.  Phase 3 wires the sync.
-        """
+        """See :meth:`IRenderer.get_camera_state`."""
         return self._last_camera_state
 
     def sync_camera(self, camera_state: "VisorCameraState") -> None:
         """See :meth:`IRenderer.sync_camera`.
 
-        Stores the state for :meth:`get_camera_state` to return.  No
-        coordinator caller on this branch; Phase 3 wires the round-trip.
+        Stores before projecting, so a raising VTK setter still leaves the
+        record holding what the earlier caller asked for.
         """
         self._last_camera_state = camera_state
+        self._apply_to_pipeline_camera(camera_state)
+
+    def serialize_camera_state(self) -> None:
+        """See :meth:`IRenderer.serialize_camera_state`.
+
+        ``vtklocal`` advertises each object's modification time off the live
+        VTK object but serves state out of a serialization cache, so a write
+        to the pipeline camera without this call publishes a new
+        version number against the old content: the client fetches the
+        pre-write camera and applies it over the one just installed.
+
+        ``UpdateStateFromObject`` re-serializes the single already-registered
+        id it is given and commits its dependency edges again; a mid-tree node
+        re-serialized on its own stays reachable from its parent, so naming
+        one id is safe.  It is narrower than ``UpdateStatesFromObjects``,
+        which serializes from the roots it is given and registers objects the
+        store has not seen: an id the store has never held answers ``GetId``
+        ``0``, the ROOT sentinel, and the call degrades to an error-logged
+        no-op.
+
+        No ``js_call``: that lives in ``LocalView.update``, so this
+        serialises without re-opening the rebuild race
+        ``_push_runtime_state`` refuses.
+        """
+        self._object_manager.UpdateStateFromObject(
+            self._object_manager.GetId(self._vtk_renderer.GetActiveCamera())
+        )
+
+    # ------------------------------------------------------------------
+    # Pipeline camera helpers
+    #
+    # Neither takes a lock.  The caller-holds convention applies exactly as
+    # it does to every other IRenderer method: the scene coordinator holds
+    # ``VisorSceneBase._vtk_lock`` across every path that reaches these.
+    # ------------------------------------------------------------------
+
+    def _read_pipeline_camera(self) -> VisorCameraState:
+        """Read the active pipeline camera into a fresh camera state.
+
+        ``GetParallelProjection`` returns an ``int``; the explicit ``bool()``
+        keeps the field's type off pydantic's non-strict coercion.
+        """
+        camera = self._vtk_renderer.GetActiveCamera()
+        return VisorCameraState(
+            position=list(camera.GetPosition()),
+            focal_point=list(camera.GetFocalPoint()),
+            view_up=list(camera.GetViewUp()),
+            clipping_range=list(camera.GetClippingRange()),
+            parallel_projection=bool(camera.GetParallelProjection()),
+            view_angle=camera.GetViewAngle(),
+            parallel_scale=camera.GetParallelScale(),
+        )
+
+    def _apply_to_pipeline_camera(self, camera_state: "VisorCameraState") -> None:
+        """Write *camera_state*'s onto the active pipeline camera."""
+        camera = self._vtk_renderer.GetActiveCamera()
+        camera.SetPosition(camera_state.position)
+        camera.SetFocalPoint(camera_state.focal_point)
+        camera.SetViewUp(camera_state.view_up)
+        camera.SetClippingRange(camera_state.clipping_range)
+        camera.SetParallelProjection(camera_state.parallel_projection)
+        camera.SetViewAngle(camera_state.view_angle)
+        camera.SetParallelScale(camera_state.parallel_scale)
 
     # ------------------------------------------------------------------
     # IRenderer: widget control (cross-section, bounding box)

src/ansys/visor/viewer/renderer/null_renderer.py

@@ -6,12 +6,17 @@
 Implements every abstract method as a no-op so that the scene coordinator can
 be unit-tested without a VTK environment.  Methods whose return type is
 annotated return the simplest valid empty value for that type; all others are
-``pass``.  No VTK imports, no local view, no side effects, no state.
+``pass``.  No VTK imports, no local view, no side effects.
+
+One exception to "no state": the camera record, ``_last_camera_state``.  The
+record half of the :class:`IRenderer` camera contract is not optional on any
+implementation -- only the projection half is, and here it is a no-op because
+there is no pipeline camera to project onto.
 """
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from ansys.visor.viewer.renderer.base import IRenderer
 
@@ -25,6 +30,12 @@
 class NullRenderer(IRenderer):
     """Null-object implementation of :class:`IRenderer` for use in tests."""
 
+    _last_camera_state: Optional["VisorCameraState"]
+
+    def __init__(self) -> None:
+        """Initialize the camera record."""
+        self._last_camera_state = None
+
     # ------------------------------------------------------------------
     # Wire contract
     # ------------------------------------------------------------------
@@ -101,13 +112,27 @@ def refresh_color_variable_range(
     # ------------------------------------------------------------------
 
     def reset_camera(self, bounds: list[float]) -> None:
-        pass
+        """See :meth:`IRenderer.reset_camera`.
+
+        Deliberately does not write the record: with no pipeline camera there
+        is nothing to derive a camera for *bounds* from, and clearing it would
+        destroy a camera the frontend reported.
+        """
 
     def get_camera_state(self) -> "VisorCameraState | None":
-        return None
+        """See :meth:`IRenderer.get_camera_state`."""
+        return self._last_camera_state
 
     def sync_camera(self, camera_state: "VisorCameraState") -> None:
-        pass
+        """See :meth:`IRenderer.sync_camera`."""
+        self._last_camera_state = camera_state
+
+    def serialize_camera_state(self) -> None:
+        """See :meth:`IRenderer.serialize_camera_state`.
+
+        No-op: this renderer serves the client no VTK object state.
+        """
+
 
     # ------------------------------------------------------------------
     # Widget control (cross-section, bounding box)

src/ansys/visor/viewer/vtk/scene/base.py

@@ -48,7 +48,7 @@ class VisorSceneBase(ABC):
 
     * :meth:`_get_runtime_state_async` — wasm path does a frontend round-trip;
       RCA/headless paths build state server-side.
-    * :meth:`_apply_runtime_state_to_render` — wasm path calls a JS
+    * :meth:`_push_runtime_state` — wasm path calls a JS
       ``set_state``; RCA path pushes camera onto ``vtkCamera``; headless
       is a no-op.
 
@@ -117,7 +117,7 @@ async def _get_runtime_state_async(self, timeout: float) -> "RuntimeAppState":
         """
 
     @abstractmethod
-    def _apply_runtime_state_to_render(self, runtime_app_state: "RuntimeAppState") -> None:
+    def _push_runtime_state(self, runtime_app_state: "RuntimeAppState") -> None:
         """
         Push a runtime app state onto the renderer / frontend after the
         shared per-part state has already been restored.
@@ -174,14 +174,14 @@ def apply_state(self, state: PersistedViewerStateV1):
         """
         Apply a saved viewer state.
 
-        Shared work (per-part state restoration) is done here; the
-        renderer-specific final step is delegated to
-        :meth:`_apply_runtime_state_to_render`.
+        One ``_restore_*`` step per state class, each making the server's own
+        copy of that class match the loaded state: its stored state, and the
+        VTK objects that the state drives.
 
-        Holds ``_vtk_lock`` for the whole body: the delegated step mutates
-        VTK and pushes to the frontend.  The critical section deliberately
-        spans the outbound bridge call and the flush that follows it — the
-        unit the lock protects is the compound sequence, not the VTK work.
+        The renderer-speific delivery step is delegated to :meth:`_push_runtime_state`,
+        and runs last, once every record above it has been written.
+
+        Holds ``_vtk_lock`` for the whole body, including the delegated render step.
         """
         with self._vtk_lock:
             # Apply UI settings
@@ -190,9 +190,14 @@ def apply_state(self, state: PersistedViewerStateV1):
             # Transform the frontend PersistedViewerStateV1 -> RuntimeAppState
             runtime_app_state = self._state_mapper.persisted_to_runtime(state)
 
-            self._restore_part_states_from_runtime(runtime_app_state)
+            # One call per state class: updates the server's stored state and its VTK objects.
+            self._restore_part_states(runtime_app_state)
+            self._restore_camera_state(runtime_app_state)
+            # TODO: restore widget state, UI state, and variable states when they are synced back to the server.
 
-            self._apply_runtime_state_to_render(runtime_app_state)
+            # The server's copy is now current; deliver it to the rendering backend.
+            # wasm: set_state() to the browser; RCA: a rendered frame; headless: no-op.
+            self._push_runtime_state(runtime_app_state)
 
             # Note: There is intentionally no wasm flush here: the bridge call is fire-and-forget, so a flush
             # at this point races the client's rebuild against a half-written object graph.
@@ -393,6 +398,7 @@ def reset_camera(self):
                 return
 
             self._renderer.reset_camera(self._scene_graph.bounds)
+            self._renderer.serialize_camera_state()
 
     def pick_geometry(self, actor_wasm_id, cell_id, mode, world_x, world_y, world_z) -> dict:
         """
@@ -518,7 +524,7 @@ def clear_part_color_variable(self, node_id: int) -> None:
                 return
             self._renderer.clear_color_variable(node_id)
 
-    def _restore_part_states_from_runtime(self, runtime_app_state: "RuntimeAppState") -> None:
+    def _restore_part_states(self, runtime_app_state: "RuntimeAppState") -> None:
         """
         Restore per-part state from a runtime app state, on the load path.
 
@@ -538,7 +544,7 @@ def _restore_part_states_from_runtime(self, runtime_app_state: "RuntimeAppState"
             dataset = self._dataset_registry.datasets.get(dataset_id)
             if dataset is None:
                 logger.warning(
-                    "_restore_part_states_from_runtime: dataset %s is not registered; "
+                    "_restore_part_states: dataset %s is not registered; "
                     "its part state was not applied to the pipeline.", dataset_id
                 )
                 continue
@@ -554,6 +560,22 @@ def _restore_part_states_from_runtime(self, runtime_app_state: "RuntimeAppState"
                     part_id, part_state, variable_states, variables_by_part.get(part_id)
                 )
 
+    def _restore_camera_state(self, runtime_app_state: "RuntimeAppState") -> None:
+        """
+        Restore the camera state from a runtime app state, on the load path.
+
+        Write the loaded camera to the record and the pipeline camera, so a client rebuilt
+        from server state (refresh) gets it.  Must precede the render step.  The re-serialize
+        is required: the server advertises the camera's live MTime but serves its cached state,
+        so without it a client fetches the pre-load camera.  A state with no camera leaves both
+        alone.
+
+        Callers must hold ``_vtk_lock``.
+        """
+        if runtime_app_state.scene.camera is not None:
+            self._renderer.sync_camera(runtime_app_state.scene.camera)
+            self._renderer.serialize_camera_state()
+
     def _restore_one_part_state(
             self,
             part_id: int,

src/ansys/visor/viewer/vtk/scene/local_scene.py

@@ -50,7 +50,7 @@ async def _get_runtime_state_async(self, timeout: float) -> "RuntimeAppState":
         response = await self._frontend_bridge.request_state(timeout=timeout)
         return response.app_state
 
-    def _apply_runtime_state_to_render(self, runtime_app_state: "RuntimeAppState") -> None:
+    def _push_runtime_state(self, runtime_app_state: "RuntimeAppState") -> None:
         """
         Flush the VTK window then push the restored state to the React frontend.
 

src/ansys/visor/viewer/vtk/scene/visor_state_mapper.py

@@ -76,7 +76,7 @@ def persisted_to_runtime(self, state: PersistedViewerStateV1) -> RuntimeAppState
 
         Returns the runtime dataset states on the ``RuntimeAppState``; it does not
         assign them to ``VisorDataset.state``.  The registry is populated by
-        :meth:`VisorSceneBase._restore_part_states_from_runtime`.
+        :meth:`VisorSceneBase._restore_part_states`.
 
         """
         # UI settings

tests/e2e/regressions/test_save_load_state.py

@@ -11,6 +11,7 @@
 """
 
 import json
+import sys
 from pathlib import Path
 
 import pytest
@@ -142,6 +143,14 @@ def test_save_load_state_file_content_valid(self, visor_server, page, tmp_path):
                 f"Dataset '{name}' has empty serialized_dataset_path"
             )
 
+    @pytest.mark.xfail(
+        sys.platform != "win32",
+        run=False,
+        reason="#122: load_state into an empty scene does not render on "
+        "Linux, and the shared server is not recoverable afterwards, "
+        "so stopping this test from running there.  The post-load checks "
+        "pass on the failing state, which is why this was not caught earlier."
+    )
     def test_load_state_into_empty_scene(self, visor_server, page, tmp_path):
         """Loading state into an empty scene should restore datasets from snapshots.
 

tests/integration/test_save_load_state.py

@@ -471,7 +471,7 @@ def test_reloading_the_saved_state_restores_the_registry(self, file_io, iface, t
 
         # No browser: the bridge push and the wasm flush are not exercised
         # in-process.  The registry restore must not depend on either.
-        iface._scene._apply_runtime_state_to_render = MagicMock()
+        iface._scene._push_runtime_state = MagicMock()
         iface._scene._renderer.flush_wasm_state = MagicMock()
 
         assert iface._scene.dataset_count == 0