def read(self, stream, cdi, floats):
assert isinstance(cdi, CurveDataInfo)
s = StreamReader(stream)
self.data = []
self.frame_index = s.u16()
flags = s.u16()
self.flags = flags >> 4
if cdi.flags.type == CurveDataType.VECTOR3_INDEXED:
for floatsRead in range(cdi.float_count()):
index = s.u16()
val = floats[index]
if flags & 1 << floatsRead: val *= -1
self.data.append(Frame.unpack(val, cdi.offset, cdi.scale))
else:
for packedRead in range(cdi.packed_count()):
if cdi.flags.type == CurveDataType.VECTOR3_PACKED:
packed = s.u32()
elif cdi.flags.type in (CurveDataType.VECTOR4_PACKED,
CurveDataType.SCALAR):
packed = s.u16()
else:
raise Exception("Unknown packed format type")
for packedIndex in range(
int(cdi.float_count() / cdi.packed_count())):
floatIndex = packedIndex + packedRead
bitsPerFloat = cdi.bits_per_float()
maxPackedVal = math.pow(2, bitsPerFloat) - 1.0
mask = int(maxPackedVal) << (packedIndex * bitsPerFloat)
val = ((packed & mask) >>
(packedIndex * bitsPerFloat)) / maxPackedVal
if flags & 1 << floatIndex: val *= -1.0
self.data.append(Frame.unpack(val, cdi.offset, cdi.scale))
return self
def read(self, stream, resources=None):
s = StreamReader(stream)
flags = s.u8()
self.type = (flags & 0x07) >> 0
self.static = ((flags & 0x08) >> 3) == 1
self.unknown = (flags & 0xF0) >> 4
return self
def read(self, stream, resources=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.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, resources=None):
s = StreamReader(stream)
self.weight = s.f32()
self.decision_graph_nodes = [
resources.get_block(s.u32(),
DecisionGraphNode.get_node_types())
]
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.next_state = rcol.get_block(s.u32(),
DecisionGraphNode.get_node_types())
DecisionGraphNode.read(self, stream, rcol)
def read(self, stream, resource=None):
s = StreamReader(stream)
self.version = s.u32()
tgi = TGIList(order='igt', count_size=8, package=resource, use_length=False)
tgi.begin_read(stream)
self.presets = [self.CasPreset(stream, tgi) for i in range(s.u32())]
self.part_name = s.s7(16, '>')
self.display_index = s.f32()
self.has_unique_texture_space = s.u8()
self.body_type = s.u32()
self.part_flags = s.u32()
self.age_gender_flags = s.u32()
self.clothing_category = s.u32()
self.naked_cas_part = tgi.get_resource(s.i8())
self.base_cas_part = tgi.get_resource(s.i8())
self.blend_fat = tgi.get_resource(s.i8())
self.blend_fit = tgi.get_resource(s.i8())
self.blend_thin = tgi.get_resource(s.i8())
self.blend_special = tgi.get_resource(s.i8())
self.draw_layer = s.u32()
self.sources = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.lod_infos = [CASLodInfo(stream) for i in range(s.u8())]
self.diffuse_refs = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.specular_refs = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.secondary_diffuse_refs = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.secondary_specular_refs = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.slot_poses = [tgi.get_resource(s.i8()) for i in range(s.u8())]
self.shoe_material = s.s7(16, '>')
tgi.end_read(stream)
def read(self, stream, 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, resource=None):
"""
"""
s = StreamReader(stream)
tag = s.chars(4)
assert tag == self.MAGIC
self.major_version = s.u32()
self.minor_version = s.u32()
self.unknown1 = s.u32()
self.unknown2 = s.u32()
self.unknown3 = s.u32()
self.date_created = s.u32()
self.date_modified = s.u32()
self.index_major_version = s.u32()
self.index_entry_count = s.u32()
self.index_entry_offset = s.u32()
self.index_size = s.u32()
self.hole_count = s.u32()
self.hole_offset = s.u32()
self.hole_size = s.u32()
self.index_minor_version = s.u32()
self.index_offset = s.u32()
self.unknown4 = s.u32()
self.reserved = [0] * 24
for i in range(24):
self.reserved[i] = s.u32()
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_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.version = s.u32()
self.deltas = [
self.Item(s.u32(), [s.f32() for i in range(3)],
[s.f32() for i in range(3)], [s.f32() for i in range(4)])
]
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):
s = StreamReader(stream)
self.age_gender = s.u32()
self.edge_color = s.u32()
self.specular_color = s.u32()
self.specular_power = s.f32()
self.is_genetic = bool(s.u8())
def read(self, stream, resource=None):
Event.read(self, stream)
s = StreamReader(stream)
self.prop_actor_name = s.u32()
self.object_actor_name = s.u32()
self.slot_name = s.u32()
self.unknown4 = s.u32()
self.matrix = [[s.f32() for i in range(4)] for i in range(4)]
def read(self, stream, resources):
s = StreamReader(stream)
self.model = resources.get_block(s.u32(), ModelLod)
self.flags = s.u32()
self.id = s.u16()
self.is_sunshadow = bool(s.u16())
self.min_z = s.f32()
self.max_z = s.f32()
def read(self, stream, resource=None):
s = StreamReader(stream)
self.vertex_size = s.u32()
self.vertex_count = s.u32()
self.byte_offset = s.u32()
self.commands = [
s.u32() for cmd_index in range(int(self.vertex_size / 4))
]
def read(self, stream, resource=None):
s = StreamReader(stream)
self.version = s.u32()
cNames = s.u32()
for i in range(cNames):
iid = s.u64()
name = s.p32()
self.names[iid] = name
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, resource=None):
s = StreamReader(stream)
self.type = s.u32()
self.origin = [s.f32() for i in range(3)]
self.normal = [s.f32() for i in range(3)]
self.x_axis = [s.f32() for i in range(3)]
self.y_axis = [s.f32() for i in range(3)]
self.pair_offset = s.f32()
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(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(self, stream, resource=None):
Light.read(self, stream)
s = StreamReader(stream)
self.at = [s.f32() for i in range(3)]
self.falloff_angle = s.f32()
self.shade_light_rig_multiplier = s.f32()
self.bottom_angle = s.f32()
self.shade_colour = [s.f32() for i in range(3)]
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)
self.version = s.u32()
names = [s.s7(16, '>') for i in range(s.u32())]
poses = [[[s.f32() for j in range(3)] for i in range(4)]
for pose_index in range(s.u32())]
self.bones = [
self.Bone(names[i], pose) for i, pose in enumerate(poses)
]
def read(self, stream, resource=None):
Event.read(self, stream)
s = StreamReader(stream)
self.unknown4 = s.u32()
self.unknown5 = s.u32()
self.effect_name = s.u32()
self.actor_name = s.u32()
self.slot_name = s.u32()
self.unknown6 = 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, resources):
s = StreamReader(stream)
self.age_gender = s.u32()
self.type_flags = s.u32()
self.specular = resources.get_resource(s.u32())
self.detail_dark = resources.get_resource(s.u32())
self.detail_light = resources.get_resource(s.u32())
self.normal = resources.get_resource(s.u32())
self.overlay = resources.get_resource(s.u32())
def read(self, stream, resource=None):
Light.read(self, stream)
s = StreamReader(stream)
self.at = [s.f32() for i in range(3)]
self.right = [s.f32() for i in range(3)]
self.width = s.f32()
self.height = s.f32()
self.falloff_angle = s.f32()
self.window_top_bottom_angle = s.f32()
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.target = rcol.get_block(s.u32(), ActorDefinition)
self.operation = s.u32()
self.operand = s.u32()
for i in range(3):
assert s.u32() == 0
MulticastDecisionGraphNode.read(self, stream, rcol)
