forked from genewildish/Mainline
David Gwilliam
14d622f0d6
- Add save_state/restore_state methods to CameraStage - Add save_state/restore_state methods to DisplayStage - Extend Pipeline._copy_stage_state() to preserve camera/display state - Add save_state/restore_state methods to UIPanel for UI state preservation - Update pipeline_runner to preserve UI state across preset changes Camera state preserved: - Position (x, y) - Mode (feed, scroll, horizontal, etc.) - Speed, zoom, canvas dimensions - Internal timing state Display state preserved: - Initialization status - Dimensions - Reuse flag for display reinitialization UI Panel state preserved: - Stage enabled/disabled status - Parameter values - Selected stage and focused parameter - Scroll position This enables manual/event-driven rebuilds when inlet-outlet connections change, while preserving all relevant state across pipeline mutations.
111 lines
3.6 KiB
Python
111 lines
3.6 KiB
Python
"""Adapter for camera stage."""
|
|
|
|
import time
|
|
from typing import Any
|
|
|
|
from engine.pipeline.core import DataType, PipelineContext, Stage
|
|
|
|
|
|
class CameraStage(Stage):
|
|
"""Adapter wrapping Camera as a Stage."""
|
|
|
|
def __init__(self, camera, name: str = "vertical"):
|
|
self._camera = camera
|
|
self.name = name
|
|
self.category = "camera"
|
|
self.optional = True
|
|
self._last_frame_time: float | None = None
|
|
|
|
def save_state(self) -> dict[str, Any]:
|
|
"""Save camera state for restoration after pipeline rebuild.
|
|
|
|
Returns:
|
|
Dictionary containing camera state that can be restored
|
|
"""
|
|
return {
|
|
"x": self._camera.x,
|
|
"y": self._camera.y,
|
|
"mode": self._camera.mode.value
|
|
if hasattr(self._camera.mode, "value")
|
|
else self._camera.mode,
|
|
"speed": self._camera.speed,
|
|
"zoom": self._camera.zoom,
|
|
"canvas_width": self._camera.canvas_width,
|
|
"canvas_height": self._camera.canvas_height,
|
|
"_x_float": getattr(self._camera, "_x_float", 0.0),
|
|
"_y_float": getattr(self._camera, "_y_float", 0.0),
|
|
"_time": getattr(self._camera, "_time", 0.0),
|
|
}
|
|
|
|
def restore_state(self, state: dict[str, Any]) -> None:
|
|
"""Restore camera state from saved state.
|
|
|
|
Args:
|
|
state: Dictionary containing camera state from save_state()
|
|
"""
|
|
from engine.camera import CameraMode
|
|
|
|
self._camera.x = state.get("x", 0)
|
|
self._camera.y = state.get("y", 0)
|
|
|
|
# Restore mode - handle both enum value and direct enum
|
|
mode_value = state.get("mode", 0)
|
|
if isinstance(mode_value, int):
|
|
self._camera.mode = CameraMode(mode_value)
|
|
else:
|
|
self._camera.mode = mode_value
|
|
|
|
self._camera.speed = state.get("speed", 1.0)
|
|
self._camera.zoom = state.get("zoom", 1.0)
|
|
self._camera.canvas_width = state.get("canvas_width", 200)
|
|
self._camera.canvas_height = state.get("canvas_height", 200)
|
|
|
|
# Restore internal state
|
|
if hasattr(self._camera, "_x_float"):
|
|
self._camera._x_float = state.get("_x_float", 0.0)
|
|
if hasattr(self._camera, "_y_float"):
|
|
self._camera._y_float = state.get("_y_float", 0.0)
|
|
if hasattr(self._camera, "_time"):
|
|
self._camera._time = state.get("_time", 0.0)
|
|
|
|
@property
|
|
def stage_type(self) -> str:
|
|
return "camera"
|
|
|
|
@property
|
|
def capabilities(self) -> set[str]:
|
|
return {"camera"}
|
|
|
|
@property
|
|
def dependencies(self) -> set[str]:
|
|
return {"render.output"}
|
|
|
|
@property
|
|
def inlet_types(self) -> set:
|
|
return {DataType.TEXT_BUFFER}
|
|
|
|
@property
|
|
def outlet_types(self) -> set:
|
|
return {DataType.TEXT_BUFFER}
|
|
|
|
def process(self, data: Any, ctx: PipelineContext) -> Any:
|
|
"""Apply camera transformation to items."""
|
|
if data is None:
|
|
return data
|
|
|
|
current_time = time.perf_counter()
|
|
dt = 0.0
|
|
if self._last_frame_time is not None:
|
|
dt = current_time - self._last_frame_time
|
|
self._camera.update(dt)
|
|
self._last_frame_time = current_time
|
|
|
|
ctx.set_state("camera_y", self._camera.y)
|
|
ctx.set_state("camera_x", self._camera.x)
|
|
|
|
if hasattr(self._camera, "apply"):
|
|
viewport_width = ctx.params.viewport_width if ctx.params else 80
|
|
viewport_height = ctx.params.viewport_height if ctx.params else 24
|
|
return self._camera.apply(data, viewport_width, viewport_height)
|
|
return data
|