@divinevoxel/vlox 0.0.74 → 0.0.76

package/Templates/Selection/VoxelBFSSelection.js

@@ -0,0 +1,141 @@
+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)
+            return false;
+        return (getBitArrayIndex(this.bitIndex, this.index.getIndexXYZ(x - this.origin.x, y - this.origin.y, z - this.origin.z)) === 1);
+    }
+    reConstruct(cursor, position, maxSize = 1000) {
+        const min = Vector3Like.Create(Infinity, Infinity, Infinity);
+        const max = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
+        const voxelId = cursor.getVoxel(position.x, position.y, position.z)?.getVoxelId() || 0;
+        if (!voxelId)
+            return false;
+        const queue = [position.x, position.y, position.z];
+        let size = 0;
+        const visited = new Set();
+        while (queue.length) {
+            if (size > maxSize)
+                break;
+            const x = queue.shift();
+            const y = queue.shift();
+            const z = queue.shift();
+            const key = `${x}-${y}-${z}`;
+            if (visited.has(key))
+                continue;
+            visited.add(key);
+            if (x < min.x)
+                min.x = x;
+            if (y < min.y)
+                min.y = y;
+            if (z < min.z)
+                min.z = z;
+            if (x > max.x)
+                max.x = x;
+            if (y > max.y)
+                max.y = y;
+            if (z > max.z)
+                max.z = z;
+            for (let i = 0; i < CardinalNeighbors3D.length; i++) {
+                const n = CardinalNeighbors3D[i];
+                let nx = x + n[0];
+                let ny = y + n[1];
+                let nz = z + n[2];
+                const voxel = cursor.getVoxel(nx, ny, nz);
+                if (!voxel || voxel.getVoxelId() != voxelId)
+                    continue;
+                queue.push(nx, ny, nz);
+            }
+            size++;
+        }
+        if (min.x == Infinity || min.y == Infinity || min.z == Infinity)
+            return false;
+        if (max.x == -Infinity || max.y == -Infinity || max.z == -Infinity)
+            return false;
+        const sizeX = max.x - min.x + 1;
+        const sizeY = max.y - min.y + 1;
+        const sizeZ = max.z - min.z + 1;
+        this.index.setBounds(sizeX, sizeY, sizeZ);
+        this.bitIndex = new Uint8Array(Math.ceil((sizeX * sizeY * sizeZ) / 8));
+        for (let x = min.x; x < min.x + sizeX; x++) {
+            for (let y = min.y; y < min.y + sizeY; y++) {
+                for (let z = min.z; z < min.z + sizeZ; z++) {
+                    const key = `${x}-${y}-${z}`;
+                    if (!visited.has(key))
+                        continue;
+                    setBitArrayIndex(this.bitIndex, this.index.getIndexXYZ(x - min.x, y - min.y, z - min.z), 1);
+                }
+            }
+        }
+        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;
+    }
+    toTemplate(cursor) {
+        const templateData = FullVoxelTemplate.CreateNew([
+            this.size.x,
+            this.size.y,
+            this.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++) {
+                    if (!this.isSelected(x, y, z))
+                        continue;
+                    const voxel = cursor.getVoxel(x, y, z);
+                    if (!voxel || voxel.isAir())
+                        continue;
+                    const index = template.getIndex(x - this.origin.x, y - this.origin.y, z - this.origin.z);
+                    template.ids[index] = voxel.ids[voxel._index];
+                    template.level[index] = voxel.level[voxel._index];
+                    template.secondary[index] = voxel.secondary[voxel._index];
+                }
+            }
+        }
+        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 },
+            size: { ...this.size },
+            bitIndex: this.bitIndex.slice(),
+        };
+    }
+    fromJSON(data) {
+        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);
+    }
+}

package/Templates/Selection/VoxelBoxSelection.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 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

@@ -0,0 +1,116 @@
+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.");
+    }
+    let min = [...points[0]];
+    let max = [...points[0]];
+    for (const point of points) {
+        for (let i = 0; i < 3; i++) {
+            if (point[i] < min[i]) {
+                min[i] = point[i];
+            }
+            if (point[i] > max[i]) {
+                max[i] = point[i];
+            }
+        }
+    }
+    return [min, max];
+};
+const getSize = (start, end) => {
+    return Vector3Like.Create(end.x - start.x, end.y - start.y, end.z - start.z);
+};
+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;
+        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(startPosition, startNormal, endPosition, endNormal, offset = 0) {
+        const size = getSize(startPosition, endPosition);
+        const point1 = [
+            startPosition.x,
+            startPosition.y,
+            startPosition.z,
+        ];
+        const point2 = Vec3ArrayLike.Add(point1, [
+            size.x || 1,
+            size.y || 1,
+            size.z || 1,
+        ]);
+        const minPoint = [
+            Math.min(point1[0], point2[0]),
+            Math.min(point1[1], point2[1]),
+            Math.min(point1[2], point2[2]),
+        ];
+        const maxPoint = [
+            Math.max(point1[0], point2[0]),
+            Math.max(point1[1], point2[1]),
+            Math.max(point1[2], point2[2]),
+        ];
+        if (size.x < 0)
+            maxPoint[0] += 1;
+        if (size.y < 0)
+            maxPoint[1] += 1;
+        if (size.z < 0)
+            maxPoint[2] += 1;
+        const normalOffset = Vec3ArrayLike.Add([startPosition.x, startPosition.y, startPosition.z], Vec3ArrayLike.MultiplyScalar([startNormal.x, startNormal.y, startNormal.z], offset));
+        const [finalMin, finalMax] = getMinMax(minPoint, maxPoint, normalOffset);
+        const finalSize = [
+            Math.abs(finalMax[0] - finalMin[0]),
+            Math.abs(finalMax[1] - finalMin[1]),
+            Math.abs(finalMax[2] - finalMin[2]),
+        ];
+        if (finalSize[0] == 0 && finalSize[1] == 0 && finalSize[2] == 0) {
+            this.origin.x = startPosition.x;
+            this.origin.y = startPosition.y;
+            this.origin.z = startPosition.z;
+            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];
+            this.origin.y = finalMin[1];
+            this.origin.z = finalMin[2];
+            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();
+        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/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

@@ -0,0 +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/VoxelSelecton.js

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

package/Templates/Selection/VoxelSurfaceSelection.d.ts

@@ -0,0 +1,30 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+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;
+    normal: Vector3Like;
+    bitIndex: Uint8Array;
+    extrusion: number;
+}
+export declare class VoxelSurfaceSelection implements IVoxelSelection, VoxelSurfaceSelectionData {
+    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;
+    clone(): VoxelSurfaceSelection;
+    toTemplate(cursor: DataCursorInterface, voxelOrExtrude: PaintVoxelData | true): FullVoxelTemplate;
+    toTemplate(cursor: DataCursorInterface, extrude: true): FullVoxelTemplate;
+    toTemplate(cursor: DataCursorInterface, voxel: PaintVoxelData): FullVoxelTemplate;
+    toJSON(): VoxelSurfaceSelectionData;
+    fromJSON(data: VoxelSurfaceSelectionData): void;
+}

package/Templates/Selection/VoxelSurfaceSelection.js

@@ -0,0 +1,224 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+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)
+            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)
+            return false;
+        return (getBitArrayIndex(this.bitIndex, this.index.getIndexXYZ(x - this.origin.x, y - this.origin.y, z - this.origin.z)) === 1);
+    }
+    reConstruct(cursor, position, normal, extrusion, maxSize = 1000) {
+        this.normal.x = normal.x;
+        this.normal.y = normal.y;
+        this.normal.z = normal.z;
+        let axis = "x";
+        if (normal.x)
+            axis = "x";
+        if (normal.y)
+            axis = "y";
+        if (normal.z)
+            axis = "z";
+        const min = Vector3Like.Create(Infinity, Infinity, Infinity);
+        const max = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
+        const queue = [
+            position.x + normal.x,
+            position.y + normal.y,
+            position.z + normal.z,
+        ];
+        let size = 0;
+        const visted = new Set();
+        while (queue.length) {
+            if (size > maxSize)
+                break;
+            const x = queue.shift();
+            const y = queue.shift();
+            const z = queue.shift();
+            const key = `${x}-${y}-${z}`;
+            if (visted.has(key))
+                continue;
+            visted.add(key);
+            if (x < min.x)
+                min.x = x;
+            if (y < min.y)
+                min.y = y;
+            if (z < min.z)
+                min.z = z;
+            if (x > max.x)
+                max.x = x;
+            if (y > max.y)
+                max.y = y;
+            if (z > max.z)
+                max.z = z;
+            for (let i = 0; i < CardinalNeighbors2D.length; i++) {
+                const n = CardinalNeighbors2D[i];
+                let nx = x;
+                let ny = y;
+                let nz = z;
+                if (axis == "x") {
+                    ny += n[0];
+                    nz += n[1];
+                }
+                if (axis == "y") {
+                    nx += n[0];
+                    nz += n[1];
+                }
+                if (axis == "z") {
+                    nx += n[0];
+                    ny += n[1];
+                }
+                const voxel = cursor.getVoxel(nx, ny, nz);
+                if (!voxel || !voxel.isAir())
+                    continue;
+                const bottomVoxel = cursor.getVoxel(nx - normal.x, ny - normal.y, nz - normal.z);
+                if (!bottomVoxel || bottomVoxel.isAir())
+                    continue;
+                queue.push(nx, ny, nz);
+            }
+            size++;
+        }
+        if (min.x == Infinity || min.y == Infinity || min.z == Infinity)
+            return false;
+        if (max.x == -Infinity || max.y == -Infinity || max.z == -Infinity)
+            return false;
+        const sizeX = max.x - min.x + 1;
+        const sizeY = max.y - min.y + 1;
+        const sizeZ = max.z - min.z + 1;
+        this.index.setBounds(sizeX, sizeY, sizeZ);
+        this.bitIndex = new Uint8Array(Math.ceil((sizeX * sizeY * sizeZ) / 8));
+        for (let x = min.x; x < min.x + sizeX; x++) {
+            for (let y = min.y; y < min.y + sizeY; y++) {
+                for (let z = min.z; z < min.z + sizeZ; z++) {
+                    const key = `${x}-${y}-${z}`;
+                    if (!visted.has(key))
+                        continue;
+                    setBitArrayIndex(this.bitIndex, this.index.getIndexXYZ(x - min.x, y - min.y, z - min.z), 1);
+                }
+            }
+        }
+        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 + 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;
+        let voxel = null;
+        if (typeof voxelOrExtrude == "boolean") {
+            extrude = true;
+        }
+        else {
+            voxel = voxelOrExtrude;
+        }
+        const template = new FullVoxelTemplate(FullVoxelTemplate.CreateNew([this.size.x, this.size.y, this.size.z]));
+        if (!extrude && voxel) {
+            const raw = PaintVoxelData.ToRaw(voxel);
+            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++) {
+                        if (this.isSelected(x, y, z)) {
+                            const index = template.getIndex(x - this.origin.x, y - this.origin.y, z - this.origin.z);
+                            template.ids[index] = raw[0];
+                            template.level[index] = raw[2];
+                            template.secondary[index] = raw[3];
+                        }
+                    }
+                }
+            }
+            return template;
+        }
+        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++) {
+                    if (this.isSelected(x, y, z)) {
+                        let nx = x;
+                        let ny = y;
+                        let nz = z;
+                        const index = template.getIndex(x - this.origin.x, y - this.origin.y, z - this.origin.z);
+                        while (true) {
+                            nx -= this.normal.x;
+                            ny -= this.normal.y;
+                            nz -= this.normal.z;
+                            if (!this.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 < this.origin.x || x >= this.origin.x + this.size.x)
+                                continue;
+                            if (y < this.origin.y || y >= this.origin.y + this.size.y)
+                                continue;
+                            if (z < this.origin.z || z >= this.origin.z + this.size.z)
+                                continue;
+                            const nIndex = template.getIndex(nx - this.origin.x, ny - this.origin.y, nz - this.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;
+    }
+    toJSON() {
+        return {
+            origin: { ...this.origin },
+            normal: { ...this.normal },
+            extrusion: this.extrusion,
+            bitIndex: this.bitIndex.slice(),
+            size: this.size,
+        };
+    }
+    fromJSON(data) {
+        this.origin.x = data.origin.x;
+        this.origin.y = data.origin.y;
+        this.origin.z = data.origin.z;
+        this.normal.x = data.normal.x;
+        this.normal.y = data.normal.y;
+        this.normal.z = data.normal.z;
+        this.extrusion = data.extrusion;
+        this.bitIndex = data.bitIndex;
+        this.size.x = data.size.x;
+        this.size.y = data.size.y;
+        this.size.z = data.size.z;
+        this.index.setBounds(this.size.x, this.size.y, this.size.z);
+    }
+}

package/Templates/Selection/VoxelTemplateSelection.d.ts

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

@@ -0,0 +1,36 @@
+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)
+            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)
+            return false;
+        const rx = x - this.origin.x;
+        const ry = y - this.origin.y;
+        const rz = z - this.origin.z;
+        if (!this.template.isIncluded(this.template.getIndex(rx, ry, rz)))
+            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;
+        this.size.y = template.bounds.size.y;
+        this.size.z = template.bounds.size.z;
+    }
+}