Привет, вот код аддона для Блендер 3.3.0, потом скажу что делать:

import bpy
import os
import shutil
from xml.etree import ElementTree as ET
from bpy_extras.io_utils import ImportHelper, ExportHelper
from mathutils import Vector, Quaternion
from math import atan2, sin, cos, degrees, radians

bl_info = {
    "name": "F1 AI Track Layout Maker",
    "author": "AlonsoBeast",
    "version": (1, 0),
    "blender": (3, 3, 0),
    "description": "Import and export F1 track layout from XML files",
    "category": "3D View",
}

gate_objects = []
splitter_data = []
brake_lines_data = []

def parse_brake_lines(root):
    brake_lines_elem = root.find('.//brake_lines')
    brake_lines = brake_lines_elem.findall('brake_line')

    parsed_brake_lines = []
    for brake_line in brake_lines:
        brake_id = int(brake_line.get('id'))
        gate_id = int(brake_line.get('gate_id'))

        parsed_brake_lines.append({
            'brake_id': brake_id,
            'gate_id': gate_id,
            'brake_data': brake_line.find('brake_data')
        })
    return parsed_brake_lines

def parse_hold_lines(root):
    hold_lines_elem = root.find('.//hold_lines')
    hold_lines = hold_lines_elem.findall('hold_line')

    parsed_hold_lines = []
    for hold_line in hold_lines:
        hold_line_id = int(hold_line.get('id'))
        gate_id = int(hold_line.get('gate_id'))
        brakeline_id = int(hold_line.get('brakeline_id'))

        parsed_hold_lines.append({
            'hold_line_id': hold_line_id,
            'gate_id': gate_id,
            'brakeline_id': brakeline_id
        })
    return parsed_hold_lines

def parse_min_speed_lines(root):
    min_speed_lines_elem = root.find('.//min_speed_lines')
    min_speed_lines = min_speed_lines_elem.findall('min_speed_line')

    parsed_min_speed_lines = []
    for min_speed_line in min_speed_lines:
        min_speed_line_id = int(min_speed_line.get('id'))
        gate_id = int(min_speed_line.get('gate_id'))
        min_speed = float(min_speed_line.get('min_speed'))

        parsed_min_speed_lines.append({
            'min_speed_line_id': min_speed_line_id,
            'gate_id': gate_id,
            'min_speed': min_speed
        })
    return parsed_min_speed_lines

def associate_data(brake_lines, hold_lines, min_speed_lines):
    associated_lines = []

    for brake_line in brake_lines:
        matching_hold_line = next((hold_line for hold_line in hold_lines if hold_line['brakeline_id'] == brake_line['brake_id']), None)

        if matching_hold_line:
            matched_min_speed_lines = [
                min_speed_line for min_speed_line in min_speed_lines
                if brake_line['gate_id'] < min_speed_line['gate_id'] < matching_hold_line['gate_id']
            ]

            associated_lines.append({
                'brake_line': brake_line,
                'hold_line': matching_hold_line,
                'min_speed_lines': matched_min_speed_lines
            })

    return associated_lines

def init_properties():
    # Оригинальные свойства Сохраненеи Поколения 
    bpy.types.Scene.show_brake_lines = bpy.props.BoolProperty(
        name="Show Brake Lines",
        description="Expand to show brake lines details",
        default=False
    )

    # Новые свойства для выбора целевых кривых
    bpy.types.Scene.Track_Line_target = bpy.props.StringProperty(
        name="Track Line Target",
        default="Track_TARGET"
    )
    bpy.types.Scene.Start_Line_target = bpy.props.StringProperty(
        name="Start Line Target",
        default="Start_TARGET"
    )
    bpy.types.Scene.Trial_Line_target = bpy.props.StringProperty(
        name="Trial Line Target",
        default="Trial_TARGET"
    )
    bpy.types.Scene.Pit_Line_target = bpy.props.StringProperty(
        name="Pit Cone Target",
        default="Pit_TARGET"
    )
    
    bpy.types.Scene.left_track_limit = bpy.props.FloatProperty(name="Left Track Limit", default=0.0)
    bpy.types.Scene.left_racing_limit = bpy.props.FloatProperty(name="Left Racing Limit", default=0.0)
    bpy.types.Scene.right_track_limit = bpy.props.FloatProperty(name="Right Track Limit", default=0.0)
    bpy.types.Scene.right_racing_limit = bpy.props.FloatProperty(name="Right Racing Limit", default=0.0)
    
    

def extract_normal_and_set_orientation(gate_empty, normal):
    forward_axis = Vector((0, 0, 1))
    target_vector = Vector((normal[2], normal[1], normal[0]))
    rotation = forward_axis.rotation_difference(target_vector)

    # Инвертируем компонент W, чтобы повернуть на 180 градусов
    reordered_rotation = Quaternion((-rotation.w, rotation.x, rotation.z, rotation.y))
    
    gate_empty.rotation_mode = 'QUATERNION'
    gate_empty.rotation_quaternion = reordered_rotation

    gate_empty['imported_normal'] = normal  # Сохраняем оригинал нормали

def create_gate_object(i, x, y, z, gate, is_splitter, context):
    y_mirrored = -y
    gate_name = f"gate_{i:02}"
    
    gate_empty = bpy.data.objects.new(gate_name, None)
    gate_empty.empty_display_type = 'CONE'  # Убедитесь, что форма - это конус

    if is_splitter:
        # Найдем все To_Gate связанные со сплиттерами
        for link in splitter_data:
            from_gate, to_gate, _ = link
            # Если текущий gate_name соответствует to_gate
            if gate_name == to_gate:
                gate_empty.empty_display_size = 3.25 * 2.0  # Увеличиваем размер в 2.5 раза
                gate_empty.scale[1] = 1.0 / 1.5  # Уменьшаем длину (высоту) в 1.5 раза
                break
        else:
            gate_empty.empty_display_size = 3.25  # Обычный размер для других сплиттеров
    else:
        gate_empty.empty_display_size = 1.0  # Для обычных gate

    gate_empty.location = (x, y_mirrored, z)
    gate_empty["gate_number"] = i

    normal_elem = gate.find('normal')
    if normal_elem is not None:
        normal = list(map(float, normal_elem.text.split()))
        extract_normal_and_set_orientation(gate_empty, normal)
        gate_empty['imported_normal'] = normal
        
    # Передаём позицию gate и список waypoints для обработки
    waypoints_elem = gate.find('waypoints')
    if waypoints_elem is not None:
        waypoints = waypoints_elem.findall('waypoint')
        create_gate_waypoints(gate_empty, (x, y, z), normal, waypoints, context)

    gate_empty.rotation_euler.rotate_axis("Z", 3.14159)
    context.collection.objects.link(gate_empty)
    gate_objects.append(gate_empty)

def create_gate_waypoints(gate_empty, position, normal, waypoints, context):
    """
    Создаёт EMPTY объекты для каждого waypoint, устанавливая локальные координаты относительно gate.
    """
    global gate_objects

    # Получаем номер текущего gate
    gate_number = gate_empty['gate_number']

    for wp in waypoints:  # Без использования enumerate
        length = float(wp.get('length', '0.0'))  # Берём значение length
        wp_type = wp.get('type')
        wp_id = int(wp.get('id'))

        # Координаты waypoint в ЛОКАЛЬНОЙ системе координат.
        wp_x = length        # X = length (локальная координата)
        wp_y = 0.0           # Y = 0 (фиксируется)
        wp_z = 0.0           # Z = 0 (фиксируется)

        # Создаём имя waypoint на основе значения wp_type и номера gate
        waypoint_name = f"{wp_type}_{gate_number:02}"

        # Создаем объект EMPTY для waypoint
        waypoint_empty = bpy.data.objects.new(waypoint_name, None)

        # Определяем тип и размер в зависимости от имени
        if "left_racing_limit" in waypoint_name or "right_racing_limit" in waypoint_name:
            waypoint_empty.empty_display_type = 'CUBE'
            waypoint_empty.scale = (0.3, 0.5, 0.3)  # Сжатый куб
        elif "left_track_limit" in waypoint_name or "right_track_limit" in waypoint_name:
            waypoint_empty.empty_display_type = 'CUBE'
            waypoint_empty.scale = (0.5, 0.8, 0.5)  # Сжатый куб, такой же как для racing_limit
        elif "racing_line" in waypoint_name:
            waypoint_empty.empty_display_type = 'SPHERE'
            waypoint_empty.scale = (0.15, 0.15, 0.15)  # Маленькая сфера
        else:
            waypoint_empty.empty_display_type = 'SPHERE'  # Значение по умолчанию
            waypoint_empty.scale = (0.5, 0.5, 0.5)  # Размер по умолчанию, если не указано

        # Устанавливаем локальные координаты waypoint
        waypoint_empty.location = (wp_x, wp_y, wp_z)

        # Свяжем waypoint с родительским gate через parent
        waypoint_empty.parent = gate_empty
        
        # Блокируем трансформацию по Y и Z
        waypoint_empty.lock_location[1] = True  # Запрет на перемещение по Y
        waypoint_empty.lock_location[2] = True  # Запрет на перемещение по Z

        # Добавляем свойства waypoint
        waypoint_empty['wp_id'] = wp_id
        waypoint_empty['wp_type'] = wp_type
        waypoint_empty['length'] = length

        # Добавляем объект в сцену
        context.collection.objects.link(waypoint_empty)


class F1AITrackLayoutMakerPanel(bpy.types.Panel):
    bl_label = "F1 Track AI Layout Tool"
    bl_idname = "VIEW3D_PT_f1_track_builder_toolkit"
    bl_space_type = 'VIEW_3D'
    bl_region_type = 'UI'
    bl_category = 'F1 Track AI Layout'

    def draw(self, context):
        layout = self.layout
        

        # Оригинальные операторы вашего аддона
        layout.operator(ImportF1TrackLayout.bl_idname, text="Import F1 Track Layout", icon='IMPORT')
        layout.operator(ExportF1TrackLayout.bl_idname, text="Export F1 Track Layout", icon='EXPORT')
        layout.operator(UpdateGatePositions.bl_idname, text="Update Gates", icon='UV_SYNC_SELECT')

        
        # Добавляем кнопку для скрытия/показа Track Limits
        layout.operator(ToggleWaypointVisibility.bl_idname, text="Hide / Unhide Track Limits", icon='HIDE_OFF' )

        if splitter_data:
            layout.label(text="Splitters in file:", icon='PLUGIN')
            for from_gate, to_gate, link_info in splitter_data:
                box = layout.box()
                row = box.row(align=True)
                row.label(text=f"Link ID: {link_info.get('id')}", icon='DOT')

                from_btn = row.operator("f1.select_splitter_gate", text=f"From_Gate: {from_gate}")
                from_btn.gate_name = from_gate

                to_btn = row.operator("f1.select_splitter_gate", text=f"To_Gate: {to_gate}")
                to_btn.gate_name = to_gate

                box.scale_y = 0.75

        # Создаем контейнер (box)
        box = layout.box()
        # Добавляем свойство в контейнер
        box.prop(context.scene, "show_brake_lines", icon="TRIA_DOWN" if context.scene.show_brake_lines else "TRIA_RIGHT", emboss=False)

        if context.scene.show_brake_lines:
            if brake_lines_data:
                layout.label(text=f"Brake Lines Num: {len(brake_lines_data)}", icon='CON_ROTLIMIT')
                for line_data in brake_lines_data:
                    box = layout.box()
                    brake_row = box.row(align=True)
                    brake_row.label(text=f"Brake ID: {line_data['brake_line']['brake_id']} / Gate {line_data['brake_line']['gate_id']}")

                    # Формируем имя gate для проверки выделенности
                    gate_name = f"gate_{line_data['brake_line']['gate_id']:02}"
                    gate_object = bpy.data.objects.get(gate_name)

                    # Проверяем, выделен ли объект
                    is_selected = gate_object and gate_object in context.selected_objects

                    # Меняем текст и иконку кнопки в зависимости от выделения объекта
                    select_text = "SELECTED" if is_selected else "Select Gate"
                    select_icon = 'CHECKBOX_HLT' if is_selected else 'RESTRICT_SELECT_OFF'
                    select_op = brake_row.operator("f1.select_gate_by_name", text=select_text, icon=select_icon)
                    select_op.gate_name = gate_name

                    new_gate_op = brake_row.operator("f1.new_gate_id", text="New Gate", icon='FILE_REFRESH')
                    new_gate_op.brake_line_id = line_data['brake_line']['brake_id']

                    for min_speed_line in line_data['min_speed_lines']:
                        ms_row = box.row(align=True)
                        ms_row.label(text=f"Min Speed ID: {min_speed_line['min_speed_line_id']} / Gate: {min_speed_line['gate_id']}")

                        # Проверяем выделение для Min Speed Gate
                        min_speed_gate_name = f"gate_{min_speed_line['gate_id']:02}"
                        min_speed_gate_object = bpy.data.objects.get(min_speed_gate_name)
                        min_speed_is_selected = min_speed_gate_object and min_speed_gate_object in context.selected_objects

                        # Меняем текст и иконку для Min Speed Gate
                        ms_select_text = "SELECTED" if min_speed_is_selected else "Select Gate"
                        ms_select_icon = 'CHECKBOX_HLT' if min_speed_is_selected else 'RESTRICT_SELECT_OFF'
                        ms_op = ms_row.operator("f1.select_gate_by_name", text=ms_select_text, icon=ms_select_icon)
                        ms_op.gate_name = min_speed_gate_name
                        new_ms_gate_op = ms_row.operator("f1.new_min_speed_gate_id", text="New Gate", icon='FILE_REFRESH')
                        new_ms_gate_op.min_speed_line_id = min_speed_line['min_speed_line_id']

                    hl_row = box.row(align=True)
                    hl_gate_id = line_data['hold_line']['gate_id']
                    hl_row.label(text=f"Hold Line ID: {line_data['hold_line']['hold_line_id']} / Gate {hl_gate_id}")

                    # Проверяем выделение для Hold Line Gate
                    hl_gate_name = f"gate_{hl_gate_id:02}"
                    hl_gate_object = bpy.data.objects.get(hl_gate_name)
                    hl_is_selected = hl_gate_object and hl_gate_object in context.selected_objects

                    # Меняем текст и иконку для Hold Line Gate
                    hl_select_text = "SELECTED" if hl_is_selected else "Select Gate"
                    hl_select_icon = 'CHECKBOX_HLT' if hl_is_selected else 'RESTRICT_SELECT_OFF'
                    hl_select_op = hl_row.operator("f1.select_gate_by_name", text=hl_select_text, icon=hl_select_icon)
                    hl_select_op.gate_name = hl_gate_name
                    new_hl_gate_op = hl_row.operator("f1.new_hold_line_gate_id", text="New Gate", icon='FILE_REFRESH')
                    new_hl_gate_op.hold_line_id = line_data['hold_line']['hold_line_id']

        # Новые элементы интерфейса для работы с безье-кривыми
        layout.operator("f1.create_target_curves", text="Create Target Curves")

        layout.label(text="Transfer Shape Spline Layout:")
        layout.operator("f1.create_target_surface", text="Create NEW Target Splines", icon='CON_LOCLIKE')

        # Заранее заданные исходные и целевые кривые
        transfer_pairs = [
            ("Track_Line", "Track_TARGET"),
            ("Start_Line", "Start_TARGET"),
            ("Pit_Line", "Pit_TARGET"),
        ]

        for source_name, target_default in transfer_pairs:
            # Создаем строку для названия и целевой кривой
            row = layout.row(align=True)
            
            # Добавляем текст с названием кривой
            row.label(text=f"[ {source_name} ]")

            # Поле для выбора целевой кривой, чтобы оно было максимально широким
            target_row = row.row(align=True)
            target_row.prop_search(context.scene, f"{source_name}_target", bpy.data, "objects", text="", icon='OUTLINER_OB_EMPTY')

            # Кнопка выбора сплайна
            select_btn = target_row.operator(SelectCurveOperator.bl_idname, text="Select Spline", icon='RESTRICT_SELECT_OFF')
            select_btn.curve_name = source_name  # Устанавливаем имя сплайна для оператора

            # Создаем новую строку для кнопок
            button_row = layout.row(align=True)

            # Получаем объект сплайна для определения состояния видимости
            spline_object = bpy.data.objects.get(source_name)

            # Проверяем состояние видимости и определяем текст кнопки
            if spline_object and not spline_object.hide_viewport:
                button_text = "Hide"
                icon = 'HIDE_OFF'
            else:
                button_text = "Unhide"
                icon = 'HIDE_ON'

            hide_button = button_row.operator(HideSplineGatesOperator.bl_idname, text=button_text, icon=icon)
            hide_button.target_spline_name = source_name  # Устанавливаем имя сплайна для оператора

            # Кнопка Transfer
            transfer_op = button_row.operator("f1.transfer_shape", text="Transfer")
            transfer_op.source_curve_name = source_name
            transfer_op.target_curve_name = context.scene.get(f"{source_name}_target", target_default)

            # Кнопка Correct Way
            correct_op = button_row.operator("f1.correct_way", text="Correct Way")
            correct_op.source_curve_name = source_name

        # Новый заголовок для лимитов
        layout.label(text="Set limit track for selected gates", icon='ARROW_LEFTRIGHT')

        # Ввод для лимитов
        col = layout.column(align=True)

        # Получаем значения
        left_racing_limit = context.scene.left_racing_limit
        left_track_limit = context.scene.left_track_limit
        right_racing_limit = context.scene.right_racing_limit
        right_track_limit = context.scene.right_track_limit

        # Проверки на ошибки
        left_error_positive = left_racing_limit > 0 or left_track_limit > 0  # Положительные значения для левых лимитов
        left_error_racing_greater = left_racing_limit < left_track_limit  # Racing не может быть больше Track
        right_error_negative = right_racing_limit < 0 or right_track_limit < 0  # Отрицательные значения для правых лимитов
        right_error_racing_greater = right_racing_limit > right_track_limit  # Racing не может быть больше Track


        # Левые лимиты
        row = layout.row(align=True)
        row.prop(context.scene, "left_track_limit", text="Left Track Limit")
        
        row = layout.row(align=True)
        row.prop(context.scene, "left_racing_limit", text="Left Racing Limit")

        # Правые лимиты
        row = layout.row(align=True)
        row.prop(context.scene, "right_racing_limit", text="Right Racing Limit")
        
        row = layout.row(align=True)
        row.prop(context.scene, "right_track_limit", text="Right Track Limit")
        

        # Проверка ошибок для левых лимитов
        if left_error_positive:
            layout.label(text="Error: Left limits cannot be positive numbers.", icon='ERROR')
        if left_error_racing_greater:
            layout.label(text="Error: Left Racing Limit cannot be greater than Left Track Limit.", icon='ERROR')
        
        # Проверка ошибок для правых лимитов
        if right_error_negative:
            layout.label(text="Error: Right limits cannot be negative numbers.", icon='ERROR')
        if right_error_racing_greater:
            layout.label(text="Error: Right Racing Limit cannot be greater than Right Track Limit.", icon='ERROR')

        # Кнопка для установки лимитов
        layout.operator(SetTrackLimitsOperator.bl_idname, text="Set Track Limits", icon='CENTER_ONLY')

class NewGateIDOperator(bpy.types.Operator):
    """Select single gate object to set as new"""
    bl_idname = "f1.new_gate_id"
    bl_label = "New Gate ID"

    brake_line_id: bpy.props.IntProperty()

    def execute(self, context):
        selected_objects = context.selected_objects

        if len(selected_objects) != 1 or not selected_objects[0].name.startswith("gate_"):
            self.report({'WARNING'}, "Please select a single gate object")
            return {'CANCELLED'}

        new_gate_id = int(selected_objects[0].name.split("_")[1])

        for line_data in brake_lines_data:
            if line_data['brake_line']['brake_id'] == self.brake_line_id:
                line_data['brake_line']['gate_id'] = new_gate_id
                break

        self.report({'INFO'}, f"Gate ID updated to: {new_gate_id}")
        return {'FINISHED'}

class NewMinSpeedGateIDOperator(bpy.types.Operator):
    """Select single gate object to set as new for Min Speed"""
    bl_idname = "f1.new_min_speed_gate_id"
    bl_label = "New Min Speed Gate ID"

    min_speed_line_id: bpy.props.IntProperty()

    def execute(self, context):
        selected_objects = context.selected_objects

        if len(selected_objects) != 1 or not selected_objects[0].name.startswith("gate_"):
            self.report({'WARNING'}, "Please select a single gate object")
            return {'CANCELLED'}

        new_gate_id = int(selected_objects[0].name.split("_")[1])

        for line_data in brake_lines_data:
            for min_speed_line in line_data['min_speed_lines']:
                if min_speed_line['min_speed_line_id'] == self.min_speed_line_id:
                    min_speed_line['gate_id'] = new_gate_id
                    break

        self.report({'INFO'}, f"Min Speed Gate ID updated to: {new_gate_id}")
        return {'FINISHED'}

class NewHoldLineGateIDOperator(bpy.types.Operator):
    """Select single gate object to set as new for Hold Line"""
    bl_idname = "f1.new_hold_line_gate_id"
    bl_label = "New Hold Line Gate ID"

    hold_line_id: bpy.props.IntProperty()

    def execute(self, context):
        selected_objects = context.selected_objects

        if len(selected_objects) != 1 or not selected_objects[0].name.startswith("gate_"):
            self.report({'WARNING'}, "Please select a single gate object")
            return {'CANCELLED'}

        new_gate_id = int(selected_objects[0].name.split("_")[1])

        for line_data in brake_lines_data:
            if line_data['hold_line']['hold_line_id'] == self.hold_line_id:
                line_data['hold_line']['gate_id'] = new_gate_id
                break

        self.report({'INFO'}, f"Hold Line Gate ID updated to: {new_gate_id}")
        return {'FINISHED'}

class SelectCurveOperator(bpy.types.Operator):
    """Select the specified curve"""
    bl_idname = "f1.select_curve"
    bl_label = "Select Curve"

    curve_name: bpy.props.StringProperty()

    def execute(self, context):
        curve_object = bpy.data.objects.get(self.curve_name)
        if curve_object is None:
            self.report({'WARNING'}, f"Curve '{self.curve_name}' not found")
            return {'CANCELLED'}

        # Снять выделение со всех объектов и выделить нужный
        for obj in context.scene.objects:
            obj.select_set(False)

        curve_object.select_set(True)
        context.view_layer.objects.active = curve_object  # Установить как активный объект.. ... .......
        return {'FINISHED'}

class SelectSplitterGate(bpy.types.Operator):
    """Splitters determine the transition from one line to another, they tend to be close to each other, imagine that this is a plug and socket. See the 'from gate to gate' example"""
    bl_idname = "f1.select_splitter_gate"
    bl_label = "Select Splitter Gate"

    gate_name: bpy.props.StringProperty()

    def execute(self, context):
        gate_object = bpy.data.objects.get(self.gate_name)
        if gate_object is None:
            self.report({'WARNING'}, "Object not found")
            return {'CANCELLED'}

        if gate_object not in bpy.context.selected_objects:
            gate_object.select_set(True)

        context.view_layer.objects.active = gate_object
        return {'FINISHED'}

class SelectGateByName(bpy.types.Operator):
    """Select gate object by name in the scene"""
    bl_idname = "f1.select_gate_by_name"
    bl_label = "Select Gate by Name"

    gate_name: bpy.props.StringProperty()

    def execute(self, context):
        gate_object = bpy.data.objects.get(self.gate_name)
        if gate_object is None:
            self.report({'WARNING'}, f"Gate object {self.gate_name} not found")
            return {'CANCELLED'}

        if gate_object not in bpy.context.selected_objects:
            gate_object.select_set(True)
            context.view_layer.objects.active = gate_object
        else:
            gate_object.select_set(False)

        return {'FINISHED'}

class CreateTargetSurface(bpy.types.Operator):
    """Create New Target Bezier Curves with Vector Handles"""
    bl_idname = "f1.create_target_surface"
    bl_label = "Create Target Surface"
    
    def execute(self, context):
        # Проверяем и создаем коллекцию для целевых сплайнов
        target_collection = bpy.data.collections.get("A TARGET SPLINES")
        if target_collection is None:
            target_collection = bpy.data.collections.new("A TARGET SPLINES")
            bpy.context.scene.collection.children.link(target_collection)

        curve_names = ["Track_TARGET", "Start_TARGET", "Trial_TARGET", "Pit_TARGET"]
        
        for name in curve_names:
            if name not in bpy.data.objects:
                # Создание новой кривой типа CURVE
                curve_data = bpy.data.curves.new(name=name, type='CURVE')
                curve_data.dimensions = '3D'
                spline = curve_data.splines.new('BEZIER')
                spline.bezier_points.add(1)  # Всего две точки (1 добавляется к уже существующей)

                # Устанавливаем позиции и типы хэндлов для контрольных точек
                start_point = spline.bezier_points[0]
                start_point.co = Vector((0, 0, 0))
                start_point.handle_left_type = 'VECTOR'
                start_point.handle_right_type = 'VECTOR'
                
                end_point = spline.bezier_points[1]
                end_point.co = Vector((0, 20, 0))  # На 20 метров вперед по оси Y
                end_point.handle_left_type = 'VECTOR'
                end_point.handle_right_type = 'VECTOR'
                
                # Создаем объект и добавляем его в коллекцию A TARGET SPLINES
                curve_object = bpy.data.objects.new(name, curve_data)
                target_collection.objects.link(curve_object)
        
        self.report({'INFO'}, "4 Target Curves Created with Straight Lines (Vector Handles)")
        return {'FINISHED'}
 
from mathutils import Vector, Quaternion

from mathutils import Vector, Quaternion
from math import atan2, sin, cos, degrees

from mathutils import Vector, Quaternion

class CorrectGateOrientationOperator(bpy.types.Operator):
    """Corrects the orientation of gate objects to align with the curve"""
    bl_idname = "f1.correct_way"
    bl_label = "Correct Way"

    source_curve_name: bpy.props.StringProperty()

    def execute(self, context):
        source_obj = bpy.data.objects.get(self.source_curve_name)

        if not source_obj:
            self.report({'ERROR'}, "Source curve not found")
            return {'CANCELLED'}

        source_spline = source_obj.data.splines[0]

        # Получаем выделенные gate объекты
        selected_gates = [obj for obj in context.selected_objects if obj.name.startswith("gate_")]

        if not selected_gates:
            # Если выделенных объектов нет, используем ассоциацию gate объектов
            empty_gates_info = context.scene.get('empty_gates_info', {})
            gates_to_adjust = []

            # Получаем ассоциацию gate объектов для текущего сплайна
            spline_name = self.source_curve_name
            if spline_name in empty_gates_info:
                gates_to_adjust = empty_gates_info[spline_name]

            # Преобразуем имена в объекты
            selected_gates = [bpy.data.objects.get(gate_name) for gate_name in gates_to_adjust]

        # Теперь мы имеем список gate объектов (выделенных или ассоциированных)
        for i, gate_object in enumerate(selected_gates):
            if gate_object is None:
                continue  # Пропускаем, если объект не найден

            # Найти ближайшую точку для каждого gate_object
            min_distance = float('inf')
            closest_point_index = 0
            
            for j, point in enumerate(source_spline.bezier_points):
                distance = (gate_object.location - point.co).length
                if distance < min_distance:
                    min_distance = distance
                    closest_point_index = j
            
            # Определяем направление между текущей и следующей точкой
            current_point = source_spline.bezier_points[closest_point_index]
            next_index = (closest_point_index + 1) % len(source_spline.bezier_points)

            if i < len(selected_gates) - 1:
                # Если это не последний gate, берём следующую точку
                next_point = source_spline.bezier_points[next_index]
            else:
                # Если это последний gate, используем предыдущую точку (current_point)
                if closest_point_index > 0:
                    previous_point = source_spline.bezier_points[closest_point_index - 1]
                    direction_vector = (current_point.co - previous_point.co).normalized()
                    # Создаем кватернион из 'up' ориентации и направления
                    rotation_quaternion = direction_vector.to_track_quat('Z', 'Y')
                else:
                    # Если это первый gate на сплайне (что вряд ли, но все же)
                    direction_vector = (next_point.co - current_point.co).normalized()
                    rotation_quaternion = direction_vector.to_track_quat('Z', 'Y')

            if i < len(selected_gates) - 1:
                direction_vector = (next_point.co - current_point.co).normalized()
                if direction_vector.length == 0:
                    continue
                rotation_quaternion = direction_vector.to_track_quat('Z', 'Y')

            # Разворачиваем объект на 180 градусов вокруг оси Z
            flip_quaternion = Quaternion((0.0, 0.0, 1.0), radians(180))
            rotation_quaternion = flip_quaternion @ rotation_quaternion

            # Устанавливаем ненужные компоненты к нулю
            rotation_quaternion.x = 0.0
            rotation_quaternion.y = 0.0

            # Применяем кватернион вращения к объекту
            gate_object.rotation_mode = 'QUATERNION'
            gate_object.rotation_quaternion = rotation_quaternion

            # Отладочный вывод
            print(f"Gate {gate_object.name}: Quaternion={rotation_quaternion}")

        self.report({'INFO'}, "Corrected orientation for selected gate_* objects")
        return {'FINISHED'}
        
class TransferShapeOperator(bpy.types.Operator):
    """Transfer Shape from Source to Target Curve"""
    bl_idname = "f1.transfer_shape"
    bl_label = "Transfer Shape"
    
    source_curve_name: bpy.props.StringProperty()
    target_curve_name: bpy.props.StringProperty()
    
    def execute(self, context):
        source_obj = bpy.data.objects.get(self.source_curve_name)
        target_obj = bpy.data.objects.get(self.target_curve_name)
        
        if not source_obj or not target_obj:
            self.report({'ERROR'}, "Source or Target curve not found")
            return {'CANCELLED'}
        
        source_spline = source_obj.data.splines[0]
        target_spline = target_obj.data.splines[0]
        
        # Interpolate target bezier points to match source spline's points
        total_source_points = len(source_spline.bezier_points)
        total_target_points = len(target_spline.bezier_points) - 1
        
        if total_target_points < 1:
            self.report({'ERROR'}, "Target curve must have at least 2 control points")
            return {'CANCELLED'}
        
        # Use linear interpolation to calculate new positions along the target curve
        for i, point in enumerate(source_spline.bezier_points):
            t = i / (total_source_points - 1)
            interpolated_index = int(t * total_target_points)
            next_interpolated_index = min(interpolated_index + 1, total_target_points)
                
            low_point = target_spline.bezier_points[interpolated_index].co
            high_point = target_spline.bezier_points[next_interpolated_index].co
            
            new_position = low_point.lerp(high_point, t * total_target_points - interpolated_index)
            point.co = new_position

        # Обновляем позиции gate
        bpy.ops.object.update_gate_positions()  # Вызываем оператор обновления
        
        # Вместо создания экземпляра, вызовем директ команду
        bpy.ops.f1.correct_way(source_curve_name=self.source_curve_name)

        self.report({'INFO'}, f"Transferred shape to {self.source_curve_name} and corrected gate orientations")
        return {'FINISHED'}
        
        
 
class ImportF1TrackLayout(bpy.types.Operator, ImportHelper):
    bl_idname = "import.f1_track_layout"
    bl_label = "Import F1 Track Layout"
    filename_ext = ".xml"

    def execute(self, context):
        global gate_objects, splitter_data, brake_lines_data

        blend_dir = os.path.dirname(bpy.data.filepath)
        
        temp_dir = os.path.join(blend_dir, "temp")
        if not os.path.exists(temp_dir):
            os.makedirs(temp_dir)

        temp_file = os.path.join(temp_dir, f"{os.path.basename(self.filepath)}_temp.xml")

        shutil.copy2(self.filepath, temp_file)
        context.scene['temp_import_filepath'] = temp_file

        success = self.import_from_temp_file(context, temp_file)

        if success == {'FINISHED'}:
            bpy.ops.object.update_gate_positions()

        return success

    def import_from_temp_file(self, context, temp_file):
        try:
            tree = ET.parse(temp_file)
            root = tree.getroot()

            gates = root.find('.//gates').findall('gate')

            if not gates:
                self.report({'ERROR'}, "No gates found in the XML file.")
                return {'CANCELLED'}

            splitter_data.clear()
            gate_objects.clear()
            brake_lines_data.clear()

            links = root.find('.//links').findall('link')
            splitter_ids = set()

            for link in links:
                from_gate = int(link.get('from_gate'))
                to_gate = int(link.get('to_gate'))
                if abs(from_gate - to_gate) > 1:
                    splitter_ids.update([from_gate, to_gate])
                    gate_name_from = f"gate_{from_gate:02}"
                    gate_name_to = f"gate_{to_gate:02}"
                    splitter_data.append((gate_name_from, gate_name_to, link))

            fork_set = root.find('.//fork_sets/fork_set')
            if not fork_set:
                self.report({'ERROR'}, "No fork_set found in the XML file.")
                return {'CANCELLED'}

            split_gate_id = int(fork_set.get('gate_id'))
            Trial_Line_id = int(fork_set.find('.//fork[@fork_position="1"]').get('link_id'))

            split_link_elem = root.find('.//links/link[@id="0"]')
            if split_link_elem is None:
                self.report({'ERROR'}, "Link with ID 0 not found in the XML file.")
                return {'CANCELLED'}

            trial_split_gate_id = int(split_link_elem.get('from_gate'))

            track_curve_data = bpy.data.curves.new(name="Track_Line_Curve", type='CURVE')
            track_curve_data.dimensions = '3D'
            track_spline = track_curve_data.splines.new('BEZIER')

            pit_curve_data = bpy.data.curves.new(name="Pit_Line_Curve", type='CURVE')
            pit_curve_data.dimensions = '3D'
            pit_spline = pit_curve_data.splines.new('BEZIER')

            start_line_curve_data = bpy.data.curves.new(name="Start_Line_Curve", type='CURVE')
            start_line_curve_data.dimensions = '3D'
            start_line_spline = start_line_curve_data.splines.new('BEZIER')

            track_points = [gate for gate in gates if int(gate.get('id')) <= split_gate_id]
            trial_points = [gate for gate in gates if split_gate_id < int(gate.get('id')) <= Trial_Line_id]
            pit_points = [gate for gate in gates if int(gate.get('id')) > Trial_Line_id]

            trial_line_points = [gate for gate in trial_points if int(gate.get('id')) <= trial_split_gate_id]
            start_line_points = [gate for gate in trial_points if int(gate.get('id')) > trial_split_gate_id]

            # Добавляем точки для Track_Line (включая Trial_Line)
            track_spline.bezier_points.add(len(track_points) + len(trial_line_points) - 1)

            # Временный словарь для связи empty_gate объектов со сплайнами
            empty_gates_info = {
                "Track_Line": [],
                "Start_Line": [],
                "Pit_Line": [],
            }

            # Добавление точек для основной трековой линии
            for i, gate in enumerate(track_points):
                position = gate.find('position')
                if position is not None:
                    x, z, y = map(float, position.text.split())
                    y_mirrored = -y

                    control_point = track_spline.bezier_points[i]
                    control_point.co = (x, y_mirrored, z)
                    control_point.handle_left_type = 'VECTOR'
                    control_point.handle_right_type = 'VECTOR'

                    is_splitter = i in splitter_ids
                    create_gate_object(i, x, y_mirrored, z, gate, is_splitter, context)

                    empty_gates_info["Track_Line"].append(f"gate_{i:02}")

            # Добавление точек для Trial_Line как продолжение Track_Line
            offset = len(track_points)
            for j, gate in enumerate(trial_line_points):
                position = gate.find('position')
                if position is not None:
                    x, z, y = map(float, position.text.split())
                    y_mirrored = -y

                    control_point = track_spline.bezier_points[offset + j]
                    control_point.co = (x, y_mirrored, z)
                    control_point.handle_left_type = 'VECTOR'
                    control_point.handle_right_type = 'VECTOR'

                    is_splitter = offset + j in splitter_ids
                    create_gate_object(offset + j, x, y_mirrored, z, gate, is_splitter, context)

                    empty_gates_info["Track_Line"].append(f"gate_{offset + j:02}")

            # Теперь добавляем точки для Start_Line
            offset += len(trial_line_points)
            start_line_spline.bezier_points.add(len(start_line_points) - 1)

            for k, gate in enumerate(start_line_points):
                position = gate.find('position')
                if position is not None:
                    x, z, y = map(float, position.text.split())
                    y_mirrored = -y

                    control_point = start_line_spline.bezier_points[k]
                    control_point.co = (x, y_mirrored, z)
                    control_point.handle_left_type = 'VECTOR'
                    control_point.handle_right_type = 'VECTOR'

                    is_splitter = offset + k in splitter_ids
                    create_gate_object(offset + k, x, y_mirrored, z, gate, is_splitter, context)

                    empty_gates_info["Start_Line"].append(f"gate_{offset + k:02}")

            # Добавление точек для Pit_Line
            offset += len(start_line_points)
            pit_spline.bezier_points.add(len(pit_points) - 1)
            for l, gate in enumerate(pit_points):
                position = gate.find('position')
                if position is not None:
                    x, z, y = map(float, position.text.split())
                    y_mirrored = -y

                    control_point = pit_spline.bezier_points[l]
                    control_point.co = (x, y_mirrored, z)
                    control_point.handle_left_type = 'VECTOR'
                    control_point.handle_right_type = 'VECTOR'

                    is_splitter = offset + l in splitter_ids
                    create_gate_object(offset + l, x, y_mirrored, z, gate, is_splitter, context)

                    empty_gates_info["Pit_Line"].append(f"gate_{offset + l:02}")

            # Сохраним временный словарь в свойство сцены
            context.scene['empty_gates_info'] = empty_gates_info
            
            # Вставляем объекты в коллекцию после завершения импорта
            track_object = bpy.data.objects.new("Track_Line", track_curve_data)
            start_line_object = bpy.data.objects.new("Start_Line", start_line_curve_data)
            pit_object = bpy.data.objects.new("Pit_Line", pit_curve_data)

            # Помещаем объекты в коллекцию SOURCE SPLINES
            source_collection = bpy.data.collections.get("SOURCE SPLINES")
            if source_collection is None:
                source_collection = bpy.data.collections.new("SOURCE SPLINES")
                bpy.context.scene.collection.children.link(source_collection)

            source_collection.objects.link(track_object)
            source_collection.objects.link(start_line_object)
            source_collection.objects.link(pit_object)

            bpy.context.view_layer.objects.active = track_object
            track_object.select_set(True)

            brake_lines = parse_brake_lines(root)
            hold_lines = parse_hold_lines(root)
            min_speed_lines = parse_min_speed_lines(root)
            brake_lines_data.extend(associate_data(brake_lines, hold_lines, min_speed_lines))

            self.report({'INFO'}, f"Imported track layout from: {temp_file}")
            return {'FINISHED'}

        except ET.ParseError as e:
            self.report({'ERROR'}, f"XML parse error: {e}")
            return {'CANCELLED'}
            
class HideSplineGatesOperator(bpy.types.Operator):
    """Hide/Unhide selected spline and associated empty gates"""
    bl_idname = "f1.hide_unhide_spline_gates"
    bl_label = "Hide/Unhide Spline and Gates"

    target_spline_name: bpy.props.StringProperty()

    def execute(self, context):
        empty_gates_info = context.scene.get('empty_gates_info', {})
        gates_to_hide = empty_gates_info.get(self.target_spline_name, [])

        # Скрытие/показ сплайна
        spline_object = bpy.data.objects.get(self.target_spline_name)

        if spline_object:
            # Переключение состояния видимости сплайна
            spline_object.hide_viewport = not spline_object.hide_viewport

        # Скрытие/показ связанных empty gates
        for gate_name in gates_to_hide:
            gate = bpy.data.objects.get(gate_name)
            if gate:
                # Переключение состояния видимости для empty gate и его дочерних объектов
                gate.hide_viewport = not gate.hide_viewport
                for child in gate.children:
                    child.hide_viewport = gate.hide_viewport  # Дочерние будут иметь то же состояние видимости

        self.report({'INFO'}, f"Toggled {self.target_spline_name} and its associated gates visibility")
        return {'FINISHED'}    


def restore_gate_objects(context):
    temp_file = context.scene.get('temp_import_filepath', "")
    if not temp_file or not os.path.isfile(temp_file):
        return

    try:
        tree = ET.parse(temp_file)
        root = tree.getroot()

        gates = root.find('.//gates').findall('gate')

        global gate_objects
        gate_objects.clear()

        for gate in gates:
            gate_id = int(gate.get('id'))
            gate_name = f"gate_{gate_id:02}"
            gate_object = bpy.data.objects.get(gate_name)
            if gate_object:
                gate_objects.append(gate_object)
    except ET.ParseError:
        return

class ToggleWaypointVisibility(bpy.types.Operator):
    """Hide or Unhide Track Limits"""
    bl_idname = "f1.toggle_waypoint_visibility"
    bl_label = "Hide/Unhide Track Limits"

    def execute(self, context):
        # Проходим по всем объектам и изменяем видимость
        for obj in context.collection.objects:
            if any(limit in obj.name for limit in ["left_racing_limit", "right_racing_limit",
                                                    "left_track_limit", "right_track_limit"]):
                obj.hide_viewport = not obj.hide_viewport  # Меняем состояние видимости
        
        return {'FINISHED'}

class ExportF1TrackLayout(bpy.types.Operator, ExportHelper):
    bl_idname = "export.f1_track_layout"
    bl_label = "Export F1 Track Layout"
    filename_ext = ".xml"

    filter_glob: bpy.props.StringProperty(
        default="*.xml",
        options={'HIDDEN'},
    )

    def export_normal(self, gate_object):
        # Извлекаем кватернион объекта
        rotation_quat = gate_object.rotation_quaternion

        # Предполагаем, что forward-вектор задан как (1, 0, 0)
        example_forward_vector = Vector((1, 0, 0))

        # Получаем нормаль из ориентации
        normal_vector = rotation_quat @ example_forward_vector

        # Инвертируем вектор нормали (разворачиваем его на 180 градусов)
        flipped_normal = -normal_vector

        # Поменять местами Y и Z, а X оставить положительным
        return f"{-round(flipped_normal.x, 6)} {round(abs(flipped_normal.z), 6)} {round(flipped_normal.y, 6)}"

    def export_waypoints(self, gate_object, gate_elem):
        """
        Экспортирует waypoints с учётом их локальных координат (length).
        """
        wp_objects = [obj for obj in gate_object.children if "_" in obj.name and len(obj.name.split("_")) >= 2]
        wp_container = gate_elem.find('waypoints')

        if wp_container is not None:
            for wp_obj in wp_objects:
                # Извлекаем id из имени waypoint
                *wp_type_parts, gate_id_str = wp_obj.name.split("_")
                wp_type = "_".join(wp_type_parts)  # Возвращаем type в виде строки
                wp_id = wp_obj['wp_id']  # Получаем id из свойства

                # Поиск соответствующего элемента
                wp_elem = wp_container.find(f"waypoint[@id='{wp_id}']")
                if wp_elem is not None:
                    # Координаты waypoint в ЛОКАЛЬНОЙ системе координат (только X)
                    length = wp_obj.location.x  # Используем только X-координату в локальной системе

                    # Обновляем XML length
                    wp_elem.set('length', f"{length:.3f}")

                    # Убедимся, что Y и Z всегда равны 0
                    wp_elem.set('y', "0.0")
                    wp_elem.set('z', "0.0")

    def execute(self, context):
        temp_file = context.scene.get('temp_import_filepath', "")

        if not temp_file or not os.path.isfile(temp_file):
            self.report({'ERROR'}, "Temporary file not found. Please import the track layout first.")
            return {'CANCELLED'}

        try:
            tree = ET.parse(temp_file)
            root = tree.getroot()

            gates = root.find('.//gates').findall('gate')
            for gate_object in gate_objects:
                gate_id = gate_object.get("gate_number", None)
                if gate_id is not None and gate_id < len(gates):
                    gate_elem = root.find(f".//gates/gate[@id='{gate_id}']")
                    if gate_elem is not None:
                        position = gate_elem.find('position')
                        if position is not None:
                            x, z, y = gate_object.location.x, gate_object.location.z, -gate_object.location.y
                            position.text = f"{round(x, 3)} {round(z, 3)} {round(y, 3)}"

                        # Используем перенесённый метод для экспорта нормали
                        normal_export = self.export_normal(gate_object)

                        normal_elem = gate_elem.find('normal')
                        if normal_elem is None:
                            normal_elem = ET.SubElement(gate_elem, 'normal')

                        normal_elem.set('format', 'float3')
                        normal_elem.text = normal_export

                        # Экспортируем waypoints для каждого gate
                        self.export_waypoints(gate_object, gate_elem)

            # Экспортируем дополнительные элементы
            brake_lines_elem = root.find('.//brake_lines')
            if brake_lines_elem is not None:
                for line_data in brake_lines_data:
                    brake_line_elem = brake_lines_elem.find(
                        f'brake_line[@id="{line_data["brake_line"]["brake_id"]}"]'
                    )
                    if brake_line_elem is not None:
                        brake_line_elem.set('gate_id', str(line_data["brake_line"]["gate_id"]))

                    min_speed_lines_elem = root.find('.//min_speed_lines')
                    for min_speed_line in line_data['min_speed_lines']:
                        min_speed_elem = min_speed_lines_elem.find(
                            f'min_speed_line[@id="{min_speed_line["min_speed_line_id"]}"]'
                        )
                        if min_speed_elem is not None:
                            min_speed_elem.set('gate_id', str(min_speed_line["gate_id"]))
                            min_speed_elem.set('min_speed', f'{min_speed_line["min_speed"]:.2f}')

            # Сохранение изменений в XML файл........
            tree.write(self.filepath)

            self.report({'INFO'}, f"Successfully exported track layout to: {self.filepath}")
            return {'FINISHED'}

        except ET.ParseError as e:
            self.report({'ERROR'}, f"XML parse error: {e}")
            return {'CANCELLED'}

class UpdateGatePositions(bpy.types.Operator):
    """"Update gate positions based on the Bezier control points"""
    bl_idname = "object.update_gate_positions"
    bl_label = "Update Gate Positions"

    @classmethod
    def poll(cls, context):
        return any(name in bpy.data.objects for name in ["Track_Line", "Trial_Line", "Start_Line", "Pit_Line"])

    def execute(self, context):
        restore_gate_objects(context)

        num_track_points = len(bpy.data.objects["Track_Line"].data.splines[0].bezier_points) if "Track_Line" in bpy.data.objects else 0
        num_trial_line_points = len(bpy.data.objects["Trial_Line"].data.splines[0].bezier_points) if "Trial_Line" in bpy.data.objects else 0
        num_start_line_points = len(bpy.data.objects["Start_Line"].data.splines[0].bezier_points) if "Start_Line" in bpy.data.objects else 0

        for curve_name in ["Track_Line", "Trial_Line", "Start_Line", "Pit_Line"]:
            if curve_name in bpy.data.objects:
                curve_object = bpy.data.objects[curve_name]
                control_points = curve_object.data.splines[0].bezier_points

                for i, point in enumerate(control_points):
                    if curve_name == "Track_Line":
                        gate_index = i
                    elif curve_name == "Trial_Line":
                        gate_index = num_track_points + i
                    elif curve_name == "Start_Line":
                        gate_index = num_track_points + num_trial_line_points + i
                    else:
                        gate_index = num_track_points + num_trial_line_points + num_start_line_points + i

                    if gate_index < len(gate_objects):
                        gate_empty = gate_objects[gate_index]

                        if gate_empty:
                            gate_empty.location = (point.co.x, point.co.y, point.co.z)

        return {'FINISHED'}
        
class SetTrackLimitsOperator(bpy.types.Operator):
    """Update track limits for selected gates"""
    bl_idname = "f1.update_track_limits"
    bl_label = "Update Track Limits"

    def update_limits(self, context):
        left_track_limit = context.scene.left_track_limit
        left_racing_limit = context.scene.left_racing_limit
        right_track_limit = context.scene.right_track_limit
        right_racing_limit = context.scene.right_racing_limit

        # Применяем значения к выделенным объектам
        for obj in context.selected_objects:
            if "left_track_limit" in obj.name:
                obj.location.x = left_track_limit
            elif "left_racing_limit" in obj.name:
                obj.location.x = left_racing_limit
            elif "right_track_limit" in obj.name:
                obj.location.x = right_track_limit
            elif "right_racing_limit" in obj.name:
                obj.location.x = right_racing_limit

    def execute(self, context):
        self.update_limits(context)
        self.report({'INFO'}, "Track limits updated for selected gates")
        return {'FINISHED'}

# Функция для обновления при изменении ползунка
def update_limit_property(self, context):
    bpy.ops.f1.update_track_limits()


def register():
    # Регистрация оригинальных классов
    init_properties()
    bpy.utils.register_class(F1AITrackLayoutMakerPanel)
    bpy.utils.register_class(ImportF1TrackLayout)
    bpy.utils.register_class(ExportF1TrackLayout)
    bpy.utils.register_class(UpdateGatePositions)
    bpy.utils.register_class(SelectSplitterGate)
    bpy.utils.register_class(SelectGateByName)
    bpy.utils.register_class(NewGateIDOperator)
    bpy.utils.register_class(NewMinSpeedGateIDOperator)
    bpy.utils.register_class(NewHoldLineGateIDOperator)
    bpy.utils.register_class(CorrectGateOrientationOperator)

    # Регистрация новых классов........
    bpy.utils.register_class(CreateTargetSurface)  
    bpy.utils.register_class(TransferShapeOperator)
    bpy.utils.register_class(ToggleWaypointVisibility) 
    bpy.utils.register_class(HideSplineGatesOperator) 
    bpy.utils.register_class(SelectCurveOperator) 
    bpy.utils.register_class(SetTrackLimitsOperator)
    bpy.types.Scene.left_track_limit = bpy.props.FloatProperty(name="Left Track Limit", default=0.0, update=update_limit_property)
    bpy.types.Scene.left_racing_limit = bpy.props.FloatProperty(name="Left Racing Limit", default=0.0, update=update_limit_property)
    bpy.types.Scene.right_track_limit = bpy.props.FloatProperty(name="Right Track Limit", default=0.0, update=update_limit_property)
    bpy.types.Scene.right_racing_limit = bpy.props.FloatProperty(name="Right Racing Limit", default=0.0, update=update_limit_property)

def unregister():
    # Отмена регистрации оригинальных классов
    del bpy.types.Scene.show_brake_lines
    bpy.utils.unregister_class(F1AITrackLayoutMakerPanel)
    bpy.utils.unregister_class(ImportF1TrackLayout)
    bpy.utils.unregister_class(ExportF1TrackLayout)
    bpy.utils.unregister_class(UpdateGatePositions)
    bpy.utils.unregister_class(SelectSplitterGate)
    bpy.utils.unregister_class(SelectGateByName)
    bpy.utils.unregister_class(NewGateIDOperator)
    bpy.utils.unregister_class(NewMinSpeedGateIDOperator)
    bpy.utils.unregister_class(NewHoldLineGateIDOperator)

    # Отмена регистрации новых классов
    del bpy.types.Scene.Track_Line_target
    del bpy.types.Scene.Start_Line_target
    del bpy.types.Scene.Trial_Line_target
    del bpy.types.Scene.Pit_Line_target
    bpy.utils.unregister_class(CreateTargetSurface)  # Убедитесь, что этот класс отпиан
    bpy.utils.unregister_class(TransferShapeOperator)
    bpy.utils.unregister_class(ToggleWaypointVisibility)
    bpy.utils.unregister_class(HideSplineGatesOperator)
    bpy.utils.unregister_class(SelectCurveOperator)
    bpy.utils.unregister_class(SetTrackLimitsOperator)
    del bpy.types.Scene.left_track_limit
    del bpy.types.Scene.left_racing_limit
    del bpy.types.Scene.right_track_limit
    del bpy.types.Scene.right_racing_limit

if __name__ == "__main__":
    register()