nucleation 0.2.18 → 0.3.0

package/MeshProgress.d.ts

@@ -0,0 +1,32 @@
+// generated by diplomat-tool
+import type { MeshPhase } from "./MeshPhase"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+export type MeshProgress_obj = {
+    phase: MeshPhase;
+    current: number;
+    total: number;
+};
+
+
+
+/**
+ * Snapshot of a {@link MeshJob}'s progress.
+ */
+export class MeshProgress {
+    get phase(): MeshPhase;
+    set phase(value: MeshPhase);
+    get current(): number;
+    set current(value: number);
+    get total(): number;
+    set total(value: number);
+    /** @internal */
+    static fromFields(structObj : MeshProgress_obj) : MeshProgress;
+
+    /**
+    * Create `MeshProgress` from an object that contains all of `MeshProgress`s fields.
+    * Optional fields do not need to be included in the provided object.
+    */
+    constructor(structObj: MeshProgress_obj);
+
+}

package/MeshProgress.mjs

@@ -0,0 +1,133 @@
+// generated by diplomat-tool
+import { MeshPhase } from "./MeshPhase.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * Snapshot of a {@link MeshJob}'s progress.
+ */
+export class MeshProgress {
+    #phase;
+    get phase() {
+        return this.#phase;
+    }
+    set phase(value){
+        this.#phase = value;
+    }
+    #current;
+    get current() {
+        return this.#current;
+    }
+    set current(value){
+        this.#current = value;
+    }
+    #total;
+    get total() {
+        return this.#total;
+    }
+    set total(value){
+        this.#total = value;
+    }
+    /** @internal */
+    static fromFields(structObj) {
+        return new MeshProgress(structObj);
+    }
+
+    #internalConstructor(structObj) {
+        if (typeof structObj !== "object") {
+            throw new Error("MeshProgress's constructor takes an object of MeshProgress's fields.");
+        }
+
+        if ("phase" in structObj) {
+            this.#phase = structObj.phase;
+        } else {
+            throw new Error("Missing required field phase.");
+        }
+
+        if ("current" in structObj) {
+            this.#current = structObj.current;
+        } else {
+            throw new Error("Missing required field current.");
+        }
+
+        if ("total" in structObj) {
+            this.#total = structObj.total;
+        } else {
+            throw new Error("Missing required field total.");
+        }
+
+        return this;
+    }
+
+    // Return this struct in FFI function friendly format.
+    // Returns an array that can be expanded with spread syntax (...)
+    _intoFFI(
+        dst,
+        functionCleanupArena,
+        appendArrayMap
+    ) {
+
+        this._writeToArrayBuffer(wasm.memory.buffer, dst, functionCleanupArena, appendArrayMap);
+
+        return dst;
+    }
+
+    static get _sizeBytes() {
+        return 12;
+    }
+
+    /// Currently unused, we may want to use later on though:
+    static get _sizeAlign() {
+        return 4;
+    }
+
+    static _fromSuppliedValue(internalConstructor, obj) {
+        if (internalConstructor !== diplomatRuntime.internalConstructor) {
+            throw new Error("_fromSuppliedValue cannot be called externally.");
+        }
+
+        if (obj instanceof MeshProgress) {
+            return obj;
+        }
+
+        return MeshProgress.fromFields(obj);
+    }
+
+    _writeToArrayBuffer(
+        arrayBuffer,
+        offset,
+        functionCleanupArena,
+        appendArrayMap
+    ) {
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 0, this.#phase.ffiValue, Int32Array);
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 4, this.#current, Uint32Array);
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 8, this.#total, Uint32Array);
+    }
+
+    // This struct contains borrowed fields, so this takes in a list of
+    // "edges" corresponding to where each lifetime's data may have been borrowed from
+    // and passes it down to individual fields containing the borrow.
+    // This method does not attempt to handle any dependencies between lifetimes, the caller
+    // should handle this when constructing edge arrays.
+    static _fromFFI(internalConstructor, ptr) {
+        if (internalConstructor !== diplomatRuntime.internalConstructor) {
+            throw new Error("MeshProgress._fromFFI is not meant to be called externally. Please use the default constructor.");
+        }
+        let structObj = {};
+        const phaseDeref = diplomatRuntime.enumDiscriminant(wasm, ptr);
+        structObj.phase = new MeshPhase(diplomatRuntime.internalConstructor, phaseDeref);
+        const currentDeref = (new Uint32Array(wasm.memory.buffer, ptr + 4, 1))[0];
+        structObj.current = currentDeref;
+        const totalDeref = (new Uint32Array(wasm.memory.buffer, ptr + 8, 1))[0];
+        structObj.total = totalDeref;
+
+        return new MeshProgress(structObj);
+    }
+
+
+    constructor(structObj) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/MeshResult.d.ts

@@ -0,0 +1,60 @@
+// generated by diplomat-tool
+import type { MeshBounds } from "./MeshBounds"
+import type { MeshConfig } from "./MeshConfig"
+import type { NucleationError } from "./NucleationError"
+import type { ResourcePack } from "./ResourcePack"
+import type { Schematic } from "./Schematic"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A single mesh output. Wraps {@link crate::meshing::MeshResult}.
+ */
+export class MeshResult {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Mesh an entire schematic in one pass (old ABI: `schematic_to_mesh`).
+     */
+    static create(schematic: Schematic, pack: ResourcePack, config: MeshConfig): MeshResult;
+
+    /**
+     * Mesh a schematic with USDZ-compatible output (old ABI: `schematic_to_usdz`).
+     */
+    static createUsdz(schematic: Schematic, pack: ResourcePack, config: MeshConfig): MeshResult;
+
+    /**
+     * The mesh as a binary GLB, base64-encoded.
+     */
+    glbDataB64(): string;
+
+    /**
+     * The mesh serialized in the NUCM cache format, base64-encoded.
+     */
+    nucmDataB64(): string;
+
+    /**
+     * Total number of vertices in the mesh.
+     */
+    vertexCount(): number;
+
+    /**
+     * Total number of triangles in the mesh.
+     */
+    triangleCount(): number;
+
+    /**
+     * Whether the mesh contains any transparent or translucent geometry.
+     */
+    hasTransparency(): boolean;
+
+    /**
+     * Axis-aligned bounding box of the mesh, in world units.
+     */
+    bounds(): MeshBounds;
+}

package/MeshResult.mjs

@@ -0,0 +1,206 @@
+// generated by diplomat-tool
+import { MeshBounds } from "./MeshBounds.mjs"
+import { MeshConfig } from "./MeshConfig.mjs"
+import { NucleationError } from "./NucleationError.mjs"
+import { ResourcePack } from "./ResourcePack.mjs"
+import { Schematic } from "./Schematic.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const MeshResult_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.MeshResult_destroy(ptr);
+});
+
+/**
+ * A single mesh output. Wraps {@link crate::meshing::MeshResult}.
+ */
+export class MeshResult {
+    // Internal ptr reference:
+    #ptr = null;
+
+    // Lifetimes are only to keep dependencies alive.
+    // Since JS won't garbage collect until there are no incoming edges.
+    #selfEdge = [];
+
+    #internalConstructor(symbol, ptr, selfEdge) {
+        if (symbol !== diplomatRuntime.internalConstructor) {
+            console.error("MeshResult is an Opaque type. You cannot call its constructor.");
+            return;
+        }
+        this.#ptr = ptr;
+        this.#selfEdge = selfEdge;
+
+        // Are we being borrowed? If not, we can register.
+        if (this.#selfEdge.length === 0) {
+            MeshResult_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Mesh an entire schematic in one pass (old ABI: `schematic_to_mesh`).
+     */
+    static create(schematic, pack, config) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.MeshResult_create(diplomatReceive.buffer, schematic.ffiValue, pack.ffiValue, config.ffiValue);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new MeshResult(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Mesh a schematic with USDZ-compatible output (old ABI: `schematic_to_usdz`).
+     */
+    static createUsdz(schematic, pack, config) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.MeshResult_create_usdz(diplomatReceive.buffer, schematic.ffiValue, pack.ffiValue, config.ffiValue);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new MeshResult(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * The mesh as a binary GLB, base64-encoded.
+     */
+    glbDataB64() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.MeshResult_glb_data_b64(diplomatReceive.buffer, this.ffiValue, write.buffer);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+            write.free();
+        }
+    }
+
+    /**
+     * The mesh serialized in the NUCM cache format, base64-encoded.
+     */
+    nucmDataB64() {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.MeshResult_nucm_data_b64(this.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    /**
+     * Total number of vertices in the mesh.
+     */
+    vertexCount() {
+
+        const result = wasm.MeshResult_vertex_count(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Total number of triangles in the mesh.
+     */
+    triangleCount() {
+
+        const result = wasm.MeshResult_triangle_count(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Whether the mesh contains any transparent or translucent geometry.
+     */
+    hasTransparency() {
+
+        const result = wasm.MeshResult_has_transparency(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Axis-aligned bounding box of the mesh, in world units.
+     */
+    bounds() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 24, 4, false);
+
+
+        const result = wasm.MeshResult_bounds(diplomatReceive.buffer, this.ffiValue);
+
+        try {
+            return MeshBounds._fromFFI(diplomatRuntime.internalConstructor, diplomatReceive.buffer);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/MultiMeshResult.d.ts

@@ -0,0 +1,50 @@
+// generated by diplomat-tool
+import type { MeshConfig } from "./MeshConfig"
+import type { MeshResult } from "./MeshResult"
+import type { NucleationError } from "./NucleationError"
+import type { ResourcePack } from "./ResourcePack"
+import type { Schematic } from "./Schematic"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Per-region mesh results. Wraps {@link crate::meshing::MultiMeshResult}.
+ */
+export class MultiMeshResult {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Mesh each region separately (old ABI: `schematic_mesh_by_region`).
+     */
+    static create(schematic: Schematic, pack: ResourcePack, config: MeshConfig): MultiMeshResult;
+
+    /**
+     * Region names, as a JSON array string.
+     */
+    regionNamesJson(): string;
+
+    /**
+     * The mesh for one region (cloned).
+     */
+    getMesh(regionName: string): MeshResult;
+
+    /**
+     * Total vertex count across all region meshes.
+     */
+    totalVertexCount(): number;
+
+    /**
+     * Total triangle count across all region meshes.
+     */
+    totalTriangleCount(): number;
+
+    /**
+     * Number of region meshes.
+     */
+    meshCount(): number;
+}

package/MultiMeshResult.mjs

@@ -0,0 +1,166 @@
+// generated by diplomat-tool
+import { MeshConfig } from "./MeshConfig.mjs"
+import { MeshResult } from "./MeshResult.mjs"
+import { NucleationError } from "./NucleationError.mjs"
+import { ResourcePack } from "./ResourcePack.mjs"
+import { Schematic } from "./Schematic.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const MultiMeshResult_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.MultiMeshResult_destroy(ptr);
+});
+
+/**
+ * Per-region mesh results. Wraps {@link crate::meshing::MultiMeshResult}.
+ */
+export class MultiMeshResult {
+    // Internal ptr reference:
+    #ptr = null;
+
+    // Lifetimes are only to keep dependencies alive.
+    // Since JS won't garbage collect until there are no incoming edges.
+    #selfEdge = [];
+
+    #internalConstructor(symbol, ptr, selfEdge) {
+        if (symbol !== diplomatRuntime.internalConstructor) {
+            console.error("MultiMeshResult is an Opaque type. You cannot call its constructor.");
+            return;
+        }
+        this.#ptr = ptr;
+        this.#selfEdge = selfEdge;
+
+        // Are we being borrowed? If not, we can register.
+        if (this.#selfEdge.length === 0) {
+            MultiMeshResult_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Mesh each region separately (old ABI: `schematic_mesh_by_region`).
+     */
+    static create(schematic, pack, config) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.MultiMeshResult_create(diplomatReceive.buffer, schematic.ffiValue, pack.ffiValue, config.ffiValue);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new MultiMeshResult(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Region names, as a JSON array string.
+     */
+    regionNamesJson() {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.MultiMeshResult_region_names_json(this.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    /**
+     * The mesh for one region (cloned).
+     */
+    getMesh(regionName) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const regionNameSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, regionName)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.MultiMeshResult_get_mesh(diplomatReceive.buffer, this.ffiValue, regionNameSlice.ptr);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return new MeshResult(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Total vertex count across all region meshes.
+     */
+    totalVertexCount() {
+
+        const result = wasm.MultiMeshResult_total_vertex_count(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Total triangle count across all region meshes.
+     */
+    totalTriangleCount() {
+
+        const result = wasm.MultiMeshResult_total_triangle_count(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Number of region meshes.
+     */
+    meshCount() {
+
+        const result = wasm.MultiMeshResult_mesh_count(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/Nbt.d.ts

@@ -0,0 +1,50 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Namespace type for the free-standing NBT builder helpers (the old
+ * `nbt_text_build` / `nbt_chest_build` / `nbt_sign_build`), following the
+ * static-methods-on-a-dummy-opaque pattern.
+ */
+export class Nbt {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Build a Minecraft JSON text-component string.
+     *
+     * `color` may be empty (no color). `bold` and `italic` use `-1` for
+     * unset, `0` for false, nonzero for true.
+     */
+    static textBuild(s: string, color: string, bold: number, italic: number): string;
+
+    /**
+     * Build a chest-NBT SNBT string for use as the `{...}` portion of a block
+     * string.
+     *
+     * `items_json` is a JSON array of `{"id": string, "count"?: int,
+     * "slot"?: int}` entries (may be empty or `[]`); a missing/non-positive
+     * `count` defaults to 1, a missing/negative `slot` auto-assigns
+     * positionally. `name` is an optional plain-text custom name (empty = no
+     * `CustomName`); it is wrapped in a JSON text component automatically
+     * unless it already starts with `{`.
+     */
+    static chestBuild(itemsJson: string, name: string): string;
+
+    /**
+     * Build a modern (1.20+) sign-NBT SNBT string.
+     *
+     * `front_json` and `back_json` are JSON arrays of up to 4 line strings
+     * (either may be empty or `[]`). Each line may be a plain string
+     * (auto-wrapped via `text_build`) or an already-built JSON component
+     * (starts with `{`). `color` is the dye color string (empty defaults to
+     * `"black"`).
+     */
+    static signBuild(frontJson: string, backJson: string, color: string, glowing: boolean, waxed: boolean): string;
+}