move viewport projector to it's own file to hopefully improve it's visibility

Author: DragonMoffon

arcade/camera/__init__.py

@@ -23,6 +23,7 @@
 
 from arcade.camera.orthographic import OrthographicProjector
 from arcade.camera.perspective import PerspectiveProjector
+from arcade.camera.viewport import ViewportProjector
 
 from arcade.camera.camera_2d import Camera2D
 
@@ -33,6 +34,7 @@
     "Projection",
     "Projector",
     "CameraData",
+    "ViewportProjector",
     "generate_view_matrix",
     "OrthographicProjectionData",
     "generate_orthographic_matrix",

arcade/camera/viewport.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import TYPE_CHECKING
+
+from pyglet.math import Mat4, Vec2, Vec3
+from typing_extensions import Self
+
+from arcade.types import LBWH, Point, Rect
+from arcade.window_commands import get_window
+from arcade.camera.data_types import DEFAULT_NEAR_ORTHO, DEFAULT_FAR
+
+if TYPE_CHECKING:
+    from arcade.context import ArcadeContext
+
+__all__ = ["ViewportProjector"]
+
+
+class ViewportProjector:
+    """
+    A simple Projector which does not rely on any camera PoDs.
+
+    Does not have a way of moving, rotating, or zooming the camera.
+    perfect for something like UI or for mapping to an offscreen framebuffer.
+
+    Args:
+        viewport: The viewport to project to.
+        context: The window context to bind the camera to. Defaults to the currently active window.
+    """
+
+    def __init__(
+        self,
+        viewport: Rect | None = None,
+        *,
+        context: ArcadeContext | None = None,
+    ):
+        self._ctx: ArcadeContext = context or get_window().ctx
+        self._viewport: Rect = viewport or LBWH(*self._ctx.viewport)
+        self._projection_matrix: Mat4 = Mat4.orthogonal_projection(
+            0.0, self.viewport.width, 0.0, self.viewport.height, DEFAULT_NEAR_ORTHO, DEFAULT_FAR
+        )
+
+    @property
+    def viewport(self) -> Rect | None:
+        """
+        The viewport use to derive projection and view matrix.
+        """
+        return self._viewport
+
+    @viewport.setter
+    def viewport(self, viewport: Rect) -> None:
+        self._viewport = viewport
+        self._projection_matrix = Mat4.orthogonal_projection(
+            0, viewport.width, 0, viewport.height, DEFAULT_NEAR_ORTHO, DEFAULT_FAR
+        )
+
+    def use(self) -> None:
+        """
+        Set the window's projection and view matrix.
+        Also sets the projector as the windows current camera.
+        """
+        self._ctx.current_camera = self
+
+        if self.viewport:
+            self._ctx.viewport = self.viewport.lbwh_int
+
+        self._ctx.view_matrix = Mat4()
+        self._ctx.projection_matrix = self._projection_matrix
+
+    @contextmanager
+    def activate(self) -> Generator[Self, None, None]:
+        """
+        The context manager version of the use method.
+
+        usable with the 'with' block. e.g. 'with ViewportProjector.activate() as cam: ...'
+        """
+        previous = self._ctx.current_camera
+        previous_viewport = self._ctx.viewport
+        try:
+            self.use()
+            yield self
+        finally:
+            self._ctx.viewport = previous_viewport
+            previous.use()
+
+    def project(self, world_coordinate: Point) -> Vec2:
+        """
+        Take a Vec2 or Vec3 of coordinates and return the related screen coordinate
+        """
+        x, y, *z = world_coordinate
+        return Vec2(x, y)
+
+    def unproject(self, screen_coordinate: Point) -> Vec3:
+        """
+        Map the screen pos to screen_coordinates.
+
+        Due to the nature of viewport projector this does not do anything.
+        """
+        x, y, *_z = screen_coordinate
+        z = 0.0 if not _z else _z[0]
+
+        return Vec3(x, y, z)