nucleation 0.2.18 → 0.3.1

package/Brush.mjs

@@ -0,0 +1,220 @@
+// generated by diplomat-tool
+import { InterpolationSpace } from "./InterpolationSpace.mjs"
+import { NucleationError } from "./NucleationError.mjs"
+import { Palette } from "./Palette.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const Brush_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.Brush_destroy(ptr);
+});
+
+/**
+ * Decides which block goes at each point of a filled shape. Wraps `BrushEnum`.
+ */
+export class Brush {
+    // 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("Brush 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) {
+            Brush_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Every point becomes `block_name` (a block-state string).
+     */
+    static solid(blockName) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const blockNameSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.str8(wasm, blockName)));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Brush_solid(diplomatReceive.buffer, blockNameSlice.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 Brush(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Nearest-block-to-RGB-color brush.
+     */
+    static color(r, g, b) {
+
+        const result = wasm.Brush_color(r, g, b);
+
+        try {
+            return new Brush(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Linear color gradient between two anchored points.
+     */
+    static linearGradient(x1, y1, z1, r1, g1, b1, x2, y2, z2, r2, g2, b2, space) {
+
+        const result = wasm.Brush_linear_gradient(x1, y1, z1, r1, g1, b1, x2, y2, z2, r2, g2, b2, space.ffiValue);
+
+        try {
+            return new Brush(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Base color shaded by surface normal against light direction
+     * (`lx`, `ly`, `lz`).
+     */
+    static shaded(r, g, b, lx, ly, lz) {
+
+        const result = wasm.Brush_shaded(r, g, b, lx, ly, lz);
+
+        try {
+            return new Brush(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Bilinear gradient over the patch `origin + s*u + t*v` with corner colors
+     * c00/c10/c01/c11.
+     */
+    static bilinearGradient(ox, oy, oz, ux, uy, uz, vx, vy, vz, r00, g00, b00, r10, g10, b10, r01, g01, b01, r11, g11, b11, space) {
+
+        const result = wasm.Brush_bilinear_gradient(ox, oy, oz, ux, uy, uz, vx, vy, vz, r00, g00, b00, r10, g10, b10, r01, g01, b01, r11, g11, b11, space.ffiValue);
+
+        try {
+            return new Brush(diplomatRuntime.internalConstructor, result, []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Inverse-distance-weighted gradient between colored anchor points.
+     * `positions` is flat `[x0, y0, z0, x1, …]` and `colors` is flat
+     * `[r0, g0, b0, r1, …]`; both must describe the same non-zero number of
+     * points (`positions.len() == colors.len()`, a multiple of 3).
+     */
+    static pointGradient(positions, colors, falloff, space) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const positionsSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.slice(wasm, positions, "i32")));
+        const colorsSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.slice(wasm, colors, "u8")));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Brush_point_gradient(diplomatReceive.buffer, positionsSlice.ptr, colorsSlice.ptr, falloff, space.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 Brush(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Use `palette` for this brush's color→block snapping instead of the
+     * default all-blocks palette. No-op for `solid` brushes, which place
+     * a fixed block state. Set it before filling; the palette is shared,
+     * not copied.
+     */
+    setPalette(palette) {
+    wasm.Brush_set_palette(this.ffiValue, palette.ffiValue);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Gradient along a parametric curve: `stops` holds the curve parameters in
+     * `[0, 1]` and `colors` the matching flat RGB triples
+     * (`colors.len() == stops.len() * 3`, `stops` non-empty).
+     */
+    static curveGradient(stops, colors, space) {
+        let functionCleanupArena = new diplomatRuntime.CleanupArena();
+
+        const stopsSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.slice(wasm, stops, "f32")));
+        const colorsSlice = functionCleanupArena.alloc(diplomatRuntime.DiplomatBuf.sliceWrapper(wasm, diplomatRuntime.DiplomatBuf.slice(wasm, colors, "u8")));
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.Brush_curve_gradient(diplomatReceive.buffer, stopsSlice.ptr, colorsSlice.ptr, space.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 Brush(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            functionCleanupArena.free();
+
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/BuildingTool.d.ts

@@ -0,0 +1,29 @@
+// generated by diplomat-tool
+import type { Brush } from "./Brush"
+import type { Schematic } from "./Schematic"
+import type { Shape } from "./Shape"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Namespace for the fill operations that combine a schematic, a shape and a
+ * brush (the old `buildingtool_*` free functions).
+ */
+export class BuildingTool {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Fill `shape` into `schematic` using `brush`.
+     */
+    static fill(schematic: Schematic, shape: Shape, brush: Brush): void;
+
+    /**
+     * Fill `count` copies of `shape`, each offset by `offset * i`.
+     */
+    static rstack(schematic: Schematic, shape: Shape, brush: Brush, count: number, offsetX: number, offsetY: number, offsetZ: number): void;
+}

package/BuildingTool.mjs

@@ -0,0 +1,74 @@
+// generated by diplomat-tool
+import { Brush } from "./Brush.mjs"
+import { Schematic } from "./Schematic.mjs"
+import { Shape } from "./Shape.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const BuildingTool_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.BuildingTool_destroy(ptr);
+});
+
+/**
+ * Namespace for the fill operations that combine a schematic, a shape and a
+ * brush (the old `buildingtool_*` free functions).
+ */
+export class BuildingTool {
+    // 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("BuildingTool 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) {
+            BuildingTool_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Fill `shape` into `schematic` using `brush`.
+     */
+    static fill(schematic, shape, brush) {
+    wasm.BuildingTool_fill(schematic.ffiValue, shape.ffiValue, brush.ffiValue);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Fill `count` copies of `shape`, each offset by `offset * i`.
+     */
+    static rstack(schematic, shape, brush, count, offsetX, offsetY, offsetZ) {
+    wasm.BuildingTool_rstack(schematic.ffiValue, shape.ffiValue, brush.ffiValue, count, offsetX, offsetY, offsetZ);
+
+        try {}
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/ChunkMeshResult.d.ts

@@ -0,0 +1,75 @@
+// generated by diplomat-tool
+import type { BlockPos } from "./BlockPos"
+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 { TextureAtlas } from "./TextureAtlas"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Per-chunk mesh results. Wraps {@link crate::meshing::ChunkMeshResult}.
+ */
+export class ChunkMeshResult {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    /**
+     * Mesh with the default chunk size (old ABI: `schematic_mesh_by_chunk`).
+     */
+    static create(schematic: Schematic, pack: ResourcePack, config: MeshConfig): ChunkMeshResult;
+
+    /**
+     * Mesh with an explicit chunk size (old ABI: `schematic_mesh_by_chunk_size`).
+     */
+    static createWithSize(schematic: Schematic, pack: ResourcePack, config: MeshConfig, chunkSize: number): ChunkMeshResult;
+
+    /**
+     * Mesh chunks against a pre-built shared atlas, synchronously
+     * (old ABI: `schematic_mesh_chunks_with_atlas`). For progress
+     * reporting use {@link MeshJob::start} instead.
+     */
+    static createWithAtlas(schematic: Schematic, pack: ResourcePack, config: MeshConfig, chunkSize: number, atlas: TextureAtlas): ChunkMeshResult;
+
+    /**
+     * Number of chunk meshes.
+     */
+    chunkCount(): number;
+
+    /**
+     * Coordinate of the `index`-th chunk (old ABI:
+     * `chunkmeshresult_chunk_coordinates` returned all of them flat).
+     */
+    chunkCoordinateAt(index: number): BlockPos;
+
+    /**
+     * The mesh for one chunk coordinate (cloned).
+     */
+    getMesh(cx: number, cy: number, cz: number): MeshResult;
+
+    /**
+     * Total vertex count across all chunk meshes.
+     */
+    totalVertexCount(): number;
+
+    /**
+     * Total triangle count across all chunk meshes.
+     */
+    totalTriangleCount(): number;
+
+    /**
+     * All chunk meshes serialized in the NUCM cache format, base64-encoded.
+     */
+    nucmDataB64(): string;
+
+    /**
+     * NUCM v2 with a shared atlas, base64-encoded.
+     */
+    nucmDataWithAtlasB64(atlas: TextureAtlas): string;
+}

package/ChunkMeshResult.mjs

@@ -0,0 +1,253 @@
+// generated by diplomat-tool
+import { BlockPos } from "./BlockPos.mjs"
+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 { TextureAtlas } from "./TextureAtlas.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const ChunkMeshResult_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.ChunkMeshResult_destroy(ptr);
+});
+
+/**
+ * Per-chunk mesh results. Wraps {@link crate::meshing::ChunkMeshResult}.
+ */
+export class ChunkMeshResult {
+    // 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("ChunkMeshResult 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) {
+            ChunkMeshResult_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    /**
+     * Mesh with the default chunk size (old ABI: `schematic_mesh_by_chunk`).
+     */
+    static create(schematic, pack, config) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.ChunkMeshResult_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 ChunkMeshResult(diplomatRuntime.internalConstructor, diplomatRuntime.ptrRead(wasm, diplomatReceive.buffer), []);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * Mesh with an explicit chunk size (old ABI: `schematic_mesh_by_chunk_size`).
+     */
+    static createWithSize(schematic, pack, config, chunkSize) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.ChunkMeshResult_create_with_size(diplomatReceive.buffer, schematic.ffiValue, pack.ffiValue, config.ffiValue, chunkSize);
+
+        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();
+        }
+    }
+
+    /**
+     * Mesh chunks against a pre-built shared atlas, synchronously
+     * (old ABI: `schematic_mesh_chunks_with_atlas`). For progress
+     * reporting use {@link MeshJob::start} instead.
+     */
+    static createWithAtlas(schematic, pack, config, chunkSize, atlas) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.ChunkMeshResult_create_with_atlas(diplomatReceive.buffer, schematic.ffiValue, pack.ffiValue, config.ffiValue, chunkSize, atlas.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();
+        }
+    }
+
+    /**
+     * Number of chunk meshes.
+     */
+    chunkCount() {
+
+        const result = wasm.ChunkMeshResult_chunk_count(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Coordinate of the `index`-th chunk (old ABI:
+     * `chunkmeshresult_chunk_coordinates` returned all of them flat).
+     */
+    chunkCoordinateAt(index) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 13, 4, true);
+
+
+        const result = wasm.ChunkMeshResult_chunk_coordinate_at(diplomatReceive.buffer, this.ffiValue, index);
+
+        try {
+            if (!diplomatReceive.resultFlag) {
+                const cause = new NucleationError(diplomatRuntime.internalConstructor, diplomatRuntime.enumDiscriminant(wasm, diplomatReceive.buffer));
+                throw new globalThis.Error('NucleationError.' + cause.value, { cause });
+            }
+            return BlockPos._fromFFI(diplomatRuntime.internalConstructor, diplomatReceive.buffer);
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    /**
+     * The mesh for one chunk coordinate (cloned).
+     */
+    getMesh(cx, cy, cz) {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 5, 4, true);
+
+
+        const result = wasm.ChunkMeshResult_get_mesh(diplomatReceive.buffer, this.ffiValue, cx, cy, cz);
+
+        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();
+        }
+    }
+
+    /**
+     * Total vertex count across all chunk meshes.
+     */
+    totalVertexCount() {
+
+        const result = wasm.ChunkMeshResult_total_vertex_count(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * Total triangle count across all chunk meshes.
+     */
+    totalTriangleCount() {
+
+        const result = wasm.ChunkMeshResult_total_triangle_count(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    /**
+     * All chunk meshes serialized in the NUCM cache format, base64-encoded.
+     */
+    nucmDataB64() {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.ChunkMeshResult_nucm_data_b64(this.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    /**
+     * NUCM v2 with a shared atlas, base64-encoded.
+     */
+    nucmDataWithAtlasB64(atlas) {
+        const write = new diplomatRuntime.DiplomatWriteBuf(wasm);
+
+    wasm.ChunkMeshResult_nucm_data_with_atlas_b64(this.ffiValue, atlas.ffiValue, write.buffer);
+
+        try {
+            return write.readString8();
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            write.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}