Wwise SDK 入门 - 以几个小工具为例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 获取工程信息，无参数调用
print("Getting Wwise instance information:")
result = client.call("ak.wwise.core.getInfo")
pprint(result)
	    
# 查询指定对象的信息	，JSON 参数调用	
print("Query the Default Work Unit information:")
# JSON 参数段
object_get_args = {
	"from": {
      		"path": ["\\Actor-Mixer Hierarchy\\Default Work Unit"]
	},
     "options": {
     		"return": ["id", "name", "type"]
 	}
}
result = client.call("ak.wwise.core.object.get", object_get_args)
pprint(result)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# 获取当前选中对象的以下四种信息
opts_select = {
    "return": [
        "id", "path", "name", "type"
    ]
}

ids = []  # 所有选中对象的id
# 三种路径主要是为了处理选中对象后在SoundBanks下生成对应路径的问题
ori_paths = []  # 所有选中对象的工程路径
paths = []  # 所有选中对象应在SoundBanks下的路径
parent_paths = []  # 所有选中对象应在SoundBanks下的父路径

names = []  # 所有选中对象的名称
types = []  # 所有选中对象的类型
wrong_select = False # 用于判断选中对象的合法性
same_path = False # 用于判断所有选中对象是否处于同一父路径下
# 调用 API 获取所需对象
result_select = client.call("ak.wwise.ui.getSelectedObjects", options=opts_select)['objects']

for select in result_select:
    # 判断选中对象是否合法，即是否在Event路径下
    if select.get('path')[:6] != '\\Event':
        wrong_select = True
        break
    ids.append(select.get('id'))
    names.append(select.get('name'))
    ori_paths.append(select.get('path'))
    types.append(select.get('type'))
    # 修改选中对象的路径为\SoundBanks开头
    path = '\SoundBanks' + select.get('path')[7:] 
    paths.append(path)
    # 获取父级路径
    name = select.get('name')
    name = '\\' + name
    parent_path = path.replace(name, "")
    parent_paths.append(parent_path)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
# 为选中的所有对象创建一个SoundBank，传入的参数是每个对象的父路径以及 id
def create_for_all_event(p_paths, object_ids):
    path_split = p_paths[0].replace('\\', "", 1)
    path_split = path_split.split('\\')
    path_split[0] = 'Events'

    # 如果所有对象在同一路径下
    if same_path and len(path_split) > 1:
        cur_event_path = '\\' + path_split[0]
        
        # 从根部开始逐一判断每一级父路径的类型并在SoundBank下创建
        for cur in path_split[1:]:
            cur_soundbank_path = '\\SoundBanks' + cur_event_path[7:]
            cur_event_path = cur_event_path + '\\' + cur
            # 查询当前一级对象的类型
            args_get_cur_type = {
                "from": {
                    "path": [
                        cur_event_path
                    ]
                }
            }
            opts_get_cur_type = {
                "return": [
                    "type"
                ]
            }
            cur_type = client.call("ak.wwise.core.object.get", args_get_cur_type, options=opts_get_cur_type)['return'][0].get('type')
            # 根据查询到的类型创建对应对象
            args_create_path = {
                "parent": cur_soundbank_path,
                "type": cur_type,
                "name": cur,
                "onNameConflict": "merge"
            }
            client.call("ak.wwise.core.object.create", args_create_path)
        bank_path = '\\SoundBanks' + cur_event_path[7:]
    # 不在同一路径下时以Default Work Unit为默认路径
    else:
        bank_path = "\\SoundBanks\\Default Work Unit"

    # 创建Bank
    args_create_bank = {
        "parent": bank_path,
        "type": "SoundBank",
        "name": "ALL_IN_ONE",
        "onNameConflict": "rename"
    }
    result_bank_id = client.call("ak.wwise.core.object.create", args_create_bank).get('id')
    # 将选中的所有Event添加至Bank
    for object_id in object_ids:
        args_bank_add = {
            "soundbank": result_bank_id,
            "operation": "add",
            "inclusions": [
                {
                    "object": object_id,
                    "filter": [
                        "events"
                    ]
                }
            ]
        }
        client.call("ak.wwise.core.soundbank.setInclusions", args_bank_add)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# 搜索xml中未使用的音频文件（对比<StreamedFiles>标签下的文件和<SoundBanksRoot>指向路径下的文件）
def search_unused_files(path):
    soundbank_data = parse(path)
    root_node = soundbank_data.documentElement
    root_path = root_node.getElementsByTagName('SoundBanksRoot')[0].childNodes[0].data
    file_list_used = []
    file_list_unused = []
    file_abspath_list_unused = []

    nodes = root_node.getElementsByTagName('SoundBanks')
    for node in nodes:
        events = node.getElementsByTagName('IncludedEvents')
        for event in events:
            streamedFiles = event.getElementsByTagName('ReferencedStreamedFiles')
            for streamedFile in streamedFiles:
                files = streamedFile.getElementsByTagName('File')
                for file in files:
                    file_id = str(file.getAttribute('Id'))
                    # 不同bank可能引用同一wem，去重复
                    if file_list_used.count(file_id) == 0:
                        file_list_used.append(file_id)

            memoryFiles = event.getElementsByTagName('IncludedMemoryFiles')
            for memoryFile in memoryFiles:
                files = memoryFile.getElementsByTagName('File')
                for file in files:
                    file_id = str(file.getAttribute('Id'))
                    # 不同bank可能引用同一wem，去重复
                    if file_list_used.count(file_id) == 0:
                        file_list_used.append(file_id)

    # 读取<SoundBanksRoot>标签指向的路径下所有wem文件的路径
    for root, dirs, files in os.walk(root_path):
        for file in files:
            base_name, ext = os.path.splitext(file)
            if ext == ".wem":
                if file_list_used.count(base_name) == 0:
                    file_list_unused.append(file)
                    file_abspath_list_unused.append(os.path.join(root, file))

    return file_list_unused, file_abspath_list_unused

1
2
3
4
5
6
7
8
9
10
11
# 获取当前Wwise版本
info_result = client.call("ak.wwise.core.getInfo").get('version')['displayName']
wwise_version = int(info_result.replace('v', '')[:4])

···

# 根据Wwise版本选择对应方法
if wwise_version < 2021:
    wwu()
else:
    waql()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
# 获取当前工程路径
args_project = {
    "from": {
        "ofType": [
            "Project"
        ]
    }
}
opts_project = {
    "return": [
        "name",
        "filePath"
    ]
}
result = client.call("ak.wwise.core.object.get", args_project, options=opts_project)['return'][0]
name = '\\' + result.get('name') + '.wproj'
file_path = result.get('filePath')
project_path = file_path.replace(name, '')  # 工程根路径
originals_path = project_path + '\\Originals'  # 音频源文件路径

# 使用wwu方法（针对低于Wwise 2021的版本）
def wwu():
    wwu_path1 = project_path + '\\Actor-Mixer Hierarchy'
    wwu_path2 = project_path + '\\Interactive Music Hierarchy'
    used_ids = []

    # 遍历包含音频源文件的wwu文件（都在以下两个文件夹内）
    for root, dirs, files in os.walk(wwu_path1):
        for file in files:
            base_name, ext = os.path.splitext(file)
            if ext == ".wwu":
                wwu_data = parse(os.path.join(root, file))
                root_node = wwu_data.documentElement
                nodes = root_node.getElementsByTagName('AudioFileSource')
                for node in nodes:
                    used_ids.append(node.getAttribute('ID'))
    for root, dirs, files in os.walk(wwu_path2):
        for file in files:
            base_name, ext = os.path.splitext(file)
            if ext == ".wwu":
                wwu_data = parse(os.path.join(root, file))
                root_node = wwu_data.documentElement
                nodes = root_node.getElementsByTagName('AudioFileSource')

                for node in nodes:
                    used_ids.append(node.getAttribute('ID'))

    # 根据wwu文件获得项目使用的音频资源的路径
    args_wwu = {
        "from": {
            "id": used_ids
        }
    }
    opts_wwu = {
        "return": [
            "name", "sound:originalWavFilePath"
        ]
    }
    used_paths = []
    wwu_results = client.call("ak.wwise.core.object.get", args_wwu, options=opts_wwu)['return']
    for r in wwu_results:
        used_paths.append(r.get('sound:originalWavFilePath'))
    used_paths = list(set(used_paths))
    if used_paths:
        used_paths = [p.lower() for p in used_paths]  # 对路径小写处理（由于WWAPI的bug，返回的路径大小写会出错）
    unused_paths = get_unused_paths(used_paths)
    gui(unused_paths)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 使用WAQL方法（针对Wwise 2021及以上版本）
def waql():
    args_all_audio = {
        "waql": "$ from type audiofilesource"
    }
    opts_all_audio = {
        "return": [
            "originalWavFilePath",
            "type"
        ]
    }
    results = client.call("ak.wwise.core.object.get", args_all_audio, options=opts_all_audio)['return']

    # 由于返回的result是list嵌套dist，删除插件源等没有音频源的项返回的空字典并将dict转化为list
    while {} in results:
        results.remove({})
    used_paths = []
    for r in results:
        used_paths.append(r.get('originalWavFilePath'))
    used_paths = list(set(used_paths))
    if used_paths:
        used_paths = [p.lower() for p in used_paths]  # 小写处理，理由同上

    unused_paths = get_unused_paths(used_paths)
    gui(unused_paths)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 对比\SFX及\Voices路径下的文件列表和项目已使用的文件列表获得未使用资源的列表
def get_unused_paths(used_paths):
    unused_paths = []
    for root, dirs, files in os.walk(originals_path + '\\SFX'):
        for file in files:
            base_name, ext = os.path.splitext(file)
            if ext == ".wav":
                cur_path = os.path.join(root, file)
                cur_path_lower = cur_path.lower()
                if used_paths.count(cur_path_lower) == 0:
                    unused_paths.append(cur_path)

    for root, dirs, files in os.walk(originals_path + '\\Voices'):
        for file in files:
            base_name, ext = os.path.splitext(file)
            if ext == ".wav":
                cur_path = os.path.join(root, file)
                cur_path_lower = cur_path.lower()
                if used_paths.count(cur_path_lower) == 0:
                    unused_paths.append(cur_path)

    return unused_paths