UE5 一些关于过场动画sequencer，轨道track的一些Python操作

import unreal
def execute():
    movie_scene_actors = []
    sequence_assets = []
    data = 0.0
    # 获取编辑器实用工具库
    lib = unreal.EditorUtilityLibrary()
    selected_assets = lib.get_selected_assets()
    for asset in selected_assets:
        if asset.get_class() == unreal.LevelSequence().get_class():
            asset = unreal.MovieSceneSequence.cast(asset)
            movie_scene_actors.append(asset)
    for movie_scene in movie_scene_actors:
        sequence_assets.clear()
        # 获取关卡中的所有轨道
        tracks = movie_scene.get_tracks()
        sequence_assets.append(movie_scene)
        for track in tracks:
            sections = track.get_sections()
            for section in sections:
                if isinstance(section, unreal.MovieSceneSubSection):
                    # 获取绑定的序列
                    path = section.get_sequence().get_path_name()
                    if "vCam_VP_" in path or "MainStage_Floor_" in path:
                        print(f"Found path: {path}")

                        # 确保在删除 section 之前，该部分依然是轨道的有效部分
                        if section in sections:
                            print(f"Removing section with path: {path}")
                            track.remove_section(section)  # 删除该部分
                        else:
                            print(f"Section with path {path} is no longer valid or has already been removed.")

import unreal


def execute():

    def set_playback_time(_movie_scene, new_start_frame):
        # 更改序列关卡的播放起始时间和结束时间
        playback_star = _movie_scene.get_playback_start()
        playback_end = _movie_scene.get_playback_end()
        _duration = playback_end - playback_star

        _movie_scene.set_playback_start(new_start_frame)
        _movie_scene.set_playback_end(new_start_frame + _duration)


    def start_conversion(_sequence_assets, _data):
        for _movie_scene in _sequence_assets:
            _movie_scene.set_read_only(False)
            set_playback_time(_movie_scene, _data)
            for __bind in _movie_scene.get_bindings():
                for __track in __bind.get_tracks():
                    for __section in __track.get_sections():
                        start_frame = __section.get_start_frame()
                        end_frame = __section.get_end_frame()
                        duration = end_frame - start_frame
                        # 注意：这里要保证轨道中只有一个片段，否则会多个片段重叠在一个起始时间里
                        if _data > start_frame:
                            __section.set_end_frame(_data + duration)
                            __section.set_start_frame(_data)
                        else:
                            __section.set_start_frame(_data)
                            __section.set_end_frame(_data + duration)

                        duration_key = _data - start_frame
                        for _channel in __section.get_all_channels():
                            for key in _channel.get_keys():
                                key.set_time(unreal.FrameNumber(key.get_time().frame_number.value + duration_key))

            # # 获取关卡中的所有轨道
            _tracks = _movie_scene.get_tracks()
            for __track in _tracks:
                # 获取轨道中的所有片段
                __sections = __track.get_sections()
                for __section in __sections:
                    # 修改片段的起始时间和结束时间
                    start_frame = __section.get_start_frame()
                    end_frame = __section.get_end_frame()
                    duration = end_frame - start_frame

                    # 注意：这里要保证轨道中只有一个片段，否则会多个片段重叠在一个起始时间里
                    if _data > start_frame:
                        __section.set_end_frame(_data + duration)
                        __section.set_start_frame(_data)
                    else:
                        __section.set_start_frame(_data)
                        __section.set_end_frame(_data + duration)

    movie_scene_actors = []
    sequence_assets = []
    data = 0.0
    # 获取编辑器实用工具库
    lib = unreal.EditorUtilityLibrary()
    selected_assets = lib.get_selected_assets()

    for asset in selected_assets:
        if asset.get_class() == unreal.LevelSequence().get_class():
            asset = unreal.MovieSceneSequence.cast(asset)
            movie_scene_actors.append(asset)

    for movie_scene in movie_scene_actors:
        sequence_assets.clear()
        # 获取关卡中的所有轨道
        tracks = movie_scene.get_tracks()
        sequence_assets.append(movie_scene)
        for track in tracks:
            sections = track.get_sections()
            for section in sections:
                if isinstance(section, unreal.MovieSceneSubSection):
                    # 获取绑定的序列
                    path = section.get_sequence().get_path_name()
                    sequence_assets.append(unreal.load_asset(path))

        start_conversion(sequence_assets, data)

import unreal
def execute():

    def set_playback_time(_movie_scene, new_start_frame):
        # 更改序列关卡的播放起始时间和结束时间
        playback_star = _movie_scene.get_playback_start()
        playback_end = _movie_scene.get_playback_end()
        _duration = playback_end - playback_star

        _movie_scene.set_playback_start(new_start_frame)
        _movie_scene.set_playback_end(new_start_frame + _duration)


    def start_conversion(_sequence_assets, _data, sub_signal):
        for _movie_scene in _sequence_assets:
            _movie_scene.set_read_only(False)
            set_playback_time(_movie_scene, _data['LTC'])
            for __bind in _movie_scene.get_bindings():
                for __track in __bind.get_tracks():
                    for __section in __track.get_sections():
                        start_frame = __section.get_start_frame()
                        end_frame = __section.get_end_frame()
                        duration = end_frame - start_frame
                        # 注意：这里要保证轨道中只有一个片段，否则会多个片段重叠在一个起始时间里
                        if _data['LTC'] > start_frame:
                            __section.set_end_frame(_data['LTC'] + duration)
                            __section.set_start_frame(_data['LTC'])
                        else:
                            __section.set_start_frame(_data['LTC'])
                            __section.set_end_frame(_data['LTC'] + duration)

                        duration_key = _data['LTC'] - start_frame
                        for _channel in __section.get_all_channels():
                            for key in _channel.get_keys():
                                key.set_time(unreal.FrameNumber(key.get_time().frame_number.value + duration_key))

            # # 获取关卡中的所有轨道
            _tracks = _movie_scene.get_tracks()
            for __track in _tracks:
                # 获取轨道中的所有片段
                __sections = __track.get_sections()
                for __section in __sections:
                    # 修改片段的起始时间和结束时间
                    start_frame = __section.get_start_frame()
                    end_frame = __section.get_end_frame()
                    duration = end_frame - start_frame

                    # 注意：这里要保证轨道中只有一个片段，否则会多个片段重叠在一个起始时间里
                    if _data['LTC'] > start_frame:
                        __section.set_end_frame(_data['LTC'] + duration)
                        __section.set_start_frame(_data['LTC'])
                    else:
                        __section.set_start_frame(_data['LTC'])
                        __section.set_end_frame(_data['LTC'] + duration)

        if sub_signal:
            for _movie_scene in _sequence_assets:
                pack = '/'.join(str(_movie_scene.get_path_name()).split('/')[:-1])
                name = "vCam_VP_" + _data["VPTakeName"] + ".vCam_VP_" + _data["VPTakeName"]
                unreal.EditorAssetLibrary.rename_asset(_movie_scene.get_path_name(), f"{pack}/{name}")
                _movie_scene.set_read_only(True)

    movie_scene_actors = []
    sequence_assets = []
    sequence_sub_assets = []
    data = {}
    # 获取编辑器实用工具库
    lib = unreal.EditorUtilityLibrary()
    # 选择所有选择的单位
    selected_assets = lib.get_selected_assets()

    for asset in selected_assets:
        # 如果单位是LevelSequence类型
        if asset.get_class() == unreal.LevelSequence().get_class():
            # 转换为MovieSceneSequence类型（因为python是动态语言，不转换其实也可以）
            asset = unreal.MovieSceneSequence.cast(asset)
            # 保存起来
            movie_scene_actors.append(asset)

    for movie_scene in movie_scene_actors:
        data.clear()
        sequence_assets.clear()
        sequence_sub_assets.clear()

        # 获取关卡中的所有轨道
        tracks = movie_scene.get_tracks()
        if len(tracks) == 0:
            sequence_sub_assets.append(movie_scene)
            bindings = movie_scene.get_bindings()
            for binding in bindings:
                if binding.get_display_name() == 'vCam_VP':
                    for _track in binding.get_tracks():
                        for _section in _track.get_sections():
                            for channel in _section.get_all_channels():
                                if _track.get_display_name() == 'VPTakeName':
                                    data["VPTakeName"] = channel.get_default()
                                if channel.get_keys():
                                    keys = channel.get_keys()[0]
                                    if _track.get_display_name() == 'LTC':
                                        data['LTC'] = keys.get_value()
                                    elif _track.get_display_name() == 'STC':
                                        data['STC'] = keys.get_value()
        else:
            sequence_assets.append(movie_scene)
            for track in tracks:
                # 获取轨道中的所有片段
                sections = track.get_sections()
                for section in sections:
                    # 判断是否为关卡子序列
                    if isinstance(section, unreal.MovieSceneSubSection):
                        # 获取绑定的序列
                        path = section.get_sequence().get_path_name()
                        sequence_sub_assets.append(unreal.load_asset(path))

                        if track.get_display_name() != 'vCam_VP':
                            continue
                        for bind in section.get_sequence().get_bindings():
                            # 获取指定序列
                            sequence = bind.sequence
                            for _bind in sequence.get_bindings():
                                for _track in _bind.get_tracks():
                                    for _section in _track.get_sections():
                                        for channel in _section.get_all_channels():
                                            if _track.get_display_name() == 'VPTakeName':
                                                data["VPTakeName"] = channel.get_default()

                                            if channel.get_keys():
                                                keys = channel.get_keys()[0]
                                                if _track.get_display_name() == 'LTC':
                                                    data['LTC'] = keys.get_value()
                                                elif _track.get_display_name() == 'STC':
                                                    data['STC'] = keys.get_value()
        if not data:
            unreal.log_error('你的关卡序列中不存在vCam_VP蓝图 或者 不存在LTC和STC属性!')
            return
        start_conversion(sequence_assets, data, False)
        start_conversion(sequence_sub_assets, data, True)

import unreal


def execute():

    def set_playback_time(_movie_scene, new_start_frame):
        # 更改序列关卡的播放起始时间和结束时间
        playback_star = _movie_scene.get_playback_start()
        playback_end = _movie_scene.get_playback_end()
        _duration = playback_end - playback_star

        _movie_scene.set_playback_start(new_start_frame)
        _movie_scene.set_playback_end(new_start_frame + _duration)


    def start_conversion(_sequence_assets, _data, sub_signal):
        for _movie_scene in _sequence_assets:
            _movie_scene.set_read_only(False)
            set_playback_time(_movie_scene, _data['STC'])
            for __bind in _movie_scene.get_bindings():
                for __track in __bind.get_tracks():
                    for __section in __track.get_sections():
                        start_frame = __section.get_start_frame()
                        end_frame = __section.get_end_frame()
                        duration = end_frame - start_frame
                        # 注意：这里要保证轨道中只有一个片段，否则会多个片段重叠在一个起始时间里
                        if _data['STC'] > start_frame:
                            __section.set_end_frame(_data['STC'] + duration)
                            __section.set_start_frame(_data['STC'])
                        else:
                            __section.set_start_frame(_data['STC'])
                            __section.set_end_frame(_data['STC'] + duration)

                        duration_key = _data['STC'] - start_frame
                        for _channel in __section.get_all_channels():
                            for key in _channel.get_keys():
                                key.set_time(unreal.FrameNumber(key.get_time().frame_number.value + duration_key))

            # # 获取关卡中的所有轨道
            _tracks = _movie_scene.get_tracks()
            for __track in _tracks:
                # 获取轨道中的所有片段
                __sections = __track.get_sections()
                for __section in __sections:
                    # 修改片段的起始时间和结束时间
                    start_frame = __section.get_start_frame()
                    end_frame = __section.get_end_frame()
                    duration = end_frame - start_frame

                    # 注意：这里要保证轨道中只有一个片段，否则会多个片段重叠在一个起始时间里
                    if _data['STC'] > start_frame:
                        __section.set_end_frame(_data['STC'] + duration)
                        __section.set_start_frame(_data['STC'])
                    else:
                        __section.set_start_frame(_data['STC'])
                        __section.set_end_frame(_data['STC'] + duration)

        if sub_signal:
            for _movie_scene in _sequence_assets:
                pack = '/'.join(str(_movie_scene.get_path_name()).split('/')[:-1])
                name = "vCamWithHud_PC_" + _data["VPTakeName"] + ".vCamWithHud_PC_" + _data["VPTakeName"]
                unreal.EditorAssetLibrary.rename_asset(_movie_scene.get_path_name(), f"{pack}/{name}")
                _movie_scene.set_read_only(True)

    movie_scene_actors = []
    sequence_assets = []
    sequence_sub_assets = []
    data = {}
    # 获取编辑器实用工具库
    lib = unreal.EditorUtilityLibrary()
    # 选择所有选择的单位
    selected_assets = lib.get_selected_assets()

    for asset in selected_assets:
        # 如果单位是LevelSequence类型
        if asset.get_class() == unreal.LevelSequence().get_class():
            # 转换为MovieSceneSequence类型（因为python是动态语言，不转换其实也可以）
            asset = unreal.MovieSceneSequence.cast(asset)
            # 保存起来
            movie_scene_actors.append(asset)

    for movie_scene in movie_scene_actors:
        data.clear()
        sequence_assets.clear()
        sequence_sub_assets.clear()

        # 获取关卡中的所有轨道
        tracks = movie_scene.get_tracks()
        if len(tracks) == 0:
            sequence_sub_assets.append(movie_scene)
            bindings = movie_scene.get_bindings()
            for binding in bindings:
                if binding.get_display_name() == 'vCamWithHud_PC':
                    for _track in binding.get_tracks():
                        for _section in _track.get_sections():
                            for channel in _section.get_all_channels():
                                if _track.get_display_name() == 'VPTakeName':
                                    data["VPTakeName"] = channel.get_default()
                                if channel.get_keys():
                                    keys = channel.get_keys()[0]
                                    if _track.get_display_name() == 'LTC':
                                        data['LTC'] = keys.get_value()
                                    elif _track.get_display_name() == 'STC':
                                        data['STC'] = keys.get_value()

        else:
            sequence_assets.append(movie_scene)
            for track in tracks:
                # 获取轨道中的所有片段
                sections = track.get_sections()
                for section in sections:
                    # 判断是否为关卡子序列
                    if isinstance(section, unreal.MovieSceneSubSection):
                        # 获取绑定的序列
                        path = section.get_sequence().get_path_name()
                        sequence_assets.append(unreal.load_asset(path))

                        if track.get_display_name() != 'vCamWithHud_PC':
                            continue
                        for bind in section.get_sequence().get_bindings():
                            # 获取指定序列
                            sequence = bind.sequence
                            for _bind in sequence.get_bindings():
                                for _track in _bind.get_tracks():
                                    for _section in _track.get_sections():
                                        for channel in _section.get_all_channels():
                                            if _track.get_display_name() == 'VPTakeName':
                                                data["VPTakeName"] = channel.get_default()

                                            if channel.get_keys():
                                                keys = channel.get_keys()[0]
                                                if _track.get_display_name() == 'LTC':
                                                    data['LTC'] = keys.get_value()
                                                elif _track.get_display_name() == 'STC':
                                                    data['STC'] = keys.get_value()
        if not data:
            unreal.log_error('你的关卡序列中不存在vCamWithHud_PC蓝图 或者 不存在LTC和STC属性!')
            return
        start_conversion(sequence_assets, data, False)
        start_conversion(sequence_sub_assets, data, True)