@divinevoxel/vlox 0.0.75 → 0.0.77

package/Templates/Selection/VoxelSurfaceSelection.d.ts

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

package/Templates/Selection/VoxelSurfaceSelection.js

@@ -3,19 +3,15 @@ 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();
-    extrusion = 0;
+    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);
     }
@@ -32,23 +28,24 @@ export class VoxelSurfaceSelection {
             axis = "z";
         const min = Vector3Like.Create(Infinity, Infinity, Infinity);
         const max = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
+        // 1) BFS to collect the *surface-adjacent* air layer (offset 1 in +normal)
         const queue = [
             position.x + normal.x,
             position.y + normal.y,
             position.z + normal.z,
         ];
         let size = 0;
-        const visted = new Set();
+        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 (visted.has(key))
+            const key = `${x} ${y} ${z}`;
+            if (visited.has(key))
                 continue;
-            visted.add(key);
+            visited.add(key);
             if (x < min.x)
                 min.x = x;
             if (y < min.y)
@@ -61,11 +58,10 @@ export class VoxelSurfaceSelection {
                 max.y = y;
             if (z > max.z)
                 max.z = z;
+            // Expand only in the 2D tangent plane to the face normal.
             for (let i = 0; i < CardinalNeighbors2D.length; i++) {
                 const n = CardinalNeighbors2D[i];
-                let nx = x;
-                let ny = y;
-                let nz = z;
+                let nx = x, ny = y, nz = z;
                 if (axis == "x") {
                     ny += n[0];
                     nz += n[1];
@@ -81,6 +77,7 @@ export class VoxelSurfaceSelection {
                 const voxel = cursor.getVoxel(nx, ny, nz);
                 if (!voxel || !voxel.isAir())
                     continue;
+                // Must be "resting" on a solid (the face we clicked)
                 const bottomVoxel = cursor.getVoxel(nx - normal.x, ny - normal.y, nz - normal.z);
                 if (!bottomVoxel || bottomVoxel.isAir())
                     continue;
@@ -92,6 +89,48 @@ export class VoxelSurfaceSelection {
             return false;
         if (max.x == -Infinity || max.y == -Infinity || max.z == -Infinity)
             return false;
+        // 2) Extrude outward along +normal for 'extrusion' layers.
+        //    We grow layer-by-layer; each new layer must be air and contiguous to the previous layer stack.
+        if (extrusion > 0) {
+            // Collect the initial (surface-adjacent) layer as our starting front.
+            let front = [];
+            for (const key of visited) {
+                const [sx, sy, sz] = key.split(" ").map(Number);
+                front.push({ x: sx, y: sy, z: sz });
+            }
+            for (let d = 1; d <= extrusion; d++) {
+                const nextFront = [];
+                for (const p of front) {
+                    const tx = p.x + normal.x;
+                    const ty = p.y + normal.y;
+                    const tz = p.z + normal.z;
+                    const tKey = `${tx} ${ty} ${tz}`;
+                    if (visited.has(tKey))
+                        continue; // already added by another path
+                    const world = cursor.getVoxel(tx, ty, tz);
+                    if (!world || !world.isAir())
+                        continue; // stop extrusion if we hit solid
+                    visited.add(tKey);
+                    nextFront.push({ x: tx, y: ty, z: tz });
+                    if (tx < min.x)
+                        min.x = tx;
+                    if (ty < min.y)
+                        min.y = ty;
+                    if (tz < min.z)
+                        min.z = tz;
+                    if (tx > max.x)
+                        max.x = tx;
+                    if (ty > max.y)
+                        max.y = ty;
+                    if (tz > max.z)
+                        max.z = tz;
+                }
+                if (nextFront.length === 0)
+                    break; // nothing more to grow
+                front = nextFront;
+            }
+        }
+        // 3) Build compact bit mask over the final bounds.
         const sizeX = max.x - min.x + 1;
         const sizeY = max.y - min.y + 1;
         const sizeZ = max.z - min.z + 1;
@@ -100,80 +139,44 @@ export class VoxelSurfaceSelection {
         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))
+                    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;
+        this.bounds.setMinMax(this.origin, {
+            x: this.origin.x + sizeX,
+            y: this.origin.y + sizeY,
+            z: this.origin.z + sizeZ,
+        });
+        return true;
     }
-    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++) {
+    clone() {
+        const newSelection = new VoxelSurfaceSelection();
+        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());
+        newSelection.bounds.setMinMax(this.bounds.min, this.bounds.max);
+        return newSelection;
+    }
+    toTemplate(voxel) {
+        const size = this.bounds.size;
+        const template = new FullVoxelTemplate(FullVoxelTemplate.CreateNew([size.x, size.y, size.z]));
+        const raw = PaintVoxelData.ToRaw(voxel);
+        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)) {
-                        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];
-                            }
-                        }
+                        template.ids[index] = raw[0];
+                        template.level[index] = raw[2];
+                        template.secondary[index] = raw[3];
                     }
                 }
             }
@@ -182,11 +185,11 @@ export class VoxelSurfaceSelection {
     }
     toJSON() {
         return {
+            type: "surface",
             origin: { ...this.origin },
             normal: { ...this.normal },
-            extrusion: this.extrusion,
             bitIndex: this.bitIndex.slice(),
-            size: this.size,
+            bounds: { ...this.bounds.size },
         };
     }
     fromJSON(data) {
@@ -196,11 +199,12 @@ export class VoxelSurfaceSelection {
         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);
+        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/VoxelTemplateSelection.d.ts

@@ -1,10 +1,19 @@
 import { Vector3Like } from "@amodx/math";
-import { IVoxelSelection } from "./VoxelSelecton";
-import { IVoxelTemplate } from "../VoxelTemplates.types";
-export declare class VoxelTemplateSelection implements IVoxelSelection {
+import { IVoxelSelection, IVoxelSelectionData } from "./VoxelSelection";
+import { IVoxelTemplate, IVoxelTemplateData } from "../VoxelTemplates.types";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import type { VoxelTemplateRegister } from "../VoxelTemplateRegister";
+export interface VoxelTemplateSelectionData extends IVoxelSelectionData<"template"> {
+    template: IVoxelTemplateData<any>;
+}
+export declare class VoxelTemplateSelection implements IVoxelSelection<"template"> {
+    static Register: typeof VoxelTemplateRegister;
     origin: Vector3Like;
-    size: Vector3Like;
+    bounds: BoundingBox;
     template: IVoxelTemplate;
     isSelected(x: number, y: number, z: number): boolean;
+    clone(): VoxelTemplateSelection;
     setTemplate(template: IVoxelTemplate): void;
+    toJSON(): VoxelTemplateSelectionData;
+    fromJSON(data: VoxelTemplateSelectionData): void;
 }

package/Templates/Selection/VoxelTemplateSelection.js

@@ -1,14 +1,12 @@
 import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export class VoxelTemplateSelection {
+    static Register;
     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)
+        if (!this.bounds.intersectsXYZ(x + 0.5, y + 0.5, z + 0.5))
             return false;
         const rx = x - this.origin.x;
         const ry = y - this.origin.y;
@@ -17,10 +15,30 @@ export class VoxelTemplateSelection {
             return false;
         return true;
     }
+    clone() {
+        const newSelection = new VoxelTemplateSelection();
+        Vector3Like.Copy(newSelection.origin, this.origin);
+        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;
+        this.bounds.setMinMax(this.origin, Vector3Like.Add(this.origin, template.bounds.size));
+    }
+    toJSON() {
+        return {
+            type: "template",
+            origin: { ...this.origin },
+            bounds: { ...this.bounds.size },
+            template: this.template.toJSON(),
+        };
+    }
+    fromJSON(data) {
+        this.origin.x = data.origin.x;
+        this.origin.y = data.origin.y;
+        this.origin.z = data.origin.z;
+        const template = VoxelTemplateSelection.Register.create(data.template);
+        this.setTemplate(template);
     }
 }

package/Templates/Shapes/Selections/BoxVoxelShapeSelection.d.ts

@@ -0,0 +1,28 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { IVoxelShapeSelection, IVoxelShapeSelectionData } from "./VoxelShapeSelection";
+export interface BoxVoxelShapeSelectionData extends IVoxelShapeSelectionData<"box-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class BoxVoxelShapeSelection implements IVoxelShapeSelection<"box-shape", BoxVoxelShapeSelectionData> {
+    static readonly Type = "box-shape";
+    static CreateNew(data: Partial<BoxVoxelShapeSelectionData>): BoxVoxelShapeSelectionData;
+    origin: Vector3Like;
+    bounds: BoundingBox;
+    _width: number;
+    get width(): number;
+    set width(width: number);
+    _height: number;
+    get height(): number;
+    set height(height: number);
+    _depth: number;
+    get depth(): number;
+    set depth(depth: number);
+    private _updateBounds;
+    isSelected(x: number, y: number, z: number): boolean;
+    clone(): BoxVoxelShapeSelection;
+    toJSON(): BoxVoxelShapeSelectionData;
+    fromJSON(data: BoxVoxelShapeSelectionData): void;
+}

package/Templates/Shapes/Selections/BoxVoxelShapeSelection.js

@@ -0,0 +1,77 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export class BoxVoxelShapeSelection {
+    static Type = "box-shape";
+    static CreateNew(data) {
+        return {
+            type: BoxVoxelShapeSelection.Type,
+            origin: data.origin || Vector3Like.Create(),
+            bounds: data.bounds ||
+                Vector3Like.Create(data.width || 5, data.height || 5, data.depth || 5),
+            width: data.width || 5,
+            height: data.height || 5,
+            depth: data.depth || 5,
+        };
+    }
+    origin = Vector3Like.Create();
+    bounds = new BoundingBox();
+    _width = 1;
+    get width() {
+        return this._width;
+    }
+    set width(width) {
+        this._width = width;
+        this._updateBounds();
+    }
+    _height = 1;
+    get height() {
+        return this._height;
+    }
+    set height(height) {
+        this._height = height;
+        this._updateBounds();
+    }
+    _depth = 1;
+    get depth() {
+        return this._depth;
+    }
+    set depth(depth) {
+        this._depth = depth;
+        this._updateBounds();
+    }
+    _updateBounds() {
+        this.bounds.setSize(Vector3Like.Create(this._width, this._height, this._depth));
+    }
+    isSelected(x, y, z) {
+        let rx = x - this.origin.x;
+        let ry = y - this.origin.y;
+        let rz = z - this.origin.z;
+        if (!this.bounds.intersectsXYZ(rx + 0.5, ry + 0.5, rz + 0.5))
+            return false;
+        return true;
+    }
+    clone() {
+        const newTemplate = new BoxVoxelShapeSelection();
+        newTemplate.fromJSON(this.toJSON());
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            type: BoxVoxelShapeSelection.Type,
+            origin: { ...this.origin },
+            bounds: { ...this.bounds.size },
+            width: this._width,
+            height: this._height,
+            depth: this._depth,
+        };
+    }
+    fromJSON(data) {
+        this.origin.x = data.origin.x;
+        this.origin.y = data.origin.y;
+        this.origin.z = data.origin.z;
+        this._width = data.width;
+        this._height = data.height;
+        this._depth = data.depth;
+        this._updateBounds();
+    }
+}

package/Templates/Shapes/Selections/ConeVoxelShapeSelection.d.ts

@@ -0,0 +1,28 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { IVoxelShapeSelection, IVoxelShapeSelectionData } from "./VoxelShapeSelection";
+export interface ConeVoxelShapeSelectionData extends IVoxelShapeSelectionData<"cone-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class ConeVoxelShapeSelection implements IVoxelShapeSelection<"cone-shape", ConeVoxelShapeSelectionData> {
+    static readonly Type = "cone-shape";
+    static CreateNew(data: Partial<ConeVoxelShapeSelectionData>): ConeVoxelShapeSelectionData;
+    origin: Vector3Like;
+    bounds: BoundingBox;
+    _width: number;
+    get width(): number;
+    set width(width: number);
+    _height: number;
+    get height(): number;
+    set height(height: number);
+    _depth: number;
+    get depth(): number;
+    set depth(depth: number);
+    private _updateBounds;
+    isSelected(x: number, y: number, z: number): boolean;
+    clone(): ConeVoxelShapeSelection;
+    toJSON(): ConeVoxelShapeSelectionData;
+    fromJSON(data: ConeVoxelShapeSelectionData): void;
+}

package/Templates/Shapes/Selections/ConeVoxelShapeSelection.js

@@ -0,0 +1,77 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export class ConeVoxelShapeSelection {
+    static Type = "cone-shape";
+    static CreateNew(data) {
+        return {
+            type: ConeVoxelShapeSelection.Type,
+            origin: data.origin || Vector3Like.Create(),
+            bounds: data.bounds ||
+                Vector3Like.Create(data.width || 1, data.height || 1, data.depth || 1),
+            width: data.width || 1,
+            height: data.height || 1,
+            depth: data.depth || 1,
+        };
+    }
+    origin = Vector3Like.Create();
+    bounds = new BoundingBox();
+    _width = 1;
+    get width() {
+        return this._width;
+    }
+    set width(width) {
+        this._width = width;
+        this._updateBounds();
+    }
+    _height = 1;
+    get height() {
+        return this._height;
+    }
+    set height(height) {
+        this._height = height;
+        this._updateBounds();
+    }
+    _depth = 1;
+    get depth() {
+        return this._depth;
+    }
+    set depth(depth) {
+        this._depth = depth;
+        this._updateBounds();
+    }
+    _updateBounds() {
+        this.bounds.setSize(Vector3Like.Create(this._width, this._height, this._depth));
+    }
+    isSelected(x, y, z) {
+        let rx = x - this.origin.x;
+        let ry = y - this.origin.y;
+        let rz = z - this.origin.z;
+        if (!this.bounds.intersectsXYZ(rx + 0.5, ry + 0.5, rz + 0.5))
+            return false;
+        return true;
+    }
+    clone() {
+        const newTemplate = new ConeVoxelShapeSelection();
+        newTemplate.fromJSON(this.toJSON());
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            type: ConeVoxelShapeSelection.Type,
+            origin: { ...this.origin },
+            bounds: { ...this.bounds.size },
+            width: this._width,
+            height: this._height,
+            depth: this._depth,
+        };
+    }
+    fromJSON(data) {
+        this.origin.x = data.origin.x;
+        this.origin.y = data.origin.y;
+        this.origin.z = data.origin.z;
+        this._width = data.width;
+        this._height = data.height;
+        this._depth = data.depth;
+        this._updateBounds();
+    }
+}

package/Templates/Shapes/Selections/CylinderVoxelShapeSelection.d.ts

@@ -0,0 +1,28 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { IVoxelShapeSelection, IVoxelShapeSelectionData } from "./VoxelShapeSelection";
+export interface CylinderVoxelShapeSelectionData extends IVoxelShapeSelectionData<"cylinder-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class CylinderVoxelShapeSelection implements IVoxelShapeSelection<"cylinder-shape", CylinderVoxelShapeSelectionData> {
+    static readonly Type = "cylinder-shape";
+    static CreateNew(data: Partial<CylinderVoxelShapeSelectionData>): CylinderVoxelShapeSelectionData;
+    origin: Vector3Like;
+    bounds: BoundingBox;
+    _width: number;
+    get width(): number;
+    set width(width: number);
+    _height: number;
+    get height(): number;
+    set height(height: number);
+    _depth: number;
+    get depth(): number;
+    set depth(depth: number);
+    private _updateBounds;
+    isSelected(x: number, y: number, z: number): boolean;
+    clone(): CylinderVoxelShapeSelection;
+    toJSON(): CylinderVoxelShapeSelectionData;
+    fromJSON(data: CylinderVoxelShapeSelectionData): void;
+}