@divinevoxel/vlox 0.0.2 → 0.0.4

package/{VoxelModels/Constructor → Mesher/Models}/VoxelGeometryLookUp.js

@@ -1,9 +1,7 @@
-import { VoxelConstructorsRegister } from "../../Mesher/Constructors/Voxel/VoxelConstructorsRegister";
-import { DataTool } from "../../Tools/Data/DataTool";
-import { VoxelModelConstructorRegister } from "./Register/VoxelModelConstructorRegister";
+import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
 import { Vector3Like } from "@amodx/math";
+import { VoxelCursor } from "../../Data/Cursor/VoxelCursor";
 export class VoxelGeometryLookUp {
-    static dataTool;
     static voxelHash = [];
     static modCache = [];
     static stateCache = [];
@@ -12,11 +10,9 @@ export class VoxelGeometryLookUp {
     static conditionalGeometryCache = [];
     static noCastAO = [];
     static offset = [0, 0, 0];
-    static init() {
-        this.dataTool = new DataTool();
-    }
+    static voxelCursor = new VoxelCursor();
+    static init() { }
     static start(dimension, x, y, z) {
-        this.dataTool.setDimension(dimension);
         this.offset[0] = x;
         this.offset[1] = y;
         this.offset[2] = z;
@@ -33,45 +29,52 @@ export class VoxelGeometryLookUp {
         this.conditonalStateCache.length = 0;
         this.noCastAO.length = 0;
     }
-    static getHash(x, y, z) {
+    static getHash(dataCursor, x, y, z) {
         const hashed = Vector3Like.HashXYZ(x - this.offset[0], y - this.offset[1], z - this.offset[2]);
         if (!this.stateCache[hashed])
-            this.hashState(hashed, x, y, z);
+            this.hashState(dataCursor, hashed, x, y, z);
         return hashed;
     }
-    static hashState(hashed, x, y, z) {
+    static hashState(dataCursor, hashed, x, y, z) {
         if (this.stateCache[hashed] !== undefined)
             return this.stateCache[hashed];
-        if (!this.dataTool.loadInAt(x, y, z)) {
+        const voxel = dataCursor.getVoxel(x, y, z);
+        if (!voxel) {
             this.stateCache[hashed] = -1;
             return -1;
         }
-        if (!this.dataTool.isRenderable()) {
+        if (!voxel.isRenderable()) {
             this.stateCache[hashed] = -1;
             return -1;
         }
-        const voxelConstructor = VoxelConstructorsRegister.constructorsPaltte[this.dataTool.getId()];
+        const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getId()];
         if (!voxelConstructor || !voxelConstructor.isModel) {
             this.stateCache[hashed] = -1;
             return -1;
         }
-        voxelConstructor.model.schema.voxel.setDimension(this.dataTool.dimension);
-        voxelConstructor.model.schema.voxel.loadInAt(x, y, z);
-        const shapeState = this.dataTool.getShapeState();
-        const state = voxelConstructor.model.shapeStateTree.getState(shapeState);
-        const mod = this.dataTool.getMod();
+        //no ao
+        this.noCastAO[hashed] = voxel.isLightSource() || voxel.noAO();
+        //state
+        const shapeState = voxel.getShapeState();
+        const state = voxelConstructor.shapeStateTree.getState(shapeState);
+        this.stateCache[hashed] = state;
+        //mod
+        const mod = voxel.getMod();
         const modState = voxelConstructor.modTree.getState(mod);
         this.modCache[hashed] = modState;
-        const conditonalState = voxelConstructor.model.condtioanlShapeStateTree.getState(shapeState);
-        this.stateCache[hashed] = state;
+        this.voxelCursor.copy(voxel).process();
+        voxelConstructor.schema.position.x = x;
+        voxelConstructor.schema.position.y = y;
+        voxelConstructor.schema.position.z = z;
+        voxelConstructor.schema.voxel = this.voxelCursor;
+        voxelConstructor.schema.dataCursor = dataCursor;
+        const conditonalState = voxelConstructor.condtioanlShapeStateTree.getState();
         this.voxelHash[hashed] = voxelConstructor;
         this.conditonalStateCache[hashed] = conditonalState;
-        this.noCastAO[hashed] =
-            this.dataTool.isLightSource() || this.dataTool.noAO();
         this.geometryCache[hashed] =
-            voxelConstructor.model.data.shapeStateGeometryMap[state];
+            voxelConstructor.data.shapeStateGeometryMap[state];
         this.conditionalGeometryCache[hashed] =
-            voxelConstructor.model.data.condiotnalShapeStateGeometryMap[conditonalState];
+            voxelConstructor.data.condiotnalShapeStateGeometryMap[conditonalState];
         return state;
     }
 }

package/Mesher/Models/VoxelModelConstructorRegister.d.ts

@@ -0,0 +1,21 @@
+import { StringPalette } from "../../Util/StringPalette";
+import { VoxelGeometryRulelessSyncData, VoxelGeometrySyncData, VoxelModelSyncData } from "../../Voxels/VoxelSyncData";
+import { GeoemtryNodeConstructor } from "./Nodes/GeometryNode";
+import { VoxelConstructor } from "./VoxelConstructor";
+import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
+export declare class VoxelModelConstructorRegister {
+    static geometryPalette: StringPalette;
+    static geometry: VoxelGeometryConstructor[];
+    static rulesless: boolean[];
+    static setGeometryPalette(palette: string[]): void;
+    static modelData: Map<string, VoxelModelSyncData>;
+    static customNodes: Map<string, GeoemtryNodeConstructor<any, any>>;
+    static registerModels(models: VoxelModelSyncData[]): void;
+    static registerCustomNode(id: string, node: GeoemtryNodeConstructor<any, any>): void;
+    static getCustomNode(id: string): GeoemtryNodeConstructor<any, any>;
+    static constructorsPaltte: VoxelConstructor[];
+    static constructors: Map<string, VoxelConstructor>;
+    static getConstructor(id: string): VoxelConstructor;
+    static registerVoxel(voxel: VoxelConstructor | VoxelConstructor[]): void;
+    static registerGeometry(geometries: (VoxelGeometrySyncData | VoxelGeometryRulelessSyncData)[]): void;
+}

package/Mesher/Models/VoxelModelConstructorRegister.js

@@ -0,0 +1,53 @@
+import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { StringPalette } from "../../Util/StringPalette";
+import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
+export class VoxelModelConstructorRegister {
+    static geometryPalette;
+    static geometry = [];
+    static rulesless = [];
+    static setGeometryPalette(palette) {
+        this.geometryPalette = new StringPalette(palette);
+    }
+    static modelData = new Map();
+    static customNodes = new Map();
+    static registerModels(models) {
+        models.forEach((_) => this.modelData.set(_.id, _));
+    }
+    static registerCustomNode(id, node) {
+        this.customNodes.set(id, node);
+    }
+    static getCustomNode(id) {
+        const node = this.customNodes.get(id);
+        if (!node)
+            throw new Error(`Custom geometry node [${id}] does not exist.`);
+        return node;
+    }
+    static constructorsPaltte = [];
+    static constructors = new Map();
+    static getConstructor(id) {
+        return this.constructors.get(id);
+    }
+    static registerVoxel(voxel) {
+        if (Array.isArray(voxel)) {
+            for (const vox of voxel) {
+                this.constructors.set(vox.id, vox);
+                this.constructorsPaltte[VoxelPalette.ids.getNumberId(vox.id)] = vox;
+            }
+            return;
+        }
+        this.constructorsPaltte[VoxelPalette.ids.getNumberId(voxel.id)] = voxel;
+        this.constructors.set(voxel.id, voxel);
+    }
+    static registerGeometry(geometries) {
+        for (const geometry of geometries) {
+            const paletteId = this.geometryPalette.getNumberId(geometry.id);
+            this.geometry[paletteId] = new VoxelGeometryConstructor(paletteId, geometry);
+            if (geometry.ruleless == true) {
+                this.rulesless[paletteId] = true;
+            }
+            else {
+                this.rulesless[paletteId] = false;
+            }
+        }
+    }
+}

package/Mesher/Models/VoxelModelEffect.d.ts

@@ -0,0 +1,13 @@
+import { VoxelConstructor } from "./VoxelConstructor";
+import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+import { Vec3Array, Vector3Like } from "@amodx/math";
+export declare class VoxelModelEffect {
+    model: VoxelConstructor;
+    effects: {
+        id: string;
+        reader: StateTreeReader;
+        palette: Vec3Array[][];
+    }[];
+    constructor(model: VoxelConstructor);
+    addEffects(state: number, origin: Vector3Like, effects: Record<string, number[]>): void;
+}

package/Mesher/Models/VoxelModelEffect.js

@@ -0,0 +1,43 @@
+import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
+export class VoxelModelEffect {
+    model;
+    effects = [];
+    constructor(model) {
+        this.model = model;
+        for (const effect of model.data.effects) {
+            if (effect.type == "fx-points") {
+                this.effects.push({
+                    id: effect.effectId,
+                    reader: new StateTreeReader(model.schema, 0, effect.tree),
+                    palette: effect.treePalette,
+                });
+            }
+        }
+    }
+    addEffects(state, origin, effects) {
+        if (!this.effects.length)
+            return;
+        for (let i = 0; i < this.effects.length; i++) {
+            const e = this.effects[i];
+            let array = effects[e.id];
+            if (!array) {
+                array = [];
+                effects[e.id] = array;
+            }
+            const effectState = e.reader.getState(state);
+            if (effectState == -1)
+                continue;
+            const v = e.palette[effectState];
+            if (!v)
+                continue;
+            let start = array.length;
+            for (let i = 0; i < v.length; i++) {
+                const point = v[i];
+                array[start] = origin.x + point[0];
+                array[start + 1] = origin.y + point[1];
+                array[start + 2] = origin.z + point[2];
+                start += 3;
+            }
+        }
+    }
+}

package/Mesher/Processors/ChunkProcessor.d.ts

@@ -1,9 +1,13 @@
 import type { LocationData } from "../../Math/index.js";
 import { HeightMapTool } from "../../Tools/Data/WorldData/HeightMapTool.js";
-import { BuilderDataTool } from "../Tools/BuilderDataTool.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
+import { ChunkCursor } from "../../Data/Cursor/World/ChunkCursor.js";
 export declare class ChunkProcessor {
-    mDataTool: BuilderDataTool;
     heightMapTool: HeightMapTool;
+    substanceData: SubstanceDataTool;
+    chunkCursor: ChunkCursor;
+    worldCursor: WorldCursor;
     _process(x: number, y: number, z: number, doSecondCheck?: boolean): boolean;
     build(location: LocationData, priority?: number): void;
 }

package/Mesher/Processors/ChunkProcessor.js

@@ -1,57 +1,74 @@
 //objects
-import { RenderedSubstances } from "../Rules/RenderedSubstances.js";
 import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
 //data
 import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
 //tools
 import { HeightMapTool } from "../../Tools/Data/WorldData/HeightMapTool.js";
-import { BuilderDataTool } from "../Tools/BuilderDataTool.js";
-import { ShapeTool } from "../Shapes/ShapeTool.js";
-import { VoxelGeometryLookUp } from "../../VoxelModels/Constructor/VoxelGeometryLookUp.js";
+import { VoxelGeometryLookUp } from "../Models//VoxelGeometryLookUp.js";
+import { CompactVoxelMesh } from "../Functions/CompactVoxelMesh.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
+import { ChunkCursor } from "../../Data/Cursor/World/ChunkCursor.js";
+import { RenderedSubstances } from "../Substances/RenderedSubstances.js";
+import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
 export class ChunkProcessor {
-    mDataTool = new BuilderDataTool();
     heightMapTool = new HeightMapTool();
+    substanceData = new SubstanceDataTool();
+    chunkCursor = new ChunkCursor();
+    worldCursor = new WorldCursor();
     _process(x, y, z, doSecondCheck = false) {
-        if (!this.mDataTool.loadInAt(x, y, z))
+        const voxel = this.chunkCursor.getVoxel(x, y, z);
+        if (!voxel)
             return false;
-        if (!this.mDataTool.isRenderable())
+        if (!voxel.isRenderable())
             return false;
         let hasVoxel = false;
-        this.mDataTool.setSecondary(doSecondCheck);
+        voxel.setSecondary(doSecondCheck);
         if (!doSecondCheck) {
-            if (this.mDataTool.hasSecondaryVoxel()) {
+            if (voxel.hasSecondaryVoxel()) {
                 hasVoxel = this._process(x, y, z, true);
             }
         }
-        const constructor = this.mDataTool.getConstructor();
-        const mesher = RenderedSubstances.meshers.get(this.mDataTool.getSubstnaceData().getRendered());
-        if (!mesher || !constructor) {
-            throw new Error(`Could not find mesh or constructor ${this.mDataTool.getId()} | ${this.mDataTool.getName()} | ${this.mDataTool.getConstructor()?.id}`);
+        const constructor = VoxelModelConstructorRegister.getConstructor(voxel.getStringId());
+        if (!constructor) {
+            throw new Error(`Could not find constructor ${voxel.getId()} | ${voxel.getName()} `);
         }
-        const voxelPOS = WorldSpaces.voxel.getPositionXYZ(x, y, z);
-        ShapeTool.origin.x = voxelPOS.x;
-        ShapeTool.origin.y = voxelPOS.y;
-        ShapeTool.origin.z = voxelPOS.z;
-        mesher.voxel.loadInAt(x, y, z);
-        mesher.nVoxel.loadInAt(x, y, z);
-        ShapeTool.setMesher(mesher);
+        const mesher = RenderedSubstances.meshers.get(voxel.getRenderedMaterialStringId());
+        if (!mesher) {
+            throw new Error(`Could not find material for ${voxel.getId()} | ${voxel.getName()} | ${constructor?.id} | ${voxel.getMaterial()} | ${voxel.getRenderedMaterialStringId()}`);
+        }
+        mesher.origin.x = this.chunkCursor._voxelPosition.x;
+        mesher.origin.y = this.chunkCursor._voxelPosition.y;
+        mesher.origin.z = this.chunkCursor._voxelPosition.z;
+        mesher.position.x = x;
+        mesher.position.y = y;
+        mesher.position.z = z;
+        mesher.voxel = voxel;
+        mesher.nVoxel = this.worldCursor;
+        mesher.startConstruction();
         constructor.process(mesher);
+        mesher.endConstruction();
         mesher.resetVars();
         return true;
     }
     build(location, priority = 0) {
         this.heightMapTool.chunk.loadInAtLocation(location);
-        this.mDataTool.setDimension(location[0]);
-        RenderedSubstances.setDimension(location[0]);
         const [dimension, cx, cy, cz] = location;
+        this.worldCursor.setFocalPoint(...location);
+        this.chunkCursor.setChunk(...location);
         let [minY, maxY] = this.heightMapTool.chunk.getMinMax();
+        const maxX = WorldSpaces.chunk._bounds.x;
+        const maxZ = WorldSpaces.chunk._bounds.z;
         if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
             return;
         VoxelGeometryLookUp.start(dimension, location[1], location[2], location[3]);
+        for (const [substance, mesher] of RenderedSubstances.meshers) {
+            mesher.bvhTool.reset();
+        }
         for (let y = minY; y <= maxY; y++) {
             let foundVoxels = false;
-            for (let x = 0; x < WorldSpaces.chunk._bounds.x; x++) {
-                for (let z = 0; z < WorldSpaces.chunk._bounds.z; z++) {
+            for (let x = 0; x < maxX; x++) {
+                for (let z = 0; z < maxZ; z++) {
                     if (this._process(x + cx, y + cy, z + cz)) {
                         foundVoxels = true;
                     }
@@ -61,17 +78,38 @@ export class ChunkProcessor {
             this.heightMapTool.chunk.setY(y).setDirty(false);
         }
         VoxelGeometryLookUp.stop();
-        const chunks = [location, [], priority];
         const trasnfers = [];
+        const chunkEffects = [];
+        const chunks = [
+            location,
+            [],
+            chunkEffects,
+            priority,
+        ];
+        const meshed = [];
         for (const [substance, mesher] of RenderedSubstances.meshers) {
-            if (mesher.positions.length == 0) {
-                chunks[1].push([substance, false]);
+            for (const e in mesher.effects) {
+                const float = Float32Array.from(mesher.effects[e]);
+                trasnfers.push(float.buffer);
+                chunkEffects.push([e, float]);
+            }
+            if (mesher.mesh.positions.length == 0) {
                 mesher.resetAll();
                 continue;
             }
-            const [attributes, buffers] = mesher.getAllAttributes();
-            trasnfers.push(...buffers);
-            chunks[1].push([substance, [location, attributes]]);
+            meshed.push(mesher);
+        }
+        const compactMesh = CompactVoxelMesh(...meshed);
+        trasnfers.push(...(compactMesh[0] == 0
+            ? [compactMesh[1]]
+            : [
+                compactMesh[1],
+                compactMesh[2].buffer,
+                compactMesh[3].buffer,
+                compactMesh[4].buffer,
+            ]));
+        chunks[1] = compactMesh;
+        for (const mesher of meshed) {
             mesher.resetAll();
         }
         DivineVoxelEngineConstructor.instance.threads.parent.runTasks("set-chunk", chunks, trasnfers);

package/Mesher/{Rules → Substances}/RenderedSubstances.d.ts

@@ -2,5 +2,4 @@ import { VoxelMesherDataTool } from "../Tools/VoxelMesherDataTool.js";
 export declare class RenderedSubstances {
     static meshers: Map<string, VoxelMesherDataTool>;
     static add(id: string): void;
-    static setDimension(dimension: string): void;
 }

package/Mesher/Substances/RenderedSubstances.js

@@ -0,0 +1,7 @@
+import { VoxelMesherDataTool } from "../Tools/VoxelMesherDataTool.js";
+export class RenderedSubstances {
+    static meshers = new Map();
+    static add(id) {
+        this.meshers.set(id, new VoxelMesherDataTool(id));
+    }
+}

package/Mesher/Tasks/BuidlerTasks.types.d.ts

@@ -1,7 +1,7 @@
 import { LocationData } from "../../Math";
-import { DVENodeMeshAttributes } from "../../Interfaces/Render/Nodes/DVERenderNode.types";
+import { CompactMeshData } from "Mesher/Types/Mesher.types";
 export type BuildNodeMesh = [location: LocationData, type: string, data: any];
 export type SetNodeMesh = [
     location: LocationData,
-    attributes: DVENodeMeshAttributes
+    attributes: CompactMeshData
 ];

package/Mesher/Tools/OutlinedVoxelTool.js

@@ -1,4 +1,3 @@
-import { DVEMesher } from "../Mesher.js";
 import { VoxelFaceDirections, VoxelFaces } from "../../Math/index.js";
 /*
 0 -> normal direction
@@ -96,34 +95,36 @@ const CheckSets = {
     [VoxelFaces.South]: northAndSouth,
 };
 const generateCheck = (direction, tool, normal, sets) => {
-    const { x, y, z } = tool.voxel;
+    return 0;
+    /*   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];
-        tool.nVoxel.loadInAt(cx, cy, cz);
-        const sameLevelCheck = tool.voxel.isSameVoxel(tool.nVoxel);
-        let normalCheck = true;
-        if (tool.nVoxel.loadInAt(cx + normal[0], cy + normal[1], cz + normal[2])) {
-            if (tool.nVoxel.isRenderable() && tool.nVoxel.isOpaque()) {
-                normalCheck = false;
-            }
-        }
-        if (sameLevelCheck && normalCheck) {
-            key |= 0b1 << i;
-        }
-        else {
-            key |= 0b0 << i;
-            if (i == 0)
-                break;
+      const set = sets[i];
+      const cx = x + set[0];
+      const cy = y + set[1];
+      const cz = z + set[2];
+  
+      tool.nVoxel.loadInAt(cx, cy, cz);
+      const sameLevelCheck = tool.voxel.isSameVoxel(tool.nVoxel);
+      let normalCheck = true;
+      if (tool.nVoxel.loadInAt(cx + normal[0], cy + normal[1], cz + normal[2])) {
+        if (tool.nVoxel.isRenderable() && tool.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;
+    if (uvsSets[direction][key] == undefined) return 0;
     const index = uvsSets[direction][key];
-    return OutlinedVoxelTool._currentTexts[index];
+    return OutlinedVoxelTool._currentTexts[index]; */
 };
 export class OutlinedVoxelTool {
     static _currentTexts = [];
@@ -176,11 +177,27 @@ export class OutlinedVoxelTool {
     };
     static getOutlineUVs(texture, onRegister) {
         const overlayTextures = [];
-        DVEMesher.observers.texturesRegistered.subscribeOnce((textureManager) => {
-            const type = texture[0];
-            const id = texture[1];
-            overlayTextures.push(textureManager.getTextureUV([type, id, "top"], true) /** */, textureManager.getTextureUV([type, id, "corner-top-right"], true), textureManager.getTextureUV([type, id, "corner-top-left"], true), textureManager.getTextureUV([type, id, "corner-top-left-top-right"], true), textureManager.getTextureUV([type, id, "bottom"], true), textureManager.getTextureUV([type, id, "corner-bottom-right"], true), textureManager.getTextureUV([type, id, "corner-bottom-left"], true), textureManager.getTextureUV([type, id, "corner-bottom-left-bottom-right"], true), textureManager.getTextureUV([type, id, "right"], true), textureManager.getTextureUV([type, id, "left"], true));
-            onRegister(overlayTextures);
+        /*     DVEMesher.observers.texturesRegistered.subscribeOnce((textureManager) => {
+          const type = texture[0];
+          const id = texture[1];
+          overlayTextures.push(
+            textureManager.getTextureUV([type, id, "top"]) ,
+            textureManager.getTextureUV([type, id, "corner-top-right"]),
+            textureManager.getTextureUV([type, id, "corner-top-left"]),
+            textureManager.getTextureUV([type, id, "corner-top-left-top-right"]),
+            textureManager.getTextureUV([type, id, "bottom"]),
+            textureManager.getTextureUV([type, id, "corner-bottom-right"]),
+            textureManager.getTextureUV([type, id, "corner-bottom-left"]),
+            textureManager.getTextureUV([
+              type,
+              id,
+              "corner-bottom-left-bottom-right",
+            ]),
+            textureManager.getTextureUV([type, id, "right"]),
+            textureManager.getTextureUV([type, id, "left"])
+          );
+          onRegister(overlayTextures);
         });
+     */
     }
 }

package/Mesher/Tools/VoxelMeshBVHBuilder.d.ts

@@ -0,0 +1,85 @@
+/**
+ * A class to help with indexing a full flat binary tree defined by the number of levels it has.
+ */
+declare class FlatBinaryTreeIndex {
+    levels: number;
+    constructor(levels: number);
+    /** Gets the number of nodes at a level of the tree */
+    getLevelSize(level: number): number;
+    /**
+     * Gets the flat index of a node indexed by the level it's on and its relative index in that level.
+     */
+    getIndexAtLevel(level: number, node: number): number;
+    /**
+     * Gets the level and relative index of a node's flat index.
+     */
+    getLevelAndIndex(index: number): [level: number, relativeIndex: number];
+    /**
+     * Gets the flat left child of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if no child exist
+     */
+    getLeftChildAtLevel(level: number, node: number): number;
+    /**
+     * Gets the flat right child of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if no child exist
+     */
+    getRightChildAtLevel(level: number, node: number): number;
+    /**
+     * Gets the flat index of the parent of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if level has no parent
+     */
+    getParentAtLevel(level: number, node: number): number;
+    /** Gets the flat index of the left child of the node.
+     * @returns -1 if no child exist
+     */
+    getLeftChild(node: number): number;
+    /** Gets the flat index of the right child of the node.
+     * @returns -1 if no child exist
+     */
+    getRightChild(node: number): number;
+    /** Gets the flat index of the parent of the node.
+     * @returns -1 if no parent exist
+     */
+    getParent(node: number): number;
+    /** Gets the total number of nodes in the tree */
+    getTotalSize(): number;
+}
+export declare class StructCursor {
+    data: Float32Array;
+    get minX(): number;
+    get minY(): number;
+    get minZ(): number;
+    get maxX(): number;
+    get maxY(): number;
+    get maxZ(): number;
+    get voxelIndex(): number;
+    get active(): number;
+    get nodeType(): number;
+    trueIndex: number;
+    _index: number;
+    get index(): number;
+    set index(index: number);
+    constructor(data: Float32Array);
+    setActive(): void;
+    setVoxelIndex(value: number): void;
+    setInnerNode(): void;
+    setGeomtryNode(): void;
+    updateMin(x: number, y: number, z: number): void;
+    updateMax(x: number, y: number, z: number): void;
+    toJSON(): {
+        min: number[];
+        max: number[];
+        active: number;
+        nodeType: number;
+    };
+}
+export declare class VoxelMeshBVHBuilder {
+    static AABBStructByteSize: number;
+    treeIndex: FlatBinaryTreeIndex;
+    tree: Float32Array;
+    structCursor: StructCursor;
+    indices: Uint32Array;
+    reset(): void;
+    updateVoxel(voxelX: number, voxelY: number, voxelZ: number, indicesStart: number, indicesEnd: number, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
+}
+export {};