def read_field(self, reader: ByteIO):
count = self.count
if count == 0: count = 1
exit_point = 0
if self.indirection_bytes:
if self.indirection_level > 1:
raise NotImplementedError(
'More than one indirection, not yet handled')
if self.count > 0:
raise NotImplementedError(
'Indirection.Count > 0 && field.Count > 0')
indir = self.indirection_bytes[0]
entry = reader.tell()
offset = reader.read_uint32()
if indir == 0x03:
pass
if not offset:
return None
exit_point = reader.tell()
# with reader.save_current_pos():
# reader.seek(entry+offset)
# return self.read_field_data(reader)
elif indir == 0x04:
# data = []
count = reader.read_uint32()
exit_point = reader.tell()
# if count>0:
# with reader.save_current_pos():
# reader.seek(entry + offset)
# for _ in range(count):
# data.append(self.read_field(reader))
# return data
else:
raise NotImplementedError("Unknown indirection. ({0})".format(
hex(indir)))
if self.count > 0 and self.indirection_level > 0:
array = []
with reader.save_current_pos():
reader.seek(entry + offset)
for _ in range(count):
data = self.read_field_data(reader)
array.append(data)
if exit_point:
reader.seek(exit_point)
return array
else:
array = []
with reader.save_current_pos():
reader.seek(entry + offset)
for _ in range(count):
data = self.read_field_data(reader)
array.append(data)
if exit_point:
reader.seek(exit_point)
return array
else:
if exit_point:
reader.seek(exit_point)
return self.read_field_data(reader)
def read(self, reader: ByteIO):
entry = reader.tell()
self.name_offset = reader.read_int32()
self.name = reader.read_from_offset(entry + self.name_offset,
reader.read_ascii_string)
entry = reader.tell()
self.value_offset = reader.read_int32()
self.value = reader.read_from_offset(entry + self.value_offset,
reader.read_ascii_string)
def read(self, reader: ByteIO):
entry = reader.tell()
self.content_relative_filename_offset = reader.read_int32()
self.content_relative_filename = reader.read_from_offset(entry + self.content_relative_filename_offset,
reader.read_ascii_string)
entry = reader.tell()
self.content_search_path_offset = reader.read_int32()
self.content_search_path = reader.read_from_offset(entry + self.content_search_path_offset,
reader.read_ascii_string)
def read(self, reader: ByteIO):
entry = reader.tell()
self.string_offset = reader.read_int32()
self.string = reader.read_from_offset(entry + self.string_offset, reader.read_ascii_string)
entry = reader.tell()
self.compiler_identifier_offset = reader.read_int32()
self.compiler_identifier = reader.read_from_offset(entry + self.compiler_identifier_offset,
reader.read_ascii_string)
self.fingerprint = reader.read_uint32()
self.user_data = reader.read_uint32()
def read(self, reader: ByteIO):
entry = reader.tell()
self.parameter_name_offset = reader.read_int32()
self.parameter_name = reader.read_from_offset(entry + self.parameter_name_offset,
reader.read_ascii_string)
entry = reader.tell()
self.parameter_type_offset = reader.read_int32()
self.parameter_type = reader.read_from_offset(entry + self.parameter_type_offset,
reader.read_ascii_string)
self.fingerprint = reader.read_uint32()
self.fingerprint_default = reader.read_uint32()
def read(self, reader: ByteIO):
entry = reader.tell()
self.material_id = reader.read_int16()
self.replacement_material_name_offset = reader.read_int32()
self.replacement_material_name = reader.read_from_offset(self.replacement_material_name_offset,
reader.read_ascii_string)
return self
def read(self, reader: ByteIO):
entry = reader.tell()
self.vertex_count = reader.read_uint32()
self.vertex_offset = reader.read_uint32()
self.index_count = reader.read_uint32()
self.index_offset = reader.read_uint32()
self.strip_count = reader.read_uint32()
self.strip_offset = reader.read_uint32()
self.flags = StripGroupFlags(reader.read_uint8())
global extra_8
if extra_8:
self.topology_indices_count = reader.read_uint32()
self.topology_offset = reader.read_uint32()
with reader.save_current_pos():
reader.seek(entry + self.index_offset)
for _ in range(self.index_count):
self.vtx_indexes.append(reader.read_uint16())
reader.seek(entry + self.vertex_offset)
for _ in range(self.vertex_count):
SourceVtxVertex().read(reader, self)
reader.seek(entry + self.strip_offset)
for _ in range(self.strip_count):
SourceVtxStrip().read(reader, self)
if extra_8:
reader.seek(entry + self.topology_offset)
# for _ in range(self.topology_indices_count):
self.topology = (reader.read_bytes(self.topology_indices_count * 2))
return self
def read(self, reader: ByteIO):
entry = reader.tell()
self.name = reader.read_ascii_string()
reader.seek(entry + 36)
self.format = DXGI_FORMAT(reader.read_int32())
self.offset = reader.read_uint32()
reader.skip(12)
def read(self, reader: ByteIO):
self.r_id = reader.read_int64()
entry = reader.tell()
self.resource_name_offset = reader.read_int64()
if self.resource_name_offset:
self.resource_name = reader.read_from_offset(
entry + self.resource_name_offset, reader.read_ascii_string)
def read(self, reader: ByteIO):
entry = reader.tell()
self.model_count, self.model_offset = reader.read_fmt('II')
with reader.save_current_pos():
reader.seek(entry + self.model_offset)
for _ in range(self.model_count):
self.vtx_models.append(SourceVtxModel().read(reader))
return self
def read(self, reader: ByteIO):
entry = reader.tell()
self.lodCount, self.lodOffset = reader.read_fmt('ii')
with reader.save_current_pos():
if self.lodCount > 0 and self.lodOffset != 0:
reader.seek(entry + self.lodOffset)
for _ in range(self.lodCount):
self.vtx_model_lods.append(SourceVtxModelLod().read(reader, self))
return self
def read(self, reader: ByteIO):
entry = reader.tell()
self.scale = [reader.read_uint32() for _ in range(6)]
self.offset = [reader.read_uint32() for _ in range(6)]
for offset in self.offset:
with reader.save_current_pos():
reader.seek(entry + offset)
self.theAnimValues.append(SourceMdlAnimationValue(reader.read_uint16()))
return self
def read(self, reader: ByteIO):
fourcc = reader.read_bytes(4)
assert tuple(fourcc) == self.SIG, 'Invalid KV Signature'
encoding = reader.read_bytes(16)
assert tuple(encoding) == self.ENCODING, 'Unrecognized KV3 Encoding'
format = reader.read_bytes(16)
assert tuple(format) == self.FORMAT, 'Unrecognised KV3 Format'
self.flags = reader.read_bytes(4)
if self.flags[3] & 0x80:
self.buffer.write_bytes(
reader.read_bytes(self.info_block.block_size -
(reader.tell() -
self.info_block.absolute_offset)))
working = True
while reader.tell() != reader.size() and working:
block_mask = reader.read_uint16()
for i in range(16):
if block_mask & (1 << i) > 0:
offset_and_size = reader.read_uint16()
offset = ((offset_and_size & 0xFFF0) >> 4) + 1
size = (offset_and_size & 0x000F) + 3
lookup_size = offset if offset < size else size
entry = self.buffer.tell()
self.buffer.seek(entry - offset)
data = self.buffer.read_bytes(lookup_size)
self.buffer.seek(entry)
while size > 0:
self.buffer.write_bytes(
data[:lookup_size if lookup_size < size else size])
size -= lookup_size
else:
data = reader.read_int8()
self.buffer.write_int8(data)
if self.buffer.size() == (self.flags[2] << 16) + (
self.flags[1] << 8) + self.flags[0]:
working = False
break
self.buffer.seek(0)
string_count = self.buffer.read_uint32()
for i in range(string_count):
self.strings.append(self.buffer.read_ascii_string())
self.parse(self.buffer, self.kv, True)
self.buffer.close()
del self.buffer
def read(self, reader: ByteIO):
self.introspection_version = reader.read_int32()
self.s_id = reader.read_int32()
entry = reader.tell()
self.name_offset = reader.read_int32()
self.name = reader.read_from_offset(entry + self.name_offset,
reader.read_ascii_string)
self.disc_crc = reader.read_int32()
self.user_version = reader.read_uint32()
entry = reader.tell()
self.field_offset = reader.read_int32()
self.field_count = reader.read_int32()
with reader.save_current_pos():
if self.field_count > 0:
reader.seek(entry + self.field_offset)
for n in range(self.field_count):
field = NTROEnumField(self)
field.read(reader)
self.fields.append(field)
def read(self, reader: ByteIO, block_info: InfoBlock = None):
self.info_block = block_info
entry = reader.tell()
self.name_offset = reader.read_int32()
self.name = reader.read_from_offset(entry + self.name_offset,
reader.read_ascii_string)
self.count = reader.read_int16()
self.on_disc_size = reader.read_int16()
entry = reader.tell()
self.indirection_bytes_offset = reader.read_int32()
self.indirection_level = reader.read_int32()
with reader.save_current_pos():
reader.seek(entry + self.indirection_bytes_offset)
indir_level = self.indirection_level if self.indirection_level < 10 else 10
for _ in range(indir_level):
self.indirection_bytes.append(reader.read_int8())
self.data_type = reader.read_int32()
self.type = KeyValueDataType(reader.read_int16())
reader.skip(2)
def read(self, reader: ByteIO, mdl: SourceMdlFileDataV10):
self.boneOffset = reader.tell()
self.name = reader.read_ascii_string(32)
self.parentBoneIndex = reader.read_int32()
self.flags = reader.read_int32()
self.boneControllerIndex = [reader.read_int32() for _ in range(6)]
self.position.read(reader)
self.rotation.read(reader)
self.scale = [reader.read_float() for _ in range(6)]
mdl.bones.append(self)
def read(self, reader: ByteIO, block_info: InfoBlock = None):
self.info_block = block_info
self.entry = reader.tell()
self.resource_entry_offset = reader.read_int32()
self.resource_count = reader.read_int32()
with reader.save_current_pos():
reader.seek(self.entry + self.resource_entry_offset)
for n in range(self.resource_count):
resource = RERLResource()
resource.read(reader)
self.resources.append(resource)
def read(self, reader: ByteIO):
entry = reader.tell()
self.nameOffset = reader.read_uint32()
self.thePathFileName = reader.read_from_offset(
entry + self.nameOffset, reader.read_ascii_string)
self.flags = reader.read_uint32()
self.used = reader.read_uint32()
self.unused1 = reader.read_uint32()
self.materialP = reader.read_uint32()
self.clientMaterialP = reader.read_uint32()
self.unused = [reader.read_uint32() for _ in range(5)]
def read_struct(self, reader: ByteIO):
# print('Reading struct {}'.format(self.name))
struct_data = {}
entry = reader.tell()
for field in self.fields:
reader.seek(entry + field.on_disc_size)
struct_data[field.name] = field.read_field(reader)
# print(struct_data)
reader.seek(entry + self.disc_size)
# print(struct_data)
return struct_data
def read(self, reader: ByteIO):
entry = reader.tell()
self.replacements_count = reader.read_int32()
self.replacement_offset = reader.read_int32()
with reader.save_current_pos():
reader.seek(entry + self.replacement_offset)
for _ in range(self.replacements_count):
mat = MaterialReplacement()
mat.read(reader)
self.replacements.append(mat)
return self
def read(self, reader: ByteIO):
entry = reader.tell()
self.strip_group_count = reader.read_uint32()
self.strip_group_offset = reader.read_uint32()
self.flags = reader.read_uint8()
with reader.save_current_pos():
if self.strip_group_offset > 0:
reader.seek(entry + self.strip_group_offset)
for _ in range(self.strip_group_count):
self.vtx_strip_groups.append(SourceVtxStripGroup().read(reader))
return self
def read(self, reader: ByteIO, block_info: InfoBlock = None):
self.info_block = block_info
entry = reader.tell()
self.vertex_offset = reader.read_uint32()
self.vertex_count = reader.read_uint32()
with reader.save_current_pos():
reader.seek(entry + self.vertex_offset)
for _ in range(self.vertex_count):
v_buffer = VertexBuffer()
v_buffer.read(reader)
self.vertex_buffer.append(v_buffer)
entry = reader.tell()
self.index_offset = reader.read_uint32()
self.index_count = reader.read_uint32()
with reader.save_current_pos():
reader.seek(entry + self.index_offset)
for _ in range(self.index_count):
i_buffer = IndexBuffer()
i_buffer.read(reader)
self.index_buffer.append(i_buffer)
def read(self,reader:ByteIO):
entry = reader.tell()
self.cycle = reader.read_float()
self.eventIndex = reader.read_uint32()
self.eventType = reader.read_uint32()
self.options = [reader.read_uint8() for _ in range(64)]
self.nameOffset = reader.read_uint32()
if self.nameOffset:
self.theName = reader.read_from_offset(self.nameOffset+entry,reader.read_ascii_string)
else:
self.theName = str(self.eventIndex)
return self
def read(self, reader: ByteIO, block_info: InfoBlock = None):
self.info_block = block_info
self.introspection_version = reader.read_int32()
entry = reader.tell()
self.struct_offset = reader.read_int32()
self.struct_count = reader.read_int32()
with reader.save_current_pos():
reader.seek(entry + self.struct_offset)
for n in range(self.struct_count):
struct = NTROStruct(self)
struct.read(reader)
self.structs.append(struct)
entry = reader.tell()
self.enum_offset = reader.read_int32()
self.enum_count = reader.read_int32()
with reader.save_current_pos():
reader.seek(entry + self.enum_offset)
for n in range(self.enum_count):
enum = NTROEnum(self)
enum.read(reader)
self.enums.append(enum)
def read(self, reader: ByteIO, model: SourceVtxModel):
entry = reader.tell()
self.lod = len(model.vtx_model_lods)
self.meshCount = reader.read_uint32()
self.meshOffset = reader.read_uint32()
self.switchPoint = reader.read_float()
with reader.save_current_pos():
if self.meshOffset > 0:
reader.seek(entry + self.meshOffset)
for _ in range(self.meshCount):
self.vtx_meshes.append(SourceVtxMesh().read(reader))
return self
def read(self, reader: ByteIO):
self.count = reader.read_uint32()
self.size = reader.read_uint32()
entry = reader.tell()
self.attributes_offset = reader.read_uint32()
self.attributes_count = reader.read_uint32()
with reader.save_current_pos():
reader.seek(entry + self.attributes_offset)
for _ in range(self.attributes_count):
v_attrib = VertexAttribute()
v_attrib.read(reader)
self.attributes.append(v_attrib)
entry = reader.tell()
self.offset = reader.read_uint32()
self.total_size = reader.read_uint32()
with reader.save_current_pos():
reader.seek(entry + self.offset)
assert self.total_size == self.size * self.count
self.buffer = ByteIO(byte_object=reader.read_bytes(self.count *
self.size))
self.read_buffer()
def read(self, reader: ByteIO):
self.count = reader.read_uint32()
self.size = reader.read_uint32()
self.unk1 = reader.read_uint32()
self.unk2 = reader.read_uint32()
entry = reader.tell()
self.offset = reader.read_uint32()
self.total_size = reader.read_uint32()
with reader.save_current_pos():
reader.seek(entry + self.offset)
assert self.total_size == self.size * self.count
self.buffer = ByteIO(byte_object=reader.read_bytes(self.count *
self.size))
self.read_buffer()
def read(self, reader: ByteIO, stripgroup: SourceVtxStripGroup):
entry = reader.tell()
self.index_count = reader.read_uint32()
self.index_mesh_index = reader.read_uint32()
self.vertex_count = reader.read_uint32()
self.vertex_mesh_index = reader.read_uint32()
self.bone_count = reader.read_uint16()
self.flags = StripHeaderFlags(reader.read_uint8())
self.bone_state_change_count = reader.read_uint32()
self.bone_state_change_offset = reader.read_uint32()
global extra_8
if extra_8:
self.topology_indices_count = reader.read_int32()
self.topology_offset = reader.read_int32()
# print('Strip end',reader.tell())
stripgroup.vtx_strips.append(self)
def read(self, reader: ByteIO, MDL: SourceMdlFileData):
entry = reader.tell()
self.entry = entry
self.baseHeaderOffset = reader.read_int32()
self.nameOffset = reader.read_int32()
self.theName = reader.read_from_offset(entry + self.nameOffset, reader.read_ascii_string)
self.fps = reader.read_float()
self.flags = self.STUDIO(reader.read_uint32())
self.frameCount = reader.read_uint32()
self.movementCount = reader.read_uint32()
self.movementOffset = reader.read_uint32()
self.unused1 = [reader.read_uint32() for _ in range(6)]
self.animBlock = reader.read_uint32()
self.animOffset = reader.read_uint32()
self.ikRuleCount = reader.read_uint32()
self.ikRuleOffset = reader.read_uint32()
self.animblockIkRuleOffset = reader.read_uint32()
self.localHierarchyCount = reader.read_uint32()
self.localHierarchyOffset = reader.read_uint32()
self.sectionOffset = reader.read_uint32()
self.sectionFrameCount = reader.read_uint32()
self.spanFrameCount = reader.read_uint16()
self.spanCount = reader.read_uint16()
self.spanOffset = reader.read_uint32()
self.spanStallTime = reader.read_float()
self.fileOffsetStart2 = entry + self.spanOffset
self.fileOffsetEnd2 = entry + self.spanOffset-1
if self.spanFrameCount!=0 or self.spanCount!=0 or self.spanOffset!=0 or self.spanStallTime!=0:
for bone_index in range(len(MDL.bones)):
bone = MDL.bones[bone_index] #type: SourceMdlBone
if bone.flags & SourceMdlBone.BONE_HAS_SAVEFRAME_POS:
self.fileOffsetEnd2 += self.spanCount * 6
if bone.flags & SourceMdlBone.BONE_HAS_SAVEFRAME_ROT:
self.fileOffsetEnd2 += self.spanCount * 8
return self
def read(self, reader: ByteIO):
entry = reader.tell()
self.boneIndex = reader.read_uint32()
self.boneNewParentIndex = reader.read_uint32()
self.startInfluence = reader.read_float()
self.peakInfluence = reader.read_float()
self.tailInfluence = reader.read_float()
self.endInfluence = reader.read_float()
self.startFrameIndex = reader.read_uint32()
self.localAnimOffset = reader.read_uint32()
if self.localAnimOffset != 0:
with reader.save_current_pos():
reader.seek(entry + self.localAnimOffset)
self.theLocalAnims.read(reader)
self.unused = [reader.read_uint32() for _ in range(4)]
return self