class Fragment:
"""
often huge amount of tiny files
"""
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# points into header datas section
self.pointers = Array()
def read(self, stream):
self.io_start = stream.tell()
self.pointers.read(stream, HeaderPointer, 2, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
self.pointers.write(stream, HeaderPointer, 2, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'Fragment [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + ']'
s += '\n * pointers = ' + self.pointers.__repr__()
s += '\n'
return s
class UnknownJointEntry:
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.floats = Array()
def read(self, stream):
self.io_start = stream.tell()
self.floats.read(stream, 'Float', 13, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
self.floats.write(stream, 'Float', 13, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'UnknownJointEntry [Size: ' + str(
self.io_size) + ', Address:' + str(
self.io_start) + '] ' + self.name
s += '\n * floats = ' + self.floats.__repr__()
s += '\n'
return s
class TextureWrapper:
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.info = TextureInfo()
self.textures = Array()
def read(self, stream):
self.io_start = stream.tell()
self.info = stream.read_type(TextureInfo)
self.textures.read(stream, Texture, self.info.texture_count, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_type(self.info)
self.textures.write(stream, Texture, self.info.texture_count, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'TextureWrapper [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + ']'
s += '\n * info = ' + self.info.__repr__()
s += '\n * textures = ' + self.textures.__repr__()
s += '\n'
return s
class MaterialcollectionInfoHeader(GenericHeader):
"""
This reads a whole custom Matcol file
"""
def __init__(self, context, arg=None, template=None):
self.name = ''
super().__init__(context, arg, template)
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.root = MatcolRoot(self.context, None, None)
self.info = RootFrag(self.context, None, None)
self.textures = Array(self.context)
self.layers = Array(self.context)
self.set_defaults()
def set_defaults(self):
self.root = MatcolRoot(self.context, None, None)
self.info = RootFrag(self.context, None, None)
self.textures = Array(self.context)
self.layers = Array(self.context)
def read(self, stream):
self.io_start = stream.tell()
super().read(stream)
self.root = stream.read_type(MatcolRoot, (self.context, None, None))
self.info = stream.read_type(RootFrag, (self.context, None, None))
self.textures.read(stream, Texture, self.info.tex_count, None)
self.layers.read(stream, Layer, self.info.mat_count, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
super().write(stream)
stream.write_type(self.root)
stream.write_type(self.info)
self.textures.write(stream, Texture, self.info.tex_count, None)
self.layers.write(stream, Layer, self.info.mat_count, None)
self.io_size = stream.tell() - self.io_start
def get_info_str(self):
return f'MaterialcollectionInfoHeader [Size: {self.io_size}, Address: {self.io_start}] {self.name}'
def get_fields_str(self):
s = ''
s += super().get_fields_str()
s += f'\n * root = {self.root.__repr__()}'
s += f'\n * info = {self.info.__repr__()}'
s += f'\n * textures = {self.textures.__repr__()}'
s += f'\n * layers = {self.layers.__repr__()}'
return s
def __repr__(self):
s = self.get_info_str()
s += self.get_fields_str()
s += '\n'
return s
class PcJointBone:
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.floats = Array()
def read(self, stream):
self.io_start = stream.tell()
self.floats.read(stream, 'Float', 12, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
self.floats.write(stream, 'Float', 12, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'PcJointBone [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + ']'
s += '\n * floats = ' + self.floats.__repr__()
s += '\n'
return s
class Onefiftytwo:
"""
# equivalent to 38 uints, 152 bytes
"""
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.model_info = CoreModelInfo()
self.some = Array()
def read(self, stream):
self.io_start = stream.tell()
self.model_info = stream.read_type(CoreModelInfo)
self.some.read(stream, 'Uint64', 7, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_type(self.model_info)
self.some.write(stream, 'Uint64', 7, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'Onefiftytwo [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + ']'
s += '\n * model_info = ' + self.model_info.__repr__()
s += '\n * some = ' + self.some.__repr__()
s += '\n'
return s
class Mdl2FourtyInfo:
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# 0, 1, 0, 0, 0
self.unknowns = Array()
def read(self, stream):
self.io_start = stream.tell()
self.unknowns.read(stream, 'Uint64', 5, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
self.unknowns.write(stream, 'Uint64', 5, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'Mdl2FourtyInfo [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + ']'
s += '\n * unknowns = ' + self.unknowns.__repr__()
s += '\n'
return s
class LayeredWrapper:
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.info = MaterialInfo()
self.layers = Array()
def read(self, stream):
self.io_start = stream.tell()
self.info = stream.read_type(MaterialInfo)
self.layers.read(stream, Layer, self.info.material_count, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_type(self.info)
self.layers.write(stream, Layer, self.info.material_count, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'LayeredWrapper [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + ']'
s += '\n * info = ' + self.info.__repr__()
s += '\n * layers = ' + self.layers.__repr__()
s += '\n'
return s
class VariantWrapper:
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.info = MaterialInfo()
self.materials = Array()
def read(self, stream):
self.io_start = stream.tell()
self.info = stream.read_type(MaterialInfo)
self.materials.read(stream, 'ZString', self.info.material_count, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_type(self.info)
self.materials.write(stream, 'ZString', self.info.material_count, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'VariantWrapper [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + '] ' + self.name
s += '\n * info = ' + self.info.__repr__()
s += '\n * materials = ' + self.materials.__repr__()
s += '\n'
return s
class Ms2SizedStrData:
"""
Read at the entry point of the sized str entry for the ms2. Seems to be the 'root header' of the ms2.
"""
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# 32 if PC, 47 if JWE, 48 if PZ
self.ms_2_version = 0
# seems likely, 1 if yes, 0 if no
self.has_model_data = 0
# 3 in stairwell
self.mdl_2_count = 0
# count of names in ms2 buffer0
self.name_count = 0
# seems to be zeros
self.unknown_1 = Array()
def read(self, stream):
self.io_start = stream.tell()
self.ms_2_version = stream.read_uint()
stream.ms_2_version = self.ms_2_version
self.has_model_data = stream.read_ushort()
self.mdl_2_count = stream.read_ushort()
self.name_count = stream.read_uint()
self.unknown_1.read(stream, 'Uint', 3, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_uint(self.ms_2_version)
stream.ms_2_version = self.ms_2_version
stream.write_ushort(self.has_model_data)
stream.write_ushort(self.mdl_2_count)
stream.write_uint(self.name_count)
self.unknown_1.write(stream, 'Uint', 3, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'Ms2SizedStrData [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + ']'
s += '\n * ms_2_version = ' + self.ms_2_version.__repr__()
s += '\n * has_model_data = ' + self.has_model_data.__repr__()
s += '\n * mdl_2_count = ' + self.mdl_2_count.__repr__()
s += '\n * name_count = ' + self.name_count.__repr__()
s += '\n * unknown_1 = ' + self.unknown_1.__repr__()
s += '\n'
return s
class DependencyEntry:
"""
Description of dependency; links it to an entry from this archive
"""
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# Hash of this dependency, for lookup in hash dict. Can be either external or internal.
self.file_hash = 0
# offset for extension into string name table
self.offset = 0
# index into ovl file table, points to the file entry where this dependency is used
self.file_index = 0
# pointer into flattened list of all archives' pools
self.pointers = Array()
def read(self, stream):
self.io_start = stream.tell()
self.file_hash = stream.read_uint()
self.offset = stream.read_uint()
self.file_index = stream.read_uint()
self.pointers.read(stream, HeaderPointer, 1, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_uint(self.file_hash)
stream.write_uint(self.offset)
stream.write_uint(self.file_index)
self.pointers.write(stream, HeaderPointer, 1, None)
self.io_size = stream.tell() - self.io_start
def get_info_str(self):
return f'DependencyEntry [Size: {self.io_size}, Address: {self.io_start}] {self.name}'
def get_fields_str(self):
s = ''
s += f'\n * file_hash = {self.file_hash.__repr__()}'
s += f'\n * offset = {self.offset.__repr__()}'
s += f'\n * file_index = {self.file_index.__repr__()}'
s += f'\n * pointers = {self.pointers.__repr__()}'
return s
def __repr__(self):
s = self.get_info_str()
s += self.get_fields_str()
s += '\n'
return s
class JointInfo(CommonJointInfo):
def __init__(self, context, arg=None, template=None):
self.name = ''
super().__init__(context, arg, template)
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# 8 bytes of zeros
self.zero = 0
# 8 bytes of zeros per hitcheck
self.zeros_per_hitcheck = numpy.zeros((self.hitcheck_count),
dtype='uint64')
self.hitchecks = Array(self.context)
self.set_defaults()
def set_defaults(self):
self.zero = 0
self.zeros_per_hitcheck = numpy.zeros((self.hitcheck_count),
dtype='uint64')
self.hitchecks = Array(self.context)
def read(self, stream):
self.io_start = stream.tell()
super().read(stream)
self.zero = stream.read_uint64()
self.zeros_per_hitcheck = stream.read_uint64s((self.hitcheck_count))
self.hitchecks.read(stream, HitCheckEntry, self.hitcheck_count, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
super().write(stream)
stream.write_uint64(self.zero)
stream.write_uint64s(self.zeros_per_hitcheck)
self.hitchecks.write(stream, HitCheckEntry, self.hitcheck_count, None)
self.io_size = stream.tell() - self.io_start
def get_info_str(self):
return f'JointInfo [Size: {self.io_size}, Address: {self.io_start}] {self.name}'
def get_fields_str(self):
s = ''
s += super().get_fields_str()
s += f'\n * zero = {self.zero.__repr__()}'
s += f'\n * zeros_per_hitcheck = {self.zeros_per_hitcheck.__repr__()}'
s += f'\n * hitchecks = {self.hitchecks.__repr__()}'
return s
def __repr__(self):
s = self.get_info_str()
s += self.get_fields_str()
s += '\n'
return s
class SetHeader:
"""
defines amount of sets and assets
(not a struct in barbasol)
"""
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.set_count = 0
self.asset_count = 0
# must be 1065336831
self.sig_a = 0
# must be 16909320
self.sig_b = 0
self.sets = Array()
self.assets = Array()
def read(self, stream):
self.io_start = stream.tell()
self.set_count = stream.read_uint()
self.asset_count = stream.read_uint()
self.sig_a = stream.read_uint()
self.sig_b = stream.read_uint()
self.sets.read(stream, SetEntry, self.set_count, None)
self.assets.read(stream, AssetEntry, self.asset_count, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_uint(self.set_count)
stream.write_uint(self.asset_count)
stream.write_uint(self.sig_a)
stream.write_uint(self.sig_b)
self.sets.write(stream, SetEntry, self.set_count, None)
self.assets.write(stream, AssetEntry, self.asset_count, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'SetHeader [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + '] ' + self.name
s += '\n * set_count = ' + self.set_count.__repr__()
s += '\n * asset_count = ' + self.asset_count.__repr__()
s += '\n * sig_a = ' + self.sig_a.__repr__()
s += '\n * sig_b = ' + self.sig_b.__repr__()
s += '\n * sets = ' + self.sets.__repr__()
s += '\n * assets = ' + self.assets.__repr__()
s += '\n'
return s
class HIRCSection:
"""
The HIRC section contains all the Wwise objects, including the events, the containers to group sounds, and the references to the sound files.
"""
context = ContextReference()
def __init__(self, context, arg=None, template=None):
self.name = ''
self._context = context
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# length of following data
self.length = 0
self.count = 0
self.hirc_pointers = Array(self.context)
self.set_defaults()
def set_defaults(self):
self.length = 0
self.count = 0
self.hirc_pointers = Array(self.context)
def read(self, stream):
self.io_start = stream.tell()
self.length = stream.read_uint()
self.count = stream.read_uint()
self.hirc_pointers.read(stream, HircPointer, self.count, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_uint(self.length)
stream.write_uint(self.count)
self.hirc_pointers.write(stream, HircPointer, self.count, None)
self.io_size = stream.tell() - self.io_start
def get_info_str(self):
return f'HIRCSection [Size: {self.io_size}, Address: {self.io_start}] {self.name}'
def get_fields_str(self):
s = ''
s += f'\n * length = {self.length.__repr__()}'
s += f'\n * count = {self.count.__repr__()}'
s += f'\n * hirc_pointers = {self.hirc_pointers.__repr__()}'
return s
def __repr__(self):
s = self.get_info_str()
s += self.get_fields_str()
s += '\n'
return s
class BufferInfoZTHeader:
"""
Data describing a MS2 buffer giving the size of the whole vertex and tri buffer.
266 bytes
very end of buffer 0 after the names list
"""
context = ContextReference()
def __init__(self, context, arg=None, template=None):
self.name = ''
self._context = context
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# sometimes 00 byte
self.weird_padding = SmartPadding(self.context, None, None)
# ?
self.unks = Array(self.context)
self.set_defaults()
def set_defaults(self):
self.weird_padding = SmartPadding(self.context, None, None)
self.unks = Array(self.context)
def read(self, stream):
self.io_start = stream.tell()
self.weird_padding = stream.read_type(SmartPadding,
(self.context, None, None))
self.unks.read(stream, InfoZTMemPool, self.arg.unk_count, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_type(self.weird_padding)
self.unks.write(stream, InfoZTMemPool, self.arg.unk_count, None)
self.io_size = stream.tell() - self.io_start
def get_info_str(self):
return f'BufferInfoZTHeader [Size: {self.io_size}, Address: {self.io_start}] {self.name}'
def get_fields_str(self):
s = ''
s += f'\n * weird_padding = {self.weird_padding.__repr__()}'
s += f'\n * unks = {self.unks.__repr__()}'
return s
def __repr__(self):
s = self.get_info_str()
s += self.get_fields_str()
s += '\n'
return s
class TextureInfo:
"""
part of fgm fragment, per texture involved
"""
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# byte offset to name in fgm buffer
self.offset = 0
# 7=has 2 8=uses texture indices
self.is_textured = 0
# stores index into shader and array index of texture
self.indices = Array()
# Stores (usually) 2 rgba colors
self.colors = Array()
def read(self, stream):
self.io_start = stream.tell()
self.offset = stream.read_uint()
self.is_textured = stream.read_uint()
if self.is_textured == 8:
self.indices.read(stream, 'Uint', 4, None)
if self.is_textured == 7:
self.colors.read(stream, Color, 4, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_uint(self.offset)
stream.write_uint(self.is_textured)
if self.is_textured == 8:
self.indices.write(stream, 'Uint', 4, None)
if self.is_textured == 7:
self.colors.write(stream, Color, 4, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'TextureInfo [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + ']'
s += '\n * offset = ' + self.offset.__repr__()
s += '\n * is_textured = ' + self.is_textured.__repr__()
s += '\n * indices = ' + self.indices.__repr__()
s += '\n * colors = ' + self.colors.__repr__()
s += '\n'
return s
class Layer:
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.name = 0
self.info_info = LayeredInfo()
self.infos = Array()
self.attrib_info = LayeredAttrib()
self.attribs = Array()
def read(self, stream):
self.io_start = stream.tell()
self.name = stream.read_zstring()
self.info_info = stream.read_type(LayeredInfo)
self.infos.read(stream, InfoWrapper, self.info_info.info_count, None)
self.attrib_info = stream.read_type(LayeredAttrib)
self.attribs.read(stream, AttribWrapper, self.attrib_info.attrib_count,
None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_zstring(self.name)
stream.write_type(self.info_info)
self.infos.write(stream, InfoWrapper, self.info_info.info_count, None)
stream.write_type(self.attrib_info)
self.attribs.write(stream, AttribWrapper,
self.attrib_info.attrib_count, None)
self.io_size = stream.tell() - self.io_start
def get_info_str(self):
return f'Layer [Size: {self.io_size}, Address: {self.io_start}] {self.name}'
def get_fields_str(self):
s = ''
s += f'\n * name = {self.name.__repr__()}'
s += f'\n * info_info = {self.info_info.__repr__()}'
s += f'\n * infos = {self.infos.__repr__()}'
s += f'\n * attrib_info = {self.attrib_info.__repr__()}'
s += f'\n * attribs = {self.attribs.__repr__()}'
return s
def __repr__(self):
s = self.get_info_str()
s += self.get_fields_str()
s += '\n'
return s
class DIDXSection:
"""
second Section of a soundback aux
"""
context = ContextReference()
def __init__(self, context, arg=None, template=None):
self.name = ''
self._context = context
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# length of following data
self.length = 0
self.data_pointers = Array(self.context)
self.set_defaults()
def set_defaults(self):
self.length = 0
self.data_pointers = Array(self.context)
def read(self, stream):
self.io_start = stream.tell()
self.length = stream.read_uint()
self.data_pointers.read(stream, DataPointer, int(self.length / 12),
None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_uint(self.length)
self.data_pointers.write(stream, DataPointer, int(self.length / 12),
None)
self.io_size = stream.tell() - self.io_start
def get_info_str(self):
return f'DIDXSection [Size: {self.io_size}, Address: {self.io_start}] {self.name}'
def get_fields_str(self):
s = ''
s += f'\n * length = {self.length.__repr__()}'
s += f'\n * data_pointers = {self.data_pointers.__repr__()}'
return s
def __repr__(self):
s = self.get_info_str()
s += self.get_fields_str()
s += '\n'
return s
class Fragment:
"""
These are to be thought of as instructions for loading.
Their order is irrelevant.
pointers[0] determines where to write a pointer
pointers[1] describes the address that is written at pointers[0]
"""
context = ContextReference()
def __init__(self, context, arg=None, template=None):
self.name = ''
self._context = context
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# points into pools
self.pointers = Array(self.context)
self.set_defaults()
def set_defaults(self):
self.pointers = Array(self.context)
def read(self, stream):
self.io_start = stream.tell()
self.pointers.read(stream, HeaderPointer, 2, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
self.pointers.write(stream, HeaderPointer, 2, None)
self.io_size = stream.tell() - self.io_start
def get_info_str(self):
return f'Fragment [Size: {self.io_size}, Address: {self.io_start}] {self.name}'
def get_fields_str(self):
s = ''
s += f'\n * pointers = {self.pointers.__repr__()}'
return s
def __repr__(self):
s = self.get_info_str()
s += self.get_fields_str()
s += '\n'
return s
class PcBuffer1:
"""
cond="general info \ ms2 version == 32"
"""
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.whatever = Array()
self.model_infos = Array()
# the padding between end of the modelinfo array and start of lodinfos
self.some_zero = 0
def read(self, stream):
self.io_start = stream.tell()
self.whatever = stream.read_uints((8))
self.model_infos.read(stream, Onefiftytwo, self.arg.mdl_2_count, None)
self.some_zero = stream.read_uint()
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_uints(self.whatever)
self.model_infos.write(stream, Onefiftytwo, self.arg.mdl_2_count, None)
stream.write_uint(self.some_zero)
self.io_size = stream.tell() - self.io_start
def get_info_str(self):
return f'PcBuffer1 [Size: {self.io_size}, Address: {self.io_start}] {self.name}'
def get_fields_str(self):
s = ''
s += f'\n * whatever = {self.whatever.__repr__()}'
s += f'\n * model_infos = {self.model_infos.__repr__()}'
s += f'\n * some_zero = {self.some_zero.__repr__()}'
return s
def __repr__(self):
s = self.get_info_str()
s += self.get_fields_str()
s += '\n'
return s
class PcJointNext:
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# 11, then 11 FFs
self.eleven_ff_stuff = PcFFCounter()
# usually 1F AA FF AA FF
self.undecoded = Array()
# start address in zstr buffer
self.name_address = 0
# 1, 0, 0, 0
self.uints = Array()
def read(self, stream):
self.io_start = stream.tell()
self.eleven_ff_stuff = stream.read_type(PcFFCounter)
self.undecoded.read(stream, 'Byte', 5, None)
self.name_address = stream.read_uint()
self.uints.read(stream, 'Uint', 4, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_type(self.eleven_ff_stuff)
self.undecoded.write(stream, 'Byte', 5, None)
stream.write_uint(self.name_address)
self.uints.write(stream, 'Uint', 4, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'PcJointNext [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + '] ' + self.name
s += '\n * eleven_ff_stuff = ' + self.eleven_ff_stuff.__repr__()
s += '\n * undecoded = ' + self.undecoded.__repr__()
s += '\n * name_address = ' + self.name_address.__repr__()
s += '\n * uints = ' + self.uints.__repr__()
s += '\n'
return s
class BaniInfoHeader: """ Custom header struct includes fragments but none of the 3 data buffers """ def __init__(self, arg=None, template=None): self.arg = arg self.template = template self.io_size = 0 self.io_start = 0 # 'BANI' self.magic = Array() # name of the banis file buffer self.banis_name = 0 self.data_0 = BaniFragmentData0() self.data_1 = BaniFragmentData1() def read(self, stream): self.io_start = stream.tell() self.magic.read(stream, 'Byte', 4, None) self.banis_name = stream.read_string() self.data_0 = stream.read_type(BaniFragmentData0) self.data_1 = stream.read_type(BaniFragmentData1) self.io_size = stream.tell() - self.io_start def write(self, stream): self.io_start = stream.tell() self.magic.write(stream, 'Byte', 4, None) stream.write_string(self.banis_name) stream.write_type(self.data_0) stream.write_type(self.data_1) self.io_size = stream.tell() - self.io_start def __repr__(self): s = 'BaniInfoHeader [Size: '+str(self.io_size)+', Address:'+str(self.io_start)+']' s += '\n * magic = ' + self.magic.__repr__() s += '\n * banis_name = ' + self.banis_name.__repr__() s += '\n * data_0 = ' + self.data_0.__repr__() s += '\n * data_1 = ' + self.data_1.__repr__() s += '\n' return s
class SizedStringEntry: """ points to a sized string in a header's data block """ def __init__(self, arg=None, template=None): self.name = '' self.arg = arg self.template = template self.io_size = 0 self.io_start = 0 # hash of the file that should be read self.file_hash = 0 # matches matching HeaderEntry's Ext Hash self.ext_hash = 0 # points into header datas section self.pointers = Array() def read(self, stream): self.io_start = stream.tell() self.file_hash = stream.read_uint() if (((stream.user_version == 24724) or (stream.user_version == 25108)) and ((stream.version == 19) and (stream.version_flag == 1))) or ((((stream.user_version == 8340) or (stream.user_version == 8724)) and (stream.version == 19)) or (((stream.user_version == 24724) or (stream.user_version == 25108)) and ((stream.version == 19) and (stream.version_flag == 8)))): self.ext_hash = stream.read_uint() self.pointers.read(stream, HeaderPointer, 1, None) self.io_size = stream.tell() - self.io_start def write(self, stream): self.io_start = stream.tell() stream.write_uint(self.file_hash) if (((stream.user_version == 24724) or (stream.user_version == 25108)) and ((stream.version == 19) and (stream.version_flag == 1))) or ((((stream.user_version == 8340) or (stream.user_version == 8724)) and (stream.version == 19)) or (((stream.user_version == 24724) or (stream.user_version == 25108)) and ((stream.version == 19) and (stream.version_flag == 8)))): stream.write_uint(self.ext_hash) self.pointers.write(stream, HeaderPointer, 1, None) self.io_size = stream.tell() - self.io_start def __repr__(self): s = 'SizedStringEntry [Size: '+str(self.io_size)+', Address:'+str(self.io_start)+'] ' + self.name s += '\n * file_hash = ' + self.file_hash.__repr__() s += '\n * ext_hash = ' + self.ext_hash.__repr__() s += '\n * pointers = ' + self.pointers.__repr__() s += '\n' return s
class BufferInfoZT:
"""
from here on, it's buffer 1
"""
context = ContextReference()
def __init__(self, context, arg=None, template=None):
self.name = ''
self._context = context
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.streams = Array(self.context)
self.set_defaults()
def set_defaults(self):
self.streams = Array(self.context)
def read(self, stream):
self.io_start = stream.tell()
self.streams.read(stream, StreamInfo, self.arg, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
self.streams.write(stream, StreamInfo, self.arg, None)
self.io_size = stream.tell() - self.io_start
def get_info_str(self):
return f'BufferInfoZT [Size: {self.io_size}, Address: {self.io_start}] {self.name}'
def get_fields_str(self):
s = ''
s += f'\n * streams = {self.streams.__repr__()}'
return s
def __repr__(self):
s = self.get_info_str()
s += self.get_fields_str()
s += '\n'
return s
class ManisSizedStrData:
"""
per attribute
"""
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# 96 in driver
self.unknown_0 = 0
# 272 in driver
self.unknown_1 = 0
# zeros in driver
self.unknown_2 = Array()
def read(self, stream):
self.io_start = stream.tell()
self.unknown_0 = stream.read_ushort()
self.unknown_1 = stream.read_ushort()
self.unknown_2.read(stream, 'Uint', 5, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_ushort(self.unknown_0)
stream.write_ushort(self.unknown_1)
self.unknown_2.write(stream, 'Uint', 5, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'ManisSizedStrData [Size: ' + str(
self.io_size) + ', Address:' + str(self.io_start) + ']'
s += '\n * unknown_0 = ' + self.unknown_0.__repr__()
s += '\n * unknown_1 = ' + self.unknown_1.__repr__()
s += '\n * unknown_2 = ' + self.unknown_2.__repr__()
s += '\n'
return s
class Header3Data1Ztuac:
"""
Data struct for headers of type 7
"""
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.lods = Array()
# ?not sure if this isn't just junk data
self.data_size = 0
def read(self, stream):
self.io_start = stream.tell()
self.lods.read(stream, Header3Data1ZTUACEntry, self.arg, None)
self.data_size = stream.read_ushort()
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
self.lods.write(stream, Header3Data1ZTUACEntry, self.arg, None)
stream.write_ushort(self.data_size)
self.io_size = stream.tell() - self.io_start
def get_info_str(self):
return f'Header3Data1Ztuac [Size: {self.io_size}, Address: {self.io_start}] {self.name}'
def get_fields_str(self):
s = ''
s += f'\n * lods = {self.lods.__repr__()}'
s += f'\n * data_size = {self.data_size.__repr__()}'
return s
def __repr__(self):
s = self.get_info_str()
s += self.get_fields_str()
s += '\n'
return s
class Info:
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.zero_0 = 0
self.zero_1 = 0
self.flags = Array()
self.value = Array()
self.zero_3 = 0
def read(self, stream):
self.io_start = stream.tell()
self.zero_0 = stream.read_uint()
self.zero_1 = stream.read_uint()
self.flags.read(stream, 'Byte', 4, None)
self.value.read(stream, 'Float', 4, None)
self.zero_3 = stream.read_uint()
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_uint(self.zero_0)
stream.write_uint(self.zero_1)
self.flags.write(stream, 'Byte', 4, None)
self.value.write(stream, 'Float', 4, None)
stream.write_uint(self.zero_3)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'Info [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + '] ' + self.name
s += '\n * zero_0 = ' + self.zero_0.__repr__()
s += '\n * zero_1 = ' + self.zero_1.__repr__()
s += '\n * flags = ' + self.flags.__repr__()
s += '\n * value = ' + self.value.__repr__()
s += '\n * zero_3 = ' + self.zero_3.__repr__()
s += '\n'
return s
class Layer: def __init__(self, arg=None, template=None): self.arg = arg self.template = template self.io_size = 0 self.io_start = 0 self.name = 0 self.info_info = LayeredInfo() self.infos = Array() self.attrib_info = LayeredAttrib() self.attribs = Array() def read(self, stream): self.io_start = stream.tell() self.name = stream.read_zstring() self.info_info = stream.read_type(LayeredInfo) self.infos.read(stream, InfoWrapper, self.info_info.info_count, None) self.attrib_info = stream.read_type(LayeredAttrib) self.attribs.read(stream, AttribWrapper, self.attrib_info.attrib_count, None) self.io_size = stream.tell() - self.io_start def write(self, stream): self.io_start = stream.tell() stream.write_zstring(self.name) stream.write_type(self.info_info) self.infos.write(stream, InfoWrapper, self.info_info.info_count, None) stream.write_type(self.attrib_info) self.attribs.write(stream, AttribWrapper, self.attrib_info.attrib_count, None) self.io_size = stream.tell() - self.io_start def __repr__(self): s = 'Layer [Size: '+str(self.io_size)+', Address:'+str(self.io_start)+']' s += '\n * name = ' + self.name.__repr__() s += '\n * info_info = ' + self.info_info.__repr__() s += '\n * infos = ' + self.infos.__repr__() s += '\n * attrib_info = ' + self.attrib_info.__repr__() s += '\n * attribs = ' + self.attribs.__repr__() s += '\n' return s
class HIRCSection: """ The HIRC section contains all the Wwise objects, including the events, the containers to group sounds, and the references to the sound files. """ def __init__(self, arg=None, template=None): self.name = '' self.arg = arg self.template = template self.io_size = 0 self.io_start = 0 # length of following data self.length = 0 self.count = 0 self.hirc_pointers = Array() def read(self, stream): self.io_start = stream.tell() self.length = stream.read_uint() self.count = stream.read_uint() self.hirc_pointers.read(stream, HircPointer, self.count, None) self.io_size = stream.tell() - self.io_start def write(self, stream): self.io_start = stream.tell() stream.write_uint(self.length) stream.write_uint(self.count) self.hirc_pointers.write(stream, HircPointer, self.count, None) self.io_size = stream.tell() - self.io_start def __repr__(self): s = 'HIRCSection [Size: '+str(self.io_size)+', Address:'+str(self.io_start)+'] ' + self.name s += '\n * length = ' + self.length.__repr__() s += '\n * count = ' + self.count.__repr__() s += '\n * hirc_pointers = ' + self.hirc_pointers.__repr__() s += '\n' return s
class PcBuffer1: """ cond="general info \ ms2 version == 32" """ def __init__(self, arg=None, template=None): self.arg = arg self.template = template self.io_size = 0 self.io_start = 0 self.whatever = Array() self.model_infos = Array() # the padding between end of the modelinfo array and start of lodinfos self.some_zero = 0 def read(self, stream): self.io_start = stream.tell() self.whatever.read(stream, 'Uint', 8, None) self.model_infos.read(stream, Onefiftytwo, self.arg.mdl_2_count, None) self.some_zero = stream.read_uint() self.io_size = stream.tell() - self.io_start def write(self, stream): self.io_start = stream.tell() self.whatever.write(stream, 'Uint', 8, None) self.model_infos.write(stream, Onefiftytwo, self.arg.mdl_2_count, None) stream.write_uint(self.some_zero) self.io_size = stream.tell() - self.io_start def __repr__(self): s = 'PcBuffer1 [Size: '+str(self.io_size)+', Address:'+str(self.io_start)+']' s += '\n * whatever = ' + self.whatever.__repr__() s += '\n * model_infos = ' + self.model_infos.__repr__() s += '\n * some_zero = ' + self.some_zero.__repr__() s += '\n' return s
