def read(self, stream, resource=None):
s = StreamReader(stream)
self.name = s.u32()
self.start_index = s.i32()
self.start_vertex = s.i32()
self.vertex_count = s.i32()
self.index_count = s.i32()
def read(self, stream, resources=None):
s = StreamReader(stream)
self.version = s.u32()
tgi = TGIList(package=resources)
tgi.begin_read(stream)
if self.version >= 0x00000007:
self.presets = ProductBase.read_presets(stream,tgi)
self.product_info = ProductInfo()
self.product_info.read(stream,tgi)
self.model = tgi.get_resource(s.i32())
self.diagonal_model = tgi.get_resource(s.i32())
self.post_model = tgi.get_resource(s.i32())
self.post_tile_spacing = s.i32()
self.can_walk_over = s.i8() == 1
if self.version >= 0x00000008:
if self.version >= 0x000000A:
self.should_not_get_thick_snow = s.i8() == 1
self.snow_post_shape_is_circle = s.i8()==1
self.snow_thickness_post_scale_factor = s.f32()
self.snow_thickness_rail_scale_factor = s.f32()
self.snow_thickness_post_vertical_offset = s.f32()
self.snow_thickness_rail_vertical_offset = s.f32()
self.has_wall = s.i8() == 1
if self.version < 0x000000A or self.has_wall:
self.raise_fence_geometry_above_wall = s.i8()== 1
self.wall = tgi.get_resource(s.i32())
tgi.end_read(stream)
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.clip = ExternalResource(s.tgi('ITG'))
self.track_mask = ExternalResource(s.tgi('ITG'))
cActorSlots = s.i32()
assert s.u32() == 0
assert s.u32() == 0
assert s.u32() == 0
self.actor_slots = [
self.SlotAssignment(stream) for i in range(cActorSlots)
]
self.actor_iks = [
self.NamespaceSlotSuffix(stream) for i in range(s.i32())
]
assert s.u32() == DEADBEEF
self.additive_clip = ExternalResource(s.tgi('ITG'))
self.clip_pattern = s.p32(size=16)
s.align()
self.additive_clip_pattern = s.p32(size=16)
s.align()
assert s.u32() == DEADBEEF
AnimationNode.read_rcol(self, stream, rcol)
def read(self, stream, resource=None):
s = StreamReader(stream)
self.name = s.u32()
self.start_index = s.i32()
self.start_vertex = s.i32()
self.vertex_count = s.i32()
self.index_count = s.i32()
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.routing_slots = [RoutingSlot() for i in range(s.i32())]
self.container_slots = [ContainerSlot() for i in range(s.i32())]
self.effect_slots = [EffectSlot() for i in range(s.i32())]
self.target_slots = [TargetSlot() for i in range(s.i32())]
self.cone_slots = [ConeSlot() for i in range(s.i32())]
def read_names(slots):
for slot in slots: slot.name = s.hash(Slot.NAMES)
def read_bones(slots):
for slot in slots: slot.bone_name = s.u32()
def read_transforms(slots):
for slot in slots: slot.transform = s.m43()
def read_offsets(slots):
if any(slots):
for i in range(s.i32()):
slots[i].offset = SlotOffset([s.f32(), s.f32(), s.f32()], [s.f32(), s.f32(), s.f32()])
pass
pass
read_names(self.routing_slots)
read_bones(self.routing_slots)
read_transforms(self.routing_slots)
read_offsets(self.routing_slots)
read_names(self.container_slots)
read_bones(self.container_slots)
for slot in self.container_slots:
slot.flags = s.u32()
read_transforms(self.container_slots)
read_offsets(self.container_slots)
read_names(self.effect_slots)
read_bones(self.effect_slots)
read_transforms(self.effect_slots)
read_offsets(self.effect_slots)
read_names(self.target_slots)
read_bones(self.target_slots)
read_transforms(self.target_slots)
read_offsets(self.target_slots)
read_names(self.cone_slots)
read_bones(self.cone_slots)
read_transforms(self.cone_slots)
for cone_slot in self.cone_slots:
cone_slot.radius = s.f32()
cone_slot.angle = s.f32()
read_offsets(self.cone_slots)
pass
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.routing_slots = [RoutingSlot() for i in range(s.i32())]
self.container_slots = [ContainerSlot() for i in range(s.i32())]
self.effect_slots = [EffectSlot() for i in range(s.i32())]
self.target_slots = [TargetSlot() for i in range(s.i32())]
self.cone_slots = [ConeSlot() for i in range(s.i32())]
def read_names(slots):
for slot in slots: slot.name = s.hash(Slot.NAMES)
def read_bones(slots):
for slot in slots: slot.bone_name = s.u32()
def read_transforms(slots):
for slot in slots: slot.transform = s.m43()
def read_offsets(slots):
if any(slots):
for i in range(s.i32()):
slots[i].offset = SlotOffset([s.f32(), s.f32(), s.f32()], [s.f32(), s.f32(), s.f32()])
pass
pass
read_names(self.routing_slots)
read_bones(self.routing_slots)
read_transforms(self.routing_slots)
read_offsets(self.routing_slots)
read_names(self.container_slots)
read_bones(self.container_slots)
for slot in self.container_slots:
slot.flags = s.u32()
read_transforms(self.container_slots)
read_offsets(self.container_slots)
read_names(self.effect_slots)
read_bones(self.effect_slots)
read_transforms(self.effect_slots)
read_offsets(self.effect_slots)
read_names(self.target_slots)
read_bones(self.target_slots)
read_transforms(self.target_slots)
read_offsets(self.target_slots)
read_names(self.cone_slots)
read_bones(self.cone_slots)
read_transforms(self.cone_slots)
for cone_slot in self.cone_slots:
cone_slot.radius = s.f32()
cone_slot.angle = s.f32()
read_offsets(self.cone_slots)
pass
def read(self, stream, resource=None):
s = StreamReader(stream)
assert s.chars(4) == self.TAG
self.version = s.u32()
cBlends = s.i32()
cLods = s.i32()
cPointers = s.i32()
cVectors = s.i32()
assert s.i32() == 0x00000008
assert s.i32() == 0x0000000C
blend_ptr = StreamPtr.begin_read(s)
vertex_ptr = StreamPtr.begin_read(s)
vector_ptr = StreamPtr.begin_read(s)
blend_ptr.end()
lod_ptrs = []
for blend_index in range(cBlends):
blend = Blend()
blend.age_gender_flags = s.u32()
blend.blend_region = s.u32()
self.blends.append(blend)
blend.lods = [Blend.LOD() for lod_index in range(cLods)]
lod_ptrs.append([self.LodPtr(s.u32(), s.u32(), s.u32()) for lod_index in range(cLods)])
vertex_ptr.end()
pointers = [self.VertexPtr(s.i16()) for pointer_index in range(cPointers)]
vector_ptr.end()
vectors = [[self.unpack(s.i16()) for i in range(3)] for vector_index in range(cVectors)]
for blend_index, blend in enumerate(self.blends):
start_vector_ptr = 0
current_vector_offset = 0
blend_ptr = lod_ptrs[blend_index]
for lod_index, lod in enumerate(blend.lods):
lod_blend_index = blend_index + lod_index
if lod_blend_index >= len(blend_ptr):
print('Skipping missing LOD %s - %s'%(lod_blend_index,len(blend_ptr)))
continue
lod_ptr = blend_ptr[blend_index + lod_index]
current_vertex_id = lod_ptr.start_vertex_id
for vector_ptr_index in range(lod_ptr.vertex_count):
vertex = Blend.Vertex()
vector_ptr = pointers[vector_ptr_index + start_vector_ptr]
current_vector_offset += vector_ptr.offset
vertex.id = current_vertex_id
vertex_vector_offset = 0
if vector_ptr.has_position:
vertex.position = vectors[current_vector_offset + vertex_vector_offset]
vertex_vector_offset += 1
if vector_ptr.has_normal:
vertex.normal = vectors[current_vector_offset + vertex_vector_offset]
vertex_vector_offset += 1
current_vertex_id += 1
lod.vertices.append(vertex)
start_vector_ptr += lod_ptr.vertex_count
current_vector_offset += lod_ptr.vector_count
def read(self, stream, resources=None):
s = StreamReader(stream)
self.rcol_version = s.u32()
item_links = [ResourceKey(group=s.u32(), instance=s.u32(), type=s.i32()) for i in range(s.i32())]
c = s.i32()
ids = [s.u32() for i in range(c)]
for i in range(c):
pass
pass
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):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
cLods = s.i32()
self.bounds.read(stream)
if self.version >= self.VERSION.EXTENDED:
self.extra_bounds = [BoundingBox(stream=stream) for i in range(s.i32())]
self.fade_type = s.u32()
self.custom_fade_distance = s.f32()
self.lods = [self.LOD(stream, rcol) for i in range(cLods)]
def read(self, stream, resource=None):
s = StreamReader(stream)
self.name = s.u32()
self.priority = s.i8()
self.footprint_type_flags = s.u32()
self.points = [(s.f32(), s.f32()) for i in range(s.i32())]
self.allow_intersection_flags = s.u32()
self.surface_type_flags = s.u32()
self.surface_attribute_flags = s.u32()
self.level_offset = s.i32()
if self.ftpt.version >= Footprint.VERSION.EXTENDED: self.elevation_offset = s.f32()
self.bounds.read(stream)
def read(self, stream, resources=None):
s = StreamReader(stream)
self.version = s.u32()
tgi = TGIList(package=resources)
tgi.begin_read(stream)
self.locale_key = s.u64()
self.indexers = [tgi.get_resource(s.i32()) for i in range(s.i32())]
self.is_bi_directional = bool(s.u32())
self.cas_panel_group = s.u32()
self.sort_index = s.i32()
assert s.u32() == 0
tgi.end_read(stream)
def read(self, stream, resource=None):
s = StreamReader(stream)
self.name = s.u32()
self.priority = s.i8()
self.footprint_type_flags = s.u32()
self.points = [(s.f32(), s.f32()) for i in range(s.i32())]
self.allow_intersection_flags = s.u32()
self.surface_type_flags = s.u32()
self.surface_attribute_flags = s.u32()
self.level_offset = s.i32()
if self.ftpt.version >= Footprint.VERSION.EXTENDED: self.elevation_offset = s.f32()
self.bounds.read(stream)
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.parameter_index = s.i32()
for item_index in range(s.i32()):
item = self.Item()
item.value = s.u32()
for action_index in range(s.i32()):
item.actions.append(rcol.get_block(s.u32(), DecisionGraphNode.get_node_types()))
self.items.append(item)
assert s.u32() == DEADBEEF
DecisionGraphNode.read(self, stream, rcol)
def read(self, stream, resources=None):
s = StreamReader(stream)
self.version = s.u32()
tgi = TGIList(package=resources)
tgi.begin_read(stream)
if self.version >= 0x00000003:
self.presets = ProductBase.read_presets(stream,tgi)
self.product_info = ProductInfo()
self.product_info.read(stream,tgi)
self.railing_4x_model = tgi.get_resource(s.i32())
self.railing_1x_model = tgi.get_resource(s.i32())
self.post_model = tgi.get_resource(s.i32())
tgi.end_read(stream)
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
cLods = s.i32()
self.bounds.read(stream)
if self.version >= self.VERSION.EXTENDED:
self.extra_bounds = [
BoundingBox(stream=stream) for i in range(s.i32())
]
self.fade_type = s.u32()
self.custom_fade_distance = s.f32()
self.lods = [self.LOD(stream, rcol) for i in range(cLods)]
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
assert s.u32() == 0x00000000
self.children = [
rcol.get_block(s.u32(), DecisionGraphNode.get_node_types())
for i in range(s.i32())
]
self.parents = [
rcol.get_block(s.u32(), DecisionGraphNode.get_node_types())
for i in range(s.i32())
]
assert s.u32() == DEADBEEF
def read(self, stream, resources=None):
s = StreamReader(stream)
s.seek(12, io.SEEK_SET)
c = s.i32()
ce = ComplateEncoder()
for i in range(c):
if not s.i8() == 1: s.i32()
preset_len = s.u32()
expected_end = s.tell() + preset_len
preset = self.BuildBuyPreset()
preset.complate = ce.deserialize(stream, resources)
assert s.tell() == expected_end
preset.id = s.u32()
self.presets.append(preset)
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.name = s.u32()
self.actors = [rcol.get_block(s.u32(), ActorDefinition) for i in range(s.i32())]
self.parameters = [rcol.get_block(s.u32(), ParameterDefinition) for i in range(s.i32())]
self.states = [rcol.get_block(s.u32(), State) for i in range(s.i32())]
self.namespace_map = [self.ActorPair(stream) for i in range(s.i32())]
assert s.u32() == DEADBEEF
self.flags = s.u32()
self.default_priority = s.i32()
self.awareness_overlay_level =AnimationOverlay(s.i32())
for i in range(4): assert s.u32() == 0
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.parameter_index = s.i32()
for item_index in range(s.i32()):
item = self.Item()
item.value = s.u32()
for action_index in range(s.i32()):
item.actions.append(
rcol.get_block(s.u32(),
DecisionGraphNode.get_node_types()))
self.items.append(item)
assert s.u32() == DEADBEEF
DecisionGraphNode.read(self, stream, rcol)
def read_data(self, stream, keys=None):
s = StreamReader(stream)
if self.type_code == self.TYPE.FLOAT:
return s.f32() if self.size32 == 1 else [s.f32() for i in range(self.size32)]
if self.type_code == self.TYPE.INT:
return s.i32() if self.size32 == 1 else[s.i32() for i in range(self.size32)]
if self.type_code == self.TYPE.TEXTURE:
if self.size32 == 4:
val = keys.get_resource(s.u32())
stream.seek(12, SEEK_CUR)
return val
elif self.size32 == 5:
key = s.tgi('ITG')
stream.seek(4, SEEK_CUR)
return key
def read(self, stream, resource=None):
s = StreamReader(stream)
self.index = s.i32()
self.slot_target_namespace = s.zs()
stream.seek(511 - len(self.slot_target_namespace), SEEK_CUR)
self.slot_target_bone = s.zs()
stream.seek(511 - len(self.slot_target_bone), SEEK_CUR)
def read(self, stream, resources=None):
s = StreamReader(stream)
self.version = s.u32()
tgi = TGIList(package=resources)
tgi.begin_read(stream)
if self.version >= 0x00000003:
self.presets = ProductBase.read_presets(stream,tgi)
self.product_info.read(stream,resources)
self.steps_4x_model = tgi.get_resource(s.i32())
self.steps_1x_model = tgi.get_resource(s.i32())
self.wall_cap_model = tgi.get_resource(s.i32())
self.railing = tgi.get_resource(s.i32())
self.wall = tgi.get_resource(s.i32())
self.floor = tgi.get_resource(s.i32())
self.fence = tgi.get_resource(s.i32())
tgi.end_read(stream)
def read_presets(cls,stream,resources=None):
s = StreamReader(stream)
c = s.i32()
ce = ComplateEncoder()
presets = []
for i in range(c):
preset = cls.BuildBuyPreset()
preset.unk1 = s.i8()
if preset.unk1 != 1:
preset.unk2 = s.i32()
preset_ptr = StreamPtr.begin_read(s,relative=True,offset_start=True)
preset.complate = ce.deserialize(stream,resources)
preset_ptr.end()
preset.id = s.u32()
presets.append(preset)
return presets
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.index = s.i32()
self.slot_target_namespace = s.zs()
stream.seek(511 - len(self.slot_target_namespace), SEEK_CUR)
self.slot_target_bone = s.zs()
stream.seek(511 - len(self.slot_target_bone), SEEK_CUR)
def read(self, stream, resources=None):
s = StreamReader(stream)
self.on_complete = [
resources.get_block(s.u32(), DecisionGraphNode.get_node_types())
for i in range(s.i32())
]
DecisionGraphNode.read(self, stream, resources)
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_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.outcomes = [self.Outcome(stream, rcol) for i in range(s.i32())]
assert s.u32() == DEADBEEF
self.flags = s.u32()
DecisionGraphNode.read(self, stream, rcol)
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
cBones = s.i32()
names = [s.u32() for i in range(cBones)]
poses = [s.m43() for pose_index in range(cBones)]
self.bones = [self.Bone(names[i], poses[i]) for i in range(cBones)]
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.outcomes = [self.Outcome(stream, rcol) for i in range(s.i32())]
assert s.u32() == DEADBEEF
self.flags = s.u32()
DecisionGraphNode.read(self, stream, rcol)
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
cBones = s.i32()
names = [s.u32() for i in range(cBones)]
poses = [s.m43() for pose_index in range(cBones)]
self.bones = [self.Bone(names[i], poses[i]) for i in range(cBones)]
def read(self, stream, rcol):
s = StreamReader(stream)
data_len = s.u32()
end = stream.tell() + data_len
self.name = s.u32()
self.material = rcol.get_block(s.u32(), (MaterialDefinition, MaterialSet))
self.vertex_format = rcol.get_block(s.u32(), VertexFormat)
self.vertex_buffer = rcol.get_block(s.u32(), (VertexBuffer, VertexBufferShadow))
self.index_buffer = rcol.get_block(s.u32(), (IndexBuffer, IndexBufferShadow))
flags = s.u32()
self.flags = flags >> 8
self.primitive_type = flags & 0x000000FF
self.stream_offset = s.u32()
self.start_vertex = s.i32()
self.start_index = s.i32()
self.min_vertex_index = s.i32()
self.vertex_count = s.i32()
self.primitive_count = s.i32()
self.bounds.read(stream)
self.skin_controller = rcol.get_block(s.u32(), ObjectSkinController)
self.bone_references = [s.u32() for i in range(s.i32())]
self.scale_offsets = rcol.get_block(s.u32(), MaterialDefinition)
self.states = [self.State(stream) for i in range(s.i32())]
if self.parent.version > ModelLod.VERSION.DEFAULT:
self.parent_name = s.u32()
self.mirror_plane_normal = [s.f32() for i in range(3)]
self.mirror_plane_offset = s.f32()
if not stream.tell() == end: raise Exception(
"Invalid MLOD.Mesh data length: expected 0x%X, but got 0x%08X" % (end, stream.tell()))
def read(self, stream, rcol):
s = StreamReader(stream)
data_len = s.u32()
end = stream.tell() + data_len
self.name = s.u32()
self.material = rcol.get_block(s.u32(),
(MaterialDefinition, MaterialSet))
self.vertex_format = rcol.get_block(s.u32(), VertexFormat)
self.vertex_buffer = rcol.get_block(s.u32(),
(VertexBuffer, VertexBufferShadow))
self.index_buffer = rcol.get_block(s.u32(),
(IndexBuffer, IndexBufferShadow))
flags = s.u32()
self.flags = flags >> 8
self.primitive_type = flags & 0x000000FF
self.stream_offset = s.u32()
self.start_vertex = s.i32()
self.start_index = s.i32()
self.min_vertex_index = s.i32()
self.vertex_count = s.i32()
self.primitive_count = s.i32()
self.bounds.read(stream)
self.skin_controller = rcol.get_block(s.u32(), ObjectSkinController)
self.bone_references = [s.u32() for i in range(s.i32())]
self.scale_offsets = rcol.get_block(s.u32(), MaterialDefinition)
self.states = [self.State(stream) for i in range(s.i32())]
if self.parent.version > ModelLod.VERSION.DEFAULT:
self.parent_name = s.u32()
self.mirror_plane_normal = [s.f32() for i in range(3)]
self.mirror_plane_offset = s.f32()
if not stream.tell() == end:
raise Exception(
"Invalid MLOD.Mesh data length: expected 0x%X, but got 0x%08X"
% (end, stream.tell()))
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.name = s.u32()
self.properties = s.u32()
self.decision_graph = rcol.get_block(s.u32(), DecisionGraph)
self.transitions = [rcol.get_block(s.u32(), State) for i in range(s.i32())]
self.awareness_overlay_level = s.u32()
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.version = s.u32()
self.deltas = {}
c = s.i32()
for i in range(c):
hsh = s.hash()
self.deltas[hsh] = self.Delta(stream)
pass
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.version = s.u32()
self.deltas = {}
c = s.i32()
for i in range(c):
hsh = s.hash()
self.deltas[hsh] = self.Delta(stream)
pass
def read(self, stream, resource=None):
s = StreamReader(stream)
self.bones = [self.parent.get_bone(s.i32()) for i in range(s.i32())]
self.info_nodes = [self.parent.get_bone(s.i32()) for i in range(11)]
self.pole = self.parent.get_bone(s.i32())
self.slot_info = self.parent.get_bone(s.i32())
self.slot_offset = self.parent.get_bone(s.i32())
self.root = self.parent.get_bone(s.i32())
def read_data(self, stream, keys=None):
s = StreamReader(stream)
if self.type_code == self.TYPE.FLOAT:
return s.f32() if self.size32 == 1 else [
s.f32() for i in range(self.size32)
]
if self.type_code == self.TYPE.INT:
return s.i32() if self.size32 == 1 else [
s.i32() for i in range(self.size32)
]
if self.type_code == self.TYPE.TEXTURE:
if self.size32 == 4:
val = keys.get_resource(s.u32())
stream.seek(12, SEEK_CUR)
return val
elif self.size32 == 5:
key = s.tgi('ITG')
stream.seek(4, SEEK_CUR)
return key
def read(self, stream, resource=None):
s = StreamReader(stream)
self.version = s.u32()
tgi = TGIList(use_length=self.version >= 7, add_eight=True)
tgi.begin_read(stream)
self.part_name = s.s7(16, '>')
self.blend_type = s.u32()
if self.version >= 8:
key = s.tgi()
bgeo = ExternalResource(key=key)
self.blend_geometry = bgeo
cEntries = s.i32()
for i in range(cEntries):
entry = self.RegionEntry()
entry.region_flags = s.u32()
entry.geom_entries = [self.GeomEntry(stream, tgi) for i in range(s.i32())]
entry.bone_entries = [self.BoneEntry(stream, tgi) for i in range(s.i32())]
self.entries.append(entry)
tgi.end_read(stream)
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.name = s.u32()
self.properties = s.u32()
self.decision_graph = rcol.get_block(s.u32(), DecisionGraph)
self.transitions = [
rcol.get_block(s.u32(), State) for i in range(s.i32())
]
self.awareness_overlay_level = s.u32()
def read(self, stream, resource=None):
s = StreamReader(stream)
self.version_major = s.u32()
self.version_minor = s.u32()
cBones = s.i32()
self.bones = []
opposites = []
parents = []
self.__hashes = {}
for i in range(cBones):
bone = Bone(self)
bone.position = [s.f32() for i in range(3)]
bone.orientation = [s.f32() for i in range(4)]
bone.scale = [s.f32() for i in range(3)]
bone.name = s.p32()
opposites.append(s.i32())
parents.append(s.i32())
hash_name = s.u32()
if not hash_name == FNV32.hash(bone.name):
print(
"WARNING: Bone %s should have matching hash 0x%08X, but has 0x%08X",
bone.name, FNV32.hash(bone.name), hash_name)
self.__hashes[hash] = bone
bone.flags = s.u32()
self.bones.append(bone)
for bone_index, opposite_index in enumerate(opposites):
if opposite_index >= 0:
self.bones[bone_index].opposite = self.bones[opposite_index]
for bone_index, parent_index in enumerate(parents):
if parent_index >= 0:
self.bones[bone_index].parent = self.bones[parent_index]
if self.version_major >= 4: self.name = s.p32()
self.ik_chains = []
cChains = s.i32()
for i in range(cChains):
chain = IKChain(self)
chain.read(stream)
self.ik_chains.append(chain)
def read(self, stream, resource=None):
s = StreamReader(stream)
chain_offsets = []
cChains = s.i32()
start_chains = stream.tell()
self.chains = []
for chain_index in range(cChains):
chain_offsets.append(start_chains + s.u32())
for chain_index in range(cChains):
assert stream.tell() == chain_offsets[chain_index]
assert s.u32() == 0x7e7e7e7e
cTargets = s.i32()
start_targets = stream.tell()
target_offsets = []
targets = []
for target_index in range(cTargets):
target_offsets.append(start_targets + s.u32())
for target_index in range(cTargets):
assert stream.tell() == target_offsets[target_index]
target = IKSlotTarget()
target.read(stream)
targets.append(target)
self.chains.append(targets)
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):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.framerate = s.f32()
cFrames = s.i32()
offsets = [s.u32() for i in range(cFrames)]
offsets.append(-1)
for frame_index in range(cFrames):
offset = offsets[frame_index]
next = offsets[frame_index + 1]
cBytes = next - offset if next > 0 else -1
data = stream.read(cBytes)
self.frames.append(data)
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, resource=None):
s = StreamReader(stream)
chain_offsets = []
cChains = s.i32()
start_chains = stream.tell()
self.chains = []
for chain_index in range(cChains):
chain_offsets.append(start_chains + s.u32())
for chain_index in range(cChains):
assert stream.tell() == chain_offsets[chain_index]
assert s.u32() == 0x7e7e7e7e
cTargets = s.i32()
start_targets = stream.tell()
target_offsets = []
targets = []
for target_index in range(cTargets):
target_offsets.append(start_targets + s.u32())
for target_index in range(cTargets):
assert stream.tell() == target_offsets[target_index]
target = IKSlotTarget()
target.read(stream)
targets.append(target)
self.chains.append(targets)
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.clip = ExternalResource(s.tgi('ITG'))
self.track_mask = ExternalResource(s.tgi('ITG'))
cActorSlots = s.i32()
assert s.u32() == 0
assert s.u32() == 0
assert s.u32() == 0
self.actor_slots = [self.SlotAssignment(stream) for i in range(cActorSlots)]
self.actor_iks = [self.NamespaceSlotSuffix(stream) for i in range(s.i32())]
assert s.u32() == DEADBEEF
self.additive_clip = ExternalResource(s.tgi('ITG'))
self.clip_pattern = s.p32(size=16)
s.align()
self.additive_clip_pattern = s.p32(size=16)
s.align()
assert s.u32() == DEADBEEF
AnimationNode.read_rcol(self, stream, rcol)
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.framerate = s.f32()
cFrames = s.i32()
offsets = [s.u32() for i in range(cFrames)]
offsets.append(-1)
for frame_index in range(cFrames):
offset = offsets[frame_index]
next = offsets[frame_index + 1]
cBytes = next - offset if next > 0 else -1
data = stream.read(cBytes)
self.frames.append(data)
def read(self, stream, resource=None):
s = StreamReader(stream)
self.version_major = s.u32()
self.version_minor = s.u32()
cBones = s.i32()
self.bones = []
opposites = []
parents = []
self.__hashes = {}
for i in range(cBones):
bone = Bone(self)
bone.position = [s.f32() for i in range(3)]
bone.orientation = [s.f32() for i in range(4)]
bone.scale = [s.f32() for i in range(3)]
bone.name = s.p32()
opposites.append(s.i32())
parents.append(s.i32())
hash_name = s.u32()
if not hash_name == FNV32.hash(bone.name):
print("WARNING: Bone %s should have matching hash 0x%08X, but has 0x%08X",bone.name, FNV32.hash(bone.name),hash_name)
self.__hashes[hash] = bone
bone.flags = s.u32()
self.bones.append(bone)
for bone_index, opposite_index in enumerate(opposites):
if opposite_index >= 0:
self.bones[bone_index].opposite = self.bones[opposite_index]
for bone_index, parent_index in enumerate(parents):
if parent_index >= 0:
self.bones[bone_index].parent = self.bones[parent_index]
if self.version_major >= 4: self.name = s.p32()
self.ik_chains = []
cChains = s.i32()
for i in range(cChains):
chain = IKChain(self)
chain.read(stream)
self.ik_chains.append(chain)
def read(self, stream, resource=None):
s = StreamReader(stream)
assert s.chars(4) == self.TAG
self.version = s.u32()
cEvents = s.i32()
length = s.u32()
start_offset = s.u32()
assert (start_offset == 4 and cEvents > 0) or (start_offset == 0 == cEvents)
self.events = []
start = stream.tell()
for event_index in range(cEvents):
type = s.u16()
event = Event.get_event_class(type)()
event.read(stream)
self.events.append(event)
actual = stream.tell() - start
def read(self, stream, resource=None):
s = StreamReader(stream)
assert s.chars(4) == self.TAG
self.version = s.u32()
cEvents = s.i32()
length = s.u32()
start_offset = s.u32()
assert (start_offset == 4
and cEvents > 0) or (start_offset == 0 == cEvents)
self.events = []
start = stream.tell()
for event_index in range(cEvents):
type = s.u16()
event = Event.get_event_class(type)()
event.read(stream)
self.events.append(event)
actual = stream.tell() - start
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
self.flags = s.u32()
self.unknown = s.u32()
start = stream.tell()
stream.seek(0, SEEK_END)
end = stream.tell()
stream.seek(start, SEEK_SET)
self.buffer = []
last = 0
while stream.tell() < end:
cur = s.i32() if Flag.is_set(self.flags,
self.FLAGS.INDEX_32) else s.i16()
if Flag.is_set(self.flags, self.FLAGS.DIFFERENCED_INDICES):
cur += last
last = cur
self.buffer.append(cur)
def read(self, stream, keys):
s = StreamReader(stream)
tag = s.chars(4)
if not tag == self.TAG_TEXTURES or tag == self.TAG_NO_TEXTURES:
raise IOError("Invalid data, expected %s or %s, but got %s" %
(self.TAG_TEXTURES, self.TAG_NO_TEXTURES, tag))
zero = s.u32()
assert zero == 0
param_len = s.u32()
cParams = s.i32()
items = []
for i in range(cParams):
item = self.Item()
item.read_pointer(stream)
items.append(item)
start = stream.tell()
for item in items:
self.__parameters[item.name] = item.read_data(stream, keys)
end = stream.tell()
assert (end - start) == param_len
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_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.name = s.u32()
self.actors = [
rcol.get_block(s.u32(), ActorDefinition) for i in range(s.i32())
]
self.parameters = [
rcol.get_block(s.u32(), ParameterDefinition)
for i in range(s.i32())
]
self.states = [rcol.get_block(s.u32(), State) for i in range(s.i32())]
self.namespace_map = [self.ActorPair(stream) for i in range(s.i32())]
assert s.u32() == DEADBEEF
self.flags = s.u32()
self.default_priority = s.i32()
self.awareness_overlay_level = AnimationOverlay(s.i32())
for i in range(4):
assert s.u32() == 0
