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)