nucleation 0.10.21 → 0.10.23

package/renderer/MeshConfig.d.mts

@@ -0,0 +1,101 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Mesh generation configuration. Wraps {@link crate::meshing::MeshConfig}.
+ */
+export class MeshConfig {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Create a config with default settings: hidden-face culling on,
+     * ambient occlusion on (intensity 0.4), no biome, atlas max size 4096,
+     * occluded-block culling on, greedy meshing off.
+     */
+    static create(): MeshConfig;
+
+    /**
+     * Enable face culling between adjacent solid blocks (default: true).
+     */
+    setCullHiddenFaces(val: boolean): void;
+
+    /**
+     * Whether hidden-face culling is enabled.
+     */
+    cullHiddenFaces(): boolean;
+
+    /**
+     * Enable ambient occlusion (default: true).
+     */
+    setAmbientOcclusion(val: boolean): void;
+
+    /**
+     * Whether ambient occlusion is enabled.
+     */
+    ambientOcclusion(): boolean;
+
+    /**
+     * Set ambient-occlusion intensity, 0.0 (no darkening) to 1.0 (full
+     * darkening). Default: 0.4.
+     */
+    setAoIntensity(val: number): void;
+
+    /**
+     * The ambient-occlusion intensity (0.0–1.0).
+     */
+    aoIntensity(): number;
+
+    /**
+     * Set the biome used for tinting (e.g. "plains", "swamp").
+     */
+    setBiome(biome: string): void;
+
+    /**
+     * Clear the biome (old ABI: `meshconfig_set_biome(NULL)`).
+     */
+    clearBiome(): void;
+
+    /**
+     * The configured biome; `NotFound` if none is set.
+     */
+    biome(): string;
+
+    /**
+     * Set the maximum texture-atlas dimension in pixels (default: 4096).
+     */
+    setAtlasMaxSize(size: number): void;
+
+    /**
+     * The maximum texture-atlas dimension in pixels.
+     */
+    atlasMaxSize(): number;
+
+    /**
+     * Skip blocks fully hidden by opaque neighbors on all 6 sides
+     * (default: true).
+     */
+    setCullOccludedBlocks(val: boolean): void;
+
+    /**
+     * Whether occluded-block culling is enabled.
+     */
+    cullOccludedBlocks(): boolean;
+
+    /**
+     * Merge adjacent coplanar faces into larger quads to reduce triangle
+     * count (default: false).
+     */
+    setGreedyMeshing(val: boolean): void;
+
+    /**
+     * Whether greedy meshing is enabled.
+     */
+    greedyMeshing(): boolean;
+}

package/renderer/MeshConfig.d.ts

@@ -0,0 +1,101 @@
+// generated by diplomat-tool
+import type { NucleationError } from "./NucleationError.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Mesh generation configuration. Wraps {@link crate::meshing::MeshConfig}.
+ */
+export class MeshConfig {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Create a config with default settings: hidden-face culling on,
+     * ambient occlusion on (intensity 0.4), no biome, atlas max size 4096,
+     * occluded-block culling on, greedy meshing off.
+     */
+    static create(): MeshConfig;
+
+    /**
+     * Enable face culling between adjacent solid blocks (default: true).
+     */
+    setCullHiddenFaces(val: boolean): void;
+
+    /**
+     * Whether hidden-face culling is enabled.
+     */
+    cullHiddenFaces(): boolean;
+
+    /**
+     * Enable ambient occlusion (default: true).
+     */
+    setAmbientOcclusion(val: boolean): void;
+
+    /**
+     * Whether ambient occlusion is enabled.
+     */
+    ambientOcclusion(): boolean;
+
+    /**
+     * Set ambient-occlusion intensity, 0.0 (no darkening) to 1.0 (full
+     * darkening). Default: 0.4.
+     */
+    setAoIntensity(val: number): void;
+
+    /**
+     * The ambient-occlusion intensity (0.0–1.0).
+     */
+    aoIntensity(): number;
+
+    /**
+     * Set the biome used for tinting (e.g. "plains", "swamp").
+     */
+    setBiome(biome: string): void;
+
+    /**
+     * Clear the biome (old ABI: `meshconfig_set_biome(NULL)`).
+     */
+    clearBiome(): void;
+
+    /**
+     * The configured biome; `NotFound` if none is set.
+     */
+    biome(): string;
+
+    /**
+     * Set the maximum texture-atlas dimension in pixels (default: 4096).
+     */
+    setAtlasMaxSize(size: number): void;
+
+    /**
+     * The maximum texture-atlas dimension in pixels.
+     */
+    atlasMaxSize(): number;
+
+    /**
+     * Skip blocks fully hidden by opaque neighbors on all 6 sides
+     * (default: true).
+     */
+    setCullOccludedBlocks(val: boolean): void;
+
+    /**
+     * Whether occluded-block culling is enabled.
+     */
+    cullOccludedBlocks(): boolean;
+
+    /**
+     * Merge adjacent coplanar faces into larger quads to reduce triangle
+     * count (default: false).
+     */
+    setGreedyMeshing(val: boolean): void;
+
+    /**
+     * Whether greedy meshing is enabled.
+     */
+    greedyMeshing(): boolean;
+}

package/renderer/MeshConfig.mjs

@@ -0,0 +1,306 @@
+// generated by diplomat-tool
+import { NucleationError } from "./NucleationError.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const MeshConfig_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.MeshConfig_destroy(ptr);
+});
+
+/**
+ * Mesh generation configuration. Wraps {@link crate::meshing::MeshConfig}.
+ */
+export class MeshConfig {
+    // 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("MeshConfig 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) {
+            MeshConfig_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Create a config with default settings: hidden-face culling on,
+     * ambient occlusion on (intensity 0.4), no biome, atlas max size 4096,
+     * occluded-block culling on, greedy meshing off.
+     */
+    static create() {
+
+        const result = wasm.MeshConfig_create();
+
+        try {
+            return new MeshConfig(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Enable face culling between adjacent solid blocks (default: true).
+     */
+    setCullHiddenFaces(val) {
+    wasm.MeshConfig_set_cull_hidden_faces(this.ffiValue, val);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Whether hidden-face culling is enabled.
+     */
+    cullHiddenFaces() {
+
+        const result = wasm.MeshConfig_cull_hidden_faces(this.ffiValue);
+
+        try {
+            return result === 1;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Enable ambient occlusion (default: true).
+     */
+    setAmbientOcclusion(val) {
+    wasm.MeshConfig_set_ambient_occlusion(this.ffiValue, val);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Whether ambient occlusion is enabled.
+     */
+    ambientOcclusion() {
+
+        const result = wasm.MeshConfig_ambient_occlusion(this.ffiValue);
+
+        try {
+            return result === 1;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Set ambient-occlusion intensity, 0.0 (no darkening) to 1.0 (full
+     * darkening). Default: 0.4.
+     */
+    setAoIntensity(val) {
+    wasm.MeshConfig_set_ao_intensity(this.ffiValue, val);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * The ambient-occlusion intensity (0.0–1.0).
+     */
+    aoIntensity() {
+
+        const result = wasm.MeshConfig_ao_intensity(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Set the biome used for tinting (e.g. "plains", "swamp").
+     */
+    setBiome(biome) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const biomeSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, biome)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.MeshConfig_set_biome(diplomatReceive.buffer, this.ffiValue, biomeSlice.ptr);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Clear the biome (old ABI: `meshconfig_set_biome(NULL)`).
+     */
+    clearBiome() {
+    wasm.MeshConfig_clear_biome(this.ffiValue);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * The configured biome; `NotFound` if none is set.
+     */
+    biome() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+
+        const result = wasm.MeshConfig_biome(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();
+        }
+    }
+
+    /**
+     * Set the maximum texture-atlas dimension in pixels (default: 4096).
+     */
+    setAtlasMaxSize(size) {
+    wasm.MeshConfig_set_atlas_max_size(this.ffiValue, size);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * The maximum texture-atlas dimension in pixels.
+     */
+    atlasMaxSize() {
+
+        const result = wasm.MeshConfig_atlas_max_size(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Skip blocks fully hidden by opaque neighbors on all 6 sides
+     * (default: true).
+     */
+    setCullOccludedBlocks(val) {
+    wasm.MeshConfig_set_cull_occluded_blocks(this.ffiValue, val);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Whether occluded-block culling is enabled.
+     */
+    cullOccludedBlocks() {
+
+        const result = wasm.MeshConfig_cull_occluded_blocks(this.ffiValue);
+
+        try {
+            return result === 1;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Merge adjacent coplanar faces into larger quads to reduce triangle
+     * count (default: false).
+     */
+    setGreedyMeshing(val) {
+    wasm.MeshConfig_set_greedy_meshing(this.ffiValue, val);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Whether greedy meshing is enabled.
+     */
+    greedyMeshing() {
+
+        const result = wasm.MeshConfig_greedy_meshing(this.ffiValue);
+
+        try {
+            return result === 1;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/renderer/MeshJob.d.mts

@@ -0,0 +1,44 @@
+// generated by diplomat-tool
+import type { ChunkMeshResult } from "./ChunkMeshResult.mjs"
+import type { MeshConfig } from "./MeshConfig.mjs"
+import type { MeshProgress } from "./MeshProgress.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { ResourcePack } from "./ResourcePack.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { TextureAtlas } from "./TextureAtlas.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A chunk-meshing job running on a background thread. Replaces the old
+ * `schematic_mesh_chunks_with_atlas_progress` C callback: poll it from a
+ * timer loop with {@link MeshJob::poll_progress}, then call
+ * {@link MeshJob::take_result} once (it blocks until the job finishes and
+ * consumes the job — a second call returns `AlreadyConsumed`).
+ */
+export class MeshJob {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Kick off chunk meshing with a shared atlas on a background thread
+     * and return immediately. Takes the same parameters as
+     * {@link ChunkMeshResult::create_with_atlas}.
+     */
+    static start(schematic: Schematic, pack: ResourcePack, config: MeshConfig, chunkSize: number, atlas: TextureAtlas): MeshJob;
+
+    /**
+     * Cheap, non-blocking progress snapshot. Call from a timer/poll loop.
+     */
+    pollProgress(): MeshProgress;
+
+    /**
+     * Block until the job finishes (if it hasn't already) and return the
+     * result. Consumes the job: a second call returns `AlreadyConsumed`.
+     */
+    takeResult(): ChunkMeshResult;
+}

package/renderer/MeshJob.d.ts

@@ -0,0 +1,44 @@
+// generated by diplomat-tool
+import type { ChunkMeshResult } from "./ChunkMeshResult.mjs"
+import type { MeshConfig } from "./MeshConfig.mjs"
+import type { MeshProgress } from "./MeshProgress.mjs"
+import type { NucleationError } from "./NucleationError.mjs"
+import type { ResourcePack } from "./ResourcePack.mjs"
+import type { Schematic } from "./Schematic.mjs"
+import type { TextureAtlas } from "./TextureAtlas.mjs"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * A chunk-meshing job running on a background thread. Replaces the old
+ * `schematic_mesh_chunks_with_atlas_progress` C callback: poll it from a
+ * timer loop with {@link MeshJob::poll_progress}, then call
+ * {@link MeshJob::take_result} once (it blocks until the job finishes and
+ * consumes the job — a second call returns `AlreadyConsumed`).
+ */
+export class MeshJob {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Kick off chunk meshing with a shared atlas on a background thread
+     * and return immediately. Takes the same parameters as
+     * {@link ChunkMeshResult::create_with_atlas}.
+     */
+    static start(schematic: Schematic, pack: ResourcePack, config: MeshConfig, chunkSize: number, atlas: TextureAtlas): MeshJob;
+
+    /**
+     * Cheap, non-blocking progress snapshot. Call from a timer/poll loop.
+     */
+    pollProgress(): MeshProgress;
+
+    /**
+     * Block until the job finishes (if it hasn't already) and return the
+     * result. Consumes the job: a second call returns `AlreadyConsumed`.
+     */
+    takeResult(): ChunkMeshResult;
+}

package/renderer/MeshJob.mjs

@@ -0,0 +1,116 @@
+// generated by diplomat-tool
+import { ChunkMeshResult } from "./ChunkMeshResult.mjs"
+import { MeshConfig } from "./MeshConfig.mjs"
+import { MeshProgress } from "./MeshProgress.mjs"
+import { NucleationError } from "./NucleationError.mjs"
+import { ResourcePack } from "./ResourcePack.mjs"
+import { Schematic } from "./Schematic.mjs"
+import { TextureAtlas } from "./TextureAtlas.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const MeshJob_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.MeshJob_destroy(ptr);
+});
+
+/**
+ * A chunk-meshing job running on a background thread. Replaces the old
+ * `schematic_mesh_chunks_with_atlas_progress` C callback: poll it from a
+ * timer loop with {@link MeshJob::poll_progress}, then call
+ * {@link MeshJob::take_result} once (it blocks until the job finishes and
+ * consumes the job — a second call returns `AlreadyConsumed`).
+ */
+export class MeshJob {
+    // 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("MeshJob 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) {
+            MeshJob_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Kick off chunk meshing with a shared atlas on a background thread
+     * and return immediately. Takes the same parameters as
+     * {@link ChunkMeshResult::create_with_atlas}.
+     */
+    static start(schematic, pack, config, chunkSize, atlas) {
+
+        const result = wasm.MeshJob_start(schematic.ffiValue, pack.ffiValue, config.ffiValue, chunkSize, atlas.ffiValue);
+
+        try {
+            return new MeshJob(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Cheap, non-blocking progress snapshot. Call from a timer/poll loop.
+     */
+    pollProgress() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 12, 4, false);
+
+
+        const result = wasm.MeshJob_poll_progress(diplomatReceive.buffer, this.ffiValue);
+
+        try {
+            return MeshProgress._fromFFI(diplomatRuntime.internalConstructor, diplomatReceive.buffer);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Block until the job finishes (if it hasn't already) and return the
+     * result. Consumes the job: a second call returns `AlreadyConsumed`.
+     */
+    takeResult() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.MeshJob_take_result(diplomatReceive.buffer, this.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 ChunkMeshResult(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}