@divinevoxel/vlox 0.0.74 → 0.0.76

package/Builder/RayProvider.d.ts

@@ -0,0 +1,6 @@
+import { Vector3Like } from "@amodx/math";
+export interface RayProvider {
+    origin: Vector3Like;
+    direction: Vector3Like;
+    length: number;
+}

package/Builder/Tools/Box/BoxSelection.d.ts

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

package/Builder/Tools/Box/BoxSelection.js

@@ -0,0 +1,27 @@
+import { Vector3Like } from "@amodx/math";
+export class BoxSelection {
+    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;
+        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;
+        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/Tools/Box/BoxTool.d.ts

@@ -0,0 +1,31 @@
+import { VoxelPickResult } from "../../../Voxels/Interaction/VoxelPickResult";
+import { VoxelBuildSpace } from "../../VoxelBuildSpace";
+import { PaintVoxelData } from "../../../Voxels";
+import { VoxelBoxSelection } from "../../../Templates/Selection/VoxelBoxSelection";
+import { BoxSelection } from "./BoxSelection";
+import { BoxToolTemplate } from "./BoxToolTemplate";
+import { BuilderToolBase } from "../BuilderToolBase";
+export declare enum BoxToolModes {
+    Fill = "Fill",
+    Extrude = "Extrude",
+    Template = "Template",
+    Remove = "Remove"
+}
+interface BoxToolEvents {
+    "template-created": BoxToolTemplate;
+}
+export declare class BoxTool extends BuilderToolBase<BoxToolEvents> {
+    space: VoxelBuildSpace;
+    static ToolId: string;
+    static ModeArray: BoxToolModes[];
+    mode: BoxToolModes;
+    selection: VoxelBoxSelection;
+    boxSelection: BoxSelection;
+    constructor(space: VoxelBuildSpace);
+    private _started;
+    isSelectionStarted(): boolean;
+    updateOffset(offset: number): void;
+    updatePlacer(picked: VoxelPickResult | null, placerMode?: "start" | "end" | null): void;
+    use(voxelData: PaintVoxelData, usePlacingStrategy?: boolean): Promise<void>;
+}
+export {};

package/Builder/Tools/Box/BoxTool.js

@@ -0,0 +1,91 @@
+import { VoxelBoxSelection } from "../../../Templates/Selection/VoxelBoxSelection";
+import { Vector3Like } from "@amodx/math";
+import { BoxSelection } from "./BoxSelection";
+import { BoxToolTemplate } from "./BoxToolTemplate";
+import { BuilderToolBase } from "../BuilderToolBase";
+export var BoxToolModes;
+(function (BoxToolModes) {
+    BoxToolModes["Fill"] = "Fill";
+    BoxToolModes["Extrude"] = "Extrude";
+    BoxToolModes["Template"] = "Template";
+    BoxToolModes["Remove"] = "Remove";
+})(BoxToolModes || (BoxToolModes = {}));
+export class BoxTool extends BuilderToolBase {
+    space;
+    static ToolId = "Box";
+    static ModeArray = [
+        BoxToolModes.Fill,
+        BoxToolModes.Extrude,
+        BoxToolModes.Template,
+        BoxToolModes.Remove,
+    ];
+    mode = BoxToolModes.Fill;
+    selection = new VoxelBoxSelection();
+    boxSelection;
+    constructor(space) {
+        super();
+        this.space = space;
+        console.warn("CREATE BOX TOOL", this.space, this.selection);
+        this.boxSelection = new BoxSelection(this.space, this.selection);
+    }
+    _started = false;
+    isSelectionStarted() {
+        return this._started;
+    }
+    updateOffset(offset) {
+        this.boxSelection.offset = offset;
+        this.boxSelection.update();
+    }
+    updatePlacer(picked, placerMode = null) {
+        if (!this._started && !placerMode && picked) {
+            if (this.mode == BoxToolModes.Fill ||
+                this.mode == BoxToolModes.Template ||
+                this.mode == BoxToolModes.Extrude) {
+                this.selection.reConstruct(picked.normalPosition, picked.normal, Vector3Like.Add(picked.normalPosition, Vector3Like.Create(1, 1, 1)), picked.normal);
+            }
+            if (this.mode == BoxToolModes.Remove) {
+                this.selection.reConstruct(picked.position, picked.normal, Vector3Like.Add(picked.position, Vector3Like.Create(1, 1, 1)), picked.normal);
+            }
+        }
+        if (!this._started && placerMode == "start" && picked) {
+            this.boxSelection.offset = 0;
+            Vector3Like.Copy(this.boxSelection.planeNormal, picked.normal);
+            if (this.mode == BoxToolModes.Fill ||
+                this.mode == BoxToolModes.Template ||
+                this.mode == BoxToolModes.Extrude) {
+                Vector3Like.Copy(this.boxSelection.planeOrigin, picked.normalPosition);
+            }
+            if (this.mode == BoxToolModes.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(voxelData, usePlacingStrategy = true) {
+        if (this.mode == BoxToolModes.Fill) {
+            await this.space.paintTemplate(Vector3Like.ToArray(this.selection.origin), this.selection
+                .toTemplate({
+                fillVoxel: voxelData,
+            })
+                .toJSON());
+        }
+        if (this.mode == BoxToolModes.Template) {
+            const boxTemplate = new BoxToolTemplate(this.space, this.selection.clone());
+            await boxTemplate.create();
+            this.dispatch("template-created", boxTemplate);
+        }
+        if (this.mode == BoxToolModes.Remove) {
+            await this.space.eraseTemplate(Vector3Like.ToArray(this.selection.origin), this.selection.toTemplate({}).toJSON());
+        }
+    }
+}

package/Builder/Tools/Box/BoxToolTemplate.d.ts

@@ -0,0 +1,13 @@
+import { FullVoxelTemplate } from "../../../Templates/Full/FullVoxelTemplate";
+import { VoxelBoxSelection } from "../../../Templates/Selection/VoxelBoxSelection";
+import { VoxelBuildSpace } from "../../VoxelBuildSpace";
+export declare class BoxToolTemplate {
+    space: VoxelBuildSpace;
+    selection: VoxelBoxSelection;
+    template: FullVoxelTemplate;
+    private _created;
+    constructor(space: VoxelBuildSpace, selection: VoxelBoxSelection);
+    create(): Promise<void>;
+    place(): Promise<void>;
+    clear(): Promise<void>;
+}

package/Builder/Tools/Box/BoxToolTemplate.js

@@ -0,0 +1,23 @@
+export class BoxToolTemplate {
+    space;
+    selection;
+    template;
+    _created = false;
+    constructor(space, selection) {
+        this.space = space;
+        this.selection = selection;
+    }
+    async create() {
+        if (this._created)
+            return;
+        const bounds = this.selection.bounds.getMinMax();
+        this.template = await this.space.createTemplate(bounds);
+        this._created = true;
+    }
+    async place() {
+        await this.space.paintTemplate(this.selection.origin, this.template.toJSON());
+    }
+    async clear() {
+        await this.space.eraseTemplate(this.selection.origin, this.template.toJSON());
+    }
+}

package/Builder/Tools/Brush/BrushTool.d.ts

@@ -0,0 +1,48 @@
+import { VoxelBuildSpace } from "../../VoxelBuildSpace";
+import { BasicVoxelShapeTemplate } from "../../../Templates/Shapes/BasicVoxelShapeTemplate";
+import { VoxelTemplateSelection } from "../../../Templates/Selection/VoxelTemplateSelection";
+import { VoxelPickResult } from "../../../Voxels/Interaction/VoxelPickResult";
+import { Vector3Like } from "@amodx/math";
+import { PaintVoxelData } from "../../../Voxels";
+import { BuilderToolBase } from "../BuilderToolBase";
+export declare enum BrushPositionModes {
+    Start = "Start",
+    Center = "Center",
+    End = "End"
+}
+export declare enum BrushToolModes {
+    Fill = "Fill",
+    Extrude = "Extrude",
+    Remove = "Remove"
+}
+type BrushVoxelData = {
+    fill: PaintVoxelData;
+    face: PaintVoxelData;
+    edge: PaintVoxelData;
+    point: PaintVoxelData;
+};
+interface BrushToolEvents {
+    "shape-updated": null;
+}
+export declare class BrushTool extends BuilderToolBase<BrushToolEvents> {
+    space: VoxelBuildSpace;
+    static ToolId: string;
+    static ModeArray: BrushToolModes[];
+    static PositionModeArray: BrushPositionModes[];
+    static get ShapesArray(): string[];
+    static ShapeCreators: Record<string, () => BasicVoxelShapeTemplate<any, any, any>>;
+    shape: string;
+    axisXPositionMode: BrushPositionModes;
+    axisYPositionMode: BrushPositionModes;
+    axisZPositionMode: BrushPositionModes;
+    mode: BrushToolModes;
+    template: BasicVoxelShapeTemplate<any, any, any>;
+    selection: VoxelTemplateSelection;
+    protected _position: Vector3Like;
+    constructor(space: VoxelBuildSpace);
+    use(picked: VoxelPickResult, voxelData?: Partial<BrushVoxelData>, usePlacingStrategy?: boolean): Promise<true | undefined>;
+    protected getPlacePosition(picked: VoxelPickResult): Vector3Like;
+    updatePlacer(picked: VoxelPickResult): false | undefined;
+    updateShape(shape: string): void;
+}
+export {};

package/Builder/Tools/Brush/BrushTool.js

@@ -0,0 +1,146 @@
+import { VoxelTemplateSelection } from "../../../Templates/Selection/VoxelTemplateSelection";
+import { SphereVoxelTemplate } from "../../../Templates/Shapes/SphereVoxelTemplate";
+import { BoxVoxelTemplate } from "../../../Templates/Shapes/BoxVoxelTemplate";
+import { PyramidVoxelTemplate } from "../../../Templates/Shapes/PyramidVoxelTemplate";
+import { Vector3Like } from "@amodx/math";
+import { BuilderToolBase } from "../BuilderToolBase";
+import { EllipsoidVoxelTemplate } from "../../../Templates/Shapes/EllipsoidVoxelTemplate";
+export var BrushPositionModes;
+(function (BrushPositionModes) {
+    BrushPositionModes["Start"] = "Start";
+    BrushPositionModes["Center"] = "Center";
+    BrushPositionModes["End"] = "End";
+})(BrushPositionModes || (BrushPositionModes = {}));
+export var BrushToolModes;
+(function (BrushToolModes) {
+    BrushToolModes["Fill"] = "Fill";
+    BrushToolModes["Extrude"] = "Extrude";
+    BrushToolModes["Remove"] = "Remove";
+})(BrushToolModes || (BrushToolModes = {}));
+export class BrushTool extends BuilderToolBase {
+    space;
+    static ToolId = "Brush";
+    static ModeArray = [
+        BrushToolModes.Fill,
+        BrushToolModes.Extrude,
+        BrushToolModes.Remove,
+    ];
+    static PositionModeArray = [
+        BrushPositionModes.Start,
+        BrushPositionModes.Center,
+        BrushPositionModes.End,
+    ];
+    static get ShapesArray() {
+        return Object.keys(this.ShapeCreators);
+    }
+    static ShapeCreators = {
+        Sphere: () => {
+            return new SphereVoxelTemplate(SphereVoxelTemplate.CreateNew({}));
+        },
+        Box: () => {
+            return new BoxVoxelTemplate(BoxVoxelTemplate.CreateNew({}));
+        },
+        Pyramid: () => {
+            return new PyramidVoxelTemplate(PyramidVoxelTemplate.CreateNew({}));
+        },
+        Ellipsoid: () => {
+            return new EllipsoidVoxelTemplate(EllipsoidVoxelTemplate.CreateNew({}));
+        },
+    };
+    shape = "Sphere";
+    axisXPositionMode = BrushPositionModes.Center;
+    axisYPositionMode = BrushPositionModes.Center;
+    axisZPositionMode = BrushPositionModes.Center;
+    mode = BrushToolModes.Fill;
+    template;
+    selection;
+    _position = Vector3Like.Create();
+    constructor(space) {
+        super();
+        this.space = space;
+        this.selection = new VoxelTemplateSelection();
+        this.updateShape(this.shape);
+    }
+    async use(picked, voxelData = {}, usePlacingStrategy = true) {
+        if (usePlacingStrategy) {
+            if (voxelData.fill) {
+                const newData = this.space.getPlaceState(voxelData.fill, picked);
+                if (newData)
+                    voxelData.fill = newData;
+            }
+        }
+        if (this.mode == BrushToolModes.Fill && voxelData.fill) {
+            if (!this.space.bounds.intersectsPoint(picked.normalPosition))
+                return;
+            this.template.setVoxels(voxelData.fill);
+            const place = this.getPlacePosition(picked);
+            await this.space.paintTemplate([place.x, place.y, place.z], this.template.toJSON());
+        }
+        if (this.mode == BrushToolModes.Remove) {
+            if (!this.space.bounds.intersectsPoint(picked.position))
+                return;
+            const voxel = picked.voxel;
+            if (voxel && !voxel.isAir()) {
+                const place = this.getPlacePosition(picked);
+                await this.space.eraseTemplate([place.x, place.y, place.z], this.template.toJSON());
+            }
+            return true;
+        }
+    }
+    getPlacePosition(picked) {
+        //x
+        if (this.axisXPositionMode == BrushPositionModes.Center) {
+            this._position.x =
+                picked.normalPosition.x - Math.floor(this.template.bounds.size.x / 2);
+        }
+        if (this.axisXPositionMode == BrushPositionModes.Start) {
+            this._position.x = picked.normalPosition.x;
+        }
+        if (this.axisXPositionMode == BrushPositionModes.End) {
+            this._position.x = picked.normalPosition.x - this.template.bounds.size.x;
+        }
+        //y
+        if (this.axisYPositionMode == BrushPositionModes.Center) {
+            this._position.y =
+                picked.normalPosition.y - Math.floor(this.template.bounds.size.y / 2);
+        }
+        if (this.axisYPositionMode == BrushPositionModes.Start) {
+            this._position.y = picked.normalPosition.y;
+        }
+        if (this.axisYPositionMode == BrushPositionModes.End) {
+            this._position.y = picked.normalPosition.y - this.template.bounds.size.y;
+        }
+        //z
+        if (this.axisZPositionMode == BrushPositionModes.Center) {
+            this._position.z =
+                picked.normalPosition.z - Math.floor(this.template.bounds.size.z / 2);
+        }
+        if (this.axisZPositionMode == BrushPositionModes.Start) {
+            this._position.z = picked.normalPosition.z;
+        }
+        if (this.axisXPositionMode == BrushPositionModes.End) {
+            this._position.z = picked.normalPosition.z - this.template.bounds.size.z;
+        }
+        return this._position;
+    }
+    updatePlacer(picked) {
+        const place = this.getPlacePosition(picked);
+        if (!this.space.bounds.intersectsPoint(place))
+            return false;
+        this.selection.origin.x = place.x;
+        this.selection.origin.y = place.y;
+        this.selection.origin.z = place.z;
+    }
+    updateShape(shape) {
+        const shapeCreator = BrushTool.ShapeCreators[shape];
+        if (!shapeCreator)
+            throw new Error(`Shape with id ${shape} does not exist`);
+        this.shape = shape;
+        this.template = shapeCreator();
+        this.selection.setTemplate(this.template);
+        this.template.addEventListener("updated", () => {
+            this.selection.setTemplate(this.template);
+            this.dispatch("shape-updated", null);
+        });
+    }
+}

package/Builder/Tools/BuilderToolBase.d.ts

@@ -0,0 +1,3 @@
+import { TypedEventTarget } from "../../Util/TypedEventTarget";
+export declare abstract class BuilderToolBase<Events extends Record<string, any>> extends TypedEventTarget<Events> {
+}

package/Builder/Tools/BuilderToolBase.js

@@ -0,0 +1,3 @@
+import { TypedEventTarget } from "../../Util/TypedEventTarget";
+export class BuilderToolBase extends TypedEventTarget {
+}

package/Builder/Tools/Hand/HandTool.d.ts

@@ -0,0 +1,22 @@
+import { VoxelPickResult } from "../../../Voxels/Interaction/VoxelPickResult";
+import { VoxelBuildSpace } from "../../VoxelBuildSpace";
+import { PaintVoxelData } from "../../../Voxels";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+export declare enum HandToolModes {
+    Place = "Place",
+    Remove = "Remove"
+}
+interface HandToolEvents {
+}
+export declare class HandTool extends BuilderToolBase<HandToolEvents> {
+    space: VoxelBuildSpace;
+    static ToolId: string;
+    static ModeArray: HandToolModes[];
+    mode: HandToolModes;
+    selection: VoxelPointSelection;
+    constructor(space: VoxelBuildSpace);
+    updatePlacer(picked: VoxelPickResult): void;
+    use(picked: VoxelPickResult, voxelData: PaintVoxelData, usePlacingStrategy?: boolean): Promise<boolean | undefined>;
+}
+export {};

package/Builder/Tools/Hand/HandTool.js

@@ -0,0 +1,56 @@
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+export var HandToolModes;
+(function (HandToolModes) {
+    HandToolModes["Place"] = "Place";
+    HandToolModes["Remove"] = "Remove";
+})(HandToolModes || (HandToolModes = {}));
+export class HandTool extends BuilderToolBase {
+    space;
+    static ToolId = "Hand";
+    static ModeArray = [
+        HandToolModes.Place,
+        HandToolModes.Remove,
+    ];
+    mode = HandToolModes.Place;
+    selection = new VoxelPointSelection();
+    constructor(space) {
+        super();
+        this.space = space;
+    }
+    updatePlacer(picked) {
+        if (this.mode == HandToolModes.Place) {
+            this.selection.reConstruct(picked.normalPosition);
+        }
+        if (this.mode == HandToolModes.Remove) {
+            this.selection.reConstruct(picked.position);
+        }
+    }
+    async use(picked, voxelData, usePlacingStrategy = true) {
+        if (this.mode == HandToolModes.Place) {
+            if (!this.space.bounds.intersectsPoint(picked.normalPosition))
+                return false;
+            if (usePlacingStrategy) {
+                const newData = this.space.getPlaceState(voxelData, picked);
+                if (newData)
+                    voxelData = newData;
+            }
+            await this.space.paintVoxel([
+                picked.normalPosition.x,
+                picked.normalPosition.y,
+                picked.normalPosition.z,
+            ], voxelData);
+            return true;
+        }
+        if (this.mode == HandToolModes.Remove) {
+            if (!this.space.bounds.intersectsPoint(picked.position))
+                return false;
+            await this.space.eraseVoxel([
+                picked.position.x,
+                picked.position.y,
+                picked.position.z,
+            ]);
+            return true;
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+import { VoxelBuildSpace } from "../../VoxelBuildSpace";
+import { PaintVoxelData } from "../../../Voxels";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+import { VoxelPath } from "../../../Templates/Path/VoxelPath";
+export declare enum PathToolModes {
+    PlacePoints = "Place Points",
+    MovePoints = "Move Points",
+    RemovePoints = "Remove Points",
+    FillPath = "Fill Path",
+    RemovePath = "Remvoe Path"
+}
+interface PathToolEvents {
+}
+export declare class PathTool extends BuilderToolBase<PathToolEvents> {
+    space: VoxelBuildSpace;
+    static ToolId: string;
+    static ModeArray: PathToolModes[];
+    mode: PathToolModes;
+    selection: VoxelPointSelection;
+    path: VoxelPath;
+    distance: number;
+    private _placedSegment;
+    constructor(space: VoxelBuildSpace);
+    setMode(mode: PathToolModes): void;
+    updatePlacer(): void;
+    use(voxelData: PaintVoxelData, usePlacingStrategy?: boolean): Promise<void>;
+}
+export {};

package/Builder/Tools/Path/PahtTool.js

@@ -0,0 +1,117 @@
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+import { VoxelPath, VoxelPathSegment } from "../../../Templates/Path/VoxelPath";
+import { Vector3Like } from "@amodx/math";
+export var PathToolModes;
+(function (PathToolModes) {
+    PathToolModes["PlacePoints"] = "Place Points";
+    PathToolModes["MovePoints"] = "Move Points";
+    PathToolModes["RemovePoints"] = "Remove Points";
+    PathToolModes["FillPath"] = "Fill Path";
+    PathToolModes["RemovePath"] = "Remvoe Path";
+})(PathToolModes || (PathToolModes = {}));
+export class PathTool extends BuilderToolBase {
+    space;
+    static ToolId = "Path";
+    static ModeArray = [
+        PathToolModes.PlacePoints,
+        PathToolModes.MovePoints,
+        PathToolModes.RemovePoints,
+        PathToolModes.FillPath,
+        PathToolModes.RemovePath,
+    ];
+    mode = PathToolModes.PlacePoints;
+    selection = new VoxelPointSelection();
+    path = new VoxelPath(VoxelPath.CreateNew({}));
+    distance = 10;
+    _placedSegment = false;
+    constructor(space) {
+        super();
+        this.space = space;
+    }
+    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 (mode == PathToolModes.PlacePoints && this.path.segments.length) {
+            const point = this.path.lastSegment().getPoint(1);
+            this.path.addSegment(VoxelPathSegment.CreateNew({
+                transient: true,
+                start: [...point],
+                end: [
+                    this.selection.origin.x,
+                    this.selection.origin.y,
+                    this.selection.origin.z,
+                ],
+            }));
+        }
+    }
+    updatePlacer() {
+        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 last = this.path.lastSegment();
+            if (last) {
+                last.setPoints(last.start, [
+                    this.selection.origin.x,
+                    this.selection.origin.y,
+                    this.selection.origin.z,
+                ]);
+            }
+            return;
+        }
+    }
+    async use(voxelData, usePlacingStrategy = true) {
+        if (this.mode == PathToolModes.PlacePoints) {
+            this._placedSegment = true;
+            if (!this.path.totalSegments) {
+                this.path.addSegment(VoxelPathSegment.CreateNew({
+                    transient: true,
+                    start: [
+                        this.selection.origin.x,
+                        this.selection.origin.y,
+                        this.selection.origin.z,
+                    ],
+                    end: [
+                        this.selection.origin.x,
+                        this.selection.origin.y,
+                        this.selection.origin.z,
+                    ],
+                }));
+            }
+            else {
+                const lastSegment = this.path.lastSegment();
+                lastSegment.transient = false;
+                this.path.addSegment(VoxelPathSegment.CreateNew({
+                    transient: true,
+                    start: [...lastSegment.end],
+                    end: [
+                        this.selection.origin.x,
+                        this.selection.origin.y,
+                        this.selection.origin.z,
+                    ],
+                }));
+            }
+        }
+        if (this.mode == PathToolModes.FillPath) {
+            for (const segment of this.path.segments) {
+                segment.voxel = voxelData;
+            }
+            await this.space.paintPath([0, 0, 0], this.path.toJSON());
+            return;
+        }
+        if (this.mode == PathToolModes.RemovePath) {
+            await this.space.erasePath([0, 0, 0], this.path.toJSON());
+            return;
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+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";
+export declare enum WandToolModes {
+    Place = "Place",
+    Extrude = "Extrude",
+    Remove = "Remove"
+}
+interface WandToolEvents {
+}
+export declare class WandTool extends BuilderToolBase<WandToolEvents> {
+    space: VoxelBuildSpace;
+    static ToolId: string;
+    static ModeArray: WandToolModes[];
+    mode: WandToolModes;
+    maxCount: number;
+    extrusion: number;
+    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>;
+}
+export {};