add original code from camtool 2 1.16 x64 on RaceDepartment

CamTool_2/apps/python/CamTool_2/classes/MouseLook.py

@@ -0,0 +1,114 @@
+import ac
+import math
+
+from classes.general import *
+from ctypes import windll, Structure, c_ulong, byref
+
+class MouseLook(object):
+    def __init__(self):
+        self.__sensitivity = 1
+        self.__drag_mode = True
+        self.__resolution = vec( windll.user32.GetSystemMetrics(0), windll.user32.GetSystemMetrics(1))
+        self.__array_size = 60
+        self.__avg_movement = vec()
+
+        self.__t_zoom = 0
+
+        self.__mouse_positions = [None] * self.__array_size
+        for self.i in range(self.__array_size):
+            self.__mouse_positions[self.i] = vec(self.__get_mouse_position().x, self.__get_mouse_position().y)
+
+    def refresh(self, reset=False, lock_movement=False):
+        if reset:
+            self.__avg_movement.x = 0
+            self.__avg_movement.y = 0
+            for self.i in range(self.__array_size-1, -1, -1):
+                self.__mouse_positions[self.i].x = self.__get_mouse_position().x
+                self.__mouse_positions[self.i].y = self.__get_mouse_position().y
+
+        else:
+            if lock_movement == False:
+                self.__avg_movement.x = 0
+                self.__avg_movement.y = 0
+                for self.i in range(self.__array_size-1, -1, -1):
+                    if self.i != 0:
+                        self.__mouse_positions[self.i].x = self.__mouse_positions[self.i-1].x
+                        self.__mouse_positions[self.i].y = self.__mouse_positions[self.i-1].y
+                    else:
+                        self.__mouse_positions[0].x = self.__get_mouse_position().x
+                        self.__mouse_positions[0].y = self.__get_mouse_position().y
+                    self.__avg_movement.x += self.__mouse_positions[self.i].x
+                    self.__avg_movement.y += self.__mouse_positions[self.i].y
+                self.__avg_movement.x /= self.__array_size
+                self.__avg_movement.y /= self.__array_size
+
+
+                if self.__drag_mode:
+                    self.__avg_movement.x -= self.__get_mouse_position().x
+                    self.__avg_movement.y -= self.__get_mouse_position().y
+                    self.__avg_movement.x /= self.__resolution.x/10
+                    self.__avg_movement.y /= self.__resolution.y/10
+                else:
+                    self.__avg_movement.x -= self.__resolution.x/2
+                    self.__avg_movement.y -= self.__resolution.y/2
+
+                    self.__avg_movement.x /= self.__resolution.x/2
+                    self.__avg_movement.y /= self.__resolution.y/2
+
+                    self.__avg_movement.x *= self.__avg_movement.x * self.__avg_movement.x * (-1)
+                    self.__avg_movement.y *= self.__avg_movement.y * self.__avg_movement.y * (-1)
+            else:
+                self.__avg_movement.x *= 0.95
+                self.__avg_movement.y *= 0.95
+                for self.i in range(self.__array_size-1, -1, -1):
+                    self.__mouse_positions[self.i].x = self.__get_mouse_position().x
+                    self.__mouse_positions[self.i].y = self.__get_mouse_position().y
+
+
+    def rotate_camera(self, ctt):
+        self.__tmp_sensitivity = self.__sensitivity * (ctt.get_fov() / 50)
+        ctt.set_heading(math.radians(self.__get_mouse_momentum().x * self.__tmp_sensitivity), False)
+        ctt.set_pitch(math.radians(self.__get_mouse_momentum().y * self.__tmp_sensitivity), False)
+
+    def zoom(self, ctt, mode, dt, released):
+        try:
+            if released:
+                self.__t_zoom = min(1, max(0, self.__t_zoom + dt * 4))
+                self.release_factor = 1 - math.sin(math.radians(self.__t_zoom * 90))
+            else:
+                self.__t_zoom = min(1, max(0, self.__t_zoom - dt * 4))
+                self.release_factor = math.sin(math.radians((1 - self.__t_zoom) * 90))
+
+
+            if self.release_factor > 0:
+                if mode == "in":
+                    ctt.set_fov( max(1, ctt.convert_fov_2_focal_length( ctt.convert_fov_2_focal_length(ctt.get_fov()) + 0.015 * dt * self.release_factor, True) )  )
+                if mode == "out":
+                    ctt.set_fov( min(90, ctt.convert_fov_2_focal_length( ctt.convert_fov_2_focal_length(ctt.get_fov()) - 0.015 * dt * self.release_factor, True) )  )
+        except Exception as e:
+            debug(e)
+
+
+
+    def __get_mouse_momentum(self):
+        return vec( self.__avg_movement.x, self.__avg_movement.y )
+
+    def __get_mouse_position(self):
+        pt = self.POINT()
+        windll.user32.GetCursorPos(byref(pt))
+        return vec(pt.x, pt.y)
+
+
+    class POINT(Structure):
+        _fields_ = [("x", c_ulong), ("y", c_ulong)]
+
+
+mouse = MouseLook()
+
+# while(True):
+#     os.system('cls')
+#
+#     mouse.update()
+#     print(mouse.__get_mouse_momentum().x)
+#
+#     time.sleep(0.1)

CamTool_2/apps/python/CamTool_2/classes/Replay.py

@@ -0,0 +1,87 @@
+from classes.general import *
+
+class Replay(object):
+    def __init__(self):
+        self.__refresh_rate = None
+        self.__replay_time_multiplier = 1
+        self.__is_sync_activated = False
+        self.__timer = 0
+        self.__init_replay_pos = None
+
+        self.__time_between_replays_keyframes = 0
+        self.__prev_replay_pos = None
+        self.__prev_replay_speed = None
+        self.__interpolated_replay_pos = 0
+        self.__get_interpolated_replay_pos = 0
+        self.__prev_get_interpolated_replay_pos = 0
+
+    def get_interpolated_replay_pos(self):
+        if self.__refresh_rate != None:
+            if self.__get_refesh_rate() != 0 and self.__get_refesh_rate() != -1:
+                return self.__prev_replay_pos +  (self.__time_between_replays_keyframes / self.__get_refesh_rate())
+            else:
+                return self.__prev_replay_pos
+        return -1
+
+    def get_refresh_rate(self):
+        if self.__refresh_rate == None:
+            return -1
+        else:
+            return self.__refresh_rate
+
+
+    def __get_refesh_rate(self):
+        if self.__replay_time_multiplier != 0 and self.__refresh_rate != None:
+            return self.__refresh_rate / self.__replay_time_multiplier
+        return -1
+
+    def sync(self, ctt):
+        self.__is_sync_activated = True
+        ctt.set_replay_speed(1)
+
+    def is_sync(self):
+        if self.__refresh_rate == None:
+            return False
+        else:
+            return True
+
+
+    def refresh(self, dt, replay_pos, replay_time_multiplier):
+        if self.__refresh_rate != None and self.__prev_replay_pos != None and replay_time_multiplier != 0 and abs(replay_pos - self.__prev_replay_pos) < 10:
+            self.__time_between_replays_keyframes += (dt * 1000)
+            if self.__prev_replay_pos != replay_pos:
+                self.__time_between_replays_keyframes -= self.__get_refesh_rate() * (replay_pos - self.__prev_replay_pos)
+                self.__prev_replay_pos = replay_pos
+        else:
+            self.__prev_replay_pos = replay_pos
+            self.__time_between_replays_keyframes = 0
+
+        self.__b_return_prev_replay_pos = False
+        if replay_time_multiplier != self.__replay_time_multiplier:
+            self.__replay_time_multiplier = replay_time_multiplier
+            self.__prev_replay_pos = replay_pos
+
+
+
+
+        if self.__is_sync_activated and self.__refresh_rate == None:
+
+            if self.__init_replay_pos == None:
+                self.__init_replay_pos = replay_pos
+
+            if self.__timer < 1:
+                self.__timer += dt
+            else:
+                self.interval = (self.__timer*1000) / (replay_pos - self.__init_replay_pos)
+                if self.interval > 105:
+                    self.__refresh_rate = 120 #very low
+                elif self.interval > 75:
+                    self.__refresh_rate = 90 #low
+                elif self.interval > 45:
+                    self.__refresh_rate = 60 #medium
+                elif self.interval > 22.5:
+                    self.__refresh_rate = 30 #high
+                else:
+                    self.__refresh_rate = 15 #ultra
+
+replay = Replay()