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):
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):
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.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_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)
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):
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)
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_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)
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)
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(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_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(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_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.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_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(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(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_rcol(self, stream, rcol):
s = StreamWriter(stream)
s.i32(len(self.segments))
for segment in self.segments:
segment.write(stream)
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)
