@divinevoxel/vlox 0.0.75 → 0.0.76

package/Contexts/Render/DivineVoxelEngineRender.d.ts

@@ -31,26 +31,26 @@ export declare class DivineVoxelEngineRender {
         getSettingsCopy(): any;
         createEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null): EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null;
         addEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null, options?: AddEventListenerOptions): void;
         removeEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null): void;
         dispatch<K extends "synced">(type: K, detail: {
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]): boolean;
         dispatchEvent(event: Event): boolean;

package/Contexts/World/DivineVoxelEngineWorld.d.ts

@@ -22,26 +22,26 @@ export declare class DivineVoxelEngineWorld {
         getSettingsCopy(): any;
         createEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null): EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null;
         addEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null, options?: AddEventListenerOptions): void;
         removeEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]>) => void) | null): void;
         dispatch<K extends "synced">(type: K, detail: {
             synced: {
-                settings: any;
+                settings: /*elided*/ any;
             };
         }[K]): boolean;
         dispatchEvent(event: Event): boolean;

package/Mesher/Functions/Base/MeshSectionBase.js

@@ -12,6 +12,9 @@ const bvhTool = new VoxelMeshBVHBuilder();
 function meshVoxel(x, y, z, voxel, worldCursor, sectionCursor) {
     let added = false;
     const constructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getVoxelId()];
+    constructor.schema.dataCursor = worldCursor;
+    constructor.schema.dataCursor = worldCursor;
+    constructor.schema.voxel = voxel;
     const builder = constructor.builder;
     builder.origin.x = sectionCursor._voxelPosition.x;
     builder.origin.y = sectionCursor._voxelPosition.y;

package/Mesher/Functions/MeshVoxel.js

@@ -19,6 +19,8 @@ export function MeshVoxel(rawVoxelData) {
     if (!constructor) {
         throw new Error(`Could not find constructor for voxel [id:${voxel.getStringId()} name:${voxel.getName()}] `);
     }
+    constructor.schema.dataCursor = templateCursor;
+    constructor.schema.voxel = voxel;
     const builder = constructor.builder;
     if (!builder) {
         console.error(builder, constructor.id, constructor);

package/Mesher/Geomtry/VoxelMeshBVHBuilder.d.ts

@@ -4,9 +4,9 @@ import { FlatBinaryTreeIndex } from "../../Util/FlatBinaryTreeIndex";
 export declare class VoxelMeshBVHBuilder {
     static AABBStructByteSize: number;
     treeIndex: FlatBinaryTreeIndex;
-    tree: Float32Array;
+    tree: Float32Array<ArrayBuffer>;
     structCursor: VoxelMeshBVHStructCursor;
-    indices: Uint32Array;
+    indices: Uint32Array<ArrayBuffer>;
     reset(): void;
     getMeshBounds(): {
         min: Vec3Array;

package/Mesher/Models/Common/Calc/CalcConstants.d.ts

@@ -2,7 +2,7 @@ import { QuadVerticies } from "../../../Geomtry/Geometry.types";
 import { VoxelFaces } from "../../../../Math";
 import { Vec4Array } from "@amodx/math";
 export declare const GradientCheckSets: Record<VoxelFaces, Record<QuadVerticies, number[]>>;
-export declare const GradientCheckSetsArray: Int8Array;
+export declare const GradientCheckSetsArray: Int8Array<ArrayBuffer>;
 export declare const GeometryCheckSetIndexes: Record<VoxelFaces, Record<QuadVerticies, [number, number, number]>>;
 export declare const CenterDirectionIndex: number;
 export declare const DirectionIndexes: Record<VoxelFaces, number>;

package/Mesher/Models/Procedures/Default/OutlinedTextureProcedure.js

@@ -72,32 +72,32 @@ const topAndDown = {
     west: [[-1, 0, 0]],
 };
 const eastAndWest = {
-    top: [
+    north: [
         [0, 1, 0],
         [0, 1, 1],
         [0, 1, -1],
     ],
-    bottom: [
+    south: [
         [0, -1, 0],
         [0, -1, 1],
         [0, -1, -1],
     ],
-    right: [[0, 0, 1]],
-    left: [[0, 0, -1]],
+    east: [[0, 0, 1]],
+    west: [[0, 0, -1]],
 };
 const northAndSouth = {
-    top: [
+    north: [
         [0, 1, 0],
         [1, 1, 0],
         [-1, 1, 0],
     ],
-    bottom: [
+    south: [
         [0, -1, 0],
         [1, -1, 0],
         [-1, -1, 0],
     ],
-    right: [[1, 0, 0]],
-    left: [[-1, 0, 0]],
+    east: [[1, 0, 0]],
+    west: [[-1, 0, 0]],
 };
 const CheckSets = {
     [VoxelFaces.Up]: topAndDown,

package/Tasks/Paint/Erase/EraseVoxel.js

@@ -17,7 +17,7 @@ export function EraseVoxel(location, updateData) {
     voxel.secondary[voxel._index] = 0;
     voxel.light[voxel._index] = 0;
     voxel.updateVoxel(1);
-    updateArea(tasks, x, y, z, x, y, z);
+    updateArea(tasks, x - 1, y - 1, z - 1, x + 1, y + 1, z + 1);
     voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (ES.doPower) {
         if (foundPower > -1) {

package/Tasks/Paint/Paint/PaintVoxel.js

@@ -15,7 +15,7 @@ export function PaintVoxel(location, raw, updateData) {
     voxel = tasks.sDataCursor.getVoxel(x, y, z);
     voxel.setRaw(raw);
     voxel.updateVoxel(0);
-    updateArea(tasks, x, y, z, x, y, z);
+    updateArea(tasks, x - 1, y - 1, z - 1, x + 1, y + 1, z + 1);
     if (ES.doPower) {
         if (voxel.tags["dve_can_be_powered"] ||
             voxel.tags["dve_is_power_source"] ||

package/Templates/Archive/ArchivedVoxelTemplate.d.ts

@@ -31,6 +31,7 @@ export declare class ArchivedVoxelTemplate implements IVoxelTemplate {
     getLight(index: number): number;
     getSecondary(index: number): number;
     traverse(curosr?: TemplateCursor): Generator<TemplateCursor>;
+    clone(): ArchivedVoxelTemplate;
     getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
     toJSON(): ArchivedVoxelTemplateData;
 }

package/Templates/Archive/ArchivedVoxelTemplate.js

@@ -111,6 +111,10 @@ export class ArchivedVoxelTemplate {
             }
         }
     }
+    clone() {
+        const newTemplate = new ArchivedVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
     getRaw(index, rawRef = [0, 0, 0, 0]) {
         rawRef[0] = this.getId(index);
         rawRef[1] = this.getLight(index);

package/Templates/Archive/Functions/CreateArchivedTemplate.js

@@ -147,14 +147,16 @@ export default function CreateArchivedTemplate(dataCursor, bounds) {
     const palettes = {
         ...voxelPalette.toJSON(),
     };
-    if (!(levelPalette.size == 1 && levelPalette._palette[0] === 0)) {
+    if (levelPalette.size > 0 &&
+        !(levelPalette.size == 1 && levelPalette._palette[0] === 0)) {
         palettes.level = BinaryBuffer.Create({
             format: BinaryBufferFormat.Uint8,
             byteLength: levelPalette._palette.length,
             buffer: Uint8Array.from(levelPalette._palette).buffer,
         });
     }
-    if (!(secondaryPalette.size == 1 && secondaryPalette._palette[0] === 0)) {
+    if (secondaryPalette.size > 0 &&
+        !(secondaryPalette.size == 1 && secondaryPalette._palette[0] === 0)) {
         palettes.secondary = BinaryBuffer.Create({
             format: BinaryBufferFormat.Uint16,
             byteLength: secondaryPalette._palette.length,

package/Templates/Cursor/TemplateCursor.js

@@ -5,7 +5,9 @@ export class TemplateCursor {
     _proxy = null;
     voxel = new TemplateVoxelCursor(this);
     inBounds(x, y, z) {
-        return true;
+        if (!this._proxy)
+            return false;
+        return this._proxy.inBounds(x, y, z);
     }
     setTemplate(template) {
         this._proxy = new TemplateProxy(template);

package/Templates/Cursor/TemplateProxy.d.ts

@@ -7,4 +7,5 @@ export declare class TemplateProxy {
     secondary: NumberArray;
     light: NumberArray;
     constructor(template: IVoxelTemplate);
+    inBounds(x: number, y: number, z: number): boolean;
 }

package/Templates/Cursor/TemplateProxy.js

@@ -1,3 +1,5 @@
+import { Vector3Like } from "@amodx/math";
+const point = Vector3Like.Create();
 export class TemplateProxy {
     template;
     ids;
@@ -19,4 +21,16 @@ export class TemplateProxy {
             get: (_, index) => this.template.getSecondary(Number(index)),
         });
     }
+    inBounds(x, y, z) {
+        point.x = x;
+        point.y = y;
+        point.z = z;
+        const inBounds = this.template.bounds.intersectsPoint(point);
+        if (!inBounds)
+            return false;
+        const index = this.template.getIndex(x, y, z);
+        if (!this.template.isIncluded(index))
+            return false;
+        return true;
+    }
 }

package/Templates/Full/FullVoxelTemplate.d.ts

@@ -23,5 +23,6 @@ export declare class FullVoxelTemplate implements IVoxelTemplate {
     getLevel(index: number): number;
     getSecondary(index: number): number;
     getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
+    clone(): FullVoxelTemplate;
     toJSON(): FullVoxelTemplateData;
 }

package/Templates/Full/FullVoxelTemplate.js

@@ -93,6 +93,10 @@ export class FullVoxelTemplate {
         rawRef[3] = this.getSecondary(index);
         return rawRef;
     }
+    clone() {
+        const newTemplate = new FullVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
     toJSON() {
         return {
             type: "full",

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

@@ -13,6 +13,7 @@ export class VoxelPathSegment extends TypedEventTarget {
     start;
     end;
     voxel;
+    transient = false;
     constructor(path, index, data) {
         super();
         this.path = path;
@@ -20,6 +21,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;
@@ -36,6 +38,7 @@ export class VoxelPathSegment extends TypedEventTarget {
         this.end[1] = ey;
         this.end[2] = ez;
         if (updated) {
+            console.warn("UPDATED");
             this.dispatch("updated", {});
         }
     }
@@ -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);

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

@@ -2,6 +2,7 @@ import { Flat3DIndex, Vector3Like } from "@amodx/math";
 import { IVoxelSelection } from "./VoxelSelecton";
 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;
@@ -12,9 +13,11 @@ export declare class VoxelBFSSelection implements IVoxelSelection, VoxelBFSSelec
     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,11 +2,13 @@ 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;
@@ -110,6 +112,15 @@ export class VoxelBFSSelection {
         }
         return template;
     }
+    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.index.setBounds(...this.index.getBounds());
+        return newSelection;
+    }
     toJSON() {
         return {
             origin: { ...this.origin },

package/Templates/Selection/VoxelBoxSelection.d.ts

@@ -3,12 +3,15 @@ import { IVoxelSelection } from "./VoxelSelecton";
 import { BoxVoxelTemplate } from "../Shapes/BoxVoxelTemplate";
 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 {
     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;
     toExtrudedTemplate(cursor: DataCursorInterface, normal: Vector3Like): void;
 }

package/Templates/Selection/VoxelBoxSelection.js

@@ -1,5 +1,6 @@
 import { Vec3ArrayLike, Vector3Like } from "@amodx/math";
 import { BoxVoxelTemplate } from "../Shapes/BoxVoxelTemplate";
+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.");
@@ -25,6 +26,7 @@ export class VoxelBoxSelection {
     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;
@@ -91,6 +93,15 @@ export class VoxelBoxSelection {
             this.size.y = finalSize[1];
             this.size.z = finalSize[2];
         }
+        this.bounds.setMinMax(this.origin, this.end);
+    }
+    clone() {
+        const newSelection = new VoxelBoxSelection();
+        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({

package/Templates/Selection/VoxelPointSelection.d.ts

@@ -0,0 +1,17 @@
+import { Vector3Like } from "@amodx/math";
+import { IVoxelSelection } from "./VoxelSelecton";
+import { BoxVoxelTemplate } from "../Shapes/BoxVoxelTemplate";
+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 {
+    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;
+    toExtrudedTemplate(cursor: DataCursorInterface, normal: Vector3Like): void;
+}

package/Templates/Selection/VoxelPointSelection.js

@@ -0,0 +1,48 @@
+import { Vector3Like } from "@amodx/math";
+import { BoxVoxelTemplate } from "../Shapes/BoxVoxelTemplate";
+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)
+            return false;
+        return true;
+    }
+    reConstruct(position) {
+        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);
+    }
+    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);
+    }
+    toExtrudedTemplate(cursor, normal) { }
+}

package/Templates/Selection/VoxelSelecton.d.ts

@@ -1,6 +1,9 @@
 import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export interface IVoxelSelection {
     origin: Vector3Like;
     size: Vector3Like;
+    bounds: BoundingBox;
     isSelected(x: number, y: number, z: number): boolean;
+    clone(): IVoxelSelection;
 }

package/Templates/Selection/VoxelSurfaceSelection.d.ts

@@ -3,6 +3,7 @@ import { IVoxelSelection } from "./VoxelSelecton";
 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;
@@ -16,9 +17,11 @@ export declare class VoxelSurfaceSelection implements IVoxelSelection, VoxelSurf
     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;
+    clone(): VoxelSurfaceSelection;
     toTemplate(cursor: DataCursorInterface, voxelOrExtrude: PaintVoxelData | true): FullVoxelTemplate;
     toTemplate(cursor: DataCursorInterface, extrude: true): FullVoxelTemplate;
     toTemplate(cursor: DataCursorInterface, voxel: PaintVoxelData): FullVoxelTemplate;

package/Templates/Selection/VoxelSurfaceSelection.js

@@ -3,12 +3,14 @@ import { CardinalNeighbors2D } from "../../Math/CardinalNeighbors";
 import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BinaryArrays";
 import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
 import { FullVoxelTemplate } from "../Full/FullVoxelTemplate";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export class VoxelSurfaceSelection {
     origin = Vector3Like.Create();
     size = Vector3Like.Create();
     normal = Vector3Like.Create();
     bitIndex;
     index = Flat3DIndex.GetXZYOrder();
+    bounds = new BoundingBox();
     extrusion = 0;
     isSelected(x, y, z) {
         if (x < this.origin.x || x >= this.origin.x + this.size.x)
@@ -113,6 +115,22 @@ export class VoxelSurfaceSelection {
         this.origin.x = min.x;
         this.origin.y = min.y;
         this.origin.z = min.z;
+        this.bounds.setMinMax(this.origin, {
+            x: this.origin.x + this.size.x,
+            y: this.origin.y + this.size.y,
+            z: this.origin.z + this.size.z,
+        });
+    }
+    clone() {
+        const newSelection = new VoxelSurfaceSelection();
+        Vector3Like.Copy(newSelection.origin, this.origin);
+        Vector3Like.Copy(newSelection.size, this.size);
+        newSelection.bounds.setMinMax(this.bounds.min, this.bounds.max);
+        newSelection.extrusion = this.extrusion;
+        newSelection.bitIndex = structuredClone(this.bitIndex);
+        newSelection.index.setBounds(...this.index.getBounds());
+        newSelection.bounds.setMinMax(this.bounds.min, this.bounds.max);
+        return newSelection;
     }
     toTemplate(cursor, voxelOrExtrude) {
         let extrude = false;

package/Templates/Selection/VoxelTemplateSelection.d.ts

@@ -1,10 +1,13 @@
 import { Vector3Like } from "@amodx/math";
 import { IVoxelSelection } from "./VoxelSelecton";
 import { IVoxelTemplate } from "../VoxelTemplates.types";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export declare class VoxelTemplateSelection implements IVoxelSelection {
     origin: Vector3Like;
     size: Vector3Like;
+    bounds: BoundingBox;
     template: IVoxelTemplate;
     isSelected(x: number, y: number, z: number): boolean;
+    clone(): VoxelTemplateSelection;
     setTemplate(template: IVoxelTemplate): void;
 }

package/Templates/Selection/VoxelTemplateSelection.js

@@ -1,7 +1,9 @@
 import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export class VoxelTemplateSelection {
     origin = Vector3Like.Create();
     size = Vector3Like.Create();
+    bounds = new BoundingBox();
     template;
     isSelected(x, y, z) {
         if (x < this.origin.x || x >= this.origin.x + this.size.x)
@@ -17,6 +19,14 @@ export class VoxelTemplateSelection {
             return false;
         return true;
     }
+    clone() {
+        const newSelection = new VoxelTemplateSelection();
+        Vector3Like.Copy(newSelection.origin, this.origin);
+        Vector3Like.Copy(newSelection.size, this.size);
+        newSelection.bounds.setMinMax(this.bounds.min, this.bounds.max);
+        newSelection.template = this.template.clone();
+        return newSelection;
+    }
     setTemplate(template) {
         this.template = template;
         this.size.x = template.bounds.size.x;

package/Templates/Shapes/BasicVoxelShapeTemplate.d.ts

@@ -23,6 +23,7 @@ export declare abstract class BasicVoxelShapeTemplate<Type extends string, Data
     getIndex(x: number, y: number, z: number): number;
     setPosition(x: number, y: number, z: number): void;
     abstract isIncluded(index: number): boolean;
+    abstract clone(): BasicVoxelShapeTemplate<Type, Data, Events>;
     isAir(index: number): boolean;
     getId(index: number): number;
     getLight(index: number): number;

package/Templates/Shapes/BoxVoxelTemplate.d.ts

@@ -18,5 +18,6 @@ export declare class BoxVoxelTemplate extends BasicVoxelShapeTemplate<"box-shape
     set depth(depth: number);
     constructor(data: BoxVoxelTemplateData);
     isIncluded(index: number): boolean;
+    clone(): BoxVoxelTemplate;
     toJSON(): BoxVoxelTemplateData;
 }