Updating the default projector to behave better with changing framebuffer

Author: DragonMoffon

arcade/camera/default.py

@@ -9,62 +9,115 @@
 
 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", "DefaultProjector"]
+__all__ = ()
 
 
-class ViewportProjector:
+class DefaultProjector:
     """
-    A simple Projector which does not rely on any camera PoDs.
+    An extremely limited projector which lacks any kind of control. This is only
+    here to act as the default camera used internally by Arcade. There should be
+    no instance where a developer would want to use this class.
+
+    The default viewport tries it's best to allow
+    simple usecases with no need to use a camera.
 
-    Does not have a way of moving, rotating, or zooming the camera.
-    perfect for something like UI or for mapping to an offscreen framebuffer.
+    It does this by defaulting to the size of the active
+    framebuffer. If the user sets the framebuffer's viewport
+    without a camera then the default camera will match it
+    until the framebuffer is changed again.
 
     Args:
-        viewport: The viewport to project to.
-        context: The window context to bind the camera to. Defaults to the currently active window.
+        context: The window context to bind the camera to. Defaults to the currently active context.
     """
 
-    def __init__(
-        self,
-        viewport: Rect | None = None,
-        *,
-        context: ArcadeContext | None = None,
-    ):
+    def __init__(self, *, 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, -100, 100
-        )
+        self._viewport: Rect | None = None
+        self._scissor: Rect | None = None
+        self._matrix: Mat4 | None = None
 
-    @property
-    def viewport(self) -> Rect:
+    def update_viewport(self):
         """
-        The viewport use to derive projection and view matrix.
+        Called when the ArcadeContext's viewport or active
+        framebuffer has been set. It only actually updates
+        the viewport if no other camera is active. Also
+        setting the viewport to match the size of the active
+        framebuffer sets the viewport to None.
         """
+        if self._ctx.current_camera != self:
+            return
+        if self._ctx.viewport[2] != self.width or self._ctx.viewport[3] != self.height:
+            self._viewport = LBWH(*self._ctx.viewport)
+        self._viewport = None
+
+        self.use()
+
+    @property
+    def viewport(self) -> Rect | None:
         return self._viewport
 
     @viewport.setter
-    def viewport(self, viewport: Rect) -> None:
+    def viewport(self, viewport: Rect | None) -> None:
+        if viewport == self._viewport:
+            return
         self._viewport = viewport
-        self._projection_matrix = Mat4.orthogonal_projection(
-            0, viewport.width, 0, viewport.height, -100, 100
+        self._matrix = Mat4.orthogonal_projection(
+            0, self.width, 0, self.height, DEFAULT_NEAR_ORTHO, DEFAULT_FAR
         )
 
+    @viewport.deleter
+    def viewport(self):
+        self.viewport = None
+
+    @property
+    def scissor(self) -> Rect | None:
+        return self._scissor
+
+    @scissor.setter
+    def scissor(self, scissor: Rect | None) -> None:
+        self._scissor = scissor
+
+    @scissor.deleter
+    def scissor(self) -> None:
+        self._scissor = None
+
+    @property
+    def width(self) -> int:
+        if self._viewport is not None:
+            return int(self._viewport.width)
+        return self._ctx.active_framebuffer.width
+
+    @property
+    def height(self) -> int:
+        if self._viewport is not None:
+            return int(self._viewport.height)
+        return self._ctx.active_framebuffer.height
+
     def use(self) -> None:
         """
-        Set the window's projection and view matrix.
-        Also sets the projector as the windows current camera.
+        Set the window's Projection and View matrices.
         """
-        self._ctx.current_camera = self
 
-        self._ctx.viewport = self.viewport.lbwh_int  # get the integer 4-tuple LBWH
+        viewport = (0, 0, self.width, self.height)
+        # If the viewport is correct and the default camera is in use,
+        # then don't waste time resetting the view and projection matrices
+        if self._ctx.viewport == viewport and self._ctx.current_camera == self:
+            return
+
+        self._ctx.current_camera = self
+        self._ctx.viewport = viewport
 
         self._ctx.view_matrix = Mat4()
-        self._ctx.projection_matrix = self._projection_matrix
+        if self._matrix is None:
+            self._matrix = Mat4.orthogonal_projection(
+                0, 0, viewport[2], viewport[3], DEFAULT_NEAR_ORTHO, DEFAULT_FAR
+            )
+        self._ctx.projection_matrix = self._matrix
 
     @contextmanager
     def activate(self) -> Generator[Self, None, None]:
@@ -74,10 +127,12 @@ def activate(self) -> Generator[Self, None, None]:
         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:
@@ -97,46 +152,3 @@ def unproject(self, screen_coordinate: Point) -> Vec3:
         z = 0.0 if not _z else _z[0]
 
         return Vec3(x, y, z)
-
-
-# As this class is only supposed to be used internally
-# I wanted to place an _ in front, but the linting complains
-# about it being a protected class.
-class DefaultProjector(ViewportProjector):
-    """
-    An extremely limited projector which lacks any kind of control. This is only
-    here to act as the default camera used internally by Arcade. There should be
-    no instance where a developer would want to use this class.
-
-    Args:
-        context: The window context to bind the camera to. Defaults to the currently active window.
-    """
-
-    def __init__(self, *, context: ArcadeContext | None = None):
-        super().__init__(context=context)
-
-    def use(self) -> None:
-        """
-        Set the window's Projection and View matrices.
-
-        cache's the window viewport to determine the projection matrix.
-        """
-
-        viewport = self.viewport.lbwh_int
-        # If the viewport is correct and the default camera is in use,
-        # then don't waste time resetting the view and projection matrices
-        if self._ctx.viewport == viewport and self._ctx.current_camera == self:
-            return
-
-        # If the viewport has changed while the default camera is active then the
-        # default needs to update itself.
-        # If it was another camera's viewport being used the default camera should not update.
-        if self._ctx.viewport != viewport and self._ctx.current_camera == self:
-            self.viewport = LBWH(*self._ctx.viewport)
-        else:
-            self._ctx.viewport = viewport
-
-        self._ctx.current_camera = self
-
-        self._ctx.view_matrix = Mat4()
-        self._ctx.projection_matrix = self._projection_matrix

arcade/context.py

@@ -372,6 +372,15 @@ def default_atlas(self) -> TextureAtlasBase:
 
         return self._atlas
 
+    @property
+    def active_framebuffer(self):
+        return self._active_framebuffer
+
+    @active_framebuffer.setter
+    def active_framebuffer(self, framebuffer: Framebuffer):
+        self._active_framebuffer = framebuffer
+        self._default_camera.update_viewport()
+
     @property
     def viewport(self) -> tuple[int, int, int, int]:
         """
@@ -393,8 +402,7 @@ def viewport(self) -> tuple[int, int, int, int]:
     @viewport.setter
     def viewport(self, value: tuple[int, int, int, int]):
         self.active_framebuffer.viewport = value
-        if self._default_camera == self.current_camera:
-            self._default_camera.use()
+        self._default_camera.update_viewport()
 
     @property
     def projection_matrix(self) -> Mat4:

arcade/gl/context.py

@@ -221,7 +221,7 @@ def __init__(
         # Tracking active program
         self.active_program: Program | ComputeShader | None = None
         # Tracking active framebuffer. On context creation the window is the default render target
-        self.active_framebuffer: Framebuffer = self._screen
+        self._active_framebuffer: Framebuffer = self._screen
         self._stats: ContextStats = ContextStats(warn_threshold=1000)
 
         self._primitive_restart_index = -1
@@ -327,7 +327,18 @@ def fbo(self) -> Framebuffer:
         """
         Get the currently active framebuffer (read only).
         """
-        return self.active_framebuffer
+        return self._active_framebuffer
+
+    @property
+    def active_framebuffer(self) -> Framebuffer:
+        """
+        Get the currently active framebuffer.
+        """
+        return self._active_framebuffer
+
+    @active_framebuffer.setter
+    def active_framebuffer(self, framebuffer: Framebuffer) -> None:
+        self._active_framebuffer = framebuffer
 
     def gc(self) -> int:
         """