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
```

Author: MiCurry

arcade/camera/camera_2d.py

@@ -111,6 +111,10 @@ def __init__(
         # but we need to have some form of default size.
         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")
+
         width, height = viewport.size
         half_width = width / 2
         half_height = height / 2
@@ -148,7 +152,7 @@ def __init__(
             left=left, right=right, top=top, bottom=bottom, near=near, far=far
         )
 
-        self.viewport: Rect = viewport or LRBT(0, 0, width, height)
+        self._viewport: Rect = viewport or LRBT(0, 0, width, height)
         """
         A rect which describes how the final projection should be mapped
         from unit-space. defaults to the size of the render_target or window
@@ -264,7 +268,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
@@ -297,7 +301,7 @@ def project(self, world_coordinate: Point) -> Vec2:
 
         return project_orthographic(
             world_coordinate,
-            self.viewport.lbwh_int,
+            self._viewport.lbwh_int,
             _view,
             _projection,
         )
@@ -320,7 +324,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 equalise(self) -> None:
         """
@@ -444,7 +450,7 @@ def update_values(
             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
@@ -467,7 +473,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 = (
@@ -727,89 +733,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: