@divinevoxel/vlox 0.0.75 → 0.0.77

package/Builder/Tools/Wrench/WrenchTool.js

@@ -0,0 +1,184 @@
+import { PaintVoxelData } from "../../../Voxels";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
+import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
+var WrenchToolModes;
+(function (WrenchToolModes) {
+    WrenchToolModes["Pick"] = "Pick";
+    WrenchToolModes["Update"] = "Update";
+})(WrenchToolModes || (WrenchToolModes = {}));
+export class WrenchTool extends BuilderToolBase {
+    static ToolId = "Wrench";
+    mode = WrenchToolModes.Pick;
+    selection = new VoxelPointSelection();
+    paintData = PaintVoxelData.Create();
+    _pickedResult = null;
+    isUpdating() {
+        if (this._pickedResult !== null && this.mode == WrenchToolModes.Update)
+            return true;
+        return false;
+    }
+    stopUpdating() {
+        this.mode = WrenchToolModes.Pick;
+        this._pickedResult = null;
+    }
+    async update() {
+        this._lastPicked = await this.space.pickWithProvider(this.rayProviderIndex);
+        if (!this._lastPicked)
+            return;
+        if (this.mode == WrenchToolModes.Pick) {
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.position)) {
+                this._lastPicked = null;
+                return;
+            }
+            this.selection.reConstruct(this._lastPicked.position);
+        }
+    }
+    processSchema(schema) {
+        const nodes = [];
+        for (const node of schema.nodes) {
+            if (node.valuePalette) {
+                nodes.push({
+                    id: node.name,
+                    label: node.name,
+                    values: [...node.valuePalette._palette],
+                    type: "string",
+                    value: "",
+                });
+            }
+            else {
+                nodes.push({
+                    id: node.name,
+                    label: node.name,
+                    min: 0,
+                    max: Math.pow(2, node.data.bitSize) - 1,
+                    type: "number",
+                    value: 0,
+                });
+            }
+        }
+        return nodes;
+    }
+    updatePickedSchema(schema) {
+        if (!this._pickedResult)
+            return;
+        const trueVoxelId = this._pickedResult.voxel.getVoxelId();
+        const voxelSchemas = SchemaRegister.getVoxelSchemas(this._pickedResult.voxel.getStringId());
+        voxelSchemas.state.startEncoding(this._pickedResult.voxel.getState());
+        voxelSchemas.mod.startEncoding(this._pickedResult.voxel.getMod());
+        for (const node of schema.stateSchema) {
+            if (node.type == "string") {
+                voxelSchemas.state.setValue(node.id, node.value);
+            }
+            else {
+                voxelSchemas.state.setNumber(node.id, node.value);
+            }
+        }
+        for (const node of schema.modSchema) {
+            if (node.type == "string") {
+                voxelSchemas.mod.setValue(node.id, node.value);
+            }
+            else {
+                voxelSchemas.mod.setNumber(node.id, node.value);
+            }
+        }
+        const currentRaw = this._pickedResult.voxel.getRaw();
+        const rawVoxelData = [
+            VoxelPalettesRegister.getVoxelId(trueVoxelId, voxelSchemas.state.getEncoded(), voxelSchemas.mod.getEncoded()),
+            currentRaw[1],
+            currentRaw[2],
+            currentRaw[3],
+        ];
+        this.paintData = PaintVoxelData.FromRaw(rawVoxelData);
+        return this.paintData;
+    }
+    getPickedSchema() {
+        if (!this._pickedResult)
+            return null;
+        const id = this._pickedResult.voxel.getStringId();
+        const voxelSchemas = SchemaRegister.getVoxelSchemas(id);
+        voxelSchemas.state.startEncoding(this._pickedResult.voxel.getState());
+        voxelSchemas.mod.startEncoding(this._pickedResult.voxel.getMod());
+        return {
+            stateSchema: this.processSchema(voxelSchemas.state),
+            modSchema: this.processSchema(voxelSchemas.mod),
+        };
+    }
+    /**Get an array of all possible state varations for the current mod of the selected voxel. */
+    getStateValues() {
+        if (!this._pickedResult)
+            return null;
+        const voxelStates = [];
+        const voxelId = this._pickedResult.voxel.id;
+        const [trueId, , mod] = VoxelPalettesRegister.voxels[voxelId];
+        const stateArray = VoxelPalettesRegister.voxelRecord[trueId][mod];
+        const rawVoxelData = [0, 0, 0, 0];
+        for (let i = 0; i < stateArray.length; i++) {
+            const value = stateArray[i];
+            if (value === undefined || value <= 0)
+                continue;
+            rawVoxelData[0] = value;
+            voxelStates.push(PaintVoxelData.FromRaw(rawVoxelData));
+        }
+        return voxelStates;
+    }
+    /**Get an array of all possible mod varations for the current state of the selected voxel. */
+    getModValues() {
+        if (!this._pickedResult)
+            return null;
+        const voxelStates = [];
+        const voxelId = this._pickedResult.voxel.id;
+        const [trueId, state] = VoxelPalettesRegister.voxels[voxelId];
+        const modArray = VoxelPalettesRegister.voxelRecord[trueId];
+        const rawVoxelData = [0, 0, 0, 0];
+        for (let i = 0; i < modArray.length; i++) {
+            const stateArray = modArray[i];
+            if (stateArray === undefined || !stateArray.length)
+                continue;
+            let id = -1;
+            for (let j = 0; j < stateArray.length; j++) {
+                id = VoxelPalettesRegister.voxelRecord[trueId][i][state];
+                if (id === undefined || id < 0)
+                    continue;
+                rawVoxelData[0] = id;
+                break;
+            }
+            if (id === undefined || id < 0)
+                continue;
+            voxelStates.push(PaintVoxelData.FromRaw(rawVoxelData));
+        }
+        return voxelStates;
+    }
+    cancel() {
+        this._lastPicked = null;
+    }
+    async use() {
+        if (this.mode == WrenchToolModes.Pick) {
+            if (this._lastPicked && !this._lastPicked.voxel.isAir()) {
+                this._pickedResult = this._lastPicked.clone();
+                this.dispatch("picked", {});
+                this.mode = WrenchToolModes.Update;
+                return;
+            }
+            else {
+                this._pickedResult = null;
+            }
+        }
+        if (this.mode == WrenchToolModes.Update) {
+            await this.space.paintVoxel([
+                this.selection.origin.x,
+                this.selection.origin.y,
+                this.selection.origin.z,
+            ], this.paintData);
+            return;
+        }
+    }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
+}

package/Builder/Util/FreeBoxSelection.d.ts

@@ -0,0 +1,12 @@
+import { VoxelBuildSpace } from "../VoxelBuildSpace";
+import { VoxelBoundsSelection } from "../../Templates/Selection/VoxelBoundsSelection";
+import { Vector3Like } from "@amodx/math";
+import { FreePointSelection } from "./FreePointSelection";
+export declare class FreeBoxSelection {
+    space: VoxelBuildSpace;
+    point: FreePointSelection;
+    start: Vector3Like;
+    selection: VoxelBoundsSelection;
+    constructor(space: VoxelBuildSpace, point: FreePointSelection);
+    update(): void;
+}

package/Builder/Util/FreeBoxSelection.js

@@ -0,0 +1,21 @@
+import { VoxelBoundsSelection } from "../../Templates/Selection/VoxelBoundsSelection";
+import { Axes } from "@amodx/math/Vectors/Axes";
+export class FreeBoxSelection {
+    space;
+    point;
+    start;
+    selection;
+    constructor(space, point) {
+        this.space = space;
+        this.point = point;
+        this.start = { ...point.selection.origin };
+        this.selection = new VoxelBoundsSelection();
+        this.selection.reConstruct(this.start, Axes.UpReadOnly(), this.start, Axes.UpReadOnly());
+    }
+    update() {
+        const point = this.point.getPoint();
+        if (!point)
+            return;
+        this.selection.reConstruct(this.start, Axes.UpReadOnly(), point, Axes.UpReadOnly());
+    }
+}

package/Builder/Util/FreePointSelection.d.ts

@@ -0,0 +1,14 @@
+import { VoxelBuildSpace } from "../VoxelBuildSpace";
+import { Vector3Like } from "@amodx/math";
+import { VoxelPointSelection } from "../../Templates/Selection/VoxelPointSelection";
+export declare class FreePointSelection {
+    space: VoxelBuildSpace;
+    selection: VoxelPointSelection;
+    distance: number;
+    planeOrigin: Vector3Like;
+    planeNormal: Vector3Like;
+    offset: number;
+    constructor(space: VoxelBuildSpace, selection: VoxelPointSelection, distance?: number);
+    getPoint(): Vector3Like | undefined;
+    update(): boolean;
+}

package/Builder/Util/FreePointSelection.js

@@ -0,0 +1,39 @@
+import { Vector3Like } from "@amodx/math";
+export class FreePointSelection {
+    space;
+    selection;
+    distance;
+    planeOrigin = Vector3Like.Create();
+    planeNormal = Vector3Like.Create();
+    offset = 0;
+    constructor(space, selection, distance = 10) {
+        this.space = space;
+        this.selection = selection;
+        this.distance = distance;
+    }
+    getPoint() {
+        let rayPosition = Vector3Like.FloorInPlace(Vector3Like.Add(this.space.rayProvider.origin, Vector3Like.MultiplyScalar(this.space.rayProvider.direction, this.distance)));
+        if (!this.space.bounds.intersectsPoint(rayPosition)) {
+            const rayIntersection = this.space.bounds.rayIntersection(this.space.rayProvider.origin, this.space.rayProvider.direction, this.space.rayProvider.length);
+            if (!isFinite(rayIntersection))
+                return;
+            if (rayIntersection == 0) {
+                const rayIntersectionFromWithin = this.space.bounds.rayIntersectionFromWithin(this.space.rayProvider.origin, this.space.rayProvider.direction, this.space.rayProvider.length);
+                if (!isFinite(rayIntersectionFromWithin))
+                    return;
+                rayPosition = Vector3Like.FloorInPlace(Vector3Like.Add(this.space.rayProvider.origin, Vector3Like.MultiplyScalar(this.space.rayProvider.direction, rayIntersectionFromWithin)));
+            }
+            else {
+                rayPosition = Vector3Like.FloorInPlace(Vector3Like.Add(this.space.rayProvider.origin, Vector3Like.MultiplyScalar(this.space.rayProvider.direction, rayIntersection)));
+            }
+        }
+        return rayPosition;
+    }
+    update() {
+        const point = this.getPoint();
+        if (!point)
+            return false;
+        this.selection.reConstruct(point);
+        return true;
+    }
+}

package/Builder/Util/SurfaceBoxSelection.d.ts

@@ -0,0 +1,12 @@
+import { VoxelBuildSpace } from "../VoxelBuildSpace";
+import { VoxelBoundsSelection } from "../../Templates/Selection/VoxelBoundsSelection";
+import { Vector3Like } from "@amodx/math";
+export declare class SurfaceBoxSelection {
+    space: VoxelBuildSpace;
+    selection: VoxelBoundsSelection;
+    planeOrigin: Vector3Like;
+    planeNormal: Vector3Like;
+    offset: number;
+    constructor(space: VoxelBuildSpace, selection: VoxelBoundsSelection);
+    update(): void;
+}

package/Builder/Util/SurfaceBoxSelection.js

@@ -0,0 +1,25 @@
+import { Vector3Like } from "@amodx/math";
+export class SurfaceBoxSelection {
+    space;
+    selection;
+    planeOrigin = Vector3Like.Create();
+    planeNormal = Vector3Like.Create();
+    offset = 0;
+    constructor(space, selection) {
+        this.space = space;
+        this.selection = selection;
+    }
+    update() {
+        const rayOrigin = this.space.rayProvider.origin;
+        const rayDirection = this.space.rayProvider.direction;
+        const distance = Vector3Like.Dot(Vector3Like.Subtract(this.planeOrigin, rayOrigin), this.planeNormal) / Vector3Like.Dot(rayDirection, this.planeNormal);
+        const intersectionPoint = Vector3Like.FloorInPlace(Vector3Like.Add(rayOrigin, Vector3Like.MultiplyScalar(rayDirection, distance)));
+        let offset = this.offset;
+        if (this.planeNormal.x > 0 ||
+            this.planeNormal.y > 0 ||
+            this.planeNormal.z > 0) {
+            offset++;
+        }
+        this.selection.reConstruct(this.planeOrigin, this.planeNormal, intersectionPoint, this.planeNormal, offset);
+    }
+}

package/Builder/VoxelBuildSpace.d.ts

@@ -0,0 +1,73 @@
+import { Vec3Array, Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { DivineVoxelEngineRender } from "../Contexts/Render";
+import { VoxelPathData } from "../Templates/Path/VoxelPath.types";
+import { IVoxelTemplateData } from "../Templates/VoxelTemplates.types";
+import { PaintVoxelData } from "../Voxels";
+import { VoxelPickResult } from "../Voxels/Interaction/VoxelPickResult";
+import { RayProvider } from "./RayProvider";
+import { FullVoxelTemplate } from "../Templates/Full/FullVoxelTemplate";
+import { BoundsMinMaxData } from "@amodx/math/Geomtry/Bounds/BoundsInterface";
+import type { VoxelSurfaceSelectionData } from "../Templates/Selection/VoxelSurfaceSelection";
+import type { VoxelBFSSelectionData } from "../Templates/Selection/VoxelBFSSelection";
+import { IVoxelSelectionData } from "../Templates/Selection/VoxelSelection";
+import "../Templates/VoxelTemplateRegister";
+type VoxelSpaceBaseUpdateData<Type extends string, Data extends any> = {
+    type: Type;
+    remote?: true;
+} & Data;
+export type VoxelSpaceUpdateData = VoxelSpaceBaseUpdateData<"paint-voxel", {
+    position: Vec3Array;
+    voxel: PaintVoxelData;
+}> | VoxelSpaceBaseUpdateData<"erase-voxel", {
+    position: Vec3Array;
+}> | VoxelSpaceBaseUpdateData<"paint-voxel-template", {
+    position: Vec3Array;
+    template: IVoxelTemplateData<any>;
+}> | VoxelSpaceBaseUpdateData<"erase-voxel-template", {
+    position: Vec3Array;
+    template: IVoxelTemplateData<any>;
+}> | VoxelSpaceBaseUpdateData<"erase-voxel-selection", {
+    selection: IVoxelSelectionData<any>;
+}> | VoxelSpaceBaseUpdateData<"paint-voxel-path", {
+    position: Vec3Array;
+    path: VoxelPathData;
+}> | VoxelSpaceBaseUpdateData<"erase-voxel-path", {
+    position: Vec3Array;
+    path: VoxelPathData;
+}>;
+export declare class VoxelBuildSpace {
+    DVER: DivineVoxelEngineRender;
+    /**Callback that is called before the update is ran. */
+    beforeUpdate: ((data: VoxelSpaceUpdateData) => Promise<void> | void) | null;
+    /**Callback that is called durning the update call using Promise.all. */
+    duringUpdate: ((data: VoxelSpaceUpdateData) => Promise<void> | void) | null;
+    /**Callback that is called after the update is ran. */
+    afterUpdate: ((data: VoxelSpaceUpdateData) => Promise<void> | void) | null;
+    bounds: BoundingBox;
+    private _rayProviders;
+    get rayProvider(): RayProvider;
+    constructor(DVER: DivineVoxelEngineRender, rayProvider: RayProvider, min?: Vector3Like, max?: Vector3Like);
+    addRayProvider(index: number, provider: RayProvider): void;
+    getRayProvider(index: number): RayProvider | null;
+    removeRayProvider(index: number): void;
+    /**Pick the current voxel space. Defaults to the rayProvider values. */
+    pick(rayOrigin?: Vector3Like, rayDirection?: Vector3Like, length?: number): Promise<VoxelPickResult | null>;
+    pickWithProvider(index: number): Promise<VoxelPickResult | null>;
+    createTemplate(bounds: BoundsMinMaxData): Promise<FullVoxelTemplate>;
+    getSurfaceSelection(position: Vector3Like, normal: Vector3Like, extrusion: number, maxSize?: number): Promise<VoxelSurfaceSelectionData>;
+    getBFSSelection(position: Vector3Like, maxSize?: number): Promise<VoxelBFSSelectionData>;
+    getExtrudedSelectionTemplate(selection: IVoxelSelectionData<any>, nomral: Vector3Like): Promise<FullVoxelTemplate>;
+    getPlaceState(data: PaintVoxelData, picked: VoxelPickResult, alt?: number | null): PaintVoxelData | undefined;
+    clear(): Promise<boolean>;
+    private _updateFunctions;
+    update<T extends VoxelSpaceUpdateData>(data: T): Promise<void>;
+    paintVoxel(position: Vec3Array | Vector3Like, voxel: PaintVoxelData): Promise<void>;
+    eraseVoxel(position: Vec3Array | Vector3Like): Promise<void>;
+    paintTemplate(position: Vec3Array | Vector3Like | Vector3Like, template: IVoxelTemplateData<any>): Promise<void>;
+    eraseTemplate(position: Vec3Array | Vector3Like, template: IVoxelTemplateData<any>): Promise<void>;
+    eraseSelection(selection: IVoxelSelectionData<any>): Promise<void>;
+    paintPath(position: Vec3Array | Vector3Like, path: VoxelPathData): Promise<void>;
+    erasePath(position: Vec3Array | Vector3Like, path: VoxelPathData): Promise<void>;
+}
+export {};

package/Builder/VoxelBuildSpace.js

@@ -0,0 +1,224 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { PaintVoxelData } from "../Voxels";
+import { VoxelPlacingStrategyRegister } from "../Voxels/Interaction/Placing/VoxelPlacingStrategyRegister";
+import { VoxelPickResult } from "../Voxels/Interaction/VoxelPickResult";
+import { SchemaRegister } from "../Voxels/State/SchemaRegister";
+import { FullVoxelTemplate } from "../Templates/Full/FullVoxelTemplate";
+import { VoxelShapeTemplate } from "../Templates/Shapes/VoxelShapeTemplate";
+import { BoxVoxelShapeSelection } from "../Templates/Shapes/Selections/BoxVoxelShapeSelection";
+import "../Templates/VoxelTemplateRegister";
+export class VoxelBuildSpace {
+    DVER;
+    /**Callback that is called before the update is ran. */
+    beforeUpdate = null;
+    /**Callback that is called durning the update call using Promise.all. */
+    duringUpdate = null;
+    /**Callback that is called after the update is ran. */
+    afterUpdate = null;
+    bounds;
+    _rayProviders = [];
+    get rayProvider() {
+        return this.getRayProvider(0);
+    }
+    constructor(DVER, rayProvider, min = Vector3Like.Create(-Infinity, -Infinity, -Infinity), max = Vector3Like.Create(Infinity, Infinity, Infinity)) {
+        this.DVER = DVER;
+        this.bounds = new BoundingBox(min, max);
+        this.addRayProvider(0, rayProvider);
+    }
+    addRayProvider(index, provider) {
+        this._rayProviders[index] = provider;
+    }
+    getRayProvider(index) {
+        return this._rayProviders[index];
+    }
+    removeRayProvider(index) {
+        this._rayProviders[index] = null;
+    }
+    /**Pick the current voxel space. Defaults to the rayProvider values. */
+    async pick(rayOrigin = this.rayProvider.origin, rayDirection = this.rayProvider.direction, length = this.rayProvider.length) {
+        const pickedVoxel = await this.DVER.threads.world.runTaskAsync("pick-voxel", [
+            [rayOrigin.x, rayOrigin.y, rayOrigin.z],
+            [rayDirection.x, rayDirection.y, rayDirection.z],
+            length,
+        ]);
+        if (pickedVoxel === null) {
+            return null;
+        }
+        return VoxelPickResult.FromJSON(pickedVoxel);
+    }
+    async pickWithProvider(index) {
+        const provider = this.getRayProvider(index);
+        if (!provider) {
+            throw new Error(`Ray Provider at index ${index} is not set`);
+        }
+        return await this.pick(provider.origin, this.rayProvider.direction, this.rayProvider.length);
+    }
+    async createTemplate(bounds) {
+        const templateData = await this.DVER.threads.world.runTaskAsync("create-voxel-template", [
+            [0, ...Vector3Like.ToArray(bounds.min)],
+            bounds,
+        ]);
+        return new FullVoxelTemplate(templateData);
+    }
+    async getSurfaceSelection(position, normal, extrusion, maxSize) {
+        return await this.DVER.threads.world.runTaskAsync("get-voxel-surface-selection", [position, normal, extrusion, maxSize]);
+    }
+    async getBFSSelection(position, maxSize) {
+        return await this.DVER.threads.world.runTaskAsync("get-voxel-bfs-selection", [position, maxSize]);
+    }
+    async getExtrudedSelectionTemplate(selection, nomral) {
+        const templateData = await this.DVER.threads.world.runTaskAsync("get-extruded-voxel-selection-template", [selection, nomral]);
+        return new FullVoxelTemplate(templateData);
+    }
+    getPlaceState(data, picked, alt = null) {
+        const strategy = VoxelPlacingStrategyRegister.get(data.id);
+        if (!strategy)
+            return data;
+        const state = strategy.getState(picked, alt);
+        if (!state) {
+            data.state = 0;
+            return data;
+        }
+        const schema = SchemaRegister.getVoxelSchemas(data.id);
+        data.state = schema.state.readString(state);
+    }
+    async clear() {
+        const size = this.bounds.size;
+        if (!isFinite(size.x) || !isFinite(size.y) || !isFinite(size.z))
+            return false;
+        const min = this.bounds.min;
+        await this.DVER.threads.world.runTaskAsync("erase-voxel-template", [
+            [0, min.x, min.y, min.z],
+            VoxelShapeTemplate.CreateNew({
+                shapeSelection: BoxVoxelShapeSelection.CreateNew({
+                    width: this.bounds.size.x,
+                    height: this.bounds.size.y,
+                    depth: this.bounds.size.z,
+                }),
+            }),
+        ]);
+        return true;
+    }
+    _updateFunctions = {
+        "paint-voxel": async (update) => {
+            await this.DVER.threads.world.runTaskAsync("paint-voxel", [
+                [0, ...update.position],
+                PaintVoxelData.ToRaw(update.voxel),
+            ]);
+        },
+        "erase-voxel": async (update) => {
+            await this.DVER.threads.world.runTaskAsync("erase-voxel", [
+                0,
+                ...update.position,
+            ]);
+        },
+        "paint-voxel-template": async (update) => {
+            await this.DVER.threads.world.runTaskAsync("paint-voxel-template", [
+                [0, ...update.position],
+                update.template,
+            ]);
+        },
+        "erase-voxel-template": async (update) => {
+            await this.DVER.threads.world.runTaskAsync("erase-voxel-template", [
+                [0, ...update.position],
+                update.template,
+            ]);
+        },
+        "erase-voxel-selection": async (update) => {
+            await this.DVER.threads.world.runTaskAsync("erase-voxel-selection", [
+                [
+                    0,
+                    update.selection.origin.x,
+                    update.selection.origin.y,
+                    update.selection.origin.z,
+                ],
+                update.selection,
+            ]);
+        },
+        "paint-voxel-path": async (update) => {
+            await this.DVER.threads.world.runTaskAsync("paint-voxel-path", [
+                [0, ...update.position],
+                update.path,
+            ]);
+        },
+        "erase-voxel-path": async (update) => {
+            await this.DVER.threads.world.runTaskAsync("erase-voxel-path", [
+                [0, ...update.position],
+                update.path,
+            ]);
+        },
+    };
+    async update(data) {
+        if (this.beforeUpdate)
+            await this.beforeUpdate(data);
+        const run = this._updateFunctions[data.type];
+        if (this.duringUpdate) {
+            await Promise.all([run(data), this.duringUpdate(data)]);
+        }
+        else {
+            await run(data);
+        }
+        if (this.afterUpdate)
+            await this.afterUpdate(data);
+    }
+    async paintVoxel(position, voxel) {
+        await this.update({
+            type: "paint-voxel",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+            voxel,
+        });
+    }
+    async eraseVoxel(position) {
+        await this.update({
+            type: "erase-voxel",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+        });
+    }
+    async paintTemplate(position, template) {
+        await this.update({
+            type: "paint-voxel-template",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+            template,
+        });
+    }
+    async eraseTemplate(position, template) {
+        await this.update({
+            type: "erase-voxel-template",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+            template,
+        });
+    }
+    async eraseSelection(selection) {
+        await this.update({
+            type: "erase-voxel-selection",
+            selection,
+        });
+    }
+    async paintPath(position, path) {
+        await this.update({
+            type: "paint-voxel-path",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+            path,
+        });
+    }
+    async erasePath(position, path) {
+        await this.update({
+            type: "erase-voxel-path",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+            path,
+        });
+    }
+}

package/Builder/World/InitTasks.d.ts

@@ -0,0 +1 @@
+export declare function InitTasks(): void;