@divinevoxel/vlox 0.0.76 → 0.0.77

package/Builder/Tools/Path/PahtTool.d.ts

@@ -1,8 +1,8 @@
-import { VoxelBuildSpace } from "../../VoxelBuildSpace";
 import { PaintVoxelData } from "../../../Voxels";
 import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
-import { BuilderToolBase } from "../BuilderToolBase";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
 import { VoxelPath } from "../../../Templates/Path/VoxelPath";
+import { FreePointSelection } from "../../Util/FreePointSelection";
 export declare enum PathToolModes {
     PlacePoints = "Place Points",
     MovePoints = "Move Points",
@@ -13,17 +13,22 @@ export declare enum PathToolModes {
 interface PathToolEvents {
 }
 export declare class PathTool extends BuilderToolBase<PathToolEvents> {
-    space: VoxelBuildSpace;
     static ToolId: string;
     static ModeArray: PathToolModes[];
     mode: PathToolModes;
     selection: VoxelPointSelection;
+    pointSelection: FreePointSelection;
     path: VoxelPath;
-    distance: number;
+    get distance(): number;
+    set distance(value: number);
+    voxelData: PaintVoxelData;
     private _placedSegment;
-    constructor(space: VoxelBuildSpace);
     setMode(mode: PathToolModes): void;
-    updatePlacer(): void;
-    use(voxelData: PaintVoxelData, usePlacingStrategy?: boolean): Promise<void>;
+    cancel(): void;
+    update(): Promise<void>;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
 }
 export {};

package/Builder/Tools/Path/PahtTool.js

@@ -1,7 +1,7 @@
 import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
 import { BuilderToolBase } from "../BuilderToolBase";
 import { VoxelPath, VoxelPathSegment } from "../../../Templates/Path/VoxelPath";
-import { Vector3Like } from "@amodx/math";
+import { FreePointSelection } from "../../Util/FreePointSelection";
 export var PathToolModes;
 (function (PathToolModes) {
     PathToolModes["PlacePoints"] = "Place Points";
@@ -11,7 +11,6 @@ export var PathToolModes;
     PathToolModes["RemovePath"] = "Remvoe Path";
 })(PathToolModes || (PathToolModes = {}));
 export class PathTool extends BuilderToolBase {
-    space;
     static ToolId = "Path";
     static ModeArray = [
         PathToolModes.PlacePoints,
@@ -22,23 +21,29 @@ export class PathTool extends BuilderToolBase {
     ];
     mode = PathToolModes.PlacePoints;
     selection = new VoxelPointSelection();
+    pointSelection = new FreePointSelection(this.space, this.selection);
     path = new VoxelPath(VoxelPath.CreateNew({}));
-    distance = 10;
-    _placedSegment = false;
-    constructor(space) {
-        super();
-        this.space = space;
+    get distance() {
+        return this.pointSelection.distance;
+    }
+    set distance(value) {
+        this.pointSelection.distance = value;
     }
+    voxelData;
+    _placedSegment = false;
     setMode(mode) {
         const lastMode = this.mode;
         this.mode = mode;
-        if (lastMode == PathToolModes.PlacePoints && this._placedSegment) {
-            this._placedSegment = false;
-            if (this.path.lastSegment())
-                this.path.removeSegment(this.path.lastSegment());
+        if (lastMode == PathToolModes.PlacePoints) {
+            for (const segment of this.path.segments) {
+                if (segment.transient) {
+                    this.path.removeSegment(segment);
+                }
+            }
         }
         if (mode == PathToolModes.PlacePoints && this.path.segments.length) {
             const point = this.path.lastSegment().getPoint(1);
+            this._placedSegment = false;
             this.path.addSegment(VoxelPathSegment.CreateNew({
                 transient: true,
                 start: [...point],
@@ -50,15 +55,14 @@ export class PathTool extends BuilderToolBase {
             }));
         }
     }
-    updatePlacer() {
+    cancel() {
+        this._lastPicked = null;
+    }
+    async update() {
         if (this.mode == PathToolModes.PlacePoints) {
-            const rayPosition = Vector3Like.FloorInPlace(Vector3Like.Add(this.space.rayProvider.origin, Vector3Like.MultiplyScalar(this.space.rayProvider.direction, this.distance)));
-            if (!this.space.bounds.intersectsPoint(rayPosition)) {
-                //get point ray intersects with the space bounding box and use that instead
-            }
-            else {
-                this.selection.reConstruct(rayPosition);
-            }
+            const updated = this.pointSelection.update();
+            if (!updated)
+                return;
             const last = this.path.lastSegment();
             if (last) {
                 last.setPoints(last.start, [
@@ -70,7 +74,7 @@ export class PathTool extends BuilderToolBase {
             return;
         }
     }
-    async use(voxelData, usePlacingStrategy = true) {
+    async use() {
         if (this.mode == PathToolModes.PlacePoints) {
             this._placedSegment = true;
             if (!this.path.totalSegments) {
@@ -104,7 +108,7 @@ export class PathTool extends BuilderToolBase {
         }
         if (this.mode == PathToolModes.FillPath) {
             for (const segment of this.path.segments) {
-                segment.voxel = voxelData;
+                segment.voxel = this.voxelData;
             }
             await this.space.paintPath([0, 0, 0], this.path.toJSON());
             return;
@@ -114,4 +118,11 @@ export class PathTool extends BuilderToolBase {
             return;
         }
     }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
 }

package/Builder/Tools/Sculpt/SculptTool.d.ts

@@ -0,0 +1,34 @@
+import { VoxelBuildSpace } from "../../VoxelBuildSpace";
+import { PaintVoxelData } from "../../../Voxels";
+import { VoxelBoundsSelection } from "../../../Templates/Selection/VoxelBoundsSelection";
+import { Vector3Like } from "@amodx/math";
+import { SurfaceBoxSelection } from "../../Util/SurfaceBoxSelection";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
+export declare enum SculptToolModes {
+    Fill = "Fill",
+    Extrude = "Extrude",
+    Remove = "Remove"
+}
+interface SculptToolEvents {
+}
+export declare class SculptTool extends BuilderToolBase<SculptToolEvents> {
+    static ToolId: string;
+    static ModeArray: SculptToolModes[];
+    mode: SculptToolModes;
+    selection: VoxelBoundsSelection;
+    boxSelection: SurfaceBoxSelection;
+    voxelData: PaintVoxelData;
+    usePlacingStrategy: boolean;
+    constructor(space: VoxelBuildSpace);
+    cancel(): void;
+    private _started;
+    isSelectionStarted(): boolean;
+    updateOffset(offset: number): void;
+    _normal: Vector3Like;
+    update(placerMode?: "start" | "end" | null): Promise<void>;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
+}
+export {};

package/Builder/Tools/Sculpt/SculptTool.js

@@ -0,0 +1,102 @@
+import { VoxelBoundsSelection } from "../../../Templates/Selection/VoxelBoundsSelection";
+import { Vector3Like } from "@amodx/math";
+import { SurfaceBoxSelection } from "../../Util/SurfaceBoxSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+export var SculptToolModes;
+(function (SculptToolModes) {
+    SculptToolModes["Fill"] = "Fill";
+    SculptToolModes["Extrude"] = "Extrude";
+    SculptToolModes["Remove"] = "Remove";
+})(SculptToolModes || (SculptToolModes = {}));
+export class SculptTool extends BuilderToolBase {
+    static ToolId = "Sculpt";
+    static ModeArray = [
+        SculptToolModes.Fill,
+        SculptToolModes.Extrude,
+        SculptToolModes.Remove,
+    ];
+    mode = SculptToolModes.Fill;
+    selection = new VoxelBoundsSelection();
+    boxSelection;
+    voxelData;
+    usePlacingStrategy = true;
+    constructor(space) {
+        super(space);
+        this.boxSelection = new SurfaceBoxSelection(this.space, this.selection);
+    }
+    cancel() {
+        this._started = false;
+    }
+    _started = false;
+    isSelectionStarted() {
+        return this._started;
+    }
+    updateOffset(offset) {
+        this.boxSelection.offset = offset;
+        this.boxSelection.update();
+    }
+    _normal;
+    async update(placerMode = null) {
+        const picked = this.isSelectionStarted()
+            ? null
+            : await this.space.pickWithProvider(this.rayProviderIndex);
+        this._lastPicked = picked;
+        if (!this._started && !placerMode && picked) {
+            if (this.mode == SculptToolModes.Fill ||
+                this.mode == SculptToolModes.Extrude) {
+                this.selection.reConstruct(picked.normalPosition, picked.normal, Vector3Like.Add(picked.normalPosition, Vector3Like.Create(1, 1, 1)), picked.normal);
+            }
+            if (this.mode == SculptToolModes.Remove) {
+                this.selection.reConstruct(picked.position, picked.normal, Vector3Like.Add(picked.position, Vector3Like.Create(1, 1, 1)), picked.normal);
+            }
+            this._normal = { ...picked.normal };
+        }
+        if (!this._started && placerMode == "start" && picked) {
+            this.boxSelection.offset = 0;
+            Vector3Like.Copy(this.boxSelection.planeNormal, picked.normal);
+            if (this.mode == SculptToolModes.Fill ||
+                this.mode == SculptToolModes.Extrude) {
+                Vector3Like.Copy(this.boxSelection.planeOrigin, picked.normalPosition);
+            }
+            if (this.mode == SculptToolModes.Remove) {
+                Vector3Like.Copy(this.boxSelection.planeOrigin, picked.position);
+            }
+            this.boxSelection.update();
+            this._started = true;
+            return;
+        }
+        if (this._started && !placerMode && !picked) {
+            this.boxSelection.update();
+            return;
+        }
+        if (this._started && placerMode == "end") {
+            this.boxSelection.update();
+            this._started = false;
+        }
+    }
+    async use() {
+        if (this.mode == SculptToolModes.Fill) {
+            await this.space.paintTemplate(Vector3Like.ToArray(this.selection.origin), this.selection
+                .toTemplate({
+                fillVoxel: this.voxelData,
+            })
+                .toJSON());
+            return;
+        }
+        if (this.mode == SculptToolModes.Extrude) {
+            const template = await this.space.getExtrudedSelectionTemplate(this.selection.toJSON(), this._normal);
+            await this.space.paintTemplate(this.selection.origin, template.toJSON());
+            return;
+        }
+        if (this.mode == SculptToolModes.Remove) {
+            await this.space.eraseTemplate(Vector3Like.ToArray(this.selection.origin), this.selection.toTemplate({}).toJSON());
+        }
+    }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
+}

package/Builder/Tools/Shape/ShapeTool.d.ts

@@ -0,0 +1,32 @@
+import { PaintVoxelData } from "../../../Voxels";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { FreePointSelection } from "../../Util/FreePointSelection";
+import { FreeBoxSelection } from "../../Util/FreeBoxSelection";
+export declare enum ShapeToolModes {
+    Fill = "Fill",
+    Remove = "Remove"
+}
+interface BoxToolEvents {
+}
+export declare class ShapeTool extends BuilderToolBase<BoxToolEvents> {
+    static ToolId: string;
+    static ModeArray: ShapeToolModes[];
+    mode: ShapeToolModes;
+    selection: VoxelPointSelection;
+    pointSelection: FreePointSelection;
+    boxSelection: FreeBoxSelection | null;
+    voxelData: PaintVoxelData;
+    usePlacingStrategy: boolean;
+    get distance(): number;
+    set distance(distance: number);
+    private _started;
+    isSelectionStarted(): boolean;
+    cancel(): void;
+    update(placerMode?: "start" | "end" | null): Promise<void>;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
+}
+export {};

package/Builder/Tools/Shape/ShapeTool.js

@@ -0,0 +1,78 @@
+import { Vector3Like } from "@amodx/math";
+import { BuilderToolBase } from "../BuilderToolBase";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { FreePointSelection } from "../../Util/FreePointSelection";
+import { FreeBoxSelection } from "../../Util/FreeBoxSelection";
+export var ShapeToolModes;
+(function (ShapeToolModes) {
+    ShapeToolModes["Fill"] = "Fill";
+    ShapeToolModes["Remove"] = "Remove";
+})(ShapeToolModes || (ShapeToolModes = {}));
+export class ShapeTool extends BuilderToolBase {
+    static ToolId = "Shape";
+    static ModeArray = [
+        ShapeToolModes.Fill,
+        ShapeToolModes.Remove,
+    ];
+    mode = ShapeToolModes.Fill;
+    selection = new VoxelPointSelection();
+    pointSelection = new FreePointSelection(this.space, this.selection);
+    boxSelection = null;
+    voxelData;
+    usePlacingStrategy = true;
+    get distance() {
+        return this.pointSelection.distance;
+    }
+    set distance(distance) {
+        if (this.boxSelection)
+            this.pointSelection.distance = distance;
+    }
+    _started = false;
+    isSelectionStarted() {
+        return this._started;
+    }
+    cancel() {
+        this._started = false;
+        this.boxSelection = null;
+    }
+    async update(placerMode = null) {
+        if (this.boxSelection) {
+            this.boxSelection.update();
+        }
+        else {
+            this.pointSelection.update();
+        }
+        if (placerMode == "start") {
+            this._started = true;
+            this.boxSelection = new FreeBoxSelection(this.space, this.pointSelection);
+        }
+        if (placerMode == "end") {
+            this._started = false;
+        }
+    }
+    async use() {
+        if (!this.boxSelection)
+            return;
+        if (this.mode == ShapeToolModes.Fill) {
+            await this.space.paintTemplate(Vector3Like.ToArray(this.boxSelection.selection.origin), this.boxSelection.selection
+                .toTemplate({
+                fillVoxel: this.voxelData,
+            })
+                .toJSON());
+            this.boxSelection = null;
+            return;
+        }
+        if (this.mode == ShapeToolModes.Remove) {
+            await this.space.eraseTemplate(Vector3Like.ToArray(this.boxSelection.selection.origin), this.boxSelection.selection.toTemplate({}).toJSON());
+            this.boxSelection = null;
+            return;
+        }
+    }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
+}

package/Builder/Tools/Template/TemplateTool.d.ts

@@ -0,0 +1,35 @@
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
+import { VoxelBoundsSelection } from "../../../Templates/Selection/VoxelBoundsSelection";
+import { FreeBoxSelection } from "../../Util/FreeBoxSelection";
+import { FullVoxelTemplate } from "../../../Templates/Full/FullVoxelTemplate";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { FreePointSelection } from "../../Util/FreePointSelection";
+export declare enum TemplateToolModes {
+    Select = "Select",
+    Place = "Place",
+    Remove = "Remove"
+}
+interface TemplateToolEvents {
+    "selection-created": VoxelBoundsSelection;
+}
+export declare class TemplateTool extends BuilderToolBase<TemplateToolEvents> {
+    static ToolId: string;
+    static ModeArray: TemplateToolModes[];
+    mode: TemplateToolModes;
+    selection: VoxelPointSelection;
+    pointSelection: FreePointSelection;
+    boxSelection: FreeBoxSelection | null;
+    usePlacingStrategy: boolean;
+    get distance(): number;
+    set distance(distance: number);
+    private _started;
+    selectionToTemplate(selection: VoxelBoundsSelection): Promise<FullVoxelTemplate>;
+    isSelectionStarted(): boolean;
+    update(placerMode?: "start" | "end" | null): Promise<void>;
+    cancel(): void;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
+}
+export {};

package/Builder/Tools/Template/TemplateTool.js

@@ -0,0 +1,73 @@
+import { BuilderToolBase } from "../BuilderToolBase";
+import { FreeBoxSelection } from "../../Util/FreeBoxSelection";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { FreePointSelection } from "../../Util/FreePointSelection";
+export var TemplateToolModes;
+(function (TemplateToolModes) {
+    TemplateToolModes["Select"] = "Select";
+    TemplateToolModes["Place"] = "Place";
+    TemplateToolModes["Remove"] = "Remove";
+})(TemplateToolModes || (TemplateToolModes = {}));
+export class TemplateTool extends BuilderToolBase {
+    static ToolId = "Template";
+    static ModeArray = [
+        TemplateToolModes.Select,
+        TemplateToolModes.Place,
+        TemplateToolModes.Remove,
+    ];
+    mode = TemplateToolModes.Select;
+    selection = new VoxelPointSelection();
+    pointSelection = new FreePointSelection(this.space, this.selection);
+    boxSelection = null;
+    usePlacingStrategy = true;
+    get distance() {
+        return this.pointSelection.distance;
+    }
+    set distance(distance) {
+        if (this.boxSelection)
+            this.pointSelection.distance = distance;
+    }
+    _started = false;
+    async selectionToTemplate(selection) {
+        const bounds = selection.bounds.getMinMax();
+        return await this.space.createTemplate(bounds);
+    }
+    isSelectionStarted() {
+        return this._started;
+    }
+    async update(placerMode = null) {
+        if (this.boxSelection) {
+            this.boxSelection.update();
+        }
+        else {
+            this.pointSelection.update();
+        }
+        if (placerMode == "start") {
+            this._started = true;
+            this.boxSelection = new FreeBoxSelection(this.space, this.pointSelection);
+        }
+        if (placerMode == "end") {
+            this._started = false;
+            this.boxSelection = null;
+        }
+    }
+    cancel() {
+        this._started = false;
+        this._lastPicked = null;
+        this.boxSelection = null;
+    }
+    async use() {
+        if (!this.boxSelection)
+            return;
+        if (this.mode == TemplateToolModes.Select) {
+            this.dispatch("selection-created", this.boxSelection.selection);
+        }
+    }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
+}

package/Builder/Tools/Wand/WandTool.d.ts

@@ -1,9 +1,7 @@
-import { VoxelPickResult } from "../../../Voxels/Interaction/VoxelPickResult";
-import { VoxelBuildSpace } from "../../VoxelBuildSpace";
 import { PaintVoxelData } from "../../../Voxels/Types/PaintVoxelData";
 import { VoxelSurfaceSelection } from "../../../Templates/Selection/VoxelSurfaceSelection";
 import { VoxelBFSSelection } from "../../../Templates/Selection/VoxelBFSSelection";
-import { BuilderToolBase } from "../BuilderToolBase";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
 export declare enum WandToolModes {
     Place = "Place",
     Extrude = "Extrude",
@@ -12,7 +10,6 @@ export declare enum WandToolModes {
 interface WandToolEvents {
 }
 export declare class WandTool extends BuilderToolBase<WandToolEvents> {
-    space: VoxelBuildSpace;
     static ToolId: string;
     static ModeArray: WandToolModes[];
     mode: WandToolModes;
@@ -21,8 +18,13 @@ export declare class WandTool extends BuilderToolBase<WandToolEvents> {
     get selection(): VoxelSurfaceSelection | VoxelBFSSelection;
     surfaceSelection: VoxelSurfaceSelection;
     bfsSelection: VoxelBFSSelection;
-    constructor(space: VoxelBuildSpace);
-    updatePlacer(picked: VoxelPickResult): Promise<void>;
-    use(picked: VoxelPickResult, voxelData: PaintVoxelData, usePlacingStrategy?: boolean): Promise<boolean | undefined>;
+    voxelData: PaintVoxelData;
+    usePlacingStrategy: boolean;
+    update(): Promise<void>;
+    cancel(): void;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
 }
 export {};

package/Builder/Tools/Wand/WandTool.js

@@ -8,7 +8,6 @@ export var WandToolModes;
     WandToolModes["Remove"] = "Remove";
 })(WandToolModes || (WandToolModes = {}));
 export class WandTool extends BuilderToolBase {
-    space;
     static ToolId = "Wand";
     static ModeArray = [
         WandToolModes.Place,
@@ -27,41 +26,65 @@ export class WandTool extends BuilderToolBase {
     }
     surfaceSelection = new VoxelSurfaceSelection();
     bfsSelection = new VoxelBFSSelection();
-    constructor(space) {
-        super();
-        this.space = space;
-    }
-    async updatePlacer(picked) {
+    voxelData;
+    usePlacingStrategy = true;
+    async update() {
+        this._lastPicked = await this.space.pickWithProvider(this.rayProviderIndex);
+        if (!this._lastPicked)
+            return;
         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.space.bounds.intersectsPoint(this._lastPicked.normalPosition)) {
+                this._lastPicked = null;
+                return;
+            }
+            this.surfaceSelection.fromJSON(await this.space.getSurfaceSelection(this._lastPicked.position, this._lastPicked.normal, this.extrusion, this.maxCount));
         }
         if (this.mode == WandToolModes.Remove) {
-            this.bfsSelection.fromJSON(await this.space.getBFSSelection(picked.position, this.maxCount));
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.position)) {
+                this._lastPicked = null;
+                return;
+            }
+            this.bfsSelection.fromJSON(await this.space.getBFSSelection(this._lastPicked.position, this.maxCount));
         }
     }
-    async use(picked, voxelData, usePlacingStrategy = true) {
+    cancel() {
+        this._lastPicked = null;
+    }
+    async use() {
+        const picked = this._lastPicked;
+        if (!picked)
+            return;
+        let voxelData = this.voxelData;
         if (this.mode == WandToolModes.Place) {
             if (!this.space.bounds.intersectsPoint(picked.normalPosition))
-                return false;
-            if (usePlacingStrategy) {
+                return;
+            if (this.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;
+            this.surfaceSelection.fromJSON(await this.space.getSurfaceSelection(picked.position, picked.normal, this.extrusion, this.maxCount));
+            await this.space.paintTemplate(this.surfaceSelection.origin, this.surfaceSelection.toTemplate(voxelData).toJSON());
+            return;
         }
         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;
+            this.surfaceSelection.fromJSON(await this.space.getSurfaceSelection(picked.position, picked.normal, this.extrusion, this.maxCount));
+            const template = await this.space.getExtrudedSelectionTemplate(this.surfaceSelection.toJSON(), picked.normal);
+            await this.space.paintTemplate(this.surfaceSelection.origin, template.toJSON());
+            return;
         }
         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;
+            const selection = await this.space.getBFSSelection(picked.position, this.maxCount);
+            await this.space.eraseSelection(selection);
+            return;
         }
     }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
 }

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

@@ -1,8 +1,6 @@
-import { VoxelPickResult } from "../../../Voxels/Interaction/VoxelPickResult";
-import { VoxelBuildSpace } from "../../VoxelBuildSpace";
 import { PaintVoxelData } from "../../../Voxels";
 import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
-import { BuilderToolBase } from "../BuilderToolBase";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
 interface WrenchToolEvents {
     picked: {};
 }
@@ -25,16 +23,14 @@ type WrenchToolSchemas = {
     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;
+    update(): Promise<void>;
     private processSchema;
     updatePickedSchema(schema: WrenchToolSchemas): PaintVoxelData | undefined;
     getPickedSchema(): WrenchToolSchemas | null;
@@ -42,6 +38,10 @@ export declare class WrenchTool extends BuilderToolBase<WrenchToolEvents> {
     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>;
+    cancel(): void;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
 }
 export {};