Created a camera shake class

Created a camera shake class. It isn't exactly like the shake provided before so people might what to have a review.

Author: DragonMoffon

arcade/camera/camera_2d.py

@@ -51,7 +51,6 @@ class Camera2D:
     :param ProjectionData projection_data: A data class which holds all the data needed to define the projection of
                                            the camera.
     """
-    # TODO: ADD PARAMS TO DOC FOR __init__
 
     def __init__(self, *,
                  window: Optional["Window"] = None,
@@ -116,7 +115,6 @@ def data(self) -> CameraData:
         If you use any of the built-in arcade camera-controllers
         or make your own this is the property to access.
         """
-        # TODO: Do not add setter
         return self._data
 
     @property
@@ -134,7 +132,6 @@ def projection_data(self) -> OrthographicProjectionData:
         most use cases will only change the projection
         on screen resize.
         """
-        # TODO: Do not add setter
         return self._projection
 
     @property

arcade/camera/controllers/input_controllers.py renamed to arcade/camera/controllers/debug_controller.py

@@ -1,4 +1,4 @@
-# TODO: Are 2D and 3D versions of a very simple controller
+# TODO: Add 2D and 3D versions of a polled input controller
 #  intended to be used for debugging.
 from typing import TYPE_CHECKING, Tuple, Optional
 from copy import deepcopy

arcade/camera/controllers/isometric_controller.py

@@ -24,7 +24,7 @@ def __init__(self, camera_data: CameraData,
         self._up: Tuple[float, float, float] = up
         self._right: Tuple[float, float, float] = right
 
-    def update_position(self):
+    def update_camera(self):
         # Ref: https://danceswithcode.net/engineeringnotes/quaternions/quaternions.html
         _pos_rads = radians(26.565 if self._pixel_angle else 30.0)
         _c, _s = cos(_pos_rads), sin(_pos_rads)

arcade/camera/controllers/simple_controller_classes.py

@@ -0,0 +1,264 @@
+from typing import TYPE_CHECKING, Optional, Tuple
+from math import e, sin, cos, radians, pi, log
+from random import uniform
+
+from arcade.camera.data import CameraData
+from arcade.window_commands import get_window
+
+if TYPE_CHECKING:
+    from arcade.application import Window
+
+
+class ScreenShaker2D:
+    """
+    Uses the equation Ae^{-fx}sin(v 2 pi x) to create shake effect which falls off over time.
+
+    where:
+        A is the amplitude (size)
+        f is the falloff
+        v is the speed
+        x is the time since start
+        e is euler's constant
+    """
+
+    stop_range: float = 0.1
+    # TODO Doc Strings
+
+    def __init__(self, camera_data: CameraData, default_shake_size: float = 1.0, default_shake_falloff: float = 1.0, *,
+                 window: Optional["Window"] = None,
+                 default_shake_speed: float = 1.0,
+                 default_shake_jitter: float = 0.0,
+                 default_shake_direction: Tuple[float, float] = (-1.0, 0.0)):
+        self._win: "Window" = window or get_window()
+        self._data: CameraData = camera_data
+
+        self._d_dir = default_shake_direction
+        self._d_speed = default_shake_speed
+        self._d_amplitude = default_shake_size
+        self._d_falloff = default_shake_falloff
+        self._d_jitter = default_shake_jitter
+
+        self._t_dir = default_shake_direction
+        self._t_speed = default_shake_speed
+        self._t_amplitude = default_shake_size
+        self._t_falloff = default_shake_falloff
+        self._t_jitter = default_shake_jitter
+
+        self._shake: bool = False
+        self._time: float = 0.0
+        self._stop_time: float = -1.0
+        self._t_pos: Tuple[float, float] = camera_data.position[:2]
+
+    def start(self, *,
+              true_pos: Optional[Tuple[float, float]] = None,
+              temp_size: Optional[float] = None,
+              temp_falloff: Optional[float] = None,
+              temp_speed: Optional[float] = None,
+              temp_jitter: Optional[float] = None,
+              temp_direction: Optional[Tuple[float, float]] = None):
+
+        self._t_dir = temp_direction if temp_direction is not None else self._d_dir
+        self._t_jitter = temp_jitter if temp_jitter is not None else self._d_jitter
+        self._t_speed = temp_speed if temp_speed is not None else self._d_speed
+        self._t_falloff = temp_falloff if temp_falloff is not None else self._d_falloff
+        self._t_amplitude = temp_size if temp_size is not None else self._d_amplitude
+
+        self._time = 0.0
+        self._shake = True
+        self._t_pos = true_pos if true_pos is not None else self._t_pos
+        self._stop_time = self.estimated_length()
+
+    def _curve(self, _t: float) -> float:
+        return self._t_amplitude * e**(-self._t_falloff*_t) * sin(self._t_speed * 2.0 * pi * self._time)
+
+    def estimated_length(self) -> float:
+        _t = (log(self._t_amplitude) - log(self.stop_range)) / self._t_falloff
+        _dt = _t % (0.5 / self._t_speed)  # Find the distance from to the last x = 0.0
+        return _t - _dt
+
+    def shaking(self) -> bool:
+        return self._shake
+
+    def stop(self):
+        self.stop_in(self._t_speed - (self._time % self._t_speed))
+
+    def stop_in(self, _time: float):
+        # This derivation was a pain
+        _dt = self._time % (1.0 / self._t_speed)
+
+        _f = log(self._t_amplitude) - log(0.1) - self._t_falloff * self._time
+        _a = self._t_amplitude * e**(_f * _dt - self._t_falloff * self._time)
+
+        self._t_amplitude = _a
+        self._t_falloff = _f
+        self._time = _dt
+
+        _st = _time % (0.5 / self._t_speed)
+        self._stop_time = _time - _st
+
+    def update(self, delta_time: float, true_pos: Optional[Tuple[float, float]] = None):
+        if true_pos is not None:
+            self._t_pos = true_pos
+
+        if 0.0 <= self._stop_time <= self._time + delta_time:
+            self._time = 0.0
+            self._shake = False
+            return
+
+        if not self._shake:
+            self._time = 0.0
+            return
+
+        _m = 0.5 / self._t_speed
+        if self._t_jitter != 0.0 and self._time % _m > (self._time + delta_time) % _m:
+            radians_shift = radians(uniform(-self._t_jitter/2.0, self._t_jitter/2.0))
+            _c, _s = cos(radians_shift), sin(radians_shift)
+            dx = self._t_dir[0] * _c - self._t_dir[1] * _s
+            dy = self._t_dir[0] * _s + self._t_dir[1] * _c
+            self._t_dir = (dx, dy)
+
+        self._time += delta_time
+
+    def update_camera(self, true_pos: Optional[Tuple[float, float]] = None):
+        if true_pos is not None:
+            self._t_pos = true_pos
+
+        step = self._curve(self._time)
+        pos = (
+            self._t_pos[0] + step * self._t_dir[0],
+            self._t_pos[1] + step * self._t_dir[1]
+        )
+        self._data.position = (pos[0], pos[1], self._data.position[2])
+
+    @property
+    def direction(self) -> Tuple[float, float]:
+        return self._t_dir
+
+    @direction.setter
+    def direction(self, _dir: Tuple[float, float]):
+        self._t_dir = _dir
+        self._stop_time = self.estimated_length()
+
+    @property
+    def jitter(self) -> float:
+        return self._t_jitter
+
+    @jitter.setter
+    def jitter(self, _jitter: float):
+        self._t_jitter = _jitter
+        self._stop_time = self.estimated_length()
+
+    @property
+    def speed(self) -> float:
+        return self._t_speed
+
+    @speed.setter
+    def speed(self, _speed: float):
+        self._t_speed = _speed
+        self._stop_time = self.estimated_length()
+
+    @property
+    def falloff(self) -> float:
+        return self._t_falloff
+
+    @falloff.setter
+    def falloff(self, _falloff: float):
+        self._t_falloff = _falloff
+        self._stop_time = self.estimated_length()
+
+    @property
+    def amplitude(self) -> float:
+        return self._t_amplitude
+
+    @amplitude.setter
+    def amplitude(self, _amplitude: float):
+        self._t_amplitude = _amplitude
+        self._stop_time = self.estimated_length()
+
+    @property
+    def default_direction(self) -> Tuple[float, float]:
+        return self._d_dir
+
+    @default_direction.setter
+    def default_direction(self, _dir: Tuple[float, float]):
+        self._d_dir = _dir
+        self._t_dir = _dir
+        self._stop_time = self.estimated_length()
+
+    @property
+    def default_jitter(self) -> float:
+        return self._d_jitter
+
+    @default_jitter.setter
+    def default_jitter(self, _jitter: float):
+        self._d_jitter = _jitter
+        self._t_jitter = _jitter
+        self._stop_time = self.estimated_length()
+
+    @property
+    def default_speed(self) -> float:
+        return self._d_speed
+
+    @default_speed.setter
+    def default_speed(self, _speed: float):
+        self._d_speed = _speed
+        self._t_speed = _speed
+        self._stop_time = self.estimated_length()
+
+    @property
+    def default_falloff(self) -> float:
+        return self._d_falloff
+
+    @default_falloff.setter
+    def default_falloff(self, _falloff: float):
+        self._d_falloff = _falloff
+        self._t_falloff = _falloff
+        self._stop_time = self.estimated_length()
+
+    @property
+    def default_amplitude(self) -> float:
+        return self._d_amplitude
+
+    @default_amplitude.setter
+    def default_amplitude(self, _amplitude: float):
+        self._d_amplitude = _amplitude
+        self._t_amplitude = _amplitude
+        self._stop_time = self.estimated_length()
+
+
+def _shakey():
+    from arcade import Window, draw_point
+
+    from arcade.camera import Camera2D
+
+    win = Window()
+    cam = Camera2D()
+    shake = ScreenShaker2D(cam.data, 200, default_shake_speed=1.0, default_shake_jitter=20, default_shake_falloff=0.5)
+
+    def on_key_press(*args):
+        if shake.shaking():
+            shake.stop()
+        else:
+            shake.start()
+
+    win.on_key_press = on_key_press
+
+    def on_update(delta_time: float):
+        shake.update(delta_time)
+
+    win.on_update = on_update
+
+    def on_draw():
+        win.clear()
+        shake.update_camera()
+        cam.use()
+        draw_point(100, 100, (255, 255, 255, 255), 10)
+
+    win.on_draw = on_draw
+
+    win.run()
+
+
+if __name__ == '__main__':
+    _shakey()
+

arcade/camera/controllers/simple_controller_functions.py

@@ -50,7 +50,9 @@ def rotate_around_up(data: CameraData, angle: float):
 
 
 def rotate_around_right(data: CameraData, angle: float):
-    _crossed_vec = Vec3(*data.forward).cross(*data.up)
+    _forward = Vec3(data.forward[0], data.forward[1], data.forward[2])
+    _up = Vec3(data.up[0], data.up[1], data.up[2])
+    _crossed_vec = _forward.cross(_up)
     _right: Tuple[float, float, float] = (_crossed_vec.x, _crossed_vec.y, _crossed_vec.z)
     data.forward = quaternion_rotation(_right, data.forward, angle)
     data.up = quaternion_rotation(_right, data.up, angle)
@@ -128,4 +130,3 @@ def simple_easing_2D(percent: float,
     """
 
     simple_easing(percent, start + (0,), target + (0,), data, func)
-

arcade/camera/offscreen.py

@@ -12,6 +12,8 @@
 class OffScreenSpace:
     _geometry: Optional[Geometry] = quad_2d_fs()
 
+    # TODO: Doc String
+
     def __init__(self, *,
                  window: Optional["Window"] = None,
                  size: Optional[Tuple[int, int]] = None,

arcade/context.py

@@ -137,7 +137,7 @@ def __init__(self, window: pyglet.window.Window, gc_mode: str = "context_gc", gl
         # renders a quad (without projection) with a single 4-component texture.
         self.utility_textured_quad_program: Program = self.load_program(
             vertex_shader=":system:shaders/util/textured_quad_vs.glsl",
-            fragment_shader=":system:shaders/collision/textured_quad_fs.glsl",
+            fragment_shader=":system:shaders/util/textured_quad_fs.glsl",
         )
 
         # --- Pre-created geometry and buffers for unbuffered draw calls ----