Raise TypeError if Viewport is not a Rect and make Viewport (#2790)

* Make viewport a property/setter and raise TypeError if not a Rect

This commit makes viewport a property of Camera2D and adds a setter for it. In
the setter, and in __init__, we check that Viewport is a Rect and raise a
TypeError if it is not.

Without this check, an error will be raised after either calling
`Camera2D.equalise()` or in `Camera2D.use()`, which may confuse users as to why
the error is occurring.

Backtrace when calling `Camera2D.equalise()` with a non-rect viewport:

```
File "E:\Projects\SpaceGame\SpaceGame\gamemodes\basegame.py", line 128, in setup_two_player_cameras
    player_one_camera.equalise()
File "E:\Programs\python-arcade\arcade\camera\camera_2d.py", line 336, in equalise
    self._projection_data.rect = XYWH(x, y, self.viewport_width, self.viewport_height)
                                            ^^^^^^^^^^^^^^^^^^^
File "E:\Programs\python-arcade\arcade\camera\camera_2d.py", line 751, in viewport_width
    return int(self._viewport.width)
```

Backtrace when calling `Camera2D.use()` with a non-rect viewport:

```
File "E:\Projects\SpaceGame\SpaceGame\gamemodes\pvp.py", line 139, in on_draw
    self.cameras[player].use()
File "E:\Programs\python-arcade\arcade\camera\camera_2d.py", line 271, in use
    self._window.ctx.viewport = self._viewport.lbwh_int
```

* Refactor viewport assignment and type check in camera_2d.py

---------

Co-authored-by: Maic Siemering <[email protected]>

Author: MiCurry

arcade/camera/camera_2d.py

@@ -122,6 +122,9 @@ def __init__(
         render_target = render_target or self._window.ctx.screen
         viewport = viewport or LBWH(*render_target.viewport)
 
+        if not isinstance(viewport, Rect):
+            raise TypeError("viewport must be a Rect type,use arcade.LBWH or arcade.types.Viewport")
+
         if aspect is None:
             width, height = viewport.size
         elif aspect == 0.0:
@@ -135,6 +138,7 @@ def __init__(
             width = viewport.width
             height = viewport.width / aspect
         viewport = XYWH(viewport.x, viewport.y, width, height)
+
         half_width = width / 2
         half_height = height / 2
 
@@ -173,7 +177,8 @@ def __init__(
             left=left, right=right, top=top, bottom=bottom, near=near, far=far
         )
 
-        self.viewport: Rect = viewport
+        self.viewport = viewport
+
         """
         A rect which describes how the final projection should be mapped
         from unit-space. defaults to the size of the render_target or window
@@ -289,7 +294,7 @@ def use(self) -> None:
         _projection = generate_orthographic_matrix(self.projection_data, self.zoom)
         _view = generate_view_matrix(self.view_data)
 
-        self._window.ctx.viewport = self.viewport.lbwh_int
+        self._window.ctx.viewport = self._viewport.lbwh_int
         self._window.ctx.scissor = None if not self.scissor else self.scissor.lbwh_int
         self._window.projection = _projection
         self._window.view = _view
@@ -322,7 +327,7 @@ def project(self, world_coordinate: Point) -> Vec2:
 
         return project_orthographic(
             world_coordinate,
-            self.viewport.lbwh_int,
+            self._viewport.lbwh_int,
             _view,
             _projection,
         )
@@ -345,7 +350,9 @@ def unproject(self, screen_coordinate: Point) -> Vec3:
 
         _projection = generate_orthographic_matrix(self.projection_data, self.zoom)
         _view = generate_view_matrix(self.view_data)
-        return unproject_orthographic(screen_coordinate, self.viewport.lbwh_int, _view, _projection)
+        return unproject_orthographic(
+            screen_coordinate, self._viewport.lbwh_int, _view, _projection
+        )
 
     def equalize(self) -> None:
         """
@@ -470,8 +477,7 @@ def update_values(
                 h = value.width / aspect
             value = XYWH(value.x, value.y, w, h)
 
-        if viewport:
-            self.viewport = value
+        self.viewport = value
 
         if projection:
             x, y = self._projection_data.rect.x, self._projection_data.rect.y
@@ -498,7 +504,7 @@ def aabb(self) -> Rect:
         ux, uy, *_ = up
         rx, ry = uy, -ux  # up x Z'
 
-        l, r, b, t = self.viewport.lrbt
+        l, r, b, t = self._viewport.lrbt
         x, y = self.position
 
         x_points = (
@@ -881,89 +887,100 @@ def projection_far(self) -> float:
     def projection_far(self, new_far: float) -> None:
         self._projection_data.far = new_far
 
+    @property
+    def viewport(self) -> Rect:
+        return self._viewport
+
+    @viewport.setter
+    def viewport(self, viewport: Rect) -> None:
+        if not isinstance(viewport, Rect):
+            raise TypeError("viewport must be a Rect type,use arcade.LBWH or arcade.types.Viewport")
+
+        self._viewport = viewport
+
     @property
     def viewport_width(self) -> int:
         """
         The width of the viewport.
         Defines the number of pixels drawn too horizontally.
         """
-        return int(self.viewport.width)
+        return int(self._viewport.width)
 
     @viewport_width.setter
     def viewport_width(self, new_width: int) -> None:
-        self.viewport = self.viewport.resize(new_width, anchor=Vec2(0.0, 0.0))
+        self._viewport = self._viewport.resize(new_width, anchor=Vec2(0.0, 0.0))
 
     @property
     def viewport_height(self) -> int:
         """
         The height of the viewport.
         Defines the number of pixels drawn too vertically.
         """
-        return int(self.viewport.height)
+        return int(self._viewport.height)
 
     @viewport_height.setter
     def viewport_height(self, new_height: int) -> None:
-        self.viewport = self.viewport.resize(height=new_height, anchor=Vec2(0.0, 0.0))
+        self._viewport = self._viewport.resize(height=new_height, anchor=Vec2(0.0, 0.0))
 
     @property
     def viewport_left(self) -> int:
         """
         The left most pixel drawn to on the X axis.
         """
-        return int(self.viewport.left)
+        return int(self._viewport.left)
 
     @viewport_left.setter
     def viewport_left(self, new_left: int) -> None:
         """
         Set the left most pixel drawn to.
         This moves the position of the viewport, and does not change the size.
         """
-        self.viewport = self.viewport.align_left(new_left)
+        self._viewport = self._viewport.align_left(new_left)
 
     @property
     def viewport_right(self) -> int:
         """
         The right most pixel drawn to on the X axis.
         """
-        return int(self.viewport.right)
+        return int(self._viewport.right)
 
     @viewport_right.setter
     def viewport_right(self, new_right: int) -> None:
         """
         Set the right most pixel drawn to.
         This moves the position of the viewport, and does not change the size.
         """
-        self.viewport = self.viewport.align_right(new_right)
+        self._viewport = self._viewport.align_right(new_right)
 
     @property
     def viewport_bottom(self) -> int:
         """
         The bottom most pixel drawn to on the Y axis.
         """
-        return int(self.viewport.bottom)
+        return int(self._viewport.bottom)
 
     @viewport_bottom.setter
     def viewport_bottom(self, new_bottom: int) -> None:
         """
         Set the bottom most pixel drawn to.
         This moves the position of the viewport, and does not change the size.
         """
-        self.viewport = self.viewport.align_bottom(new_bottom)
+        self._viewport = self._viewport.align_bottom(new_bottom)
 
     @property
     def viewport_top(self) -> int:
         """
         The top most pixel drawn to on the Y axis.
         """
-        return int(self.viewport.top)
+        return int(self._viewport.top)
 
     @viewport_top.setter
     def viewport_top(self, new_top: int) -> None:
         """
         Set the top most pixel drawn to.
         This moves the position of the viewport, and does not change the size.
         """
-        self.viewport = self.viewport.align_top(new_top)
+        self._viewport = self._viewport.align_top(new_top)
 
     @property
     def up(self) -> Vec2: