Last active
September 25, 2020 11:32
-
-
Save Marocco2/15a239775fccce1afb220e032db835b5 to your computer and use it in GitHub Desktop.
CamTool_2.py - Up to 2x performance, fixes bugs
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import ac | |
| import acsys | |
| import math | |
| import timeit | |
| from classes.general import * | |
| class Camera(object): | |
| def __init__(self): | |
| self.__tracked_car_a = 0 | |
| self.__tracked_car_b = 0 | |
| self.__t_recording = 0 | |
| self.__spline_recording_enabled = False | |
| self.__spline_following_enabled = False | |
| self.__spline_index = 0 | |
| self.__spline_recording_mode = None | |
| self.__track_spline_recording_initiazlied = False | |
| self.__track_spline_recording_initiazlied_2 = False | |
| self.__t_shake = 0 | |
| self.__shake_offset = 0 | |
| self.__cam_rot_momentum = 0 | |
| self.__t = 0 | |
| self.__avg_car_pos = vec3() | |
| #smart tracking | |
| self.__t_st = {"switch_point": 0} | |
| self.__t_smart_tracking = 0 | |
| self.__t_car_out = 0 | |
| self.__prev_car_out = None | |
| self.__t_ver_car_out = 0 | |
| self.__prev_ver_car_out = None | |
| self.__locked_car = None | |
| self.__prev_smart_tracked_car = 0 | |
| self.__locked_smart_tracked_car = None | |
| self.__smart_tracking_x = 0 | |
| self.__smart_tracking_fov = 0 | |
| self.__smart_tracking_cam_rot = 0 | |
| self.__smart_tracking_fov_mix = 0 | |
| self.__t_smart_tracking_2 = 0 | |
| self.__prev_smart_tracked_car_2 = 0 | |
| self.__n_prev_cam_heading = 50 | |
| self.__prev_cam_heading = [None] * self.__n_prev_cam_heading | |
| self.__max_tracked_car_positions = 50 | |
| self.__tracking_smoothness = self.__max_tracked_car_positions | |
| self.__tracked_car_positions = [None] * self.__max_tracked_car_positions | |
| self.__t_cars_position = 0 | |
| self.__splines = [] | |
| for self.i in range(self.__max_tracked_car_positions): | |
| self.__tracked_car_positions[self.i] = [] | |
| for self.j in range(32): #max cars | |
| self.__tracked_car_positions[self.i].append(vec3()) | |
| def refresh(self, ctt, replay, info, dt, data, x): | |
| try: | |
| self.__set_offset_shake(dt, info, data, replay) | |
| if self.__spline_recording_enabled: | |
| self.record_spline(ctt, data, replay, x, dt * info.graphics.replayTimeMultiplier) | |
| except Exception as e: | |
| debug(e) | |
| def calculate_cam_rot_to_tracking_car(self, ctt, data, info, car_id, dt, loc_x, loc_y, loc_z): | |
| try: | |
| self.car_pos = ac.getCarState(car_id, acsys.CS.WorldPosition) | |
| self.__avg_car_pos = vec3() | |
| # self.interval = (1/100) | |
| # if self.__t_cars_position < self.interval: | |
| # self.__t_cars_position += dt * info.graphics.replayTimeMultiplier | |
| # else: | |
| # self.__t_cars_position = 0 | |
| for self.i in range(self.__tracking_smoothness-1, -1, -1): | |
| if self.i > 0: | |
| #if self.__t_cars_position == 0: | |
| self.__tracked_car_positions[self.i][car_id].x = self.__tracked_car_positions[self.i-1][car_id].x | |
| self.__tracked_car_positions[self.i][car_id].y = self.__tracked_car_positions[self.i-1][car_id].y | |
| self.__tracked_car_positions[self.i][car_id].z = self.__tracked_car_positions[self.i-1][car_id].z | |
| else: | |
| self.__tracked_car_positions[0][car_id].x = self.car_pos[0] | |
| self.__tracked_car_positions[0][car_id].y = self.car_pos[2] | |
| self.__tracked_car_positions[0][car_id].z = self.car_pos[1] | |
| self.__avg_car_pos.x += self.__tracked_car_positions[self.i][car_id].x | |
| self.__avg_car_pos.y += self.__tracked_car_positions[self.i][car_id].y | |
| self.__avg_car_pos.z += self.__tracked_car_positions[self.i][car_id].z | |
| self.__avg_car_pos.x /= self.__tracking_smoothness | |
| self.__avg_car_pos.y /= self.__tracking_smoothness | |
| self.__avg_car_pos.z /= self.__tracking_smoothness | |
| self.__pred_car_pos = vec3() | |
| self.__pred_car_pos.x = self.__tracked_car_positions[0][car_id].x + (self.__tracked_car_positions[0][car_id].x - self.__avg_car_pos.x) | |
| self.__pred_car_pos.y = self.__tracked_car_positions[0][car_id].y + (self.__tracked_car_positions[0][car_id].y - self.__avg_car_pos.y) | |
| self.__pred_car_pos.z = self.__tracked_car_positions[0][car_id].z + (self.__tracked_car_positions[0][car_id].z - self.__avg_car_pos.z) | |
| self.cam_pos = vec3( loc_x, loc_y, loc_z ) | |
| #camera rot raw momentum for offset shake | |
| self.x = self.car_pos[0] - self.cam_pos.x | |
| self.y = self.car_pos[2] - self.cam_pos.y | |
| self.z = self.car_pos[1] - self.cam_pos.z | |
| self.xy = math.sqrt((self.x*self.x) + (self.y*self.y)) | |
| self.heading = math.atan2( self.x, self.y ) + math.pi/2 | |
| self.pitch = math.atan2( self.z, self.xy ) | |
| if car_id == ac.getFocusedCar(): | |
| if self.__t < (1/60) and info.graphics.replayTimeMultiplier < 0.9: | |
| self.__t += dt * info.graphics.replayTimeMultiplier | |
| else: | |
| for self.i in range(self.__n_prev_cam_heading - 1, -1, -1): | |
| if self.i > 0: | |
| self.__prev_cam_heading[self.i] = self.__prev_cam_heading[self.i - 1] | |
| else: | |
| if self.__prev_cam_heading[0] == None: | |
| for self.j in range(self.__n_prev_cam_heading): | |
| self.__prev_cam_heading[self.j] = self.heading | |
| else: | |
| self.__prev_cam_heading[0] = self.heading | |
| self.__t = 0 | |
| if data.get_offset() < 0: | |
| self.x = (self.__pred_car_pos.x * self.__get_offset(data, info, dt) + self.car_pos[0] * (1 - self.__get_offset(data, info, dt))) - self.cam_pos.x | |
| self.y = (self.__pred_car_pos.y * self.__get_offset(data, info, dt) + self.car_pos[2] * (1 - self.__get_offset(data, info, dt))) - self.cam_pos.y | |
| self.z = (self.__pred_car_pos.z * self.__get_offset(data, info, dt) + self.car_pos[1] * (1 - self.__get_offset(data, info, dt))) - self.cam_pos.z | |
| else: | |
| self.x = (self.__avg_car_pos.x * self.__get_offset(data, info, dt) + self.car_pos[0] * (1 - self.__get_offset(data, info, dt))) - self.cam_pos.x | |
| self.y = (self.__avg_car_pos.y * self.__get_offset(data, info, dt) + self.car_pos[2] * (1 - self.__get_offset(data, info, dt))) - self.cam_pos.y | |
| self.z = (self.__avg_car_pos.z * self.__get_offset(data, info, dt) + self.car_pos[1] * (1 - self.__get_offset(data, info, dt))) - self.cam_pos.z | |
| self.xy = math.sqrt((self.x*self.x) + (self.y*self.y)) | |
| self.heading = math.atan2( self.x, self.y ) + math.pi/2 | |
| self.pitch = math.atan2( self.z, self.xy ) | |
| self.roll = ctt.get_roll() | |
| return vec3(self.pitch, self.roll, self.heading) | |
| except Exception as e: | |
| debug(e) | |
| def calculate_cam_rot_to_point(self, ctt, point): | |
| try: | |
| self.cam_pos = vec3( ctt.get_position(0), ctt.get_position(1), ctt.get_position(2) ) | |
| #camera rot raw momentum for offset shake | |
| self.x = point.x - self.cam_pos.x | |
| self.y = point.y - self.cam_pos.y | |
| self.z = point.z - self.cam_pos.z | |
| self.xy = math.sqrt((self.x*self.x) + (self.y*self.y)) | |
| self.heading = math.atan2( self.x, self.y ) + math.pi/2 | |
| self.pitch = math.atan2( self.z, self.xy ) | |
| self.roll = ctt.get_roll() | |
| return vec3(self.pitch, self.roll, self.heading) | |
| except Exception as e: | |
| debug(e) | |
| def update_smart_tracking_values(self, ctt, data, interpolation, info, the_x, dt): | |
| try: | |
| self.camera_in = data.mode[data.active_mode][data.active_cam].camera_in | |
| self.camera_out = data.get_camera_out() | |
| self.car_id = ac.getFocusedCar() | |
| self.opponent = self.get_closest_opponent(self.car_id, interpolation, x, data) | |
| #------------------------------------------------------------------- | |
| #VERIFY SECOND CAR | |
| #change opponent only if is the closest one for x amount of time | |
| if self.opponent != self.__prev_smart_tracked_car_2: | |
| self.__t_smart_tracking_2 += (dt * info.graphics.replayTimeMultiplier / 2) | |
| if self.__t_smart_tracking_2 > 1 and self.__t_smart_tracking == 0: | |
| self.__t_smart_tracking_2 = 0 | |
| self.__prev_smart_tracked_car_2 = self.opponent | |
| else: | |
| self.opponent = self.__prev_smart_tracked_car_2 | |
| else: | |
| self.__t_smart_tracking_2 = 0 | |
| self.__prev_smart_tracked_car_2 = self.opponent | |
| #dark magic - prevent jumping between opponents during transition | |
| if self.__prev_smart_tracked_car != self.opponent or self.__t_smart_tracking > 0: | |
| if self.__locked_smart_tracked_car == None: | |
| self.__locked_smart_tracked_car = self.opponent | |
| else: | |
| self.opponent = self.__locked_smart_tracked_car | |
| self.__t_smart_tracking += (dt * info.graphics.replayTimeMultiplier / self.transition) | |
| if self.__t_smart_tracking > 1: | |
| self.__prev_smart_tracked_car = self.__locked_smart_tracked_car | |
| self.__locked_smart_tracked_car = None | |
| self.__t_smart_tracking = 0 | |
| #------------------------------------------------------------------- | |
| #FIND AND VERIFY LAST CAR OUT IN CAMERA SECTOR | |
| self.last_car_out = {"id": None, "duration": None, "pos_expected": None} | |
| for self.i in range(32): #max_cars | |
| if ac.isConnected(self.i) == 1: | |
| if data.get_car_is_out(self.i)["status"] == True: | |
| if self.last_car_out["id"] == None: | |
| self.last_car_out["id"] = self.i | |
| self.last_car_out["duration"] = data.get_car_is_out(self.i)["duration"] | |
| self.last_car_out["pos_expected"] = data.get_car_is_out(self.i)["pos_expected"] | |
| else: | |
| if self.last_car_out["duration"] > data.get_car_is_out(self.i)["duration"] and data.get_car_is_out(self.i)["duration"] > 1: | |
| self.last_car_out["id"] = self.i | |
| self.last_car_out["duration"] = data.get_car_is_out(self.i)["duration"] | |
| self.last_car_out["pos_expected"] = data.get_car_is_out(self.i)["pos_expected"] | |
| #------------------------------------------------------------------- | |
| #CAR IS CLOSE | |
| #if self.last_car_out["id"] == None: | |
| #if self.car_id = | |
| #CAR OUT | |
| #self.__car_out = self.last_car_out["id"] | |
| # self.__smart_tracking_fov_mix = 1 | |
| # self.__smart_tracking_cam_rot_to_track = self.calculate_cam_rot_to_point(ctt, self.last_car_out["pos_expected"]) | |
| # self.__smart_tracking_cam_rot_to_car_out = self.calculate_cam_rot_to_tracking_car(ctt, data, info, self.__car_out) * vec3(0.5, 0.5, 0.5) + self.__smart_tracking_cam_rot_to_track * vec3(0.5, 0.5, 0.5) | |
| # self.__smart_tracking_fov = self.calculate_fov(ctt, self.cam_pos_2d, self.car_pos_2d, vec(self.last_car_out["pos_expected"].x, self.last_car_out["pos_expected"].y)) | |
| self.__smart_tracking_x = the_x | |
| self.__smart_tracking_cam_rot = self.calculate_cam_rot_to_tracking_car(ctt, data, info, ac.getFocusedCar(), dt) | |
| self.__smart_tracking_fov = ctt.get_fov() | |
| except Exception as e: | |
| debug(e) | |
| def calculate_cam_rot_to_smart_tracking_car(self, ctt, data, interpolation, info, x, dt, car_id): | |
| try: | |
| self.threshold = 50 #in meters | |
| self.transition = 2.5 #time required to change tracking opponent | |
| self.opponent = self.get_closest_opponent(car_id, interpolation, x, data) | |
| #change opponent only if is the closest one for x amount of time | |
| if self.opponent != self.__prev_smart_tracked_car_2: | |
| self.__t_smart_tracking_2 += (dt * info.graphics.replayTimeMultiplier / 2) | |
| if self.__t_smart_tracking_2 > 1 and self.__t_smart_tracking == 0: | |
| self.__t_smart_tracking_2 = 0 | |
| self.__prev_smart_tracked_car_2 = self.opponent | |
| else: | |
| self.opponent = self.__prev_smart_tracked_car_2 | |
| else: | |
| self.__t_smart_tracking_2 = 0 | |
| self.__prev_smart_tracked_car_2 = self.opponent | |
| #dark magic - prevent jumping between opponents during transition | |
| if self.__prev_smart_tracked_car != self.opponent or self.__t_smart_tracking > 0: | |
| if self.__locked_smart_tracked_car == None: | |
| self.__locked_smart_tracked_car = self.opponent | |
| else: | |
| self.opponent = self.__locked_smart_tracked_car | |
| self.__t_smart_tracking += (dt * info.graphics.replayTimeMultiplier / self.transition) | |
| if self.__t_smart_tracking > 1: | |
| self.__prev_smart_tracked_car = self.__locked_smart_tracked_car | |
| self.__locked_smart_tracked_car = None | |
| self.__t_smart_tracking = 0 | |
| #store cars positions | |
| self.pos_a = vec3(ac.getCarState(car_id, acsys.CS.WorldPosition)[0], ac.getCarState(car_id, acsys.CS.WorldPosition)[2], ac.getCarState(car_id, acsys.CS.WorldPosition)[1]) | |
| self.pos_b = vec3(ac.getCarState(self.opponent, acsys.CS.WorldPosition)[0], ac.getCarState(self.opponent, acsys.CS.WorldPosition)[2], ac.getCarState(self.opponent, acsys.CS.WorldPosition)[1]) | |
| self.distance_pow = math.pow(self.pos_a.x - self.pos_b.x, 2) + math.pow(self.pos_a.y - self.pos_b.y, 2) + math.pow(self.pos_a.z - self.pos_b.z, 2) | |
| self.distance_pow_tmp = self.distance_pow | |
| #calculate mix between two closest opponents | |
| self.__smart_tracking_mix = (math.sin(math.radians(self.__t_smart_tracking * 180 - 90)) + 1) / 2 | |
| if self.__smart_tracking_mix > 0: | |
| self.pos_tmp = vec3(ac.getCarState(self.__prev_smart_tracked_car, acsys.CS.WorldPosition)[0], ac.getCarState(self.__prev_smart_tracked_car, acsys.CS.WorldPosition)[2], ac.getCarState(self.__prev_smart_tracked_car, acsys.CS.WorldPosition)[1]) | |
| self.distance_pow_tmp = math.pow(self.pos_a.x - self.pos_tmp.x, 2) + math.pow(self.pos_a.y - self.pos_tmp.y, 2) + math.pow(self.pos_a.z - self.pos_tmp.z, 2) | |
| self.pos_b.x = self.pos_b.x * self.__smart_tracking_mix + self.pos_tmp.x * (1 - self.__smart_tracking_mix) | |
| self.pos_b.y = self.pos_b.y * self.__smart_tracking_mix + self.pos_tmp.y * (1 - self.__smart_tracking_mix) | |
| self.pos_b.z = self.pos_b.z * self.__smart_tracking_mix + self.pos_tmp.z * (1 - self.__smart_tracking_mix) | |
| #calculate mix between current car and calculated point | |
| self.threshold *= self.threshold | |
| self.mix = max(0, min(1, (self.threshold - self.distance_pow) / self.threshold)) | |
| self.mix *= self.mix | |
| self.mix /= 2 | |
| self.mix_tmp = max(0, min(1, (self.threshold - self.distance_pow_tmp) / self.threshold)) | |
| self.mix_tmp *= self.mix_tmp | |
| self.mix_tmp /= 2 | |
| self.mix = self.mix * self.__smart_tracking_mix + self.mix_tmp * (1 - self.__smart_tracking_mix) | |
| if self.mix == 0: | |
| self.reset_smart_tracking() | |
| #calculate camera rotations | |
| self.rot_a = self.calculate_cam_rot_to_tracking_car(ctt, data, info, car_id, dt) | |
| if self.mix > 0 or self.__smart_tracking_mix > 0: | |
| self.rot_b = self.calculate_cam_rot_to_tracking_car(ctt, data, info, self.opponent) | |
| self.rot_b.z = normalize_angle(self.rot_a.z, self.rot_b.z) | |
| #if transition between opponents is running, calculate camera rotation to the previous closest opponent and mix it with current closest | |
| if self.__smart_tracking_mix > 0: | |
| self.rot_tmp = self.calculate_cam_rot_to_tracking_car(ctt, data, info, self.__prev_smart_tracked_car, dt) | |
| self.rot_tmp.z = normalize_angle(self.rot_b.z, self.rot_tmp.z) | |
| self.rot_b.x = self.rot_b.x * self.__smart_tracking_mix + self.rot_tmp.x * (1 - self.__smart_tracking_mix) | |
| self.rot_b.y = self.rot_b.y * self.__smart_tracking_mix + self.rot_tmp.y * (1 - self.__smart_tracking_mix) | |
| self.rot_b.z = self.rot_b.z * self.__smart_tracking_mix + self.rot_tmp.z * (1 - self.__smart_tracking_mix) | |
| #------------------------------------------------------------------- | |
| #calculate fov | |
| self.__smart_tracking_fov_mix = self.mix + (self.mix - self.mix * self.mix) | |
| if self.mix > 0: | |
| self.heading_a = self.calculate_heading(ctt, car_id) | |
| self.heading_b = self.calculate_heading(ctt, self.opponent) | |
| self.heading_b = normalize_angle(self.heading_a, self.heading_b) | |
| self.heading_tmp = self.calculate_heading(ctt, self.__prev_smart_tracked_car) | |
| self.heading_tmp = normalize_angle(self.heading_b, self.heading_tmp) | |
| self.heading_b = self.heading_b * self.__smart_tracking_mix + self.heading_tmp * (1 - self.__smart_tracking_mix) | |
| self.rotation_difference = self.heading_a - self.heading_b | |
| self.fov = max(0, min(1, self.rotation_difference / math.pi)) * 90 | |
| if abs(self.fov - ctt.get_fov()) * dt > 0.5: | |
| self.fov += max(-0.5, min(0.5, self.fov - ctt.get_fov())) | |
| self.__smart_tracking_fov = max(self.fov, ctt.get_fov()) | |
| #mix camera rotation to current car with calculated point | |
| if self.mix > 0: | |
| self.pitch = self.rot_a.x * (1 - self.mix) + self.rot_b.x * self.mix | |
| self.roll = self.rot_a.y * (1 - self.mix) + self.rot_b.y * self.mix | |
| self.heading = self.rot_a.z * (1 - self.mix) + self.rot_b.z * self.mix | |
| else: | |
| self.pitch = self.rot_a.x | |
| self.roll = self.rot_a.y | |
| self.heading = self.rot_a.z | |
| if self.mix == 0: | |
| self.reset_smart_tracking() | |
| return vec3(self.pitch, self.roll, self.heading) | |
| except Exception as e: | |
| debug(e) | |
| def calculate_focus_point(self, ctt, mix, heading_tracked, dt): | |
| try: | |
| if abs(ctt.get_heading() - heading_tracked) > math.pi / 2: | |
| return ctt.get_focus_point() | |
| self.cam_pos = vec3( ctt.get_position(0), ctt.get_position(1), ctt.get_position(2) ) | |
| self.car_a_pos = vec3( ac.getCarState(self.__tracked_car_a, acsys.CS.WorldPosition)[0], ac.getCarState(self.__tracked_car_a, acsys.CS.WorldPosition)[2], ac.getCarState(self.__tracked_car_a, acsys.CS.WorldPosition)[1] ) | |
| self.car_b_pos = vec3( ac.getCarState(self.__tracked_car_b, acsys.CS.WorldPosition)[0], ac.getCarState(self.__tracked_car_b, acsys.CS.WorldPosition)[2], ac.getCarState(self.__tracked_car_b, acsys.CS.WorldPosition)[1] ) | |
| self.result = 0 | |
| if mix == 0 or mix == None: | |
| self.result = math.pow(self.cam_pos.x - self.car_a_pos.x, 2) + math.pow(self.cam_pos.y - self.car_a_pos.y, 2) + math.pow(self.cam_pos.z - self.car_a_pos.z, 2) | |
| else: | |
| self.result_a = math.pow(self.cam_pos.x - self.car_a_pos.x, 2) + math.pow(self.cam_pos.y - self.car_a_pos.y, 2) + math.pow(self.cam_pos.z - self.car_a_pos.z, 2) | |
| self.result_b = math.pow(self.cam_pos.x - self.car_b_pos.x, 2) + math.pow(self.cam_pos.y - self.car_b_pos.y, 2) + math.pow(self.cam_pos.z - self.car_b_pos.z, 2) | |
| self.result = min(self.result_a, self.result_b) | |
| return math.sqrt(self.result) | |
| except Exception as e: | |
| debug(e) | |
| def calculate_heading(self, ctt, car_id): | |
| self.car_pos = ac.getCarState(car_id, acsys.CS.WorldPosition) | |
| self.cam_pos = vec3( ctt.get_position(0), ctt.get_position(1), ctt.get_position(2) ) | |
| self.x = self.car_pos[0] - self.cam_pos.x | |
| self.y = self.car_pos[2] - self.cam_pos.y | |
| return math.atan2( self.x, self.y ) + math.pi/2 | |
| def calculate_fov(self, ctt, cam, point_a, point_b): | |
| try: | |
| cout("---------------------------") | |
| self.__cam_pos = vec(ctt.get_position(0), ctt.get_position(1)) | |
| self.tangent_points = self.find_tangent_points(self.__cam_pos, point_a) | |
| self.tangent_points = self.tangent_points + self.find_tangent_points(self.__cam_pos, point_b) | |
| self.headings = [0] * 4 | |
| self.current_heading = self.calculate_heading_from_points(self.__cam_pos, (point_a + point_b) * vec(0.5, 0.5)) | |
| cout("current", self.current_heading) | |
| for self.i in range(4): | |
| self.heading = normalize_angle(self.heading, self.calculate_heading_from_points(self.__cam_pos, self.tangent_points[self.i])) | |
| self.headings[self.i] = self.current_heading - self.heading | |
| cout("heading", self.heading) | |
| cout("delta", self.headings[self.i]) | |
| self.heading_differences = [0] * 16 | |
| for self.i in range(4): | |
| for self.j in range(4): | |
| self.angle_1 = self.headings[self.i] | |
| self.angle_2 = normalize_angle(self.angle_1, self.headings[self.j]) | |
| self.heading_differences[self.i * 4 + self. j] = abs(self.angle_1 - self.angle_2) | |
| cout(self.angle_1, self.angle_2) | |
| cout(self.heading_differences[self.i * 4 + self. j]) | |
| self.heading_differences = sorted(self.heading_differences) | |
| self.fov = math.degrees(self.heading_differences[len(self.heading_differences) - 1]) | |
| cout("fov", self.fov) | |
| return self.fov | |
| except Exception as e: | |
| debug(e) | |
| def find_tangent_points(self, cam, point): | |
| try: | |
| self.radius = 3 | |
| self.delta = point - cam | |
| self.x = math.sqrt(self.delta.x * self.delta.x + self.delta.y * self.delta.y) | |
| self.a = math.asin(self.radius / self.x) | |
| self.b = math.atan2(self.delta.y, self.delta.x) | |
| self.t = self.b - self.a | |
| self.ta = vec( self.radius * math.sin(self.t), self.radius * -math.cos(self.t) ) + point | |
| self.t = self.b + self.a | |
| self.tb = vec( self.radius * -math.sin(self.t), self.radius * math.cos(self.t) ) + point | |
| return [self.ta, self.tb] | |
| except Exception as e: | |
| debug(e) | |
| def calculate_heading_from_points(self, c_point, point): | |
| try: | |
| self.cam_pos = c_point | |
| #camera rot raw momentum for offset shake | |
| self.x = point.x - self.cam_pos.x | |
| self.y = point.y - self.cam_pos.y | |
| self.heading = math.atan2( self.x, self.y ) + math.pi/2 | |
| return self.heading | |
| except Exception as e: | |
| debug(e) | |
| #--------------------------------------------------------------------------- | |
| #GETS | |
| def get_st_fov(self): | |
| return self.__smart_tracking_fov | |
| def get_st_fov_mix(self): | |
| return self.__smart_tracking_fov_mix | |
| def get_st_x(self): | |
| return self.__smart_tracking_x | |
| def get_st_cam_rot(self): | |
| return self.__smart_tracking_cam_rot | |
| def get_tracked_car(self, car=0): | |
| if car == 0: | |
| self.car_id = self.__tracked_car_a | |
| else: | |
| self.car_id = self.__tracked_car_b | |
| if ac.isConnected(self.car_id) == 1: | |
| return self.car_id | |
| else: | |
| return 0 | |
| def __get_next_car(self, data, car_id, pitline_validation=False): | |
| try: | |
| self.nsp = ac.getCarState(car_id, acsys.CS.NormalizedSplinePosition) | |
| self.next_car = [car_id, 1] | |
| for self.iteration in range(32): #max cars | |
| if ac.isConnected(self.iteration) == 1 and self.iteration != car_id: | |
| self.pitline_condition = True | |
| if pitline_validation: | |
| if data.is_car_in_pitline(self.iteration) == data.is_car_in_pitline(car_id): | |
| self.pitline_condition = True | |
| else: | |
| self.pitline_condition = False | |
| if self.pitline_condition: | |
| if self.nsp < ac.getCarState(self.iteration, acsys.CS.NormalizedSplinePosition): | |
| self.distance = abs(self.nsp - ac.getCarState(self.iteration, acsys.CS.NormalizedSplinePosition)) | |
| else: | |
| self.distance = 1 - abs(self.nsp - ac.getCarState(self.iteration, acsys.CS.NormalizedSplinePosition)) | |
| if self.distance < self.next_car[1]: | |
| self.next_car = [self.iteration, self.distance] | |
| return self.next_car[0] | |
| except Exception as e: | |
| debug(e) | |
| def get_next_car(self, car_id): | |
| try: | |
| self.max_cars = 32 | |
| self.nsp = ac.getCarState(car_id, acsys.CS.NormalizedSplinePosition) | |
| self.next_car = vec(car_id, 1) | |
| for self.i in range(32): #max cars | |
| if ac.isConnected(self.i) == 1 and self.i != car_id: | |
| if self.nsp < ac.getCarState(self.i, acsys.CS.NormalizedSplinePosition): | |
| self.distance = abs(self.nsp - ac.getCarState(self.i, acsys.CS.NormalizedSplinePosition)) | |
| else: | |
| self.distance = 1 - abs(self.nsp - ac.getCarState(self.i, acsys.CS.NormalizedSplinePosition)) | |
| if self.distance < self.next_car.y: | |
| self.next_car = vec(self.i, self.distance) | |
| return self.next_car.x | |
| except Exception as e: | |
| debug(e) | |
| def get_prev_car(self, car_id): | |
| try: | |
| self.max_cars = 32 | |
| self.nsp = ac.getCarState(car_id, acsys.CS.NormalizedSplinePosition) | |
| self.prev_car = vec(car_id, 1) | |
| for self.i in range(32): #max cars | |
| if ac.isConnected(self.i) == 1 and self.i != car_id: | |
| if self.nsp > ac.getCarState(self.i, acsys.CS.NormalizedSplinePosition): | |
| self.distance = abs(self.nsp - ac.getCarState(self.i, acsys.CS.NormalizedSplinePosition)) | |
| else: | |
| self.distance = 1 - abs(self.nsp - ac.getCarState(self.i, acsys.CS.NormalizedSplinePosition)) | |
| if self.distance < self.prev_car.y: | |
| self.prev_car = vec(self.i, self.distance) | |
| return self.prev_car.x | |
| except Exception as e: | |
| debug(e) | |
| def get_closest_opponent(self, car_id, interpolation, x, data): | |
| self.max_cars = 32 | |
| self.nsp = ac.getCarState(car_id, acsys.CS.NormalizedSplinePosition) | |
| self.next_car = vec(car_id, 1) | |
| for self.i in range(32): #max cars | |
| if ac.isConnected(self.i) == 1 and self.i != car_id: | |
| if data.is_car_in_pitline(car_id) == data.is_car_in_pitline(self.i): | |
| self.distance_a = abs(self.nsp - ac.getCarState(self.i, acsys.CS.NormalizedSplinePosition)) | |
| self.distance_b = 1 - abs(self.nsp - ac.getCarState(self.i, acsys.CS.NormalizedSplinePosition)) | |
| self.distance = min(self.distance_a, self.distance_b) | |
| if self.distance < self.next_car.y: | |
| self.next_car = vec(self.i, self.distance) | |
| return self.next_car.x | |
| def get_shake(self, data, replayTimeMultiplier): | |
| self.shake_strength = data.mode[data.active_mode][data.active_cam].camera_shake_strength * (self.__cam_rot_momentum * 0.2 + 0.8) * 0.001 | |
| self.heading = (math.sin(self.__t_shake * 8) + math.sin(self.__t_shake * 5) + math.sin(self.__t_shake)) * self.shake_strength | |
| self.pitch = (math.sin(self.__t_shake * 7) + math.sin(self.__t_shake * 2) + math.sin(self.__t_shake * 8)) * self.shake_strength | |
| self.heading *= replayTimeMultiplier | |
| self.pitch *= replayTimeMultiplier | |
| return vec3(self.pitch, 0, self.heading) | |
| def get_recording_status(self, mode="camera"): | |
| if self.__spline_recording_enabled and self.__spline_recording_mode == mode: | |
| return True | |
| else: | |
| return False | |
| def __get_offset(self, data, info, dt): | |
| self.rtm = info.graphics.replayTimeMultiplier | |
| if self.rtm == 0: | |
| self.rtm = 1 | |
| #cout((abs(data.get_offset()) + self.__shake_offset), (abs(data.get_offset()) + self.__shake_offset) / self.rtm) | |
| return (abs(data.get_offset()) + self.__shake_offset) / self.rtm | |
| #--------------------------------------------------------------------------- | |
| #SETS | |
| def set_tracked_car(self, car, val): | |
| if car == 0: | |
| self.__tracked_car_a = val | |
| else: | |
| self.__tracked_car_b = val | |
| def set_spline_recording(self, val, mode="camera"): | |
| self.__spline_recording_enabled = val | |
| self.__spline_recording_mode = mode | |
| def __set_offset_shake(self, dt, info, data, replay): | |
| try: | |
| self.avg = 0 | |
| if self.__prev_cam_heading[0] != None: | |
| for self.i in range(1, self.__n_prev_cam_heading): | |
| self.avg += self.__prev_cam_heading[self.i] | |
| self.avg /= (self.__n_prev_cam_heading - 1) | |
| self.__cam_rot_momentum = min(1, abs(self.__prev_cam_heading[0] - self.avg) * 25) | |
| self.strength = data.mode[data.active_mode][data.active_cam].camera_offset_shake_strength | |
| #update timer responsible for shake | |
| if info.graphics.status == 1 and replay.is_sync(): | |
| self.__t_shake = replay.get_interpolated_replay_pos() / (1000 / replay.get_refresh_rate()) | |
| else: | |
| if info.graphics.replayTimeMultiplier != 0: | |
| self.__t_shake += dt * info.graphics.replayTimeMultiplier | |
| else: | |
| self.__t_shake = 0 | |
| self.__shake_offset = (math.sin((self.__t_shake) * 3) * math.sin((self.__t_shake) * 4)) * (1 - self.__cam_rot_momentum) + math.sin((self.__t_shake) * 9) * self.__cam_rot_momentum | |
| self.__shake_offset *= (self.__cam_rot_momentum * 0.2) + 0.8 | |
| self.__shake_offset *= self.strength | |
| self.__shake_offset *= 0.25 | |
| if info.graphics.replayTimeMultiplier != 0: | |
| self.__shake_offset / info.graphics.replayTimeMultiplier | |
| except Exception as e: | |
| debug(e) | |
| #--------------------------------------------------------------------------- | |
| #OTHER | |
| def reset_smart_tracking(self): | |
| self.__smart_tracking_fov_mix = 0 | |
| self.__t_smart_tracking = 0 | |
| self.__t_smart_tracking_2 = 1 | |
| self.__prev_smart_tracked_car = ac.getFocusedCar() | |
| self.__prev_smart_tracked_car_2 = ac.getFocusedCar() | |
| self.__cam_rot_momentum = 0 | |
| def toogle_spline_following(self): | |
| if self.__spline_following_enabled: | |
| self.__spline_following_enabled = False | |
| else: | |
| self.__spline_following_enabled = True | |
| self.__spline_index = 0 | |
| def record_spline(self, ctt, data, replay, x, dt): | |
| try: | |
| if data.active_mode == "time": | |
| if not replay.is_sync: | |
| self.__spline_recording_enabled = False | |
| return -1 | |
| self.__t_recording += dt | |
| if self.__t_recording > 1: | |
| self.__t_recording = 0 | |
| if self.__spline_recording_mode == "camera": | |
| self.n = len(data.mode[data.active_mode][data.active_cam].spline["the_x"]) | |
| self.x = x | |
| if data.active_mode == "pos": | |
| if self.n > 0: | |
| self.prev_x = data.mode[data.active_mode][data.active_cam].spline["the_x"][self.n - 1] | |
| if abs(self.x - self.prev_x) > abs(self.x + 1 - self.prev_x): | |
| self.x += 1 | |
| data.mode[data.active_mode][data.active_cam].spline["the_x"].append(self.x) | |
| data.mode[data.active_mode][data.active_cam].spline["loc_x"].append(ctt.get_position(0)) | |
| data.mode[data.active_mode][data.active_cam].spline["loc_y"].append(ctt.get_position(1)) | |
| data.mode[data.active_mode][data.active_cam].spline["loc_z"].append(ctt.get_position(2)) | |
| data.mode[data.active_mode][data.active_cam].spline["rot_x"].append(ctt.get_pitch()) | |
| data.mode[data.active_mode][data.active_cam].spline["rot_y"].append(ctt.get_roll()) | |
| self.heading = ctt.get_heading() | |
| if self.n > 0: | |
| self.prev_heading = data.mode[data.active_mode][data.active_cam].spline["rot_z"][self.n - 1] | |
| self.heading = normalize_angle(self.prev_heading, self.heading) | |
| data.mode[data.active_mode][data.active_cam].spline["rot_z"].append(self.heading) | |
| #--------------------------------------------------------------- | |
| if self.__spline_recording_mode == "track": | |
| if data.active_mode == "pos": | |
| if x < 0.5 and not self.__track_spline_recording_initiazlied: | |
| self.__track_spline_recording_initiazlied = True | |
| self.__track_spline_recording_initiazlied_2 = False | |
| if x < 0.5 and self.__track_spline_recording_initiazlied and self.__track_spline_recording_initiazlied_2: | |
| self.__spline_recording_enabled = False | |
| self.__track_spline_recording_initiazlied = False | |
| self.__track_spline_recording_initiazlied_2 = False | |
| if self.__track_spline_recording_initiazlied: | |
| if x > 0.5: | |
| self.__track_spline_recording_initiazlied_2 = True | |
| if self.__spline_recording_enabled: | |
| cout("inside") | |
| self.n = len(data.track_spline["the_x"]) | |
| data.track_spline["the_x"].append(x) | |
| data.track_spline["loc_x"].append(ctt.get_position(0)) | |
| data.track_spline["loc_y"].append(ctt.get_position(1)) | |
| data.track_spline["loc_z"].append(ctt.get_position(2)) | |
| data.track_spline["rot_x"].append(ctt.get_pitch()) | |
| data.track_spline["rot_y"].append(ctt.get_roll()) | |
| self.heading = ctt.get_heading() | |
| if self.n > 0: | |
| self.prev_heading = data.track_spline["rot_z"][self.n - 1] | |
| self.heading = normalize_angle(self.prev_heading, self.heading) | |
| data.track_spline["rot_z"].append(self.heading) | |
| else: | |
| self.__spline_recording_enabled = False | |
| #------------------------------------------------------------------- | |
| if self.__spline_recording_mode == "pit": | |
| if data.active_mode == "pos": | |
| self.n = len(data.pit_spline["the_x"]) | |
| self.x = x | |
| if self.n > 0: | |
| self.prev_x = data.pit_spline["the_x"][self.n - 1] | |
| if abs(self.x - self.prev_x) > abs(self.x + 1 - self.prev_x): | |
| self.x += 1 | |
| data.pit_spline["the_x"].append(self.x) | |
| data.pit_spline["loc_x"].append(ctt.get_position(0)) | |
| data.pit_spline["loc_y"].append(ctt.get_position(1)) | |
| data.pit_spline["loc_z"].append(ctt.get_position(2)) | |
| data.pit_spline["rot_x"].append(ctt.get_pitch()) | |
| data.pit_spline["rot_y"].append(ctt.get_roll()) | |
| self.heading = ctt.get_heading() | |
| if self.n > 0: | |
| self.prev_heading = data.pit_spline["rot_z"][self.n - 1] | |
| self.heading = normalize_angle(self.prev_heading, self.heading) | |
| data.pit_spline["rot_z"].append(self.heading) | |
| else: | |
| self.__spline_recording_enabled = False | |
| except Exception as e: | |
| debug(e) | |
| def follow_spline(self, ctt): | |
| if self.__spline_index < len(self.__splines): | |
| ctt.set_position(0, self.__splines[self.__spline_index][0]) | |
| ctt.set_position(1, self.__splines[self.__spline_index][1]) | |
| ctt.set_position(2, self.__splines[self.__spline_index][2]) | |
| if self.__spline_index != 0: | |
| self.x = self.__splines[self.__spline_index][0] - self.__splines[self.__spline_index-1][0] | |
| self.y = self.__splines[self.__spline_index][1] - self.__splines[self.__spline_index-1][1] | |
| self.z = self.__splines[self.__spline_index][2] - self.__splines[self.__spline_index-1][2] | |
| self.xy = math.sqrt((self.x * self.x) + (self.y * self.y)) | |
| self.heading = math.degrees( math.atan2( self.x, self.y ) ) + 90 | |
| self.pitch = math.degrees( math.atan2( self.z, self.xy ) ) | |
| ctt.set_heading(self.heading) | |
| ctt.set_pitch(self.pitch) | |
| self.__spline_index += 1 | |
| cam = Camera() |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ''' | |
| 1.14.3 x64 | |
| kasperski95@gmail.com | |
| ''' | |
| from classes.general import * | |
| from classes.CubicBezierInterpolation import interpolation | |
| from classes.Camera import cam | |
| from classes.MouseLook import mouse | |
| from classes.Replay import replay | |
| from classes.data import data | |
| from stdlib64.CamToolTool import ctt | |
| from stdlib.sim_info import info | |
| import sys | |
| import os | |
| import platform | |
| import ac | |
| import acsys | |
| import math | |
| import time | |
| #import timeit | |
| import functools | |
| import threading | |
| def async(func): | |
| @functools.wraps(func) | |
| def wrapper(*args, **kwargs): | |
| t = threading.Thread(target=func, args=args, kwargs=kwargs) | |
| t.daemon = True | |
| t.start() | |
| #t.join() | |
| return t | |
| return wrapper | |
| if platform.architecture()[0] == "64bit": | |
| sysdir = os.path.dirname(__file__)+'/stdlib64' | |
| else: | |
| sysdir = os.path.dirname(__file__)+'/stdlib' | |
| sys.path.insert(0, sysdir) | |
| os.environ['PATH'] = os.environ['PATH'] + ";." | |
| #================================================= | |
| gUI = None | |
| donce = 0 | |
| changing = 0 | |
| gTimer_mouse = 0 | |
| gTimer_volume = 1 | |
| gPrev_zoom_mode = "in" | |
| gFont = "Arial" | |
| gFont2 = "Segoe UI Symbol" | |
| gImgPath = os.path.dirname(__file__)+'/img/' | |
| gDataPath = os.path.abspath(__file__).replace( | |
| "\\", '/').replace(os.path.basename(__file__), '') + "data/" | |
| gPrevCar = 0 | |
| gInitVolume = 1 | |
| loc_x = 0 | |
| loc_y = 0 | |
| loc_z = 0 | |
| rot_x = 0 | |
| rot_y = 0 | |
| rot_z = 0 | |
| fov = 0 | |
| focus_point = 0 | |
| focused_car = 0 | |
| replay_pos = 0 | |
| s = False | |
| c = False | |
| a = False | |
| lmb = False | |
| @async | |
| def ctt_get(): | |
| global loc_x, loc_y, loc_z, rot_x, rot_y, rot_z, fov, replay_pos, focused_car, focus_point | |
| focused_car = ac.getFocusedCar() | |
| loc_x = ctt.get_position(0) | |
| loc_y = ctt.get_position(1) | |
| loc_z = ctt.get_position(2) | |
| rot_x = ctt.get_pitch() | |
| rot_y = ctt.get_roll() | |
| rot_z = ctt.get_heading() | |
| fov = ctt.get_fov() | |
| focus_point = ctt.get_focus_point() | |
| replay_pos = ctt.get_replay_position() | |
| def acMain(ac_version): | |
| try: | |
| global gUI | |
| gUI = CamTool2() | |
| ac.addOnAppActivatedListener(gUI.app, activated) | |
| ac.addOnAppDismissedListener(gUI.app, dismissed) | |
| except Exception as e: | |
| debug(e) | |
| def acUpdate(dt): | |
| try: | |
| global gTimer_mouse, gPrev_zoom_mode, gPrevCar, gTimer_volume, donce, changing | |
| global loc_x, loc_y, loc_z, rot_x, rot_y, rot_z, fov, replay_pos, focus_point | |
| global a, s, c, lmb | |
| s = ctt.is_async_key_pressed("s") | |
| c = ctt.is_async_key_pressed("c") | |
| a = ctt.is_async_key_pressed("a") | |
| lmb = ctt.is_lmb_pressed() | |
| if s: | |
| if not bool(donce): | |
| if c: # ctrl | |
| gUI.on_click__activate() | |
| donce += dt | |
| #elif ctt.is_async_key_pressed("2"): | |
| # gUI.on_click__file_form("btn_click", 1) | |
| # donce += dt | |
| else: | |
| donce = 0 | |
| if gUI.active_app: | |
| ctta = ctt_get() | |
| if ac.isConnected(focused_car) != 1: | |
| ac.focusCar(0) | |
| gUI.update_the_x() | |
| #ctt.set_volume(1) | |
| if a: # alt | |
| gTimer_mouse = min(1, gTimer_mouse + dt) | |
| mouse.rotate_camera(ctt) | |
| if lmb: | |
| mouse.refresh(False, False) | |
| else: | |
| mouse.refresh(False, True) | |
| if s: # shift | |
| mouse.zoom(ctt, "in", dt, False) | |
| gPrev_zoom_mode = "in" | |
| if c: # ctrl | |
| mouse.zoom(ctt, "out", dt, False) | |
| gPrev_zoom_mode = "out" | |
| else: | |
| gTimer_mouse = max(0, gTimer_mouse - dt / 2) | |
| mouse.refresh(True) | |
| if not s and not c: | |
| mouse.zoom(ctt, gPrev_zoom_mode, dt, True) | |
| x = gUI.get_the_x() | |
| cam.refresh(ctt, replay, info, dt, data, x) | |
| data.refresh(x, dt, interpolation, __file__) | |
| ctta.join() | |
| if gUI.is_AC_visible: | |
| gUI.refresh(math.sin(math.radians(gTimer_mouse * 90)), dt) | |
| else: | |
| gUI.interpolate(math.sin(math.radians(gTimer_mouse * 90)), dt) | |
| if focused_car != gPrevCar or data.has_camera_changed(): | |
| gPrevCar = focused_car | |
| cam.reset_smart_tracking() | |
| gTimer_volume = 0 | |
| if info.graphics.status == 1: # is replay | |
| replay.refresh(dt, replay_pos, | |
| info.graphics.replayTimeMultiplier) | |
| if gTimer_volume < 1: | |
| #volume_multiplier = (math.sin( math.radians(gTimer_volume * 90 - 90) ) + 1) * 0.5 + gTimer_volume * 0.5 | |
| volume_multiplier = gTimer_volume | |
| volume_multiplier *= volume_multiplier | |
| volume = gInitVolume * volume_multiplier | |
| ctt.set_volume(volume) | |
| gTimer_volume = max(0, min(1, gTimer_volume + dt * 2)) | |
| except Exception as e: | |
| debug(e) | |
| #=============================================================================== | |
| class CamTool2(object): | |
| golden_ratio = 1.618 | |
| def __init__(self): | |
| try: | |
| self.app = ac.newApp("CamTool_2") | |
| ac.setBackgroundOpacity(self.app, 0) | |
| self.is_AC_visible = False | |
| self.__scale = 1 | |
| self.__active_cam = 0 | |
| self.__active_kf = 0 | |
| self.__active_menu = "camera" | |
| self.active_app = False | |
| self.__mode = "pos" | |
| self.__the_x = 0 | |
| self.__max_btns_in_column = 17 | |
| self.__file_form_visible = False | |
| self.__file_form_page = 0 | |
| self.__n_files = 0 | |
| self.__lock = {"interpolate_init": False} | |
| self.x = [] | |
| self.y = {} | |
| self.mouselook_start_camera = None | |
| self.__max_keyframes = self.__max_btns_in_column * 3 - 1 | |
| self.__max_cameras = self.__max_btns_in_column * 10 - 1 | |
| self.__btn_height = 24 * self.__scale | |
| self.__width = 350 * self.__scale | |
| self.__height = None | |
| self.__margin = vec(8 * self.__scale, 34 * self.__scale) | |
| self.__sizes = { | |
| "gold": vec(self.__btn_height * self.golden_ratio, self.__btn_height), | |
| "half": vec((self.__width - ((self.__btn_height * self.golden_ratio) * 2 + (self.__margin.x * 3))) / 2, self.__btn_height), | |
| "square": vec(self.__btn_height, self.__btn_height) | |
| } | |
| self.__offset = vec(self.__margin.x, self.__margin.y) | |
| self.__ui = {} | |
| self.__create_UI() | |
| self.__reset() | |
| except Exception as e: | |
| debug(e) | |
| def interpolate(self, strength, dt): | |
| global focused_car | |
| try: | |
| cam.set_tracked_car(0, focused_car) | |
| self.__interpolate(strength, dt) | |
| self.__ui["options"]["camera"]["camera_in"].set_focus() | |
| except Exception as e: | |
| debug(e) | |
| def activated(self): | |
| try: | |
| self.is_AC_visible = True | |
| return | |
| except Exception as e: | |
| debug(e) | |
| def dismissed(self): | |
| try: | |
| self.is_AC_visible = False | |
| return | |
| except Exception as e: | |
| debug(e) | |
| def refresh(self, strength, dt): | |
| try: | |
| ac.setBackgroundOpacity(self.app, 0) | |
| self.__update_btns() | |
| self.__interpolate(strength, dt) | |
| self.__ui["options"]["camera"]["camera_in"].set_focus() | |
| except Exception as e: | |
| debug(e) | |
| def __reset(self): | |
| self.set_active_kf(0) | |
| self.set_active_cam(0) | |
| #--------------------------------------------------------------------------- | |
| def __create_UI(self): | |
| try: | |
| self.__height = self.__btn_height * \ | |
| self.__max_btns_in_column + self.__margin.y + self.__margin.x | |
| ac.setSize(self.app, self.__width + self.__margin.x, self.__height) | |
| ac.drawBorder(self.app, 0) | |
| ac.setTitlePosition(self.app, 1000000, 0) | |
| ac.setIconPosition(self.app, 1000000, 0) | |
| self.divs = {} | |
| self.divs["bg"] = self.Div(self.app, vec(0, self.__margin.y + self.__btn_height), vec( | |
| self.__width, self.__margin.y - 1 + (self.__max_btns_in_column - 1) * self.__btn_height)) | |
| self.divs["top"] = self.Div(self.app, vec(0, self.__margin.y - self.__margin.x), vec( | |
| self.__width, self.__btn_height + 2 * self.__margin.x), vec3(0.15, 0.15, 0.15), 1) | |
| self.divs["side"] = self.Div( | |
| self.app, vec(), vec(), vec3(0.15, 0.15, 0.15), 1) | |
| self.__ui["divs"] = self.divs | |
| self.__create_header() | |
| self.__create_menu() | |
| self.__create_side_c() | |
| self.__create_side_k() | |
| self.__create_core() | |
| self.__create_file_form() | |
| except Exception as e: | |
| debug(e) | |
| def __create_header(self): | |
| try: | |
| self.ui = {} | |
| self.ui["info"] = {"height": self.__btn_height} | |
| self.ui["free_camera"] = self.Button(self.app, "Activate Free Camera", vec( | |
| 0, 2), vec(self.__width, self.__btn_height)) | |
| ac.addOnClickedListener( | |
| self.ui["free_camera"].get_btn(), header__free_camera) | |
| self.ui["title"] = self.Label(self.app, " CamTool 2", vec( | |
| 0, self.__offset.y), vec(85, self.__btn_height)) | |
| self.ui["the_x"] = self.Label(self.app, "()", self.ui["title"].get_pos( | |
| ) + vec(80, 0), vec(85, self.__btn_height)) | |
| #Activate | |
| self.ui["activate"] = self.Button(self.app, "", vec( | |
| self.__width - self.__sizes["square"].x - self.__margin.x, self.__offset.y), self.__sizes["square"]) | |
| self.ui["activate"].set_background("off", 0, 0) | |
| ac.addOnClickedListener( | |
| self.ui["activate"].get_btn(), header__activate) | |
| # self.ui["header_replay_mm"] = self.Button(self.app, "<<", self.ui["title"].get_next_pos() + vec(self.__margin.x, 0), self.__sizes["square"]) | |
| # self.ui["header_replay_m"] = self.Button(self.app, "<", self.ui["title"].header_replay_mm() + vec(self.__margin.x, 0), self.__sizes["square"]) | |
| # self.ui["header_jump_to_keyframe"] = self.Button(self.app, "^", self.ui["title"].get_next_pos() + vec(self.__margin.x, 0), self.__sizes["square"]) | |
| # self.ui["header_replay_m"] = self.Button(self.app, ">", self.ui["title"].header_replay_mm() + vec(self.__margin.x, 0), self.__sizes["square"]) | |
| self.ui["mode-pos"] = self.Button(self.app, "", self.ui["activate"].get_pos() - vec( | |
| self.__sizes["square"].x * 2 + self.__margin.x, 0), self.__sizes["square"]) | |
| self.ui["mode-time"] = self.Button( | |
| self.app, "", self.ui["mode-pos"].get_next_pos(), self.__sizes["square"]) | |
| self.ui["mode-pos"].set_background("pos", 0) | |
| self.ui["mode-time"].set_background("time", 0) | |
| ac.addOnClickedListener( | |
| self.ui["mode-pos"].get_btn(), header__mode_pos) | |
| ac.addOnClickedListener( | |
| self.ui["mode-time"].get_btn(), header__mode_time) | |
| self.__offset.y += self.ui["info"]["height"] | |
| self.__ui["header"] = self.ui | |
| except Exception as e: | |
| debug(e) | |
| def __create_side_c(self): | |
| try: | |
| self.ui = {} | |
| self.ui["top"] = self.Div( | |
| self.app, vec(), vec(), vec3(0.15, 0.15, 0.15), 1) | |
| self.ui["bg"] = self.Div( | |
| self.app, vec(), vec(), vec3(0.2, 0.2, 0.2), 1) | |
| ac.addOnClickedListener(self.ui["bg"].get_btn(), side_c) | |
| self.ui["icon_camera"] = self.Button( | |
| self.app, "", vec(), self.__sizes["square"]) | |
| self.ui["icon_camera"].set_background("camera", 0, 0) | |
| self.cameras = [] | |
| for self.i in range(self.__max_cameras+1): | |
| if self.i != 0: | |
| self.btn = self.Button( | |
| self.app, self.i, vec(), self.__sizes["square"]) | |
| self.cameras.append(self.btn) | |
| else: | |
| self.ui["remove"] = self.Button( | |
| self.app, "-", vec(), self.__sizes["square"]) | |
| ac.addOnClickedListener( | |
| self.ui["remove"].get_btn(), side_c__remove_camera) | |
| self.ui["cameras"] = self.cameras | |
| self.ui["add"] = self.Button( | |
| self.app, "+", vec(), self.__sizes["square"]) | |
| ac.addOnClickedListener( | |
| self.ui["add"].get_btn(), side_c__add_camera) | |
| self.__ui["side_c"] = self.ui | |
| except Exception as e: | |
| debug(e) | |
| def __create_side_k(self): | |
| try: | |
| self.ui = {} | |
| self.ui["top"] = self.Div( | |
| self.app, vec(), vec(), vec3(0.15, 0.15, 0.15), 1) | |
| self.ui["bg"] = self.Div( | |
| self.app, vec(), vec(), vec3(0.2, 0.2, 0.2), 1) | |
| ac.addOnClickedListener(self.ui["bg"].get_btn(), side_k) | |
| self.ui["icon_keyframe"] = self.Button( | |
| self.app, "", vec(), self.__sizes["square"]) | |
| self.ui["icon_keyframe"].set_background("keyframe", 0, 0) | |
| self.keyframes = [] | |
| for self.i in range(self.__max_keyframes+1): | |
| if self.i != 0: | |
| self.btn = self.Button( | |
| self.app, self.i, vec(), self.__sizes["square"]) | |
| self.keyframes.append(self.btn) | |
| else: | |
| self.ui["remove"] = self.Button( | |
| self.app, "-", vec(), self.__sizes["square"]) | |
| ac.addOnClickedListener( | |
| self.ui["remove"].get_btn(), side_k__remove_keyframe) | |
| self.ui["keyframes"] = self.keyframes | |
| self.ui["add"] = self.Button( | |
| self.app, "+", vec(), self.__sizes["square"]) | |
| ac.addOnClickedListener( | |
| self.ui["add"].get_btn(), side_k__add_keyframe) | |
| self.__ui["side_k"] = self.ui | |
| except Exception as e: | |
| debug(e) | |
| def __create_menu(self): | |
| try: | |
| self.ui = {} | |
| self.size = vec(self.__ui["header"]["title"].get_size( | |
| ).x - self.__margin.x, self.__btn_height) | |
| self.color = vec3(0.25, 0.25, 0.25) | |
| self.alignment = "left" | |
| self.offset = vec(0, self.__margin.y + | |
| self.__btn_height + self.__margin.x + 1) | |
| self.ui["camera"] = self.Button( | |
| self.app, "Camera", self.offset, self.size, self.color, self.alignment) | |
| self.ui["transform"] = self.Button( | |
| self.app, "Transform", self.ui["camera"].get_next_pos_v(), self.size, self.color, self.alignment) | |
| self.ui["tracking"] = self.Button(self.app, "Tracking", self.ui["transform"].get_next_pos_v( | |
| ), self.size, self.color, self.alignment) | |
| self.ui["spline"] = self.Button(self.app, "Spline", self.ui["tracking"].get_next_pos_v( | |
| ), self.size, self.color, self.alignment) | |
| self.ui["settings"] = self.Button(self.app, "Settings", self.ui["spline"].get_next_pos_v( | |
| ), self.size, self.color, self.alignment) | |
| ac.addOnClickedListener( | |
| self.ui["settings"].get_btn(), menu__settings) | |
| ac.addOnClickedListener( | |
| self.ui["transform"].get_btn(), menu__transform) | |
| ac.addOnClickedListener(self.ui["spline"].get_btn(), menu__spline) | |
| ac.addOnClickedListener( | |
| self.ui["tracking"].get_btn(), menu__tracking) | |
| ac.addOnClickedListener(self.ui["camera"].get_btn(), menu__camera) | |
| self.__ui["menu"] = self.ui | |
| except Exception as e: | |
| debug(e) | |
| def __create_file_form(self): | |
| try: | |
| self.ui = {} | |
| self.offset = vec(ac.getSize(self.app)[ | |
| 0] - self.__margin.x + 1, self.__margin.y - self.__margin.x) | |
| self.size = vec(ac.getSize(self.app)[0] * 0.61, self.__btn_height) | |
| self.btn_size = vec(50, self.__btn_height) | |
| self.ui["top"] = self.Div(self.app, self.offset, vec( | |
| self.size.x, self.__btn_height + 2 * self.__margin.x), vec3(0.15, 0.15, 0.15), 1) | |
| self.ui["bg_big"] = self.Div(self.app, self.ui["top"].get_pos() - vec(1, 0), vec( | |
| self.size.x + 2, self.__btn_height * self.__max_btns_in_column + self.ui["top"].get_size().y + 1), vec3(0.15, 0.15, 0.15), 1) | |
| self.ui["bg"] = self.Div(self.app, self.ui["top"].get_next_pos_v(), vec( | |
| self.size.x, self.__btn_height * self.__max_btns_in_column), vec3(0.2, 0.2, 0.2), 1) | |
| self.ui["cancel"] = self.Button(self.app, "Cancel", self.offset + vec( | |
| self.size.x - self.btn_size.x, self.__margin.x), self.btn_size) | |
| self.ui["save"] = self.Button(self.app, "Save", self.ui["cancel"].get_pos( | |
| ) - vec(self.ui["cancel"].get_size().x, 0), self.btn_size) | |
| self.ui["input"] = self.Input(self.app, "", self.offset + vec(0, self.__margin.x), vec( | |
| self.size.x - self.__margin.x - 2 * self.btn_size.x, self.__btn_height)) | |
| self.ui["buttons"] = [] | |
| self.ui["buttons_x"] = [] | |
| for self.i in range(self.__max_btns_in_column): | |
| self.btn_pos = self.ui["input"].get_next_pos_v( | |
| ) + vec(0, self.__margin.x + 1) + vec(0, self.i * self.__btn_height) | |
| self.ui["buttons"].append(self.Button(self.app, "Slot", self.btn_pos, vec( | |
| self.ui["top"].get_size().x - self.__btn_height, self.__btn_height))) | |
| self.__btn_x = self.Button(self.app, "", self.btn_pos + vec(self.ui["top"].get_size( | |
| ).x - self.__btn_height, 0), vec(self.__btn_height, self.__btn_height)) | |
| self.__btn_x.set_background("remove") | |
| self.ui["buttons_x"].append(self.__btn_x) | |
| ac.addOnClickedListener( | |
| self.ui["bg"].get_btn(), file_form__wrapper) | |
| ac.addOnClickedListener( | |
| self.ui["cancel"].get_btn(), file_form__cancel) | |
| ac.addOnClickedListener( | |
| self.ui["save"].get_btn(), file_form__save_or_load) | |
| self.__ui["file_form"] = self.ui | |
| except Exception as e: | |
| debug(e) | |
| #--------------------------------------------------------------------------- | |
| def __create_core(self): | |
| try: | |
| self.__ui["options"] = {} | |
| self.ui = {} | |
| self.ui["info"] = { | |
| "start_pos": vec(self.__ui["menu"]["camera"].get_size().x + self.__margin.x, self.__ui["menu"]["camera"].get_pos().y + self.__btn_height + self.__margin.x), | |
| "width": self.__width - (self.__ui["menu"]["camera"].get_size().x + self.__margin.x * 2), | |
| "size": vec(self.__width - (self.__ui["menu"]["camera"].get_size().x + self.__margin.x * 2), self.__btn_height) | |
| } | |
| self.__ui["options"].update(self.ui) | |
| self.__create_keyframe() | |
| self.__create_settings() | |
| self.__create_transform() | |
| self.__create_tracking() | |
| self.__create_spline() | |
| self.__create_camera_options() | |
| except Exception as e: | |
| debug(e) | |
| def __create_keyframe(self): | |
| try: | |
| self.ui = {"pos": {}, "time": {}} | |
| #pos | |
| self.size = self.__sizes["square"] # arrow buttons | |
| self.ui["pos"]["--"] = self.Button(self.app, "", self.__ui["menu"] | |
| ["camera"].get_next_pos() + vec(self.__margin.x, 0), self.size) | |
| self.ui["pos"]["-"] = self.Button(self.app, "", | |
| self.ui["pos"]["--"].get_next_pos(), self.size) | |
| self.ui["pos"]["keyframe"] = self.Button(self.app, "Keyframe", self.ui["pos"]["-"].get_next_pos( | |
| ), self.__ui["options"]["info"]["size"] - vec(4 * self.size.x, 0)) | |
| self.ui["pos"]["+"] = self.Button( | |
| self.app, "", self.ui["pos"]["keyframe"].get_next_pos(), self.size) | |
| self.ui["pos"]["++"] = self.Button(self.app, "", | |
| self.ui["pos"]["+"].get_next_pos(), self.size) | |
| self.ui["pos"]["--"].set_background("prev+") | |
| self.ui["pos"]["-"].set_background("prev") | |
| self.ui["pos"]["+"].set_background("next") | |
| self.ui["pos"]["++"].set_background("next+") | |
| ac.addOnClickedListener( | |
| self.ui["pos"]["keyframe"].get_btn(), keyframes__pos) | |
| ac.addOnClickedListener( | |
| self.ui["pos"]["--"].get_btn(), keyframes__pos_mm) | |
| ac.addOnClickedListener( | |
| self.ui["pos"]["-"].get_btn(), keyframes__pos_m) | |
| ac.addOnClickedListener( | |
| self.ui["pos"]["++"].get_btn(), keyframes__pos_pp) | |
| ac.addOnClickedListener( | |
| self.ui["pos"]["+"].get_btn(), keyframes__pos_p) | |
| #time | |
| self.ui["time"]["--"] = self.Button(self.app, "", self.__ui["menu"] | |
| ["camera"].get_next_pos() + vec(self.__margin.x, 0), self.size) | |
| self.ui["time"]["-"] = self.Button(self.app, "", | |
| self.ui["time"]["--"].get_next_pos(), self.size) | |
| self.ui["time"]["keyframe"] = self.Button(self.app, "-", self.ui["time"]["-"].get_next_pos( | |
| ), self.__ui["options"]["info"]["size"] - vec(4 * self.size.x, 0)) | |
| self.ui["time"]["+"] = self.Button( | |
| self.app, "", self.ui["time"]["keyframe"].get_next_pos(), self.size) | |
| self.ui["time"]["++"] = self.Button(self.app, "", | |
| self.ui["time"]["+"].get_next_pos(), self.size) | |
| self.ui["time"]["replay_sync"] = self.Button(self.app, "Sync", self.__ui["menu"]["camera"].get_next_pos( | |
| ) + vec(self.__margin.x, 0), self.__ui["options"]["info"]["size"]) | |
| self.ui["time"]["--"].set_background("prev+") | |
| self.ui["time"]["-"].set_background("prev") | |
| self.ui["time"]["+"].set_background("next") | |
| self.ui["time"]["++"].set_background("next+") | |
| ac.addOnClickedListener( | |
| self.ui["time"]["--"].get_btn(), keyframes__time_mm) | |
| ac.addOnClickedListener( | |
| self.ui["time"]["-"].get_btn(), keyframes__time_m) | |
| ac.addOnClickedListener( | |
| self.ui["time"]["keyframe"].get_btn(), keyframes__time) | |
| ac.addOnClickedListener( | |
| self.ui["time"]["+"].get_btn(), keyframes__time_p) | |
| ac.addOnClickedListener( | |
| self.ui["time"]["++"].get_btn(), keyframes__time_pp) | |
| ac.addOnClickedListener( | |
| self.ui["time"]["replay_sync"].get_btn(), replay_sync) | |
| self.__ui["options"]["keyframes"] = self.ui | |
| except Exception as e: | |
| debug(e) | |
| def __create_settings(self): | |
| try: | |
| self.ui = {} | |
| self.ui["save"] = self.Button(self.app, "Save", self.__ui["options"]["info"] | |
| ["start_pos"], self.__ui["options"]["info"]["size"] * vec(0.5, 1)) | |
| self.ui["load"] = self.Button( | |
| self.app, "Load", self.ui["save"].get_next_pos(), self.ui["save"].get_size()) | |
| #self.ui["settings_smart_tracking"] = self.Option(self.app, self.Button, self.Label, "Smart tracking", self.__ui["options"]["info"]["start_pos"] + vec(0, self.__btn_height + self.__margin.x), self.__ui["options"]["info"]["size"], True, False) | |
| self.ui["settings_track_spline"] = self.Option(self.app, self.Button, self.Label, "Track spline", self.__ui["options"]["info"]["start_pos"] + vec( | |
| 0, self.__btn_height + self.__margin.x), self.__ui["options"]["info"]["size"], True, False) | |
| self.ui["settings_pit_spline"] = self.Option(self.app, self.Button, self.Label, "Pit spline", self.ui["settings_track_spline"].get_next_pos_v( | |
| ), self.__ui["options"]["info"]["size"], True, False) | |
| self.ui["settings_reset"] = self.Button(self.app, "Reset", self.ui["settings_pit_spline"].get_next_pos_v( | |
| ) + vec(0, self.__margin.x), self.__ui["options"]["info"]["size"]) | |
| ac.addOnClickedListener( | |
| self.ui["save"].get_btn(), settings__show_form__save) | |
| ac.addOnClickedListener( | |
| self.ui["load"].get_btn(), settings__show_form__load) | |
| #ac.addOnClickedListener(self.ui["settings_smart_tracking"].get_btn(), settings__smart_tracking) | |
| ac.addOnClickedListener( | |
| self.ui["settings_track_spline"].get_btn(), settings_track_spline) | |
| ac.addOnClickedListener( | |
| self.ui["settings_pit_spline"].get_btn(), settings_pit_spline) | |
| ac.addOnClickedListener( | |
| self.ui["settings_reset"].get_btn(), settings_reset) | |
| self.__ui["options"]["settings"] = self.ui | |
| except Exception as e: | |
| debug(e) | |
| def __create_transform(self): | |
| try: | |
| self.ui = {} | |
| self.ui["lbl_location"] = self.Label(self.app, "Location", self.__ui["options"]["info"]["start_pos"], vec( | |
| self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["lbl_location"].set_alignment("center") | |
| self.ui["lbl_location"].set_bold(True) | |
| self.ui["loc_x"] = self.Option(self.app, self.Button, self.Label, "X", self.ui["lbl_location"].get_next_pos_v( | |
| ), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["loc_y"] = self.Option( | |
| self.app, self.Button, self.Label, "Y", self.ui["loc_x"].get_next_pos_v(), self.ui["loc_x"].get_size()) | |
| self.ui["loc_z"] = self.Option( | |
| self.app, self.Button, self.Label, "Z", self.ui["loc_y"].get_next_pos_v(), self.ui["loc_y"].get_size()) | |
| self.ui["transform_loc_strength"] = self.Option( | |
| self.app, self.Button, self.Label, "Strength", self.ui["loc_z"].get_next_pos_v(), self.ui["loc_z"].get_size()) | |
| ac.addOnClickedListener( | |
| self.ui["loc_x"].get_btn(), transform__loc_x) | |
| ac.addOnClickedListener( | |
| self.ui["loc_y"].get_btn(), transform__loc_y) | |
| ac.addOnClickedListener( | |
| self.ui["loc_z"].get_btn(), transform__loc_z) | |
| ac.addOnClickedListener( | |
| self.ui["loc_x"].get_btn_m(), transform__loc_x_m) | |
| ac.addOnClickedListener( | |
| self.ui["loc_y"].get_btn_m(), transform__loc_y_m) | |
| ac.addOnClickedListener( | |
| self.ui["loc_z"].get_btn_m(), transform__loc_z_m) | |
| ac.addOnClickedListener( | |
| self.ui["loc_x"].get_btn_p(), transform__loc_x_p) | |
| ac.addOnClickedListener( | |
| self.ui["loc_y"].get_btn_p(), transform__loc_y_p) | |
| ac.addOnClickedListener( | |
| self.ui["loc_z"].get_btn_p(), transform__loc_z_p) | |
| ac.addOnClickedListener( | |
| self.ui["transform_loc_strength"].get_btn_m(), transform__loc_strength_m) | |
| ac.addOnClickedListener( | |
| self.ui["transform_loc_strength"].get_btn(), transform__loc_strength) | |
| ac.addOnClickedListener( | |
| self.ui["transform_loc_strength"].get_btn_p(), transform__loc_strength_p) | |
| self.ui["lbl_rotation"] = self.Label(self.app, "Rotation", self.ui["transform_loc_strength"].get_next_pos_v( | |
| ) + vec(0, self.__margin.x), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["lbl_rotation"].set_alignment("center") | |
| self.ui["lbl_rotation"].set_bold(True) | |
| self.ui["rot_x"] = self.Option(self.app, self.Button, self.Label, "Pitch", | |
| self.ui["lbl_rotation"].get_next_pos_v(), self.ui["loc_z"].get_size()) | |
| self.ui["rot_y"] = self.Option( | |
| self.app, self.Button, self.Label, "Roll", self.ui["rot_x"].get_next_pos_v(), self.ui["rot_x"].get_size()) | |
| self.ui["rot_z"] = self.Option(self.app, self.Button, self.Label, "Heading", | |
| self.ui["rot_y"].get_next_pos_v(), self.ui["rot_y"].get_size()) | |
| self.ui["rot_x"].show_reset_button() | |
| self.ui["rot_y"].show_reset_button() | |
| self.ui["transform_rot_strength"] = self.Option( | |
| self.app, self.Button, self.Label, "Strength*", self.ui["rot_z"].get_next_pos_v(), self.ui["rot_z"].get_size()) | |
| self.ui["lbl_rot_strength_exception"] = self.Label(self.app, "*except roll", vec( | |
| self.ui["transform_rot_strength"].get_next_pos_v().x, self.__height), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["lbl_rot_strength_exception"].set_font_size(12) | |
| ac.addOnClickedListener( | |
| self.ui["rot_x"].get_btn(), transform__rot_x) | |
| ac.addOnClickedListener( | |
| self.ui["rot_y"].get_btn(), transform__rot_y) | |
| ac.addOnClickedListener( | |
| self.ui["rot_z"].get_btn(), transform__rot_z) | |
| ac.addOnClickedListener( | |
| self.ui["rot_x"].get_btn_m(), transform__rot_x_m) | |
| ac.addOnClickedListener( | |
| self.ui["rot_y"].get_btn_m(), transform__rot_y_m) | |
| ac.addOnClickedListener( | |
| self.ui["rot_z"].get_btn_m(), transform__rot_z_m) | |
| ac.addOnClickedListener( | |
| self.ui["rot_x"].get_btn_p(), transform__rot_x_p) | |
| ac.addOnClickedListener( | |
| self.ui["rot_y"].get_btn_p(), transform__rot_y_p) | |
| ac.addOnClickedListener( | |
| self.ui["rot_z"].get_btn_p(), transform__rot_z_p) | |
| ac.addOnClickedListener( | |
| self.ui["rot_x"].get_btn_reset(), transform__reset_pitch) | |
| ac.addOnClickedListener( | |
| self.ui["rot_y"].get_btn_reset(), transform__reset_roll) | |
| ac.addOnClickedListener( | |
| self.ui["transform_rot_strength"].get_btn_m(), transform__rot_strength_m) | |
| ac.addOnClickedListener( | |
| self.ui["transform_rot_strength"].get_btn(), transform__rot_strength) | |
| ac.addOnClickedListener( | |
| self.ui["transform_rot_strength"].get_btn_p(), transform__rot_strength_p) | |
| self.__ui["options"]["transform"] = self.ui | |
| except Exception as e: | |
| debug(e) | |
| def __create_spline(self): | |
| try: | |
| self.ui = {} | |
| self.size = self.__ui["options"]["info"]["size"] | |
| self.ui["spline_record"] = self.Button( | |
| self.app, "Record", self.__ui["options"]["info"]["start_pos"], self.size) | |
| self.ui["spline_speed"] = self.Option(self.app, self.Button, self.Label, "Speed", | |
| self.ui["spline_record"].get_next_pos_v() + vec(0, self.__margin.x), self.size) | |
| self.ui["lbl_affect"] = self.Label(self.app, "Strength", self.ui["spline_speed"].get_next_pos_v( | |
| ) + vec(0, self.__margin.x), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["lbl_affect"].set_alignment("center") | |
| self.ui["lbl_affect"].set_bold(True) | |
| self.ui["spline_affect_loc_xy"] = self.Option( | |
| self.app, self.Button, self.Label, "Location XY", self.ui["lbl_affect"].get_next_pos_v(), self.size) | |
| self.ui["spline_affect_loc_z"] = self.Option( | |
| self.app, self.Button, self.Label, "Location Z", self.ui["spline_affect_loc_xy"].get_next_pos_v(), self.size) | |
| self.ui["spline_affect_pitch"] = self.Option( | |
| self.app, self.Button, self.Label, "Pitch", self.ui["spline_affect_loc_z"].get_next_pos_v(), self.size) | |
| self.ui["spline_affect_roll"] = self.Option( | |
| self.app, self.Button, self.Label, "Roll", self.ui["spline_affect_pitch"].get_next_pos_v(), self.size) | |
| self.ui["spline_affect_heading"] = self.Option( | |
| self.app, self.Button, self.Label, "Heading", self.ui["spline_affect_roll"].get_next_pos_v(), self.size) | |
| self.ui["lbl_offset"] = self.Label(self.app, "Offset", self.ui["spline_affect_heading"].get_next_pos_v( | |
| ) + vec(0, self.__margin.x), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["lbl_offset"].set_alignment("center") | |
| self.ui["lbl_offset"].set_bold(True) | |
| self.ui["spline_offset_pitch"] = self.Option( | |
| self.app, self.Button, self.Label, "Pitch", self.ui["lbl_offset"].get_next_pos_v(), self.size) | |
| self.ui["spline_offset_heading"] = self.Option( | |
| self.app, self.Button, self.Label, "Heading", self.ui["spline_offset_pitch"].get_next_pos_v(), self.size) | |
| self.ui["spline_offset_loc_x"] = self.Option( | |
| self.app, self.Button, self.Label, "Location X", self.ui["spline_offset_heading"].get_next_pos_v(), self.size) | |
| self.ui["spline_offset_loc_z"] = self.Option( | |
| self.app, self.Button, self.Label, "Location Z", self.ui["spline_offset_loc_x"].get_next_pos_v(), self.size) | |
| self.ui["spline_offset_spline"] = self.Option( | |
| self.app, self.Button, self.Label, "Spline", self.ui["spline_offset_loc_z"].get_next_pos_v(), self.size) | |
| self.ui["spline_offset_spline"].show_reset_button() | |
| ac.addOnClickedListener( | |
| self.ui["spline_record"].get_btn(), spline__record) | |
| ac.addOnClickedListener( | |
| self.ui["spline_speed"].get_btn_m(), spline__speed_m) | |
| ac.addOnClickedListener( | |
| self.ui["spline_speed"].get_btn(), spline__speed) | |
| ac.addOnClickedListener( | |
| self.ui["spline_speed"].get_btn_p(), spline__speed_p) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_loc_xy"].get_btn_m(), spline__affect_loc_xy_m) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_loc_xy"].get_btn(), spline__affect_loc_xy) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_loc_xy"].get_btn_p(), spline__affect_loc_xy_p) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_loc_z"].get_btn_m(), spline__affect_loc_z_m) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_loc_z"].get_btn(), spline__affect_loc_z) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_loc_z"].get_btn_p(), spline__affect_loc_z_p) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_pitch"].get_btn_m(), spline_affect_pitch_m) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_pitch"].get_btn(), spline_affect_pitch) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_pitch"].get_btn_p(), spline_affect_pitch_p) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_roll"].get_btn_m(), spline_affect_roll_m) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_roll"].get_btn(), spline_affect_roll) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_roll"].get_btn_p(), spline_affect_roll_p) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_heading"].get_btn_m(), spline_affect_heading_m) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_heading"].get_btn(), spline_affect_heading) | |
| ac.addOnClickedListener( | |
| self.ui["spline_affect_heading"].get_btn_p(), spline_affect_heading_p) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_pitch"].get_btn_m(), spline_offset_pitch_m) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_pitch"].get_btn(), spline_offset_pitch) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_pitch"].get_btn_p(), spline_offset_pitch_p) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_heading"].get_btn_m(), spline_offset_heading_m) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_heading"].get_btn(), spline_offset_heading) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_heading"].get_btn_p(), spline_offset_heading_p) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_loc_z"].get_btn_m(), spline_offset_loc_z_m) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_loc_z"].get_btn(), spline_offset_loc_z) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_loc_z"].get_btn_p(), spline_offset_loc_z_p) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_loc_x"].get_btn_m(), spline_offset_loc_x_m) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_loc_x"].get_btn(), spline_offset_loc_x) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_loc_x"].get_btn_p(), spline_offset_loc_x_p) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_spline"].get_btn_m(), spline_offset_spline_m) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_spline"].get_btn(), spline_offset_spline) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_spline"].get_btn_p(), spline_offset_spline_p) | |
| ac.addOnClickedListener( | |
| self.ui["spline_offset_spline"].get_btn_reset(), spline_offset_reset) | |
| self.__ui["options"]["spline"] = self.ui | |
| except Exception as e: | |
| debug(e) | |
| def __create_tracking(self): | |
| try: | |
| self.ui = {} | |
| self.ui["lbl_tracking"] = self.Label(self.app, "Tracking", self.__ui["options"]["info"]["start_pos"], vec( | |
| self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["lbl_tracking"].set_alignment("center") | |
| self.ui["lbl_tracking"].set_bold(True) | |
| self.ui["car_1"] = self.Option(self.app, self.Button, self.Label, "Active car", self.ui["lbl_tracking"].get_next_pos_v( | |
| ), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["tracking_mix"] = self.Option( | |
| self.app, self.Button, self.Label, "Mix", self.ui["car_1"].get_next_pos_v(), self.ui["car_1"].get_size()) | |
| self.ui["car_2"] = self.Option(self.app, self.Button, self.Label, "Extra car", | |
| self.ui["tracking_mix"].get_next_pos_v(), self.ui["car_1"].get_size()) | |
| self.ui["lbl_offset"] = self.Label(self.app, "Offset", self.ui["car_2"].get_next_pos_v( | |
| ) + vec(0, self.__margin.x), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["lbl_offset"].set_alignment("center") | |
| self.ui["lbl_offset"].set_bold(True) | |
| self.ui["tracking_offset"] = self.Option( | |
| self.app, self.Button, self.Label, "Tracking", self.ui["lbl_offset"].get_next_pos_v(), self.ui["car_1"].get_size()) | |
| self.ui["tracking_offset_pitch"] = self.Option(self.app, self.Button, self.Label, "Pitch", self.ui["tracking_offset"].get_next_pos_v( | |
| ) + vec(0, self.__margin.x), self.ui["car_1"].get_size()) | |
| self.ui["tracking_offset_heading"] = self.Option( | |
| self.app, self.Button, self.Label, "Heading", self.ui["tracking_offset_pitch"].get_next_pos_v(), self.ui["car_1"].get_size()) | |
| self.ui["lbl_strength"] = self.Label(self.app, "Strength", self.ui["tracking_offset_heading"].get_next_pos_v( | |
| ) + vec(0, self.__margin.x), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["lbl_strength"].set_alignment("center") | |
| self.ui["lbl_strength"].set_bold(True) | |
| self.ui["tracking_strength_pitch"] = self.Option( | |
| self.app, self.Button, self.Label, "Pitch", self.ui["lbl_strength"].get_next_pos_v(), self.ui["car_1"].get_size()) | |
| self.ui["tracking_strength_heading"] = self.Option( | |
| self.app, self.Button, self.Label, "Heading", self.ui["tracking_strength_pitch"].get_next_pos_v(), self.ui["car_1"].get_size()) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_offset"].get_btn_m(), tracking__offset_m) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_offset"].get_btn(), tracking__offset) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_offset"].get_btn_p(), tracking__offset_p) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_strength_pitch"].get_btn_m(), tracking__strength_pitch_m) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_strength_pitch"].get_btn(), tracking__strength_pitch) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_strength_pitch"].get_btn_p(), tracking__strength_pitch_p) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_strength_heading"].get_btn_m(), tracking__strength_heading_m) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_strength_heading"].get_btn(), tracking__strength_heading) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_strength_heading"].get_btn_p(), tracking__strength_heading_p) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_offset_pitch"].get_btn_m(), tracking__offset_pitch_m) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_offset_pitch"].get_btn(), tracking__offset_pitch) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_offset_pitch"].get_btn_p(), tracking__offset_pitch_p) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_offset_heading"].get_btn_m(), tracking__offset_heading_m) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_offset_heading"].get_btn(), tracking__offset_heading) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_offset_heading"].get_btn_p(), tracking__offset_heading_p) | |
| ac.addOnClickedListener( | |
| self.ui["car_1"].get_btn_m(), tracking__car_1_m) | |
| ac.addOnClickedListener( | |
| self.ui["car_1"].get_btn(), tracking__car_1) | |
| ac.addOnClickedListener( | |
| self.ui["car_1"].get_btn_p(), tracking__car_1_p) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_mix"].get_btn_m(), tracking__mix_m) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_mix"].get_btn(), tracking__mix) | |
| ac.addOnClickedListener( | |
| self.ui["tracking_mix"].get_btn_p(), tracking__mix_p) | |
| ac.addOnClickedListener( | |
| self.ui["car_2"].get_btn_m(), tracking__car_2_m) | |
| ac.addOnClickedListener( | |
| self.ui["car_2"].get_btn(), tracking__car_2) | |
| ac.addOnClickedListener( | |
| self.ui["car_2"].get_btn_p(), tracking__car_2_p) | |
| self.__ui["options"]["tracking"] = self.ui | |
| except Exception as e: | |
| debug(e) | |
| def __create_camera_options(self): | |
| try: | |
| self.ui = {} | |
| self.ui["lbl_activation"] = self.Label(self.app, "Activation", self.__ui["options"]["info"]["start_pos"], vec( | |
| self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["lbl_activation"].set_alignment("center") | |
| self.ui["lbl_activation"].set_bold(True) | |
| self.ui["camera_in"] = self.Editable_Button(self.app, self.Button, self.Input, self.Label, "Camera in", self.ui["lbl_activation"].get_next_pos_v( | |
| ), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| ac.addOnClickedListener( | |
| self.ui["camera_in"].get_btn(), camera__camera_in__show_input) | |
| ac.addOnValidateListener( | |
| self.ui["camera_in"].get_input(), camera__camera_in__hide_input) | |
| self.ui["camera_pit"] = self.Option(self.app, self.Button, self.Label, "True", self.ui["camera_in"].get_next_pos_v( | |
| ), self.ui["camera_in"].get_size(), True, False, "Pit only") | |
| self.ui["lbl_camera"] = self.Label(self.app, "Camera", self.ui["camera_pit"].get_next_pos_v( | |
| ) + vec(0, self.__margin.x), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["lbl_camera"].set_alignment("center") | |
| self.ui["lbl_camera"].set_bold(True) | |
| self.ui["camera_focus_point"] = self.Option( | |
| self.app, self.Button, self.Label, "Focus point", self.ui["lbl_camera"].get_next_pos_v(), self.ui["camera_pit"].get_size()) | |
| self.ui["camera_use_tracking_point"] = self.Option(self.app, self.Button, self.Label, "True", self.ui["camera_focus_point"].get_next_pos_v( | |
| ), self.ui["camera_focus_point"].get_size(), True, False, "Autofocus") | |
| self.ui["camera_fov"] = self.Option(self.app, self.Button, self.Label, "FOV", self.ui["camera_focus_point"].get_next_pos_v( | |
| ) + vec(0, self.__margin.x + self.__btn_height), self.ui["camera_focus_point"].get_size()) | |
| self.ui["lbl_shake"] = self.Label(self.app, "Shake", self.ui["camera_fov"].get_next_pos_v( | |
| ) + vec(0, self.__margin.x), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["lbl_shake"].set_alignment("center") | |
| self.ui["lbl_shake"].set_bold(True) | |
| self.ui["camera_shake"] = self.Option(self.app, self.Button, self.Label, "Camera", self.ui["lbl_shake"].get_next_pos_v( | |
| ), vec(self.__ui["options"]["info"]["width"], self.__btn_height)) | |
| self.ui["camera_offset_shake"] = self.Option( | |
| self.app, self.Button, self.Label, "Tracking", self.ui["camera_shake"].get_next_pos_v(), self.ui["camera_shake"].get_size()) | |
| ac.addOnClickedListener( | |
| self.ui["camera_shake"].get_btn_p(), camera__shake_p) | |
| ac.addOnClickedListener( | |
| self.ui["camera_shake"].get_btn(), camera__shake) | |
| ac.addOnClickedListener( | |
| self.ui["camera_shake"].get_btn_m(), camera__shake_m) | |
| ac.addOnClickedListener( | |
| self.ui["camera_offset_shake"].get_btn_p(), camera__offset_shake_p) | |
| ac.addOnClickedListener( | |
| self.ui["camera_offset_shake"].get_btn(), camera__offset_shake) | |
| ac.addOnClickedListener( | |
| self.ui["camera_offset_shake"].get_btn_m(), camera__offset_shake_m) | |
| ac.addOnClickedListener( | |
| self.ui["camera_focus_point"].get_btn_m(), camera__focus_m) | |
| ac.addOnClickedListener( | |
| self.ui["camera_focus_point"].get_btn(), camera__focus) | |
| ac.addOnClickedListener( | |
| self.ui["camera_focus_point"].get_btn_p(), camera__focus_p) | |
| ac.addOnClickedListener( | |
| self.ui["camera_use_tracking_point"].get_btn(), camera__use_tracking_point) | |
| ac.addOnClickedListener( | |
| self.ui["camera_pit"].get_btn(), camera__pit) | |
| ac.addOnClickedListener( | |
| self.ui["camera_fov"].get_btn_m(), camera__fov_m) | |
| ac.addOnClickedListener( | |
| self.ui["camera_fov"].get_btn(), camera__fov) | |
| ac.addOnClickedListener( | |
| self.ui["camera_fov"].get_btn_p(), camera__fov_p) | |
| self.__ui["options"]["camera"] = self.ui | |
| except Exception as e: | |
| debug(e) | |
| #--------------------------------------------------------------------------- | |
| def update_the_x(self): | |
| global focused_car | |
| if data.active_mode == "pos": | |
| self.__the_x = ac.getCarState( | |
| focused_car, acsys.CS.NormalizedSplinePosition) | |
| elif data.active_mode == "time": | |
| self.__the_x = replay.get_interpolated_replay_pos() | |
| def __update_btns(self): | |
| self.__update_side_btns() | |
| self.__update_menu() | |
| self.__update_file_form() | |
| self.__update_core_visibility() | |
| self.__update_text() | |
| def __update_side_btns(self): | |
| try: | |
| #keyframe slots positions | |
| for self.i in range(self.__max_keyframes + 1): | |
| self.init_offset = int(data.get_n_keyframes( | |
| self.__active_cam) / self.__max_btns_in_column) + 1 | |
| #consider add keyframe btn | |
| if data.get_n_keyframes(self.__active_cam) % self.__max_btns_in_column == self.__max_btns_in_column - 1: | |
| if data.get_n_keyframes(self.__active_cam) < self.__max_keyframes - 1: | |
| self.init_offset += 1 | |
| #grid | |
| self.x = int(self.i / self.__max_btns_in_column) - \ | |
| self.init_offset | |
| self.y = int(self.i % self.__max_btns_in_column) | |
| self.pos = vec( | |
| self.x * self.__sizes["square"].x - 1, | |
| self.y * self.__sizes["square"].y + self.__margin.y + | |
| self.__btn_height + self.__margin.x + 1 | |
| ) | |
| if self.i == 0: | |
| self.__ui["side_k"]["remove"].set_pos(self.pos) | |
| else: | |
| self.__ui["side_k"]["keyframes"][self.i - | |
| 1].set_pos(self.pos) | |
| #hide empty slots | |
| if self.i - 1 < data.get_n_keyframes(self.__active_cam): | |
| self.__ui["side_k"]["keyframes"][self.i-1].show() | |
| if self.i - 1 == self.__active_kf: | |
| self.__ui["side_k"]["keyframes"][self.i - | |
| 1].highlight(True) | |
| else: | |
| self.__ui["side_k"]["keyframes"][self.i - | |
| 1].highlight(False) | |
| if data.mode[data.active_mode][self.__active_cam].keyframes[self.i - 1].keyframe != None: | |
| self.__ui["side_k"]["keyframes"][self.i - | |
| 1].bold(True) | |
| else: | |
| self.__ui["side_k"]["keyframes"][self.i - | |
| 1].bold(False) | |
| else: | |
| self.__ui["side_k"]["keyframes"][self.i-1].hide() | |
| #set position of add btn | |
| if self.i - 1 == data.get_n_keyframes(self.__active_cam): | |
| self.__ui["side_k"]["add"].set_pos(self.pos) | |
| #hide add btn if max slots | |
| if self.__max_keyframes == data.get_n_keyframes(self.__active_cam): | |
| self.__ui["side_k"]["add"].hide() | |
| else: | |
| self.__ui["side_k"]["add"].show() | |
| self.offset_x = self.__ui["side_k"]["remove"].get_pos().x | |
| self.size_x_k = (self.__ui["side_k"]["add"].get_pos( | |
| ).x + self.__ui["side_k"]["add"].get_size().x) - self.offset_x | |
| self.__ui["side_k"]["icon_keyframe"].set_pos(vec( | |
| self.offset_x + (self.size_x_k - self.__sizes["square"].x) / 2, self.__margin.y)) | |
| #divs | |
| self.__ui["side_k"]["top"].set_pos( | |
| vec(self.offset_x, self.__margin.y - self.__margin.x)) | |
| self.__ui["side_k"]["top"].set_size( | |
| vec(self.size_x_k, self.__btn_height + self.__margin.x * 2)) | |
| self.__ui["side_k"]["bg"].set_pos( | |
| vec(self.offset_x, self.__margin.y + self.__btn_height + self.__margin.x)) | |
| self.__ui["side_k"]["bg"].set_size( | |
| vec(self.size_x_k, self.__btn_height * self.__max_btns_in_column)) | |
| #--------------------------------- | |
| #camera slots positions | |
| for self.i in range(self.__max_cameras + 1): | |
| self.init_offset = int( | |
| data.get_n_cameras() / self.__max_btns_in_column) + 1 | |
| #consider add keyframe btn | |
| if data.get_n_cameras() % self.__max_btns_in_column == self.__max_btns_in_column - 1: | |
| if data.get_n_cameras() < self.__max_cameras - 1: | |
| self.init_offset += 1 | |
| #grid | |
| self.x = int(self.i / self.__max_btns_in_column) - \ | |
| self.init_offset | |
| self.y = int(self.i % self.__max_btns_in_column) | |
| self.pos = vec( | |
| # offset.x => - keyframes | |
| self.x * self.__sizes["square"].x + self.offset_x - 1, | |
| self.y * self.__sizes["square"].y + self.__margin.y + \ | |
| self.__btn_height + self.__margin.x + 1 | |
| ) | |
| if self.i == 0: | |
| self.__ui["side_c"]["remove"].set_pos(self.pos) | |
| else: | |
| self.__ui["side_c"]["cameras"][self.i-1].set_pos(self.pos) | |
| #hide empty slots | |
| if self.i - 1 < data.get_n_cameras(): | |
| self.__ui["side_c"]["cameras"][self.i-1].show() | |
| #show active camera | |
| if self.i - 1 == self.__active_cam: | |
| self.__ui["side_c"]["cameras"][self.i - | |
| 1].highlight(True) | |
| else: | |
| self.__ui["side_c"]["cameras"][self.i - | |
| 1].highlight(False) | |
| if data.active_cam == self.i-1: | |
| self.__ui["side_c"]["cameras"][self.i-1].bold(True) | |
| else: | |
| self.__ui["side_c"]["cameras"][self.i - | |
| 1].bold(False) | |
| else: | |
| self.__ui["side_c"]["cameras"][self.i-1].hide() | |
| #set position of add btn | |
| if self.i - 1 == data.get_n_cameras(): | |
| self.__ui["side_c"]["add"].set_pos(self.pos) | |
| #hide add btn if max slots | |
| if self.__max_cameras == data.get_n_cameras(): | |
| self.__ui["side_c"]["add"].hide() | |
| else: | |
| self.__ui["side_c"]["add"].show() | |
| self.offset_x = self.__ui["side_c"]["remove"].get_pos().x | |
| self.size_x = (self.__ui["side_c"]["add"].get_pos( | |
| ).x + self.__ui["side_c"]["add"].get_size().x) - self.offset_x | |
| self.__ui["side_c"]["icon_camera"].set_pos(vec( | |
| self.offset_x + (self.size_x - self.__sizes["square"].x) / 2, self.__margin.y)) | |
| #divs | |
| self.__ui["side_c"]["top"].set_pos( | |
| vec(self.offset_x, self.__margin.y - self.__margin.x)) | |
| self.__ui["side_c"]["top"].set_size( | |
| vec(self.size_x, self.__btn_height + self.__margin.x * 2)) | |
| self.__ui["side_c"]["bg"].set_pos( | |
| vec(self.offset_x, self.__margin.y + self.__btn_height + self.__margin.x)) | |
| self.__ui["side_c"]["bg"].set_size( | |
| vec(self.size_x, self.__btn_height * self.__max_btns_in_column)) | |
| self.__ui["divs"]["side"].set_pos( | |
| vec(self.offset_x - 1, self.__margin.y - self.__margin.x)) | |
| self.height = self.__ui["side_c"]["top"].get_size( | |
| ).y + self.__ui["side_c"]["bg"].get_size().y + 1 | |
| self.__ui["divs"]["side"].set_size( | |
| vec(self.size_x + self.size_x_k + 3, self.height)) | |
| except Exception as e: | |
| debug(e) | |
| def __update_menu(self): | |
| try: | |
| #highlighht active menu | |
| for self.key, self.val in self.__ui["menu"].items(): | |
| if self.key == self.__active_menu: | |
| self.val.highlight(True) | |
| else: | |
| self.val.highlight(False) | |
| if (self.data().interpolation["loc_x"] == None and | |
| self.data().interpolation["loc_y"] == None and | |
| self.data().interpolation["loc_z"] == None and | |
| self.data().interpolation["transform_loc_strength"] == None and | |
| self.data().interpolation["transform_rot_strength"] == None and | |
| self.data().interpolation["rot_x"] == None and | |
| self.data().interpolation["rot_y"] == None and | |
| self.data().interpolation["rot_z"] == None): | |
| self.__ui["menu"]["transform"].bold(False) | |
| else: | |
| self.__ui["menu"]["transform"].bold(True) | |
| if (self.data().interpolation["camera_focus_point"] == None and | |
| self.data().interpolation["camera_fov"] == None and | |
| self.data().interpolation["camera_shake_strength"] == None and | |
| self.data().interpolation["camera_offset_shake_strength"] == None): | |
| self.__ui["menu"]["camera"].bold(False) | |
| else: | |
| self.__ui["menu"]["camera"].bold(True) | |
| if (self.data().interpolation["tracking_mix"] == None and | |
| self.data().interpolation["tracking_strength_pitch"] == None and | |
| self.data().interpolation["tracking_strength_heading"] == None and | |
| self.data().interpolation["tracking_offset_pitch"] == None and | |
| self.data().interpolation["tracking_offset_heading"] == None and | |
| self.data().interpolation["tracking_offset"] == None): | |
| self.__ui["menu"]["tracking"].bold(False) | |
| else: | |
| self.__ui["menu"]["tracking"].bold(True) | |
| if (self.data().interpolation["spline_speed"] == None and | |
| self.data().interpolation["spline_affect_loc_xy"] == None and | |
| self.data().interpolation["spline_affect_loc_z"] == None and | |
| self.data().interpolation["spline_affect_pitch"] == None and | |
| self.data().interpolation["spline_affect_roll"] == None and | |
| self.data().interpolation["spline_affect_heading"] == None and | |
| self.data().interpolation["spline_offset_loc_x"] == None and | |
| self.data().interpolation["spline_offset_loc_z"] == None and | |
| self.data().interpolation["spline_offset_pitch"] == None and | |
| self.data().interpolation["spline_offset_heading"] == None and | |
| self.data().interpolation["spline_offset_spline"] == None): | |
| self.__ui["menu"]["spline"].bold(False) | |
| else: | |
| self.__ui["menu"]["spline"].bold(True) | |
| except Exception as e: | |
| debug(e) | |
| def __update_file_form(self): | |
| try: | |
| self.files = [] | |
| #visibility | |
| for self.key, self.val in self.__ui["file_form"].items(): | |
| if self.key == "buttons" or self.key == "buttons_x": | |
| for self.val2 in range(len(self.__ui["file_form"][self.key])): | |
| if self.__file_form_visible: | |
| self.__ui["file_form"][self.key][self.val2].show() | |
| else: | |
| self.__ui["file_form"][self.key][self.val2].hide() | |
| else: | |
| if self.__file_form_visible: | |
| self.val.show() | |
| else: | |
| self.val.hide() | |
| if self.__file_form_visible: | |
| #update files | |
| for file in os.listdir(gDataPath): | |
| if file.endswith(".json"): | |
| self.file_name = file.split(".")[0] | |
| self.file_name = self.file_name.split("-") | |
| self.track_name = ac.getTrackName( | |
| 0) + "_" + ac.getTrackConfiguration(0) | |
| if self.file_name[0] == self.track_name: | |
| self.files.append(self.file_name[1]) | |
| self.__n_files = len(self.files) | |
| #update text | |
| for self.i in range(self.__max_btns_in_column): | |
| self.file_index = self.i + self.__file_form_page * self.__max_btns_in_column | |
| self.file_index -= 2 * self.__file_form_page | |
| if self.file_index < self.__n_files: | |
| self.__ui["file_form"]["buttons"][self.i].show() | |
| self.__ui["file_form"]["buttons_x"][self.i].show() | |
| if self.__file_form_page > 0 and self.i == 0: | |
| self.__ui["file_form"]["buttons"][0].set_text( | |
| "Show previous") | |
| else: | |
| self.__ui["file_form"]["buttons"][self.i].set_text( | |
| self.files[self.file_index]) | |
| if self.i == self.__max_btns_in_column - 1: | |
| if self.__n_files - (self.__max_btns_in_column * self.__file_form_page) > self.__max_btns_in_column: | |
| self.__ui["file_form"]["buttons"][self.__max_btns_in_column - 1].set_text( | |
| "Show more") | |
| else: | |
| self.__ui["file_form"]["buttons"][self.i].hide() | |
| self.__ui["file_form"]["buttons_x"][self.i].hide() | |
| except Exception as e: | |
| debug(e) | |
| def __update_core_visibility(self): | |
| try: | |
| #activate button | |
| if ac.getCameraMode() == 6: | |
| self.__ui["header"]["free_camera"].hide() | |
| else: | |
| self.__ui["header"]["free_camera"].show() | |
| for self.key, self.val in self.__ui["options"].items(): | |
| if self.key != "info" and self.key != "file_form": | |
| if self.key != "keyframes": | |
| if self.key != self.__active_menu: | |
| for self.key2, self.val2 in self.val.items(): | |
| self.val2.hide() | |
| else: | |
| for self.key2, self.val2 in self.val.items(): | |
| self.val2.show() | |
| else: | |
| #keyframe | |
| for self.key4, self.val4 in self.__ui["options"]["keyframes"].items(): | |
| for self.key5, self.val5 in self.val4.items(): | |
| if data.active_mode == self.key4: | |
| self.val5.show() | |
| else: | |
| self.val5.hide() | |
| if data.active_mode == "time": | |
| self.wrapper = self.__ui["options"]["keyframes"]["time"] | |
| self.wrapper["replay_sync"].hide() | |
| for self.key, self.val in self.wrapper.items(): | |
| if replay.is_sync(): | |
| if self.key == "replay_sync": | |
| self.val.hide() | |
| else: | |
| self.val.show() | |
| else: | |
| if self.key == "replay_sync": | |
| self.val.show() | |
| else: | |
| self.val.hide() | |
| except Exception as e: | |
| debug(e) | |
| #--------------------------------------------------------------------------- | |
| def __update_text(self): | |
| self.__update_keyframe_btns() | |
| self.__update_settings() | |
| self.__update_transform() | |
| self.__update_tracking() | |
| self.__update_spline() | |
| self.__update_mode() | |
| self.__update_camera_options() | |
| def __update_keyframe_btns(self): | |
| global focused_car | |
| try: | |
| if data.active_mode == "pos": | |
| if self.data().keyframe == None: | |
| self.__ui["options"]["keyframes"]["pos"]["keyframe"].set_text(ac.getCarState( | |
| focused_car, acsys.CS.NormalizedSplinePosition) * ac.getTrackLength(), True, "m") | |
| self.__ui["options"]["keyframes"]["pos"]["keyframe"].highlight( | |
| False) | |
| else: | |
| self.__ui["options"]["keyframes"]["pos"]["keyframe"].set_text( | |
| self.data().keyframe * ac.getTrackLength(), True, "m") | |
| self.__ui["options"]["keyframes"]["pos"]["keyframe"].highlight( | |
| True) | |
| elif data.active_mode == "time": | |
| if self.data().keyframe == None: | |
| self.__ui["options"]["keyframes"]["time"]["keyframe"].set_text("{0:.1f}".format( | |
| replay.get_interpolated_replay_pos() / (1000 / replay.get_refresh_rate()))) | |
| self.__ui["options"]["keyframes"]["time"]["keyframe"].highlight( | |
| False) | |
| else: | |
| self.__ui["options"]["keyframes"]["time"]["keyframe"].set_text( | |
| "{0:.1f}".format(self.data().keyframe / (1000 / replay.get_refresh_rate()))) | |
| self.__ui["options"]["keyframes"]["time"]["keyframe"].highlight( | |
| True) | |
| except Exception as e: | |
| debug(e) | |
| def __update_mode(self): | |
| try: | |
| if data.active_mode == "pos": | |
| self.__ui["header"]["mode-pos"].set_background("pos_active", 0) | |
| self.__ui["header"]["mode-time"].set_background("time", 0) | |
| else: | |
| self.__ui["header"]["mode-pos"].set_background("pos", 0) | |
| self.__ui["header"]["mode-time"].set_background( | |
| "time_active", 0) | |
| if data.active_mode == "pos": | |
| self.__ui["header"]["the_x"].set_text( | |
| "({0:.0f} m)".format(self.__the_x * ac.getTrackLength())) | |
| if data.active_mode == "time": | |
| if replay.get_refresh_rate() == -1: | |
| self.__ui["header"]["the_x"].set_text("") | |
| else: | |
| self.__ui["header"]["the_x"].set_text("({0:.1f} s)".format( | |
| self.__the_x / (1000 / replay.get_refresh_rate()))) | |
| except Exception as e: | |
| debug(e) | |
| def __update_settings(self): | |
| try: | |
| if self.__active_menu == "settings": | |
| # if data.smart_tracking: | |
| # self.__ui["options"]["settings"]["settings_smart_tracking"].highlight(True) | |
| # else: | |
| # self.__ui["options"]["settings"]["settings_smart_tracking"].highlight(False) | |
| if cam.get_recording_status("track"): | |
| self.__ui["options"]["settings"]["settings_track_spline"].set_text( | |
| "Stop") | |
| else: | |
| if len(data.track_spline["the_x"]) == 0: | |
| self.__ui["options"]["settings"]["settings_track_spline"].set_text( | |
| "Record") | |
| else: | |
| self.__ui["options"]["settings"]["settings_track_spline"].set_text( | |
| "Remove") | |
| if cam.get_recording_status("pit"): | |
| self.__ui["options"]["settings"]["settings_pit_spline"].set_text( | |
| "Stop") | |
| else: | |
| if len(data.pit_spline["the_x"]) == 0: | |
| self.__ui["options"]["settings"]["settings_pit_spline"].set_text( | |
| "Record") | |
| else: | |
| self.__ui["options"]["settings"]["settings_pit_spline"].set_text( | |
| "Remove") | |
| except Exception as e: | |
| debug(e) | |
| def __update_transform(self): | |
| global loc_x, loc_y, loc_z, rot_x, rot_y, rot_z | |
| try: | |
| if self.__active_menu == "transform": | |
| self.loc_x = self.data().interpolation["loc_x"] | |
| if self.loc_x == None: | |
| self.loc_x = loc_x | |
| self.__ui["options"]["transform"]["loc_x"].highlight(False) | |
| else: | |
| self.__ui["options"]["transform"]["loc_x"].highlight(True) | |
| self.__ui["options"]["transform"]["loc_x"].set_text( | |
| self.loc_x, True, "m") | |
| self.loc_y = self.data().interpolation["loc_y"] | |
| if self.loc_y == None: | |
| self.loc_y = loc_y | |
| self.__ui["options"]["transform"]["loc_y"].highlight(False) | |
| else: | |
| self.__ui["options"]["transform"]["loc_y"].highlight(True) | |
| self.__ui["options"]["transform"]["loc_y"].set_text( | |
| self.loc_y, True, "m") | |
| self.loc_z = self.data().interpolation["loc_z"] | |
| if self.loc_z == None: | |
| self.loc_z = loc_z | |
| self.__ui["options"]["transform"]["loc_z"].highlight(False) | |
| else: | |
| self.__ui["options"]["transform"]["loc_z"].highlight(True) | |
| self.__ui["options"]["transform"]["loc_z"].set_text( | |
| self.loc_z, True, "m") | |
| self.rot_x = self.data().interpolation["rot_x"] | |
| if self.rot_x == None: | |
| self.rot_x = rot_x | |
| self.__ui["options"]["transform"]["rot_x"].highlight(False) | |
| else: | |
| self.__ui["options"]["transform"]["rot_x"].highlight(True) | |
| self.__ui["options"]["transform"]["rot_x"].set_text( | |
| self.rot_x, True, "degrees") | |
| self.rot_y = self.data().interpolation["rot_y"] | |
| if self.rot_y == None: | |
| self.rot_y = rot_y | |
| self.__ui["options"]["transform"]["rot_y"].highlight(False) | |
| else: | |
| self.__ui["options"]["transform"]["rot_y"].highlight(True) | |
| self.__ui["options"]["transform"]["rot_y"].set_text( | |
| self.rot_y, True, "degrees") | |
| self.rot_z = self.data().interpolation["rot_z"] | |
| if self.rot_z == None: | |
| self.rot_z = rot_z | |
| self.__ui["options"]["transform"]["rot_z"].highlight(False) | |
| else: | |
| self.__ui["options"]["transform"]["rot_z"].highlight(True) | |
| self.__ui["options"]["transform"]["rot_z"].set_text( | |
| self.rot_z, True, "degrees") | |
| self.transform_loc_strength = self.data( | |
| ).interpolation["transform_loc_strength"] | |
| if self.transform_loc_strength == None: | |
| self.transform_loc_strength = self.data( | |
| "camera").transform_loc_strength | |
| self.__ui["options"]["transform"]["transform_loc_strength"].highlight( | |
| False) | |
| else: | |
| self.__ui["options"]["transform"]["transform_loc_strength"].highlight( | |
| True) | |
| self.__ui["options"]["transform"]["transform_loc_strength"].set_text( | |
| self.transform_loc_strength, True, "%") | |
| self.transform_rot_strength = self.data( | |
| ).interpolation["transform_rot_strength"] | |
| if self.transform_rot_strength == None: | |
| self.transform_rot_strength = self.data( | |
| "camera").transform_rot_strength | |
| self.__ui["options"]["transform"]["transform_rot_strength"].highlight( | |
| False) | |
| else: | |
| self.__ui["options"]["transform"]["transform_rot_strength"].highlight( | |
| True) | |
| self.__ui["options"]["transform"]["transform_rot_strength"].set_text( | |
| self.transform_rot_strength, True, "%") | |
| except Exception as e: | |
| debug(e) | |
| def __update_tracking(self): | |
| global focused_car | |
| try: | |
| cam.set_tracked_car(0, focused_car) | |
| self.driver_name_a = ac.getDriverName(cam.get_tracked_car(0)) | |
| if len(self.driver_name_a) > 13: | |
| self.driver_name_a = self.driver_name_a[:13] + "." | |
| self.driver_name_b = ac.getDriverName(cam.get_tracked_car(1)) | |
| if len(self.driver_name_b) > 13: | |
| self.driver_name_b = self.driver_name_b[:13] + "." | |
| self.__ui["options"]["tracking"]["car_1"].set_text( | |
| self.driver_name_a) | |
| self.__ui["options"]["tracking"]["car_2"].set_text( | |
| self.driver_name_b) | |
| if self.data().interpolation["tracking_mix"] == None: | |
| self.__ui["options"]["tracking"]["tracking_mix"].set_text( | |
| self.data("camera").tracking_mix, True, "%") | |
| self.__ui["options"]["tracking"]["tracking_mix"].highlight( | |
| False) | |
| else: | |
| self.__ui["options"]["tracking"]["tracking_mix"].set_text( | |
| self.data().interpolation["tracking_mix"], True, "%") | |
| self.__ui["options"]["tracking"]["tracking_mix"].highlight( | |
| True) | |
| if self.data().interpolation["tracking_strength_pitch"] == None: | |
| self.__ui["options"]["tracking"]["tracking_strength_pitch"].set_text( | |
| data.get_tracking_strength("pitch", self.__active_cam), True, "%") | |
| self.__ui["options"]["tracking"]["tracking_strength_pitch"].highlight( | |
| False) | |
| else: | |
| self.__ui["options"]["tracking"]["tracking_strength_pitch"].set_text( | |
| self.data().interpolation["tracking_strength_pitch"], True, "%") | |
| self.__ui["options"]["tracking"]["tracking_strength_pitch"].highlight( | |
| True) | |
| if self.data().interpolation["tracking_strength_heading"] == None: | |
| self.__ui["options"]["tracking"]["tracking_strength_heading"].set_text( | |
| data.get_tracking_strength("heading", self.__active_cam), True, "%") | |
| self.__ui["options"]["tracking"]["tracking_strength_heading"].highlight( | |
| False) | |
| else: | |
| self.__ui["options"]["tracking"]["tracking_strength_heading"].set_text( | |
| self.data().interpolation["tracking_strength_heading"], True, "%") | |
| self.__ui["options"]["tracking"]["tracking_strength_heading"].highlight( | |
| True) | |
| if self.data().interpolation["tracking_offset_pitch"] == None: | |
| self.__ui["options"]["tracking"]["tracking_offset_pitch"].set_text( | |
| self.data("camera").tracking_offset_pitch, True, "degrees") | |
| self.__ui["options"]["tracking"]["tracking_offset_pitch"].highlight( | |
| False) | |
| else: | |
| self.__ui["options"]["tracking"]["tracking_offset_pitch"].set_text( | |
| self.data().interpolation["tracking_offset_pitch"], True, "degrees") | |
| self.__ui["options"]["tracking"]["tracking_offset_pitch"].highlight( | |
| True) | |
| if self.data().interpolation["tracking_offset_heading"] == None: | |
| self.__ui["options"]["tracking"]["tracking_offset_heading"].set_text( | |
| self.data("camera").tracking_offset_heading, True, "degrees") | |
| self.__ui["options"]["tracking"]["tracking_offset_heading"].highlight( | |
| False) | |
| else: | |
| self.__ui["options"]["tracking"]["tracking_offset_heading"].set_text( | |
| self.data().interpolation["tracking_offset_heading"], True, "degrees") | |
| self.__ui["options"]["tracking"]["tracking_offset_heading"].highlight( | |
| True) | |
| if self.data().interpolation["tracking_offset"] == None: | |
| self.__ui["options"]["tracking"]["tracking_offset"].set_text( | |
| self.data("camera").tracking_offset, True) | |
| self.__ui["options"]["tracking"]["tracking_offset"].highlight( | |
| False) | |
| else: | |
| self.__ui["options"]["tracking"]["tracking_offset"].set_text( | |
| self.data().interpolation["tracking_offset"], True) | |
| self.__ui["options"]["tracking"]["tracking_offset"].highlight( | |
| True) | |
| except Exception as e: | |
| debug(e) | |
| def __update_spline(self): | |
| try: | |
| if self.__active_menu == "spline": | |
| if cam.get_recording_status("camera"): | |
| self.__ui["options"]["spline"]["spline_record"].set_text( | |
| "Stop") | |
| else: | |
| if len(data.mode[data.active_mode][self.__active_cam].spline["the_x"]) == 0: | |
| self.__ui["options"]["spline"]["spline_record"].set_text( | |
| "Record") | |
| else: | |
| self.__ui["options"]["spline"]["spline_record"].set_text( | |
| "Remove") | |
| for self.key, self.val in self.__ui["options"]["spline"].items(): | |
| if self.val.__class__.__name__ == "Option": | |
| if self.data().interpolation[self.key] == None: | |
| self.text = self.data("camera").get_attr(self.key) | |
| self.val.highlight(False) | |
| else: | |
| self.text = self.data().interpolation[self.key] | |
| self.val.highlight(True) | |
| self.display_mode = "%" | |
| if self.key == "spline_offset_heading" or self.key == "spline_offset_pitch" or self.key == "spline_offset_roll": | |
| self.display_mode = "degrees" | |
| if self.key == "spline_offset_loc_x" or self.key == "spline_offset_spline" or self.key == "spline_offset_loc_z": | |
| self.display_mode = "m" | |
| if self.key == "spline_offset_spline" and data.active_mode == "time": | |
| self.display_mode = "time" | |
| if self.key == "spline_offset_spline" and data.active_mode == "pos": | |
| self.text *= ac.getTrackLength() | |
| self.val.set_text(self.text, True, self.display_mode) | |
| except Exception as e: | |
| debug(e) | |
| def __update_camera_options(self): | |
| global fov, focus_point | |
| try: | |
| self.__ui["options"]["camera"]["camera_in"].set_text( | |
| data.get_camera_in(self.__active_cam), True, "m") | |
| if self.data("camera").camera_pit: | |
| self.__ui["options"]["camera"]["camera_pit"].set_text("True") | |
| else: | |
| self.__ui["options"]["camera"]["camera_pit"].set_text("False") | |
| if self.data("camera").camera_use_tracking_point == 1: | |
| self.__ui["options"]["camera"]["camera_use_tracking_point"].set_text( | |
| "True") | |
| self.__ui["options"]["camera"]["camera_focus_point"].disable() | |
| else: | |
| self.__ui["options"]["camera"]["camera_use_tracking_point"].set_text( | |
| "False") | |
| self.__ui["options"]["camera"]["camera_focus_point"].enable() | |
| if self.data().interpolation["camera_focus_point"] != None: | |
| self.__ui["options"]["camera"]["camera_focus_point"].set_text( | |
| self.data().interpolation["camera_focus_point"], True, "m") | |
| self.__ui["options"]["camera"]["camera_focus_point"].highlight( | |
| True) | |
| else: | |
| self.__ui["options"]["camera"]["camera_focus_point"].set_text( | |
| focus_point, True, "m") | |
| self.__ui["options"]["camera"]["camera_focus_point"].highlight( | |
| False) | |
| if self.data().interpolation["camera_fov"] != None: | |
| self.__ui["options"]["camera"]["camera_fov"].set_text(math.radians( | |
| ctt.convert_fov_2_focal_length(self.data().interpolation["camera_fov"], True)), True, "degrees") | |
| self.__ui["options"]["camera"]["camera_fov"].highlight(True) | |
| else: | |
| self.__ui["options"]["camera"]["camera_fov"].set_text( | |
| math.radians(fov), True, "degrees") | |
| self.__ui["options"]["camera"]["camera_fov"].highlight(False) | |
| if self.data().interpolation["camera_offset_shake_strength"] == None: | |
| self.__ui["options"]["camera"]["camera_offset_shake"].set_text( | |
| self.data("canera").camera_offset_shake_strength, True, "%") | |
| self.__ui["options"]["camera"]["camera_offset_shake"].highlight( | |
| False) | |
| else: | |
| self.__ui["options"]["camera"]["camera_offset_shake"].set_text( | |
| self.data().interpolation["camera_offset_shake_strength"], True, "%") | |
| self.__ui["options"]["camera"]["camera_offset_shake"].highlight( | |
| True) | |
| if self.data().interpolation["camera_shake_strength"] == None: | |
| self.__ui["options"]["camera"]["camera_shake"].set_text( | |
| self.data("camera").camera_shake_strength, True, "%") | |
| self.__ui["options"]["camera"]["camera_shake"].highlight(False) | |
| else: | |
| self.__ui["options"]["camera"]["camera_shake"].set_text( | |
| self.data().interpolation["camera_shake_strength"], True, "%") | |
| self.__ui["options"]["camera"]["camera_shake"].highlight(True) | |
| except Exception as e: | |
| debug(e) | |
| #--------------------------------------------------------------------------- | |
| @async | |
| def set_camera(self): | |
| ctt.set_fov(self.fov * (1 - self.strength_inv) + | |
| fov * self.strength_inv) | |
| ctt.set_focus_point(self.focus_point) | |
| @async | |
| def set_comb_pos(self): | |
| global loc_x, loc_y, loc_z | |
| ctt.set_position(0, (self.loc_x_transform * (1 - self.spline_affect_loc_xy) + self.loc_x_spline * | |
| self.spline_affect_loc_xy) * (1 - self.strength_inv) + loc_x * self.strength_inv) | |
| ctt.set_position(1, (self.loc_y_transform * (1 - self.spline_affect_loc_xy) + self.loc_y_spline * | |
| self.spline_affect_loc_xy) * (1 - self.strength_inv) + loc_y * self.strength_inv) | |
| ctt.set_position(2, (self.loc_z_transform * (1 - self.spline_affect_loc_z) + self.loc_z_spline * | |
| self.spline_affect_loc_z) * (1 - self.strength_inv) + loc_z * self.strength_inv) | |
| def __interpolate(self, strength_inv, dt): | |
| try: | |
| global gTimer_mouse, a | |
| global loc_x, loc_y, loc_z, rot_x, rot_y, rot_z, fov, replay_pos, focus_point | |
| #reset strength_inv if camera has changed | |
| self.strength_inv = strength_inv | |
| if a and self.mouselook_start_camera == None: | |
| self.mouselook_start_camera = data.active_cam | |
| if strength_inv > 0: | |
| if not a: | |
| if self.mouselook_start_camera != data.active_cam: | |
| gTimer_mouse = 0 | |
| else: | |
| self.mouselook_start_camera = None | |
| #if app is activated, take control over camera | |
| if self.active_app: | |
| ac.setCameraMode(6) | |
| if data.smart_tracking: | |
| cam.update_smart_tracking_values( | |
| ctt, data, interpolation, info, self.__the_x, dt) | |
| self.x = [] | |
| self.y = {} | |
| #prepare dict to store interpolated values | |
| for self.key, self.val in self.data().interpolation.items(): | |
| self.y[self.key] = [] | |
| #interpolate all options | |
| for self.val in data.mode[data.active_mode][data.active_cam].keyframes: | |
| self.x.append(self.val.keyframe) | |
| for self.key, self.val2 in self.val.interpolation.items(): | |
| self.y[self.key].append(self.val2) | |
| # if data.is_last_camera() and data.get_n_cameras() > 1: | |
| # for self.i in range(len(self.x)): | |
| # if self.x[self.i] != None: | |
| # if self.x[self.i] > 0.5: | |
| # self.x[self.i] -= 1 | |
| # for self.key, self.val in self.y.items(): | |
| # self.x, self.y[self.key] = zip(*sorted(zip(self.x, self.y[self.key]))) | |
| #prepare the_x for last camera | |
| if data.smart_tracking: | |
| self.__the_x_tmp = cam.get_st_x() | |
| else: | |
| self.__the_x_tmp = self.__the_x | |
| if data.is_last_camera() and data.get_n_cameras() > 1: | |
| if self.__the_x > 0.5: | |
| self.__the_x_tmp -= 1 | |
| #--------------------------------------------------------------- | |
| #LOCATION | |
| self.spline_len = len( | |
| self.data("camera", False).spline["the_x"]) | |
| if self.spline_len > 0: | |
| self.spline_exists = True | |
| else: | |
| self.spline_exists = False | |
| #spline offset | |
| self.spline_offset = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["spline_offset_spline"]) | |
| if self.spline_offset == None: | |
| self.spline_offset = self.data( | |
| "camera", False).spline_offset_spline | |
| else: | |
| self.data( | |
| "camera", False).spline_offset_spline = self.spline_offset | |
| if data.active_mode == "time": | |
| self.spline_offset = self.spline_offset * \ | |
| (1000 / replay.get_refresh_rate()) | |
| #spline speed | |
| self.spline_speed = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["spline_speed"]) | |
| if self.spline_speed == None: | |
| self.spline_speed = self.data("camera", False).spline_speed | |
| else: | |
| self.data("camera", False).spline_speed = self.spline_speed | |
| self.__the_x_tmp_4_spline = self.__the_x_tmp | |
| if self.spline_exists: | |
| self.__the_x_tmp_4_spline = (self.__the_x - self.data( | |
| "camera", False).spline["the_x"][0]) * self.spline_speed - self.spline_offset + self.data("camera", False).spline["the_x"][0] | |
| if self.data("camera", False).spline["the_x"][self.spline_len - 1] > 1: | |
| if data.active_mode == "pos": | |
| if self.__the_x_tmp_4_spline < 0.5: | |
| self.__the_x_tmp_4_spline += 1 | |
| self.loc_x_spline = None | |
| self.loc_y_spline = None | |
| self.loc_z_spline = None | |
| self.heading_spline = None | |
| if self.spline_exists: | |
| #spline_offset relative loc_x | |
| self.heading_spline = interpolation.interpolate(self.__the_x_tmp_4_spline, self.data( | |
| "camera", False).spline["the_x"], self.data("camera", False).spline["rot_z"]) | |
| self.spline_offset_x = vec() | |
| self.value = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["spline_offset_loc_x"]) | |
| if self.value == None: | |
| self.value = self.data( | |
| "camera", False).spline_offset_loc_x | |
| self.spline_offset_x.y = math.cos( | |
| self.heading_spline) * self.value | |
| self.spline_offset_x.x = math.sin( | |
| self.heading_spline) * self.value | |
| self.loc_x_spline = interpolation.interpolate(self.__the_x_tmp_4_spline, self.data( | |
| "camera", False).spline["the_x"], self.data("camera", False).spline["loc_x"]) | |
| self.loc_y_spline = interpolation.interpolate(self.__the_x_tmp_4_spline, self.data( | |
| "camera", False).spline["the_x"], self.data("camera", False).spline["loc_y"]) | |
| self.loc_z_spline = interpolation.interpolate(self.__the_x_tmp_4_spline, self.data( | |
| "camera", False).spline["the_x"], self.data("camera", False).spline["loc_z"]) | |
| self.loc_x_spline += self.spline_offset_x.x | |
| self.loc_y_spline += self.spline_offset_x.y | |
| #transform | |
| self.transform_loc_strength = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["transform_loc_strength"]) | |
| if self.transform_loc_strength == None: | |
| self.transform_loc_strength = self.data( | |
| "camera", False).transform_loc_strength | |
| else: | |
| self.data( | |
| "camera", False).transform_rot_strength = self.transform_loc_strength | |
| self.transform_rot_strength = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["transform_rot_strength"]) | |
| if self.transform_rot_strength == None: | |
| self.transform_rot_strength = self.data( | |
| "camera", False).transform_rot_strength | |
| else: | |
| self.data( | |
| "camera", False).transform_rot_strength = self.transform_rot_strength | |
| self.loc_x_transform = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["loc_x"]) | |
| self.loc_y_transform = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["loc_y"]) | |
| self.loc_z_transform = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["loc_z"]) | |
| #combining: spline / transform / self.strength_inv (mouse) | |
| if self.loc_x_spline != None or self.loc_x_transform != None: | |
| if self.loc_x_spline == None: | |
| self.loc_x_spline = loc_x | |
| if self.loc_x_transform == None: | |
| self.loc_x_transform = loc_x | |
| else: | |
| self.loc_x_transform = self.loc_x_transform * self.transform_loc_strength + \ | |
| loc_x * (1 - self.transform_loc_strength) | |
| if self.spline_exists: | |
| self.spline_affect_loc_xy = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["spline_affect_loc_xy"]) | |
| if self.spline_affect_loc_xy == None: | |
| self.spline_affect_loc_xy = self.data( | |
| "camera", False).spline_affect_loc_xy | |
| else: | |
| self.data( | |
| "camera", False).spline_affect_loc_xy = self.spline_affect_loc_xy | |
| else: | |
| self.spline_affect_loc_xy = 0 | |
| if self.loc_y_spline != None or self.loc_y_transform != None: | |
| if self.loc_y_spline == None: | |
| self.loc_y_spline = loc_y | |
| if self.loc_y_transform == None: | |
| self.loc_y_transform = loc_y | |
| else: | |
| self.loc_y_transform = self.loc_y_transform * self.transform_loc_strength + \ | |
| loc_x * (1 - self.transform_loc_strength) | |
| if self.spline_exists: | |
| self.spline_affect_loc_xy = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["spline_affect_loc_xy"]) | |
| if self.spline_affect_loc_xy == None: | |
| self.spline_affect_loc_xy = self.data( | |
| "camera", False).spline_affect_loc_xy | |
| else: | |
| self.data( | |
| "camera", False).spline_affect_loc_xy = self.spline_affect_loc_xy | |
| else: | |
| self.spline_affect_loc_xy = 0 | |
| if self.loc_z_spline != None or self.loc_z_transform != None: | |
| if self.loc_z_spline == None: | |
| self.loc_z_spline = loc_z | |
| if self.loc_z_transform == None: | |
| self.loc_z_transform = loc_z | |
| else: | |
| self.loc_z_transform = self.loc_z_transform * self.transform_loc_strength + \ | |
| loc_x * (1 - self.transform_loc_strength) | |
| if self.spline_exists: | |
| self.spline_affect_loc_z = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["spline_affect_loc_z"]) | |
| if self.spline_affect_loc_z == None: | |
| self.spline_affect_loc_z = self.data( | |
| "camera", False).spline_affect_loc_z | |
| else: | |
| self.spline_affect_loc_z = 0 | |
| self.spline_offset_loc_z = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["spline_offset_loc_z"]) | |
| if self.spline_offset_loc_z == None: | |
| self.spline_offset_loc_z = self.data( | |
| "camera", False).spline_offset_loc_z | |
| self.loc_z_spline += self.spline_offset_loc_z | |
| self.set_comb_pos() | |
| #=============================================================== | |
| #ROTATION | |
| #transform | |
| self.pitch_transform = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["rot_x"]) | |
| self.roll_transform = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["rot_y"]) | |
| self.heading_transform = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["rot_z"]) | |
| #spline | |
| self.pitch_spline = None | |
| self.roll_spline = None | |
| #moved up | |
| #self.heading_spline = None | |
| if self.spline_exists: | |
| self.pitch_spline = interpolation.interpolate(self.__the_x_tmp_4_spline, self.data( | |
| "camera", False).spline["the_x"], self.data("camera", False).spline["rot_x"]) | |
| self.roll_spline = interpolation.interpolate(self.__the_x_tmp_4_spline, self.data( | |
| "camera", False).spline["the_x"], self.data("camera", False).spline["rot_y"]) | |
| #moved up | |
| #self.heading_spline = interpolation.interpolate(self.__the_x_tmp_4_spline, self.data("camera", False).spline["the_x"], self.data("camera", False).spline["rot_z"]) | |
| #offset - rotation | |
| self.spline_offset_heading = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["spline_offset_heading"]) | |
| if self.spline_offset_heading == None: | |
| self.spline_offset_heading = self.data( | |
| "camera", False).spline_offset_heading | |
| self.heading_spline += self.spline_offset_heading | |
| self.roll_spline *= math.sin( | |
| self.spline_offset_heading + math.pi/2) | |
| self.pitch_spline *= math.sin( | |
| self.spline_offset_heading + math.pi/2) | |
| self.spline_offset_pitch = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["spline_offset_pitch"]) | |
| if self.spline_offset_pitch == None: | |
| self.spline_offset_pitch = self.data( | |
| "camera", False).spline_offset_pitch | |
| self.pitch_spline += self.spline_offset_pitch | |
| #--------------------------------------------------------------- | |
| #TRACKING | |
| #tracking - offset | |
| self.value = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["tracking_offset"]) | |
| if self.value != None: | |
| self.data("camera", False).tracking_offset = self.value | |
| if data.smart_tracking: | |
| self.cam_rot_tracking = cam.get_st_cam_rot() | |
| else: | |
| self.cam_rot_to_car_a = cam.calculate_cam_rot_to_tracking_car( | |
| ctt, data, info, cam.get_tracked_car(0), dt, loc_x, loc_y, loc_z) | |
| #tracking - mix | |
| self.cam_rot_tracking = self.cam_rot_to_car_a | |
| self.value = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["tracking_mix"]) | |
| if self.value == None: | |
| self.value = self.data("camera", False).tracking_mix | |
| else: | |
| self.data("camera", False).tracking_mix = self.value | |
| if self.value > 0: | |
| self.cam_rot_to_car_b = cam.calculate_cam_rot_to_tracking_car( | |
| ctt, data, info, cam.get_tracked_car(1), dt, loc_x, loc_y, loc_z) | |
| self.cam_rot_to_car_b.z = normalize_angle( | |
| self.cam_rot_to_car_a.z, self.cam_rot_to_car_b.z) | |
| self.cam_rot_tracking = self.cam_rot_to_car_a * \ | |
| vec3((1-self.value), (1-self.value), (1-self.value)) + \ | |
| self.cam_rot_to_car_b * \ | |
| vec3(self.value, self.value, self.value) | |
| self.heading_4_focus_point = self.cam_rot_tracking.z | |
| #tracking - strength - pitch | |
| self.value = interpolation.interpolate_sin( | |
| self.__the_x_tmp, self.x, self.y["tracking_strength_pitch"]) | |
| if self.value != None: | |
| self.data( | |
| "camera", False).tracking_strength_pitch = self.value | |
| #tracking - strength - heading | |
| self.value = interpolation.interpolate_sin( | |
| self.__the_x_tmp, self.x, self.y["tracking_strength_heading"]) | |
| if self.value != None: | |
| self.data( | |
| "camera", False).tracking_strength_heading = self.value | |
| self.tracking_offset_heading = interpolation.interpolate_sin( | |
| self.__the_x_tmp, self.x, self.y["tracking_offset_heading"]) | |
| if self.tracking_offset_heading != None: | |
| self.data( | |
| "camera", False).tracking_offset_heading = self.tracking_offset_heading | |
| self.tracking_offset_pitch = interpolation.interpolate_sin( | |
| self.__the_x_tmp, self.x, self.y["tracking_offset_pitch"]) | |
| if self.tracking_offset_pitch != None: | |
| self.data( | |
| "camera", False).tracking_offset_pitch = self.tracking_offset_pitch | |
| #--------------------------------------------------------------- | |
| #Combining rotations - heading | |
| self.heading = rot_z | |
| if self.heading_transform != None or self.heading_spline != None or data.get_tracking_strength("heading") > 0: | |
| #prepare values | |
| if self.heading_transform == None: | |
| self.heading_transform = self.heading | |
| else: | |
| self.heading_transform = self.heading_transform * \ | |
| self.transform_rot_strength + self.heading * \ | |
| (1 - self.transform_rot_strength) | |
| if self.heading_spline == None: | |
| self.heading_spline = self.heading | |
| if self.cam_rot_tracking.z == None: | |
| self.cam_rot_tracking.z = self.heading | |
| else: | |
| self.cam_rot_tracking.z += self.data( | |
| "camera", False).tracking_offset_heading | |
| self.heading_transform = normalize_angle( | |
| self.heading, self.heading_transform) | |
| self.cam_rot_tracking.z = normalize_angle( | |
| self.heading, self.cam_rot_tracking.z) | |
| self.heading_spline = normalize_angle( | |
| self.heading, self.heading_spline) | |
| #prepare self.strength_invs | |
| if self.spline_exists: | |
| self.strength_spline = self.get_data( | |
| "spline_affect_heading", True, False) | |
| else: | |
| self.strength_spline = 0 | |
| self.strength_tracking = data.get_tracking_strength( | |
| "heading") | |
| self.heading = ( | |
| ( | |
| (self.heading_transform * (1 - self.strength_tracking) + | |
| self.cam_rot_tracking.z * self.strength_tracking) | |
| * (1 - self.strength_spline) + self.heading_spline * self.strength_spline | |
| ) | |
| * (1 - self.strength_inv) + self.heading * self.strength_inv | |
| ) | |
| #--------------------------------------------------------------- | |
| #Combining rotations - pitch | |
| self.pitch = rot_x | |
| if self.pitch_transform != None or self.pitch_spline != None or data.get_tracking_strength("pitch") > 0: | |
| #prepare values | |
| if self.pitch_transform == None: | |
| self.pitch_transform = self.pitch | |
| else: | |
| self.pitch_transform = self.pitch_transform * self.transform_rot_strength + \ | |
| self.pitch * (1 - self.transform_rot_strength) | |
| if self.pitch_spline == None: | |
| self.pitch_spline = self.pitch | |
| if self.cam_rot_tracking.x == None: | |
| self.cam_rot_tracking.x = self.pitch | |
| else: | |
| self.cam_rot_tracking.x += self.data( | |
| "camera", False).tracking_offset_pitch | |
| #prepare self.strength_invs | |
| if self.spline_exists: | |
| self.strength_spline = self.get_data( | |
| "spline_affect_pitch", True, False) | |
| else: | |
| self.strength_spline = 0 | |
| self.strength_tracking = data.get_tracking_strength( | |
| "pitch") | |
| self.pitch = ( | |
| ( | |
| (self.pitch_transform * (1 - self.strength_tracking) + | |
| self.cam_rot_tracking.x * self.strength_tracking) | |
| * (1 - self.strength_spline) + self.pitch_spline * self.strength_spline | |
| ) | |
| * (1 - self.strength_inv) + self.pitch * self.strength_inv | |
| ) | |
| #--------------------------------------------------------------- | |
| #Combining rotations - roll | |
| self.roll = rot_y | |
| if self.roll_transform != None or self.roll_spline != None: | |
| #prepare values | |
| if self.roll_transform == None: | |
| self.roll_transform = self.roll | |
| else: | |
| # * self.transform_rot_strength + self.roll * (1 - self.transform_rot_strength) | |
| self.roll_transform = self.roll_transform | |
| if self.roll_spline == None: | |
| self.roll_spline = self.roll | |
| #prepare self.strength_invs | |
| if self.spline_exists: | |
| self.strength_spline = self.get_data( | |
| "spline_affect_roll", True, False) | |
| else: | |
| self.strength_spline = 0 | |
| self.roll = (self.roll_transform * (1 - self.strength_spline) + self.roll_spline * | |
| self.strength_spline) * (1 - self.strength_inv) + self.roll * self.strength_inv | |
| #--------------------------------------------------------------- | |
| self.camera_shake_strength = interpolation.interpolate_sin( | |
| self.__the_x_tmp, self.x, self.y["camera_shake_strength"]) | |
| if self.camera_shake_strength != None: | |
| self.data( | |
| "camera", False).camera_shake_strength = self.camera_shake_strength | |
| self.shake_factor = 0.75 * data.get_tracking_strength("heading") + 0.01 * ( | |
| 1 - min(1, data.get_tracking_strength("heading") + self.transform_rot_strength)) | |
| self.shake = cam.get_shake(data, info.graphics.replayTimeMultiplier) * vec3( | |
| 1 - self.strength_inv * self.shake_factor, 0, 1 - self.strength_inv * self.shake_factor) | |
| #=============================================================== | |
| #CAMERA | |
| #fov | |
| self.strength_tracking_heading = data.get_tracking_strength( | |
| "heading") | |
| self.fov = interpolation.interpolate_sin( | |
| self.__the_x_tmp, self.x, self.y["camera_fov"]) | |
| if self.fov != None: | |
| self.fov = ctt.convert_fov_2_focal_length(self.fov, True) | |
| else: | |
| self.fov = fov | |
| if data.smart_tracking: | |
| if data.has_camera_changed(): | |
| cam.reset_smart_tracking() | |
| self.st_fov = cam.get_st_fov() | |
| self.st_fov_mix = cam.get_st_fov_mix() | |
| self.st_fov = self.st_fov * self.strength_tracking_heading + \ | |
| self.fov * (1 - self.strength_tracking_heading) | |
| self.fov = self.fov * \ | |
| (1 - self.st_fov_mix) + self.st_fov * self.st_fov_mix | |
| #--------------------------------------------------------------- | |
| #focus point | |
| self.camera_use_tracking_point = self.data( | |
| "camera", False).camera_use_tracking_point | |
| self.focus_point = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["camera_focus_point"]) | |
| if self.focus_point == None: | |
| self.focus_point = focus_point | |
| self.mix = interpolation.interpolate( | |
| self.__the_x_tmp, self.x, self.y["tracking_mix"]) | |
| if self.mix == None: | |
| self.mix = self.data("camera", False).tracking_mix | |
| if self.heading_4_focus_point != None: | |
| self.heading_4_focus_point = normalize_angle( | |
| rot_z, self.heading_4_focus_point) | |
| else: | |
| self.heading_4_focus_point = rot_z | |
| self.focus_point = cam.calculate_focus_point( | |
| ctt, self.mix, self.heading_4_focus_point, dt) * self.camera_use_tracking_point + self.focus_point * (1 - self.camera_use_tracking_point) | |
| self.focus_point = self.focus_point * \ | |
| (1 - self.strength_inv) + 300 * self.strength_inv | |
| self.set_camera() | |
| ctt.set_rotation(self.pitch + self.shake.x, | |
| self.roll, self.heading + self.shake.z) | |
| else: | |
| self.__lock["interpolate_init"] = False | |
| except Exception as e: | |
| debug(e) | |
| def data(self, mode="keyframes", slot_camera=True): | |
| try: | |
| if slot_camera: | |
| self.cam = self.__active_cam | |
| else: | |
| self.cam = data.active_cam | |
| if mode == "keyframes": | |
| return data.mode[data.active_mode][self.cam].keyframes[self.__active_kf] | |
| else: | |
| return data.mode[data.active_mode][self.cam] | |
| except Exception as e: | |
| debug(e) | |
| def get_data(self, key, custom_camera_option=False, use_slot_camera=True): | |
| try: | |
| self.result = self.data( | |
| "keyframes", use_slot_camera).interpolation[key] | |
| if custom_camera_option and self.result == None: | |
| self.result = self.data( | |
| "camera", use_slot_camera).get_attr(key) | |
| else: | |
| self.data("camera", use_slot_camera).set_attr(key, self.result) | |
| return self.result | |
| except Exception as e: | |
| debug(e) | |
| def set_data(self, action, val=0.25, clamp=True): | |
| global s, a, c | |
| try: | |
| self.key = action[:len(action)-2] | |
| self.action = action[-2:] | |
| if self.action != "_m" and self.action != "_p": | |
| self.key = action | |
| self.action = "toogle" | |
| self.val = val | |
| if self.key in self.data().interpolation: | |
| if self.data().interpolation[self.key] != None: | |
| if c: | |
| self.val /= 4 | |
| if s: | |
| self.val *= 4 | |
| if self.action == "_m": | |
| if clamp: | |
| self.data().interpolation[self.key] = max( | |
| 0, min(1, (self.data().interpolation[self.key] - self.val / 5))) | |
| else: | |
| self.data().interpolation[self.key] -= self.val / 5 | |
| return True | |
| elif self.action == "_p": | |
| if clamp: | |
| self.data().interpolation[self.key] = max( | |
| 0, min(1, (self.data().interpolation[self.key] + self.val / 5))) | |
| else: | |
| self.data().interpolation[self.key] += self.val / 5 | |
| return True | |
| if self.action == "toogle": | |
| self.data().interpolation[self.key] = None | |
| return True | |
| else: | |
| if self.action == "toogle": | |
| if val == "camera": | |
| self.data().interpolation[self.key] = self.data( | |
| "camera").get_attr(self.key) | |
| else: | |
| self.data().interpolation[self.key] = self.val | |
| return True | |
| elif hasattr(self.data("camera"), self.key): | |
| if self.action == "_m": | |
| self.value = self.data("camera").get_attr(self.key) | |
| if c: | |
| self.val /= 4 | |
| if s: | |
| self.val *= 4 | |
| if clamp: | |
| self.data("camera").set_attr( | |
| self.key, max(0, min(1, self.value - self.val))) | |
| else: | |
| self.data("camera").set_attr( | |
| self.key, self.value - self.val) | |
| return True | |
| elif self.action == "_p": | |
| self.value = self.data("camera").get_attr(self.key) | |
| if c: | |
| self.val /= 4 | |
| if s: | |
| self.val *= 4 | |
| if clamp: | |
| self.data("camera").set_attr( | |
| self.key, max(0, min(1, self.value + self.val))) | |
| else: | |
| self.data("camera").set_attr( | |
| self.key, self.value + self.val) | |
| return True | |
| if self.action == "_m": | |
| self.multiplier = -1 | |
| else: | |
| self.multiplier = 1 | |
| return self.set_custom_data(self.key, self.multiplier) | |
| except Exception as e: | |
| debug(e) | |
| return False | |
| def set_camera_data(self, key, step=0.25, custom_camera_option=False, clamp=True): | |
| global s, c | |
| try: | |
| self.step = step | |
| if c: | |
| self.step /= 4 | |
| if s: | |
| self.step *= 4 | |
| if self.data().interpolation[key] != None: | |
| if clamp: | |
| self.data().interpolation[key] = max( | |
| 0, min(1, self.data().interpolation[key] + self.step/10)) | |
| else: | |
| self.data().interpolation[key] = self.data( | |
| ).interpolation[key] + self.step/10 | |
| elif custom_camera_option: | |
| if clamp: | |
| self.data("camera").set_attr( | |
| key, max(0, min(1, self.data("camera").get_attr(key) + self.step))) | |
| else: | |
| self.data("camera").set_attr(key, self.data( | |
| "camera").get_attr(key) + self.step) | |
| except Exception as e: | |
| debug(e) | |
| def set_custom_data(self, key, multiplier): | |
| global loc_x, loc_y, loc_z, rot_x, rot_y, rot_z | |
| global fov, focus_point | |
| if key == "loc_x": | |
| ctt.set_position(0, loc_x + 0.5 * multiplier) | |
| return True | |
| elif key == "loc_y": | |
| ctt.set_position(1, loc_y + 0.5 * multiplier) | |
| return True | |
| elif key == "loc_z": | |
| ctt.set_position(2, loc_z + 0.5 * multiplier) | |
| return True | |
| elif key == "rot_x": | |
| ctt.set_pitch(rot_x + math.radians(0.5 * multiplier)) | |
| return True | |
| elif key == "rot_y": | |
| ctt.set_roll(rot_y + math.radians(0.5 * multiplier)) | |
| return True | |
| elif key == "rot_z": | |
| ctt.set_heading(math.radians(0.5 * multiplier), False) | |
| return True | |
| elif key == "camera_fov": | |
| ctt.set_fov(fov + 1 * multiplier) | |
| return True | |
| elif key == "camera_focus_point": | |
| ctt.set_focus_point(focus_point + 1 * multiplier) | |
| return True | |
| return False | |
| #--------------------------------------------------------------------------- | |
| def get_active_cam(self): | |
| return self.__active_cam | |
| def get_side_panel_size(self, keyframes=True): | |
| if keyframes: | |
| return self.__ui["side_k"]["bg"].get_size() | |
| return self.__ui["side_c"]["bg"].get_size() | |
| def get_max_btns_in_col(self): | |
| return self.__max_btns_in_column | |
| def get_btn_height(self): | |
| return self.__btn_height | |
| def get_right_panel_size(self): | |
| return self.__ui["file_form"]["top"].get_size() | |
| def get_margin(self): | |
| return self.__margin | |
| def get_the_x(self): | |
| return self.__the_x | |
| def get_file_form_input(self): | |
| return self.__ui["file_form"]["input"].get_text() | |
| #return ac.getTrackName(0) + "_" + ac.getTrackConfiguration(0) + "-" + self.__ui["file_form"]["input"].get_text() | |
| def get_file_form_mode(self): | |
| return self.__ui["file_form"]["save"].get_text() | |
| def __prepare_degrees(self, option): | |
| self.result = self.data().interpolation[option] | |
| if self.__active_kf > 0 and self.result != None: | |
| self.prev_val = data.mode[data.active_mode][self.__active_cam].keyframes[self.__active_kf - | |
| 1].interpolation[option] | |
| if self.prev_val != None: | |
| if self.result < self.prev_val: | |
| if abs(self.result - self.prev_val) > abs(self.result + (math.pi*2) - self.prev_val): | |
| self.result += (math.pi*2) | |
| else: | |
| if abs(self.result - self.prev_val) > abs(self.result - (math.pi*2) - self.prev_val): | |
| self.result -= (math.pi*2) | |
| self.data().interpolation[option] = self.result | |
| def set_active_kf(self, value): | |
| try: | |
| if value >= 0 and value < data.get_n_keyframes(self.__active_cam): | |
| self.__active_kf = value | |
| for self.i in range(len(self.__ui["side_k"]["keyframes"])): | |
| if self.i == self.__active_kf: | |
| self.__ui["side_k"]["keyframes"][self.i].highlight(True) | |
| else: | |
| self.__ui["side_k"]["keyframes"][self.i].highlight(False) | |
| except Exception as e: | |
| debug(e) | |
| def set_active_cam(self, value): | |
| try: | |
| if value >= 0 and value < data.get_n_cameras(): | |
| if self.__active_cam != value: | |
| self.set_active_kf(0) | |
| self.__active_cam = value | |
| for self.i in range(len(self.__ui["side_c"]["cameras"])): | |
| if self.i == self.__active_cam: | |
| self.__ui["side_c"]["cameras"][self.i].highlight(True) | |
| else: | |
| self.__ui["side_c"]["cameras"][self.i].highlight(False) | |
| except Exception as e: | |
| debug(e) | |
| def set_active_menu(self, active_menu): | |
| self.__active_menu = active_menu | |
| def set_mode(self, mode): | |
| self.set_active_kf(0) | |
| if mode == "time" and info.graphics.status != 1: | |
| return False | |
| data.active_mode = mode | |
| return True | |
| def set_replay_pos(self, pos): | |
| ctt.set_replay_position(max(0, int(pos))) | |
| #--------------------------------------------------------------------------- | |
| def on_click__sync(self): | |
| self.__ui["options"]["keyframes"]["time"]["replay_sync"].set_text( | |
| "Synchronizing...") | |
| def on_click__settings(self, action): | |
| try: | |
| if action == "show_save_form": | |
| self.__file_form_visible = True | |
| self.__ui["file_form"]["save"].set_text("Save") | |
| if action == "show_load_form": | |
| self.__file_form_visible = True | |
| self.__ui["file_form"]["save"].set_text("Load") | |
| if action == "record_track_spline": | |
| if cam.get_recording_status("track"): | |
| cam.set_spline_recording(False, "track") | |
| if len(data.track_spline["the_x"]) == 0: | |
| self.__ui["options"]["settings"]["settings_track_spline"].set_text( | |
| "Record") | |
| else: | |
| self.__ui["options"]["settings"]["settings_track_spline"].set_text( | |
| "Remove") | |
| else: | |
| if len(data.track_spline["the_x"]) == 0: | |
| cam.set_spline_recording(True, "track") | |
| self.__ui["options"]["settings"]["settings_track_spline"].set_text( | |
| "Stop") | |
| else: | |
| data.remove_track_spline() | |
| self.__ui["options"]["settings"]["settings_track_spline"].set_text( | |
| "Record") | |
| if action == "record_pit_spline": | |
| if cam.get_recording_status("pit"): | |
| cam.set_spline_recording(False, "pit") | |
| if len(data.pit_spline["the_x"]) == 0: | |
| self.__ui["options"]["settings"]["settings_pit_spline"].set_text( | |
| "Record") | |
| else: | |
| self.__ui["options"]["settings"]["settings_pit_spline"].set_text( | |
| "Remove") | |
| else: | |
| if len(data.pit_spline["the_x"]) == 0: | |
| cam.set_spline_recording(True, "pit") | |
| self.__ui["options"]["settings"]["settings_pit_spline"].set_text( | |
| "Stop") | |
| else: | |
| data.remove_pit_spline() | |
| self.__ui["options"]["settings"]["settings_pit_spline"].set_text( | |
| "Record") | |
| except Exception as e: | |
| debug(e) | |
| def on_click__keyframe(self, action): | |
| global replay_pos, a, s, c | |
| try: | |
| self.action = action | |
| if self.action == "pos": | |
| if self.data().keyframe == None: | |
| self.data().keyframe = float( | |
| self.__ui["options"]["keyframes"]["pos"]["keyframe"].get_text()[:-2]) / ac.getTrackLength() | |
| else: | |
| self.data().keyframe = None | |
| self.multiplier = 0.5 | |
| if s: | |
| self.multiplier *= 4 | |
| if c: | |
| self.multiplier /= 4 | |
| if self.data().keyframe != None and not a: | |
| if self.action == "pos_mmm": | |
| self.data().keyframe = ((self.data().keyframe * ac.getTrackLength() - | |
| self.multiplier * 100) / ac.getTrackLength()) # % 1 | |
| if self.action == "pos_mm": | |
| self.data().keyframe = ((self.data().keyframe * ac.getTrackLength() - | |
| self.multiplier * 10) / ac.getTrackLength()) # % 1 | |
| if self.action == "pos_m": | |
| self.data().keyframe = ((self.data().keyframe * ac.getTrackLength() - | |
| self.multiplier * 1) / ac.getTrackLength()) # % 1 | |
| if self.action == "pos_ppp": | |
| self.data().keyframe = ((self.data().keyframe * ac.getTrackLength() + | |
| self.multiplier * 100) / ac.getTrackLength()) # % 1 | |
| if self.action == "pos_pp": | |
| self.data().keyframe = ((self.data().keyframe * ac.getTrackLength() + | |
| self.multiplier * 10) / ac.getTrackLength()) # % 1 | |
| if self.action == "pos_p": | |
| self.data().keyframe = ((self.data().keyframe * ac.getTrackLength() + | |
| self.multiplier * 1) / ac.getTrackLength()) # % 1 | |
| else: | |
| if self.action[:3] == "pos" and self.action != "pos": | |
| self.action = self.action.replace("pos", "time") | |
| #------------------------------------------------------------------- | |
| if self.action == "time": | |
| if self.data().keyframe == None: | |
| self.data().keyframe = replay.get_interpolated_replay_pos() | |
| else: | |
| self.data().keyframe = None | |
| if self.data().keyframe == None or a: | |
| if replay.is_sync(): | |
| if self.action == "time_mm": | |
| self.set_replay_pos(replay_pos - (self.multiplier * 10 * (1000 / replay.get_refresh_rate()))) | |
| if self.action == "time_m": | |
| self.set_replay_pos(replay_pos - (self.multiplier * 1 * (1000 / replay.get_refresh_rate()))) | |
| if self.action == "time_pp": | |
| self.set_replay_pos(replay_pos + (self.multiplier * 10 * (1000 / replay.get_refresh_rate()))) | |
| if self.action == "time_p": | |
| self.set_replay_pos(replay_pos + (self.multiplier * 1 * (1000 / replay.get_refresh_rate()))) | |
| else: | |
| if self.action == "time_mm": | |
| self.set_replay_pos( | |
| replay_pos - self.multiplier * 100) | |
| if self.action == "time_m": | |
| self.set_replay_pos( | |
| replay_pos - self.multiplier * 10) | |
| if self.action == "time_pp": | |
| self.set_replay_pos( | |
| replay_pos + self.multiplier * 100) | |
| if self.action == "time_p": | |
| self.set_replay_pos( | |
| replay_pos + self.multiplier * 10) | |
| if self.data().keyframe != None and not a: | |
| if self.action == "time_pp": | |
| self.data().set_keyframe(self.data().get_keyframe() + | |
| self.multiplier * (1000 / replay.get_refresh_rate())) | |
| if self.action == "time_p": | |
| self.data().set_keyframe(self.data().get_keyframe() + | |
| self.multiplier * (1000 / replay.get_refresh_rate()) * 0.1) | |
| if self.action == "time_mm": | |
| self.data().set_keyframe(self.data().get_keyframe() - | |
| self.multiplier * (1000 / replay.get_refresh_rate())) | |
| if self.action == "time_m": | |
| self.data().set_keyframe(self.data().get_keyframe() - | |
| self.multiplier * (1000 / replay.get_refresh_rate()) * 0.1) | |
| #------------------------------------------------------------------- | |
| self.set_active_kf( | |
| data.mode[data.active_mode][self.__active_cam].sort_keyframes(self.__active_kf)) | |
| except Exception as e: | |
| debug(e) | |
| def on_click__tracking(self, action): | |
| try: | |
| if action == "car_1_p": | |
| cam.set_tracked_car( | |
| 0, cam.get_next_car(cam.get_tracked_car(0))) | |
| ac.focusCar(cam.get_tracked_car(0)) | |
| if action == "car_1": | |
| pass | |
| if action == "car_1_m": | |
| cam.set_tracked_car( | |
| 0, cam.get_prev_car(cam.get_tracked_car(0))) | |
| ac.focusCar(cam.get_tracked_car(0)) | |
| if action == "car_2_p": | |
| cam.set_tracked_car( | |
| 1, cam.get_next_car(cam.get_tracked_car(1))) | |
| if action == "car_2": | |
| pass | |
| if action == "car_2_m": | |
| cam.set_tracked_car( | |
| 1, cam.get_prev_car(cam.get_tracked_car(1))) | |
| except Exception as e: | |
| debug(e) | |
| def on_click__camera(self, action): | |
| global fov, focus_point | |
| try: | |
| if action == "hide_input": | |
| self.__ui["options"]["camera"]["camera_in"].hide_input() | |
| data.set_camera_in( | |
| self.__active_cam, self.__ui["options"]["camera"]["camera_in"].get_input_text().replace(",", ".")) | |
| self.set_active_cam(data.sort_cameras(self.__active_cam)) | |
| elif action == "show_input": | |
| self.__ui["options"]["camera"]["camera_in"].show_input() | |
| if action == "use_tracking_point": | |
| if self.data("camera").camera_use_tracking_point == 0: | |
| self.data("camera").camera_use_tracking_point = 1 | |
| else: | |
| self.data("camera").camera_use_tracking_point = 0 | |
| if action == "camera_pit": | |
| if self.data("camera").camera_pit == False: | |
| self.data("camera").camera_pit = True | |
| else: | |
| self.data("camera").camera_pit = False | |
| if action == "focus_m": | |
| if self.data().interpolation["camera_focus_point"] == None: | |
| ctt.set_focus_point( | |
| max(0, focus_point - (focus_point * 0.1))) | |
| else: | |
| self.data().interpolation["camera_focus_point"] = max( | |
| 0, self.data().interpolation["camera_focus_point"] - 0.5) | |
| if action == "focus": | |
| if self.data().interpolation["camera_focus_point"] == None: | |
| self.data( | |
| ).interpolation["camera_focus_point"] = focus_point | |
| else: | |
| self.data().interpolation["camera_focus_point"] = None | |
| if action == "focus_p": | |
| if self.data().interpolation["camera_focus_point"] == None: | |
| ctt.set_focus_point( | |
| focus_point + (focus_point * 0.1)) | |
| else: | |
| self.data().interpolation["camera_focus_point"] = self.data( | |
| ).interpolation["camera_focus_point"] + 0.5 | |
| if action == "fov_m": | |
| if self.data().interpolation["camera_fov"] == None: | |
| ctt.set_fov(max(0, fov - 5)) | |
| else: | |
| self.data().interpolation["camera_fov"] = ctt.convert_fov_2_focal_length(max( | |
| 0, ctt.convert_fov_2_focal_length(self.data().interpolation["camera_fov"], True) - 0.5)) | |
| if action == "fov": | |
| if self.data().interpolation["camera_fov"] == None: | |
| self.data().interpolation["camera_fov"] = ctt.convert_fov_2_focal_length( | |
| fov) | |
| else: | |
| self.data().interpolation["camera_fov"] = None | |
| if action == "fov_p": | |
| if self.data().interpolation["camera_fov"] == None: | |
| ctt.set_fov(max(0, fov + 5)) | |
| else: | |
| self.data().interpolation["camera_fov"] = ctt.convert_fov_2_focal_length(max( | |
| 0, ctt.convert_fov_2_focal_length(self.data().interpolation["camera_fov"], True) + 0.5)) | |
| except Exception as e: | |
| debug(e) | |
| def on_click__spline(self, action): | |
| try: | |
| if action == "record": | |
| if cam.get_recording_status("camera"): | |
| cam.set_spline_recording(False) | |
| if len(data.mode[data.active_mode][self.__active_cam].spline["the_x"]) == 0: | |
| self.__ui["options"]["spline"]["spline_record"].set_text( | |
| "Record") | |
| else: | |
| self.__ui["options"]["spline"]["spline_record"].set_text( | |
| "Remove") | |
| else: | |
| if len(data.mode[data.active_mode][self.__active_cam].spline["the_x"]) == 0: | |
| cam.set_spline_recording(True) | |
| self.__ui["options"]["spline"]["spline_record"].set_text( | |
| "Stop") | |
| else: | |
| data.mode[data.active_mode][self.__active_cam].remove_spline() | |
| self.__ui["options"]["spline"]["spline_record"].set_text( | |
| "Record") | |
| if action == "speed_m": | |
| self.set_camera_data("spline_speed", -0.05, True, False) | |
| if action == "speed_p": | |
| self.set_camera_data("spline_speed", 0.05, True, False) | |
| if action == "loc_xy_m": | |
| self.set_camera_data("spline_affect_loc_xy", -0.1, True) | |
| if action == "loc_xy_p": | |
| self.set_camera_data("spline_affect_loc_xy", 0.1, True) | |
| if action == "loc_z_m": | |
| self.set_camera_data("spline_affect_loc_z", -0.1, True) | |
| if action == "loc_z_p": | |
| self.set_camera_data("spline_affect_loc_z", 0.1, True) | |
| if action == "pitch_m": | |
| self.set_camera_data("spline_affect_pitch", -0.1, True) | |
| if action == "pitch_p": | |
| self.set_camera_data("spline_affect_pitch", 0.1, True) | |
| if action == "roll_m": | |
| self.set_camera_data("spline_affect_roll", -0.1, True) | |
| if action == "roll_p": | |
| self.set_camera_data("spline_affect_roll", 0.1, True) | |
| if action == "heading_m": | |
| self.set_camera_data("spline_affect_heading", -0.1, True) | |
| if action == "heading_p": | |
| self.set_camera_data("spline_affect_heading", 0.1, True) | |
| if action == "offset_pitch_m": | |
| self.set_camera_data("spline_offset_pitch", | |
| math.radians(-1), True, False) | |
| if action == "offset_pitch_p": | |
| self.set_camera_data("spline_offset_pitch", | |
| math.radians(1), True, False) | |
| if action == "offset_heading_m": | |
| self.set_camera_data( | |
| "spline_offset_heading", math.radians(-5), True, False) | |
| if action == "offset_heading_p": | |
| self.set_camera_data( | |
| "spline_offset_heading", math.radians(5), True, False) | |
| if action == "offset_loc_z_m": | |
| self.set_camera_data("spline_offset_loc_z", -0.25, True, False) | |
| if action == "offset_loc_z_p": | |
| self.set_camera_data("spline_offset_loc_z", 0.25, True, False) | |
| if action == "offset_loc_x_m": | |
| self.set_camera_data("spline_offset_loc_x", -0.25, True, False) | |
| if action == "offset_loc_x_p": | |
| self.set_camera_data("spline_offset_loc_x", 0.25, True, False) | |
| if data.active_mode == "pos": | |
| if action == "offset_spline_m": | |
| self.set_camera_data( | |
| "spline_offset_spline", -5 / ac.getTrackLength(), True, False) | |
| if action == "offset_spline_p": | |
| self.set_camera_data( | |
| "spline_offset_spline", 5 / ac.getTrackLength(), True, False) | |
| else: | |
| if action == "offset_spline_m": | |
| self.set_camera_data( | |
| "spline_offset_spline", -10, True, False) | |
| if action == "offset_spline_p": | |
| self.set_camera_data( | |
| "spline_offset_spline", 10, True, False) | |
| except Exception as e: | |
| debug(e) | |
| def on_click__add_keyframe(self): | |
| global loc_x, loc_y, loc_z, rot_x, rot_y, rot_z | |
| if data.get_n_keyframes(self.__active_cam) < self.__max_keyframes: | |
| self.loc = vec3(loc_x, loc_y, loc_z) | |
| self.roll = rot_y | |
| data.add_keyframe(self.__active_cam, None, | |
| vec3(None, None, None), None) | |
| self.set_active_kf(data.get_n_keyframes(self.__active_cam) - 1) | |
| def on_click__remove_keyframe(self): | |
| if data.get_n_keyframes(self.__active_cam) > 1 and self.data("camera").keyframes[data.get_n_keyframes(self.__active_cam) - 1].keyframe == None: | |
| data.remove_keyframe(self.__active_cam, self.__active_kf) | |
| self.set_active_kf(data.get_n_keyframes(self.__active_cam) - 1) | |
| def on_click__add_camera(self): | |
| global loc_x, loc_y, loc_z, rot_x, rot_y, rot_z | |
| try: | |
| if data.get_n_cameras() < self.__max_cameras: | |
| self.loc = vec3(loc_x, loc_y, loc_z) | |
| self.roll = rot_y | |
| self.active_cam = data.add_camera(self.__the_x, self.loc, 0) | |
| self.set_active_cam(self.active_cam) | |
| except Exception as e: | |
| debug(e) | |
| def on_click__remove_camera(self): | |
| try: | |
| if data.get_n_cameras() > 1 and data.mode[data.active_mode][self.__active_cam].keyframes[0].keyframe == None: | |
| self.set_active_kf(0) | |
| data.remove_camera(self.__active_cam) | |
| self.set_active_cam(data.get_n_cameras() - 1) | |
| except Exception as e: | |
| debug(e) | |
| def on_click__activate(self): | |
| if self.active_app: | |
| self.active_app = False | |
| self.__ui["header"]["activate"].set_background("off", 0, 0) | |
| else: | |
| self.active_app = True | |
| self.__ui["header"]["activate"].set_background("on", 0, 0) | |
| def on_click__file_form(self, action, button_id=None): | |
| try: | |
| if action == "btn_click": | |
| self.btn_text = self.__ui["file_form"]["buttons"][button_id].get_text( | |
| ) | |
| if self.btn_text == "Show more": | |
| if (self.__file_form_page + 1) * self.__max_btns_in_column < self.__n_files: | |
| self.__file_form_page += 1 | |
| elif self.btn_text == "Show previous": | |
| self.__file_form_page = max(0, self.__file_form_page - 1) | |
| else: | |
| self.file_index = button_id + self.__file_form_page * self.__max_btns_in_column | |
| self.file_index -= 2 * self.__file_form_page | |
| if self.file_index < self.__n_files: | |
| self.__ui["file_form"]["input"].set_text( | |
| self.__ui["file_form"]["buttons"][button_id].get_text()) | |
| if self.get_file_form_mode() == "Load": | |
| file_form__save_or_load() | |
| if action == "btn_x_click": | |
| self.btn_text = self.__ui["file_form"]["buttons"][button_id].get_text( | |
| ) | |
| if self.btn_text != "Show more" and self.btn_text != "Show previous": | |
| self.file_index = button_id + self.__file_form_page * self.__max_btns_in_column | |
| self.file_index -= 2 * self.__file_form_page | |
| if self.file_index < self.__n_files: | |
| data.remove_file(__file__, self.btn_text) | |
| if action == "close": | |
| self.__file_form_visible = False | |
| except Exception as e: | |
| debug(e) | |
| #------------------------------------------------------------------------------- | |
| class Button(object): | |
| def __init__(self, app, name="Button", pos=vec(0, 20), size=vec(100, 20), color=vec3(0.5, 0.5, 0.5), align="center"): | |
| if align == "left": | |
| self.__name = " "+name | |
| else: | |
| self.__name = name | |
| self.__btn = ac.addButton(app, "{0}".format(self.__name)) | |
| self.__size = size | |
| self.__pos = pos | |
| self.__enabled = True | |
| self.__color = color | |
| ac.setSize(self.__btn, self.__size.x, self.__size.y) | |
| ac.setPosition(self.__btn, self.__pos.x, self.__pos.y) | |
| ac.setBackgroundColor(self.__btn, color.x, color.y, color.z) | |
| ac.setBackgroundOpacity(self.__btn, 0.5) | |
| ac.setFontAlignment(self.__btn, "{0}".format(align)) | |
| ac.setCustomFont(self.__btn, gFont2, 0, 0) | |
| ac.setFontSize(self.__btn, 14) | |
| def bold(self, val): | |
| if val: | |
| ac.setCustomFont(self.__btn, gFont, 0, 1) | |
| else: | |
| ac.setCustomFont(self.__btn, gFont, 0, 0) | |
| ac.setFontSize(self.__btn, 14) | |
| def set_background(self, name, opacity=0.5, border=1): | |
| try: | |
| ac.drawBackground(self.__btn, 1) | |
| ac.drawBorder(self.__btn, border) | |
| ac.setBackgroundOpacity(self.__btn, opacity) | |
| #ac.setBackgroundTexture( self.__btn, str(gImgPath) + str(name) + 'png') | |
| # ⌚ ⌦ ⃟ ⏱ ⏲ ◌ ○ ☑ ☒ ✊ ✋✌ ⊀⊁≻≺≪≫ ⃠ ⃤ ∎ ∧ ↺ ↻ ⏹ ⏺ ◎ ◉ | |
| if str(name) == 'camera': | |
| ac.setText(self.__btn, '⌻') | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| elif str(name) == 'on': | |
| ac.setText(self.__btn, '◉') | |
| ac.setFontColor(self.__btn, 1, 0.25, 0.25, 1) | |
| elif str(name) == 'off': | |
| ac.setText(self.__btn, '◎') | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| elif str(name) == 'pos_active': | |
| ac.setText(self.__btn, '▲') | |
| ac.setFontColor(self.__btn, 1, 0.25, 0.25, 1) | |
| elif str(name) == 'pos': | |
| ac.setText(self.__btn, '△') | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| elif str(name) == 'remove': | |
| ac.setText(self.__btn, '☒') | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| elif str(name) == 'reset': | |
| ac.setText(self.__btn, '↻') | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| elif str(name) == 'time_active': | |
| ac.setText(self.__btn, '⌚') | |
| ac.setFontColor(self.__btn, 1, 0.25, 0.25, 1) | |
| elif str(name) == 'time': | |
| ac.setText(self.__btn, '⌚') | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| elif str(name) == 'keyframe': | |
| ac.setText(self.__btn, ' ⃟ ') | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| elif str(name) == 'next': | |
| ac.setText(self.__btn, '≻') | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| elif str(name) == 'next_disabled': | |
| ac.setText(self.__btn, '⊁') | |
| ac.setFontColor(self.__btn, 0.25, 0.25, 0.25, 1) | |
| elif str(name) == 'next+': | |
| ac.setText(self.__btn, '≫') | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| elif str(name) == 'prev': | |
| ac.setText(self.__btn, '≺') | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| elif str(name) == 'prev_disabled': | |
| ac.setText(self.__btn, '⊀') | |
| ac.setFontColor(self.__btn, 0.25, 0.25, 0.25, 1) | |
| elif str(name) == 'prev+': | |
| ac.setText(self.__btn, '≪') | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| except Exception as e: | |
| debug(e) | |
| def disable(self): | |
| self.__enabled = False | |
| ac.setFontColor(self.__btn, 1, 1, 1, 0.5) | |
| def enable(self): | |
| self.__enabled = True | |
| ac.setFontColor(self.__btn, 1, 1, 1, 1) | |
| def is_enabled(self): | |
| return self.__enabled | |
| def get_btn(self): | |
| return self.__btn | |
| def get_size(self): | |
| return self.__size | |
| def get_pos(self): | |
| return self.__pos | |
| def get_next_pos(self): | |
| return vec(self.__pos.x + self.__size.x, self.__pos.y) | |
| def get_next_pos_v(self): | |
| return vec(self.__pos.x, self.__pos.y + self.__size.y) | |
| def get_text(self): | |
| return ac.getText(self.__btn) | |
| def set_pos(self, pos): | |
| try: | |
| self.__pos.x = pos.x | |
| self.__pos.y = pos.y | |
| ac.setPosition(self.__btn, self.__pos.x, self.__pos.y) | |
| except Exception as e: | |
| debug(e) | |
| def set_size(self, size): | |
| self.__size = size | |
| ac.setSize(self.__btn, self.__size.x, self.__size.y) | |
| def set_text(self, text, b_round=False, unit=None): | |
| self.value = text | |
| self.unit = "" | |
| if b_round: | |
| if unit == "%": | |
| self.value *= 100 | |
| self.unit = "%" | |
| if unit == "degrees": | |
| self.value = math.degrees(self.value) | |
| self.unit = "°" | |
| if unit == "time": | |
| self.unit = " s" | |
| if unit == "m": | |
| self.unit = " m" | |
| if unit == "%": | |
| ac.setText(self.__btn, "{0:.0f}{1}".format( | |
| float(self.value), self.unit)) | |
| else: | |
| ac.setText(self.__btn, "{0:.2f}{1}".format( | |
| float(self.value), self.unit)) | |
| else: | |
| ac.setText(self.__btn, "{0}".format(self.value)) | |
| def show(self): | |
| ac.setVisible(self.__btn, 1) | |
| def hide(self): | |
| ac.setVisible(self.__btn, 0) | |
| def highlight(self, b_highlight): | |
| if b_highlight: | |
| ac.setBackgroundColor(self.__btn, 0.75, 0.1, 0.1) | |
| ac.setBackgroundOpacity(self.__btn, 1) | |
| else: | |
| ac.setBackgroundColor(self.__btn, 0.5, 0.5, 0.5) | |
| ac.setBackgroundOpacity(self.__btn, 0.5) | |
| class Div(object): | |
| def __init__(self, app, pos=vec(0, 0), size=vec(100, 100), color=vec3(0, 0, 0), opacity=0.5): | |
| try: | |
| self.__div = ac.addButton(app, "") | |
| self.__size = size | |
| self.__pos = pos | |
| ac.setSize(self.__div, self.__size.x, self.__size.y) | |
| ac.setPosition(self.__div, self.__pos.x, self.__pos.y) | |
| ac.setBackgroundColor(self.__div, color.x, color.y, color.z) | |
| ac.setBackgroundOpacity(self.__div, opacity) | |
| ac.drawBorder(self.__div, 0) | |
| except Exception as e: | |
| debug(e) | |
| def get_btn(self): | |
| return self.__div | |
| def get_size(self): | |
| return self.__size | |
| def get_next_pos_v(self): | |
| return self.__pos + vec(0, self.__size.y) | |
| def show(self): | |
| ac.setVisible(self.__div, 1) | |
| def hide(self): | |
| ac.setVisible(self.__div, 0) | |
| def get_pos(self): | |
| return self.__pos | |
| def set_pos(self, pos): | |
| self.__pos = pos | |
| ac.setPosition(self.__div, self.__pos.x, self.__pos.y) | |
| def set_size(self, size): | |
| self.__size = size | |
| ac.setSize(self.__div, self.__size.x, self.__size.y) | |
| class Label(object): | |
| def __init__(self, app, text, pos, size=vec(100, 24), font_size=14): | |
| self.__lbl = ac.addLabel(app, "{0}".format(text)) | |
| self.__size = size | |
| self.__pos = pos | |
| self.__font_size = font_size | |
| self.set_pos(pos) | |
| self.set_size(size) | |
| ac.setCustomFont(self.__lbl, gFont, 0, 0) | |
| ac.setFontSize(self.__lbl, font_size) | |
| def set_alignment(self, value): | |
| ac.setFontAlignment(self.__lbl, value) | |
| def get_pos(self): | |
| return self.__pos | |
| def hide(self): | |
| ac.setVisible(self.__lbl, 0) | |
| def show(self): | |
| ac.setVisible(self.__lbl, 1) | |
| def get_label(self): | |
| return self.__lbl | |
| def get_size(self): | |
| return self.__size | |
| def set_size(self, size): | |
| try: | |
| ac.setSize(self.__lbl, size.x, size.y) | |
| except Exception as e: | |
| debug(e) | |
| def set_bold(self, value): | |
| if value: | |
| ac.setCustomFont(self.__lbl, gFont, 0, 1) | |
| else: | |
| ac.setCustomFont(self.__lbl, gFont, 0, 0) | |
| ac.setFontSize(self.__lbl, self.__font_size) | |
| def set_text(self, text): | |
| ac.setText(self.__lbl, "{0}".format(text)) | |
| def set_font_size(self, size): | |
| ac.setFontSize(self.__lbl, size) | |
| def set_pos(self, pos): | |
| try: | |
| ac.setPosition(self.__lbl, pos.x, pos.y) | |
| except Exception as e: | |
| debug(e) | |
| def get_next_pos(self): | |
| return vec(self.__pos.x + self.__size.x, self.__pos.y) | |
| def get_next_pos_v(self): | |
| return vec(self.__pos.x, self.__pos.y + self.__size.y) | |
| class Input(object): | |
| def __init__(self, app, name="Button", pos=vec(), size=vec(200, 30), bgcol=vec3(0.5, 0.5, 0.5)): | |
| self.__input = ac.addTextInput(app, "{0}".format(name)) | |
| ac.setPosition(self.__input, pos.x, pos.y) | |
| ac.setSize(self.__input, size.x, size.y) | |
| ac.setText(self.__input, "{0}".format(name)) | |
| ac.setFontAlignment(self.__input, "center") | |
| ac.setBackgroundColor(self.__input, bgcol.x, bgcol.y, bgcol.z) | |
| def get_text(self): | |
| return ac.getText(self.__input) | |
| def get_input(self): | |
| return self.__input | |
| def get_next_pos_v(self): | |
| return vec(ac.getPosition(self.__input)[0], ac.getPosition(self.__input)[1] + ac.getSize(self.__input)[1]) | |
| def set_text(self, text): | |
| ac.setText(self.__input, "{0}".format(text)) | |
| def hide(self): | |
| ac.setVisible(self.__input, 0) | |
| def show(self): | |
| ac.setVisible(self.__input, 1) | |
| class Editable_Button(object): | |
| def __init__(self, app, Button, Input, Label, name="", pos=vec(200, 200), size=vec(100, 24)): | |
| self.active = False | |
| if name == "": | |
| self.__lbl_size = vec(0, 0) | |
| else: | |
| self.__lbl_size = vec(100, size.y) | |
| self.__pos = pos | |
| self.__size = size | |
| self.__btn = Button(app, name, vec( | |
| pos.x + self.__lbl_size.x, pos.y), vec(size.x - self.__lbl_size.x, size.y)) | |
| self.__input = Input(app, name, vec( | |
| pos.x + self.__lbl_size.x, pos.y), vec(size.x - self.__lbl_size.x, size.y), vec3(1, 0, 0)) | |
| self.__label = Label(app, name+':', pos, self.__lbl_size) | |
| ac.setFontSize(self.__label.get_label(), 14) | |
| self.__input.hide() | |
| def get_btn(self): | |
| return self.__btn.get_btn() | |
| def get_input(self): | |
| return self.__input.get_input() | |
| def set_focus(self): | |
| ac.setFocus(self.__input.get_input(), 1) | |
| def hide_input(self): | |
| self.active = False | |
| self.value = ac.getText(self.get_input()) | |
| self.value = self.value.replace(",", ".") | |
| self.__btn.set_text(self.value, True, "m") | |
| ac.setVisible(self.get_input(), 0) | |
| ac.setVisible(self.get_btn(), 1) | |
| def show_input(self): | |
| try: | |
| self.active = True | |
| #ac.setText(self.get_input(), ac.getText(self.get_btn())) | |
| ac.setText(self.get_input(), "") | |
| self.__input.show() | |
| self.__btn.hide() | |
| except Exception as e: | |
| debug(e) | |
| def hide(self): | |
| self.__btn.hide() | |
| self.__input.hide() | |
| self.__label.hide() | |
| def show(self): | |
| if self.active: | |
| self.__btn.hide() | |
| self.__input.show() | |
| self.__label.show() | |
| else: | |
| self.__btn.show() | |
| self.__input.hide() | |
| self.__label.show() | |
| def get_size(self): | |
| return self.__size | |
| def get_true_size(self): | |
| return self.__size - vec(self.__lbl_size.x, 0) | |
| def get_next_pos_v(self): | |
| return vec(self.__pos.x, self.__pos.y + self.__size.y) | |
| def get_next_true_pos_v(self): | |
| return vec(self.__pos.x + self.__lbl_size.x, self.__pos.y + self.__size.y) | |
| def get_input_text(self): | |
| return self.__input.get_text() | |
| def set_text(self, text, b_round=False, unit=None): | |
| self.__btn.set_text(text, b_round, unit) | |
| class Option(object): | |
| def __init__(self, app, Button, Label, name="Option", pos=vec(200, 200), size=vec(100, 24), label=True, arrows=True, label_text=""): | |
| if label: | |
| self.__lbl_width = 100 | |
| if label_text == "": | |
| self.__lbl_name = name | |
| else: | |
| self.__lbl_name = label_text | |
| else: | |
| self.__lbl_width = 0 | |
| self.__pos = pos | |
| self.__size = size | |
| self.__enabled = True | |
| self.__value = None | |
| self.__reset_btn_enabled = False | |
| if arrows: | |
| self.__btn_sub = Button( | |
| app, "", pos + vec(self.__lbl_width, 0), vec(size.y, size.y)) | |
| self.__btn = Button(app, name, self.__btn_sub.get_next_pos( | |
| ), size - vec(self.__lbl_width + size.y * 2, 0)) | |
| self.__btn_add = Button( | |
| app, "", self.__btn.get_next_pos(), vec(size.y, size.y)) | |
| self.__btn_sub.set_background("prev") | |
| self.__btn_add.set_background("next") | |
| else: | |
| self.__btn_sub = Button(app, "", vec(-999999, -99999), vec()) | |
| self.__btn_add = Button(app, "", vec(-999999, -99999), vec()) | |
| self.__btn = Button( | |
| app, name, pos + vec(self.__lbl_width, 0), size - vec(self.__lbl_width, 0)) | |
| self.__btn_reset = Button(app, "", self.__btn_add.get_pos( | |
| ) - vec(self.__btn_add.get_size().x, 0), vec(size.y, size.y)) | |
| self.__btn_reset.set_background("reset") | |
| self.__btn_reset.hide() | |
| if self.__lbl_name != "": | |
| self.__lbl_name += ':' | |
| self.__lbl = Label(app, self.__lbl_name, pos, | |
| vec(self.__lbl_width, size.y)) | |
| self.__lbl.set_font_size(14) | |
| def show_reset_button(self): | |
| self.__reset_btn_enabled = True | |
| self.__btn.set_size(vec(self.__btn.get_size( | |
| ).x - self.__btn_reset.get_size().x, self.__btn.get_size().y)) | |
| self.__btn_reset.show() | |
| def disable(self): | |
| self.__enabled = False | |
| self.__btn.disable() | |
| self.__btn_sub.set_background("prev_disabled") | |
| self.__btn_add.set_background("next_disabled") | |
| def enable(self): | |
| self.__enabled = True | |
| self.__btn.enable() | |
| self.__btn_sub.set_background("prev") | |
| self.__btn_add.set_background("next") | |
| def is_enabled(self): | |
| return self.__enabled | |
| def highlight(self, b_highlight): | |
| if b_highlight: | |
| self.__btn.highlight(True) | |
| else: | |
| self.__btn.highlight(False) | |
| def hide(self): | |
| self.__lbl.hide() | |
| self.__btn_sub.hide() | |
| self.__btn.hide() | |
| self.__btn_add.hide() | |
| self.__btn_reset.hide() | |
| def show(self): | |
| self.__lbl.show() | |
| self.__btn_sub.show() | |
| self.__btn.show() | |
| self.__btn_add.show() | |
| if self.__reset_btn_enabled: | |
| self.__btn_reset.show() | |
| def get_btn_reset(self): | |
| return self.__btn_reset.get_btn() | |
| def get_btn(self): | |
| return self.__btn.get_btn() | |
| def get_btn_m(self): | |
| return self.__btn_sub.get_btn() | |
| def get_btn_p(self): | |
| return self.__btn_add.get_btn() | |
| def set_text(self, value, b_round=False, unit=None): | |
| try: | |
| self.__btn.set_text(value, b_round, unit) | |
| except Exception as e: | |
| debug(e) | |
| def get_value(self): | |
| return self.__value | |
| def get_text(self): | |
| ac.getText(self.__btn.get_btn()) | |
| def get_true_next_pos_v(self): | |
| return self.__btn_sub.get_pos() + vec(0, self.__size.y) | |
| def get_next_pos_v(self): | |
| return vec(self.__pos.x, self.__pos.y + self.__size.y) | |
| def get_size(self): | |
| return self.__size | |
| #=============================================================================== | |
| def file_form__wrapper(*arg): | |
| click_pos = arg | |
| button_id = math.floor(click_pos[1] / gUI.get_btn_height()) | |
| if gUI.get_right_panel_size().x - gUI.get_btn_height() > click_pos[0]: | |
| gUI.on_click__file_form("btn_click", button_id) | |
| else: | |
| gUI.on_click__file_form("btn_x_click", button_id) | |
| def file_form__cancel(*arg): | |
| gUI.on_click__file_form("close") | |
| def file_form__save_or_load(*arg): | |
| if gUI.get_file_form_mode() == "Save": | |
| if data.save(__file__, gUI.get_file_form_input()): | |
| gUI.on_click__file_form("close") | |
| else: | |
| if data.load(__file__, gUI.get_file_form_input()): | |
| gUI.on_click__file_form("close") | |
| def spline__record(*arg): | |
| gUI.on_click__spline("record") | |
| def spline__speed_m(*arg): | |
| gUI.set_data("spline_speed_m", 0.01, False) | |
| def spline__speed(*arg): | |
| gUI.set_data("spline_speed", "camera") | |
| def spline__speed_p(*arg): | |
| gUI.set_data("spline_speed_p", 0.01, False) | |
| def spline__affect_loc_xy_m(*arg): | |
| gUI.set_data("spline_affect_loc_xy_m", 0.05) | |
| def spline__affect_loc_xy(*arg): | |
| gUI.set_data("spline_affect_loc_xy", "camera") | |
| def spline__affect_loc_xy_p(*arg): | |
| gUI.set_data("spline_affect_loc_xy_p", 0.05) | |
| def spline__affect_loc_z_m(*arg): | |
| gUI.on_click__spline("loc_z_m") | |
| def spline__affect_loc_z(*arg): | |
| gUI.set_data("spline_affect_loc_z", "camera") | |
| def spline__affect_loc_z_p(*arg): | |
| gUI.on_click__spline("loc_z_p") | |
| def spline_affect_pitch_m(*arg): | |
| gUI.on_click__spline("pitch_m") | |
| def spline_affect_pitch(*arg): | |
| gUI.set_data("spline_affect_pitch", "camera") | |
| def spline_affect_pitch_p(*arg): | |
| gUI.on_click__spline("pitch_p") | |
| def spline_affect_roll_m(*arg): | |
| gUI.on_click__spline("roll_m") | |
| def spline_affect_roll(*arg): | |
| gUI.set_data("spline_affect_roll", "camera") | |
| def spline_affect_roll_p(*arg): | |
| gUI.on_click__spline("roll_p") | |
| def spline_affect_heading_m(*arg): | |
| gUI.on_click__spline("heading_m") | |
| def spline_affect_heading(*arg): | |
| gUI.set_data("spline_affect_heading", "camera") | |
| def spline_affect_heading_p(*arg): | |
| gUI.on_click__spline("heading_p") | |
| def spline_offset_pitch_m(*arg): | |
| gUI.on_click__spline("offset_pitch_m") | |
| def spline_offset_pitch(*arg): | |
| gUI.set_data("spline_offset_pitch", "camera") | |
| def spline_offset_pitch_p(*arg): | |
| gUI.on_click__spline("offset_pitch_p") | |
| def spline_offset_heading_m(*arg): | |
| gUI.on_click__spline("offset_heading_m") | |
| def spline_offset_heading(*arg): | |
| gUI.set_data("spline_offset_heading", "camera") | |
| def spline_offset_heading_p(*arg): | |
| gUI.on_click__spline("offset_heading_p") | |
| def spline_offset_loc_z_m(*arg): | |
| gUI.on_click__spline("offset_loc_z_m") | |
| def spline_offset_loc_z(*arg): | |
| gUI.set_data("spline_offset_loc_z", "camera") | |
| def spline_offset_loc_z_p(*arg): | |
| gUI.on_click__spline("offset_loc_z_p") | |
| def spline_offset_loc_x_m(*arg): | |
| gUI.on_click__spline("offset_loc_x_m") | |
| def spline_offset_loc_x(*arg): | |
| gUI.set_data("spline_offset_loc_x", "camera") | |
| def spline_offset_loc_x_p(*arg): | |
| gUI.on_click__spline("offset_loc_x_p") | |
| def spline_offset_spline_m(*arg): | |
| gUI.on_click__spline("offset_spline_m") | |
| def spline_offset_spline(*arg): | |
| gUI.set_data("spline_offset_spline", "camera") | |
| def spline_offset_spline_p(*arg): | |
| gUI.on_click__spline("offset_spline_p") | |
| def spline_offset_reset(*arg): | |
| if gUI.data().interpolation["spline_offset_spline"] == None: | |
| gUI.data("camera").spline_offset_spline = 0 | |
| else: | |
| gUI.data().interpolation["spline_offset_spline"] = 0 | |
| def side_k(*arg): | |
| try: | |
| mouse_click_pos = vec(arg[0], arg[1]) | |
| panel_size = gUI.get_side_panel_size() | |
| btn_height = gUI.get_btn_height() | |
| mouse_click_pos_in_grid = vec( | |
| int(mouse_click_pos.x / btn_height), int((mouse_click_pos.y) / btn_height)) | |
| slot = mouse_click_pos_in_grid.x * gUI.get_max_btns_in_col() + \ | |
| mouse_click_pos_in_grid.y - 1 | |
| gUI.set_active_kf(slot) | |
| except Exception as e: | |
| debug(e) | |
| def side_c(*arg): | |
| try: | |
| mouse_click_pos = vec(arg[0], arg[1]) | |
| panel_size = gUI.get_side_panel_size() | |
| btn_height = gUI.get_btn_height() | |
| mouse_click_pos_in_grid = vec( | |
| int(mouse_click_pos.x / btn_height), int((mouse_click_pos.y) / btn_height)) | |
| slot = mouse_click_pos_in_grid.x * gUI.get_max_btns_in_col() + \ | |
| mouse_click_pos_in_grid.y - 1 | |
| gUI.set_active_cam(slot) | |
| except Exception as e: | |
| debug(e) | |
| def keyframes__pos(*arg): | |
| gUI.on_click__keyframe("pos") | |
| def keyframes__pos_mmm(*arg): | |
| gUI.on_click__keyframe("pos_mmm") | |
| def keyframes__pos_mm(*arg): | |
| gUI.on_click__keyframe("pos_mm") | |
| def keyframes__pos_m(*arg): | |
| gUI.on_click__keyframe("pos_m") | |
| def keyframes__pos_p(*arg): | |
| gUI.on_click__keyframe("pos_p") | |
| def keyframes__pos_pp(*arg): | |
| gUI.on_click__keyframe("pos_pp") | |
| def keyframes__pos_ppp(*arg): | |
| gUI.on_click__keyframe("pos_ppp") | |
| def keyframes__time(*arg): | |
| gUI.on_click__keyframe("time") | |
| def keyframes__time_mm(*arg): | |
| gUI.on_click__keyframe("time_mm") | |
| def keyframes__time_m(*arg): | |
| gUI.on_click__keyframe("time_m") | |
| def keyframes__time_p(*arg): | |
| gUI.on_click__keyframe("time_p") | |
| def keyframes__time_pp(*arg): | |
| gUI.on_click__keyframe("time_pp") | |
| def replay_sync(*arg): | |
| replay.sync(ctt) | |
| gUI.on_click__sync() | |
| def transform__loc_x(*arg): | |
| global loc_x | |
| gUI.set_data("loc_x", loc_x) | |
| def transform__loc_y(*arg): | |
| global loc_y | |
| gUI.set_data("loc_y", loc_y) | |
| def transform__loc_z(*arg): | |
| global loc_z | |
| gUI.set_data("loc_z", loc_z) | |
| def transform__loc_x_m(*arg): | |
| gUI.set_data("loc_x_m", 0.5, False) | |
| def transform__loc_y_m(*arg): | |
| gUI.set_data("loc_y_m", 0.5, False) | |
| def transform__loc_z_m(*arg): | |
| gUI.set_data("loc_z_m", 0.5, False) | |
| def transform__loc_x_p(*arg): | |
| gUI.set_data("loc_x_p", 0.5, False) | |
| def transform__loc_y_p(*arg): | |
| gUI.set_data("loc_y_p", 0.5, False) | |
| def transform__loc_z_p(*arg): | |
| gUI.set_data("loc_z_p", 0.5, False) | |
| def transform__rot_x(*arg): | |
| global rot_x | |
| gUI.set_data("rot_x", rot_x) | |
| def transform__rot_y(*arg): | |
| global rot_y | |
| gUI.set_data("rot_y", rot_y) | |
| def transform__rot_z(*arg): | |
| global rot_z | |
| gUI.set_data("rot_z", rot_z) | |
| def transform__rot_x_m(*arg): | |
| gUI.set_data("rot_x_m", math.radians(2.5), False) | |
| def transform__rot_y_m(*arg): | |
| gUI.set_data("rot_y_m", math.radians(2.5), False) | |
| def transform__rot_z_m(*arg): | |
| gUI.set_data("rot_z_m", math.radians(2.5), False) | |
| def transform__rot_x_p(*arg): | |
| gUI.set_data("rot_x_p", math.radians(2.5), False) | |
| def transform__rot_y_p(*arg): | |
| gUI.set_data("rot_y_p", math.radians(2.5), False) | |
| def transform__rot_z_p(*arg): | |
| gUI.set_data("rot_z_p", math.radians(2.5), False) | |
| def transform__reset_pitch(*arg): | |
| if gUI.data().interpolation["rot_x"] == None: | |
| ctt.set_pitch(0) | |
| else: | |
| gUI.data().interpolation["rot_x"] = 0 | |
| def transform__reset_roll(*arg): | |
| if gUI.data().interpolation["rot_y"] == None: | |
| ctt.set_roll(0) | |
| else: | |
| gUI.data().interpolation["rot_y"] = 0 | |
| def transform__rot_strength(*arg): | |
| gUI.set_data("transform_rot_strength", "camera") | |
| def transform__rot_strength_p(*arg): | |
| gUI.set_data("transform_rot_strength_p") | |
| def transform__rot_strength_m(*arg): | |
| gUI.set_data("transform_rot_strength_m") | |
| def transform__loc_strength(*arg): | |
| gUI.set_data("transform_loc_strength", "camera") | |
| def transform__loc_strength_p(*arg): | |
| gUI.set_data("transform_loc_strength_p") | |
| def transform__loc_strength_m(*arg): | |
| gUI.set_data("transform_loc_strength_m") | |
| def tracking__strength_pitch_m(*arg): | |
| gUI.set_data("tracking_strength_pitch_m") | |
| def tracking__strength_pitch(*arg): | |
| gUI.set_data("tracking_strength_pitch", "camera") | |
| def tracking__strength_pitch_p(*arg): | |
| gUI.set_data("tracking_strength_pitch_p") | |
| def tracking__strength_heading_m(*arg): | |
| gUI.set_data("tracking_strength_heading_m") | |
| def tracking__strength_heading(*arg): | |
| gUI.set_data("tracking_strength_heading", "camera") | |
| def tracking__strength_heading_p(*arg): | |
| gUI.set_data("tracking_strength_heading_p") | |
| def tracking__offset_pitch_m(*arg): | |
| gUI.set_data("tracking_offset_pitch_m", math.radians(0.5), False) | |
| def tracking__offset_pitch(*arg): | |
| gUI.set_data("tracking_offset_pitch", "camera") | |
| def tracking__offset_pitch_p(*arg): | |
| gUI.set_data("tracking_offset_pitch_p", math.radians(0.5), False) | |
| def tracking__offset_heading_m(*arg): | |
| gUI.set_data("tracking_offset_heading_m", math.radians(1), False) | |
| def tracking__offset_heading(*arg): | |
| gUI.set_data("tracking_offset_heading", "camera") | |
| def tracking__offset_heading_p(*arg): | |
| gUI.set_data("tracking_offset_heading_p", math.radians(1), False) | |
| def tracking__offset_m(*arg): | |
| gUI.set_data("tracking_offset_m", 0.1, False) | |
| def tracking__offset(*arg): | |
| gUI.set_data("tracking_offset", "camera") | |
| def tracking__offset_p(*arg): | |
| gUI.set_data("tracking_offset_p", 0.1, False) | |
| def tracking__car_1_m(*arg): | |
| gUI.on_click__tracking("car_1_m") | |
| def tracking__car_1(*arg): | |
| gUI.on_click__tracking("car_1") | |
| def tracking__car_1_p(*arg): | |
| gUI.on_click__tracking("car_1_p") | |
| def tracking__mix_m(*arg): | |
| gUI.set_data("tracking_mix_m", 0.25) | |
| def tracking__mix(*arg): | |
| gUI.set_data("tracking_mix", "camera") | |
| def tracking__mix_p(*arg): | |
| gUI.set_data("tracking_mix_p", 0.25) | |
| def tracking__car_2_m(*arg): | |
| gUI.on_click__tracking("car_2_m") | |
| def tracking__car_2(*arg): | |
| gUI.on_click__tracking("car_2") | |
| def tracking__car_2_p(*arg): | |
| gUI.on_click__tracking("car_2_p") | |
| def menu__settings(*arg): | |
| gUI.set_active_menu("settings") | |
| def menu__transform(*arg): | |
| gUI.set_active_menu("transform") | |
| def menu__spline(*arg): | |
| gUI.set_active_menu("spline") | |
| def menu__tracking(*arg): | |
| gUI.set_active_menu("tracking") | |
| def menu__camera(*arg): | |
| gUI.set_active_menu("camera") | |
| def settings__show_form__save(*arg): | |
| gUI.on_click__settings("show_save_form") | |
| def settings__show_form__load(*arg): | |
| gUI.on_click__settings("show_load_form") | |
| def settings_reset(*arg): | |
| data.reset() | |
| gUI.set_active_kf(0) | |
| gUI.set_active_cam(0) | |
| def settings__smart_tracking(*arg): | |
| if data.smart_tracking: | |
| data.smart_tracking = False | |
| else: | |
| data.smart_tracking = True | |
| def settings_track_spline(*arg): | |
| gUI.on_click__settings("record_track_spline") | |
| def settings_pit_spline(*arg): | |
| gUI.on_click__settings("record_pit_spline") | |
| def camera__offset_shake_p(*arg): | |
| gUI.set_data("camera_offset_shake_strength_p", 0.1, False) | |
| def camera__offset_shake_m(*arg): | |
| gUI.set_data("camera_offset_shake_strength_m", 0.1, False) | |
| def camera__shake_p(*arg): | |
| gUI.set_data("camera_shake_strength_p", 0.1, False) | |
| def camera__shake_m(*arg): | |
| gUI.set_data("camera_shake_strength_m", 0.1, False) | |
| def camera__shake(*arg): | |
| gUI.set_data("camera_shake_strength", "camera") | |
| def camera__offset_shake(*arg): | |
| gUI.set_data("camera_offset_shake_strength", "camera") | |
| def camera__camera_in__show_input(*arg): | |
| gUI.on_click__camera("show_input") | |
| def camera__camera_in__hide_input(*arg): | |
| gUI.on_click__camera("hide_input") | |
| def camera__use_tracking_point(*arg): | |
| gUI.on_click__camera("use_tracking_point") | |
| def camera__pit(*arg): | |
| gUI.on_click__camera("camera_pit") | |
| def camera__focus_m(*arg): | |
| gUI.on_click__camera("focus_m") | |
| def camera__focus(*arg): | |
| gUI.on_click__camera("focus") | |
| def camera__focus_p(*arg): | |
| gUI.on_click__camera("focus_p") | |
| def camera__fov_m(*arg): | |
| gUI.on_click__camera("fov_m") | |
| def camera__fov(*arg): | |
| gUI.on_click__camera("fov") | |
| def camera__fov_p(*arg): | |
| gUI.on_click__camera("fov_p") | |
| def side_c__remove_camera(*arg): | |
| gUI.on_click__remove_camera() | |
| def side_c__add_camera(*arg): | |
| gUI.on_click__add_camera() | |
| def side_k__remove_keyframe(*arg): | |
| gUI.on_click__remove_keyframe() | |
| def side_k__add_keyframe(*arg): | |
| gUI.on_click__add_keyframe() | |
| def header__activate(*arg): | |
| gUI.on_click__activate() | |
| def header__free_camera(*arg): | |
| ac.setCameraMode(6) | |
| def header__mode_pos(*arg): | |
| gUI.set_mode("pos") | |
| def header__mode_time(*arg): | |
| gUI.set_mode("time") | |
| def activated(*arg): | |
| gUI.activated() | |
| def dismissed(*arg): | |
| gUI.dismissed() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment