def read(self, f, endian):
address = f.tell()
self.data = BCSPart(
*struct.unpack(endian +
BCS_PART_BYTE_ORDER, f.read(BCS_PART_SIZE)))
self.name = re.sub(r'[^\x20-\x7f]', '', self.name.decode())
# print(self.data)
if self.emd_offset:
self.emd_name = read_name(f, address + self.emd_offset)
if self.emm_offset:
self.emm_name = read_name(f, address + self.emm_offset)
# print(f'emm: {self.emm_name}')
if self.emb_offset:
self.emb_name = read_name(f, address + self.emb_offset)
# print(f'emb: {self.emb_name}')
if self.ean_offset:
self.ean_name = read_name(f, address + self.ean_offset)
# print(f'ean: {self.ean_name}')
# Color Selectors
self.color_selectors.clear()
for i in range(self.num_color_selectors):
f.seek(address + self.color_selector_offset +
i * BCS_COLOR_SELECTOR_SIZE)
color_selector = ColorSelector()
color_selector.read(f, endian)
self.color_selectors.append(color_selector)
# Physics
self.physics.clear()
for i in range(self.num_physics):
f.seek(address + self.physics_offset + i * BCS_PHYSICS_SIZE)
physics = Physics()
physics.read(f, endian)
self.physics.append(physics)
# Unk3 Hack
self.unk3.clear()
if self.num_unk3:
f.seek(address + self.unk3_offset)
unk3_start_address = f.tell()
i = 0
while i < self.num_unk3:
unk3 = struct.unpack(endian + "I", f.read(4))[0]
if unk3 == 8:
i += 1
unk3 = struct.unpack(endian + "I", f.read(4))[0]
while True:
h1 = unk3 & 0xFFFF
h2 = unk3 >> 16
unk3 = struct.unpack(endian + "I", f.read(4))[0]
if h1 != h2:
break
unk3_end_address = f.tell() - 4 # remove a byte
unk3_length = unk3_end_address - unk3_start_address
f.seek(unk3_start_address)
self.unk3 = list(
struct.unpack(endian + unk3_length * "B", f.read(unk3_length)))
def read(self, f, endian):
address = f.tell()
self.data = BCSBone(
*struct.unpack(endian +
BCS_BONE_BYTE_ORDER, f.read(BCS_BONE_SIZE)))
if self.name_offset:
self.name = read_name(f, address + self.name_offset)
def read(self, f, endian):
address = f.tell()
self.data = BCSPartColor(*struct.unpack(
endian + BCS_PART_COLOR_BYTE_ORDER, f.read(BCS_PART_COLOR_SIZE)))
# print(self.data)
if self.name_offset:
self.name = read_name(f, address + self.name_offset)
# print(f'name: {self.name}')
self.colors.clear()
f.seek(address + self.colors_offset)
for i in range(self.num):
color = Color()
color.read(f, endian)
self.colors.append(color)
def read(self, f, endian):
base_skeleton_address = f.tell()
self.data = ESKHeader(*struct.unpack(endian + ESK_HEADER_BYTE_ORDER, f.read(ESK_HEADER_SIZE)))
# print("--------------- read ESK \n[{}] bone_count : {}, flag : {}, bone_indices_offset : [{}],"
# " bone_names_offset : [{}], skinning_matrix_offset : [{}], transform_matrix_offset : [{}],"
# " unknown_offset_0 : [{}], unknown_offset_1 : [{}], unknown_offset_2 : [{}], unknown_offset_3 : [{}]"
# .format(base_skeleton_address, self.bone_count, self.flag, self.bone_indices_offset,
# self.bone_names_offset, self.skinning_matrix_offset, self.transform_matrix_offset,
# self.unknown_offset_0, self.unknown_offset_1, self.unknown_offset_2, self.unknown_offset_3))
self.bones.clear()
for i in range(self.bone_count):
bone = Bone(i)
# print("pyxenoverse {}".format(i))
# Read Bone Indices
f.seek(base_skeleton_address + self.bone_indices_offset + i * 8)
bone.read_indices(f, endian)
# print(" Indices - parent: {}, child: {}, sibling(next): {}, index4: {}".format(
# pyxenoverse.parent_index, pyxenoverse.child_index, pyxenoverse.sibling_index, pyxenoverse.index_4))
# Read Bone Name
f.seek(base_skeleton_address + self.bone_names_offset + i * 4)
address = struct.unpack(endian + 'I', f.read(4))[0]
f.seek(base_skeleton_address + address)
bone.name = read_name(f)
# print(" Name - {}".format(pyxenoverse.name))
# Read Skinning Matrices
f.seek(base_skeleton_address + self.skinning_matrix_offset + i * 48)
bone.read_skinning_matrix(f, endian)
# print(" Skinning matrix\n{}\n".format(pyxenoverse.get_skinning_matrix_debug()))
if self.transform_matrix_offset:
# Read Bone matrices
f.seek(base_skeleton_address + self.transform_matrix_offset + i * 64)
bone.read_transform_matrix(f, endian)
# print(" Transform matrix\n{}\n".format(pyxenoverse.get_transform_matrix_debug()))
self.bones.append(bone)
f.seek(base_skeleton_address + self.unknown_offset_0)
unknown_0 = struct.unpack('<I', f.read(4))[0]
self.m_have_128_unknown_bytes = (unknown_0 == 5)
def read(self, f, endian):
self.data = EANHeader(
*struct.unpack(endian +
EAN_HEADER_BYTE_ORDER, f.read(EAN_HEADER_SIZE)))
# print("--------------- read EAN \n[8] unkTotal : {}, animation_count : {}, SkeletonOffset : [{}]"
# " animation_keyframes_offset : [{}], animation_names_offset : [{}]".format(
# self.unknown_total, self.animation_count, self.skeleton_offset, self.animation_keyframes_offset,
# self.animation_names_offset))
# Read Skeleton
# print("----------- Skeleton")
f.seek(self.skeleton_offset)
self.skeleton = ESK(endian)
self.skeleton.read(f, endian)
# Read Animations
# print("----------- Animations KeyFrames")
self.animations.clear()
for i in range(self.animation_count):
animation = Animation(self)
# Read Keyframes
f.seek(self.animation_keyframes_offset + i * 4)
address = struct.unpack(endian + 'I', f.read(4))[0]
f.seek(address)
# print("------ animation {} : [{}] => [{}]".format(i, self.animation_keyframes_offset + i * 4, address))
animation.read(f, endian)
# Read Name
f.seek(self.animation_names_offset + i * 4)
address = struct.unpack(endian + 'I', f.read(4))[0]
f.seek(address)
animation.name = read_name(f)
# print("------ animation {} : [{}] => [{}] => {}".format(
# i, self.animation_names_offset + i * 4, address, animation.get_name()))
self.animations.append(animation)
def read(self, f, endian):
address = f.tell()
self.data = BCSPhysics(
*struct.unpack(endian +
BCS_PHYSICS_BYTE_ORDER, f.read(BCS_PHYSICS_SIZE)))
self.name = re.sub(r'[^\x20-\x7f]', '', self.name.decode())
# print(self.data)
if self.emd_offset:
self.emd_name = read_name(f, address + self.emd_offset)
# print(f'emd: {self.emd_name}')
if self.emm_offset:
self.emm_name = read_name(f, address + self.emm_offset)
# print(f'emm: {self.emm_name}')
if self.emb_offset:
self.emb_name = read_name(f, address + self.emb_offset)
# print(f'emb: {self.emb_name}')
if self.ean_offset:
self.ean_name = read_name(f, address + self.ean_offset)
# print(f'ean: {self.ean_name}')
if self.bone_offset:
self.bone_name = read_name(f, address + self.bone_offset)
# print(f'bone: {self.bone_name}')
if self.scd_offset:
self.scd_name = read_name(f, address + self.scd_offset)