Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-11-20· OpenAIAi2 WildChat-4.8M (AI2)

Вот полный код аддона для блендер 3.3.0: import bpy import os import shutil from…

  1. User

    Вот полный код аддона для блендер 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": "Object", }

    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_CONE_target = bpy.props.StringProperty(
        name="Pit Cone Target",
        default="Pit_TARGET"
    )
    

    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_empty.rotation_euler.rotate_axis("Z", 3.14159)
    context.collection.objects.link(gate_empty)
    gate_objects.append(gate_empty)
    

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

    def draw(self, context):
        layout = self.layout
    
        # Оригинальные операторы вашего аддона
        layout.operator(ImportF1TrackLayout.bl_idname, text="Import F1 Track Layout")
        layout.operator(ExportF1TrackLayout.bl_idname, text="Export F1 Track Layout")
        layout.operator(UpdateGatePositions.bl_idname, text="Update Gates")
    
        # Добавляем оператор CreateTargetSurface
        layout.operator("f1.create_target_surface", text="Create Target Surface")
    
        if splitter_data:
            layout.label(text="Splitters in file:", icon='LINK_BLEND')
            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
    
        layout.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='DECORATE_DRIVER')
                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']}")
                    select_op = brake_row.operator("f1.select_gate_by_name", text="Select Gate", icon='RESTRICT_SELECT_OFF')
                    select_op.gate_name = f"gate_{line_data['brake_line']['gate_id']:02}"
                    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']}")
                        ms_op = ms_row.operator("f1.select_gate_by_name", text="Select Gate", icon='RESTRICT_SELECT_OFF')
                        ms_op.gate_name = f"gate_{min_speed_line['gate_id']:02}"
                        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}")
                    hl_select_op = hl_row.operator("f1.select_gate_by_name", text="Select Gate", icon='RESTRICT_SELECT_OFF')
                    hl_select_op.gate_name = f"gate_{hl_gate_id:02}"
                    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 Layout:")
    
        # Заранее заданные исходные и целевые кривые
        transfer_pairs = [
            ("Track_Line", "Track_TARGET"),
            ("Start_Line", "Start_TARGET"),
            ("Trial_Line", "Trial_TARGET"),
            ("Pit_CONE", "Pit_TARGET"),
        ]
    
        for source_name, target_default in transfer_pairs:
            row = layout.row(align=True)
            row.label(text=f"{source_name}:")
            row.prop_search(context.scene, f"{source_name}_target", bpy.data, "objects", text="")
    
            transfer_op = 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_op = row.operator("f1.correct_way", text="Correct Way")
            correct_op.source_curve_name = source_name
    

    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 SelectSplitterGate(bpy.types.Operator): """Select gate in scene""" 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
        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):
        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'
                
                # Создаем объект и добавляем его в текущую коллекцию
                curve_object = bpy.data.objects.new(name, curve_data)
                context.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]
    
        selected_gates = [obj for obj in context.selected_objects if obj.name.startswith("gate_")]
    
        if not selected_gates:
            self.report({'WARNING'}, "No gate_* objects selected")
            return {'CANCELLED'}
    
        for gate_object in selected_gates:
            # Найти ближайшую точку для каждого gate_object
            min_distance = float('inf')
            closest_point_index = 0
            
            for i, point in enumerate(source_spline.bezier_points):
                distance = (gate_object.location - point.co).length
                if distance < min_distance:
                    min_distance = distance
                    closest_point_index = i
            
            # Определяем направление между текущей и следующей точкой
            current_point = source_spline.bezier_points[closest_point_index]
            next_index = (closest_point_index + 1) % len(source_spline.bezier_points)
            next_point = source_spline.bezier_points[next_index]
            
            direction_vector = (next_point.co - current_point.co).normalized()
            if direction_vector.length == 0:
                continue
    
            # Создаем кватернион из 'up' ориентации и направления
            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
        
        self.report({'INFO'}, f"Transferred shape to {self.source_curve_name}")
        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_CIRCLE_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')
    
            trial_curve_data = bpy.data.curves.new(name="Trial_CIRCLE_Curve", type='CURVE')
            trial_curve_data.dimensions = '3D'
            trial_spline = trial_curve_data.splines.new('BEZIER')
    
            pit_curve_data = bpy.data.curves.new(name="Pit_CONE_Curve", type='CURVE')
            pit_curve_data.dimensions = '3D'
            pit_spline = pit_curve_data.splines.new('BEZIER')
    
            trial_line_curve_data = bpy.data.curves.new(name="Trial_Line_Curve", type='CURVE')
            trial_line_curve_data.dimensions = '3D'
            trial_line_spline = trial_line_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_CIRCLE_id]
            pit_points = [gate for gate in gates if int(gate.get('id')) > Trial_CIRCLE_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_spline.bezier_points.add(len(track_points) - 1)
            trial_line_spline.bezier_points.add(len(trial_line_points) - 1)
            start_line_spline.bezier_points.add(len(start_line_points) - 1)
            pit_spline.bezier_points.add(len(pit_points) - 1)
    
            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)
    
            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 = trial_line_spline.bezier_points[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)
    
            offset += len(trial_line_points)
            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)
    
            offset += len(start_line_points)
            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)
    
            track_object = bpy.data.objects.new("Track_Line", track_curve_data)
            trial_line_object = bpy.data.objects.new("Trial_Line", trial_line_curve_data)
            start_line_object = bpy.data.objects.new("Start_Line", start_line_curve_data)
            pit_object = bpy.data.objects.new("Pit_CONE", pit_curve_data)
            context.collection.objects.link(track_object)
            context.collection.objects.link(trial_line_object)
            context.collection.objects.link(start_line_object)
            context.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'}
    

    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 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 execute(self, context):
        
        def export_normal(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)}"
        
        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 = 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
    
            brake_lines_elem = root.find('.//brake_lines')
            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:
                    gate_id_str = str(line_data["brake_line"]["gate_id"])
                    brake_line_elem.set('gate_id', gate_id_str)
    
                min_speed_lines_elem = root.find('.//min_speed_lines')
                for min_speed_line in line_data['min_speed_lines']:
                    min_speed_line_elem = min_speed_lines_elem.find(f'min_speed_line[@id="{min_speed_line["min_speed_line_id"]}"]')
                    if min_speed_line_elem is not None:
                        gate_id_str = str(min_speed_line["gate_id"])
                        min_speed_line_elem.set('gate_id', gate_id_str)
                        min_speed_line_elem.set('min_speed', f'{min_speed_line["min_speed"]:.2f}')
    
            hold_lines_elem = root.find('.//hold_lines')
            for line_data in brake_lines_data:
                hold_line_elem = hold_lines_elem.find(f'hold_line[@id="{line_data["hold_line"]["hold_line_id"]}"]')
                if hold_line_elem is not None:
                    gate_id_str = str(line_data["hold_line"]["gate_id"])
                    hold_line_elem.set('gate_id', gate_id_str)
    
            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_CONE"])
    
    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_CONE"]:
            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'}
    

    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)
    

    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_CONE_target
    bpy.utils.unregister_class(CreateTargetSurface)  # Убедитесь, что этот класс отпиан
    bpy.utils.unregister_class(TransferShapeOperator)
    

    if name == "main": register()

  2. Assistant

    Ваш код представляет собой сложное дополнение для Blender, предназначенное для работы с трассами с использованием XML-данных. Оно позволяет импортировать, экспортировать, редактировать и обновлять трассы, работая с Bezier-кривыми и объектами в сцене. Перед установкой и использованием этого дополнения убедитесь, что вы понимаете логику его работы.

    Основные функции:

    1. Импорт трассы из XML-файла:

      • Загружает данные о воротах (gates), трассах и других элементах из XML и преобразует их в объекты Blender.
      • Используются Bezier-кривые для отображения различных частей трассы (основная линия, линия старта, питстоп и т.д.).
    2. Экспорт трассы в XML:

      • Позволяет обновлять положения, вращение и другой мета-информации объектов и экспортировать изменённые данные обратно в формат XML.
    3. Создание целевых кривых:

      • Создаёт 4 предварительно настроенные Bezier-кривые для целей трасс.
    4. Корректировки ориентации объектов-ворот:

      • Исправляет ориентацию объектов трассы (ворот), чтобы они выравнивались по кривой.
    5. Логика обновления:

      • Обновляет положения ворот в сцене на основе положения контрольных точек кривых.
    6. Интерфейс на панели View3D:

      • Расширяет интерфейс Blender, добавляя пользовательскую панель с множеством функций.
    7. Поддержка управления линиями торможения (brake lines), линиями минимальной скорости и удержания (hold lines):

      • Позволяет модерировать данные по тормозным и удерживающим линиям, включая загрузку и обновление из данных.

    Проверка установки:

    Для использования аддона, сохраните код в файл с расширением .py, например f1_ai_track_layout_maker.py, затем выполните следующие шаги:

    1. Перейдите в Blender в Edit > Preferences > Add-ons.
    2. Нажмите Install и выберите сохранённый файл.
    3. Активируйте аддон, установив галочку.

    Примечания:

    1. Тестирование:

      • Этот аддон требует XML-файлов заданного формата. Убедитесь, что ваш файл имеет правильную структуру XML с элементами вроде <gates>, <links>, <brake_lines>, иначе обработка может завершиться с ошибкой.
    2. Совместимость:

      • Аддон разрабатывался для Blender версии 3.3.0, он может работать в других версиях, но возможны проблемы с совместимостью.
    3. Обширная функциональность:

      • Код содержит множество функций, от работы с Bezier-кривыми до управления объектами-воротами. Поэтому стоит разбить функционал и протестировать каждую часть отдельно перед массовыми изменениями.
    4. Оптимизация:

      • Код можно оптимизировать, выводя обобщённые функции для повторяющихся операций, таких как обработка элементов XML или работы с Bezier-кривыми.

    Если у вас будут вопросы по доработке кода или его использованию, обязательно уточните!

  3. User

    в нашем коде мы в фалйе получаем такие блоки:

      <gate id="34">
        <position format="float3">-197.658 0.0 126.586</position>
        <normal format="float3">-0.926198 0.0 0.377036</normal>
        <waypoints num_waypoints="5">
          <waypoint id="0" type="right_racing_limit" length="4.75" />
          <waypoint id="1" type="right_track_limit" length="8.68" />
          <waypoint id="2" type="racing_line" length="0.00">
            <racing_line type="optimal" />
          </waypoint>
          <waypoint id="3" type="left_racing_limit" length="-1.61" />
          <waypoint id="4" type="left_track_limit" length="-2.59" />
        </waypoints>
        <edges num_edges="0" />
      </gate>
    

    мы уже парсим следующие данные:

      <gate id="34">
        <position format="float3">-197.658 0.0 126.586</position>
        <normal format="float3">-0.926198 0.0 0.377036</normal>
    

    Теперь нужно добавить функционал для парсинга, изменения и экспорта вот этих данных:

        <waypoints num_waypoints="5">
          <waypoint id="0" type="right_racing_limit" length="4.75" />
          <waypoint id="1" type="right_track_limit" length="8.68" />
          <waypoint id="2" type="racing_line" length="0.00">
            <racing_line type="optimal" />
          </waypoint>
          <waypoint id="3" type="left_racing_limit" length="-1.61" />
          <waypoint id="4" type="left_track_limit" length="-2.59" />
        </waypoints>
    

    Насколько я понимаю, это лимиты трассы, которые располагаются по краям ориентации normal (который мы уже парсим на CONE empty_gate меш ориентацию), короче, можешь передать эти данные на вертексы которые будут по бокам идти от CONE mesh для empty gate

  4. Assistant

    Для этого вам потребуется выполнить несколько шагов:

    1. Парсинг данных <waypoints> и их атрибутов.
    2. Добавление функционала, который создаёт новые объекты (например, линии или точки), представляющие параметры waypoints.
    3. Генерация вершин (vertices), смещённых от ориентации вектора normal.
    4. Экспорт модифицированных данных обратно в XML.

    1. Парсинг <waypoints>:

    Для начала добавим функционал парсинга новых данных (<waypoints>) в существующую систему. Данные о waypoints можно сохранить в виде структуры Python, содержащей все необходимые поля.

    Добавьте функцию parse_waypoints:

    def parse_waypoints(gate):
        """
        Извлекает waypoints из gate XML и возвращает их как список словарей.
        """
        waypoints_elem = gate.find('waypoints')
        if waypoints_elem is None:
            return []  # Если нет данных
    
        waypoints = []
        for waypoint_elem in waypoints_elem.findall('waypoint'):
            waypoint_data = {
                "id": int(waypoint_elem.get('id')),
                "type": waypoint_elem.get('type'),
                "length": float(waypoint_elem.get('length'))
            }
    
            # Если waypoint содержит вложенный элемент, учитываем его
            racing_line_elem = waypoint_elem.find('racing_line')
            if racing_line_elem is not None:
                waypoint_data["racing_line_type"] = racing_line_elem.get('type')
    
            waypoints.append(waypoint_data)
    
        return waypoints
    

    Теперь при импорте данных в функции import_from_temp_file можно парсить данные waypoints и сохранять их в объект gate_empty:

    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
            gate_empty = create_gate_object(i, x, y_mirrored, z, gate, is_splitter, context)
    
            # Парсим waypoints для данного gate
            gate_empty["waypoints"] = parse_waypoints(gate)
    

    2. Генерация вершин (vertices) для waypoints:

    Создадим функцию, которая преобразует каждый waypoint в смещённую точку относительно gate на основе normal и length. Позиции точек будут находиться по сторонам ориентации normal. Мы добавим эти данные как новые объекты в сцену Blender.

    Функция:

    def generate_waypoints(gate_empty, context):
        """
        Генерирует объекты для отображения waypoints на основе gate и сохранённых данных.
        """
        if "waypoints" not in gate_empty:
            return
    
        normal = gate_empty.get("imported_normal", [0.0, 0.0, 1.0])  # использовать нормаль из объекта
        gate_location = Vector(gate_empty.location)
        normal_vector = Vector((normal[0], normal[1], normal[2]))
    
        for waypoint in gate_empty["waypoints"]:
            length = waypoint["length"]
            waypoint_type = waypoint["type"]
    
            # Рассчитываем позицию для waypoint
            offset = normal_vector.normalized() * length
            waypoint_location = gate_location + offset
    
            # Создаём новый объект Empty для waypoint
            waypoint_name = f"{gate_empty.name}_waypoint_{waypoint['id']}"
            waypoint_empty = bpy.data.objects.new(waypoint_name, None)
            waypoint_empty.empty_display_type = 'SPHERE'  # Настройка отображения
            waypoint_empty.empty_display_size = 0.5  # Размер
    
            waypoint_empty.location = waypoint_location
            waypoint_empty["type"] = waypoint_type
            waypoint_empty["length"] = length
    
            # Ссылка на текущий gate
            waypoint_empty["gate"] = gate_empty.name
    
            # Добавляем в сцену
            context.collection.objects.link(waypoint_empty)
    

    Теперь вызовите эту функцию после создания каждого gate_empty:

    generate_waypoints(gate_empty, context)
    

    3. Экспорт данных waypoints:

    Для экспорта waypoints необходимо сохранить их в те же <gate> элементы XML-файла. Добавим функционал экспорта waypoints.

    Дополните функцию ExportF1TrackLayout.execute следующим кодом:

    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:
                # Удаляем старые waypoints
                waypoints_elem = gate_elem.find('waypoints')
                if waypoints_elem is not None:
                    gate_elem.remove(waypoints_elem)
    
                # Создаём новый элемент waypoints
                waypoints_elem = ET.SubElement(gate_elem, 'waypoints')
                waypoints_elem.set("num_waypoints", str(len(gate_object["waypoints"])))
    
                for waypoint in gate_object["waypoints"]:
                    waypoint_elem = ET.SubElement(waypoints_elem, 'waypoint')
                    waypoint_elem.set("id", str(waypoint["id"]))
                    waypoint_elem.set("type", waypoint["type"])
                    waypoint_elem.set("length", f"{waypoint['length']:.2f}")
    
                    # Добавляем racing_line если указано
                    if "racing_line_type" in waypoint:
                        racing_line_elem = ET.SubElement(waypoint_elem, 'racing_line')
                        racing_line_elem.set('type', waypoint["racing_line_type"])
    

    4. Визуализация в Blender:

    Чтобы waypoints можно было лучше визуализировать, объекты SPHERE можно заменить, например, на линии (Mesh Line) или комбинировать для создания отображения границ трассы.


    Итог:

    Теперь у вас есть полный цикл:

    • Импорт данных в виде waypoints в объекты Empty (или другой подходящий тип).
    • Генерация точек на основе normal и length, которые определяют положения для трековых ограничений и контрольной линии.
    • Экспорт скорректированных waypoints обратно в XML-файл.

    Если будут дополнительные уточнения, как конкретно визуализировать или распространять данные, дайте знать!

  5. User

    normal мы уже и так парсим в моем коде...

  6. Assistant

    Да, вы правы, нормаль уже парсится в вашем существующем коде. Мы можем переиспользовать её, чтобы вычислить позиции waypoints, которые располагаются по краям ориентации normal. Это минимизирует необходимость в дублирующем коде.

    Давайте доработаем предложенное решение с учётом того, что нормаль уже присутствует. Вместо парсинга нормали снова будем использовать уже существующую атрибут imported_normal, который добавляется в gate_empty.


    Генерация вершин на основе waypoints:

    Мы используем нормаль, направление которой указывает ось смещения, чтобы вычислить позиции waypoints для каждого gate. Сами waypoints указывают length, что и задаёт вдоль нормали, где именно расположить вершины. Вот актуализированный код:

    Функция генерации вершин:

    def generate_waypoints(gate_empty, context):
        """
        Создаёт геометрию (линии или точки) для отображения waypoints вокруг gate.
        """
        if "waypoints" not in gate_empty:
            return
    
        # Извлечённая нормаль из gate_empty (вы уже это делаете в процессе импорта)
        normal = gate_empty.get("imported_normal", [0.0, 0.0, 1.0])
        gate_location = Vector(gate_empty.location)
        normal_vector = Vector((normal[0], normal[1], normal[2]))
    
        # Перебираем waypoints
        for waypoint in gate_empty["waypoints"]:
            length = waypoint["length"]
            waypoint_type = waypoint["type"]
    
            # Рассчитываем смещение вдоль нормали
            offset = normal_vector.normalized() * length
            waypoint_location = gate_location + offset
    
            # Создаём новый объект Empty для waypoint
            waypoint_name = f"{gate_empty.name}_waypoint_{waypoint['id']}"
            waypoint_empty = bpy.data.objects.new(waypoint_name, None)
            waypoint_empty.empty_display_type = 'SPHERE'  # Выводим точку в виде сферы
            waypoint_empty.empty_display_size = 0.5  # Размер сферы
    
            # Настраиваем свойства объекта waypoint
            waypoint_empty.location = waypoint_location
            waypoint_empty["type"] = waypoint_type
            waypoint_empty["length"] = length
    
            # Добавляем в сцену (главная коллекция)
            context.collection.objects.link(waypoint_empty)
    

    Интеграция в процесс импорта:

    Добавьте вызов generate_waypoints после создания gate_empty. Ваш существующий код, который создаёт gate_empty, должен выглядеть так:

    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:
            gate_empty.empty_display_size = 3.25 * 2.0
            gate_empty.scale[1] = 1.0 / 1.5
        else:
            gate_empty.empty_display_size = 1.0
    
        gate_empty.location = (x, y_mirrored, z)
        gate_empty["gate_number"] = i
    
        # Если у gate есть нормаль, установить её
        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 в пространстве
        gate_empty.rotation_euler.rotate_axis("Z", 3.14159)
        context.collection.objects.link(gate_empty)
    
        # Сохраняем gate в глобальный список
        gate_objects.append(gate_empty)
    
        # Добавляем waypoints в этот gate
        gate_empty["waypoints"] = parse_waypoints(gate)
        
        # Вызов генерации waypoints-геометрии
        generate_waypoints(gate_empty, context)
    
        return gate_empty
    

    Итог:

    Этот обновлённый подход:

    1. Использует уже парсенную нормаль.
    2. Для каждого waypoint создаёт Empty-объект, правильно рассчитанный с учётом длины смещения (length) и ориентации нормали.
    3. Такие данные будут добавляться как объекты Blender (Empty), визуализируемые на сцене.

    Визуализация в сцене Blender:

    • Вы увидите Empty-объекты типа SPHERE, размещённые по направлению нормали.
    • Каждое Empty будет хранить данные type и length из XML.

    Если вы хотите вместо Empty создавать mesh-объекты, например, линии или точки, это можно сделать, изменив тип создаваемых объектов. Дайте знать, если потребуется помощь!