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_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_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.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_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.next_state = rcol.get_block(s.u32(),
DecisionGraphNode.get_node_types())
DecisionGraphNode.read(self, stream, rcol)
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, 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_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.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):
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_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):
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, 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_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, 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):
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)
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_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):
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(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(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()
self.actor = rcol.get_block(s.u32(), ActorDefinition)
self.parameter = s.u32()
self.prop = s.tgi('ITG')
for i in range(4):
assert s.u32() == 0
MulticastDecisionGraphNode.read(self, stream, rcol)
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_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
self.rig.key = s.tgi('ITG')
self.unknown = s.f32()
for i in range(self.RESERVED_COUNT): self.reserved[i] = s.u8()
cValues = s.u32()
self.bone_weights = [0.0] * cValues
for i in range(cValues): self.bone_weights[i] = s.f32()
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
self.actor = rcol.get_block(s.u32(), ActorDefinition)
self.parameter = s.u32()
self.prop = s.tgi('ITG')
for i in range(4):
assert s.u32() == 0
MulticastDecisionGraphNode.read(self, stream, rcol)
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)
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, resources=None):
s = StreamReader(stream)
assert s.u16() == self.TAG
self.id = s.u32()
self.time_code = s.f32()
self.unknown1 = s.f32()
self.unknown2 = s.f32()
self.unknown3 = s.u32()
length = s.u32()
self.name = s.zs()
assert len(self.name) == length
s.align()
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(self, stream, resources=None):
s = StreamReader(stream)
assert s.u16() == self.TAG
self.id = s.u32()
self.time_code = s.f32()
self.unknown1 = s.f32()
self.unknown2 = s.f32()
self.unknown3 = s.u32()
length = s.u32()
self.name = s.zs()
assert len(self.name) == length
s.align()
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
self.rig.key = s.tgi('ITG')
self.unknown = s.f32()
for i in range(self.RESERVED_COUNT):
self.reserved[i] = s.u8()
cValues = s.u32()
self.bone_weights = [0.0] * cValues
for i in range(cValues):
self.bone_weights[i] = s.f32()
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):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
name = s.hash(self.NAMES)
value = rcol.get_block(s.u32(), (MaterialDefinition, MaterialSet))
self.default_material = self.Element(name, value)
self.elements = []
cItems = s.u32()
for i in range(cItems):
value = rcol.get_block(s.u32(), (MaterialDefinition, MaterialSet))
name = s.hash(self.NAMES)
self.elements.append(self.Element(name, value))
def read_rcol(self, stream, rcol):
self.read_tag(stream)
s = StreamReader(stream)
self.version = s.u32()
name = s.hash(self.NAMES)
value = rcol.get_block(s.u32(),(MaterialDefinition, MaterialSet))
self.default_material = self.Element(name, value)
self.elements = []
cItems = s.u32()
for i in range(cItems):
value = rcol.get_block(s.u32(), (MaterialDefinition, MaterialSet))
name = s.hash(self.NAMES)
self.elements.append(self.Element(name, value))
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()
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)
tag = s.chars(8)
if not tag == '_pilC3S_': raise Exception("Not a valid _S3Clip_")
self.version = s.u32()
self.unknown1 = s.u32()
self.frame_duration = s.f32()
self.max_frame_count = s.u16()
self.unknown2 = s.u16()
cCurves = s.u32()
cFloats = s.u32()
curveOffset = StreamPtr.begin_read(s)
frameOffset = StreamPtr.begin_read(s)
nameOffset = StreamPtr.begin_read(s)
srcNameOffset = StreamPtr.begin_read(s)
curveOffset.end()
curves = []
for curveIndex in range(cCurves):
cdi = CurveDataInfo()
cdi.read(stream)
curves.append(cdi)
nameOffset.end()
self.name = s.zs()
srcNameOffset.end()
self.source_file_name = s.zs()
frameOffset.end()
indexedFloats = []
for floatIndex in range(cFloats):
indexedFloats.append(s.f32())
trackMap = {}
self.tracks = []
for curveIndex, cdi in enumerate(curves):
cdi.frame_data_ptr.end()
if cdi.track_key not in trackMap.keys():
t = Track(cdi.track_key)
trackMap[cdi.track_key] = t
self.tracks.append(t)
track = trackMap[cdi.track_key]
frames = []
for frameIndex in range(cdi.frame_count):
f = Frame()
f.read(stream, cdi, indexedFloats)
frames.append(f)
curve = Curve(cdi.type)
curve.flags = cdi.flags
curve.frames = frames
track[curve.type] = curve
return self
def read(self, stream, resources=None):
s = StreamReader(stream)
tag = s.chars(8)
if not tag == '_pilC3S_': raise Exception("Not a valid _S3Clip_")
self.version = s.u32()
self.unknown1 = s.u32()
self.frame_duration = s.f32()
self.max_frame_count = s.u16()
self.unknown2 = s.u16()
cCurves = s.u32()
cFloats = s.u32()
curveOffset = StreamPtr.begin_read(s)
frameOffset = StreamPtr.begin_read(s)
nameOffset = StreamPtr.begin_read(s)
srcNameOffset = StreamPtr.begin_read(s)
curveOffset.end()
curves = []
for curveIndex in range(cCurves):
cdi = CurveDataInfo()
cdi.read(stream)
curves.append(cdi)
nameOffset.end()
self.name = s.zs()
srcNameOffset.end()
self.source_file_name = s.zs()
frameOffset.end()
indexedFloats = []
for floatIndex in range(cFloats):
indexedFloats.append(s.f32())
trackMap = {}
self.tracks = []
for curveIndex,cdi in enumerate(curves):
cdi.frame_data_ptr.end()
if cdi.track_key not in trackMap.keys():
t = Track(cdi.track_key)
trackMap[cdi.track_key] = t
self.tracks.append(t)
track = trackMap[cdi.track_key]
frames = []
for frameIndex in range(cdi.frame_count):
f = Frame()
f.read(stream, cdi, indexedFloats)
frames.append(f)
curve = Curve(cdi.type)
curve.flags = cdi.flags
curve.frames = frames
track[curve.type] = curve
return self
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()
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.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.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_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
assert s.u32() == 0
self.swizzle_info = rcol.get_block(s.u32(), SwizzleInfo)
start = stream.tell()
stream.seek(0, SEEK_END)
end = stream.tell()
stream.seek(start, SEEK_SET)
length = end - start
self.buffer.stream.seek(0, SEEK_SET)
self.buffer.stream.truncate()
self.buffer.stream.write(stream.read(length))
self.buffer.stream.seek(0, SEEK_SET)
def read_rcol(self, stream, rcol):
s = StreamReader(stream)
self.read_tag(stream)
self.version = s.u32()
assert s.u32() == 0
self.swizzle_info = rcol.get_block(s.u32(), SwizzleInfo)
start = stream.tell()
stream.seek(0, SEEK_END)
end = stream.tell()
stream.seek(start, SEEK_SET)
length = end - start
self.buffer.stream.seek(0, SEEK_SET)
self.buffer.stream.truncate()
self.buffer.stream.write(stream.read(length))
self.buffer.stream.seek(0, SEEK_SET)
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(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.weight = s.f32()
self.decision_graph_nodes = [
resources.get_block(s.u32(),
DecisionGraphNode.get_node_types())
]
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, 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, resources=None):
s = StreamReader(stream)
s.version = s.u32()
tgi = TGIList(package=resources)
tgi.begin_read(stream)
self.components = [s.hash(self.component_hashes) for i in range(s.i8())]
self.component_data = {}
def read_component_data():
key = s.p32()
val = None
t = s.i8()
if t == 0x00:
val = t, s.p32()
elif t == 0x01:
val = t, tgi.get_resource(s.i32())
elif t == 0x02:
val = t, tgi.get_resource(s.i32())
elif t == 0x03:
val = t, s.p32()
elif t == 0x04:
val = t, s.u32()
self.component_data[key] = val
for i in range(s.i8()):
read_component_data()
self.visible = s.u8()
tgi.end_read(stream)
pass
