@divinevoxel/vlox 0.0.76 → 0.0.77

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

@@ -1,10 +1,9 @@
 import { VoxelBuildSpace } from "../../VoxelBuildSpace";
-import { BasicVoxelShapeTemplate } from "../../../Templates/Shapes/BasicVoxelShapeTemplate";
-import { VoxelTemplateSelection } from "../../../Templates/Selection/VoxelTemplateSelection";
+import { VoxelShapeTemplate } from "../../../Templates/Shapes/VoxelShapeTemplate";
 import { VoxelPickResult } from "../../../Voxels/Interaction/VoxelPickResult";
 import { Vector3Like } from "@amodx/math";
 import { PaintVoxelData } from "../../../Voxels";
-import { BuilderToolBase } from "../BuilderToolBase";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
 export declare enum BrushPositionModes {
     Start = "Start",
     Center = "Center",
@@ -25,24 +24,32 @@ 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>>;
+    static ShapeCreators: Record<string, () => VoxelShapeTemplate>;
+    static BaseToolOptions: ToolOptionsData;
+    static ShapeOptions: Record<string, () => ToolOptionsData>;
     shape: string;
     axisXPositionMode: BrushPositionModes;
     axisYPositionMode: BrushPositionModes;
     axisZPositionMode: BrushPositionModes;
     mode: BrushToolModes;
-    template: BasicVoxelShapeTemplate<any, any, any>;
-    selection: VoxelTemplateSelection;
+    template: VoxelShapeTemplate;
+    get selection(): import("../../../Templates/Shapes/Selections/VoxelShapeSelection").IVoxelShapeSelection<any, import("../../../Templates/Shapes/Selections/VoxelShapeSelection").IVoxelShapeSelectionData<any>>;
+    voxelData: Partial<BrushVoxelData>;
+    usePlacingStrategy: boolean;
+    placePosition: Vector3Like;
     protected _position: Vector3Like;
     constructor(space: VoxelBuildSpace);
-    use(picked: VoxelPickResult, voxelData?: Partial<BrushVoxelData>, usePlacingStrategy?: boolean): Promise<true | undefined>;
+    update(): Promise<void>;
+    cancel(): void;
+    use(): Promise<void>;
     protected getPlacePosition(picked: VoxelPickResult): Vector3Like;
-    updatePlacer(picked: VoxelPickResult): false | undefined;
     updateShape(shape: string): void;
+    getOptionValue(property: string): any;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
 }
 export {};

package/Builder/Tools/Brush/BrushTool.js

@@ -1,10 +1,10 @@
-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 { VoxelShapeTemplate } from "../../../Templates/Shapes/VoxelShapeTemplate";
+import { SphereVoxelShapeSelection } from "../../../Templates/Shapes/Selections/SphereVoxelShapeSelection";
+import { BoxVoxelShapeSelection } from "../../../Templates/Shapes/Selections/BoxVoxelShapeSelection";
+import { PyramidVoxelShapeSelection } from "../../../Templates/Shapes/Selections/PyramidVoxelShapeSelection";
+import { EllipsoidVoxelShapeSelection } from "../../../Templates/Shapes/Selections/EllipsoidVoxelShapeSelection";
 import { Vector3Like } from "@amodx/math";
 import { BuilderToolBase } from "../BuilderToolBase";
-import { EllipsoidVoxelTemplate } from "../../../Templates/Shapes/EllipsoidVoxelTemplate";
 export var BrushPositionModes;
 (function (BrushPositionModes) {
     BrushPositionModes["Start"] = "Start";
@@ -18,7 +18,6 @@ export var BrushToolModes;
     BrushToolModes["Remove"] = "Remove";
 })(BrushToolModes || (BrushToolModes = {}));
 export class BrushTool extends BuilderToolBase {
-    space;
     static ToolId = "Brush";
     static ModeArray = [
         BrushToolModes.Fill,
@@ -34,17 +33,164 @@ export class BrushTool extends BuilderToolBase {
         return Object.keys(this.ShapeCreators);
     }
     static ShapeCreators = {
-        Sphere: () => {
-            return new SphereVoxelTemplate(SphereVoxelTemplate.CreateNew({}));
+        Sphere() {
+            return new VoxelShapeTemplate(VoxelShapeTemplate.CreateNew({
+                shapeSelection: SphereVoxelShapeSelection.CreateNew({}),
+            }));
         },
-        Box: () => {
-            return new BoxVoxelTemplate(BoxVoxelTemplate.CreateNew({}));
+        Box() {
+            return new VoxelShapeTemplate(VoxelShapeTemplate.CreateNew({
+                shapeSelection: BoxVoxelShapeSelection.CreateNew({}),
+            }));
         },
-        Pyramid: () => {
-            return new PyramidVoxelTemplate(PyramidVoxelTemplate.CreateNew({}));
+        Pyramid() {
+            return new VoxelShapeTemplate(VoxelShapeTemplate.CreateNew({
+                shapeSelection: PyramidVoxelShapeSelection.CreateNew({}),
+            }));
         },
-        Ellipsoid: () => {
-            return new EllipsoidVoxelTemplate(EllipsoidVoxelTemplate.CreateNew({}));
+        Ellipsoid() {
+            return new VoxelShapeTemplate(VoxelShapeTemplate.CreateNew({
+                shapeSelection: EllipsoidVoxelShapeSelection.CreateNew({}),
+            }));
+        },
+    };
+    static BaseToolOptions = [
+        {
+            cateogry: "main",
+            property: "axisXPositionMode",
+            name: "X Axis Position Mode",
+            type: "string",
+            options: [
+                ["End", BrushPositionModes.End],
+                ["Center", BrushPositionModes.Center],
+                ["Start", BrushPositionModes.Start],
+            ],
+        },
+        {
+            cateogry: "main",
+            property: "axisYPositionMode",
+            name: "Y Axis Position Mode",
+            type: "string",
+            options: [
+                ["End", BrushPositionModes.End],
+                ["Center", BrushPositionModes.Center],
+                ["Start", BrushPositionModes.Start],
+            ],
+        },
+        {
+            cateogry: "main",
+            property: "axisZPositionMode",
+            name: "Z Axis Position Mode",
+            type: "string",
+            options: [
+                ["End", BrushPositionModes.End],
+                ["Center", BrushPositionModes.Center],
+                ["Start", BrushPositionModes.Start],
+            ],
+        },
+    ];
+    static ShapeOptions = {
+        Sphere() {
+            return [
+                {
+                    cateogry: "shape",
+                    property: "radius",
+                    name: "Radius",
+                    type: "number",
+                    min: 0,
+                    max: 50,
+                },
+            ];
+        },
+        Box() {
+            return [
+                {
+                    cateogry: "shape",
+                    property: "width",
+                    name: "Width",
+                    type: "number",
+                    min: 0,
+                    max: 50,
+                },
+                {
+                    cateogry: "shape",
+                    property: "height",
+                    name: "Height",
+                    type: "number",
+                    min: 0,
+                    max: 50,
+                },
+                {
+                    cateogry: "shape",
+                    property: "depth",
+                    name: "Depth",
+                    type: "number",
+                    min: 0,
+                    max: 50,
+                },
+            ];
+        },
+        Pyramid() {
+            return [
+                {
+                    cateogry: "shape",
+                    property: "direction",
+                    name: "Direction",
+                    type: "string",
+                    options: [
+                        ["Up", "+y"],
+                        ["Down", "-y"],
+                        ["East", "+x"],
+                        ["West", "-x"],
+                        ["North", "+z"],
+                        ["South", "-z"],
+                    ],
+                },
+                {
+                    cateogry: "shape",
+                    property: "height",
+                    name: "Height",
+                    type: "number",
+                    min: 0,
+                    max: 50,
+                },
+                {
+                    cateogry: "shape",
+                    property: "fallOff",
+                    name: "Falloff",
+                    type: "number",
+                    min: 0,
+                    max: 50,
+                },
+            ];
+        },
+        Ellipsoid() {
+            return [
+                {
+                    cateogry: "shape",
+                    property: "radiusX",
+                    name: "Radius X",
+                    type: "number",
+                    min: 0,
+                    max: 50,
+                },
+                {
+                    cateogry: "shape",
+                    property: "radiusY",
+                    name: "Radius Y",
+                    type: "number",
+                    min: 0,
+                    max: 50,
+                },
+                {
+                    cateogry: "shape",
+                    property: "radiusZ",
+                    name: "Radius Z",
+                    type: "number",
+                    min: 0,
+                    max: 50,
+                },
+            ];
         },
     };
     shape = "Sphere";
@@ -53,94 +199,154 @@ export class BrushTool extends BuilderToolBase {
     axisZPositionMode = BrushPositionModes.Center;
     mode = BrushToolModes.Fill;
     template;
-    selection;
+    get selection() {
+        return this.template.shapeSelection;
+    }
+    voxelData = {};
+    usePlacingStrategy = true;
+    placePosition = Vector3Like.Create();
     _position = Vector3Like.Create();
     constructor(space) {
-        super();
-        this.space = space;
-        this.selection = new VoxelTemplateSelection();
+        super(space);
         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;
+    async update() {
+        this._lastPicked = await this.space.pickWithProvider(this.rayProviderIndex);
+        if (!this._lastPicked)
+            return;
+        if (this.mode == BrushToolModes.Fill ||
+            this.mode == BrushToolModes.Extrude) {
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.normalPosition)) {
+                this._lastPicked = null;
+                return;
             }
         }
-        if (this.mode == BrushToolModes.Fill && voxelData.fill) {
-            if (!this.space.bounds.intersectsPoint(picked.normalPosition))
+        if (this.mode == BrushToolModes.Remove) {
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.position)) {
+                this._lastPicked = null;
                 return;
-            this.template.setVoxels(voxelData.fill);
-            const place = this.getPlacePosition(picked);
+            }
+        }
+        const place = this.getPlacePosition(this._lastPicked);
+        this.placePosition.x = place.x;
+        this.placePosition.y = place.y;
+        this.placePosition.z = place.z;
+        this.selection.origin.x = place.x;
+        this.selection.origin.y = place.y;
+        this.selection.origin.z = place.z;
+    }
+    cancel() {
+        this._lastPicked = null;
+    }
+    async use() {
+        if (!this._lastPicked)
+            return;
+        if (this.usePlacingStrategy) {
+            if (this.voxelData.fill) {
+                const newData = this.space.getPlaceState(this.voxelData.fill, this._lastPicked);
+                if (newData)
+                    this.voxelData.fill = newData;
+            }
+        }
+        if (this.mode == BrushToolModes.Fill && this.voxelData.fill) {
+            this.template.setVoxels(this.voxelData.fill);
+            const place = this.getPlacePosition(this._lastPicked);
             await this.space.paintTemplate([place.x, place.y, place.z], this.template.toJSON());
+            return;
+        }
+        if (this.mode == BrushToolModes.Extrude) {
+            const template = await this.space.getExtrudedSelectionTemplate(this.selection.toJSON(), this._lastPicked.normal);
+            await this.space.paintTemplate(this.selection.origin, template.toJSON());
+            return;
         }
         if (this.mode == BrushToolModes.Remove) {
-            if (!this.space.bounds.intersectsPoint(picked.position))
-                return;
-            const voxel = picked.voxel;
+            const voxel = this._lastPicked.voxel;
             if (voxel && !voxel.isAir()) {
-                const place = this.getPlacePosition(picked);
+                const place = this.getPlacePosition(this._lastPicked);
                 await this.space.eraseTemplate([place.x, place.y, place.z], this.template.toJSON());
             }
-            return true;
+            return;
         }
     }
     getPlacePosition(picked) {
         //x
         if (this.axisXPositionMode == BrushPositionModes.Center) {
             this._position.x =
-                picked.normalPosition.x - Math.floor(this.template.bounds.size.x / 2);
+                picked.normalPosition.x -
+                    Math.floor(this.template.shapeSelection.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;
+            this._position.x =
+                picked.normalPosition.x - this.template.shapeSelection.bounds.size.x;
         }
         //y
         if (this.axisYPositionMode == BrushPositionModes.Center) {
             this._position.y =
-                picked.normalPosition.y - Math.floor(this.template.bounds.size.y / 2);
+                picked.normalPosition.y -
+                    Math.floor(this.template.shapeSelection.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;
+            this._position.y =
+                picked.normalPosition.y - this.template.shapeSelection.bounds.size.y;
         }
         //z
         if (this.axisZPositionMode == BrushPositionModes.Center) {
             this._position.z =
-                picked.normalPosition.z - Math.floor(this.template.bounds.size.z / 2);
+                picked.normalPosition.z -
+                    Math.floor(this.template.shapeSelection.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;
+            this._position.z =
+                picked.normalPosition.z - this.template.shapeSelection.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);
-        });
+    }
+    getOptionValue(property) {
+        const data = this.getOptionData(property);
+        if (!data)
+            return;
+        if (this.optionInCategory(property, "main")) {
+            return this[data.property];
+        }
+        if (this.optionInCategory(property, "shape")) {
+            return this.selection[data.property];
+        }
+    }
+    getCurrentOptions() {
+        const options = [
+            ...BrushTool.BaseToolOptions,
+            ...BrushTool.ShapeOptions[this.shape](),
+        ];
+        this.processOptions(options);
+        return options;
+    }
+    updateOption(property, value) {
+        const data = this.getOptionData(property);
+        if (!data)
+            return;
+        if (this.optionInCategory(property, "main")) {
+            this[data.property] = value;
+            return;
+        }
+        if (this.optionInCategory(property, "shape")) {
+            this.selection[data.property] = value;
+            return;
+        }
     }
 }

package/Builder/Tools/BuilderToolBase.d.ts

@@ -1,3 +1,39 @@
+import { VoxelPickResult } from "Voxels/Interaction/VoxelPickResult";
 import { TypedEventTarget } from "../../Util/TypedEventTarget";
+import { VoxelBuildSpace } from "../VoxelBuildSpace";
+type ToolOptionBase<Data> = {
+    cateogry: string;
+    property: string;
+    name: string;
+} & Data;
+export type ToolOption = ToolOptionBase<{
+    type: "string";
+    options: [name: string, value: any][];
+}> | ToolOptionBase<{
+    type: "number";
+    min: number;
+    max: number;
+}>;
+export type ToolOptionsData = ToolOption[];
 export declare abstract class BuilderToolBase<Events extends Record<string, any>> extends TypedEventTarget<Events> {
+    space: VoxelBuildSpace;
+    rayProviderIndex: number;
+    protected _lastPicked: VoxelPickResult | null;
+    get picked(): Readonly<VoxelPickResult> | null;
+    constructor(space: VoxelBuildSpace);
+    protected _options: ToolOptionsData;
+    protected _optionsMap: Map<string, ToolOption>;
+    protected _categoryMap: Map<string, Set<string>>;
+    protected processOptions(data: ToolOptionsData): void;
+    getOptions(): ToolOptionsData;
+    getOptionCategories(): [string, Set<string>][];
+    abstract getOptionValue(id: string): any;
+    getOptionData(id: string): ToolOption | undefined;
+    optionInCategory(option: string, cateogry: string): boolean;
+    abstract getCurrentOptions(): ToolOptionsData;
+    abstract updateOption(property: string, value: any): void;
+    abstract cancel(): void;
+    abstract use(...args: any): Promise<void>;
+    abstract update(...args: any): Promise<void>;
 }
+export {};

package/Builder/Tools/BuilderToolBase.js

@@ -1,3 +1,42 @@
 import { TypedEventTarget } from "../../Util/TypedEventTarget";
 export class BuilderToolBase extends TypedEventTarget {
+    space;
+    rayProviderIndex = 0;
+    _lastPicked = null;
+    get picked() {
+        return this._lastPicked;
+    }
+    constructor(space) {
+        super();
+        this.space = space;
+    }
+    _options = [];
+    _optionsMap = new Map();
+    _categoryMap = new Map();
+    processOptions(data) {
+        this._options = data;
+        this._optionsMap.clear();
+        this._categoryMap.clear();
+        for (const option of data) {
+            let categoryArray = this._categoryMap.get(option.cateogry);
+            if (!categoryArray) {
+                categoryArray = new Set();
+                this._categoryMap.set(option.cateogry, categoryArray);
+            }
+            categoryArray.add(option.property);
+            this._optionsMap.set(option.property, option);
+        }
+    }
+    getOptions() {
+        return this._options;
+    }
+    getOptionCategories() {
+        return [...this._categoryMap];
+    }
+    getOptionData(id) {
+        return this._optionsMap.get(id);
+    }
+    optionInCategory(option, cateogry) {
+        return Boolean(this._categoryMap.get(cateogry)?.has(option));
+    }
 }

package/Builder/Tools/Hand/HandTool.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";
 export declare enum HandToolModes {
     Place = "Place",
     Remove = "Remove"
@@ -10,13 +8,17 @@ export declare enum HandToolModes {
 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>;
+    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/Hand/HandTool.js

@@ -6,7 +6,6 @@ export var HandToolModes;
     HandToolModes["Remove"] = "Remove";
 })(HandToolModes || (HandToolModes = {}));
 export class HandTool extends BuilderToolBase {
-    space;
     static ToolId = "Hand";
     static ModeArray = [
         HandToolModes.Place,
@@ -14,43 +13,61 @@ export class HandTool extends BuilderToolBase {
     ];
     mode = HandToolModes.Place;
     selection = new VoxelPointSelection();
-    constructor(space) {
-        super();
-        this.space = space;
-    }
-    updatePlacer(picked) {
+    voxelData;
+    usePlacingStrategy = true;
+    async update() {
+        this._lastPicked = await this.space.pickWithProvider(this.rayProviderIndex);
+        if (!this._lastPicked)
+            return;
         if (this.mode == HandToolModes.Place) {
-            this.selection.reConstruct(picked.normalPosition);
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.normalPosition)) {
+                this._lastPicked = null;
+                return;
+            }
+            this.selection.reConstruct(this._lastPicked.normalPosition);
         }
         if (this.mode == HandToolModes.Remove) {
-            this.selection.reConstruct(picked.position);
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.position)) {
+                this._lastPicked = null;
+                return;
+            }
+            this.selection.reConstruct(this._lastPicked.position);
         }
     }
-    async use(picked, voxelData, usePlacingStrategy = true) {
+    cancel() {
+        this._lastPicked = null;
+    }
+    async use() {
+        if (!this._lastPicked)
+            return;
         if (this.mode == HandToolModes.Place) {
-            if (!this.space.bounds.intersectsPoint(picked.normalPosition))
-                return false;
-            if (usePlacingStrategy) {
-                const newData = this.space.getPlaceState(voxelData, picked);
+            let voxelData = this.voxelData;
+            if (this.usePlacingStrategy) {
+                const newData = this.space.getPlaceState(voxelData, this._lastPicked);
                 if (newData)
                     voxelData = newData;
             }
             await this.space.paintVoxel([
-                picked.normalPosition.x,
-                picked.normalPosition.y,
-                picked.normalPosition.z,
+                this._lastPicked.normalPosition.x,
+                this._lastPicked.normalPosition.y,
+                this._lastPicked.normalPosition.z,
             ], voxelData);
-            return true;
+            return;
         }
         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,
+                this._lastPicked.position.x,
+                this._lastPicked.position.y,
+                this._lastPicked.position.z,
             ]);
-            return true;
+            return;
         }
     }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
 }