def write(self, stream, resources=None): s = StreamWriter(stream) s.u32(self.version) tgi = TGIList() tgi.begin_write(stream) if self.version >= 0x00000007: ProductBase.write_presets(stream,self.presets,tgi) self.product_info.write(stream,tgi) s.i32(tgi.get_resource_index(self.model)) s.i32(tgi.get_resource_index(self.diagonal_model)) s.i32(tgi.get_resource_index(self.post_model)) s.i32(self.post_tile_spacing) s.i8(1 if self.can_walk_over else 0) if self.version >= 0x00000008: if self.version >= 0x0000000A: s.i8(1 if self.should_not_get_thick_snow else 0) s.i8(1 if self.snow_post_shape_is_circle else 0) s.f32(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.i8(1 if self.has_wall else 0) if self.version < 0x0000000A or self.has_wall: s.i8(1 if self.raise_fence_geometry_above_wall else 0) s.i32(tgi.get_resource_index(self.wall)) tgi.end_write(stream)
def write(self, stream, resources=None): s = StreamWriter(stream) s.u32(self.version) tgi = resources use_tgi = not isinstance(tgi, TGIList) if use_tgi: tgi = TGIList(order='IGT', use_length=False, package=resources, count_size=8) tgi.begin_write(self, stream) if self.version >= 7: s.i8(len(self.fabrics)) for fabric in self.fabrics: s.i8(tgi.get_resource_index(fabric)) fabric_len = 0 with BytesIO() as fabric_stream: fabric.write(fabric_stream, tgi) s.u32(fabric_stream.tell()) fabric_stream.seek(0, SEEK_SET) stream.write(fabric_stream.read(-1)) s.u32(self.target_size) s.u32(self.part_type) s.u8(0) s.i32(len(self.steps)) if self.version >= 0x08: s.u8(0) for step in self.steps: self.write_step(stream, tgi, step) if use_tgi: tgi.end_read(stream) else: s.u32(0)
def write_rcol(self, stream, rcol): self.write_tag(stream) s = StreamWriter(stream) s.u32(self.version) cBones = len(self.bones) s.i32(cBones) for i in range(cBones): s.hash(self.bones[i].name) for bone in self.bones: s.m43(bone.inverse_bind_pose)
def write_rcol(self, stream, rcol): s = StreamWriter(stream) s.u32(self.version) s.i32(len(self.deltas)) for delta in self.deltas: s.hash(delta.bone_name) for i in range(3): s.f32(delta.offset[i]) for i in range(3): s.f32(delta.scale[i]) for i in range(4): s.f32(delta.rotation[i])
def write_rcol(self, stream, rcol): s = StreamWriter(stream) self.write_tag(stream) s.u32(self.version) s.i32(len(self.outcomes)) for outcome in self.outcomes: outcome.write(stream, rcol) s.u32(DEADBEEF) s.u32(self.flags) DecisionGraphNode.write(self, stream, rcol)
def write_rcol(self, stream, rcol): s = StreamWriter(stream) s.u32(self.version) s.i32(len(self.deltas)) for hash in self.deltas: delta = self.deltas[hash] s.u32(hash) delta.write(stream)
def write_rcol(self, stream, rcol): s = StreamWriter(stream) self.write_tag(stream) s.u32(self.version) s.hash(self.name) s.u32(self.properties) s.u32(rcol.get_block_index(self.decision_graph, DecisionGraph)) s.i32(len(self.transitions)) for transition in self.transitions: s.u32(rcol.get_block_index(transition, State)) s.u32(self.awareness_overlay_level)
def write_rcol(self, stream, rcol): s = StreamWriter(stream) self.write_tag(stream) s.u32(self.version) s.u32(0) s.i32(len(self.children)) for child in self.children: s.u32(rcol.get_block_index(child)) s.i32(len(self.parents)) for parent in self.parents: s.u32(rcol.get_block_index(parent)) s.u32(DEADBEEF)
def write(self, stream, resources=None): s = StreamWriter(stream) s.u32(self.version) tgi = TGIList() tgi.begin_write(stream) if self.version >= 0x00000003: ProductBase.write_presets(stream,self.presets,tgi) self.product_info.write(stream,tgi) s.i32(tgi.get_resource_index(self.railing_4x_model)) s.i32(tgi.get_resource_index(self.railing_1x_model)) s.i32(tgi.get_resource_index(self.post_model)) tgi.end_write(stream)
def write_rcol(self, stream, rcol): self.write_tag(stream) s = StreamWriter(stream) s.u32(self.version) s.u32(self.flags) s.u32(self.unknown) last = 0 for i in range(len(self.buffer)): cur = self.buffer[i] if Flag.is_set(self.flags, self.FLAGS.DIFFERENCED_INDICES): cur -= last last = self.buffer[i] s.i32(cur) if Flag.is_set(self.flags, self.FLAGS.INDEX_32) else s.i16(cur)
def write_rcol(self, stream, rcol): s = StreamWriter(stream) self.write_tag(stream) s.u32(self.version) s.f32(self.framerate) cFrames = len(self.frames) s.i32(cFrames) data_pos = stream.tell() + (cFrames * 4) for frame in self.frames: s.u32(data_pos) data_pos += len(frame) for frame in self.frames: stream.write(frame)
def write(self, stream, resources=None): s = StreamWriter(stream) s.u32(self.version) tgi = TGIList(package=resources) tgi.begin_write(stream) s.u64(self.locale_key) for indexer in self.indexers: s.u32(tgi.get_resource_index(indexer)) s.u32(0 if not self.is_bi_directional else 1) s.u32(self.cas_panel_group) s.i32(self.sort_index) s.u32(0) tgi.end_read(stream)
def write_presets(cls, stream,presets, resources): s = StreamWriter(stream) s.i32(len(presets)) ce = ComplateEncoder() for preset in presets: assert isinstance(preset,cls.BuildBuyPreset) s.i8(preset.unk1) if preset.unk1 != 1: s.i32(preset.unk2) preset_ptr = StreamPtr.begin_write(s) ce.serialize(preset.complate,stream,resources) preset_ptr.end() s.u32(preset.id)
def write_rcol(self, stream, rcol): s = StreamWriter(stream) self.write_tag(stream) s.u32(self.version) s.i32(len(self.lods)) self.bounds.write(stream) if self.version >= self.VERSION.EXTENDED: s.i32(len(self.extra_bounds)) for extra in self.extra_bounds: extra.write(stream) s.u32(self.fade_type) s.f32(self.custom_fade_distance) for lod in self.lods: lod.write_rcol(stream, rcol)
def write_rcol(self, stream, rcol): s = StreamWriter(stream) def write_names(slots): for slot in slots: s.hash(slot.name) def write_bones(slots): for slot in slots: s.hash(slot.bone_name) def write_transforms(slots): for slot in slots: s.m43(slot.transform) def write_offsets(slots): if any(slots): s.i32(len(list(filter(lambda slot: slot.offset != None, slots)))) for i, slot in enumerate(slots): if slot.offset != None: s.i32(i) for i in range(3): s.i32(slot.offset.position) for i in range(3): s.i32(slot.offset.rotation) self.write_tag(stream) s.u32(self.version) s.i32(len(self.routing_slots)) s.i32(len(self.container_slots)) s.i32(len(self.effect_slots)) s.i32(len(self.target_slots)) s.i32(len(self.cone_slots)) write_names(self.routing_slots) write_bones(self.routing_slots) write_transforms(self.routing_slots) write_offsets(self.routing_slots) write_names(self.container_slots) write_bones(self.container_slots) for slot in self.container_slots: s.u32(slot.flags) write_transforms(self.container_slots) write_offsets(self.container_slots) write_names(self.effect_slots) write_bones(self.effect_slots) write_transforms(self.effect_slots) write_offsets(self.effect_slots) write_names(self.target_slots) write_bones(self.target_slots) write_transforms(self.target_slots) write_offsets(self.target_slots) write_names(self.cone_slots) write_bones(self.cone_slots) write_transforms(self.cone_slots) for slot in self.cone_slots: s.f32(slot.radius) s.f32(slot.angle) write_offsets(self.cone_slots)
def write(self, stream, resource=None): s = StreamWriter(stream) s.i32(len(self.chains)) chain_pos = (4 * len(self.chains)) for targets in self.chains: s.u32(chain_pos) chain_pos += 8 + ((4 + IKSlotTarget.BYTE_SIZE) * len(targets)) for targets in self.chains: s.u32(0x7e7e7e7e) s.i32(len(targets)) target_pos = 4 * len(targets) for target_index in range(len(targets)): s.u32(target_pos) target_pos += IKSlotTarget.BYTE_SIZE for target in targets: target.write(stream)
def write(self, stream, resource=None): s = StreamWriter(stream) s.chars(self.TAG) s.u32(self.version) s.i32(len(self.events)) size_offset = stream.tell() s.u32(0) s.u32(0 if not len(self.events) else 4) start_pos = stream.tell() for event in self.events: s.u16(event.TYPE) event.write(stream) end_pos = stream.tell() stream.seek(size_offset, SEEK_SET) s.u32(end_pos - start_pos) stream.seek(end_pos, SEEK_SET)
def write(self, stream, resource=None): s = StreamWriter(stream) s.i32(len(self.chains)) chain_pos = (4 * len(self.chains)) for targets in self.chains: s.u32(chain_pos) chain_pos += 8 + ( (4 + IKSlotTarget.BYTE_SIZE) * len(targets)) for targets in self.chains: s.u32(0x7e7e7e7e) s.i32(len(targets)) target_pos = 4 * len(targets) for target_index in range(len(targets)): s.u32(target_pos) target_pos += IKSlotTarget.BYTE_SIZE for target in targets: target.write(stream)
def write(self, stream, resource=None): s = StreamWriter(stream) self.bounds.clear() s.hash(self.name) s.i8(self.priority) s.u32(self.footprint_type_flags) s.i32(len(self.points)) for point in self.points: self.bounds.add(point) s.f32(point[0]) s.f32(point[1]) s.u32(self.allow_intersection_flags) s.u32(self.surface_type_flags) s.u32(self.surface_attribute_flags) s.i8(self.level_offset) if self.ftpt.version >= Footprint.VERSION.EXTENDED: s.f32(self.elevation_offset) self.bounds.write(stream)
def write_rcol(self, stream, rcol): self.write_tag(stream) s = StreamWriter(stream) s.u32(self.version) s.i32(self.stride) s.i32(len(self.declarations)) s.u32(1 if self.is_extended_format else 0) for declaration in self.declarations: if self.is_extended_format: s.u32(declaration.usage) s.u32(declaration.usage_index) s.u32(declaration.format) s.u32(declaration.offset) else: s.u8(declaration.usage) s.u8(declaration.usage_index) s.u8(declaration.format) s.u8(declaration.offset)
def write(self, stream, resource=None): s = StreamWriter(stream) s.hash(self.name) s.i32(self.start_index) s.i32(self.start_vertex) s.i32(self.vertex_count) s.i32(self.index_count)
def write_data(self, stream, keys): s = StreamWriter(stream) self.pointer.end() if self.type_code == self.TYPE.FLOAT: if self.size32 == 1: s.f32(self.value) else: for f in self.value: s.f32(f) elif self.type_code == self.TYPE.INT: if self.size32 == 1: s.i32(self.value) else: for i in self.value: s.i32(i) elif self.type_code == self.TYPE.TEXTURE: if not keys == None: s.u32(keys.get_resource_index(self.value)) s.u32(0) s.u32(0) s.u32(0) else: s.tgi(self.value, 'ITG') s.u32(0)
def write_rcol(self, stream, rcol): s = StreamWriter(stream) self.write_tag(stream) s.u32(self.version) s.tgi(self.clip, 'ITG') s.tgi(self.track_mask, 'ITG') s.i32(len(self.actor_slots)) s.u32(0) s.u32(0) s.u32(0) for actor_slot in self.actor_slots: actor_slot.write(stream) s.i32(len(self.actor_iks)) for actor_ik in self.actor_iks: actor_ik.write(stream) s.u32(DEADBEEF) s.tgi(self.additive_clip) s.p32(self.clip_pattern, size=16) s.align() s.p32(self.additive_clip_pattern, size=16) s.align() s.u32(DEADBEEF) AnimationNode.write_rcol(self, stream, rcol)
def write_rcol(self, stream, rcol): s = StreamWriter(stream) self.write_tag(stream) s.u32(self.version) s.hash(self.name) s.i32(len(self.actors)) for actor in self.actors: s.u32(rcol.get_block_index(actor, ActorDefinition)) s.i32(len(self.parameters)) for parameter in self.parameters: s.u32(rcol.get_block_index(parameter, ParameterDefinition)) s.i32(len(self.states)) for state in self.states: s.u32(rcol.get_block_index(state, State)) s.i32(len(self.namespace_map)) for actor_pair in self.namespace_map: actor_pair.write(stream) s.u32(DEADBEEF) s.u32(self.flags) s.u32(self.default_priority) s.u32(self.awareness_overlay_level) for i in range(4): s.u32(0)
def write(self, stream, resource=None): s = StreamWriter(stream) s.u32(self.version_major) s.u32(self.version_minor) s.i32(len(self.bones)) for bone in self.bones: for i in range(3): s.f32(bone.position[i]) for i in range(4): s.f32(bone.orientation[i]) for i in range(3): s.f32(bone.scale[i]) assert bone.name != None, "Bone %s must have a name" s.p32(bone.name) s.i32(-1 if not bone.opposite in self.bones else self.bones.index(bone.opposite)) s.i32(-1 if not bone.parent in self.bones else self.bones.index(bone.parent)) s.u32(FNV32.hash(bone.name)) s.u32(bone.flags) if self.version_major >= 4: s.p32(self.name) s.i32(len(self.ik_chains)) for chain in self.ik_chains: chain.write(stream)
def write_rcol(self, stream, rcol): s = StreamWriter(stream) self.write_tag(stream) s.u32(self.version) s.i32(self.parameter_index) s.i32(len(self.items)) for item in self.items: s.hash(item.value) s.i32(len(item.actions)) for action in item.actions: s.u32(rcol.get_block_index(action, DecisionGraphNode.get_node_types())) s.u32(DEADBEEF) DecisionGraphNode.write(self, stream, rcol)
def write_rcol(self, stream, rcol): s = StreamWriter(stream) self.write_tag(stream) s.u32(self.version) s.i32(self.parameter_index) s.i32(len(self.items)) for item in self.items: s.hash(item.value) s.i32(len(item.actions)) for action in item.actions: s.u32( rcol.get_block_index(action, DecisionGraphNode.get_node_types())) s.u32(DEADBEEF) DecisionGraphNode.write(self, stream, rcol)
def write(self, stream, resource=None): s = StreamWriter(stream) s.u32(self.version) tgi = TGIList(use_length=self.version >= 7, add_eight=True) tgi.begin_write(stream) s.s7(self.part_name, 16, '>') s.u32(self.blend_type) s.i32(len(self.entries)) for entry in self.entries: s.u32(entry.region_flags) s.i32(len(entry.geom_entries)) for geom_entry in entry.geom_entries: geom_entry.write_rcol(stream, tgi) s.i32(len(entry.bone_entries)) for bone_entry in entry.bone_entries: bone_entry.write_rcol(stream, tgi) tgi.end_write(stream)
def write(self, stream, resource=None): s = StreamWriter(stream) s.u32(self.version_major) s.u32(self.version_minor) s.i32(len(self.bones)) for bone in self.bones: for i in range(3): s.f32(bone.position[i]) for i in range(4): s.f32(bone.orientation[i]) for i in range(3): s.f32(bone.scale[i]) assert bone.name != None, "Bone %s must have a name" s.p32(bone.name) s.i32(-1 if not bone.opposite in self.bones else self.bones. index(bone.opposite)) s.i32(-1 if not bone.parent in self.bones else self.bones. index(bone.parent)) s.u32(FNV32.hash(bone.name)) s.u32(bone.flags) if self.version_major >= 4: s.p32(self.name) s.i32(len(self.ik_chains)) for chain in self.ik_chains: chain.write(stream)
def write(self, stream, resources=None): s = StreamWriter(stream) s.f32(self.weight) s.i32(len(self.decision_graph_nodes)) for dgn in self.decision_graph_nodes: s.u32(resources.get_block_index(dgn))
def write(self, stream, resources=None): s = StreamWriter(stream) s.i32(len(self.on_complete)) for node in self.on_complete: s.u32(resources.get_block_index(node)) DecisionGraphNode.write(self, stream, resources)
def write(self, stream, resource=None): s = StreamWriter(stream) s.i32(len(self.declarations)) for declaration in self.declarations: declaration.write_rcol(stream)
def write(self, stream, rcol): s = StreamWriter(stream) len_offset = stream.tell() s.u32(0) start = stream.tell() s.hash(self.name) s.u32(rcol.get_block_index(self.material)) s.u32(rcol.get_block_index(self.vertex_format)) s.u32(rcol.get_block_index(self.vertex_buffer)) s.u32(rcol.get_block_index(self.index_buffer)) flags = self.primitive_type flags |= (self.flags << 8) s.u32(flags) s.u32(self.stream_offset) s.i32(self.start_vertex) s.i32(self.start_index) s.i32(self.min_vertex_index) s.i32(self.vertex_count) s.i32(self.primitive_count) self.bounds.write(stream) s.u32(rcol.get_block_index(self.skin_controller)) s.i32(len(self.bone_references)) for bone in self.bone_references: s.u32(bone) s.u32(rcol.get_block_index(self.scale_offsets)) s.i32(len(self.states)) for state in self.states: state.write_rcol(self, rcol) if self.parent.version > ModelLod.VERSION.DEFAULT: s.hash(self.parent_name) for i in range(3): s.f32(self.mirror_plane_normal[i]) s.f32(self.mirror_plane_offset) end = stream.tell() stream.seek(len_offset, SEEK_SET) s.u32(end - start) stream.seek(end, SEEK_SET)
def write(self, stream, resource=None): s = StreamWriter(stream) for bone_index in self.bones: s.i32(self.parent.get_bone_index(bone_index)) for info_node_index in self.info_nodes: s.i32(self.parent.get_bone_index(info_node_index)) s.i32(self.parent.get_bone_index(self.pole)) s.i32(self.parent.get_bone_index(self.slot_info)) s.i32(self.parent.get_bone_index(self.slot_offset)) s.i32(self.parent.get_bone_index(self.root))
def write_rcol(self, stream, rcol): s = StreamWriter(stream) s.i32(len(self.segments)) for segment in self.segments: segment.write(stream)
def write(self, stream, resource=None): s = StreamWriter(stream) for bone_index in self.bones: s.i32(self.parent.get_bone_index(bone_index)) if self.parent.version_major >= 4: for info_node_index in self.info_nodes: s.i32(self.parent.get_bone_index(info_node_index)) s.i32(self.parent.get_bone_index(self.pole)) if self.parent.version_major >= 4: s.i32(self.parent.get_bone_index(self.slot_info)) s.i32(self.parent.get_bone_index(self.slot_offset)) s.i32(self.parent.get_bone_index(self.root))
def write_rcol(self, stream, rcol): self.write_tag(stream) s = StreamWriter(stream) s.u32(self.version) s.i32(len(self.meshes)) for mesh in self.meshes: mesh.write(stream, rcol)