@divinevoxel/vlox 0.0.76 → 0.0.77

package/Builder/Tools/Box/BoxTool.js

@@ -1,91 +0,0 @@
-import { VoxelBoxSelection } from "../../../Templates/Selection/VoxelBoxSelection";
-import { Vector3Like } from "@amodx/math";
-import { BoxSelection } from "./BoxSelection";
-import { BoxToolTemplate } from "./BoxToolTemplate";
-import { BuilderToolBase } from "../BuilderToolBase";
-export var BoxToolModes;
-(function (BoxToolModes) {
-    BoxToolModes["Fill"] = "Fill";
-    BoxToolModes["Extrude"] = "Extrude";
-    BoxToolModes["Template"] = "Template";
-    BoxToolModes["Remove"] = "Remove";
-})(BoxToolModes || (BoxToolModes = {}));
-export class BoxTool extends BuilderToolBase {
-    space;
-    static ToolId = "Box";
-    static ModeArray = [
-        BoxToolModes.Fill,
-        BoxToolModes.Extrude,
-        BoxToolModes.Template,
-        BoxToolModes.Remove,
-    ];
-    mode = BoxToolModes.Fill;
-    selection = new VoxelBoxSelection();
-    boxSelection;
-    constructor(space) {
-        super();
-        this.space = space;
-        console.warn("CREATE BOX TOOL", this.space, this.selection);
-        this.boxSelection = new BoxSelection(this.space, this.selection);
-    }
-    _started = false;
-    isSelectionStarted() {
-        return this._started;
-    }
-    updateOffset(offset) {
-        this.boxSelection.offset = offset;
-        this.boxSelection.update();
-    }
-    updatePlacer(picked, placerMode = null) {
-        if (!this._started && !placerMode && picked) {
-            if (this.mode == BoxToolModes.Fill ||
-                this.mode == BoxToolModes.Template ||
-                this.mode == BoxToolModes.Extrude) {
-                this.selection.reConstruct(picked.normalPosition, picked.normal, Vector3Like.Add(picked.normalPosition, Vector3Like.Create(1, 1, 1)), picked.normal);
-            }
-            if (this.mode == BoxToolModes.Remove) {
-                this.selection.reConstruct(picked.position, picked.normal, Vector3Like.Add(picked.position, Vector3Like.Create(1, 1, 1)), picked.normal);
-            }
-        }
-        if (!this._started && placerMode == "start" && picked) {
-            this.boxSelection.offset = 0;
-            Vector3Like.Copy(this.boxSelection.planeNormal, picked.normal);
-            if (this.mode == BoxToolModes.Fill ||
-                this.mode == BoxToolModes.Template ||
-                this.mode == BoxToolModes.Extrude) {
-                Vector3Like.Copy(this.boxSelection.planeOrigin, picked.normalPosition);
-            }
-            if (this.mode == BoxToolModes.Remove) {
-                Vector3Like.Copy(this.boxSelection.planeOrigin, picked.position);
-            }
-            this.boxSelection.update();
-            this._started = true;
-            return;
-        }
-        if (this._started && !placerMode && !picked) {
-            this.boxSelection.update();
-            return;
-        }
-        if (this._started && placerMode == "end") {
-            this.boxSelection.update();
-            this._started = false;
-        }
-    }
-    async use(voxelData, usePlacingStrategy = true) {
-        if (this.mode == BoxToolModes.Fill) {
-            await this.space.paintTemplate(Vector3Like.ToArray(this.selection.origin), this.selection
-                .toTemplate({
-                fillVoxel: voxelData,
-            })
-                .toJSON());
-        }
-        if (this.mode == BoxToolModes.Template) {
-            const boxTemplate = new BoxToolTemplate(this.space, this.selection.clone());
-            await boxTemplate.create();
-            this.dispatch("template-created", boxTemplate);
-        }
-        if (this.mode == BoxToolModes.Remove) {
-            await this.space.eraseTemplate(Vector3Like.ToArray(this.selection.origin), this.selection.toTemplate({}).toJSON());
-        }
-    }
-}

package/Builder/Tools/Box/BoxToolTemplate.d.ts

@@ -1,13 +0,0 @@
-import { FullVoxelTemplate } from "../../../Templates/Full/FullVoxelTemplate";
-import { VoxelBoxSelection } from "../../../Templates/Selection/VoxelBoxSelection";
-import { VoxelBuildSpace } from "../../VoxelBuildSpace";
-export declare class BoxToolTemplate {
-    space: VoxelBuildSpace;
-    selection: VoxelBoxSelection;
-    template: FullVoxelTemplate;
-    private _created;
-    constructor(space: VoxelBuildSpace, selection: VoxelBoxSelection);
-    create(): Promise<void>;
-    place(): Promise<void>;
-    clear(): Promise<void>;
-}

package/Builder/Tools/Box/BoxToolTemplate.js

@@ -1,23 +0,0 @@
-export class BoxToolTemplate {
-    space;
-    selection;
-    template;
-    _created = false;
-    constructor(space, selection) {
-        this.space = space;
-        this.selection = selection;
-    }
-    async create() {
-        if (this._created)
-            return;
-        const bounds = this.selection.bounds.getMinMax();
-        this.template = await this.space.createTemplate(bounds);
-        this._created = true;
-    }
-    async place() {
-        await this.space.paintTemplate(this.selection.origin, this.template.toJSON());
-    }
-    async clear() {
-        await this.space.eraseTemplate(this.selection.origin, this.template.toJSON());
-    }
-}

package/Builder/VoxelBuilder.types.js

@@ -1 +0,0 @@
-"use strict";

package/Mesher/Functions/CompactVoxelMesh.d.ts

@@ -1,3 +0,0 @@
-import { CompactMeshData } from "../Types/Mesher.types";
-import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
-export declare function CompactVoxelMesh(tools: VoxelModelBuilder[], transfers?: any[]): CompactMeshData;

package/Mesher/Functions/MeshTexture.js

@@ -1,278 +0,0 @@
-import { Quad } from "../Geomtry/Primitives/Quad";
-const Quads = {
-    north: Quad.Create([
-        [1, 1, 0],
-        [0, 1, 0],
-        [0, 0, 0],
-        [1, 0, 0],
-    ], Quad.FullUVs),
-    south: Quad.Create([
-        [1, 1, 0],
-        [0, 1, 0],
-        [0, 0, 0],
-        [1, 0, 0],
-    ], Quad.FullUVs),
-};
-//const tool = new MesherDataTool();
-//tool.startNewMesh();
-//tool.mesh!.attributes.set("uv", [[], 2, BinaryNumberTypes.Float32]);
-//tool.mesh!.attributes.set("textureIndex", [[], 3, BinaryNumberTypes.Float32]);
-export function MeshTexture(textureId, textureData) {
-    /*
-      const width = Math.sqrt(textureData.length / 4);
-      const height = Math.sqrt(textureData.length / 4);
-      const factor = 1 / width;
-    
-      const textureDataIndex = Flat2DIndex.GetXYOrder();
-      textureDataIndex.setBounds(width, height);
-    
-      const origin = Vector3Like.Create(-0.5, -0.5, -0.5);
-    
-      const isSolid = (x: number, y: number) =>
-        x >= 0 &&
-        x < width &&
-        y >= 0 &&
-        y < height &&
-        textureData[textureDataIndex.getIndexXY(x, y) * 4 + 3] > 0.01
-          ? true
-          : false;
-    
-      const uvs = tool.mesh!.getAttribute("uv");
-      const textureIndex = tool.mesh!.getAttribute("textureIndex");
-      const uvOffset = width > 16 ? -(2 / Math.max(width, height)) : 0;
-    
-      const addUvs = (sx: number, sy: number, ex: number, ey: number) => {
-        uvs.push(
-          (ex + uvOffset) * factor,
-          (ey + uvOffset) * factor,
-          (sx - uvOffset) * factor,
-          (ey + uvOffset) * factor,
-          (sx - uvOffset) * factor,
-          (sy - uvOffset) * factor,
-          (ex + uvOffset) * factor,
-          (sy - uvOffset) * factor
-        );
-        textureIndex.push(
-          textureId,
-          0,
-          0,
-          textureId,
-          0,
-          0,
-          textureId,
-          0,
-          0,
-          textureId,
-          0,
-          0
-        );
-      };
-    
-      {
-        GeometryBuilder.addQuad(tool, origin, Quads.south);
-        uvs.push(
-          Quads.south.uvs.vertices[QuadVerticies.TopRight].x,
-          Quads.south.uvs.vertices[QuadVerticies.TopRight].y,
-          Quads.south.uvs.vertices[QuadVerticies.TopLeft].x,
-          Quads.south.uvs.vertices[QuadVerticies.TopLeft].y,
-          Quads.south.uvs.vertices[QuadVerticies.BottomLeft].x,
-          Quads.south.uvs.vertices[QuadVerticies.BottomLeft].y,
-          Quads.south.uvs.vertices[QuadVerticies.BottomRight].x,
-          Quads.south.uvs.vertices[QuadVerticies.BottomRight].y
-        );
-    
-        textureIndex.push(
-          textureId,
-          0,
-          0,
-          textureId,
-          0,
-          0,
-          textureId,
-          0,
-          0,
-          textureId,
-          0,
-          0
-        );
-      }
-    
-      {
-        const backPositionZ = factor;
-        Quads.north.positions.vertices[QuadVerticies.TopRight].z = backPositionZ;
-        Quads.north.positions.vertices[QuadVerticies.TopLeft].z = backPositionZ;
-        Quads.north.positions.vertices[QuadVerticies.BottomLeft].z = backPositionZ;
-        Quads.north.positions.vertices[QuadVerticies.BottomRight].z = backPositionZ;
-        Quads.north.flip = true;
-        uvs.push(
-          Quads.north.uvs.vertices[QuadVerticies.TopLeft].x,
-          Quads.north.uvs.vertices[QuadVerticies.TopLeft].y,
-          Quads.north.uvs.vertices[QuadVerticies.TopRight].x,
-          Quads.north.uvs.vertices[QuadVerticies.TopRight].y,
-          Quads.north.uvs.vertices[QuadVerticies.BottomRight].x,
-          Quads.north.uvs.vertices[QuadVerticies.BottomRight].y,
-          Quads.north.uvs.vertices[QuadVerticies.BottomLeft].x,
-          Quads.north.uvs.vertices[QuadVerticies.BottomLeft].y
-        );
-        GeometryBuilder.addQuad(tool, origin, Quads.north);
-        textureIndex.push(
-          textureId,
-          0,
-          0,
-          textureId,
-          0,
-          0,
-          textureId,
-          0,
-          0,
-          textureId,
-          0,
-          0
-        );
-      }
-    
-      for (let x = 0; x < width; x++) {
-        let eastFace: Vec2Array | null = null;
-        let westFace: Vec2Array | null = null;
-        for (let y = 0; y < height; y++) {
-          let eastFaceExposed = true;
-          let westFaceExposed = true;
-    
-          if (!isSolid(x, y)) {
-            eastFaceExposed = false;
-            westFaceExposed = false;
-          }
-          if (isSolid(x + 1, y)) {
-            eastFaceExposed = false;
-          }
-          if (isSolid(x - 1, y)) {
-            westFaceExposed = false;
-          }
-    
-          if (eastFace && !eastFaceExposed) {
-            const newQuad = Quad.Create(
-              [
-                [x * factor + factor, eastFace[1] * factor, 0],
-                [x * factor + factor, y * factor, factor],
-              ],
-              Quad.FullUVs as any,
-              false,
-              0
-            );
-            GeometryBuilder.addQuad(tool, origin, newQuad);
-    
-            let [sx, sy] = eastFace;
-            let ex = x;
-            let ey = y;
-            ex += 1;
-            addUvs(sx, sy, ex, ey);
-            eastFace = null;
-          }
-    
-          if (westFace && !westFaceExposed) {
-            const newQuad = Quad.Create(
-              [
-                [x * factor, westFace[1] * factor, 0],
-                [x * factor, y * factor, factor],
-              ],
-              Quad.FullUVs as any,
-              false,
-              1
-            );
-            GeometryBuilder.addQuad(tool, origin, newQuad);
-            let [sx, sy] = westFace;
-            let ex = x;
-            let ey = y;
-            ex += 1;
-            addUvs(sx, sy, ex, ey);
-            westFace = null;
-          }
-          const isPixel = isSolid(x, y);
-          if (!isSolid(x + 1, y) && !eastFace && isPixel) {
-            eastFace = [x, y];
-          }
-          if (!isSolid(x - 1, y) && !westFace && isPixel) {
-            westFace = [x, y];
-          }
-        }
-      }
-      for (let y = 0; y < height; y++) {
-        let upFace: Vec2Array | null = null;
-        let downFace: Vec2Array | null = null;
-    
-        for (let x = 0; x < width; x++) {
-          let upFaceExposed = true;
-          let downFaceExposed = true;
-    
-          if (!isSolid(x, y)) {
-            upFaceExposed = false;
-            downFaceExposed = false;
-          }
-          if (isSolid(x, y + 1)) {
-            upFaceExposed = false;
-          }
-          if (isSolid(x, y - 1)) {
-            downFaceExposed = false;
-          }
-    
-          if (upFace && !upFaceExposed) {
-            const newQuad = Quad.Create(
-              [
-                [upFace[0] * factor, y * factor + factor, 0],
-                [x * factor, y * factor + factor, factor],
-              ],
-              Quad.FullUVs as any,
-              false,
-              0
-            );
-            GeometryBuilder.addQuad(tool, origin, newQuad);
-            let [sx, sy] = upFace;
-            let [ex, ey] = [x, y];
-    
-            ey += 1;
-            addUvs(sx, sy, ex, ey);
-            upFace = null;
-          }
-    
-          if (downFace && !downFaceExposed) {
-            const newQuad = Quad.Create(
-              [
-                [downFace[0] * factor, y * factor, 0],
-                [x * factor, y * factor, factor],
-              ],
-              Quad.FullUVs as any,
-              false,
-              1
-            );
-            GeometryBuilder.addQuad(tool, origin, newQuad);
-            let [sx, sy] = downFace;
-            let [ex, ey] = [x, y];
-            ey += 1;
-            addUvs(sx, sy, ex, ey);
-            downFace = null;
-          }
-    
-          const isPixel = isSolid(x, y);
-          if (!isSolid(x, y + 1) && !upFace && isPixel) {
-            upFace = [x, y];
-          }
-          if (!isSolid(x, y - 1) && !downFace && isPixel) {
-            downFace = [x, y];
-          }
-        }
-      }
-    
-      for (const [key, [data]] of tool.mesh!.attributes) {
-        if (key == "position") {
-          for (let i = 0; i < data.length; i += 3) {
-            (data as any as number[])[i] -= 0.5;
-            (data as any as number[])[i + 1] -= 0.5;
-            (data as any as number[])[i + 2];
-          }
-        }
-      }
-    
-      const compacted = CompactMesh("dve_node", tool);
-     */
-    //  return tool.mesh;
-}

package/Mesher/Geomtry/VoxelMesh.d.ts

@@ -1,12 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./VoxelMeshBuffers";
-export declare class VoxelMesh {
-    indicieCount: number;
-    vertexCount: number;
-    minBounds: Vector3Like;
-    maxBounds: Vector3Like;
-    readonly buffer: VoxelVertexBuffer;
-    readonly indices: VoxelIndiceBuffer;
-    addVerticies(vertexCount: number, indicesCount: number): void;
-    clear(): void;
-}

package/Mesher/Geomtry/VoxelMesh.js

@@ -1,25 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./VoxelMeshBuffers";
-import { VoxelMeshVertexStructCursor } from "./VoxelMeshVertexStructCursor";
-export class VoxelMesh {
-    indicieCount = 0;
-    vertexCount = 0;
-    minBounds = Vector3Like.Create(Infinity, Infinity, Infinity);
-    maxBounds = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
-    buffer = new VoxelVertexBuffer(VoxelMeshVertexStructCursor.VertexFloatSize, 1024);
-    indices = new VoxelIndiceBuffer(1024);
-    addVerticies(vertexCount, indicesCount) {
-        this.vertexCount += vertexCount;
-        this.indicieCount += indicesCount;
-    }
-    clear() {
-        this.indicieCount = 0;
-        this.vertexCount = 0;
-        this.minBounds.x = Infinity;
-        this.minBounds.y = Infinity;
-        this.minBounds.z = Infinity;
-        this.maxBounds.x = -Infinity;
-        this.maxBounds.y = -Infinity;
-        this.maxBounds.z = -Infinity;
-    }
-}

package/Mesher/Models/Procedures/Default/ConsistentRotationTextureProcedure.d.ts

@@ -1,25 +0,0 @@
-import { Vec3Array, Vector4Like } from "@amodx/math";
-import type { Quad } from "../../../Geomtry";
-import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
-import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
-import { TextureId } from "Textures";
-import { VoxelFaces } from "Math";
-/**
- * Extend your data type so we can add a seed if we want, and define
- * the rotations we can choose from.
- */
-interface VoxelGeometryConsistentRotationTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
-    type: "consistent-rotation";
-    texture: TextureId | number;
-    /**
-     * You can allow (0 | 90 | 180 | 270), or remove 0 if you don’t want an unrotated option
-     */
-    rotations: (0 | 90 | 180 | 270)[];
-    rotationBounds?: Vec3Array;
-}
-export declare class ConsistentRotationTextureProcedure extends TextureProcedure<VoxelGeometryConsistentRotationTextureProcedureData> {
-    getTexture(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
-    getOverlayTexture(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
-    transformUVs(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
-}
-export {};

package/Mesher/Models/Procedures/Default/OutlinedTextureProcedure.js

@@ -1,162 +0,0 @@
-import { TextureProcedure } from "../TextureProcedure";
-import { VoxelFaces } from "../../../../Math/index.js";
-const textureMap = [
-    "top",
-    "corner-top-right",
-    "corner-top-left",
-    "corner-top-left-top-right",
-    "bottom",
-    "corner-bottom-right",
-    "corner-bottom-left",
-    "corner-bottom-left-bottom-right",
-    "right",
-    "left",
-];
-/*
-0 -> normal direction
-1 -> top right
-2 -> top left
-*/
-const uvsSets = {
-    //top bottom faces
-    north: {
-        0b0: 0,
-        0b101: 1,
-        0b011: 2,
-        0b001: 3,
-    },
-    south: {
-        0b0: 4,
-        0b101: 5,
-        0b011: 6,
-        0b001: 7,
-    },
-    east: {
-        0b0: 8,
-    },
-    west: {
-        0b0: 9,
-    },
-    //side faces
-    top: {
-        0b0: 0,
-        0b101: 1,
-        0b011: 2,
-        0b001: 3,
-    },
-    bottom: {
-        0b0: 4,
-        0b101: 5,
-        0b011: 6,
-        0b001: 7,
-    },
-    right: {
-        0b0: 8,
-    },
-    left: {
-        0b0: 9,
-    },
-};
-const topAndDown = {
-    north: [
-        [0, 0, 1],
-        [1, 0, 1],
-        [-1, 0, 1],
-    ],
-    south: [
-        [0, 0, -1],
-        [1, 0, -1],
-        [-1, 0, -1],
-    ],
-    east: [[1, 0, 0]],
-    west: [[-1, 0, 0]],
-};
-const eastAndWest = {
-    north: [
-        [0, 1, 0],
-        [0, 1, 1],
-        [0, 1, -1],
-    ],
-    south: [
-        [0, -1, 0],
-        [0, -1, 1],
-        [0, -1, -1],
-    ],
-    east: [[0, 0, 1]],
-    west: [[0, 0, -1]],
-};
-const northAndSouth = {
-    north: [
-        [0, 1, 0],
-        [1, 1, 0],
-        [-1, 1, 0],
-    ],
-    south: [
-        [0, -1, 0],
-        [1, -1, 0],
-        [-1, -1, 0],
-    ],
-    east: [[1, 0, 0]],
-    west: [[-1, 0, 0]],
-};
-const CheckSets = {
-    [VoxelFaces.Up]: topAndDown,
-    [VoxelFaces.Down]: topAndDown,
-    [VoxelFaces.North]: northAndSouth,
-    [VoxelFaces.South]: northAndSouth,
-    [VoxelFaces.East]: eastAndWest,
-    [VoxelFaces.West]: eastAndWest,
-};
-const generateCheck = (direction, tool, normal, sets) => {
-    const { x, y, z } = tool.position;
-    let key = 0b0;
-    for (let i = 0; i < sets.length; i++) {
-        const set = sets[i];
-        const cx = x + set[0];
-        const cy = y + set[1];
-        const cz = z + set[2];
-        const sameLevelCheck = tool.nVoxel
-            .getVoxel(cx, cy, cz)
-            ?.isSameVoxel(tool.voxel);
-        let normalCheck = true;
-        const nVoxel = tool.nVoxel.getVoxel(cx + normal[0], cy + normal[1], cz + normal[2]);
-        if (nVoxel && nVoxel.isRenderable() && nVoxel.isOpaque()) {
-            normalCheck = false;
-        }
-        if (sameLevelCheck && normalCheck) {
-            key |= 0b1 << i;
-        }
-        else {
-            key |= 0b0 << i;
-            if (i == 0)
-                break;
-        }
-    }
-    if (uvsSets[direction][key] == undefined)
-        return 0;
-    const index = uvsSets[direction][key];
-    return textureMap[index];
-};
-const normal = [0, 0, 0];
-export class OutlinedTextureProcedure extends TextureProcedure {
-    getTexture(builder, data, closestFace, primitive) {
-        return data.texture;
-    }
-    getOverlayTexture(builder, data, closestFace, primitive, ref) {
-        const set = CheckSets[closestFace];
-        const x = generateCheck("north", builder, normal, set.north);
-        if (x)
-            ref.x = data.textureRecrod[x];
-        const y = generateCheck("south", builder, normal, set.south);
-        if (y)
-            ref.y = data.textureRecrod[y];
-        const z = generateCheck("east", builder, normal, set.east);
-        if (z)
-            ref.z = data.textureRecrod[z];
-        const w = generateCheck("west", builder, normal, set.west);
-        if (w)
-            ref.w = data.textureRecrod[w];
-        return ref;
-    }
-    transformUVs(builder, data, closestFace, primitive) { }
-}

package/Templates/Selection/VoxelSelecton.d.ts

@@ -1,9 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
-export interface IVoxelSelection {
-    origin: Vector3Like;
-    size: Vector3Like;
-    bounds: BoundingBox;
-    isSelected(x: number, y: number, z: number): boolean;
-    clone(): IVoxelSelection;
-}

package/Templates/Shapes/BasicVoxelShapeTemplate.d.ts

@@ -1,36 +0,0 @@
-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;
-    abstract clone(): BasicVoxelShapeTemplate<Type, Data, Events>;
-    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>;
-}