def children(data, visual):
chunked_reader = xray_io.ChunkedReader(data)
children_visuals = []
for child_id, child_data in chunked_reader:
child_visual = main(child_data, ogf=True, child=True)
children_visuals.append(child_visual)
return children_visuals
def dump_level(level_data, print):
chunked_reader = xray_io.ChunkedReader(level_data)
for chunk_id, chunk_data in chunked_reader:
if chunk_id == LevelChunks.HEADER:
read_header(chunk_data)
elif chunk_id == LevelChunks.TEXTURES:
read_textures(chunk_data)
elif chunk_id == LevelChunks.SHADERS:
read_shaders(chunk_data)
elif chunk_id == LevelChunks.VISUALS:
read_visuals(chunk_data)
elif chunk_id == LevelChunks.VBUFFERS:
read_vertex_buffers(chunk_data)
elif chunk_id == LevelChunks.CFORM:
read_cform(chunk_data)
elif chunk_id == LevelChunks.PORTALS:
read_portals(chunk_data)
elif chunk_id == LevelChunks.LIGHTS:
read_lights(chunk_data)
elif chunk_id == LevelChunks.LIGHT_KEYS:
read_light_keys(chunk_data)
elif chunk_id == LevelChunks.GLOWS:
read_glows(chunk_data)
elif chunk_id == LevelChunks.SECTORS:
read_sectors(chunk_data)
else:
print('unknown level chunk:', chunk_id, 'size:', len(chunk_data))
def main(data, level, fastpath=False):
chunked_reader = xray_io.ChunkedReader(data)
chunk_data = chunked_reader.next(format_level.Chunks.HEADER)
xrlc_version = read.header(chunk_data)
chunks = format_level.CHUNKS_TABLE[xrlc_version]
for chunk_id, chunk_data in chunked_reader:
if chunk_id == chunks.VB:
st = time.time()
vertex_buffers(chunk_data, level, fastpath)
print('Load VB:', time.time() - st)
elif chunk_id == chunks.IB:
st = time.time()
indices_buffers(chunk_data, level, fastpath)
print('Load IB:', time.time() - st)
elif chunk_id == chunks.SWIS:
st = time.time()
slide_windows_indices(chunk_data, level, fastpath)
print('Load SWIS:', time.time() - st)
else:
print('UNKNOW LEVEL GEOM CHUNK: {0:#x}'.format(chunk_id))
return level
def read_visuals(data):
chunks = set()
chunked_reader = xray_io.ChunkedReader(data)
for visual_index, visual_data in chunked_reader:
read_visual(visual_data, chunks)
for chunk_id in sorted(chunks):
print(hex(chunk_id), end=' ')
print()
def s_motions(data, visual, bones):
chunked_reader = xray_io.ChunkedReader(data)
chunk_motion_count_data = chunked_reader.next(0)
motion_count_packed_reader = xray_io.PackedReader(chunk_motion_count_data)
motions_count = motion_count_packed_reader.getf('I')[0]
motions = {}
for chunk_id, chunk_data in chunked_reader:
motion = read_motion(chunk_data, bones)
motions[motion.name] = motion
return motions
def decompress_chunks(data):
chunked_reader = xray_io.ChunkedReader(data)
chunked_writer = xray_io.ChunkedWriter()
for chunk_id, chunk_data in chunked_reader:
# bad file
if chunk_id == 0x0 and len(chunk_data) == 0:
break
packed_writer = xray_io.PackedWriter()
packed_writer.data = chunk_data
chunked_writer.put(chunk_id, packed_writer)
print('saved chunk: 0x{:x}'.format(chunk_id))
with open(sys.argv[1] + '.decompressed', mode='wb') as file:
file.write(chunked_writer.data)
def fastpath(data, visual):
chunked_reader = xray_io.ChunkedReader(data)
visual.fastpath = types.FastPath()
for chunk_id, chunk_data in chunked_reader:
if chunk_id == format_.Chunks.GCONTAINER:
gcontainer(chunk_data, visual, fast_path=True)
elif chunk_id == format_.Chunks.SWIDATA:
swidata(chunk_data, visual, fast_path=True)
else:
print('UNKNOW OGF FASTPATH CHUNK: {0:#x}'.format(chunk_id))
def _sector(data):
chunked_reader = xray_io.ChunkedReader(data)
sector = types.Sector()
for chunk_id, chunk_data in chunked_reader:
if chunk_id == format_.Chunks.Sector.PORTALS:
_sector_portal(chunk_data, sector)
elif chunk_id == format_.Chunks.Sector.ROOT:
_sector_root(chunk_data, sector)
else:
print('UNKNOW LEVEL SECTOR CHUNK: {0:#x}'.format(chunk_id))
return sector
def main(chunks, ogf=True, visual=None, child=False):
chunks_ids = format_.Chunks.Version3
for chunk_id, chunk_data in chunks.items():
if chunk_id == format_.Chunks.HEADER:
pass
elif chunk_id == chunks_ids.TEXTURE:
read.texture(chunk_data, visual)
elif chunk_id == chunks_ids.TEXTURE_L:
texture_l(chunk_data, visual)
elif chunk_id == chunks_ids.BBOX:
bbox(chunk_data, visual)
elif chunk_id == chunks_ids.CHILDREN:
chunked_reader_children = xray_io.ChunkedReader(chunk_data)
for child_id, child_data in chunked_reader_children:
chunked_reader = xray_io.ChunkedReader(child_data)
chunks_children = {}
for chunk_id_children, chunk_data_children in chunked_reader:
chunks_children[chunk_id_children] = chunk_data_children
main(chunks_children, ogf=True, visual=visual, child=True)
elif chunk_id == chunks_ids.VERTICES:
vertices(chunk_data, visual)
elif chunk_id == chunks_ids.INDICES:
read.indices(chunk_data, visual)
elif chunk_id == chunks_ids.LODDATA:
lod_data(chunk_data, visual)
elif chunk_id == chunks_ids.ICONTAINER:
indices_container(chunk_data, visual)
elif chunk_id == chunks_ids.VCONTAINER:
vertices_container(chunk_data, visual)
elif chunk_id == chunks_ids.BSPHERE:
bsphere(chunk_data, visual)
elif chunk_id == chunks_ids.CHILDREN_L:
children_l(chunk_data, visual)
elif chunk_id == chunks_ids.TREEDEF2:
read.treedef2(chunk_data, visual)
else:
print(hex(chunk_id))
def read_sector(data):
chunked_reader = xray_io.ChunkedReader(data)
for chunk_id, chunk_data in chunked_reader:
if chunk_id == SectorChunks.PORTALS:
read_sector_portals(chunk_data)
elif chunk_id == SectorChunks.ROOT:
read_sector_root(chunk_data)
elif chunk_id == SectorChunks.OCCLUDERS:
read_sector_occluders(chunk_data)
elif chunk_id == SectorChunks.GLOWS:
read_sector_glows(chunk_data)
elif chunk_id == SectorChunks.LIGHTS:
read_sector_lights(chunk_data)
else:
print('unknown sector chunk:', chunk_id, 'size:', len(chunk_data))
def lod_data(data, visual):
chunked_reader = xray_io.ChunkedReader(data)
hoppe_chunks = format_.Chunks.Version3.Hoppe
for chunk_id, chunk_data in chunked_reader:
packed_reader = xray_io.PackedReader(chunk_data)
if chunk_id == hoppe_chunks.HEADER:
min_vertices = packed_reader.getf('I')[0]
min_indices = packed_reader.getf('I')[0]
elif chunk_id == hoppe_chunks.VERT_SPLITS:
vert_splits_count = len(visual.vertices) - min_vertices
vert_splits = []
print(len(chunk_data), vert_splits_count * 4)
for vertex_index in range(vert_splits_count):
vertex = packed_reader.getf('H')[0]
new_tris = packed_reader.getf('B')[0]
fix_faces = packed_reader.getf('B')[0]
vert_splits.append(fix_faces)
elif chunk_id == hoppe_chunks.FIX_FACES:
fix_faces_count = packed_reader.getf('I')[0]
fix_faces = []
for face_index in range(fix_faces_count):
vertex_index = packed_reader.getf('H')[0]
fix_faces.append(vertex_index)
else:
print('UNKNOWN HOPPE CHUNK', hex(chunk_id))
m_ib0 = visual.indices
fix_idx = 0
active_vb_size = min_vertices
p = 0
end = len(visual.vertices) - min_vertices
while p != end:
end_idx = fix_idx + vert_splits[p]
p += 1
while fix_idx < end_idx:
fix_face = fix_faces[fix_idx]
m_ib0[fix_face] = active_vb_size
fix_idx += 1
active_vb_size += 1
visual.indices = m_ib0
def file(file_path):
file = open(file_path, 'rb')
data = file.read()
file.close()
bones = []
visual = Visual()
arm_obj = bpy.context.object
for bone in arm_obj.data.bones:
if not bone.parent:
parent = ''
else:
parent = bone.parent.name
bones.append((bone.name, parent))
chunked_reader = xray_io.ChunkedReader(data)
motions_chunk = chunked_reader.next(Chunks.S_MOTIONS)
visual.motions = s_motions(motions_chunk, None, bones)
import_motions(visual, arm_obj)
for chunk_id, chunk_data in chunked_reader:
if chunk_id == Chunks.S_SMPARAMS:
s_smparams(chunk_data, visual)
else:
print('! Unknown OMF chunk: {}'.format(hex(chunk_id)))
def read_visual(data, chunks):
chunked_reader = xray_io.ChunkedReader(data)
for chunk_id, chunk_data in chunked_reader:
chunks.add(chunk_id)
def read_sectors(data):
chunked_reader = xray_io.ChunkedReader(data)
for sector_index, sector_data in chunked_reader:
read_sector(sector_data)
def main(data, file_name=None, ogf=False, child=False):
chunked_reader = xray_io.ChunkedReader(data)
visual = types.Visual()
visual.file_name = file_name
chunks = {}
for chunk_id, chunk_data in chunked_reader:
chunks[chunk_id] = chunk_data
header_data = chunks.get(format_.Chunks.HEADER)
format_version = header(header_data, visual)
if format_version == 4:
if chunks.get(format_.Chunks.S_BONE_NAMES):
bone_names_data = chunks.get(format_.Chunks.S_BONE_NAMES)
bones = s_bone_names(bone_names_data)
for chunk_id, chunk_data in chunks.items():
visual.chunks.append(hex(chunk_id))
if chunk_id == format_.Chunks.HEADER:
pass
elif chunk_id == format_.Chunks.S_BONE_NAMES:
pass
elif chunk_id == format_.Chunks.TEXTURE:
texture(chunk_data, visual)
elif chunk_id == format_.Chunks.VERTICES:
vertices(chunk_data, visual)
elif chunk_id == format_.Chunks.INDICES:
indices(chunk_data, visual)
elif chunk_id == format_.Chunks.VCONTAINER:
vcontainer(chunk_data, visual)
elif chunk_id == format_.Chunks.ICONTAINER:
icontainer(chunk_data, visual)
elif chunk_id == format_.Chunks.SWIDATA:
swidata(chunk_data, visual)
elif chunk_id == format_.Chunks.CHILDREN:
visual.children_visuals = children(chunk_data, visual)
elif chunk_id == format_.Chunks.CHILDREN_L:
children_l(chunk_data, visual)
elif chunk_id == format_.Chunks.LODDEF2:
loddef2(chunk_data)
elif chunk_id == format_.Chunks.TREEDEF2:
treedef2(chunk_data, visual)
elif chunk_id == format_.Chunks.S_SMPARAMS:
s_smparams(chunk_data, visual)
elif chunk_id == format_.Chunks.S_IKDATA:
s_ikdata(chunk_data, visual, bones)
elif chunk_id == format_.Chunks.S_USERDATA:
s_userdata(chunk_data, visual)
elif chunk_id == format_.Chunks.DESC:
desc(chunk_data, visual)
elif chunk_id == format_.Chunks.S_MOTION_REFS_0:
s_motion_refs_0(chunk_data, visual)
elif chunk_id == format_.Chunks.SWICONTAINER:
swicontainer(chunk_data, visual)
elif chunk_id == format_.Chunks.GCONTAINER:
gcontainer(chunk_data, visual)
elif chunk_id == format_.Chunks.FASTPATH:
fastpath(chunk_data, visual)
elif chunk_id == format_.Chunks.S_MOTIONS:
visual.motions = s_motions(chunk_data, visual, bones)
else:
print('UNKNOW OGF CHUNK: {0:#x}'.format(chunk_id))
if ogf and not child:
importer.import_ogf(visual)
return visual
elif format_version == 3:
version_3.read.main(chunks, ogf=ogf, visual=visual, child=False)
if ogf and not child:
importer.import_ogf(visual)
return visual
def _sectors(data, level):
chunked_reader = xray_io.ChunkedReader(data)
for sector_id, sector_data in chunked_reader:
sector = _sector(sector_data)
level.sectors.append(sector)
def _root(data, level):
start_time = time.time()
chunked_reader = xray_io.ChunkedReader(data)
chunk_data = chunked_reader.next(format_.Chunks.HEADER)
xrlc_version = header(chunk_data)
level.format_version = xrlc_version
chunks = format_.CHUNKS_TABLE[xrlc_version]
for chunk_id, chunk_data in chunked_reader:
if chunk_id == chunks.SHADERS:
if level.format_version <= format_.XRLC_VERSION_11:
_shaders_v8(chunk_data, level)
else:
_shaders_v13(chunk_data, level)
elif chunk_id == chunks.VISUALS:
visuals_chunk_data = chunk_data
elif chunk_id == chunks.PORTALS:
_portals(chunk_data, level)
elif chunk_id == chunks.LIGHT_DYNAMIC:
_light_dynamic(chunk_data)
elif chunk_id == chunks.GLOWS:
_glows(chunk_data, level)
elif chunk_id == chunks.SECTORS:
_sectors(chunk_data, level)
elif chunk_id == chunks.VB:
geom.read.vertex_buffers(chunk_data, level)
elif chunk_id == chunks.IB:
geom.read.indices_buffers(chunk_data, level)
elif chunk_id == chunks.SWIS:
geom.read.slide_windows_indices(chunk_data, level)
else:
print('UNKNOW LEVEL CHUNK: {0:#x}'.format(chunk_id))
print('Load Level', time.time() - start_time)
start_time = time.time()
geom_path = level.file_path + '.geom'
has_geom = False
if os.path.exists(geom_path):
has_geom = True
geom.read.file(geom_path, level)
geomx_path = level.file_path + '.geomx'
has_geomx = False
if os.path.exists(geomx_path):
has_geomx = True
geom.read.file(geomx_path, level, fastpath=True)
level.has_geomx = has_geomx
cform_path = level.file_path + '.cform'
if os.path.exists(cform_path):
cform.read.file(cform_path, level)
print('Load Geom:', time.time() - start_time)
start_time = time.time()
_visuals(visuals_chunk_data, level)
print('Load Visuals', time.time() - start_time)
start_time = time.time()
importer.import_visuals(level)
print('Imported Visuals', time.time() - start_time)
def _visuals(data, level):
chunked_reader = xray_io.ChunkedReader(data)
for visual_index, visual_data in chunked_reader:
visual = ogf.read.main(visual_data)
level.visuals.append(visual)