@divinevoxel/vlox 0.0.76 → 0.0.78

package/Templates/Functions/FlipTemplate.js

@@ -1,18 +1,18 @@
 import { Flat3DIndex } from "@amodx/math";
-const flipArray = ([sizeX, sizeY, sizeZ], array, direction, index) => {
+const flipArray = ([sizeX, sizeY, sizeZ], array, axes, index) => {
     const newArray = new Array(array.length);
     for (let x = 0; x < sizeX; x++) {
         for (let y = 0; y < sizeY; y++) {
             for (let z = 0; z < sizeZ; z++) {
                 const oldIndex = index.getIndexXYZ(x, y, z);
                 let newCoords = [x, y, z];
-                if (direction === "x") {
+                if (axes === "x") {
                     newCoords[0] = sizeX - 1 - x;
                 }
-                else if (direction === "y") {
+                else if (axes === "y") {
                     newCoords[1] = sizeY - 1 - y;
                 }
-                else if (direction === "z") {
+                else if (axes === "z") {
                     newCoords[2] = sizeZ - 1 - z;
                 }
                 const newIndexFlat = index.getIndexXYZ(...newCoords);
@@ -24,20 +24,20 @@ const flipArray = ([sizeX, sizeY, sizeZ], array, direction, index) => {
         array[i] = newArray[i];
     }
 };
-export default function FlipTemplate(template, direction) {
+export default function FlipTemplate(template, axes) {
     const { x: sizeX, y: sizeY, z: sizeZ } = template.bounds.size;
     const index = Flat3DIndex.GetXZYOrder();
     index.setBounds(sizeX, sizeY, sizeZ);
     if (typeof template.ids === "object") {
         const ids = template.ids;
-        flipArray([sizeX, sizeY, sizeZ], ids, direction, index);
+        flipArray([sizeX, sizeY, sizeZ], ids, axes, index);
     }
     if (typeof template.level === "object") {
         const level = template.level;
-        flipArray([sizeX, sizeY, sizeZ], level, direction, index);
+        flipArray([sizeX, sizeY, sizeZ], level, axes, index);
     }
     if (typeof template.secondary === "object") {
         const secondary = template.secondary;
-        flipArray([sizeX, sizeY, sizeZ], secondary, direction, index);
+        flipArray([sizeX, sizeY, sizeZ], secondary, axes, index);
     }
 }

package/Templates/Functions/RotateTemplate.d.ts

@@ -1,4 +1,4 @@
+import { Vector3Axes } from "@amodx/math";
 import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
-export type TemplateRotationAxes = "x" | "y" | "z";
 export type TemplateRotationAngles = 90 | 180 | 270 | -90 | -180 | -270;
-export default function RotateTemplate(template: FullVoxelTemplate, angle: TemplateRotationAngles, axes?: TemplateRotationAxes): void;
+export default function RotateTemplate(template: FullVoxelTemplate, angle: TemplateRotationAngles, axes?: Vector3Axes): void;

package/Templates/Path/VoxelPath.js

@@ -8,6 +8,7 @@ export class VoxelPathSegment extends TypedEventTarget {
             start: data.start ? data.start : [0, 0, 0],
             end: data.end ? data.end : [0, 0, 0],
             voxel: data.voxel ? data.voxel : PaintVoxelData.Create(),
+            transient: data.transient ? data.transient : undefined,
         };
     }
     start;
@@ -38,7 +39,6 @@ export class VoxelPathSegment extends TypedEventTarget {
         this.end[1] = ey;
         this.end[2] = ez;
         if (updated) {
-            console.warn("UPDATED");
             this.dispatch("updated", {});
         }
     }
@@ -105,6 +105,7 @@ export class VoxelPath extends TypedEventTarget {
         for (let i = this.segments.length - 1; i > -1; i--) {
             this.segments[i].index--;
             if (this.segments[i] == segment) {
+                console.log("found segment to remove", i);
                 this.segments.splice(i, 1);
                 break;
             }

package/Templates/Selection/VoxelBFSSelection.d.ts

@@ -1,16 +1,13 @@
 import { Flat3DIndex, Vector3Like } from "@amodx/math";
-import { IVoxelSelection } from "./VoxelSelecton";
+import { IVoxelSelection, IVoxelSelectionData } from "./VoxelSelection";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
-export interface VoxelBFSSelectionData {
-    origin: Vector3Like;
-    size: Vector3Like;
+export interface VoxelBFSSelectionData extends IVoxelSelectionData<"bfs"> {
     bitIndex: Uint8Array;
 }
-export declare class VoxelBFSSelection implements IVoxelSelection, VoxelBFSSelectionData {
+export declare class VoxelBFSSelection implements IVoxelSelection<"bfs", VoxelBFSSelectionData> {
     origin: Vector3Like;
-    size: Vector3Like;
     bitIndex: Uint8Array;
     index: Flat3DIndex;
     bounds: BoundingBox;

package/Templates/Selection/VoxelBFSSelection.js

@@ -5,16 +5,11 @@ import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export class VoxelBFSSelection {
     origin = Vector3Like.Create();
-    size = Vector3Like.Create();
     bitIndex;
     index = Flat3DIndex.GetXZYOrder();
     bounds = new BoundingBox();
     isSelected(x, y, z) {
-        if (x < this.origin.x || x >= this.origin.x + this.size.x)
-            return false;
-        if (y < this.origin.y || y >= this.origin.y + this.size.y)
-            return false;
-        if (z < this.origin.z || z >= this.origin.z + this.size.z)
+        if (!this.bounds.intersectsXYZ(x + 0.5, y + 0.5, z + 0.5))
             return false;
         return (getBitArrayIndex(this.bitIndex, this.index.getIndexXYZ(x - this.origin.x, y - this.origin.y, z - this.origin.z)) === 1);
     }
@@ -80,24 +75,23 @@ export class VoxelBFSSelection {
                 }
             }
         }
-        this.size.x = sizeX;
-        this.size.y = sizeY;
-        this.size.z = sizeZ;
         this.origin.x = min.x;
         this.origin.y = min.y;
         this.origin.z = min.z;
+        this.bounds.setMinMax(this.origin, {
+            x: this.origin.x + sizeX,
+            y: this.origin.y + sizeY,
+            z: this.origin.z + sizeZ,
+        });
     }
     toTemplate(cursor) {
-        const templateData = FullVoxelTemplate.CreateNew([
-            this.size.x,
-            this.size.y,
-            this.size.z,
-        ]);
+        const size = this.bounds.size;
+        const templateData = FullVoxelTemplate.CreateNew([size.x, size.y, size.z]);
         templateData.mask = this.bitIndex.slice();
         const template = new FullVoxelTemplate(templateData);
-        for (let x = this.origin.x; x < this.origin.x + this.size.x; x++) {
-            for (let y = this.origin.y; y < this.origin.y + this.size.y; y++) {
-                for (let z = this.origin.z; z < this.origin.z + this.size.z; z++) {
+        for (let x = this.origin.x; x < this.origin.x + size.x; x++) {
+            for (let y = this.origin.y; y < this.origin.y + size.y; y++) {
+                for (let z = this.origin.z; z < this.origin.z + size.z; z++) {
                     if (!this.isSelected(x, y, z))
                         continue;
                     const voxel = cursor.getVoxel(x, y, z);
@@ -115,16 +109,16 @@ export class VoxelBFSSelection {
     clone() {
         const newSelection = new VoxelBFSSelection();
         Vector3Like.Copy(newSelection.origin, this.origin);
-        Vector3Like.Copy(newSelection.size, this.size);
         newSelection.bounds.setMinMax(this.bounds.min, this.bounds.max);
-        newSelection.bitIndex = structuredClone(this.bitIndex);
+        newSelection.bitIndex = this.bitIndex.slice();
         newSelection.index.setBounds(...this.index.getBounds());
         return newSelection;
     }
     toJSON() {
         return {
+            type: "bfs",
             origin: { ...this.origin },
-            size: { ...this.size },
+            bounds: { ...this.bounds.size },
             bitIndex: this.bitIndex.slice(),
         };
     }
@@ -132,10 +126,12 @@ export class VoxelBFSSelection {
         this.origin.x = data.origin.x;
         this.origin.y = data.origin.y;
         this.origin.z = data.origin.z;
-        this.size.x = data.size.x;
-        this.size.y = data.size.y;
-        this.size.z = data.size.z;
         this.bitIndex = data.bitIndex;
-        this.index.setBounds(this.size.x, this.size.y, this.size.z);
+        this.bounds.setMinMax(this.origin, {
+            x: this.origin.x + data.bounds.x,
+            y: this.origin.y + data.bounds.y,
+            z: this.origin.z + data.bounds.z,
+        });
+        this.index.setBounds(data.bounds.x, data.bounds.y, data.bounds.z);
     }
 }

package/Templates/Selection/{VoxelBoxSelection.d.ts → VoxelBoundsSelection.d.ts}

@@ -1,17 +1,20 @@
 import { Vector3Like } from "@amodx/math";
-import { IVoxelSelection } from "./VoxelSelecton";
-import { BoxVoxelTemplate } from "../Shapes/BoxVoxelTemplate";
+import { IVoxelSelection, IVoxelSelectionData } from "./VoxelSelection";
+import { VoxelShapeTemplate } from "../Shapes/VoxelShapeTemplate";
 import { IVoxelshapeTemplateBaseData } from "../Shapes/VoxelShapeTemplate.types";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
-export declare class VoxelBoxSelection implements IVoxelSelection {
+export interface VoxelBoundsSelectionData extends IVoxelSelectionData<"bounds"> {
+}
+export declare class VoxelBoundsSelection implements IVoxelSelection<"bounds", VoxelBoundsSelectionData> {
     origin: Vector3Like;
     end: Vector3Like;
-    size: Vector3Like;
     bounds: BoundingBox;
     isSelected(x: number, y: number, z: number): boolean;
     reConstruct(startPosition: Vector3Like, startNormal: Vector3Like, endPosition: Vector3Like, endNormal: Vector3Like, offset?: number): void;
-    clone(): VoxelBoxSelection;
-    toTemplate(data?: Partial<IVoxelshapeTemplateBaseData>): BoxVoxelTemplate;
+    clone(): VoxelBoundsSelection;
+    toTemplate(data?: Partial<IVoxelshapeTemplateBaseData>): VoxelShapeTemplate;
     toExtrudedTemplate(cursor: DataCursorInterface, normal: Vector3Like): void;
+    toJSON(): VoxelBoundsSelectionData;
+    fromJSON(data: VoxelBoundsSelectionData): void;
 }

package/Templates/Selection/{VoxelBoxSelection.js → VoxelBoundsSelection.js}

@@ -1,5 +1,6 @@
 import { Vec3ArrayLike, Vector3Like } from "@amodx/math";
-import { BoxVoxelTemplate } from "../Shapes/BoxVoxelTemplate";
+import { VoxelShapeTemplate } from "../Shapes/VoxelShapeTemplate";
+import { BoxVoxelShapeSelection } from "../Shapes/Selections/BoxVoxelShapeSelection";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 const getMinMax = (...points) => {
     if (points.length === 0) {
@@ -22,17 +23,12 @@ const getMinMax = (...points) => {
 const getSize = (start, end) => {
     return Vector3Like.Create(end.x - start.x, end.y - start.y, end.z - start.z);
 };
-export class VoxelBoxSelection {
+export class VoxelBoundsSelection {
     origin = Vector3Like.Create();
     end = Vector3Like.Create();
-    size = Vector3Like.Create();
     bounds = new BoundingBox();
     isSelected(x, y, z) {
-        if (x < this.origin.x || x >= this.end.x)
-            return false;
-        if (y < this.origin.y || y >= this.end.y)
-            return false;
-        if (z < this.origin.z || z >= this.end.z)
+        if (!this.bounds.intersectsXYZ(x + 0.5, y + 0.5, z + 0.5))
             return false;
         return true;
     }
@@ -78,9 +74,6 @@ export class VoxelBoxSelection {
             this.end.x = startPosition.x + startNormal.x;
             this.end.y = startPosition.y + startNormal.y;
             this.end.z = startPosition.z + startNormal.z;
-            this.size.x = 1;
-            this.size.y = 1;
-            this.size.z = 1;
         }
         else {
             this.origin.x = finalMin[0];
@@ -89,28 +82,42 @@ export class VoxelBoxSelection {
             this.end.x = finalMax[0];
             this.end.y = finalMax[1];
             this.end.z = finalMax[2];
-            this.size.x = finalSize[0];
-            this.size.y = finalSize[1];
-            this.size.z = finalSize[2];
         }
         this.bounds.setMinMax(this.origin, this.end);
     }
     clone() {
-        const newSelection = new VoxelBoxSelection();
+        const newSelection = new VoxelBoundsSelection();
         Vector3Like.Copy(newSelection.origin, this.origin);
-        Vector3Like.Copy(newSelection.size, this.size);
         Vector3Like.Copy(newSelection.end, this.end);
         newSelection.bounds.setMinMax(this.bounds.min, this.bounds.max);
         return newSelection;
     }
     toTemplate(data) {
-        const boxTemplate = BoxVoxelTemplate.CreateNew({
-            width: this.size.x,
-            height: this.size.y,
-            depth: this.size.z,
+        return new VoxelShapeTemplate(VoxelShapeTemplate.CreateNew({
+            shapeSelection: BoxVoxelShapeSelection.CreateNew({
+                width: this.bounds.size.x,
+                height: this.bounds.size.y,
+                depth: this.bounds.size.z,
+            }),
             ...(data ? data : {}),
-        });
-        return new BoxVoxelTemplate(boxTemplate);
+        }));
     }
     toExtrudedTemplate(cursor, normal) { }
+    toJSON() {
+        return {
+            type: "bounds",
+            origin: { ...this.origin },
+            bounds: { ...this.bounds.size },
+        };
+    }
+    fromJSON(data) {
+        this.origin.x = data.origin.x;
+        this.origin.y = data.origin.y;
+        this.origin.z = data.origin.z;
+        this.bounds.setMinMax(this.origin, {
+            x: this.origin.x + data.bounds.x,
+            y: this.origin.y + data.bounds.y,
+            z: this.origin.z + data.bounds.z,
+        });
+    }
 }

package/Templates/Selection/VoxelPointSelection.d.ts

@@ -1,17 +1,19 @@
 import { Vector3Like } from "@amodx/math";
-import { IVoxelSelection } from "./VoxelSelecton";
-import { BoxVoxelTemplate } from "../Shapes/BoxVoxelTemplate";
+import { IVoxelSelection, IVoxelSelectionData } from "./VoxelSelection";
+import { VoxelShapeTemplate } from "../Shapes/VoxelShapeTemplate";
 import { IVoxelshapeTemplateBaseData } from "../Shapes/VoxelShapeTemplate.types";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
-export declare class VoxelPointSelection implements IVoxelSelection {
+export interface VoxelPointSelectionData extends IVoxelSelectionData<"point"> {
+}
+export declare class VoxelPointSelection implements IVoxelSelection<"point", VoxelPointSelectionData> {
     origin: Vector3Like;
-    end: Vector3Like;
-    size: Vector3Like;
     bounds: BoundingBox;
     isSelected(x: number, y: number, z: number): boolean;
     reConstruct(position: Vector3Like): void;
     clone(): VoxelPointSelection;
-    toTemplate(data?: Partial<IVoxelshapeTemplateBaseData>): BoxVoxelTemplate;
+    toTemplate(data?: Partial<IVoxelshapeTemplateBaseData>): VoxelShapeTemplate;
     toExtrudedTemplate(cursor: DataCursorInterface, normal: Vector3Like): void;
+    toJSON(): VoxelPointSelectionData;
+    fromJSON(data: any): void;
 }

package/Templates/Selection/VoxelPointSelection.js

@@ -1,17 +1,12 @@
 import { Vector3Like } from "@amodx/math";
-import { BoxVoxelTemplate } from "../Shapes/BoxVoxelTemplate";
+import { VoxelShapeTemplate } from "../Shapes/VoxelShapeTemplate";
+import { BoxVoxelShapeSelection } from "../Shapes/Selections/BoxVoxelShapeSelection";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export class VoxelPointSelection {
     origin = Vector3Like.Create();
-    end = Vector3Like.Create();
-    size = Vector3Like.Create();
     bounds = new BoundingBox();
     isSelected(x, y, z) {
-        if (x < this.origin.x || x >= this.end.x)
-            return false;
-        if (y < this.origin.y || y >= this.end.y)
-            return false;
-        if (z < this.origin.z || z >= this.end.z)
+        if (!this.bounds.intersectsXYZ(x + 0.5, y + 0.5, z + 0.5))
             return false;
         return true;
     }
@@ -19,30 +14,36 @@ export class VoxelPointSelection {
         this.origin.x = position.x;
         this.origin.y = position.y;
         this.origin.z = position.z;
-        this.end.x = this.origin.x + 1;
-        this.end.y = this.origin.y + 1;
-        this.end.z = this.origin.z + 1;
-        this.size.x = 1;
-        this.size.y = 1;
-        this.size.z = 1;
-        this.bounds.setMinMax(this.origin, this.end);
+        this.bounds.setMinMax(this.origin, Vector3Like.AddScalar(this.origin, 1));
     }
     clone() {
         const newSelection = new VoxelPointSelection();
         Vector3Like.Copy(newSelection.origin, this.origin);
-        Vector3Like.Copy(newSelection.size, this.size);
-        Vector3Like.Copy(newSelection.end, this.end);
         newSelection.bounds.setMinMax(this.bounds.min, this.bounds.max);
         return newSelection;
     }
     toTemplate(data) {
-        const boxTemplate = BoxVoxelTemplate.CreateNew({
-            width: this.size.x,
-            height: this.size.y,
-            depth: this.size.z,
-            ...(data ? data : {}),
-        });
-        return new BoxVoxelTemplate(boxTemplate);
+        return new VoxelShapeTemplate(VoxelShapeTemplate.CreateNew({
+            shapeSelection: BoxVoxelShapeSelection.CreateNew({}),
+            ...data,
+        }));
     }
     toExtrudedTemplate(cursor, normal) { }
+    toJSON() {
+        return {
+            type: "point",
+            origin: { ...this.origin },
+            bounds: { ...this.bounds.size },
+        };
+    }
+    fromJSON(data) {
+        this.origin.x = data.origin.x;
+        this.origin.y = data.origin.y;
+        this.origin.z = data.origin.z;
+        this.bounds.setMinMax(this.origin, {
+            x: this.origin.x + data.bounds.x,
+            y: this.origin.y + data.bounds.y,
+            z: this.origin.z + data.bounds.z,
+        });
+    }
 }

package/Templates/Selection/VoxelSelection.d.ts

@@ -0,0 +1,18 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export interface IVoxelSelection<Type extends string = "", Data extends IVoxelSelectionData<Type> = any> {
+    origin: Vector3Like;
+    bounds: BoundingBox;
+    isSelected(x: number, y: number, z: number): boolean;
+    clone(): IVoxelSelection;
+    toJSON(): Data;
+    fromJSON(data: Data): void;
+}
+export interface IVoxelSelectionData<Type extends string> {
+    type: Type;
+    origin: Vector3Like;
+    bounds: Vector3Like;
+}
+export interface IVoxelSelectionConstructor<Type extends string, Data extends IVoxelSelectionData<Type> = any> {
+    new (): IVoxelSelection<Type, Data>;
+}

package/Templates/Selection/VoxelSurfaceSelection.d.ts

@@ -1,30 +1,23 @@
 import { Flat3DIndex, Vector3Like } from "@amodx/math";
-import { IVoxelSelection } from "./VoxelSelecton";
+import { IVoxelSelection, IVoxelSelectionData } from "./VoxelSelection";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
 import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
-export interface VoxelSurfaceSelectionData {
-    origin: Vector3Like;
-    size: Vector3Like;
+export interface VoxelSurfaceSelectionData extends IVoxelSelectionData<"surface"> {
     normal: Vector3Like;
     bitIndex: Uint8Array;
-    extrusion: number;
 }
-export declare class VoxelSurfaceSelection implements IVoxelSelection, VoxelSurfaceSelectionData {
+export declare class VoxelSurfaceSelection implements IVoxelSelection<"surface"> {
     origin: Vector3Like;
-    size: Vector3Like;
     normal: Vector3Like;
     bitIndex: Uint8Array;
     index: Flat3DIndex;
     bounds: BoundingBox;
-    extrusion: number;
     isSelected(x: number, y: number, z: number): boolean;
-    reConstruct(cursor: DataCursorInterface, position: Vector3Like, normal: Vector3Like, extrusion: number, maxSize?: number): false | undefined;
+    reConstruct(cursor: DataCursorInterface, position: Vector3Like, normal: Vector3Like, extrusion: number, maxSize?: number): boolean;
     clone(): VoxelSurfaceSelection;
-    toTemplate(cursor: DataCursorInterface, voxelOrExtrude: PaintVoxelData | true): FullVoxelTemplate;
-    toTemplate(cursor: DataCursorInterface, extrude: true): FullVoxelTemplate;
-    toTemplate(cursor: DataCursorInterface, voxel: PaintVoxelData): FullVoxelTemplate;
+    toTemplate(voxel: PaintVoxelData): FullVoxelTemplate;
     toJSON(): VoxelSurfaceSelectionData;
     fromJSON(data: VoxelSurfaceSelectionData): void;
 }