nucleation 0.10.21 → 0.10.23

package/renderer/MeshPhase.d.mts

@@ -0,0 +1,38 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Phase of a running {@link MeshJob}.
+ */
+export class MeshPhase {
+
+    /** @internal */
+    static fromValue(value: MeshPhase | string): MeshPhase;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    /**
+     * Scanning palettes / building the shared texture atlas.
+     */
+    static BuildingAtlas : MeshPhase;
+    /**
+     * Meshing individual chunks (`current` / `total` advance here).
+     */
+    static MeshingChunks : MeshPhase;
+    /**
+     * All chunks meshed; `take_result` will not block.
+     */
+    static Complete : MeshPhase;
+    /**
+     * The job failed; `take_result` returns the error.
+     */
+    static Failed : MeshPhase;
+
+
+    constructor(value: MeshPhase | string );
+}

package/renderer/MeshPhase.d.ts

@@ -0,0 +1,38 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Phase of a running {@link MeshJob}.
+ */
+export class MeshPhase {
+
+    /** @internal */
+    static fromValue(value: MeshPhase | string): MeshPhase;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    /**
+     * Scanning palettes / building the shared texture atlas.
+     */
+    static BuildingAtlas : MeshPhase;
+    /**
+     * Meshing individual chunks (`current` / `total` advance here).
+     */
+    static MeshingChunks : MeshPhase;
+    /**
+     * All chunks meshed; `take_result` will not block.
+     */
+    static Complete : MeshPhase;
+    /**
+     * The job failed; `take_result` returns the error.
+     */
+    static Failed : MeshPhase;
+
+
+    constructor(value: MeshPhase | string );
+}

package/renderer/MeshPhase.mjs

@@ -0,0 +1,90 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * Phase of a running {@link MeshJob}.
+ */
+export class MeshPhase {
+    #value = undefined;
+
+    static #values = new Map([
+        ["BuildingAtlas", 0],
+        ["MeshingChunks", 1],
+        ["Complete", 2],
+        ["Failed", 3]
+    ]);
+
+    static getAllEntries() {
+        return MeshPhase.#values.entries();
+    }
+
+    #internalConstructor(value) {
+        if (arguments.length > 1 && arguments[0] === diplomatRuntime.internalConstructor) {
+            // We pass in two internalConstructor arguments to create *new*
+            // instances of this type, otherwise the enums are treated as singletons.
+            if (arguments[1] === diplomatRuntime.internalConstructor ) {
+                this.#value = arguments[2];
+                return this;
+            }
+            return MeshPhase.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof MeshPhase) {
+            return value;
+        }
+
+        let intVal = MeshPhase.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return MeshPhase.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a MeshPhase and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new MeshPhase(value);
+    }
+
+    get value(){
+        return [...MeshPhase.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new MeshPhase(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new MeshPhase(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+        new MeshPhase(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 2),
+        new MeshPhase(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 3),
+    ];
+
+    /**
+     * Scanning palettes / building the shared texture atlas.
+     */
+    static BuildingAtlas = MeshPhase.#objectValues[0];
+    /**
+     * Meshing individual chunks (`current` / `total` advance here).
+     */
+    static MeshingChunks = MeshPhase.#objectValues[1];
+    /**
+     * All chunks meshed; `take_result` will not block.
+     */
+    static Complete = MeshPhase.#objectValues[2];
+    /**
+     * The job failed; `take_result` returns the error.
+     */
+    static Failed = MeshPhase.#objectValues[3];
+
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/renderer/MeshProgress.d.mts

@@ -0,0 +1,32 @@
+// generated by diplomat-tool
+import type { MeshPhase } from "./MeshPhase.mjs"
+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/renderer/MeshProgress.d.ts

@@ -0,0 +1,32 @@
+// generated by diplomat-tool
+import type { MeshPhase } from "./MeshPhase.mjs"
+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/renderer/MeshProgress.mjs

@@ -0,0 +1,134 @@
+// 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) {
+        ptr >>>= 0; // unsigned wasm32 address; field values retain their signedness.
+        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/renderer/MeshResult.d.mts

@@ -0,0 +1,76 @@
+// generated by diplomat-tool
+import type { MeshBounds } from "./MeshBounds.mjs"
+import type { MeshConfig } from "./MeshConfig.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { ResourcePack } from "./ResourcePack.mjs"
+import type { Schematic } from "./Schematic.mjs"
+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;
+
+    /**
+     * A schematic plus a run timeline, as an animated GLB, base64-encoded.
+     *
+     * `timeline_json` is what `TickSimulation::animation_timeline_json`
+     * produces, and `schematic` the scene it starts from
+     * (`selection_schematic_b64`). Static rather than a method on a mesh
+     * because the animation is built from the schematic and the timeline
+     * together — there is no intermediate `MeshResult` to hang it off.
+     */
+    static animatedGlbB64(schematic: Schematic, pack: ResourcePack, timelineJson: string): string;
+
+    /**
+     * The mesh as a binary GLB, base64-encoded.
+     */
+    glbDataB64(): string;
+
+    /**
+     * The mesh as a USDZ archive, base64-encoded.
+     */
+    usdzDataB64(): 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/renderer/MeshResult.d.ts

@@ -0,0 +1,76 @@
+// generated by diplomat-tool
+import type { MeshBounds } from "./MeshBounds.mjs"
+import type { MeshConfig } from "./MeshConfig.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { ResourcePack } from "./ResourcePack.mjs"
+import type { Schematic } from "./Schematic.mjs"
+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;
+
+    /**
+     * A schematic plus a run timeline, as an animated GLB, base64-encoded.
+     *
+     * `timeline_json` is what `TickSimulation::animation_timeline_json`
+     * produces, and `schematic` the scene it starts from
+     * (`selection_schematic_b64`). Static rather than a method on a mesh
+     * because the animation is built from the schematic and the timeline
+     * together — there is no intermediate `MeshResult` to hang it off.
+     */
+    static animatedGlbB64(schematic: Schematic, pack: ResourcePack, timelineJson: string): string;
+
+    /**
+     * The mesh as a binary GLB, base64-encoded.
+     */
+    glbDataB64(): string;
+
+    /**
+     * The mesh as a USDZ archive, base64-encoded.
+     */
+    usdzDataB64(): 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;
+}