@divinevoxel/vlox 0.0.76 → 0.0.78

package/Builder/Tools/Wrench/WrenchTool.js

@@ -9,16 +9,11 @@ var WrenchToolModes;
     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;
@@ -28,11 +23,16 @@ export class WrenchTool extends BuilderToolBase {
         this.mode = WrenchToolModes.Pick;
         this._pickedResult = null;
     }
-    updatePlacer(picked) {
-        console.log("update placer", this.mode);
+    async update() {
+        this._lastPicked = await this.space.pickWithProvider(this.rayProviderIndex);
+        if (!this._lastPicked)
+            return;
         if (this.mode == WrenchToolModes.Pick) {
-            this._pickedResult = picked;
-            this.selection.reConstruct(picked.position);
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.position)) {
+                this._lastPicked = null;
+                return;
+            }
+            this.selection.reConstruct(this._lastPicked.position);
         }
     }
     processSchema(schema) {
@@ -100,7 +100,6 @@ export class WrenchTool extends BuilderToolBase {
         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),
@@ -151,10 +150,13 @@ export class WrenchTool extends BuilderToolBase {
         }
         return voxelStates;
     }
+    cancel() {
+        this._lastPicked = null;
+    }
     async use() {
         if (this.mode == WrenchToolModes.Pick) {
-            if (this._pickedResult && !this._pickedResult.voxel.isAir()) {
-                this._pickedResult = this._pickedResult.clone();
+            if (this._lastPicked && !this._lastPicked.voxel.isAir()) {
+                this._pickedResult = this._lastPicked.clone();
                 this.dispatch("picked", {});
                 this.mode = WrenchToolModes.Update;
                 return;
@@ -169,7 +171,14 @@ export class WrenchTool extends BuilderToolBase {
                 this.selection.origin.y,
                 this.selection.origin.z,
             ], this.paintData);
-            return true;
+            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/{Tools/Box/BoxSelection.js → Util/SurfaceBoxSelection.js}

@@ -1,5 +1,5 @@
 import { Vector3Like } from "@amodx/math";
-export class BoxSelection {
+export class SurfaceBoxSelection {
     space;
     selection;
     planeOrigin = Vector3Like.Create();
@@ -12,8 +12,6 @@ export class BoxSelection {
     update() {
         const rayOrigin = this.space.rayProvider.origin;
         const rayDirection = this.space.rayProvider.direction;
-        console.warn("SPACE", this.space);
-        console.warn("UPDATE BOX TOOL", [rayOrigin.x, rayOrigin.y, rayOrigin.z], [rayDirection.x, rayDirection.y, rayDirection.z]);
         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;

package/Builder/VoxelBuildSpace.d.ts

@@ -8,54 +8,66 @@ 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";
+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;
-} | {
-    type: "erase-voxel";
+}> | VoxelSpaceBaseUpdateData<"erase-voxel", {
     position: Vec3Array;
-} | {
-    type: "paint-voxel-template";
+}> | VoxelSpaceBaseUpdateData<"paint-voxel-template", {
     position: Vec3Array;
     template: IVoxelTemplateData<any>;
-} | {
-    type: "erase-voxel-template";
+}> | VoxelSpaceBaseUpdateData<"erase-voxel-template", {
     position: Vec3Array;
     template: IVoxelTemplateData<any>;
-} | {
-    type: "paint-voxel-path";
+}> | VoxelSpaceBaseUpdateData<"erase-voxel-selection", {
+    selection: IVoxelSelectionData<any>;
+}> | VoxelSpaceBaseUpdateData<"paint-voxel-path", {
     position: Vec3Array;
     path: VoxelPathData;
-} | {
-    type: "erase-voxel-path";
+}> | VoxelSpaceBaseUpdateData<"erase-voxel-path", {
     position: Vec3Array;
     path: VoxelPathData;
-};
+}>;
 export declare class VoxelBuildSpace {
     DVER: DivineVoxelEngineRender;
-    rayProvider: RayProvider;
-    beforeUpdate: (data: VoxelSpaceUpdateData) => void;
-    afterUpdate: (data: VoxelSpaceUpdateData) => void;
+    /**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);
-    pick(rayOrigin: Vector3Like, rayDirection: Vector3Like, length: number): Promise<VoxelPickResult | null>;
+    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>;
-    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>;
+    getExtrudedSelectionTemplate(selection: IVoxelSelectionData<any>, nomral: Vector3Like): Promise<FullVoxelTemplate>;
     getPlaceState(data: PaintVoxelData, picked: VoxelPickResult, alt?: number | null): PaintVoxelData | undefined;
-    private _update;
-    private _doUpdate;
+    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

@@ -5,18 +5,38 @@ import { VoxelPlacingStrategyRegister } from "../Voxels/Interaction/Placing/Voxe
 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;
-    rayProvider;
-    beforeUpdate;
-    afterUpdate;
+    /**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.rayProvider = rayProvider;
         this.bounds = new BoundingBox(min, max);
+        this.addRayProvider(0, rayProvider);
+    }
+    addRayProvider(index, provider) {
+        this._rayProviders[index] = provider;
+    }
+    getRayProvider(index) {
+        return this._rayProviders[index];
     }
-    async pick(rayOrigin, rayDirection, length) {
+    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],
@@ -27,6 +47,13 @@ export class VoxelBuildSpace {
         }
         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)],
@@ -37,14 +64,12 @@ export class VoxelBuildSpace {
     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]));
+    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);
@@ -58,59 +83,87 @@ export class VoxelBuildSpace {
         const schema = SchemaRegister.getVoxelSchemas(data.id);
         data.state = schema.state.readString(state);
     }
-    async _update(update) {
-        if (update.type == "paint-voxel") {
+    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),
             ]);
-            return;
-        }
-        if (update.type == "erase-voxel") {
+        },
+        "erase-voxel": async (update) => {
             await this.DVER.threads.world.runTaskAsync("erase-voxel", [
                 0,
                 ...update.position,
             ]);
-            return;
-        }
-        if (update.type == "paint-voxel-template") {
+        },
+        "paint-voxel-template": async (update) => {
             await this.DVER.threads.world.runTaskAsync("paint-voxel-template", [
                 [0, ...update.position],
                 update.template,
             ]);
-            return;
-        }
-        if (update.type == "erase-voxel-template") {
+        },
+        "erase-voxel-template": async (update) => {
             await this.DVER.threads.world.runTaskAsync("erase-voxel-template", [
                 [0, ...update.position],
                 update.template,
             ]);
-            return;
-        }
-        if (update.type == "paint-voxel-path") {
+        },
+        "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,
             ]);
-            return;
-        }
-        if (update.type == "erase-voxel-path") {
+        },
+        "erase-voxel-path": async (update) => {
             await this.DVER.threads.world.runTaskAsync("erase-voxel-path", [
                 [0, ...update.position],
                 update.path,
             ]);
-            return;
-        }
-    }
-    async _doUpdate(data) {
+        },
+    };
+    async update(data) {
         if (this.beforeUpdate)
-            this.beforeUpdate(data);
-        await this._update(data);
+            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)
-            this.afterUpdate(data);
+            await this.afterUpdate(data);
     }
     async paintVoxel(position, voxel) {
-        await this._doUpdate({
+        await this.update({
             type: "paint-voxel",
             position: Array.isArray(position)
                 ? position
@@ -119,7 +172,7 @@ export class VoxelBuildSpace {
         });
     }
     async eraseVoxel(position) {
-        await this._doUpdate({
+        await this.update({
             type: "erase-voxel",
             position: Array.isArray(position)
                 ? position
@@ -127,7 +180,7 @@ export class VoxelBuildSpace {
         });
     }
     async paintTemplate(position, template) {
-        await this._doUpdate({
+        await this.update({
             type: "paint-voxel-template",
             position: Array.isArray(position)
                 ? position
@@ -136,7 +189,7 @@ export class VoxelBuildSpace {
         });
     }
     async eraseTemplate(position, template) {
-        await this._doUpdate({
+        await this.update({
             type: "erase-voxel-template",
             position: Array.isArray(position)
                 ? position
@@ -144,8 +197,14 @@ export class VoxelBuildSpace {
             template,
         });
     }
+    async eraseSelection(selection) {
+        await this.update({
+            type: "erase-voxel-selection",
+            selection,
+        });
+    }
     async paintPath(position, path) {
-        await this._doUpdate({
+        await this.update({
             type: "paint-voxel-path",
             position: Array.isArray(position)
                 ? position
@@ -154,7 +213,7 @@ export class VoxelBuildSpace {
         });
     }
     async erasePath(position, path) {
-        await this._doUpdate({
+        await this.update({
             type: "erase-voxel-path",
             position: Array.isArray(position)
                 ? position

package/Builder/World/InitTasks.js

@@ -1,7 +1,7 @@
 import { WorldSimulation } from "../../WorldSimulation";
 import { Threads } from "@amodx/threads";
 import { Vector3Like } from "@amodx/math";
-import { VoxelTemplateRegister } from "../../Templates/VoxelTempateRegister";
+import { VoxelTemplateRegister } from "../../Templates/VoxelTemplateRegister";
 import { VoxelPath } from "../../Templates/Path/VoxelPath";
 import PickVoxelWorld from "../../Voxels/Interaction/Functions/PickVoxelWorld";
 import { WorldCursor } from "../../World";
@@ -11,6 +11,7 @@ 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";
+import { ExtrudeSelection } from "../../Templates/Functions/ExtrudeSelection";
 export function InitTasks() {
     const dimension = WorldSimulation.getDimension(0);
     const brush = dimension.getBrush();
@@ -45,17 +46,12 @@ export function InitTasks() {
         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-extruded-voxel-selection-template", async ([selectionData, normal]) => {
+        const selection = VoxelTemplateRegister.createSelection(selectionData);
+        await LockSectors(cursor.dimension, selection.bounds);
+        const fullVoxelTemplate = ExtrudeSelection(cursor, selection, normal);
+        await UnLockSectors(cursor.dimension, selection.bounds);
+        return [fullVoxelTemplate.toJSON()];
     });
     Threads.registerTask("get-voxel-bfs-selection", async ([position, maxSize]) => {
         await LockSectors(cursor.dimension, buildAreaBounds);
@@ -63,16 +59,6 @@ export function InitTasks() {
         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
      */
@@ -115,6 +101,15 @@ export function InitTasks() {
             .eraseTemplate(template, updateData);
         await UnLockSectors(location[0], template.bounds);
     });
+    Threads.registerTask("erase-voxel-selection", async ([location, selectionData]) => {
+        brush.dimension = location[0];
+        const selection = VoxelTemplateRegister.createSelection(selectionData);
+        await LockSectors(location[0], selection.bounds);
+        brush
+            .setXYZ(location[1], location[2], location[3])
+            .eraseSelection(selection, updateData);
+        await UnLockSectors(location[0], selection.bounds);
+    });
     Threads.registerTask("paint-voxel-path", async ([location, data]) => {
         await LockSectors(location[0], buildAreaBounds);
         brush.dimension = location[0];

package/Mesher/Geomtry/Proto/ProtoMesh.d.ts

@@ -0,0 +1,18 @@
+import { Vector3Like } from "@amodx/math";
+import { ProtoVertexBuffer, ProtoIndiceBuffer } from "./ProtoMeshBuffer";
+export declare class ProtoMesh {
+    vertexFloatSize: number;
+    indicieCount: number;
+    vertexCount: number;
+    minBounds: Vector3Like;
+    maxBounds: Vector3Like;
+    readonly buffer: ProtoVertexBuffer;
+    readonly indices: ProtoIndiceBuffer;
+    constructor(vertexFloatSize: number);
+    create(): {
+        vertexArray: Float32Array<ArrayBuffer>;
+        indiciesArray: Uint32Array<ArrayBuffer> | Uint16Array<ArrayBuffer>;
+    };
+    addVerticies(vertexCount: number, indicesCount: number): void;
+    clear(): void;
+}