pyxora.camera

  1from .display import Display
  2from .wrapper.functions import vector
  3from .wrapper import Text,Image,Shape
  4
  5from math import log2
  6from typing import Tuple
  7
  8import pygame
  9
 10class Camera:
 11    """
 12    Camera class for the pyxora display environment.
 13    Handles position, zoom, and rendering of shapes, text, and images with camera-relative coordinates.
 14
 15    Note: Every Scene has a camera instance by default. You can create multiple instances but it's not recommended.
 16    """
 17
 18    def __init__(self) -> None:
 19        """Initialize the camera position, offset, zoom, and set initial zoom."""
 20        self._pos = vector(0, 0)
 21        self._offset = vector(0, 0)
 22        self._zoom_scale = 1
 23        self._zoom_factor = 0
 24        self._zoom_direction = 0
 25        self.__max_zoom_factor = 3
 26        self.zoom(1)
 27
 28    @property
 29    def surface(self) -> pygame.Surface:
 30        """Property to the current drawing surface."""
 31        return Display.surface
 32
 33    @property
 34    def position(self) -> pygame.math.Vector2:
 35        """Property to get a copy of the position of the camera."""
 36        return self._pos.copy()
 37
 38    @property
 39    def rect(self) -> pygame.Rect:
 40        """Property to get the camera's rectangle area as a pygame.Rect."""
 41        rect = pygame.Rect(self._pos + self._offset, Display._res)
 42        rect.width = int(rect.width / self.zoom_scale)
 43        rect.height = int(rect.height / self.zoom_scale)
 44        return rect
 45
 46    @property
 47    def zoom_scale(self) -> float:
 48        """Property to get the current zoom scale factor"""
 49        return self._zoom_scale
 50
 51    @property
 52    def zoom_factor(self) -> float:
 53        """Property to get the current log2 zoom factor"""
 54        return self._zoom_factor
 55
 56    @property
 57    def zoom_direction(self) -> float:
 58        """Property to get the current zoom direction."""
 59        return self._zoom_direction
 60
 61    @property
 62    def zoom_level(self) -> float:
 63        """Property to get the current zoom level."""
 64        if self.zoom_direction == 0 and self.zoom_factor == 0:
 65            return 1
 66        elif self.zoom_factor == 0:
 67            return 1
 68        elif self.zoom_factor >= 1:
 69            return self.zoom_factor + 1
 70        else:
 71            return self.zoom_factor - 1
 72
 73    def set_max_zoom(self, factor: float) -> None:
 74        """
 75        Set the maximum zoom factor for the camera.
 76
 77        Args:
 78            factor: The maximum zoom factor to set.
 79        """
 80        self.__max_zoom_factor = factor
 81
 82    def get_max_zoom(self) -> float:
 83        """
 84        Get the maximum zoom factor for the camera.
 85
 86        Returns:
 87            The maximum zoom factor.
 88        """
 89        return self.__max_zoom_factor
 90
 91    def is_visible(self, obj) -> bool:
 92        """
 93        Check if an object is at least partially visible on the screen (Requires object to have a rect attribute).
 94
 95        Args:
 96            obj: The object to check visibility for.
 97
 98        Returns:
 99            True if the object is visible, False otherwise.
100        """
101        return self.rect.colliderect(obj.rect)
102
103    def move(self, offset: Tuple[int | float, int | float] | pygame.math.Vector2) -> None:
104        """
105        Move the camera by a given offset (tuple or vector).
106
107        Args:
108            offset: The offset to move the camera by.
109        """
110        self._pos.x += offset[0]
111        self._pos.y += offset[1]
112
113    def move_at(self, new_pos: Tuple[int | float, int | float] | pygame.math.Vector2) -> None:
114        """
115        Move the camera to a specific position (centered).
116
117        Args:
118            new_pos: The new position to move the camera to.
119        """
120        self._pos.x = new_pos[0] + Display._res[0] / 2
121        self._pos.y = new_pos[1] + Display._res[1] / 2
122
123    def zoom(self, factor: int) -> None:
124        """
125        Zoom the camera by a given step, adjusting its scale.
126
127        Args:
128            factor: The zoom factor to apply.
129        """
130        if factor == 0:
131            return
132        factor = (factor + 1) if factor < 0 else (factor - 1)
133        scale = 2 ** (self.zoom_factor + factor)
134        self.zoom_at(scale)
135
136    def zoom_at(self, scale: float) -> None:
137        """
138        Set the camera zoom to a specific scale, centering the view.
139
140        Args:
141            scale: The scale to set the camera zoom to.
142        """
143        if not scale:
144            return
145        min_scale = 2 ** -self.__max_zoom_factor
146        max_scale = 2 ** self.__max_zoom_factor
147        scale = max(min_scale, min(max_scale, scale))
148        factor = log2(scale)
149        direction = factor - self._zoom_factor
150
151        # Center the camera based on the new zoom scale
152        sign = 1 if scale < 0 else -1
153        self._offset.x = 1 / scale * Display._res[0] / 2 * sign + Display._res[0] / 2
154        self._offset.y = 1 / scale * Display._res[1] / 2 * sign + Display._res[1] / 2
155
156        self._zoom_scale = scale
157        self._zoom_factor = factor
158        self._zoom_direction = direction
159
160    def draw_shape(self, Shape: Shape, fill: int = 0) -> None:
161        """Draw a shape on the camera's surface if it is visible."""
162        if not self.is_visible(Shape):
163            return
164
165        Shape._pos -= self._pos + self._offset
166        Shape._pos *= self._zoom_scale
167        Shape.draw(self.surface, fill, self._zoom_scale)
168        Shape._pos /= self._zoom_scale
169        Shape._pos += self._offset + self._pos
170
171    def draw_text(self, Txt: Text) -> None:
172        """Draw text on the camera's surface if it is visible."""
173        if not self.is_visible(Txt):
174            return
175
176        Txt._pos -= self._pos + self._offset
177        Txt._pos *= self._zoom_scale
178        Txt.draw(self.surface, self._zoom_scale)
179        Txt._pos /= self._zoom_scale
180        Txt._pos += self._offset + self._pos
181
182    def draw_image(self, Image: Image) -> None:
183        """Draw an image on the camera's surface if it is visible."""
184        if not self.is_visible(Image):
185            return
186
187        Image._pos -= self._pos + self._offset
188        Image._pos *= self._zoom_scale
189        Image.draw(self.surface, self._zoom_scale)
190        Image._pos /= self._zoom_scale
191        Image._pos += self._offset + self._pos
192
193    def _dynamic_zoom(self) -> None:
194        """Dynamically adjust the zoom based on the display's resolution."""
195        scale = min((Display._res[0] / Display._new_res[0]),(Display._res[1] / Display._new_res[1]))
196        self.zoom_at(scale)