Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-mini-2024-07-18· OpenAIAi2 WildChat-4.8M (AI2)

Привет! Теперь вопрос в следующем. Вот у нас есть меш RaceTrack, в нем есть несколько…

  1. User

    Привет! Теперь вопрос в следующем. Вот у нас есть меш RaceTrack, в нем есть несколько тысяч точек вертексов, а этот оператор сначала конвентирует сплайн в сурс меш, а затем сурс меш экстраполирует (или интерполирует) свои точки на RaceTrack вертексы (переписывая его координаты). Проблема в том, что если длиная сплайна недостаточна, то идёт неполная перезапись координат вертексов у RaceTrack, и часть вертексов остается, либо же наоборот, сплайн длинный и тогда просто обрезается. Сделай так, чтобы распределение было равномерным вдоль сплайн-меша, чтобы каждый вертекс на RaceTrack в итоге был перезаписан по координатам.

    class TRANSFER_OT_spline_to_mesh(Operator): """Transfer Track_Line Spline to RaceTrack Mesh by reshaping existing RaceTrack""" bl_idname = "transfer.spline_to_mesh" bl_label = "Transfer Spline to Mesh" bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        # Получаем объект Track_Line
        track_line_object = context.scene.track_line_object
    
        if track_line_object and track_line_object.type == 'CURVE':
            # Получаем ширину из контекста
            width = context.scene.track_width
    
            # Преобразуем кривую Track_Line в меш
            bpy.context.view_layer.objects.active = track_line_object
            bpy.ops.object.convert(target='MESH')
            new_mesh_object = bpy.context.active_object
    
            if new_mesh_object and new_mesh_object.type == 'MESH':
                new_vertices = [v.co.copy() for v in new_mesh_object.data.vertices]
    
                # Получаем RaceTrack
                race_track_name = "RaceTrack"  # Имя вашего объекта RaceTrack
                race_track_object = bpy.data.objects.get(race_track_name)
    
                if not race_track_object or race_track_object.type != 'MESH':
                    self.report({'ERROR'}, "RaceTrack object not found or is not a MESH.")
                    return {'CANCELLED'}
    
                race_track_vertices = race_track_object.data.vertices
                race_track_count = len(race_track_vertices)
                track_line_count = len(new_vertices)
    
                # Проверка чтобы не допустить ошибок по количеству вершин
                if race_track_count == 0 or track_line_count == 0:
                    self.report({'ERROR'}, "One of the objects has no vertices.")
                    return {'CANCELLED'}
    
                total_needed_points = race_track_count  # Всего точек в RaceTrack
                segment_length = total_needed_points / track_line_count  # Длина сегмента для интерполяции
    
                # Обновление координат для RaceTrack
                for i in range(track_line_count - 1):
                    start_point = new_vertices[i]
                    end_point = new_vertices[i + 1]
    
                    # Вычисляем направление и нормализацию
                    direction_vector = (end_point - start_point).normalized()
                    rotation_quaternion = direction_vector.to_track_quat('Z', 'Y')
                    side_vector = rotation_quaternion @ Vector((1, 0, 0)) * (width / 2)
    
                    # Количество промежуточных точек на основе сегмента
                    num_intermediate_points = round(segment_length)
    
                    # Заполнение промежуточных точек
                    for j in range(num_intermediate_points):
                        factor = j / num_intermediate_points  # Нормализация от 0 до 1
                        current_point = start_point.lerp(end_point, factor)
    
                        # Определяем левую и правую точки
                        left_vert = current_point + side_vector
                        right_vert = current_point - side_vector
    
                        # Зеркаливание по оси Y
                        left_vert.y = -left_vert.y
                        right_vert.y = -right_vert.y
    
                        # Индекс для RaceTrack
                        race_track_index = i * num_intermediate_points + j
    
                        # Обновляем оригинальные вершины, если в пределах
                        if race_track_index < race_track_count:
                            # Убедимся, что мы чередуем, чтобы не писать один и тот же индекс.....
                            if j % 2 == 0:
                                race_track_vertices[race_track_index].co = left_vert
                            else:
                                race_track_vertices[race_track_index].co = right_vert
    
                # Обновляем меш
                race_track_object.data.update()
    
                self.report({'INFO'}, "RaceTrack reshaped successfully using the Track_Line spline.")
                return {'FINISHED'}
    
        self.report({'ERROR'}, "Track_Line not found or is not a curve.")
        return {'CANCELLED'}
    
  2. Assistant

    Чтобы добиться равномерного распределения вершин вдоль сплайна и обеспечить, чтобы все вершины RaceTrack были перезаписаны, нужно внести изменения в вашу логику интерполяции.

    Вот исправленная версия вашего кода, которая включает равномерное распределение вершин для RaceTrack с перерасчетом их координат:

    class TRANSFER_OT_spline_to_mesh(Operator):
        """Transfer Track_Line Spline to RaceTrack Mesh by reshaping existing RaceTrack"""
        bl_idname = "transfer.spline_to_mesh"
        bl_label = "Transfer Spline to Mesh"
        bl_options = {'REGISTER', 'UNDO'}
    
        def execute(self, context):
            # Получаем объект Track_Line
            track_line_object = context.scene.track_line_object
    
            if track_line_object and track_line_object.type == 'CURVE':
                # Получаем ширину из контекста
                width = context.scene.track_width
    
                # Преобразуем кривую Track_Line в меш
                bpy.context.view_layer.objects.active = track_line_object
                bpy.ops.object.convert(target='MESH')
                new_mesh_object = bpy.context.active_object
    
                if new_mesh_object and new_mesh_object.type == 'MESH':
                    new_vertices = [v.co.copy() for v in new_mesh_object.data.vertices]
    
                    # Получаем RaceTrack
                    race_track_name = "RaceTrack"  # Имя вашего объекта RaceTrack
                    race_track_object = bpy.data.objects.get(race_track_name)
    
                    if not race_track_object or race_track_object.type != 'MESH':
                        self.report({'ERROR'}, "RaceTrack object not found or is not a MESH.")
                        return {'CANCELLED'}
    
                    race_track_vertices = race_track_object.data.vertices
                    race_track_count = len(race_track_vertices)
                    track_line_count = len(new_vertices)
    
                    # Проверка чтобы не допустить ошибок по количеству вершин
                    if race_track_count == 0 or track_line_count == 0:
                        self.report({'ERROR'}, "One of the objects has no vertices.")
                        return {'CANCELLED'}
    
                    # Получаем длину сплайна
                    total_length = 0.0
                    for i in range(track_line_count - 1):
                        total_length += (new_vertices[i + 1] - new_vertices[i]).length
                    
                    if total_length == 0:
                        self.report({'ERROR'}, "Total length of the track line is 0.")
                        return {'CANCELLED'}
    
                    # Количество промежуточных точек на основе длины
                    segment_length = total_length / race_track_count
                    
                    current_length = 0.0
                    v_index = 0
                    
                    for i in range(track_line_count - 1):
                        start_point = new_vertices[i]
                        end_point = new_vertices[i + 1]
                        segment_distance = (end_point - start_point).length
                        
                        while current_length + segment_distance >= segment_length and v_index < race_track_count:
                            # Находим позицию точки
                            remaining_distance = segment_length - current_length
                            factor = remaining_distance / segment_distance
                            current_point = start_point.lerp(end_point, factor)
    
                            # Вычисляем направление и нормализацию
                            direction_vector = (end_point - start_point).normalized()
                            rotation_quaternion = direction_vector.to_track_quat('Z', 'Y')
                            side_vector = rotation_quaternion @ Vector((1, 0, 0)) * (width / 2)
    
                            # Нормализуем вертексы
                            left_vert = current_point + side_vector
                            right_vert = current_point - side_vector
    
                            # Зеркалирование по оси Y
                            left_vert.y = -left_vert.y
                            right_vert.y = -right_vert.y
    
                            # Обновляем оригинальные вершины (чередуем)
                            if v_index % 2 == 0:
                                race_track_vertices[v_index].co = left_vert
                            else:
                                race_track_vertices[v_index].co = right_vert
                            
                            v_index += 1
                            current_length = 0.0  # сбрасываем длину для следующего сегмента
                        current_length += segment_distance
                
                    # В случае, если яркость больше чем количество вершин
                    if v_index < race_track_count:
                        missing_count = race_track_count - v_index
                        # Выравниваем оставшиеся вертексы
                        for j in range(missing_count):
                            race_track_vertices[v_index + j].co = race_track_vertices[v_index - 1].co
    
                    # Обновляем меш
                    race_track_object.data.update()
    
                    self.report({'INFO'}, "RaceTrack reshaped successfully using the Track_Line spline.")
                    return {'FINISHED'}
    
            self.report({'ERROR'}, "Track_Line not found or is not a curve.")
            return {'CANCELLED'}
    

    Изменения и объяснения:

    1. Равномерное распределение: Теперь распределение вдоль сплайна более аккуратное. Мы повторно используем current_length, чтобы отслеживать текущую длину и общее расстояние.
    2. Интерполяция: Используем лерпа для вычисления текущей точки на основе оставшегося расстояния.
    3. Обработка остатка вершин: Если количество вершин в RaceTrack больше, чем количество интерполированных, заполняем оставшиеся вершины последней известной позицией.

    Этот код должен улучшить процесс переноса координат, чтобы все вершины RaceTrack были обновлены, и распределение происходило равномерно вдоль сплайна.