@divinevoxel/vlox 0.0.75 → 0.0.77

package/Templates/Full/FullVoxelTemplate.js

@@ -2,6 +2,7 @@ import { Flat3DIndex, Vector3Like } from "@amodx/math";
 import { getBitArrayIndex } from "../../Util/Binary/BinaryArrays";
 import { EngineSettings } from "../../Settings/EngineSettings";
 import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+const point = Vector3Like.Create();
 export class FullVoxelTemplate {
     static CreateNew(bounds, baseLightValue = 0) {
         const voxelSize = bounds[0] * bounds[1] * bounds[2];
@@ -29,7 +30,6 @@ export class FullVoxelTemplate {
         bufferStart += voxelSize;
         return {
             type: "full",
-            position: Vector3Like.Create(),
             bounds: Vector3Like.Create(...bounds),
             ids,
             light,
@@ -38,7 +38,6 @@ export class FullVoxelTemplate {
         };
     }
     index = Flat3DIndex.GetXZYOrder();
-    position = Vector3Like.Create();
     bounds;
     ids;
     level;
@@ -46,26 +45,20 @@ export class FullVoxelTemplate {
     secondary;
     mask;
     constructor(data) {
-        this.position = { ...data.position };
-        this.bounds = new BoundingBox();
-        this.bounds.setMinPositionAndSize(data.position, data.bounds);
-        this.index.setBounds(data.bounds.x, data.bounds.y, data.bounds.z);
-        this.ids = data.ids;
-        this.level = data.level;
-        this.light = data.light;
-        this.secondary = data.secondary;
-        if (data.mask)
-            this.mask = data.mask;
+        this.fromJSON(data);
     }
-    setPosition(x, y, z) {
-        this.position.x = x;
-        this.position.y = y;
-        this.position.z = z;
+    inBounds(x, y, z) {
+        point.x = x + 0.5;
+        point.y = y + 0.5;
+        point.z = z + 0.5;
+        return this.bounds.intersectsPoint(point);
     }
     isAir(index) {
         return this.ids[index] === 0;
     }
     isIncluded(index) {
+        if (index < 0 || index >= this.index.size)
+            return false;
         if (this.mask) {
             return getBitArrayIndex(this.mask, index) === 1;
         }
@@ -93,10 +86,21 @@ export class FullVoxelTemplate {
         rawRef[3] = this.getSecondary(index);
         return rawRef;
     }
+    clone() {
+        const newTemplate = new FullVoxelTemplate({
+            type: "full",
+            bounds: { ...this.bounds.size },
+            ids: this.ids.slice(),
+            light: this.light.slice(),
+            level: this.level.slice(),
+            secondary: this.secondary.slice(),
+            ...(this.mask ? { mask: this.mask.slice() } : {}),
+        });
+        return newTemplate;
+    }
     toJSON() {
         return {
             type: "full",
-            position: this.position,
             bounds: this.bounds.size,
             ids: this.ids,
             light: this.light,
@@ -105,4 +109,15 @@ export class FullVoxelTemplate {
             ...(this.mask ? { mask: this.mask } : {}),
         };
     }
+    fromJSON(data) {
+        this.bounds = new BoundingBox();
+        this.bounds.setSize(data.bounds);
+        this.index.setBounds(data.bounds.x, data.bounds.y, data.bounds.z);
+        this.ids = data.ids;
+        this.level = data.level;
+        this.light = data.light;
+        this.secondary = data.secondary;
+        if (data.mask)
+            this.mask = data.mask;
+    }
 }

package/Templates/Functions/ExtrudeSelection.d.ts

@@ -0,0 +1,5 @@
+import { IVoxelSelection } from "../Selection/VoxelSelection";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
+import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
+import { Vector3Like } from "@amodx/math";
+export declare function ExtrudeSelection(cursor: DataCursorInterface, selection: IVoxelSelection, normal: Vector3Like): FullVoxelTemplate;

package/Templates/Functions/ExtrudeSelection.js

@@ -0,0 +1,44 @@
+import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
+export function ExtrudeSelection(cursor, selection, normal) {
+    const size = selection.bounds.size;
+    const template = new FullVoxelTemplate(FullVoxelTemplate.CreateNew([size.x, size.y, size.z]));
+    for (let x = selection.origin.x; x < selection.origin.x + size.x; x++) {
+        for (let y = selection.origin.y; y < selection.origin.y + size.y; y++) {
+            for (let z = selection.origin.z; z < selection.origin.z + size.z; z++) {
+                if (selection.isSelected(x, y, z)) {
+                    let nx = x;
+                    let ny = y;
+                    let nz = z;
+                    const index = template.getIndex(x - selection.origin.x, y - selection.origin.y, z - selection.origin.z);
+                    while (true) {
+                        nx -= normal.x;
+                        ny -= normal.y;
+                        nz -= normal.z;
+                        if (!selection.isSelected(nx, ny, nz)) {
+                            const voxel = cursor.getVoxel(nx, ny, nz);
+                            if (!voxel || voxel.isAir())
+                                break;
+                            template.ids[index] = voxel.ids[voxel._index];
+                            template.level[index] = voxel.level[voxel._index];
+                            template.secondary[index] = voxel.secondary[voxel._index];
+                            break;
+                        }
+                        if (x < selection.origin.x || x >= selection.origin.x + size.x)
+                            continue;
+                        if (y < selection.origin.y || y >= selection.origin.y + size.y)
+                            continue;
+                        if (z < selection.origin.z || z >= selection.origin.z + size.z)
+                            continue;
+                        const nIndex = template.getIndex(nx - selection.origin.x, ny - selection.origin.y, nz - selection.origin.z);
+                        if (!template.isAir(nIndex)) {
+                            template.ids[index] = template.ids[nIndex];
+                            template.level[index] = template.level[nIndex];
+                            template.secondary[index] = template.secondary[nIndex];
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return template;
+}

package/Templates/Functions/FillSelection.d.ts

@@ -0,0 +1,4 @@
+import { IVoxelSelection } from "../Selection/VoxelSelection";
+import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
+import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
+export declare function FillSelection(voxel: PaintVoxelData, selection: IVoxelSelection): FullVoxelTemplate;

package/Templates/Functions/FillSelection.js

@@ -0,0 +1,20 @@
+import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
+import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
+export function FillSelection(voxel, selection) {
+    const size = selection.bounds.size;
+    const template = new FullVoxelTemplate(FullVoxelTemplate.CreateNew([size.x, size.y, size.z]));
+    const raw = PaintVoxelData.ToRaw(voxel);
+    for (let x = selection.origin.x; x < selection.origin.x + size.x; x++) {
+        for (let y = selection.origin.y; y < selection.origin.y + size.y; y++) {
+            for (let z = selection.origin.z; z < selection.origin.z + size.z; z++) {
+                if (selection.isSelected(x, y, z)) {
+                    const index = template.getIndex(x - selection.origin.x, y - selection.origin.y, z - selection.origin.z);
+                    template.ids[index] = raw[0];
+                    template.level[index] = raw[2];
+                    template.secondary[index] = raw[3];
+                }
+            }
+        }
+    }
+    return template;
+}

package/Templates/Functions/FlipTemplate.d.ts

@@ -1,3 +1,3 @@
+import { Vector3Axes } from "@amodx/math";
 import { FullVoxelTemplate } from "../../Templates/Full/FullVoxelTemplate";
-export type TemplateFlipDirections = "x" | "z" | "y";
-export default function FlipTemplate(template: FullVoxelTemplate, direction: TemplateFlipDirections): void;
+export default function FlipTemplate(template: FullVoxelTemplate, axes: Vector3Axes): void;

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.d.ts

@@ -12,6 +12,7 @@ export declare class VoxelPathSegment extends TypedEventTarget<VoxelPathSegments
     start: Vec3Array;
     end: Vec3Array;
     voxel: PaintVoxelData;
+    transient: boolean;
     constructor(path: VoxelPath, index: number, data: VoxelPathSegmentData);
     setPoints([sx, sy, sz]: Vec3Array, [ex, ey, ez]: Vec3Array): void;
     getPoint(point: 0 | 1): Vec3Array;
@@ -27,6 +28,9 @@ export declare class VoxelPath extends TypedEventTarget<VoxelPathEvents> {
     static CreateNew(data: Partial<VoxelPathData>): VoxelPathData;
     segments: VoxelPathSegment[];
     constructor(data: VoxelPathData);
+    get totalSegments(): number;
+    lastSegment(): VoxelPathSegment | null;
+    firstSegment(): VoxelPathSegment | null;
     addSegment(data: VoxelPathSegmentData): boolean;
     removeSegment(segment: VoxelPathSegment): boolean;
     removePoint(segmentIndex: number, pointIndex: 0 | 1): false | undefined;

package/Templates/Path/VoxelPath.js

@@ -8,11 +8,13 @@ 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;
     end;
     voxel;
+    transient = false;
     constructor(path, index, data) {
         super();
         this.path = path;
@@ -20,6 +22,7 @@ export class VoxelPathSegment extends TypedEventTarget {
         this.start = data.start;
         this.end = data.end;
         this.voxel = data.voxel;
+        this.transient = data.transient || false;
     }
     setPoints([sx, sy, sz], [ex, ey, ez]) {
         let updated = false;
@@ -60,6 +63,7 @@ export class VoxelPathSegment extends TypedEventTarget {
             start: [...this.start],
             end: [...this.end],
             voxel: { ...this.voxel },
+            ...(this.transient ? { transient: true } : {}),
         };
     }
 }
@@ -78,6 +82,19 @@ export class VoxelPath extends TypedEventTarget {
             this.segments.push(new VoxelPathSegment(this, i, data.segments[i]));
         }
     }
+    get totalSegments() {
+        return this.segments.length;
+    }
+    lastSegment() {
+        if (!this.segments.length)
+            return null;
+        return this.segments[(this.totalSegments - 1) % this.totalSegments];
+    }
+    firstSegment() {
+        if (!this.segments.length)
+            return null;
+        return this.segments[0];
+    }
     addSegment(data) {
         const segment = new VoxelPathSegment(this, this.segments.length, data);
         this.segments.push(segment);
@@ -88,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/Path/VoxelPath.types.d.ts

@@ -4,6 +4,7 @@ export type VoxelPathSegmentData = {
     start: Vec3Array;
     end: Vec3Array;
     voxel: PaintVoxelData;
+    transient?: boolean;
 };
 export type VoxelPathData = {
     segments: VoxelPathSegmentData[];

package/Templates/Selection/VoxelBFSSelection.d.ts

@@ -1,20 +1,20 @@
 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";
-export interface VoxelBFSSelectionData {
-    origin: Vector3Like;
-    size: Vector3Like;
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+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;
     isSelected(x: number, y: number, z: number): boolean;
     reConstruct(cursor: DataCursorInterface, position: Vector3Like, maxSize?: number): false | undefined;
     toTemplate(cursor: DataCursorInterface): FullVoxelTemplate;
+    clone(): VoxelBFSSelection;
     toJSON(): VoxelBFSSelectionData;
     fromJSON(data: VoxelBFSSelectionData): void;
 }

package/Templates/Selection/VoxelBFSSelection.js

@@ -2,17 +2,14 @@ import { Flat3DIndex, Vector3Like } from "@amodx/math";
 import { CardinalNeighbors3D } from "../../Math/CardinalNeighbors";
 import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BinaryArrays";
 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);
     }
@@ -78,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);
@@ -110,10 +106,19 @@ export class VoxelBFSSelection {
         }
         return template;
     }
+    clone() {
+        const newSelection = new VoxelBFSSelection();
+        Vector3Like.Copy(newSelection.origin, this.origin);
+        newSelection.bounds.setMinMax(this.bounds.min, this.bounds.max);
+        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(),
         };
     }
@@ -121,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/VoxelBoundsSelection.d.ts

@@ -0,0 +1,20 @@
+import { Vector3Like } from "@amodx/math";
+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 interface VoxelBoundsSelectionData extends IVoxelSelectionData<"bounds"> {
+}
+export declare class VoxelBoundsSelection implements IVoxelSelection<"bounds", VoxelBoundsSelectionData> {
+    origin: Vector3Like;
+    end: Vector3Like;
+    bounds: BoundingBox;
+    isSelected(x: number, y: number, z: number): boolean;
+    reConstruct(startPosition: Vector3Like, startNormal: Vector3Like, endPosition: Vector3Like, endNormal: Vector3Like, offset?: number): void;
+    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,7 @@
 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) {
         throw new Error("At least one point is required to calculate min/max.");
@@ -21,16 +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;
     }
@@ -76,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];
@@ -87,19 +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 VoxelBoundsSelection();
+        Vector3Like.Copy(newSelection.origin, this.origin);
+        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

@@ -0,0 +1,19 @@
+import { Vector3Like } from "@amodx/math";
+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 interface VoxelPointSelectionData extends IVoxelSelectionData<"point"> {
+}
+export declare class VoxelPointSelection implements IVoxelSelection<"point", VoxelPointSelectionData> {
+    origin: Vector3Like;
+    bounds: BoundingBox;
+    isSelected(x: number, y: number, z: number): boolean;
+    reConstruct(position: Vector3Like): void;
+    clone(): VoxelPointSelection;
+    toTemplate(data?: Partial<IVoxelshapeTemplateBaseData>): VoxelShapeTemplate;
+    toExtrudedTemplate(cursor: DataCursorInterface, normal: Vector3Like): void;
+    toJSON(): VoxelPointSelectionData;
+    fromJSON(data: any): void;
+}

package/Templates/Selection/VoxelPointSelection.js

@@ -0,0 +1,49 @@
+import { Vector3Like } from "@amodx/math";
+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();
+    bounds = new BoundingBox();
+    isSelected(x, y, z) {
+        if (!this.bounds.intersectsXYZ(x + 0.5, y + 0.5, z + 0.5))
+            return false;
+        return true;
+    }
+    reConstruct(position) {
+        this.origin.x = position.x;
+        this.origin.y = position.y;
+        this.origin.z = position.z;
+        this.bounds.setMinMax(this.origin, Vector3Like.AddScalar(this.origin, 1));
+    }
+    clone() {
+        const newSelection = new VoxelPointSelection();
+        Vector3Like.Copy(newSelection.origin, this.origin);
+        newSelection.bounds.setMinMax(this.bounds.min, this.bounds.max);
+        return newSelection;
+    }
+    toTemplate(data) {
+        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/VoxelSelection.js

@@ -0,0 +1 @@
+export {};