@divinevoxel/vlox 0.0.76 → 0.0.78

package/Templates/Shapes/Selections/EllipsoidVoxelShapeSelection.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 EllipsoidVoxelShapeSelectionData extends IVoxelShapeSelectionData<"ellipsoid-shape"> {
+    radiusX: number;
+    radiusY: number;
+    radiusZ: number;
+}
+export declare class EllipsoidVoxelShapeSelection implements IVoxelShapeSelection<"ellipsoid-shape", EllipsoidVoxelShapeSelectionData> {
+    static readonly Type = "ellipsoid-shape";
+    static CreateNew(data: Partial<EllipsoidVoxelShapeSelectionData>): EllipsoidVoxelShapeSelectionData;
+    origin: Vector3Like;
+    bounds: BoundingBox;
+    private _radiusX;
+    get radiusX(): number;
+    set radiusX(radius: number);
+    private _radiusY;
+    get radiusY(): number;
+    set radiusY(radius: number);
+    private _radiusZ;
+    get radiusZ(): number;
+    set radiusZ(radius: number);
+    private _updateBounds;
+    isSelected(x: number, y: number, z: number): boolean;
+    clone(): EllipsoidVoxelShapeSelection;
+    toJSON(): EllipsoidVoxelShapeSelectionData;
+    fromJSON(data: EllipsoidVoxelShapeSelectionData): void;
+}

package/Templates/Shapes/Selections/EllipsoidVoxelShapeSelection.js

@@ -0,0 +1,92 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export class EllipsoidVoxelShapeSelection {
+    static Type = "ellipsoid-shape";
+    static CreateNew(data) {
+        return {
+            type: EllipsoidVoxelShapeSelection.Type,
+            origin: data.origin || Vector3Like.Create(),
+            bounds: data.bounds || Vector3Like.Create(),
+            radiusX: data.radiusX || 5,
+            radiusY: data.radiusY || 5,
+            radiusZ: data.radiusZ || 5,
+        };
+    }
+    origin = Vector3Like.Create();
+    bounds = new BoundingBox();
+    _radiusX = 0;
+    get radiusX() {
+        return this._radiusX;
+    }
+    set radiusX(radius) {
+        const oldRadius = this._radiusX;
+        this._radiusX = radius;
+        if (oldRadius != radius) {
+            this._updateBounds();
+        }
+    }
+    _radiusY = 0;
+    get radiusY() {
+        return this._radiusY;
+    }
+    set radiusY(radius) {
+        const oldRadius = this._radiusY;
+        this._radiusY = radius;
+        if (oldRadius != radius) {
+            this._updateBounds();
+        }
+    }
+    _radiusZ = 0;
+    get radiusZ() {
+        return this._radiusZ;
+    }
+    set radiusZ(radius) {
+        const oldRadius = this._radiusZ;
+        this._radiusZ = radius;
+        if (oldRadius != radius) {
+            this._updateBounds();
+        }
+    }
+    _updateBounds() {
+        this.bounds.setSize(Vector3Like.Create(this._radiusX * 2 + 1, this._radiusY * 2 + 1, this._radiusZ * 2 + 1));
+    }
+    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;
+        const cx = Math.floor(this.bounds.size.x / 2);
+        const cy = Math.floor(this.bounds.size.y / 2);
+        const cz = Math.floor(this.bounds.size.z / 2);
+        const normX = (rx - cx) / this.radiusX;
+        const normY = (ry - cy) / this.radiusY;
+        const normZ = (rz - cz) / this.radiusZ;
+        const distance = Math.sqrt(normX * normX + normY * normY + normZ * normZ);
+        return distance <= 1;
+    }
+    clone() {
+        const newTemplate = new EllipsoidVoxelShapeSelection();
+        newTemplate.fromJSON(this.toJSON());
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            type: "ellipsoid-shape",
+            origin: { ...this.origin },
+            bounds: { ...this.bounds.size },
+            radiusX: this._radiusX,
+            radiusY: this._radiusY,
+            radiusZ: this._radiusZ,
+        };
+    }
+    fromJSON(data) {
+        this.origin.x = data.origin.x;
+        this.origin.y = data.origin.y;
+        this.origin.z = data.origin.z;
+        this._radiusX = data.radiusX;
+        this._radiusY = data.radiusY;
+        this._radiusZ = data.radiusZ;
+        this._updateBounds();
+    }
+}

package/Templates/Shapes/Selections/OctahedronVoxelShapeSelection.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 OctahedronVoxelShapeSelectionData extends IVoxelShapeSelectionData<"octahedron-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class OctahedronVoxelShapeSelection implements IVoxelShapeSelection<"octahedron-shape", OctahedronVoxelShapeSelectionData> {
+    static readonly Type = "octahedron-shape";
+    static CreateNew(data: Partial<OctahedronVoxelShapeSelectionData>): OctahedronVoxelShapeSelectionData;
+    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(): OctahedronVoxelShapeSelection;
+    toJSON(): OctahedronVoxelShapeSelectionData;
+    fromJSON(data: OctahedronVoxelShapeSelectionData): void;
+}

package/Templates/Shapes/Selections/OctahedronVoxelShapeSelection.js

@@ -0,0 +1,76 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export class OctahedronVoxelShapeSelection {
+    static Type = "octahedron-shape";
+    static CreateNew(data) {
+        return {
+            type: OctahedronVoxelShapeSelection.Type,
+            origin: data.origin || Vector3Like.Create(),
+            bounds: data.bounds || Vector3Like.Create(),
+            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 OctahedronVoxelShapeSelection();
+        newTemplate.fromJSON(this.toJSON());
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            type: "octahedron-shape",
+            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/PyramidVoxelShapeSelection.d.ts

@@ -0,0 +1,37 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { VoxelShapeShapeDirections } from "../VoxelShape.types";
+import { IVoxelShapeSelection, IVoxelShapeSelectionData } from "./VoxelShapeSelection";
+export interface PyramidVoxelShapeSelectionData extends IVoxelShapeSelectionData<"pyramid-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+    fallOff: number;
+    direction: VoxelShapeShapeDirections;
+}
+export declare class PyramidVoxelShapeSelection implements IVoxelShapeSelection<"pyramid-shape", PyramidVoxelShapeSelectionData> {
+    static readonly Type = "pyramid-shape";
+    static CreateNew(data: Partial<PyramidVoxelShapeSelectionData>): PyramidVoxelShapeSelectionData;
+    origin: Vector3Like;
+    bounds: BoundingBox;
+    private _fallOff;
+    get fallOff(): number;
+    set fallOff(fallOFf: number);
+    private _direction;
+    get direction(): VoxelShapeShapeDirections;
+    set direction(direction: VoxelShapeShapeDirections);
+    _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(): PyramidVoxelShapeSelection;
+    toJSON(): PyramidVoxelShapeSelectionData;
+    fromJSON(data: PyramidVoxelShapeSelectionData): void;
+}

package/Templates/Shapes/Selections/PyramidVoxelShapeSelection.js

@@ -0,0 +1,137 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export class PyramidVoxelShapeSelection {
+    static Type = "pyramid-shape";
+    static CreateNew(data) {
+        return {
+            type: PyramidVoxelShapeSelection.Type,
+            origin: data.origin || Vector3Like.Create(),
+            bounds: data.bounds || Vector3Like.Create(),
+            width: data.width || 6,
+            height: data.height || 6,
+            depth: data.depth || 6,
+            fallOff: data.fallOff || 1,
+            direction: data.direction || "+y",
+        };
+    }
+    origin = Vector3Like.Create();
+    bounds = new BoundingBox();
+    _fallOff = 0;
+    get fallOff() {
+        return this._fallOff;
+    }
+    set fallOff(fallOFf) {
+        this._fallOff = fallOFf;
+    }
+    _direction = "+y";
+    get direction() {
+        return this._direction;
+    }
+    set direction(direction) {
+        this._direction = direction;
+    }
+    _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;
+        switch (this.direction) {
+            case "+y": {
+                // Pyramid pointing up
+                const normalizedFallOff = ry * this.fallOff;
+                const minX = normalizedFallOff;
+                const minZ = normalizedFallOff;
+                const maxX = this.width - normalizedFallOff;
+                const maxZ = this.depth - normalizedFallOff;
+                if (rx >= minX && rz >= minZ && rx < maxX && rz < maxZ)
+                    return true;
+                return false;
+            }
+            case "-y": {
+                // Pyramid pointing down
+                const normalizedFallOff = (this.height - 1 - ry) * this.fallOff;
+                const minX = normalizedFallOff;
+                const minZ = normalizedFallOff;
+                const maxX = this.width - normalizedFallOff;
+                const maxZ = this.depth - normalizedFallOff;
+                if (rx >= minX && rz >= minZ && rx < maxX && rz < maxZ)
+                    return true;
+                return false;
+            }
+            case "+x": {
+                // Pyramid pointing right
+                return true;
+            }
+            case "-x": {
+                // Pyramid pointing left
+                return true;
+            }
+            case "+z": {
+                // Pyramid pointing forward
+                return true;
+            }
+            case "-z": {
+                // Pyramid pointing backward
+                return true;
+            }
+            default:
+                return false;
+        }
+    }
+    clone() {
+        const newTemplate = new PyramidVoxelShapeSelection();
+        newTemplate.fromJSON(this.toJSON());
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            type: "pyramid-shape",
+            origin: { ...this.origin },
+            bounds: { ...this.bounds.size },
+            fallOff: this._fallOff,
+            direction: this._direction,
+            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._direction = data.direction;
+        this._fallOff = data.fallOff;
+        this._updateBounds();
+    }
+}

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

@@ -0,0 +1,20 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { IVoxelShapeSelection, IVoxelShapeSelectionData } from "./VoxelShapeSelection";
+export interface SphereVoxelShapeSelectionData extends IVoxelShapeSelectionData<"sphere-shape"> {
+    radius: number;
+}
+export declare class SphereVoxelShapeSelection implements IVoxelShapeSelection<"sphere-shape", SphereVoxelShapeSelectionData> {
+    static readonly Type = "sphere-shape";
+    static CreateNew(data: Partial<SphereVoxelShapeSelectionData>): SphereVoxelShapeSelectionData;
+    origin: Vector3Like;
+    bounds: BoundingBox;
+    _radius: number;
+    get radius(): number;
+    set radius(radius: number);
+    private _updateBounds;
+    isSelected(x: number, y: number, z: number): boolean;
+    clone(): SphereVoxelShapeSelection;
+    toJSON(): SphereVoxelShapeSelectionData;
+    fromJSON(data: SphereVoxelShapeSelectionData): void;
+}

package/Templates/Shapes/Selections/SphereVoxelShapeSelection.js

@@ -0,0 +1,61 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export class SphereVoxelShapeSelection {
+    static Type = "sphere-shape";
+    static CreateNew(data) {
+        return {
+            type: SphereVoxelShapeSelection.Type,
+            origin: data.origin || Vector3Like.Create(),
+            bounds: data.bounds || Vector3Like.Create(),
+            radius: data.radius || 2,
+        };
+    }
+    origin = Vector3Like.Create();
+    bounds = new BoundingBox();
+    _radius = 1;
+    get radius() {
+        return this._radius;
+    }
+    set radius(radius) {
+        this._radius = radius;
+        this._updateBounds();
+    }
+    _updateBounds() {
+        this.bounds.setSize(Vector3Like.Create(this._radius * 2 + 1, this._radius * 2 + 1, this._radius * 2 + 1));
+    }
+    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;
+        const cx = Math.floor(this.bounds.size.x / 2);
+        const cy = Math.floor(this.bounds.size.y / 2);
+        const cz = Math.floor(this.bounds.size.z / 2);
+        const normX = (rx - cx) / this.radius;
+        const normY = (ry - cy) / this.radius;
+        const normZ = (rz - cz) / this.radius;
+        const distance = Math.sqrt(normX * normX + normY * normY + normZ * normZ);
+        return distance <= 1;
+    }
+    clone() {
+        const newTemplate = new SphereVoxelShapeSelection();
+        newTemplate.fromJSON(this.toJSON());
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            type: "sphere-shape",
+            origin: { ...this.origin },
+            bounds: { ...this.bounds.size },
+            radius: this._radius,
+        };
+    }
+    fromJSON(data) {
+        this.origin.x = data.origin.x;
+        this.origin.y = data.origin.y;
+        this.origin.z = data.origin.z;
+        this.radius = data.radius;
+        this._updateBounds();
+    }
+}

package/Templates/Shapes/Selections/TorusVoxelShapeSelection.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 TorusVoxelShapeSelectionData extends IVoxelShapeSelectionData<"torus-shape"> {
+    width: number;
+    height: number;
+    depth: number;
+}
+export declare class TorusVoxelShapeSelection implements IVoxelShapeSelection<"torus-shape", TorusVoxelShapeSelectionData> {
+    static readonly Type = "torus-shape";
+    static CreateNew(data: Partial<TorusVoxelShapeSelectionData>): TorusVoxelShapeSelectionData;
+    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(): TorusVoxelShapeSelection;
+    toJSON(): TorusVoxelShapeSelectionData;
+    fromJSON(data: TorusVoxelShapeSelectionData): void;
+}

package/Templates/Shapes/Selections/TorusVoxelShapeSelection.js

@@ -0,0 +1,76 @@
+import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+export class TorusVoxelShapeSelection {
+    static Type = "torus-shape";
+    static CreateNew(data) {
+        return {
+            type: TorusVoxelShapeSelection.Type,
+            origin: data.origin || Vector3Like.Create(),
+            bounds: data.bounds || Vector3Like.Create(),
+            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 TorusVoxelShapeSelection();
+        newTemplate.fromJSON(this.toJSON());
+        return newTemplate;
+    }
+    toJSON() {
+        return {
+            type: "torus-shape",
+            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/VoxelShapeSelection.d.ts

@@ -0,0 +1,5 @@
+import { IVoxelSelection, IVoxelSelectionData } from "../../Selection/VoxelSelection";
+export interface IVoxelShapeSelectionData<Type extends string> extends IVoxelSelectionData<Type> {
+}
+export interface IVoxelShapeSelection<Type extends string, Data extends IVoxelShapeSelectionData<Type>> extends IVoxelSelection<Type, Data> {
+}

package/Templates/Shapes/Selections/VoxelShapeSelection.js

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

package/Templates/Shapes/VoxelShape.types.d.ts

@@ -0,0 +1,2 @@
+export type VoxelShapeShapeDirections = "+x" | "-x" | "+y" | "-y" | "+z" | "-z";
+export declare const VoxelShapeShapeDirectionsArray: VoxelShapeShapeDirections[];

package/Templates/Shapes/VoxelShape.types.js

@@ -0,0 +1,8 @@
+export const VoxelShapeShapeDirectionsArray = [
+    "+x",
+    "-x",
+    "+y",
+    "-y",
+    "+z",
+    "-z",
+];

package/Templates/Shapes/VoxelShapeTemplate.d.ts

@@ -0,0 +1,37 @@
+import { Flat3DIndex } from "@amodx/math";
+import { PaintVoxelData, RawVoxelData } from "../../Voxels";
+import { VoxelShapeTemplateData, VoxelShapeTemplateFillModes } from "./VoxelShapeTemplate.types";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { IVoxelTemplate } from "../VoxelTemplates.types";
+import { IVoxelShapeSelection, IVoxelShapeSelectionData } from "./Selections/VoxelShapeSelection";
+import type { VoxelTemplateRegister } from "../VoxelTemplateRegister";
+export declare class VoxelShapeTemplate implements IVoxelTemplate<"shape", VoxelShapeTemplateData> {
+    static Register: typeof VoxelTemplateRegister;
+    static CreateNew(data: Partial<VoxelShapeTemplateData>): VoxelShapeTemplateData;
+    index: Flat3DIndex;
+    bounds: BoundingBox;
+    fillMode: VoxelShapeTemplateFillModes;
+    fillVoxel: PaintVoxelData;
+    faceVoxel: PaintVoxelData;
+    edgeVoxel: PaintVoxelData;
+    pointVoxel: PaintVoxelData;
+    _fillVoxel: RawVoxelData;
+    _faceVoxel: RawVoxelData;
+    _edgeVoxel: RawVoxelData;
+    _pointVoxel: RawVoxelData;
+    shapeSelection: IVoxelShapeSelection<any, IVoxelShapeSelectionData<any>>;
+    constructor(data?: VoxelShapeTemplateData);
+    inBounds(x: number, y: number, z: number): boolean;
+    setVoxels(fill: PaintVoxelData, face?: PaintVoxelData, edge?: PaintVoxelData, point?: PaintVoxelData): void;
+    getIndex(x: number, y: number, z: number): number;
+    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;
+    clone(): VoxelShapeTemplate;
+    toJSON(): VoxelShapeTemplateData;
+    fromJSON(data: VoxelShapeTemplateData): void;
+}