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 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 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 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 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 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 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 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 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 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 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 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 PcModel:
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.lod_infos = Array()
self.materials_1 = Array()
self.model_data = Array()
def read(self, stream):
self.io_start = stream.tell()
self.lod_infos.read(stream, LodInfo, self.arg.model_info.lod_count,
None)
self.materials_1.read(stream, Material1,
self.arg.model_info.mat_1_count, None)
self.model_data.read(stream, PcModelData,
self.arg.model_info.model_count, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
self.lod_infos.write(stream, LodInfo, self.arg.model_info.lod_count,
None)
self.materials_1.write(stream, Material1,
self.arg.model_info.mat_1_count, None)
self.model_data.write(stream, PcModelData,
self.arg.model_info.model_count, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'PcModel [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + '] ' + self.name
s += '\n * lod_infos = ' + self.lod_infos.__repr__()
s += '\n * materials_1 = ' + self.materials_1.__repr__()
s += '\n * model_data = ' + self.model_data.__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
class Repeat:
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.zeros_0 = Array()
# to be read sequentially starting after this array
self.byte_size = 0
self.zeros_1 = Array()
def read(self, stream):
self.io_start = stream.tell()
self.zeros_0.read(stream, 'Uint', 15, None)
self.byte_size = stream.read_uint()
self.zeros_1.read(stream, 'Uint', 4, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
self.zeros_0.write(stream, 'Uint', 15, None)
stream.write_uint(self.byte_size)
self.zeros_1.write(stream, 'Uint', 4, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'Repeat [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + '] ' + self.name
s += '\n * zeros_0 = ' + self.zeros_0.__repr__()
s += '\n * byte_size = ' + self.byte_size.__repr__()
s += '\n * zeros_1 = ' + self.zeros_1.__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 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 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 SizedStrData:
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.a = 0
self.hash_block_size = 0
self.zeros = Array()
self.c = 0
def read(self, stream):
self.io_start = stream.tell()
self.a = stream.read_ushort()
self.hash_block_size = stream.read_ushort()
self.zeros.read(stream, 'Int', 2, None)
self.c = stream.read_ushort()
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_ushort(self.a)
stream.write_ushort(self.hash_block_size)
self.zeros.write(stream, 'Int', 2, None)
stream.write_ushort(self.c)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'SizedStrData [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + '] ' + self.name
s += '\n * a = ' + self.a.__repr__()
s += '\n * hash_block_size = ' + self.hash_block_size.__repr__()
s += '\n * zeros = ' + self.zeros.__repr__()
s += '\n * c = ' + self.c.__repr__()
s += '\n'
return s
class Attrib:
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.attrib = Array()
self.zero_2 = 0
def read(self, stream):
self.io_start = stream.tell()
self.zero_0 = stream.read_uint()
self.zero_1 = stream.read_uint()
self.attrib.read(stream, 'Byte', 4, None)
self.zero_2 = 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.attrib.write(stream, 'Byte', 4, None)
stream.write_uint(self.zero_2)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'Attrib [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 * attrib = ' + self.attrib.__repr__()
s += '\n * zero_2 = ' + self.zero_2.__repr__()
s += '\n'
return s
class TypeOther:
"""
generic
"""
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 this section
self.length = 0
# id of this Sound SFX object
self.raw = Array()
def read(self, stream):
self.io_start = stream.tell()
self.length = stream.read_uint()
self.raw.read(stream, 'Byte', self.length, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_uint(self.length)
self.raw.write(stream, 'Byte', self.length, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'TypeOther [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + '] ' + self.name
s += '\n * length = ' + self.length.__repr__()
s += '\n * raw = ' + self.raw.__repr__()
s += '\n'
return s
class SizedString:
"""
A string of given length.
"""
def __init__(self, arg=None, template=None):
self.name = ''
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# The string length.
self.length = 0
# The string itself.
self.value = Array()
def read(self, stream):
self.io_start = stream.tell()
self.length = stream.read_uint()
self.value.read(stream, 'Char', self.length, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_uint(self.length)
self.value.write(stream, 'Char', self.length, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'SizedString [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + '] ' + self.name
s += '\n * length = ' + self.length.__repr__()
s += '\n * value = ' + self.value.__repr__()
s += '\n'
return s
class DIDXSection:
"""
second Section of a soundback aux
"""
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.data_pointers = Array()
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 __repr__(self):
s = 'DIDXSection [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + '] ' + self.name
s += '\n * length = ' + self.length.__repr__()
s += '\n * data_pointers = ' + self.data_pointers.__repr__()
s += '\n'
return s
class DATASection:
"""
second Section of a soundback aux
"""
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# length of following data
self.length = 0
self.wem_files_datas = Array()
def read(self, stream):
self.io_start = stream.tell()
self.length = stream.read_uint()
self.wem_files_datas.read(stream, 'Byte', self.length, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
stream.write_uint(self.length)
self.wem_files_datas.write(stream, 'Byte', self.length, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'DATASection [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + ']'
s += '\n * length = ' + self.length.__repr__()
s += '\n * wem_files_datas = ' + self.wem_files_datas.__repr__()
s += '\n'
return s
class PcFFCounter: """ count is nonzero in PZ broken birch model """ def __init__(self, arg=None, template=None): self.name = '' self.arg = arg self.template = template self.io_size = 0 self.io_start = 0 self.count = 0 self.f_fs = Array() def read(self, stream): self.io_start = stream.tell() self.count = stream.read_uint() self.f_fs.read(stream, 'Byte', self.count, None) self.io_size = stream.tell() - self.io_start def write(self, stream): self.io_start = stream.tell() stream.write_uint(self.count) self.f_fs.write(stream, 'Byte', self.count, None) self.io_size = stream.tell() - self.io_start def __repr__(self): s = 'PcFFCounter [Size: '+str(self.io_size)+', Address:'+str(self.io_start)+'] ' + self.name s += '\n * count = ' + self.count.__repr__() s += '\n * f_fs = ' + self.f_fs.__repr__() s += '\n' return s
class ManiBlock:
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
self.indices_0 = Array()
self.indices_0 = Array()
self.indices_1 = Array()
self.indices_1 = Array()
self.indices_2 = Array()
self.indices_2 = Array()
self.p_indices_0 = Array()
self.p_indices_1 = Array()
self.p_indices_2 = Array()
self.c_indices_0 = Array()
self.c_indices_1 = Array()
self.c_indices_2 = Array()
self.zero = 0
# likely
self.frame_count = 0
self.c = 0
self.e = 0
# fixed
self.zeros = Array()
self.zeros = Array()
self.count = 0
# usually / always 420
self.four_and_twenty = 0
self.pad_to_8 = Array()
# these are likely a scale reference or factor
self.floats = Array()
self.repeats = Array()
def read(self, stream):
self.io_start = stream.tell()
if stream.version == 18:
self.indices_0.read(stream, 'Ushort', self.arg.c, None)
if not (stream.version == 18):
self.indices_0.read(stream, 'Uint', self.arg.c, None)
if stream.version == 18:
self.indices_1.read(stream, 'Ushort', self.arg.name_count, None)
if not (stream.version == 18):
self.indices_1.read(stream, 'Uint', self.arg.name_count, None)
if stream.version == 18:
self.indices_2.read(stream, 'Ushort', self.arg.e, None)
if not (stream.version == 18):
self.indices_2.read(stream, 'Uint', self.arg.e, None)
self.p_indices_0.read(stream, 'Ubyte', self.arg.c, None)
self.p_indices_1.read(stream, 'Ubyte', self.arg.name_count, None)
self.p_indices_2.read(stream, 'Ubyte', self.arg.e, None)
if stream.version == 18:
self.c_indices_0.read(stream, 'Ubyte', self.arg.c, None)
self.c_indices_1.read(stream, 'Ubyte', self.arg.name_count, None)
self.c_indices_2.read(stream, 'Ubyte', self.arg.e, None)
self.zero = stream.read_uint64()
self.frame_count = stream.read_uint()
self.c = stream.read_uint()
self.e = stream.read_uint()
self.zeros.read(stream, 'Uint', 19, None)
self.zeros.read(stream, 'Ubyte', self.count, None)
self.count = stream.read_ushort()
self.four_and_twenty = stream.read_ushort()
self.pad_to_8.read(stream, 'Ubyte', (8 - (self.count % 8)) % 8, None)
self.floats.read(stream, 'Float', 6, None)
self.repeats.read(stream, Repeat, self.count, None)
self.io_size = stream.tell() - self.io_start
def write(self, stream):
self.io_start = stream.tell()
if stream.version == 18:
self.indices_0.write(stream, 'Ushort', self.arg.c, None)
if not (stream.version == 18):
self.indices_0.write(stream, 'Uint', self.arg.c, None)
if stream.version == 18:
self.indices_1.write(stream, 'Ushort', self.arg.name_count, None)
if not (stream.version == 18):
self.indices_1.write(stream, 'Uint', self.arg.name_count, None)
if stream.version == 18:
self.indices_2.write(stream, 'Ushort', self.arg.e, None)
if not (stream.version == 18):
self.indices_2.write(stream, 'Uint', self.arg.e, None)
self.p_indices_0.write(stream, 'Ubyte', self.arg.c, None)
self.p_indices_1.write(stream, 'Ubyte', self.arg.name_count, None)
self.p_indices_2.write(stream, 'Ubyte', self.arg.e, None)
if stream.version == 18:
self.c_indices_0.write(stream, 'Ubyte', self.arg.c, None)
self.c_indices_1.write(stream, 'Ubyte', self.arg.name_count, None)
self.c_indices_2.write(stream, 'Ubyte', self.arg.e, None)
stream.write_uint64(self.zero)
stream.write_uint(self.frame_count)
stream.write_uint(self.c)
stream.write_uint(self.e)
self.zeros.write(stream, 'Uint', 19, None)
self.zeros.write(stream, 'Ubyte', self.count, None)
stream.write_ushort(self.count)
stream.write_ushort(self.four_and_twenty)
self.pad_to_8.write(stream, 'Ubyte', (8 - (self.count % 8)) % 8, None)
self.floats.write(stream, 'Float', 6, None)
self.repeats.write(stream, Repeat, self.count, None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'ManiBlock [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + ']'
s += '\n * indices_0 = ' + self.indices_0.__repr__()
s += '\n * indices_1 = ' + self.indices_1.__repr__()
s += '\n * indices_2 = ' + self.indices_2.__repr__()
s += '\n * p_indices_0 = ' + self.p_indices_0.__repr__()
s += '\n * p_indices_1 = ' + self.p_indices_1.__repr__()
s += '\n * p_indices_2 = ' + self.p_indices_2.__repr__()
s += '\n * c_indices_0 = ' + self.c_indices_0.__repr__()
s += '\n * c_indices_1 = ' + self.c_indices_1.__repr__()
s += '\n * c_indices_2 = ' + self.c_indices_2.__repr__()
s += '\n * zero = ' + self.zero.__repr__()
s += '\n * frame_count = ' + self.frame_count.__repr__()
s += '\n * c = ' + self.c.__repr__()
s += '\n * e = ' + self.e.__repr__()
s += '\n * zeros = ' + self.zeros.__repr__()
s += '\n * count = ' + self.count.__repr__()
s += '\n * four_and_twenty = ' + self.four_and_twenty.__repr__()
s += '\n * pad_to_8 = ' + self.pad_to_8.__repr__()
s += '\n * floats = ' + self.floats.__repr__()
s += '\n * repeats = ' + self.repeats.__repr__()
s += '\n'
return s
class InfoHeader:
"""
Custom header struct
"""
def __init__(self, arg=None, template=None):
self.arg = arg
self.template = template
self.io_size = 0
self.io_start = 0
# 'MANI'
self.magic = Array()
self.version = 0
self.flag_2 = 0
self.mani_count = 0
self.names = Array()
self.header = SizedStrData()
self.mani_infos = Array()
self.bone_hashes = Array()
self.bone_names = Array()
def read(self, stream):
self.io_start = stream.tell()
self.magic.read(stream, 'Byte', 4, None)
self.version = stream.read_uint()
stream.version = self.version
self.flag_2 = stream.read_uint()
self.mani_count = stream.read_uint()
self.names.read(stream, 'ZString', self.mani_count, None)
self.header = stream.read_type(SizedStrData)
self.mani_infos.read(stream, ManiInfo, self.mani_count, None)
self.bone_hashes.read(stream, 'Uint',
int(self.header.hash_block_size / 4), None)
self.bone_names.read(stream, 'ZString',
int(self.header.hash_block_size / 4), None)
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_uint(self.version)
stream.version = self.version
stream.write_uint(self.flag_2)
stream.write_uint(self.mani_count)
self.names.write(stream, 'ZString', self.mani_count, None)
stream.write_type(self.header)
self.mani_infos.write(stream, ManiInfo, self.mani_count, None)
self.bone_hashes.write(stream, 'Uint',
int(self.header.hash_block_size / 4), None)
self.bone_names.write(stream, 'ZString',
int(self.header.hash_block_size / 4), None)
self.io_size = stream.tell() - self.io_start
def __repr__(self):
s = 'InfoHeader [Size: ' + str(self.io_size) + ', Address:' + str(
self.io_start) + ']'
s += '\n * magic = ' + self.magic.__repr__()
s += '\n * version = ' + self.version.__repr__()
s += '\n * flag_2 = ' + self.flag_2.__repr__()
s += '\n * mani_count = ' + self.mani_count.__repr__()
s += '\n * names = ' + self.names.__repr__()
s += '\n * header = ' + self.header.__repr__()
s += '\n * mani_infos = ' + self.mani_infos.__repr__()
s += '\n * bone_hashes = ' + self.bone_hashes.__repr__()
s += '\n * bone_names = ' + self.bone_names.__repr__()
s += '\n'
return s
