@divinevoxel/vlox 0.0.74 → 0.0.76

package/Templates/Cursor/TemplateCursor.js

@@ -1,19 +1,25 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
+import { TemplateProxy } from "./TemplateProxy";
 export class TemplateCursor {
     _voxelIndex = 0;
-    _template = null;
+    _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._template = template;
+        this._proxy = new TemplateProxy(template);
     }
     getVoxel(x, y, z) {
-        if (!this._template)
+        if (!this._proxy)
             return null;
-        this._voxelIndex = this._template.index.getIndexXYZ(x, y, z);
+        this._voxelIndex = this._proxy.template.index.getIndexXYZ(x, y, z);
         this.voxel.loadIn();
         return this.voxel;
     }
+    clone() {
+        return new TemplateCursor();
+    }
 }

package/Templates/Cursor/TemplateProxy.d.ts

@@ -0,0 +1,11 @@
+import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types";
+import { NumberArray } from "../../Util/Util.types";
+export declare class TemplateProxy {
+    template: IVoxelTemplate;
+    ids: NumberArray;
+    levels: NumberArray;
+    secondary: NumberArray;
+    light: NumberArray;
+    constructor(template: IVoxelTemplate);
+    inBounds(x: number, y: number, z: number): boolean;
+}

package/Templates/Cursor/TemplateProxy.js

@@ -0,0 +1,36 @@
+import { Vector3Like } from "@amodx/math";
+const point = Vector3Like.Create();
+export class TemplateProxy {
+    template;
+    ids;
+    levels;
+    secondary;
+    light;
+    constructor(template) {
+        this.template = template;
+        this.ids = new Proxy([], {
+            get: (_, index) => this.template.getId(Number(index)),
+        });
+        this.light = new Proxy([], {
+            get: (_, index) => this.template.getLight(Number(index)),
+        });
+        this.levels = new Proxy([], {
+            get: (_, index) => this.template.getLevel(Number(index)),
+        });
+        this.secondary = new Proxy([], {
+            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/Cursor/TemplateVoxelCursor.d.ts

@@ -2,13 +2,11 @@ import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface"
 import { TemplateCursor } from "./TemplateCursor";
 export declare class TemplateVoxelCursor extends VoxelCursorInterface {
     dataCursor: TemplateCursor;
-    private _template;
-    get ids(): Uint16Array;
-    get level(): Uint8Array;
-    get light(): Uint16Array;
-    get state(): Uint16Array;
-    get secondary(): Uint16Array;
-    get mod(): Uint16Array;
+    private _proxy;
+    get ids(): import("../../Util/Util.types").NumberArray;
+    get level(): import("../../Util/Util.types").NumberArray;
+    get light(): import("../../Util/Util.types").NumberArray;
+    get secondary(): import("../../Util/Util.types").NumberArray;
     constructor(dataCursor: TemplateCursor);
     loadIn(): void;
     updateVoxel(mode: 0 | 1): void;

package/Templates/Cursor/TemplateVoxelCursor.js

@@ -1,33 +1,27 @@
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 export class TemplateVoxelCursor extends VoxelCursorInterface {
     dataCursor;
-    _template;
+    _proxy;
     get ids() {
-        return this._template.ids;
+        return this._proxy.ids;
     }
     get level() {
-        return this._template.level;
+        return this._proxy.levels;
     }
     get light() {
-        return this._template.light;
-    }
-    get state() {
-        return this._template.state;
+        return this._proxy.light;
     }
     get secondary() {
-        return this._template.secondary;
-    }
-    get mod() {
-        return this._template.mod;
+        return this._proxy.secondary;
     }
     constructor(dataCursor) {
         super();
         this.dataCursor = dataCursor;
     }
     loadIn() {
-        if (!this.dataCursor._template)
+        if (!this.dataCursor._proxy)
             return;
-        this._template = this.dataCursor._template;
+        this._proxy = this.dataCursor._proxy;
         this._index = this.dataCursor._voxelIndex;
         this.process();
     }

package/Templates/Full/FullVoxelTemplate.d.ts

@@ -0,0 +1,28 @@
+import { Flat3DIndex, Vec3Array, Vector3Like } from "@amodx/math";
+import { IVoxelTemplate } from "../VoxelTemplates.types";
+import { FullVoxelTemplateData } from "./FullVoxelTemplate.types";
+import { RawVoxelData } from "../../Voxels/Types/Voxel.types";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export declare class FullVoxelTemplate implements IVoxelTemplate {
+    static CreateNew(bounds: Vec3Array, baseLightValue?: number): FullVoxelTemplateData;
+    index: Flat3DIndex;
+    position: Vector3Like;
+    bounds: BoundingBox;
+    ids: Uint16Array;
+    level: Uint8Array;
+    light: Uint16Array;
+    secondary: Uint16Array;
+    mask?: Uint8Array;
+    constructor(data: FullVoxelTemplateData);
+    setPosition(x: number, y: number, z: number): void;
+    isAir(index: number): boolean;
+    isIncluded(index: number): boolean;
+    getIndex(x: number, y: number, z: number): number;
+    getId(index: number): number;
+    getLight(index: number): number;
+    getLevel(index: number): number;
+    getSecondary(index: number): number;
+    getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
+    clone(): FullVoxelTemplate;
+    toJSON(): FullVoxelTemplateData;
+}

package/Templates/Full/FullVoxelTemplate.js

@@ -0,0 +1,112 @@
+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";
+export class FullVoxelTemplate {
+    static CreateNew(bounds, baseLightValue = 0) {
+        const voxelSize = bounds[0] * bounds[1] * bounds[2];
+        const bufferSize = //ids
+         voxelSize * 2 +
+            //light
+            voxelSize * 2 +
+            //secondary
+            voxelSize * 2 +
+            //level
+            voxelSize;
+        const sectionBuffer = EngineSettings.settings.memoryAndCPU.useSharedMemory
+            ? new SharedArrayBuffer(bufferSize)
+            : new ArrayBuffer(bufferSize);
+        let bufferStart = 0;
+        const ids = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const light = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        if (baseLightValue)
+            light.fill(baseLightValue);
+        const secondary = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const level = new Uint8Array(sectionBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize;
+        return {
+            type: "full",
+            position: Vector3Like.Create(),
+            bounds: Vector3Like.Create(...bounds),
+            ids,
+            light,
+            level,
+            secondary,
+        };
+    }
+    index = Flat3DIndex.GetXZYOrder();
+    position = Vector3Like.Create();
+    bounds;
+    ids;
+    level;
+    light;
+    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;
+    }
+    setPosition(x, y, z) {
+        this.position.x = x;
+        this.position.y = y;
+        this.position.z = z;
+    }
+    isAir(index) {
+        return this.ids[index] === 0;
+    }
+    isIncluded(index) {
+        if (this.mask) {
+            return getBitArrayIndex(this.mask, index) === 1;
+        }
+        return true;
+    }
+    getIndex(x, y, z) {
+        return this.index.getIndexXYZ(x, y, z);
+    }
+    getId(index) {
+        return this.ids[index];
+    }
+    getLight(index) {
+        return this.light[index];
+    }
+    getLevel(index) {
+        return this.level[index];
+    }
+    getSecondary(index) {
+        return this.secondary[index];
+    }
+    getRaw(index, rawRef = [0, 0, 0, 0]) {
+        rawRef[0] = this.getId(index);
+        rawRef[1] = this.getLight(index);
+        rawRef[2] = this.getLevel(index);
+        rawRef[3] = this.getSecondary(index);
+        return rawRef;
+    }
+    clone() {
+        const newTemplate = new FullVoxelTemplate(structuredClone(this.toJSON()));
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            type: "full",
+            position: this.position,
+            bounds: this.bounds.size,
+            ids: this.ids,
+            light: this.light,
+            level: this.level,
+            secondary: this.secondary,
+            ...(this.mask ? { mask: this.mask } : {}),
+        };
+    }
+}

package/Templates/Full/FullVoxelTemplate.types.d.ts

@@ -0,0 +1,5 @@
+import { VoxelDataArrays } from "../../Voxels";
+import { IVoxelTemplateData } from "../VoxelTemplates.types";
+export interface FullVoxelTemplateData extends IVoxelTemplateData<"full">, VoxelDataArrays {
+    mask?: Uint8Array;
+}

package/Templates/Full/FullVoxelTemplate.types.js

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

package/Templates/Full/Functions/CreateFullTemplate.d.ts

@@ -0,0 +1,3 @@
+import { BoundsMinMaxData } from "@amodx/math/Geomtry/Bounds/BoundsInterface";
+import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface";
+export default function CreateFullTemplate(dataCursor: DataCursorInterface, bounds: BoundsMinMaxData, storeLight?: boolean): import("../FullVoxelTemplate.types").FullVoxelTemplateData;

package/Templates/Full/Functions/CreateFullTemplate.js

@@ -0,0 +1,27 @@
+import { FullVoxelTemplate } from "../FullVoxelTemplate";
+import { Flat3DIndex } from "@amodx/math";
+export default function CreateFullTemplate(dataCursor, bounds, storeLight = false) {
+    const { x: sx, y: sy, z: sz } = bounds.min;
+    const { x: ex, y: ey, z: ez } = bounds.max;
+    const template = FullVoxelTemplate.CreateNew([ex - sx, ey - sy, ez - sz]);
+    const index = Flat3DIndex.GetXZYOrder();
+    index.setBounds(template.bounds.x, template.bounds.y, template.bounds.z);
+    for (let x = sx; x < ex; x++) {
+        for (let y = sy; y < ey; y++) {
+            for (let z = sz; z < ez; z++) {
+                if (!dataCursor.inBounds(x, y, z))
+                    continue;
+                const voxel = dataCursor.getVoxel(x, y, z);
+                if (!voxel)
+                    continue;
+                const vIndex = index.getIndexXYZ(x - sx, y - sy, z - sz);
+                template.ids[vIndex] = voxel.ids[voxel._index];
+                template.level[vIndex] = voxel.level[voxel._index];
+                template.secondary[vIndex] = voxel.secondary[voxel._index];
+                if (storeLight)
+                    template.light[vIndex] = voxel.light[voxel._index];
+            }
+        }
+    }
+    return template;
+}

package/Templates/Functions/FlipTemplate.d.ts

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

package/Templates/Functions/FlipTemplate.js

@@ -25,7 +25,7 @@ const flipArray = ([sizeX, sizeY, sizeZ], array, direction, index) => {
     }
 };
 export default function FlipTemplate(template, direction) {
-    const [sizeX, sizeY, sizeZ] = template.size;
+    const { x: sizeX, y: sizeY, z: sizeZ } = template.bounds.size;
     const index = Flat3DIndex.GetXZYOrder();
     index.setBounds(sizeX, sizeY, sizeZ);
     if (typeof template.ids === "object") {
@@ -36,14 +36,6 @@ export default function FlipTemplate(template, direction) {
         const level = template.level;
         flipArray([sizeX, sizeY, sizeZ], level, direction, index);
     }
-    if (typeof template.state === "object") {
-        const state = template.state;
-        flipArray([sizeX, sizeY, sizeZ], state, direction, index);
-    }
-    if (typeof template.mod === "object") {
-        const mod = template.mod;
-        flipArray([sizeX, sizeY, sizeZ], mod, direction, index);
-    }
     if (typeof template.secondary === "object") {
         const secondary = template.secondary;
         flipArray([sizeX, sizeY, sizeZ], secondary, direction, index);

package/Templates/Functions/RotateTemplate.d.ts

@@ -1,4 +1,4 @@
-import { VoxelTemplate } from "../VoxelTemplate";
+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: VoxelTemplate, angle: TemplateRotationAngles, axes?: TemplateRotationAxes): void;
+export default function RotateTemplate(template: FullVoxelTemplate, angle: TemplateRotationAngles, axes?: TemplateRotationAxes): void;

package/Templates/Functions/RotateTemplate.js

@@ -66,7 +66,7 @@ const rotateArray = ([sizeX, sizeY, sizeZ], array, angle, axes, index, newIndex)
     }
 };
 export default function RotateTemplate(template, angle, axes = "y") {
-    const [sizeX, sizeY, sizeZ] = template.size;
+    const { x: sizeX, y: sizeY, z: sizeZ } = template.bounds.size;
     const index = Flat3DIndex.GetXZYOrder();
     index.setBounds(sizeX, sizeY, sizeZ);
     let newSizeX = sizeX;
@@ -97,18 +97,10 @@ export default function RotateTemplate(template, angle, axes = "y") {
         const level = template.level;
         rotateArray([sizeX, sizeY, sizeZ], level, angle, axes, index, newIndex);
     }
-    if (typeof template.state === "object") {
-        const state = template.state;
-        rotateArray([sizeX, sizeY, sizeZ], state, angle, axes, index, newIndex);
-    }
-    if (typeof template.mod === "object") {
-        const mod = template.mod;
-        rotateArray([sizeX, sizeY, sizeZ], mod, angle, axes, index, newIndex);
-    }
     if (typeof template.secondary === "object") {
         const secondary = template.secondary;
         rotateArray([sizeX, sizeY, sizeZ], secondary, angle, axes, index, newIndex);
     }
     template.index = newIndex;
-    template.size = [newSizeX, newSizeY, newSizeZ];
+    template.bounds.setSize({ x: newSizeX, y: newSizeY, z: newSizeZ });
 }

package/Templates/Functions/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./CreateTemplate";
+export * from "../Archive/Functions/CreateArchivedTemplate";
 export * from "./RotateTemplate";
 export * from "./FlipTemplate";

package/Templates/Functions/index.js

@@ -1,3 +1,3 @@
-export * from "./CreateTemplate";
+export * from "../Archive/Functions/CreateArchivedTemplate";
 export * from "./RotateTemplate";
 export * from "./FlipTemplate";

package/Templates/Path/VoxelPath.d.ts

@@ -0,0 +1,38 @@
+import { TypedEventTarget } from "../../Util/TypedEventTarget";
+import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
+import type { VoxelPathData, VoxelPathSegmentData } from "./VoxelPath.types";
+import type { Vec3Array } from "@amodx/math";
+export interface VoxelPathSegmentsEvents {
+    updated: {};
+}
+export declare class VoxelPathSegment extends TypedEventTarget<VoxelPathSegmentsEvents> implements VoxelPathSegmentData {
+    path: VoxelPath;
+    index: number;
+    static CreateNew(data: Partial<VoxelPathSegmentData>): VoxelPathSegmentData;
+    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;
+    setPoint(point: 0 | 1, vec: Vec3Array): void;
+    toJSON(): VoxelPathSegmentData;
+}
+export interface VoxelPathEvents {
+    segmentAdded: VoxelPathSegment;
+    segmentRemoved: VoxelPathSegment;
+}
+export declare class VoxelPath extends TypedEventTarget<VoxelPathEvents> {
+    data: VoxelPathData;
+    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;
+    toJSON(): VoxelPathData;
+}

package/Templates/Path/VoxelPath.js

@@ -0,0 +1,144 @@
+import { TypedEventTarget } from "../../Util/TypedEventTarget";
+import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData";
+export class VoxelPathSegment extends TypedEventTarget {
+    path;
+    index;
+    static CreateNew(data) {
+        return {
+            start: data.start ? data.start : [0, 0, 0],
+            end: data.end ? data.end : [0, 0, 0],
+            voxel: data.voxel ? data.voxel : PaintVoxelData.Create(),
+        };
+    }
+    start;
+    end;
+    voxel;
+    transient = false;
+    constructor(path, index, data) {
+        super();
+        this.path = path;
+        this.index = index;
+        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;
+        if (this.start[0] != sx || this.start[1] != sy || this.start[2] != sz) {
+            updated = true;
+        }
+        this.start[0] = sx;
+        this.start[1] = sy;
+        this.start[2] = sz;
+        if (this.end[0] != ex || this.end[1] != ey || this.end[2] != ez) {
+            updated = true;
+        }
+        this.end[0] = ex;
+        this.end[1] = ey;
+        this.end[2] = ez;
+        if (updated) {
+            console.warn("UPDATED");
+            this.dispatch("updated", {});
+        }
+    }
+    getPoint(point) {
+        if (point == 0)
+            return this.start;
+        if (point == 1)
+            return this.end;
+        throw new Error(`Point must be 0 or 1 get ${point}`);
+    }
+    setPoint(point, vec) {
+        if (point == 0) {
+            return this.setPoints(vec, this.end);
+        }
+        if (point == 1) {
+            return this.setPoints(this.start, vec);
+        }
+        throw new Error(`Point must be 0 or 1 get ${point}`);
+    }
+    toJSON() {
+        return {
+            start: [...this.start],
+            end: [...this.end],
+            voxel: { ...this.voxel },
+            ...(this.transient ? { transient: true } : {}),
+        };
+    }
+}
+export class VoxelPath extends TypedEventTarget {
+    data;
+    static CreateNew(data) {
+        return {
+            segments: data.segments ? data.segments : [],
+        };
+    }
+    segments = [];
+    constructor(data) {
+        super();
+        this.data = data;
+        for (let i = 0; i < data.segments.length; i++) {
+            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);
+        this.dispatch("segmentAdded", segment);
+        return true;
+    }
+    removeSegment(segment) {
+        for (let i = this.segments.length - 1; i > -1; i--) {
+            this.segments[i].index--;
+            if (this.segments[i] == segment) {
+                this.segments.splice(i, 1);
+                break;
+            }
+        }
+        this.dispatch("segmentRemoved", segment);
+        return false;
+    }
+    removePoint(segmentIndex, pointIndex) {
+        if (!this.segments.length)
+            return false;
+        if (!this.segments[segmentIndex])
+            return false;
+        if (segmentIndex > 0) {
+            const segment = this.segments[segmentIndex];
+            const previousSegment = this.segments.at(segmentIndex - 1);
+            if (pointIndex == 0) {
+                previousSegment.setPoints(previousSegment.start, segment.end);
+            }
+            if (pointIndex == 1) {
+                previousSegment.setPoints(previousSegment.start, segment.start);
+            }
+            this.removeSegment(segment);
+        }
+        else {
+            this.removeSegment(this.segments[0]);
+        }
+    }
+    toJSON() {
+        const segments = [];
+        for (let i = 0; i < this.segments.length; i++) {
+            segments.push(this.segments[i].toJSON());
+        }
+        return {
+            segments,
+        };
+    }
+}

package/Templates/Path/VoxelPath.types.d.ts

@@ -0,0 +1,11 @@
+import { Vec3Array } from "@amodx/math";
+import { PaintVoxelData } from "../../Voxels";
+export type VoxelPathSegmentData = {
+    start: Vec3Array;
+    end: Vec3Array;
+    voxel: PaintVoxelData;
+    transient?: boolean;
+};
+export type VoxelPathData = {
+    segments: VoxelPathSegmentData[];
+};

package/Templates/Path/VoxelPath.types.js

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

package/Templates/Selection/VoxelBFSSelection.d.ts

@@ -0,0 +1,23 @@
+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;
+    bitIndex: Uint8Array;
+}
+export declare class VoxelBFSSelection implements IVoxelSelection, 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;
+}