@divinevoxel/vlox 0.0.75 → 0.0.76

package/Builder/Tools/Wand/WandTool.js

@@ -0,0 +1,67 @@
+import { VoxelSurfaceSelection } from "../../../Templates/Selection/VoxelSurfaceSelection";
+import { VoxelBFSSelection } from "../../../Templates/Selection/VoxelBFSSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+export var WandToolModes;
+(function (WandToolModes) {
+    WandToolModes["Place"] = "Place";
+    WandToolModes["Extrude"] = "Extrude";
+    WandToolModes["Remove"] = "Remove";
+})(WandToolModes || (WandToolModes = {}));
+export class WandTool extends BuilderToolBase {
+    space;
+    static ToolId = "Wand";
+    static ModeArray = [
+        WandToolModes.Place,
+        WandToolModes.Extrude,
+        WandToolModes.Remove,
+    ];
+    mode = WandToolModes.Place;
+    maxCount = 1000;
+    extrusion = 0;
+    get selection() {
+        if (this.mode == WandToolModes.Place ||
+            this.mode == WandToolModes.Extrude) {
+            return this.surfaceSelection;
+        }
+        return this.bfsSelection;
+    }
+    surfaceSelection = new VoxelSurfaceSelection();
+    bfsSelection = new VoxelBFSSelection();
+    constructor(space) {
+        super();
+        this.space = space;
+    }
+    async updatePlacer(picked) {
+        if (this.mode == WandToolModes.Place ||
+            this.mode == WandToolModes.Extrude) {
+            this.surfaceSelection.fromJSON(await this.space.getSurfaceSelection(picked.position, picked.normal, this.extrusion, this.maxCount));
+        }
+        if (this.mode == WandToolModes.Remove) {
+            this.bfsSelection.fromJSON(await this.space.getBFSSelection(picked.position, this.maxCount));
+        }
+    }
+    async use(picked, voxelData, usePlacingStrategy = true) {
+        if (this.mode == WandToolModes.Place) {
+            if (!this.space.bounds.intersectsPoint(picked.normalPosition))
+                return false;
+            if (usePlacingStrategy) {
+                const newData = this.space.getPlaceState(voxelData, picked);
+                if (newData)
+                    voxelData = newData;
+            }
+            const template = await this.space.getSurfaceSelectionTemplate(picked.position, picked.normal, this.extrusion, this.maxCount, voxelData);
+            await this.space.paintTemplate(template.position, template.toJSON());
+            return true;
+        }
+        if (this.mode == WandToolModes.Extrude) {
+            const template = await this.space.getSurfaceSelectionTemplate(picked.position, picked.normal, this.extrusion, this.maxCount, true);
+            await this.space.paintTemplate(template.position, template.toJSON());
+            return true;
+        }
+        if (this.mode == WandToolModes.Remove) {
+            const template = await this.space.getBFSSelectionTemplate(picked.position, this.maxCount);
+            await this.space.eraseTemplate(template.position, template.toJSON());
+            return true;
+        }
+    }
+}

package/Builder/Tools/Wrench/WrenchTool.d.ts

@@ -0,0 +1,47 @@
+import { VoxelPickResult } from "../../../Voxels/Interaction/VoxelPickResult";
+import { VoxelBuildSpace } from "../../VoxelBuildSpace";
+import { PaintVoxelData } from "../../../Voxels";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+interface WrenchToolEvents {
+    picked: {};
+}
+export type WrenchToolVoxelScehmaNodes = {
+    type: "string";
+    values: string[];
+    id: string;
+    label: string;
+    value: string;
+} | {
+    type: "number";
+    min: number;
+    max: number;
+    id: string;
+    label: string;
+    value: number;
+};
+type WrenchToolSchemas = {
+    stateSchema: WrenchToolVoxelScehmaNodes[];
+    modSchema: WrenchToolVoxelScehmaNodes[];
+};
+export declare class WrenchTool extends BuilderToolBase<WrenchToolEvents> {
+    space: VoxelBuildSpace;
+    static ToolId: string;
+    private mode;
+    selection: VoxelPointSelection;
+    paintData: PaintVoxelData;
+    private _pickedResult;
+    constructor(space: VoxelBuildSpace);
+    isUpdating(): boolean;
+    stopUpdating(): void;
+    updatePlacer(picked: VoxelPickResult): void;
+    private processSchema;
+    updatePickedSchema(schema: WrenchToolSchemas): PaintVoxelData | undefined;
+    getPickedSchema(): WrenchToolSchemas | null;
+    /**Get an array of all possible state varations for the current mod of the selected voxel. */
+    getStateValues(): PaintVoxelData[] | null;
+    /**Get an array of all possible mod varations for the current state of the selected voxel. */
+    getModValues(): PaintVoxelData[] | null;
+    use(): Promise<true | undefined>;
+}
+export {};

package/Builder/Tools/Wrench/WrenchTool.js

@@ -0,0 +1,175 @@
+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 {
+    space;
+    static ToolId = "Wrench";
+    mode = WrenchToolModes.Pick;
+    selection = new VoxelPointSelection();
+    paintData = PaintVoxelData.Create();
+    _pickedResult = null;
+    constructor(space) {
+        super();
+        this.space = space;
+    }
+    isUpdating() {
+        if (this._pickedResult !== null && this.mode == WrenchToolModes.Update)
+            return true;
+        return false;
+    }
+    stopUpdating() {
+        this.mode = WrenchToolModes.Pick;
+        this._pickedResult = null;
+    }
+    updatePlacer(picked) {
+        console.log("update placer", this.mode);
+        if (this.mode == WrenchToolModes.Pick) {
+            this._pickedResult = picked;
+            this.selection.reConstruct(picked.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());
+        console.warn("get picked schemas", { id }, SchemaRegister.stateSchemaData);
+        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;
+    }
+    async use() {
+        if (this.mode == WrenchToolModes.Pick) {
+            if (this._pickedResult && !this._pickedResult.voxel.isAir()) {
+                this._pickedResult = this._pickedResult.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 true;
+        }
+    }
+}

package/Builder/VoxelBuildSpace.d.ts

@@ -0,0 +1,61 @@
+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 { VoxelSurfaceSelectionData } from "Templates/Selection/VoxelSurfaceSelection";
+import { VoxelBFSSelectionData } from "Templates/Selection/VoxelBFSSelection";
+export type VoxelSpaceUpdateData = {
+    type: "clear";
+} | {
+    type: "paint-voxel";
+    position: Vec3Array;
+    voxel: PaintVoxelData;
+} | {
+    type: "erase-voxel";
+    position: Vec3Array;
+} | {
+    type: "paint-voxel-template";
+    position: Vec3Array;
+    template: IVoxelTemplateData<any>;
+} | {
+    type: "erase-voxel-template";
+    position: Vec3Array;
+    template: IVoxelTemplateData<any>;
+} | {
+    type: "paint-voxel-path";
+    position: Vec3Array;
+    path: VoxelPathData;
+} | {
+    type: "erase-voxel-path";
+    position: Vec3Array;
+    path: VoxelPathData;
+};
+export declare class VoxelBuildSpace {
+    DVER: DivineVoxelEngineRender;
+    rayProvider: RayProvider;
+    beforeUpdate: (data: VoxelSpaceUpdateData) => void;
+    afterUpdate: (data: VoxelSpaceUpdateData) => void;
+    bounds: BoundingBox;
+    constructor(DVER: DivineVoxelEngineRender, rayProvider: RayProvider, min?: Vector3Like, max?: Vector3Like);
+    pick(rayOrigin: Vector3Like, rayDirection: Vector3Like, length: number): Promise<VoxelPickResult | null>;
+    createTemplate(bounds: BoundsMinMaxData): Promise<FullVoxelTemplate>;
+    getSurfaceSelection(position: Vector3Like, normal: Vector3Like, extrusion: number, maxSize?: number): Promise<VoxelSurfaceSelectionData>;
+    getSurfaceSelectionTemplate(position: Vector3Like, normal: Vector3Like, extrusion: number, maxSize: number, voxelDataOrExtrude: true | PaintVoxelData): Promise<FullVoxelTemplate>;
+    getBFSSelection(position: Vector3Like, maxSize?: number): Promise<VoxelBFSSelectionData>;
+    getBFSSelectionTemplate(position: Vector3Like, maxSize?: number): Promise<FullVoxelTemplate>;
+    getPlaceState(data: PaintVoxelData, picked: VoxelPickResult, alt?: number | null): PaintVoxelData | undefined;
+    private _update;
+    private _doUpdate;
+    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>;
+    paintPath(position: Vec3Array | Vector3Like, path: VoxelPathData): Promise<void>;
+    erasePath(position: Vec3Array | Vector3Like, path: VoxelPathData): Promise<void>;
+}

package/Builder/VoxelBuildSpace.js

@@ -0,0 +1,165 @@
+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";
+export class VoxelBuildSpace {
+    DVER;
+    rayProvider;
+    beforeUpdate;
+    afterUpdate;
+    bounds;
+    constructor(DVER, rayProvider, min = Vector3Like.Create(-Infinity, -Infinity, -Infinity), max = Vector3Like.Create(Infinity, Infinity, Infinity)) {
+        this.DVER = DVER;
+        this.rayProvider = rayProvider;
+        this.bounds = new BoundingBox(min, max);
+    }
+    async pick(rayOrigin, rayDirection, 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 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 getSurfaceSelectionTemplate(position, normal, extrusion, maxSize, voxelDataOrExtrude) {
+        return new FullVoxelTemplate(await this.DVER.threads.world.runTaskAsync("get-voxel-surface-selection-template", [position, normal, extrusion, maxSize, voxelDataOrExtrude]));
+    }
+    async getBFSSelection(position, maxSize) {
+        return await this.DVER.threads.world.runTaskAsync("get-voxel-bfs-selection", [position, maxSize]);
+    }
+    async getBFSSelectionTemplate(position, maxSize) {
+        return new FullVoxelTemplate(await this.DVER.threads.world.runTaskAsync("get-voxel-bfs-selection-template", [position, maxSize]));
+    }
+    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 _update(update) {
+        if (update.type == "paint-voxel") {
+            await this.DVER.threads.world.runTaskAsync("paint-voxel", [
+                [0, ...update.position],
+                PaintVoxelData.ToRaw(update.voxel),
+            ]);
+            return;
+        }
+        if (update.type == "erase-voxel") {
+            await this.DVER.threads.world.runTaskAsync("erase-voxel", [
+                0,
+                ...update.position,
+            ]);
+            return;
+        }
+        if (update.type == "paint-voxel-template") {
+            await this.DVER.threads.world.runTaskAsync("paint-voxel-template", [
+                [0, ...update.position],
+                update.template,
+            ]);
+            return;
+        }
+        if (update.type == "erase-voxel-template") {
+            await this.DVER.threads.world.runTaskAsync("erase-voxel-template", [
+                [0, ...update.position],
+                update.template,
+            ]);
+            return;
+        }
+        if (update.type == "paint-voxel-path") {
+            await this.DVER.threads.world.runTaskAsync("paint-voxel-path", [
+                [0, ...update.position],
+                update.path,
+            ]);
+            return;
+        }
+        if (update.type == "erase-voxel-path") {
+            await this.DVER.threads.world.runTaskAsync("erase-voxel-path", [
+                [0, ...update.position],
+                update.path,
+            ]);
+            return;
+        }
+    }
+    async _doUpdate(data) {
+        if (this.beforeUpdate)
+            this.beforeUpdate(data);
+        await this._update(data);
+        if (this.afterUpdate)
+            this.afterUpdate(data);
+    }
+    async paintVoxel(position, voxel) {
+        await this._doUpdate({
+            type: "paint-voxel",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+            voxel,
+        });
+    }
+    async eraseVoxel(position) {
+        await this._doUpdate({
+            type: "erase-voxel",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+        });
+    }
+    async paintTemplate(position, template) {
+        await this._doUpdate({
+            type: "paint-voxel-template",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+            template,
+        });
+    }
+    async eraseTemplate(position, template) {
+        await this._doUpdate({
+            type: "erase-voxel-template",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+            template,
+        });
+    }
+    async paintPath(position, path) {
+        await this._doUpdate({
+            type: "paint-voxel-path",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+            path,
+        });
+    }
+    async erasePath(position, path) {
+        await this._doUpdate({
+            type: "erase-voxel-path",
+            position: Array.isArray(position)
+                ? position
+                : Vector3Like.ToArray(position),
+            path,
+        });
+    }
+}

package/Builder/VoxelBuilder.types.js

@@ -0,0 +1 @@
+"use strict";

package/Builder/World/InitTasks.d.ts

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

package/Builder/World/InitTasks.js

@@ -0,0 +1,134 @@
+import { WorldSimulation } from "../../WorldSimulation";
+import { Threads } from "@amodx/threads";
+import { Vector3Like } from "@amodx/math";
+import { VoxelTemplateRegister } from "../../Templates/VoxelTempateRegister";
+import { VoxelPath } from "../../Templates/Path/VoxelPath";
+import PickVoxelWorld from "../../Voxels/Interaction/Functions/PickVoxelWorld";
+import { WorldCursor } from "../../World";
+import LockSectors from "../../World/Lock/Function/LockSectors";
+import UnLockSectors from "../../World/Lock/Function/UnLockSectors";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { VoxelSurfaceSelection } from "../../Templates/Selection/VoxelSurfaceSelection";
+import { VoxelBFSSelection } from "../../Templates/Selection/VoxelBFSSelection";
+import CreateFullTemplate from "../../Templates/Full/Functions/CreateFullTemplate";
+export function InitTasks() {
+    const dimension = WorldSimulation.getDimension(0);
+    const brush = dimension.getBrush();
+    const cursor = new WorldCursor();
+    const surfaceSelection = new VoxelSurfaceSelection();
+    const bfsSelection = new VoxelBFSSelection();
+    const updateData = {
+        includedAreas: [],
+    };
+    const buildAreaBounds = new BoundingBox();
+    Threads.registerTask("get-box-area-template", async ([min, max]) => {
+        await LockSectors(cursor.dimension, buildAreaBounds);
+        const archived = CreateFullTemplate(cursor, { min, max });
+        await UnLockSectors(cursor.dimension, buildAreaBounds);
+        return [archived];
+    });
+    Threads.registerTask("set-build-area", async ([min, max]) => {
+        buildAreaBounds.setMinMax(Vector3Like.Create(...min), Vector3Like.Create(...max));
+        updateData.includedAreas = [[min, max]];
+    });
+    Threads.registerTask("pick-voxel", async ([position, direction, length]) => {
+        const pickedVoxel = await PickVoxelWorld(cursor, position, direction, length);
+        //pick voxels error when not using shared memory if the secotrs are check out
+        return [pickedVoxel?.toJSON() || null];
+    });
+    /**
+     * Selections
+     */
+    Threads.registerTask("get-voxel-surface-selection", async ([position, normal, extrusion, maxSize]) => {
+        await LockSectors(cursor.dimension, buildAreaBounds);
+        surfaceSelection.reConstruct(cursor, position, normal, extrusion, maxSize);
+        await UnLockSectors(cursor.dimension, buildAreaBounds);
+        return [surfaceSelection.toJSON()];
+    });
+    Threads.registerTask("get-voxel-surface-selection-template", async ([position, normal, extrusion, maxSize, voxelDataOrExtrude]) => {
+        await LockSectors(cursor.dimension, buildAreaBounds);
+        surfaceSelection.reConstruct(cursor, position, normal, extrusion, maxSize);
+        await UnLockSectors(cursor.dimension, buildAreaBounds);
+        const template = surfaceSelection
+            .toTemplate(cursor, voxelDataOrExtrude)
+            .toJSON();
+        template.position.x = surfaceSelection.origin.x;
+        template.position.y = surfaceSelection.origin.y;
+        template.position.z = surfaceSelection.origin.z;
+        return [template];
+    });
+    Threads.registerTask("get-voxel-bfs-selection", async ([position, maxSize]) => {
+        await LockSectors(cursor.dimension, buildAreaBounds);
+        bfsSelection.reConstruct(cursor, position, maxSize);
+        await UnLockSectors(cursor.dimension, buildAreaBounds);
+        return [bfsSelection.toJSON()];
+    });
+    Threads.registerTask("get-voxel-bfs-selection-template", async ([position, maxSize]) => {
+        await LockSectors(cursor.dimension, buildAreaBounds);
+        bfsSelection.reConstruct(cursor, position, maxSize);
+        await UnLockSectors(cursor.dimension, buildAreaBounds);
+        const template = bfsSelection.toTemplate(cursor).toJSON();
+        template.position.x = bfsSelection.origin.x;
+        template.position.y = bfsSelection.origin.y;
+        template.position.z = bfsSelection.origin.z;
+        return [template];
+    });
+    /**
+     * Painting
+     */
+    Threads.registerTask("paint-voxel", async ([location, raw]) => {
+        await LockSectors(location[0], buildAreaBounds);
+        brush.setXYZ(location[1], location[2], location[3]);
+        brush.setRaw(raw);
+        brush.paint(updateData);
+        await UnLockSectors(location[0], buildAreaBounds);
+    });
+    Threads.registerTask("erase-voxel", async (location) => {
+        await LockSectors(location[0], buildAreaBounds);
+        brush.dimension = location[0];
+        brush.setXYZ(location[1], location[2], location[3]);
+        brush.erase(updateData);
+        await UnLockSectors(location[0], buildAreaBounds);
+    });
+    Threads.registerTask("create-voxel-template", async ([location, bounds]) => {
+        const boundingBox = new BoundingBox(bounds.min, bounds.max);
+        await LockSectors(location[0], boundingBox);
+        const template = CreateFullTemplate(cursor, bounds);
+        await UnLockSectors(location[0], boundingBox);
+        return [template];
+    });
+    Threads.registerTask("paint-voxel-template", async ([location, data]) => {
+        const template = VoxelTemplateRegister.create(data);
+        brush.dimension = location[0];
+        await LockSectors(location[0], template.bounds);
+        brush
+            .setXYZ(location[1], location[2], location[3])
+            .paintTemplate(template, updateData);
+        await UnLockSectors(location[0], template.bounds);
+    });
+    Threads.registerTask("erase-voxel-template", async ([location, data]) => {
+        brush.dimension = location[0];
+        const template = VoxelTemplateRegister.create(data);
+        await LockSectors(location[0], template.bounds);
+        brush
+            .setXYZ(location[1], location[2], location[3])
+            .eraseTemplate(template, updateData);
+        await UnLockSectors(location[0], template.bounds);
+    });
+    Threads.registerTask("paint-voxel-path", async ([location, data]) => {
+        await LockSectors(location[0], buildAreaBounds);
+        brush.dimension = location[0];
+        brush
+            .setXYZ(location[1], location[2], location[3])
+            .paintPath(new VoxelPath(data), updateData);
+        await UnLockSectors(location[0], buildAreaBounds);
+    });
+    Threads.registerTask("erase-voxel-path", async ([location, data]) => {
+        await LockSectors(location[0], buildAreaBounds);
+        brush.dimension = location[0];
+        brush
+            .setXYZ(location[1], location[2], location[3])
+            .erasePath(new VoxelPath(data), updateData);
+        await UnLockSectors(location[0], buildAreaBounds);
+    });
+}

package/Builder/World/VoxelBuildSpaceWorld.d.ts

@@ -0,0 +1,4 @@
+export declare class VoxelBuildSpaceWorld {
+    private static BuildTaskInit;
+    constructor();
+}

package/Builder/World/VoxelBuildSpaceWorld.js

@@ -0,0 +1,10 @@
+import { InitTasks } from "./InitTasks";
+export class VoxelBuildSpaceWorld {
+    static BuildTaskInit = false;
+    constructor() {
+        if (!VoxelBuildSpaceWorld.BuildTaskInit) {
+            InitTasks();
+            VoxelBuildSpaceWorld.BuildTaskInit = true;
+        }
+    }
+}