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_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_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, 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_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_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(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): 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.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_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_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