@that-sky-project/that-sky-level 1.0.0

package/main.js

@@ -0,0 +1,218 @@
+const ps = require("process");
+const fs = require("fs");
+const pl = require("path");
+const arg = require("arg");
+const MeshoptDecoder = require("./src/meshopt/meshopt_decoder.js");
+const MeshoptEncoder = require("./src/meshopt/meshopt_encoder.js");
+const { WavefrontObj } = require("./src/formats/wavefront.js");
+const { LevelMeshes } = require("./src/level/meshes/levelMeshes.js");
+const { LevelCvtAdjacency } = require("./src/level/adjacency.js");
+const { LevelObjectsJson } = require("./src/level/objects/levelObjectsJson.js");
+const { silence, printf } = require("./src/utils/logger.js");
+
+const kEngineVersion = [0, 32, 2];
+const kEditorVersion = [1, 0, 0];
+
+const argv = arg({
+  // Show helps.
+  "--help": Boolean,
+  // Convert from .meshes to .obj
+  "--touch": Boolean,
+  // Convert from .obj to .meshes
+  "--convert": Boolean,
+  // Convert from .level.json to .level.bin
+  "--serialize": Boolean,
+  // Convert from .level.bin to .level.json
+  "--deserialize": Boolean,
+
+  // Merge chunks to a single object.
+  "-m": Boolean,
+  // Input file.
+  "-i": String,
+  // Output file.
+  "-o": String,
+  // Silence mode.
+  "-s": Boolean,
+
+  "-h": "--help",
+  "-T": "--touch",
+  "-C": "--convert",
+  "-S": "--serialize",
+  "-D": "--deserialize",
+}, { permissive: true });
+
+function readModelFile(path) {
+  var ext = pl.extname(path);
+  if (ext === ".obj") {
+    var raw = fs.readFileSync(path, "utf-8")
+      , result = new WavefrontObj();
+    result.fromFileBuffer(raw);
+    return result;
+  } else {
+    throw new Error("unrecognized file extname");
+  }
+}
+
+function readMeshesFile(path) {
+  var ext = pl.extname(path);
+  if (ext === ".meshes") {
+    var raw = fs.readFileSync(path)
+      , result = new LevelMeshes();
+    result.fromFileBuffer(raw);
+    return result;
+  } else {
+    throw new Error("unrecognized file extname");
+  }
+}
+
+function setDesc(desc, inputFile) {
+  desc.fileName = inputFile;
+  desc.timeStamp = Math.floor(new Date().getTime() / 1000);
+  desc.editor = "that-sky-level";
+  desc.editorVersion = kEditorVersion;
+  desc.engineVersion = kEngineVersion;
+}
+
+function touchObject(meshes, merge) {
+  var geo = meshes.geo
+    , obj = ""
+    , totalIdx = 0;
+
+  for (var vtx of geo.vertices)
+    obj += `v ${vtx.pos.x} ${vtx.pos.y} ${vtx.pos.z}\n`;
+  obj += "\n";
+
+  for (var vtx of geo.vertices)
+    obj += `vn ${vtx.normal.x} ${vtx.normal.y} ${vtx.normal.z}\n`;
+  obj += "\n";
+
+  if (merge)
+    obj += "o Chunks" + "\n";
+  for (var i = 0; i < geo.chunkCount; i++) {
+    if (!merge)
+      obj += "o Chunk_" + i + "\n";
+    var chunk = geo.chunks[i];
+    for (var j = 0; j < chunk.idxCount; j += 3) {
+      var fileIdx;
+
+      obj += "f ";
+      fileIdx = chunk.vtxStart + geo.localIndices[chunk.idxStart + j] + 1;
+      obj += `${fileIdx}//${fileIdx} `;
+      fileIdx = chunk.vtxStart + geo.localIndices[chunk.idxStart + j + 1] + 1;
+      obj += `${fileIdx}//${fileIdx} `;
+      fileIdx = chunk.vtxStart + geo.localIndices[chunk.idxStart + j + 2] + 1;
+      obj += `${fileIdx}//${fileIdx}\n`;
+
+      totalIdx += 3;
+    }
+  }
+
+  return {
+    result: obj,
+    totalVtx: geo.vertices.length,
+    totalIdx: totalIdx
+  };
+}
+
+!async function () {
+  await MeshoptDecoder.ready;
+  await MeshoptEncoder.ready;
+
+  silence(argv["-s"]);
+
+  if (argv["--convert"]) {
+    var input = argv["-i"]
+      , output = argv["-o"] || "./BstBaked.meshes";
+
+    if (!input)
+      throw new Error("no input file");
+
+    var rawMesh = readModelFile(input)
+      , converter = new LevelCvtAdjacency(rawMesh)
+      , meshes = new LevelMeshes();
+
+    converter.initialize(rawMesh);
+    meshes.geo = converter.convert();
+    setDesc(meshes.desc, input);
+    fs.writeFileSync(output, meshes.toFileBuffer());
+    printf("Converted:");
+    printf("  Chunks: " + meshes.geo.chunkCount);
+    printf("  Subchunks: " + meshes.geo.subchunkCount);
+    printf("  Vertices: " + meshes.geo.vertexCount);
+    printf("  Faces: " + meshes.geo.indexCount / 3);
+    return;
+  } else if (argv["--touch"]) {
+    var input = argv["-i"]
+      , output = argv["-o"];
+
+    if (!input)
+      throw new Error("no input file");
+
+    var meshes = readMeshesFile(input);
+    printf("File information:");
+    printf("  Version: 0x" + meshes.fileVersion.toString(16));
+    if (meshes.desc) {
+      printf("  Editor: " + meshes.desc.editor);
+      printf("  Editor version: " + meshes.desc.editorVersion);
+      printf("  Timestamp: " + meshes.desc.timeStamp);
+      printf("  Original file: " + meshes.desc.fileName);
+    } else {
+      printf("  Editor: -");
+      printf("  Editor version: -");
+      printf("  Timestamp: -");
+      printf("  Original file: -");
+    }
+
+    if (!output)
+      return;
+
+    var result = touchObject(meshes, argv["-m"]);
+
+    fs.writeFileSync(output, result.result);
+    printf("\nConverted:");
+    printf("  Vertices: " + result.totalVtx);
+    printf("  Indices: " + result.totalIdx);
+  } else if (argv["--serialize"]) {
+    var input = argv["-i"]
+      , output = argv["-o"] || "./Objects.level.bin";
+
+    if (!input)
+      throw new Error("no input file");
+
+    var file = fs.readFileSync(input, "utf-8");
+    fs.writeFileSync(output, LevelObjectsJson.write(JSON.parse(file)));
+  } else if (argv["--deserialize"]) {
+    var input = argv["-i"]
+      , output = argv["-o"] || "./Objects.level.json";
+
+    if (!input)
+      throw new Error("no input file");
+
+    var file = fs.readFileSync(input);
+    fs.writeFileSync(output, JSON.stringify(LevelObjectsJson.read(file), null, 2));
+  } else {
+    printf("that-sky-level");
+    printf("Copyright (c) 2026 That Sky Project");
+    printf("<https://www.github.com/that-sky-project/that-sky-level>");
+    printf(" - A Sky CotL level reader and writer.");
+    printf("");
+    printf("Usage:");
+    printf("  node main.js <-T|-C|-S|-D> -i <input> -o <output> [-m] [-s]");
+    printf("  node main.js --help");
+    printf("");
+    printf("Options:");
+    printf("  --touch, -T         Convert from .meshes to .obj");
+    printf("  --convert, -C       Convert from .obj to .meshes");
+    printf("  --serialize, -S     Convert from .level.json to .level.bin");
+    printf("  --deserialize, -D   Convert from .level.bin to .level.json");
+    printf("  --help, -h          Show this help");
+    printf("  -i <file>           Input file");
+    printf("  -o <file>           Output file");
+    printf("  -s                  Disable logger");
+    printf("  -m                  Merge chunks when exporting to .obj");
+    return;
+  }
+}().catch(e => {
+  printf("tslevel: §c§lerror: §r%0", e.message || "" + e);
+  ps.exit(1);
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@that-sky-project/that-sky-level",
+  "version": "1.0.0",
+  "dependencies": {
+    "@htmonkeyg/tformat": "^1.0.1",
+    "arg": "^5.0.2",
+    "fbx-parser": "^2.1.3",
+    "long": "^5.3.2",
+    "lz4": "^0.6.5",
+    "parsenbt-js": "^3.1.3"
+  },
+  "scripts": {
+    "build": "npx webpack"
+  },
+  "bin": {
+    "tslevel": "./dist/cli.js"
+  },
+  "devDependencies": {
+    "terser-webpack-plugin": "^5.6.1",
+    "webpack": "^5.108.3",
+    "webpack-cli": "^7.1.0"
+  }
+}

package/src/formats/triangleMesh.js

@@ -0,0 +1,82 @@
+const { kMaterial } = require("../level/enums/kMaterial.js");
+const { Vec3 } = require("../utils/vector.js");
+
+class TriangleMeshVertex {
+  constructor(pos, normal) {
+    this.pos = pos || new Vec3();
+    this.normal = normal || new Vec3();
+    /** A list of vertices considered adjacent to the current vertex. */
+    this.nearby = new Set();
+  }
+}
+
+class TriangleMeshMaterial {
+  static Null = new TriangleMeshMaterial();
+  static Default = new TriangleMeshMaterial("kMaterial_Cliff");
+
+  static isNull(mat) {
+    return mat == TriangleMeshMaterial.Null;
+  }
+
+  constructor(name) {
+    this.name = name || "";
+  }
+
+  getId() {
+    if (this.name.substring(0, 10) !== "kMaterial_")
+      return 0;
+    return kMaterial[this.name.substring(10)];
+  }
+}
+
+class TriangleMeshMaterialBarn {
+  constructor() {
+    this.materials = new Map();
+  }
+
+  initialize() {
+    this.materials.clear();
+    this.materials.set("", TriangleMeshMaterial.Null);
+  }
+
+  tryAddMaterial(name) {
+    if (this.materials.has(name))
+      return this.materials.get(name);
+
+    var result = new TriangleMeshMaterial(name);
+    this.materials.set(name, result);
+
+    return result;
+  }
+}
+
+class TriangleMeshFace {
+  constructor() {
+    this.materialRef = TriangleMeshMaterial.Null;
+    this.indices = [];
+  }
+}
+
+class TriangleMesh {
+  constructor() {
+    this.cmdBuffer = [];
+    this.vtxBuffer = [];
+    this.materials = new TriangleMeshMaterialBarn();
+
+    this.clear();
+  }
+
+  clear() {
+    this.cmdBuffer = [];
+    this.vtxBuffer = [];
+    this.materials.initialize();
+  }
+}
+
+module.exports = {
+  TriangleMeshVertex,
+  TriangleMeshMaterial,
+  TriangleMeshMaterialBarn,
+  TriangleMeshFace,
+  TriangleMesh
+};

package/src/formats/wavefront.js

@@ -0,0 +1,148 @@
+const { R8G8B8A8_SNORM } = require("../utils/normVec.js");
+const { Vec3 } = require("../utils/vector");
+const {
+  TriangleMesh,
+  TriangleMeshVertex,
+  TriangleMeshMaterial,
+  TriangleMeshMaterialBarn,
+  TriangleMeshFace
+} = require("./triangleMesh.js");
+
+/**
+ * Parse a Wavefront OBJ string into vertices, indices, and per-triangle
+ * material names. Only vertex positions and face indices are extracted.
+ * Returns an object with vertices (array of [x, y, z]), indices
+ * (flattened triangle index list), and materials (material name per
+ * triangle). If no usemtl is given, "" is used.
+ * 
+ * @param {string} objStr 
+ * @param {TriangleMeshMaterialBarn} materialBarn 
+ */
+function parseObj(objStr, materialBarn) {
+  // Split the file content into lines.
+  var lines = objStr.split("\n")
+    // Storage for raw vertex positions and normals.
+    , positions = []
+    , normals = []
+    , positionRefs = []
+    // Current material name, defaults to "".
+    , currentMtl = ""
+    // Map from combined position/normal keys to vertex indices.
+    , vertexMap = {}
+    // Output arrays.
+    , vertices = []
+    , faces = [];
+
+  // Process every line.
+  for (var i = 0; i < lines.length; i++) {
+    var line = lines[i].trim();
+    // Skip empty lines and comments.
+    if (line === "" || line.charAt(0) === "#")
+      continue;
+
+    var parts = line.split(/\s+/);
+    var keyword = parts[0];
+
+    if (keyword === "v") {
+      // Store a vertex position.
+      positionRefs[positions.length] = new Set();
+      positions.push(new Vec3(
+        parseFloat(parts[1]),
+        parseFloat(parts[2]),
+        parseFloat(parts[3])
+      ));
+    } else if (keyword === "vn") {
+      // Store a vertex normal.
+      normals.push(new R8G8B8A8_SNORM(
+        parseFloat(parts[1]),
+        parseFloat(parts[2]),
+        parseFloat(parts[3])
+      ));
+    } else if (keyword === "usemtl") {
+      // Switch active material.
+      currentMtl = parts[1] || "";
+    } else if (keyword === "f") {
+      // Parse a face definition.
+      var faceIndices = [];
+      var material = currentMtl;
+
+      // Loop through each vertex reference in the face.
+      for (var j = 1; j < parts.length; j++) {
+        var token = parts[j];
+        var subParts = token.split("/");
+        var posIdx = parseInt(subParts[0], 10);
+        var normIdx = null;
+
+        // Extract normal index when available (third component).
+        if (subParts.length >= 3 && subParts[2] !== "")
+          normIdx = parseInt(subParts[2], 10);
+
+        // Resolve negative indices relative to the end of the lists.
+        if (posIdx < 0)
+          posIdx = positions.length + 1 + posIdx;
+        if (normIdx !== null && normIdx < 0)
+          normIdx = normals.length + 1 + normIdx;
+
+        // Build a unique key based on position and normal pair.
+        var normKey = normIdx !== null
+          ? normIdx
+          : "none";
+        var key = posIdx + "," + normKey;
+
+        // Add a new vertex if the pair hasn't been seen.
+        if (!vertexMap.hasOwnProperty(key)) {
+          if (posIdx - 1 > positions.length)
+            throw new Error("encountered invalid vertex pos");
+          if (normIdx - 1 > normals.length)
+            throw new Error("encountered invalid vertex normal");
+
+          var pos = positions[posIdx - 1]
+            , posRef = positionRefs[posIdx - 1]
+            , norm = (normIdx !== null && normals[normIdx - 1])
+              ? normals[normIdx - 1]
+              : [0, 1, 0];
+
+          var vtx = new TriangleMeshVertex(pos, norm);
+          vtx.nearby = posRef;
+
+          vertexMap[key] = vertices.length;
+          posRef.add(vtx);
+          vertices.push(vtx);
+        }
+        // Record the index for the face.
+        faceIndices.push(vertexMap[key]);
+      }
+      // Store the face with its material.
+      var face = new TriangleMeshFace();
+      face.indices = faceIndices;
+      face.materialRef = materialBarn.tryAddMaterial(material);
+      faces.push(face);
+    }
+    // Other OBJ keywords (vt, g, o, s, mtllib, etc.) are ignored.
+  }
+
+  // Return the assembled vertices and indexed faces.
+  return { vertices: vertices, faces: faces };
+}
+
+class WavefrontObj extends TriangleMesh {
+  constructor() {
+    super();
+  }
+
+  /**
+   * @param {Buffer} fileBuffer 
+   */
+  fromFileBuffer(fileBuffer) {
+    this.clear();
+
+    var raw = parseObj(fileBuffer.toString("uit-8"), this.materials);
+
+    this.vtxBuffer = raw.vertices;
+    this.cmdBuffer = raw.faces;
+  }
+}
+
+module.exports = {
+  WavefrontObj
+};