@divinevoxel/vlox 0.0.74 → 0.0.75

package/Templates/Selection/VoxelBoxSelection.js

@@ -0,0 +1,105 @@
+import { Vec3ArrayLike, Vector3Like } from "@amodx/math";
+import { BoxVoxelTemplate } from "../Shapes/BoxVoxelTemplate";
+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();
+    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];
+        }
+    }
+    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,6 @@
+import { Vector3Like } from "@amodx/math";
+export interface IVoxelSelection {
+    origin: Vector3Like;
+    size: Vector3Like;
+    isSelected(x: number, y: number, z: number): boolean;
+}

package/Templates/Selection/VoxelSelecton.js

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

package/Templates/Selection/VoxelSurfaceSelection.d.ts

@@ -0,0 +1,27 @@
+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";
+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;
+    extrusion: number;
+    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;
+    toJSON(): VoxelSurfaceSelectionData;
+    fromJSON(data: VoxelSurfaceSelectionData): void;
+}

package/Templates/Selection/VoxelSurfaceSelection.js

@@ -0,0 +1,206 @@
+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";
+export class VoxelSurfaceSelection {
+    origin = Vector3Like.Create();
+    size = Vector3Like.Create();
+    normal = Vector3Like.Create();
+    bitIndex;
+    index = Flat3DIndex.GetXZYOrder();
+    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;
+    }
+    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,10 @@
+import { Vector3Like } from "@amodx/math";
+import { IVoxelSelection } from "./VoxelSelecton";
+import { IVoxelTemplate } from "../VoxelTemplates.types";
+export declare class VoxelTemplateSelection implements IVoxelSelection {
+    origin: Vector3Like;
+    size: Vector3Like;
+    template: IVoxelTemplate;
+    isSelected(x: number, y: number, z: number): boolean;
+    setTemplate(template: IVoxelTemplate): void;
+}

package/Templates/Selection/VoxelTemplateSelection.js

@@ -0,0 +1,26 @@
+import { Vector3Like } from "@amodx/math";
+export class VoxelTemplateSelection {
+    origin = Vector3Like.Create();
+    size = Vector3Like.Create();
+    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;
+    }
+    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;
+    }
+}

package/Templates/Shapes/BasicVoxelShapeTemplate.d.ts

@@ -0,0 +1,35 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { PaintVoxelData, RawVoxelData } from "../../Voxels";
+import { IVoxelShapeTemplate, IVoxelShapeTemplateData, VoxelShapeTemplateFillModes, IVoxelShapeTemplateEvents } from "./VoxelShapeTemplate.types";
+import { TypedEventTarget } from "../../Util/TypedEventTarget";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export declare abstract class BasicVoxelShapeTemplate<Type extends string, Data extends IVoxelShapeTemplateData<any>, Events extends IVoxelShapeTemplateEvents = IVoxelShapeTemplateEvents> extends TypedEventTarget<Events> implements IVoxelShapeTemplate<Type, Data, Events> {
+    static CreateBaseData<Type extends string>(type: Type, data: Partial<IVoxelShapeTemplateData<Type>>): IVoxelShapeTemplateData<Type>;
+    position: Vector3Like;
+    index: Flat3DIndex;
+    bounds: BoundingBox;
+    type: string;
+    fillMode: VoxelShapeTemplateFillModes;
+    fillVoxel: PaintVoxelData;
+    faceVoxel: PaintVoxelData;
+    edgeVoxel: PaintVoxelData;
+    pointVoxel: PaintVoxelData;
+    _fillVoxel: RawVoxelData;
+    _faceVoxel: RawVoxelData;
+    _edgeVoxel: RawVoxelData;
+    _pointVoxel: RawVoxelData;
+    constructor(data: Data);
+    setVoxels(fill: PaintVoxelData, face?: PaintVoxelData, edge?: PaintVoxelData, point?: PaintVoxelData): void;
+    getIndex(x: number, y: number, z: number): number;
+    setPosition(x: number, y: number, z: number): void;
+    abstract isIncluded(index: number): boolean;
+    isAir(index: number): boolean;
+    getId(index: number): number;
+    getLight(index: number): number;
+    getLevel(index: number): number;
+    getSecondary(index: number): number;
+    getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
+    protected _updateBounds(): void;
+    abstract toJSON(): Data;
+    protected getBaseJSON(): IVoxelShapeTemplateData<any>;
+}

package/Templates/Shapes/BasicVoxelShapeTemplate.js

@@ -0,0 +1,126 @@
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { PaintVoxelData } from "../../Voxels";
+import { TypedEventTarget } from "../../Util/TypedEventTarget";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export class BasicVoxelShapeTemplate extends TypedEventTarget {
+    static CreateBaseData(type, data) {
+        return {
+            type,
+            bounds: data.bounds || { x: 1, y: 1, z: 1 },
+            position: Vector3Like.Create(),
+            fillMode: "full",
+            fillVoxel: PaintVoxelData.Create(),
+            faceVoxel: PaintVoxelData.Create(),
+            edgeVoxel: PaintVoxelData.Create(),
+            pointVoxel: PaintVoxelData.Create(),
+            ...data,
+        };
+    }
+    position = Vector3Like.Create();
+    index = Flat3DIndex.GetXZYOrder();
+    bounds;
+    type = "";
+    fillMode;
+    fillVoxel;
+    faceVoxel;
+    edgeVoxel;
+    pointVoxel;
+    _fillVoxel;
+    _faceVoxel;
+    _edgeVoxel;
+    _pointVoxel;
+    constructor(data) {
+        super();
+        this.type = data.type;
+        this.fillMode = data.fillMode;
+        this.bounds = new BoundingBox();
+        this.bounds.setMinPositionAndSize(data.position, data.bounds);
+        this.index.setBounds(data.bounds.x, data.bounds.y, data.bounds.z);
+        this.setVoxels(data.fillVoxel, data.faceVoxel, data.edgeVoxel, data.pointVoxel);
+    }
+    setVoxels(fill, face, edge, point) {
+        this.fillVoxel = fill;
+        this.faceVoxel = face || fill;
+        this.edgeVoxel = edge || fill;
+        this.pointVoxel = point || fill;
+        this._fillVoxel = PaintVoxelData.ToRaw(this.fillVoxel);
+        this._faceVoxel = PaintVoxelData.ToRaw(this.faceVoxel);
+        this._edgeVoxel = PaintVoxelData.ToRaw(this.edgeVoxel);
+        this._pointVoxel = PaintVoxelData.ToRaw(this.pointVoxel);
+    }
+    getIndex(x, y, z) {
+        return this.index.getIndexXYZ(x, y, z);
+    }
+    setPosition(x, y, z) {
+        this.position.x = x;
+        this.position.y = y;
+        this.position.z = z;
+    }
+    isAir(index) {
+        if (!this.isIncluded(index))
+            return true;
+        return this.getId(index) === 0;
+    }
+    getId(index) {
+        if (!this.isIncluded(index))
+            return 0;
+        const id = this._fillVoxel[0];
+        if (this.fillMode == "full")
+            return id;
+        return id;
+    }
+    getLight(index) {
+        if (!this.isIncluded(index))
+            return 0;
+        const light = this._fillVoxel[1];
+        if (this.fillMode == "full")
+            return light;
+        return light;
+    }
+    getLevel(index) {
+        if (!this.isIncluded(index))
+            return 0;
+        const level = this._fillVoxel[2];
+        if (this.fillMode == "full")
+            return level;
+        return level;
+    }
+    getSecondary(index) {
+        if (!this.isIncluded(index))
+            return 0;
+        const secondary = this._fillVoxel[3];
+        if (this.fillMode == "full")
+            return secondary;
+        return secondary;
+    }
+    getRaw(index, rawRef = [0, 0, 0, 0]) {
+        if (!this.isIncluded(index)) {
+            rawRef[0] = 0;
+            rawRef[1] = 0;
+            rawRef[2] = 0;
+            rawRef[3] = 0;
+            return rawRef;
+        }
+        rawRef[0] = this.getId(index);
+        rawRef[1] = this.getLight(index);
+        rawRef[2] = this.getLevel(index);
+        rawRef[3] = this.getSecondary(index);
+        return rawRef;
+    }
+    _updateBounds() {
+        this.bounds.setSize(this.bounds.size);
+        this.index.setBounds(this.bounds.size.x, this.bounds.size.y, this.bounds.size.z);
+    }
+    getBaseJSON() {
+        return {
+            type: this.type,
+            position: this.position,
+            bounds: this.bounds.size,
+            fillMode: this.fillMode,
+            fillVoxel: this.fillVoxel,
+            faceVoxel: this.faceVoxel,
+            edgeVoxel: this.edgeVoxel,
+            pointVoxel: this.pointVoxel,
+        };
+    }
+}

package/Templates/Shapes/BoxVoxelTemplate.d.ts

@@ -0,0 +1,22 @@
+import { IVoxelShapeTemplateData } from "./VoxelShapeTemplate.types";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export interface BoxVoxelTemplateData extends IVoxelShapeTemplateData<"box-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class BoxVoxelTemplate extends BasicVoxelShapeTemplate<"box-shape", BoxVoxelTemplateData> {
+    static CreateNew(data: Partial<BoxVoxelTemplateData>): BoxVoxelTemplateData;
+    private _width;
+    get width(): number;
+    set width(width: number);
+    private _height;
+    get height(): number;
+    set height(height: number);
+    private _depth;
+    get depth(): number;
+    set depth(depth: number);
+    constructor(data: BoxVoxelTemplateData);
+    isIncluded(index: number): boolean;
+    toJSON(): BoxVoxelTemplateData;
+}

package/Templates/Shapes/BoxVoxelTemplate.js

@@ -0,0 +1,75 @@
+import { PaintVoxelData } from "../../Voxels";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export class BoxVoxelTemplate extends BasicVoxelShapeTemplate {
+    static CreateNew(data) {
+        return {
+            ...BasicVoxelShapeTemplate.CreateBaseData("box-shape", {
+                bounds: { x: data.width || 1, y: data.height || 1, z: data.depth || 1 },
+                fillVoxel: data.fillVoxel || PaintVoxelData.Create(),
+                pointVoxel: data.pointVoxel || PaintVoxelData.Create(),
+                faceVoxel: data.faceVoxel || PaintVoxelData.Create(),
+                edgeVoxel: data.edgeVoxel || PaintVoxelData.Create(),
+                fillMode: data.fillMode || "full",
+            }),
+            width: data.width || 1,
+            height: data.height || 1,
+            depth: data.depth || 1,
+        };
+    }
+    _width = 0;
+    get width() {
+        return this._width;
+    }
+    set width(width) {
+        const oldWidth = this._width;
+        this._width = width;
+        if (oldWidth != width) {
+            this.bounds.size.x = width;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _height = 0;
+    get height() {
+        return this._height;
+    }
+    set height(height) {
+        const oldWidth = this._height;
+        this._height = height;
+        if (oldWidth != height) {
+            this.bounds.size.y = height;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    _depth = 0;
+    get depth() {
+        return this._depth;
+    }
+    set depth(depth) {
+        const oldWidth = this._depth;
+        this._depth = depth;
+        if (oldWidth != depth) {
+            this.bounds.size.z = depth;
+            this._updateBounds();
+            this.dispatch("updated", null);
+        }
+    }
+    constructor(data) {
+        super(data);
+        this._width = data.width;
+        this._height = data.height;
+        this._depth = data.depth;
+    }
+    isIncluded(index) {
+        return true;
+    }
+    toJSON() {
+        return {
+            width: this.width,
+            height: this.height,
+            depth: this.depth,
+            ...this.getBaseJSON(),
+        };
+    }
+}

package/Templates/Shapes/ConeVoxelTemplate.d.ts

@@ -0,0 +1,22 @@
+import { IVoxelShapeTemplateData } from "./VoxelShapeTemplate.types";
+import { BasicVoxelShapeTemplate } from "./BasicVoxelShapeTemplate";
+export interface ConeVoxelTemplateData extends IVoxelShapeTemplateData<"cone-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class ConeVoxelTemplate extends BasicVoxelShapeTemplate<"cone-shape", ConeVoxelTemplateData> {
+    static CreateNew(data: Partial<ConeVoxelTemplateData>): ConeVoxelTemplateData;
+    private _width;
+    get width(): number;
+    set width(width: number);
+    private _height;
+    get height(): number;
+    set height(height: number);
+    private _depth;
+    get depth(): number;
+    set depth(depth: number);
+    constructor(data: ConeVoxelTemplateData);
+    isIncluded(index: number): boolean;
+    toJSON(): ConeVoxelTemplateData;
+}