def read_property(self, stream, hash, tgi):
s = StreamReader(stream)
id = s.u32()
value = None
if not id:
return False
if not s.u8():
t = s.u8()
if t == 0x00: value = bool(s.u8())
elif t == 0x01: value = s.i8()
elif t == 0x02: value = s.i16()
elif t == 0x03: value = s.i32()
elif t == 0x04: value = s.i64()
elif t == 0x05: value = s.u8()
elif t == 0x06: value = s.u16()
elif t == 0x07: value = s.u32()
elif t == 0x08: value = s.u64()
elif t == 0x09: value = s.f32()
elif t == 0x0A: value = [s.f32() for i in range(4)]
elif t == 0x0B: value = [s.f32() for i in range(4)]
elif t == 0x0C: value = tgi.get_resource(s.u8())
elif t == 0x0D: value = s.p16()
else: raise Exception("Unknown TXTC parameter type %s" % t)
hash[id] = value
return True
def read_property(self, stream, hash, tgi):
s = StreamReader(stream)
id = s.u32()
value = None
if not id:
return False
if not s.u8():
t = s.u8()
if t == 0x00: value = bool(s.u8())
elif t == 0x01: value = s.i8()
elif t == 0x02: value = s.i16()
elif t == 0x03: value = s.i32()
elif t == 0x04: value = s.i64()
elif t == 0x05: value = s.u8()
elif t == 0x06: value = s.u16()
elif t == 0x07: value = s.u32()
elif t == 0x08: value = s.u64()
elif t == 0x09: value = s.f32()
elif t == 0x0A: value = [s.f32() for i in range(4)]
elif t == 0x0B: value = [s.f32() for i in range(4)]
elif t == 0x0C: value = tgi.get_resource(s.u8())
elif t == 0x0D: value = s.p16()
else: raise Exception("Unknown TXTC parameter type %s" % t)
hash[id] = value
return True
def read(self, stream, resources=None):
s = StreamReader(stream)
self.version = s.u32()
use_tgi = not isinstance(resources, TGIList)
tgi = resources
if use_tgi:
tgi = TGIList(order='IGT', use_length=False, package=resources, count_size=8)
tgi.begin_read(stream)
if self.version >= 7:
cFabrics = s.i8()
for fabric_index in range(cFabrics):
key = tgi.get_resource(s.u8())
fabric = TextureCompositor(key)
fabric_len = s.u32()
with BytesIO() as fabric_stream:
fabric_stream.write(stream.read(fabric_len))
fabric_stream.seek(0, SEEK_SET)
fabric.read(fabric_stream, tgi)
self.fabrics.append(fabric)
self.target_size = s.u32()
self.part_type = s.u32()
assert s.u8() == 0
cSteps = s.i32()
if self.version >= 0x08:
assert s.u8() == 0
self.steps = []
for step_index in range(cSteps):
self.steps.append(self.read_step(stream, tgi))
if use_tgi:
tgi.end_read(stream)
else:
assert s.u32() == 0
def read(self, stream, resource=None):
s = StreamReader(stream)
self.version = s.u32()
tgi = TGIList(order='igt', count_size=8, package=resource, use_length=False)
tgi.begin_read(stream)
self.presets = [self.CasPreset(stream, tgi) for i in range(s.u32())]
self.part_name = s.s7(16, '>')
self.display_index = s.f32()
self.has_unique_texture_space = s.u8()
self.body_type = s.u32()
self.part_flags = s.u32()
self.age_gender_flags = s.u32()
self.clothing_category = s.u32()
self.naked_cas_part = tgi.get_resource(s.i8())
self.base_cas_part = tgi.get_resource(s.i8())
self.blend_fat = tgi.get_resource(s.i8())
self.blend_fit = tgi.get_resource(s.i8())
self.blend_thin = tgi.get_resource(s.i8())
self.blend_special = tgi.get_resource(s.i8())
self.draw_layer = s.u32()
self.sources = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.lod_infos = [CASLodInfo(stream) for i in range(s.u8())]
self.diffuse_refs = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.specular_refs = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.secondary_diffuse_refs = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.secondary_specular_refs = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.slot_poses = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.shoe_material = s.s7(16, '>')
tgi.end_read(stream)
def read(self, stream, resources=None):
s = StreamReader(stream)
s.version = s.u32()
tgi = TGIList(package=resources)
tgi.begin_read(stream)
self.components = [s.hash(self.component_hashes) for i in range(s.i8())]
self.component_data = {}
def read_component_data():
key = s.p32()
val = None
t = s.i8()
if t == 0x00:
val = t, s.p32()
elif t == 0x01:
val = t, tgi.get_resource(s.i32())
elif t == 0x02:
val = t, tgi.get_resource(s.i32())
elif t == 0x03:
val = t, s.p32()
elif t == 0x04:
val = t, s.u32()
self.component_data[key] = val
for i in range(s.i8()):
read_component_data()
self.visible = s.u8()
tgi.end_read(stream)
pass
def read(self, stream, resources=None):
s = StreamReader(stream)
flags = s.u8()
self.type = (flags & 0x07) >> 0
self.static = ((flags & 0x08) >> 3) == 1
self.unknown = (flags & 0xF0) >> 4
return self
def read(self, stream, resources):
s = StreamReader(stream)
self.age_gender = s.u32()
self.edge_color = s.u32()
self.specular_color = s.u32()
self.specular_power = s.f32()
self.is_genetic = bool(s.u8())
def read(self, stream, resources=None):
s = StreamReader(stream)
flags = s.u8()
self.type = (flags & 0x07) >> 0
self.static = ((flags & 0x08) >> 3) == 1
self.unknown = (flags & 0xF0) >> 4
return self
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
tgi = TGIList()
tgi.begin_read(stream)
self.shader = s.u32()
if self.shader:
end_material = s.u32() + stream.tell()
self.material = MaterialBlock()
self.material.read(stream, tgi)
assert stream.tell() == end_material
self.merge_group = s.u32()
self.sort_order = s.u32()
cVertices = s.u32()
self.vertex_format.read(stream)
for vertex_index in range(cVertices):
vertex = Vertex()
for declaration in self.vertex_format.declarations:
if declaration.usage == self.VertexFormat.Declaration.USAGE.POSITION:
vertex.position = [s.f32(), s.f32(), s.f32()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.NORMAL:
vertex.normal = [s.f32(), s.f32(), s.f32()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.UV:
uv = [s.f32(), s.f32()]
if vertex.uv == None:
vertex.uv = []
vertex.uv.append(uv)
elif declaration.usage == self.VertexFormat.Declaration.USAGE.BLEND_INDEX:
vertex.blend_indices = [s.i8(), s.i8(), s.i8(), s.i8()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.BLEND_WEIGHT:
vertex.blend_weights = [s.f32(), s.f32(), s.f32(), s.f32()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.TANGENT:
vertex.tangent = [s.f32(), s.f32(), s.f32()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.COLOUR:
vertex.colour = [s.u8(), s.u8(), s.u8(), s.u8()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.ID:
vertex.id = s.u32()
self.vertices.append(vertex)
assert s.u32() == 1
bytes_per_index = s.u8()
assert bytes_per_index == 2
self.indices = [[s.u16() for i in range(3)]
for i in range(int(s.u32() / 3))]
self.skin_controller = tgi.get_resource(s.u32())
self.bones = [s.u32() for i in range(s.u32())]
tgi.end_read(stream)
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
tgi = TGIList()
tgi.begin_read(stream)
self.shader = s.u32()
if self.shader:
end_material = s.u32() + stream.tell()
self.material = MaterialBlock()
self.material.read(stream, tgi)
assert stream.tell() == end_material
self.merge_group = s.u32()
self.sort_order = s.u32()
cVertices = s.u32()
self.vertex_format.read(stream)
for vertex_index in range(cVertices):
vertex = Vertex()
for declaration in self.vertex_format.declarations:
if declaration.usage == self.VertexFormat.Declaration.USAGE.POSITION:
vertex.position = [s.f32(), s.f32(), s.f32()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.NORMAL:
vertex.normal = [s.f32(), s.f32(), s.f32()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.UV:
uv = [s.f32(), s.f32()]
if vertex.uv == None:
vertex.uv = []
vertex.uv.append(uv)
elif declaration.usage == self.VertexFormat.Declaration.USAGE.BLEND_INDEX:
vertex.blend_indices = [s.i8(), s.i8(), s.i8(), s.i8()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.BLEND_WEIGHT:
vertex.blend_weights = [s.f32(), s.f32(), s.f32(), s.f32()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.TANGENT:
vertex.tangent = [s.f32(), s.f32(), s.f32()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.COLOUR:
vertex.colour = [s.u8(), s.u8(), s.u8(), s.u8()]
elif declaration.usage == self.VertexFormat.Declaration.USAGE.ID:
vertex.id = s.u32()
self.vertices.append(vertex)
assert s.u32() == 1
bytes_per_index = s.u8()
assert bytes_per_index == 2
self.indices = [[s.u16() for i in range(3)] for i in range(int(s.u32() / 3))]
self.skin_controller = tgi.get_resource(s.u32())
self.bones = [s.u32() for i in range(s.u32())]
tgi.end_read(stream)
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
tgi = TGIList()
self.version = s.u32()
tgi.begin_read(stream)
cEntries = s.u8()
for entry_index in range(cEntries):
t = s.u8()
entry = self.Entry.create_instance(t)
entry.read(stream, tgi)
self.entries.append(entry)
assert s.u8() == 0x02
self.bounds.read(stream)
self.flags = s.u32()
if s.u8():
self.routing_footprint = tgi.get_resource(s.u32())
tgi.end_read(stream)
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
tgi = TGIList()
self.version = s.u32()
tgi.begin_read(stream)
cEntries = s.u8()
for entry_index in range(cEntries):
type = s.u8()
entry = self.Entry.create_instance(type)
entry.read(stream, tgi)
self.entries.append(entry)
assert s.u8() == 0x02
self.bounds.read(stream)
self.flags = s.u32()
if s.u8():
self.routing_footprint = tgi.get_resource(s.u32())
tgi.end_read(stream)
def read(self, stream, resource=None):
s = StreamReader(stream)
self.frame_data_ptr = StreamPtr.begin_read(s)
self.track_key = s.u32()
self.offset = s.f32()
self.scale = s.f32()
self.frame_count = s.u16()
self.flags.read(stream)
self.type = s.u8()
return self
def read(self, stream, resource=None):
s = StreamReader(stream)
self.frame_data_ptr = StreamPtr.begin_read(s)
self.track_key = s.u32()
self.offset = s.f32()
self.scale = s.f32()
self.frame_count = s.u16()
self.flags.read(stream)
self.type = s.u8()
return self
def read(self, stream, resources=None):
s = StreamReader(stream)
self.version = s.u32()
tgi = TGIList()
tgi.begin_read(stream)
self.shader_keys = [self.ShaderKey(self, stream, tgi) for i in range(s.i32())]
self.sub_skin_ramp = tgi.get_resource(s.u32())
self.tone_ramp = tgi.get_resource(s.u32())
self.texture_keys = [self.TextureKey(self, stream, tgi) for i in range(s.i32())]
self.dominant = bool(s.u8())
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
self.rig.key = s.tgi('ITG')
self.unknown = s.f32()
for i in range(self.RESERVED_COUNT): self.reserved[i] = s.u8()
cValues = s.u32()
self.bone_weights = [0.0] * cValues
for i in range(cValues): self.bone_weights[i] = s.f32()
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
num = s.u32()
cLights = s.u8()
cOccluders = s.u8()
assert num == (4 + (cLights * 128) + (cOccluders * 14))
num2 = s.u16()
assert num2 == (cOccluders * 14)
self.lights = []
for light_index in range(cLights):
start = stream.tell()
light_type = s.u32()
light = Light.get_type(light_type)()
light.read_rcol(stream)
stream.seek(start + 128, SEEK_SET)
self.lights.append(light)
self.occluders = [Occluder(stream) for i in range(cOccluders)]
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
num = s.u32()
cLights = s.u8()
cOccluders = s.u8()
assert num == (4 + (cLights * 128) + (cOccluders * 14))
num2 = s.u16()
assert num2 == (cOccluders * 14)
self.lights = []
for light_index in range(cLights):
start = stream.tell()
light_type = s.u32()
light = Light.get_type(light_type)()
light.read_rcol(stream)
stream.seek(start + 128, SEEK_SET)
self.lights.append(light)
self.occluders = [Occluder(stream) for i in range(cOccluders)]
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
self.rig.key = s.tgi('ITG')
self.unknown = s.f32()
for i in range(self.RESERVED_COUNT):
self.reserved[i] = s.u8()
cValues = s.u32()
self.bone_weights = [0.0] * cValues
for i in range(cValues):
self.bone_weights[i] = s.f32()
def read(self, stream, resources=None):
s = StreamReader(stream)
self.version = s.u32()
self.name_guid = s.u64()
self.desc_guid = s.u64()
self.name_key = s.s7(size=16,order='>')
self.desc_key = s.s7(size=16,order='>')
self.price = s.f32()
self.niceness_multiplier = s.f32()
self.crap_score = s.f32()
self.status_flags = s.u8()
self.icon = s.u64()
assert s.u8() == 0
self.environment_score = s.f32()
self.fire_type = s.u32()
self.is_stealable = bool(s.i8())
self.is_reposessable = bool(s.i8())
self.ui_sort_index = s.u32()
if self.version >= 0x0000000D: self.is_placeable_on_roof = bool(s.u8())
if self.version >= 0x0000000E: self.is_visible_in_worldbuilder = bool(s.u8())
if self.version >= 0x0000000F: self.product_name = s.u32()
def read(self, stream, resources=None):
s = StreamReader(stream)
self.version = s.u32()
self.name_guid = s.u64()
self.desc_guid = s.u64()
self.name_key = s.s7()
self.desc_key = s.s7()
self.price = s.f32()
self.niceness_multiplier = s.f32()
self.crap_score = s.f32()
self.status_flags = s.u8()
self.icon = s.u64()
self.environment_score = s.f32()
self.fire_type = s.u32()
self.is_stealable = bool(s.i8())
self.is_reposessable = bool(s.i8())
self.ui_sort_index = s.u32()
if self.version >= 0x0000000D: self.is_placeable_on_roof = bool(s.u8())
if self.version >= 0x0000000E:
self.is_visible_in_worldbuilder = bool(s.u8())
if self.version >= 0x0000000F: self.product_name = s.u32()
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
self.stride = s.i32()
cDeclarations = s.i32()
self.is_extended_format = s.u32() > 0
self.declarations = []
for declaration_index in range(cDeclarations):
declaration = self.Declaration()
if self.is_extended_format:
declaration.usage = s.u32()
declaration.usage_index = s.u32()
declaration.format = s.u32()
declaration.offset = s.u32()
else:
declaration.usage = s.u8()
declaration.usage_index = s.u8()
declaration.format = s.u8()
declaration.offset = s.u8()
self.declarations.append(declaration)
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
self.stride = s.i32()
cDeclarations = s.i32()
self.is_extended_format = s.u32() > 0
self.declarations = []
for declaration_index in range(cDeclarations):
declaration = self.Declaration()
if self.is_extended_format:
declaration.usage = s.u32()
declaration.usage_index = s.u32()
declaration.format = s.u32()
declaration.offset = s.u32()
else:
declaration.usage = s.u8()
declaration.usage_index = s.u8()
declaration.format = s.u8()
declaration.offset = s.u8()
self.declarations.append(declaration)
def read(self, stream, resources=None):
s = StreamReader(stream)
self.version = s.u32()
use_tgi = not isinstance(resources, TGIList)
tgi = resources
if use_tgi:
tgi = TGIList(order='IGT',
use_length=False,
package=resources,
count_size=8)
tgi.begin_read(stream)
if self.version >= 7:
cFabrics = s.i8()
for fabric_index in range(cFabrics):
key = tgi.get_resource(s.u8())
fabric = TextureCompositor(key)
fabric_len = s.u32()
with BytesIO() as fabric_stream:
fabric_stream.write(stream.read(fabric_len))
fabric_stream.seek(0, SEEK_SET)
fabric.read(fabric_stream, tgi)
self.fabrics.append(fabric)
self.target_size = s.u32()
self.part_type = s.u32()
assert s.u8() == 0
cSteps = s.i32()
if self.version >= 0x08:
assert s.u8() == 0
self.steps = []
for step_index in range(cSteps):
self.steps.append(self.read_step(stream, tgi))
if use_tgi:
tgi.end_read(stream)
else:
assert s.u32() == 0
def uncompress(cls, input_stream, file_size, mem_size):
output_stream = BytesIO()
br = StreamReader(input_stream)
end = input_stream.tell() + file_size
data = br.bytes(2)
data_len = (4 if ((data[0] & 0x80) != 0) else 3) * (2 if (
(data[0] & 0x01) != 0) else 1)
data = br.bytes(data_len)
real_size = 0
for i in range(data_len):
real_size = (real_size << 8) + data[i]
assert real_size == mem_size
while input_stream.tell() < end:
copy_size = 0
copy_offset = 0
packing = br.u8()
if packing < 0x80:
data = br.bytes(1)
data_len = packing & 0x03
copy_size = ((packing >> 2) & 0x07) + 3
copy_offset = (((packing << 3) & 0x300) | data[0]) + 1
elif packing < 0xC0:
data = br.bytes(2)
data_len = (data[0] >> 6) & 0x03
copy_size = (packing & 0x3F) + 4
copy_offset = (((data[0] << 8) & 0x3F00) | data[1]) + 1
elif packing < 0xE0:
data = br.bytes(3)
data_len = packing & 0x03
copy_size = (((packing << 6) & 0x300) | data[2]) + 5
copy_offset = (((packing << 12) & 0x10000) | data[0] << 8
| data[1]) + 1
elif packing < 0xFC:
data_len = (((packing & 0x1F) + 1) << 2)
else:
data_len = packing & 0x03
if data_len > 0:
output_stream.write(input_stream.read(data_len))
if copy_size < copy_offset > 8:
cls.copy_a(output_stream, copy_offset, copy_size)
else:
cls.copy_b(output_stream, copy_offset, copy_size)
output_stream.seek(0, SEEK_SET)
return output_stream
def uncompress(cls,input_stream, file_size, mem_size):
output_stream = BytesIO()
br = StreamReader(input_stream)
end = input_stream.tell() + file_size
data = br.bytes(2)
data_len = (4 if ((data[0] & 0x80) != 0) else 3 ) * ( 2 if ((data[0] & 0x01) != 0) else 1 )
data = br.bytes(data_len)
real_size = 0
for i in range(data_len): real_size = (real_size << 8) + data[i]
assert real_size == mem_size
while input_stream.tell() < end:
copy_size = 0
copy_offset = 0
packing = br.u8()
if packing < 0x80:
data = br.bytes(1)
data_len = packing & 0x03
copy_size = ((packing >> 2) & 0x07) + 3
copy_offset = (((packing << 3) & 0x300) | data[0]) + 1
elif packing < 0xC0:
data = br.bytes(2)
data_len = (data[0] >> 6) & 0x03
copy_size = (packing & 0x3F) + 4
copy_offset = (((data[0] << 8) & 0x3F00) | data[1]) + 1
elif packing < 0xE0:
data = br.bytes(3)
data_len = packing & 0x03
copy_size = (((packing << 6) & 0x300) | data[2]) + 5
copy_offset = (((packing << 12) & 0x10000) | data[0] << 8 | data[1]) + 1
elif packing < 0xFC:
data_len = (((packing & 0x1F) + 1) << 2)
else:
data_len = packing & 0x03
if data_len > 0:
output_stream.write(input_stream.read(data_len))
if copy_size < copy_offset > 8:
cls.copy_a(output_stream, copy_offset, copy_size)
else:
cls.copy_b(output_stream, copy_offset, copy_size)
output_stream.seek(0, SEEK_SET)
return output_stream
def read(self, stream, resources=None):
s = StreamReader(stream)
if s.u32() != self.ID: raise Exception("Not a valid clip resource")
if s.u32(): raise Exception("Linked clip offset not supported")
clipSize = s.u32()
clip_ptr = StreamPtr.begin_read(s, True)
ik_ptr = StreamPtr.begin_read(s, True)
actor_ptr = StreamPtr.begin_read(s, True)
event_ptr = StreamPtr.begin_read(s, True)
self.unknown1 = s.u32()
self.unknown2 = s.u32()
vector_ptr = StreamPtr.begin_read(s, True)
self.unknown3 = []
for i in range(16):
self.unknown3.append(s.u8())
a = clip_ptr.seek_data()
clipStream = BytesIO()
clipStream.write(stream.read(clipSize))
clipStream.seek(0, SEEK_SET)
self.clip = Clip()
self.clip.read(clipStream)
clipStream.close()
assert actor_ptr.seek_data()
self.actor_name = s.zs()
if ik_ptr.seek_data():
self.ik_info = ClipIKInfo()
self.ik_info.read(stream)
else:
self.ik_info = None
assert event_ptr.seek_data()
self.event_table.read(stream)
self.vector = []
assert vector_ptr.seek_data()
for i in range(4):
self.vector.append(s.f32())
def read(self, stream, resources=None):
s = StreamReader(stream)
if s.u32() != self.ID: raise Exception("Not a valid clip resource")
if s.u32(): raise Exception("Linked clip offset not supported")
clipSize = s.u32()
clip_ptr = StreamPtr.begin_read(s, True)
ik_ptr = StreamPtr.begin_read(s, True)
actor_ptr = StreamPtr.begin_read(s, True)
event_ptr = StreamPtr.begin_read(s, True)
self.unknown1 = s.u32()
self.unknown2 = s.u32()
vector_ptr = StreamPtr.begin_read(s, True)
self.unknown3 = []
for i in range(16): self.unknown3.append(s.u8())
a= clip_ptr.seek_data()
clipStream = BytesIO()
clipStream.write(stream.read(clipSize))
clipStream.seek(0, SEEK_SET)
self.clip = Clip()
self.clip.read(clipStream)
clipStream.close()
assert actor_ptr.seek_data()
self.actor_name = s.zs()
if ik_ptr.seek_data():
self.ik_info = ClipIKInfo()
self.ik_info.read(stream)
else:
self.ik_info = None
assert event_ptr.seek_data()
self.event_table.read(stream)
self.vector = []
assert vector_ptr.seek_data()
for i in range(4): self.vector.append(s.f32())
def read(self, stream, resources=None):
s = StreamReader(stream)
self.index = s.u8()
self.resources = [resources.get_resource(s.u32()) for i in range(s.u8())]
def read(self, stream, resource=None):
s = StreamReader(stream)
self.usage = s.u32()
self.type = s.u32()
self.size = s.u8()
def read(self, stream, rcol):
RCOLChunk.read(self, stream, rcol)
s = StreamReader(stream)
self.sg.read(stream, rcol)
data_length = s.u32()
self.time = s.u16()
count_modifiers = s.u16()
count_p7 = s.u16()
obj_mod_len = s.u8()
self.anim_version = s.u8()
self.anim_type = s.u8()
unknown1 = s.u8()
self.locomotion_type = s.u8()
obj_name_len = s.u8()
self.read_foosball(stream, 4)
self.initial_direction = s.f32()
self.locomotion_magnitude = s.f32()
self.locomotion_scale = s.f32()
unknown2 = s.f32()
self.unknown3 = s.f32()
self.unknown4 = s.f32()
self.final_direction = s.f32()
self.skeleton_scale = s.f32()
self.height = s.f32()
self.object_name = s.zs()
self.object_modifier_string = s.zs()
self.fix_read_offset(stream)
self.actors = []
#P1:Object
for i in range(count_modifiers):
self.read_foosball(stream, 2)
actor = self.Actor()
actor.unknown1 = s.u16()
actor.tracks = [0] * s.u16()
part_4_count = s.u16()
actor.frames = [0] * (part_4_count & 0x3F)
actor.frame_flags = part_4_count & 0xC0
object_name_len = s.u16()
self.read_foosball(stream, 3)
self.actors.append(actor)
for actor in self.actors:
actor.name = s.zs()
# name_lookup = {}
# for name in blend_object_names:
# name_lookup[crc32(bytes(name,encoding='ascii'))]=name
self.fix_read_offset(stream)
for actor in self.actors:
for i in range(len(actor.tracks)):
self.read_foosball(stream, 2)
crc = s.u32()
self.read_foosball(stream)
unknown5 = s.u32()
t = (unknown5 & 0x00F00000) >> 20
# highest 3 bits
count_movements = (unknown5 >> 0x1D) & 0x7
self.read_foosball(stream)
track = self.Track()
track.hash = crc
track.duration = 0
track.type = t
track.frames = [self.Frame()] * count_movements
actor.tracks[i] = track
for actor in self.actors:
for track in actor.tracks:
track.name = s.zs()
self.fix_read_offset(stream)
#P3:Movements
for actor in self.actors:
for track_index, track in enumerate(actor.tracks):
for i in range(len(track.frames)):
f = self.Frame()
f.u1 = s.u16()
f.u2 = s.u16()
track.frames[i] = f
self.read_foosball(stream)
self.fix_read_offset(stream)
#P4:Transforms
for actor in self.actors:
for track_index, track in enumerate(actor.tracks):
for frame_index, frame in enumerate(track.frames):
u1 = frame.u1
u2 = frame.u2
dum = u1 >> 0x10
count = u1 & 0x0F
t = dum & 3
if t == 0:
size = 1
elif t == 1:
size = 3
else:
size = 4
total = count * size
for i in range(t):
data = []
for j in range(size):
data.append(self.unpack_float(stream))
frame.data.append(data)
pass
pass
pass
def read(self, stream, resource=None):
s = StreamReader(stream)
self.usage = s.u32()
self.type = s.u32()
self.size = s.u8()
class Buffer:
def __init__(self):
self.stream = BytesIO()
self.reader = StreamReader(self.stream)
self.writer = StreamWriter(self.stream)
def delete_vertices(self, offset, vrtf, count):
end_offset = offset + vrtf.stride * count
self.stream.seek(end_offset, SEEK_SET)
end_data = self.stream.read(-1)
self.stream.seek(offset, SEEK_SET)
self.stream.truncate()
self.stream.writable(end_data)
def read_vertices(self, offset, vrtf, count, uvscales):
self.stream.seek(offset, SEEK_SET)
return [self.read_vertex(vrtf, uvscales) for i in range(count)]
def read_vertex(self, vrtf, uvscales):
vertex = Vertex()
start = self.stream.tell()
end = start + vrtf.stride
for declaration in vrtf.declarations:
u = declaration.usage
value = self.read_element(declaration,
uvscales[declaration.usage_index])
if u == VertexFormat.USAGE.POSITION: vertex.position = value
elif u == VertexFormat.USAGE.NORMAL: vertex.normal = value
elif u == VertexFormat.USAGE.UV:
if vertex.uv == None: vertex.uv = []
vertex.uv.append(value)
elif u == VertexFormat.USAGE.BLEND_INDEX:
vertex.blend_indices = value
elif u == VertexFormat.USAGE.BLEND_WEIGHT:
vertex.blend_weights = value
elif u == VertexFormat.USAGE.COLOR:
vertex.colour = value
elif u == VertexFormat.USAGE.TANGENT:
vertex.tangent = value
else:
raise Exception("Unknown usage %s", declaration.usage)
actual = self.stream.tell()
return vertex
def write_vertices(self, vrtf, vertices, uvscales=None):
self.stream.seek(0, SEEK_END)
offset = self.stream.tell()
for vertex in vertices:
self.write_vertex(vrtf, vertex)
def write_vertex(self, vrtf, v):
for declaration in vrtf.declarations:
u = declaration.usage
if u == VertexFormat.USAGE.POSITION: data = v.position
elif u == VertexFormat.USAGE.NORMAL: data = v.normal
elif u == VertexFormat.USAGE.UV: data = v.uv[vrtf.usage_index]
elif u == VertexFormat.USAGE.BLEND_INDEX:
data = v.blend_indices
elif u == VertexFormat.USAGE.BLEND_WEIGHT:
data = v.blend_weights
elif u == VertexFormat.USAGE.COLOR:
data = v.colour
elif u == VertexFormat.USAGE.TANGENT:
data = v.tangents
else:
raise Exception('Unknown VRTF usage type %i' % u)
self.write_element(declaration, data)
def write_element(self, declaration, value):
pass
def read_element(self, declaration, uvscale):
float_count = VertexFormat.FORMAT.float_count(declaration.format)
value = [0.0] * float_count
f = declaration.format
u = declaration.usage
if u == VertexFormat.USAGE.UV:
if f == VertexFormat.FORMAT.SHORT2:
for i in range(float_count):
value[i] = self.reader.i16() * uvscale
elif f == VertexFormat.FORMAT.SHORT4:
shorts = [self.reader.i16() for i in range(4)]
assert shorts[2] == 0
value = [
shorts[0] / 0x7FFF, shorts[1] / 0x7FFF,
shorts[3] / 0x1FF
]
elif f in (VertexFormat.FORMAT.FLOAT, VertexFormat.FORMAT.FLOAT2,
VertexFormat.FORMAT.FLOAT3, VertexFormat.FORMAT.FLOAT4):
for i in range(float_count):
value[i] = self.reader.f32()
elif f == VertexFormat.FORMAT.UBYTE4:
for i in range(float_count):
value[i] = self.reader.i8()
elif f == VertexFormat.FORMAT.COLOR_UBYTE4:
if u == VertexFormat.USAGE.COLOR:
for i in range(float_count):
value[i] = self.reader.u8() / 0xFF
elif u == VertexFormat.USAGE.BLEND_WEIGHT:
for i in range(float_count):
value[VertexFormat.FORMAT.
UBYTE_MAP[i]] = self.reader.u8() / 0xFF
elif u in (VertexFormat.USAGE.NORMAL,
VertexFormat.USAGE.TANGENT):
bytes = [self.reader.u8() for i in range(4)]
for i in range(float_count - 1):
value[i] = -1 if bytes[2 - i] == 0 else ((
(bytes[2 - i] + 1) / 128.0) - 1)
determinant = 0.0
if not bytes[3]: determinant = -1.0
elif bytes[3] == 127.0: determinant = 0.0
elif bytes[3] == 255.0: determinant = 1.0
else: print("Unexpected handedness %i " % bytes[3])
value[float_count - 1] = determinant
else:
raise Exception("Unhandled usage %s for format %s" %
(u, f))
elif f == VertexFormat.FORMAT.SHORT2:
for i in range(float_count):
value[i] = self.reader.i16() / 0xFFFF
elif f == VertexFormat.FORMAT.SHORT4:
shorts = [self.reader.i16() for i in range(3)]
scalar = self.reader.u16()
if not scalar: scalar = 0x7FFF
for i in range(float_count):
value[i] = float(shorts[i]) / float(scalar)
elif f == VertexFormat.FORMAT.USHORT4N:
shorts = [self.reader.i16() for i in range(3)]
scalar = self.reader.u16()
if not scalar: scalar = 511
for i in range(float_count):
value[i] = shorts[i] / scalar
elif f == VertexFormat.FORMAT.UBYTE4:
data = [self.reader.i8() for i in range(4)]
else:
raise Exception("Unhandled format %s" % f)
return value
def __del__(self):
if self.stream != None:
self.stream.close()
def read(self, stream, resource=None):
s = StreamReader(stream)
self.level = s.u8()
self.dest_texture = s.u32()
self.assets = [self.Asset(stream) for i in range(s.i8())]
class Buffer:
def __init__(self):
self.stream = BytesIO()
self.reader = StreamReader(self.stream)
self.writer = StreamWriter(self.stream)
def delete_vertices(self, offset, vrtf, count):
end_offset = offset + vrtf.stride * count
self.stream.seek(end_offset, SEEK_SET)
end_data = self.stream.read(-1)
self.stream.seek(offset, SEEK_SET)
self.stream.truncate()
self.stream.writable(end_data)
def read_vertices(self, offset, vrtf, count,uvscales):
self.stream.seek(offset, SEEK_SET)
return [self.read_vertex(vrtf,uvscales) for i in range(count)]
def read_vertex(self, vrtf, uvscales):
vertex = Vertex()
start = self.stream.tell()
end = start + vrtf.stride
for declaration in vrtf.declarations:
u = declaration.usage
value = self.read_element(declaration,uvscales[declaration.usage_index])
if u == VertexFormat.USAGE.POSITION: vertex.position = value
elif u == VertexFormat.USAGE.NORMAL: vertex.normal = value
elif u == VertexFormat.USAGE.UV:
if vertex.uv == None: vertex.uv = []
vertex.uv.append(value)
elif u == VertexFormat.USAGE.BLEND_INDEX: vertex.blend_indices = value
elif u == VertexFormat.USAGE.BLEND_WEIGHT: vertex.blend_weights = value
elif u == VertexFormat.USAGE.COLOR: vertex.colour = value
elif u == VertexFormat.USAGE.TANGENT: vertex.tangent = value
else:
raise Exception("Unknown usage %s", declaration.usage)
actual = self.stream.tell()
return vertex
def write_vertices(self, vrtf, vertices, uvscales=None):
self.stream.seek(0, SEEK_END)
offset = self.stream.tell()
for vertex in vertices: self.write_vertex(vrtf, vertex)
def write_vertex(self, vrtf, v):
for declaration in vrtf.declarations:
u = declaration.usage
if u == VertexFormat.USAGE.POSITION: data = v.position
elif u == VertexFormat.USAGE.NORMAL: data = v.normal
elif u == VertexFormat.USAGE.UV: data = v.uv[vrtf.usage_index]
elif u == VertexFormat.USAGE.BLEND_INDEX: data = v.blend_indices
elif u == VertexFormat.USAGE.BLEND_WEIGHT: data = v.blend_weights
elif u == VertexFormat.USAGE.COLOR: data = v.colour
elif u == VertexFormat.USAGE.TANGENT: data = v.tangents
else: raise Exception('Unknown VRTF usage type %i' % u)
self.write_element(declaration, data)
def write_element(self, declaration, value):
pass
def read_element(self, declaration, uvscale):
float_count = VertexFormat.FORMAT.float_count(declaration.format)
value = [0.0] * float_count
f = declaration.format
u = declaration.usage
if u == VertexFormat.USAGE.UV:
if f == VertexFormat.FORMAT.SHORT2:
for i in range(float_count): value[i] = self.reader.i16() * uvscale
elif f == VertexFormat.FORMAT.SHORT4:
shorts = [self.reader.i16() for i in range(4)]
assert shorts[2] == 0
value = [shorts[0] /0x7FFF, shorts[1]/0x7FFF, shorts[3] /0x1FF]
elif f in (VertexFormat.FORMAT.FLOAT, VertexFormat.FORMAT.FLOAT2, VertexFormat.FORMAT.FLOAT3,
VertexFormat.FORMAT.FLOAT4):
for i in range(float_count): value[i] = self.reader.f32()
elif f == VertexFormat.FORMAT.UBYTE4:
for i in range(float_count): value[i] = self.reader.i8()
elif f == VertexFormat.FORMAT.COLOR_UBYTE4:
if u == VertexFormat.USAGE.COLOR:
for i in range(float_count): value[i] = self.reader.u8() / 0xFF
elif u == VertexFormat.USAGE.BLEND_WEIGHT:
for i in range(float_count): value[VertexFormat.FORMAT.UBYTE_MAP[i]] = self.reader.u8() / 0xFF
elif u in (VertexFormat.USAGE.NORMAL, VertexFormat.USAGE.TANGENT):
bytes = [self.reader.u8() for i in range(4)]
for i in range(float_count - 1):
value[i] = -1 if bytes[2 - i] == 0 else ( ((bytes[2 - i] + 1) / 128.0) - 1)
determinant = 0.0
if not bytes[3]: determinant = -1.0
elif bytes[3] == 127.0: determinant = 0.0
elif bytes[3] == 255.0: determinant = 1.0
else: print("Unexpected handedness %i " % bytes[3])
value[float_count - 1] = determinant
else:
raise Exception("Unhandled usage %s for format %s" % (u, f))
elif f == VertexFormat.FORMAT.SHORT2:
for i in range(float_count): value[i] = self.reader.i16() / 0xFFFF
elif f == VertexFormat.FORMAT.SHORT4:
shorts = [self.reader.i16() for i in range(3)]
scalar = self.reader.u16()
if not scalar: scalar = 0x7FFF
for i in range(float_count): value[i] = float(shorts[i]) / float(scalar)
elif f == VertexFormat.FORMAT.USHORT4N:
shorts = [self.reader.i16() for i in range(3)]
scalar = self.reader.u16()
if not scalar: scalar = 511
for i in range(float_count): value[i] = shorts[i] / scalar
elif f == VertexFormat.FORMAT.UBYTE4:
data = [self.reader.i8() for i in range(4)]
else:
raise Exception("Unhandled format %s" % f)
return value
def __del__(self):
if self.stream != None:
self.stream.close()
def read(self, stream, resources):
s = StreamReader(stream)
self.index = s.u8()
self.resources = [resources.get_resource(s.u32()) for i in range(s.u8())]
