@divinevoxel/vlox 0.0.75 → 0.0.77

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/Brush/BrushTool.d.ts

@@ -0,0 +1,55 @@
+import { VoxelBuildSpace } from "../../VoxelBuildSpace";
+import { VoxelShapeTemplate } from "../../../Templates/Shapes/VoxelShapeTemplate";
+import { VoxelPickResult } from "../../../Voxels/Interaction/VoxelPickResult";
+import { Vector3Like } from "@amodx/math";
+import { PaintVoxelData } from "../../../Voxels";
+import { BuilderToolBase, ToolOptionsData } 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> {
+    static ToolId: string;
+    static ModeArray: BrushToolModes[];
+    static PositionModeArray: BrushPositionModes[];
+    static get ShapesArray(): string[];
+    static ShapeCreators: Record<string, () => VoxelShapeTemplate>;
+    static BaseToolOptions: ToolOptionsData;
+    static ShapeOptions: Record<string, () => ToolOptionsData>;
+    shape: string;
+    axisXPositionMode: BrushPositionModes;
+    axisYPositionMode: BrushPositionModes;
+    axisZPositionMode: BrushPositionModes;
+    mode: BrushToolModes;
+    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);
+    update(): Promise<void>;
+    cancel(): void;
+    use(): Promise<void>;
+    protected getPlacePosition(picked: VoxelPickResult): Vector3Like;
+    updateShape(shape: string): void;
+    getOptionValue(property: string): any;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
+}
+export {};

package/Builder/Tools/Brush/BrushTool.js

@@ -0,0 +1,352 @@
+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";
+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 {
+    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 VoxelShapeTemplate(VoxelShapeTemplate.CreateNew({
+                shapeSelection: SphereVoxelShapeSelection.CreateNew({}),
+            }));
+        },
+        Box() {
+            return new VoxelShapeTemplate(VoxelShapeTemplate.CreateNew({
+                shapeSelection: BoxVoxelShapeSelection.CreateNew({}),
+            }));
+        },
+        Pyramid() {
+            return new VoxelShapeTemplate(VoxelShapeTemplate.CreateNew({
+                shapeSelection: PyramidVoxelShapeSelection.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";
+    axisXPositionMode = BrushPositionModes.Center;
+    axisYPositionMode = BrushPositionModes.Center;
+    axisZPositionMode = BrushPositionModes.Center;
+    mode = BrushToolModes.Fill;
+    template;
+    get selection() {
+        return this.template.shapeSelection;
+    }
+    voxelData = {};
+    usePlacingStrategy = true;
+    placePosition = Vector3Like.Create();
+    _position = Vector3Like.Create();
+    constructor(space) {
+        super(space);
+        this.updateShape(this.shape);
+    }
+    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.Remove) {
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.position)) {
+                this._lastPicked = null;
+                return;
+            }
+        }
+        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) {
+            const voxel = this._lastPicked.voxel;
+            if (voxel && !voxel.isAir()) {
+                const place = this.getPlacePosition(this._lastPicked);
+                await this.space.eraseTemplate([place.x, place.y, place.z], this.template.toJSON());
+            }
+            return;
+        }
+    }
+    getPlacePosition(picked) {
+        //x
+        if (this.axisXPositionMode == BrushPositionModes.Center) {
+            this._position.x =
+                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.shapeSelection.bounds.size.x;
+        }
+        //y
+        if (this.axisYPositionMode == BrushPositionModes.Center) {
+            this._position.y =
+                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.shapeSelection.bounds.size.y;
+        }
+        //z
+        if (this.axisZPositionMode == BrushPositionModes.Center) {
+            this._position.z =
+                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.shapeSelection.bounds.size.z;
+        }
+        return this._position;
+    }
+    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();
+    }
+    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

@@ -0,0 +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

@@ -0,0 +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

@@ -0,0 +1,24 @@
+import { PaintVoxelData } from "../../../Voxels";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
+export declare enum HandToolModes {
+    Place = "Place",
+    Remove = "Remove"
+}
+interface HandToolEvents {
+}
+export declare class HandTool extends BuilderToolBase<HandToolEvents> {
+    static ToolId: string;
+    static ModeArray: HandToolModes[];
+    mode: HandToolModes;
+    selection: VoxelPointSelection;
+    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

@@ -0,0 +1,73 @@
+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 {
+    static ToolId = "Hand";
+    static ModeArray = [
+        HandToolModes.Place,
+        HandToolModes.Remove,
+    ];
+    mode = HandToolModes.Place;
+    selection = new VoxelPointSelection();
+    voxelData;
+    usePlacingStrategy = true;
+    async update() {
+        this._lastPicked = await this.space.pickWithProvider(this.rayProviderIndex);
+        if (!this._lastPicked)
+            return;
+        if (this.mode == HandToolModes.Place) {
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.normalPosition)) {
+                this._lastPicked = null;
+                return;
+            }
+            this.selection.reConstruct(this._lastPicked.normalPosition);
+        }
+        if (this.mode == HandToolModes.Remove) {
+            if (!this.space.bounds.intersectsPoint(this._lastPicked.position)) {
+                this._lastPicked = null;
+                return;
+            }
+            this.selection.reConstruct(this._lastPicked.position);
+        }
+    }
+    cancel() {
+        this._lastPicked = null;
+    }
+    async use() {
+        if (!this._lastPicked)
+            return;
+        if (this.mode == HandToolModes.Place) {
+            let voxelData = this.voxelData;
+            if (this.usePlacingStrategy) {
+                const newData = this.space.getPlaceState(voxelData, this._lastPicked);
+                if (newData)
+                    voxelData = newData;
+            }
+            await this.space.paintVoxel([
+                this._lastPicked.normalPosition.x,
+                this._lastPicked.normalPosition.y,
+                this._lastPicked.normalPosition.z,
+            ], voxelData);
+            return;
+        }
+        if (this.mode == HandToolModes.Remove) {
+            await this.space.eraseVoxel([
+                this._lastPicked.position.x,
+                this._lastPicked.position.y,
+                this._lastPicked.position.z,
+            ]);
+            return;
+        }
+    }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
+}

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

@@ -0,0 +1,34 @@
+import { PaintVoxelData } from "../../../Voxels";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+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",
+    RemovePoints = "Remove Points",
+    FillPath = "Fill Path",
+    RemovePath = "Remvoe Path"
+}
+interface PathToolEvents {
+}
+export declare class PathTool extends BuilderToolBase<PathToolEvents> {
+    static ToolId: string;
+    static ModeArray: PathToolModes[];
+    mode: PathToolModes;
+    selection: VoxelPointSelection;
+    pointSelection: FreePointSelection;
+    path: VoxelPath;
+    get distance(): number;
+    set distance(value: number);
+    voxelData: PaintVoxelData;
+    private _placedSegment;
+    setMode(mode: PathToolModes): void;
+    cancel(): void;
+    update(): Promise<void>;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
+}
+export {};