CHUNK STUFF
This commit is contained in:
+119
-43
@@ -4,7 +4,8 @@
|
||||
# https://opensource.org/licenses/MIT
|
||||
|
||||
"""
|
||||
Converts DCF chunk files from version 1 to version 2.
|
||||
Converts DCF chunk files (version 1 or 2) to version 3 and generates the
|
||||
companion DMF (Dusk Mesh Format) files that version 3 references.
|
||||
|
||||
Version 1 format (after 8-byte header + tiles):
|
||||
uint32_t vertCount
|
||||
@@ -13,37 +14,51 @@ Version 1 format (after 8-byte header + tiles):
|
||||
Version 2 format (after 8-byte header + tiles):
|
||||
uint8_t meshCount
|
||||
for each mesh:
|
||||
uint32_t vertCount
|
||||
uint32_t vertCount
|
||||
meshvertex_t vertices[vertCount]
|
||||
|
||||
Version 3 format (after 8-byte header + tiles):
|
||||
uint8_t meshCount
|
||||
for each mesh:
|
||||
null-terminated string (path to companion .dmf asset)
|
||||
|
||||
DMF format:
|
||||
Bytes 0-3: DMF\x00
|
||||
Bytes 4-7: uint32_t version = 1 (little-endian)
|
||||
Bytes 8-11: uint32_t vertCount (little-endian)
|
||||
Bytes 12+: meshvertex_t vertices[vertCount]
|
||||
|
||||
Usage:
|
||||
python3 -m tools.asset.chunk <input.dcf> [output.dcf]
|
||||
If output is omitted the input file is updated in place.
|
||||
DMF files are written to assets/meshes/ beside the chunks/ directory.
|
||||
"""
|
||||
|
||||
import struct
|
||||
import sys
|
||||
import os
|
||||
|
||||
# Must match src/dusk/rpg/overworld/chunk.h
|
||||
CHUNK_WIDTH = 16
|
||||
CHUNK_HEIGHT = 16
|
||||
CHUNK_DEPTH = 32
|
||||
CHUNK_WIDTH = 16
|
||||
CHUNK_HEIGHT = 16
|
||||
CHUNK_DEPTH = 32
|
||||
CHUNK_TILE_COUNT = CHUNK_WIDTH * CHUNK_HEIGHT * CHUNK_DEPTH # 8192
|
||||
|
||||
CHUNK_MESH_COUNT_MAX = 10
|
||||
CHUNK_VERTEX_COUNT = 8192
|
||||
CHUNK_MESH_NAME_MAX = 64
|
||||
|
||||
# C enum (int) = 4 bytes; meshvertex_t = uv[2]+pos[3] floats = 20 bytes
|
||||
TILE_SIZE = 4
|
||||
VERTEX_SIZE = 20 # 2 floats UV + 3 floats pos, MESH_ENABLE_COLOR=0
|
||||
VERTEX_SIZE = 20
|
||||
|
||||
FILE_MAGIC = b'DCF'
|
||||
VERSION_IN = 1
|
||||
VERSION_OUT = 2
|
||||
DMF_MAGIC = b'DMF\x00'
|
||||
VERSION_OUT = 3
|
||||
DMF_VERSION = 1
|
||||
|
||||
|
||||
def read_v1(path):
|
||||
def read_dcf(path):
|
||||
"""Read a v1 or v2 DCF file. Returns (tiles, meshes) where meshes is a
|
||||
list of raw vertex byte strings, one per mesh."""
|
||||
with open(path, 'rb') as f:
|
||||
data = f.read()
|
||||
|
||||
@@ -51,34 +66,66 @@ def read_v1(path):
|
||||
raise ValueError(f"{path}: not a DCF file")
|
||||
|
||||
version = struct.unpack_from('<I', data, 4)[0]
|
||||
if version != VERSION_IN:
|
||||
raise ValueError(f"{path}: expected version {VERSION_IN}, got {version}")
|
||||
if version not in (1, 2):
|
||||
raise ValueError(
|
||||
f"{path}: expected version 1 or 2, got {version}"
|
||||
)
|
||||
|
||||
offset = 8
|
||||
tiles_bytes = CHUNK_TILE_COUNT * TILE_SIZE
|
||||
tiles = data[offset:offset + tiles_bytes]
|
||||
offset += tiles_bytes
|
||||
tiles_size = CHUNK_TILE_COUNT * TILE_SIZE
|
||||
tiles = data[offset:offset + tiles_size]
|
||||
offset += tiles_size
|
||||
|
||||
vert_count = struct.unpack_from('<I', data, offset)[0]
|
||||
offset += 4
|
||||
meshes = []
|
||||
|
||||
verts = data[offset:offset + vert_count * VERTEX_SIZE]
|
||||
if len(verts) != vert_count * VERTEX_SIZE:
|
||||
raise ValueError(f"{path}: truncated vertex data")
|
||||
if version == 1:
|
||||
vert_count = struct.unpack_from('<I', data, offset)[0]
|
||||
offset += 4
|
||||
verts = data[offset:offset + vert_count * VERTEX_SIZE]
|
||||
if len(verts) != vert_count * VERTEX_SIZE:
|
||||
raise ValueError(f"{path}: truncated vertex data")
|
||||
if vert_count > 0:
|
||||
meshes.append(verts)
|
||||
else:
|
||||
mesh_count = data[offset]
|
||||
offset += 1
|
||||
for _ in range(mesh_count):
|
||||
vert_count = struct.unpack_from('<I', data, offset)[0]
|
||||
offset += 4
|
||||
verts = data[offset:offset + vert_count * VERTEX_SIZE]
|
||||
if len(verts) != vert_count * VERTEX_SIZE:
|
||||
raise ValueError(f"{path}: truncated vertex data")
|
||||
offset += vert_count * VERTEX_SIZE
|
||||
if vert_count > 0:
|
||||
meshes.append(verts)
|
||||
|
||||
return tiles, vert_count, verts
|
||||
return tiles, meshes
|
||||
|
||||
|
||||
def write_v2(path, tiles, vert_count, verts):
|
||||
if vert_count > CHUNK_VERTEX_COUNT:
|
||||
print(
|
||||
f" Warning: {vert_count} vertices exceeds pool "
|
||||
f"({CHUNK_VERTEX_COUNT}); truncating."
|
||||
)
|
||||
vert_count = CHUNK_VERTEX_COUNT
|
||||
verts = verts[:vert_count * VERTEX_SIZE]
|
||||
def write_dmf(path, vertex_bytes):
|
||||
vert_count = len(vertex_bytes) // VERTEX_SIZE
|
||||
buf = bytearray()
|
||||
buf += DMF_MAGIC
|
||||
buf += struct.pack('<I', DMF_VERSION)
|
||||
buf += struct.pack('<I', vert_count)
|
||||
buf += vertex_bytes
|
||||
with open(path, 'wb') as f:
|
||||
f.write(buf)
|
||||
print(
|
||||
f' Wrote DMF {path}: '
|
||||
f'{vert_count} vertices, {len(buf)} bytes'
|
||||
)
|
||||
|
||||
mesh_count = 1 if vert_count > 0 else 0
|
||||
|
||||
def write_v3(dcf_path, tiles, mesh_names, mesh_offsets=None):
|
||||
"""Write a v3 DCF that references the given DMF asset paths.
|
||||
|
||||
mesh_offsets is an optional list of (x, y, z) tuples, one per mesh.
|
||||
Defaults to (0, 0, 0) for each mesh when omitted.
|
||||
"""
|
||||
mesh_count = len(mesh_names)
|
||||
if mesh_offsets is None:
|
||||
mesh_offsets = [(0.0, 0.0, 0.0)] * mesh_count
|
||||
|
||||
buf = bytearray()
|
||||
buf += FILE_MAGIC
|
||||
@@ -86,34 +133,63 @@ def write_v2(path, tiles, vert_count, verts):
|
||||
buf += struct.pack('<I', VERSION_OUT)
|
||||
buf += tiles
|
||||
buf += struct.pack('<B', mesh_count)
|
||||
if mesh_count > 0:
|
||||
buf += struct.pack('<I', vert_count)
|
||||
buf += verts
|
||||
|
||||
with open(path, 'wb') as f:
|
||||
for name, offset in zip(mesh_names, mesh_offsets):
|
||||
encoded = name.encode('ascii')
|
||||
if len(encoded) >= CHUNK_MESH_NAME_MAX:
|
||||
raise ValueError(
|
||||
f"Mesh name too long (>= {CHUNK_MESH_NAME_MAX}): {name}"
|
||||
)
|
||||
buf += encoded + b'\x00'
|
||||
buf += struct.pack('<3f', offset[0], offset[1], offset[2])
|
||||
with open(dcf_path, 'wb') as f:
|
||||
f.write(buf)
|
||||
|
||||
print(
|
||||
f" Wrote {path}: version {VERSION_OUT}, "
|
||||
f"{mesh_count} mesh(es), {vert_count} vertices."
|
||||
f' Wrote DCF {dcf_path}: '
|
||||
f'version {VERSION_OUT}, {mesh_count} mesh(es)'
|
||||
)
|
||||
|
||||
|
||||
def main():
|
||||
args = sys.argv[1:]
|
||||
if not args:
|
||||
print("Usage: python3 -m tools.asset.chunk <input.dcf> [output.dcf]")
|
||||
print(
|
||||
"Usage: python3 -m tools.asset.chunk "
|
||||
"<input.dcf> [output.dcf]"
|
||||
)
|
||||
sys.exit(1)
|
||||
|
||||
src = args[0]
|
||||
dst = args[1] if len(args) > 1 else src
|
||||
|
||||
print(f"Reading {src} ...")
|
||||
tiles, vert_count, verts = read_v1(src)
|
||||
print(f" tiles={CHUNK_TILE_COUNT}, vertices={vert_count}")
|
||||
tiles, meshes = read_dcf(src)
|
||||
print(
|
||||
f" tiles={CHUNK_TILE_COUNT}, "
|
||||
f"meshes={len(meshes)}, "
|
||||
f"total_verts="
|
||||
f"{sum(len(m) // VERTEX_SIZE for m in meshes)}"
|
||||
)
|
||||
|
||||
# Derive chunk base name from the DCF filename (e.g. "0_0_0" from
|
||||
# "0_0_0.dcf") to name DMF files "chunk_0_0_0_0.dmf" etc.
|
||||
base = os.path.splitext(os.path.basename(dst))[0]
|
||||
|
||||
# assets/meshes/ sits beside assets/chunks/ (one dir up from the DCF).
|
||||
meshes_dir = os.path.normpath(
|
||||
os.path.join(os.path.dirname(os.path.abspath(dst)), '..', 'meshes')
|
||||
)
|
||||
os.makedirs(meshes_dir, exist_ok=True)
|
||||
|
||||
print(f"Writing DMF files to {meshes_dir} ...")
|
||||
mesh_names = []
|
||||
for idx, verts in enumerate(meshes):
|
||||
dmf_filename = f'chunk_{base}_{idx}.dmf'
|
||||
dmf_path = os.path.join(meshes_dir, dmf_filename)
|
||||
write_dmf(dmf_path, verts)
|
||||
mesh_names.append(f'meshes/{dmf_filename}')
|
||||
|
||||
print(f"Writing {dst} ...")
|
||||
write_v2(dst, tiles, vert_count, verts)
|
||||
write_v3(dst, tiles, mesh_names)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
Reference in New Issue
Block a user