@divinevoxel/vlox 0.0.73 → 0.0.74

package/Mesher/Geomtry/VoxelGeometryBuilder.js

@@ -4,205 +4,126 @@ import { VoxelMeshVertexConstants, VoxelMeshVertexStructCursor, } from "./VoxelM
 const empty = [];
 const structCursor = new VoxelMeshVertexStructCursor();
 export class VoxelGeometryBuilder {
-    /*   static addTriangle(
-      tool: VoxelMesherDataTool,
-      origin: Vector3Like,
-      points: [Vec3Array, Vec3Array, Vec3Array],
-      [[u1, v1], [u2, v2], [u3, v3]]: [Vec2Array, Vec2Array, Vec2Array]
-    ) {
-      if (!tool.mesh) return;
-      const worldLight = tool.vars.light;
-      const worldAO = tool.vars.ao;
-      const texture = tool.vars.textureIndex;
-      GeometryBuilder.addTriangle(tool, origin, points);
-      {
-        const attribute = tool.mesh.getAttribute("voxelData");
-  
-        attribute.push(
-          VoxelShaderData.createAttribute(
-            worldLight.vertices[1],
-            worldAO.vertices[1],
-            0
-          ),
-          VoxelShaderData.createAttribute(
-            worldLight.vertices[2],
-            worldAO.vertices[2],
-            0
-          ),
-          VoxelShaderData.createAttribute(
-            worldLight.vertices[3],
-            worldAO.vertices[3],
-            9
-          )
-        );
-      }
-      {
-        const uvs = tool.mesh.getAttribute("uv");
-        uvs.push(u1, v1, texture, u2, v2, texture, u3, v3, texture);
-      }
-      {
-        const uvs = tool.mesh.getAttribute("textureIndex");
-  
-        uvs.push(
-          //v1
-          0,
-          0,
-          0,
-          0,
-          //v2
-          0,
-          0,
-          0,
-          0,
-          //v3
-          0,
-          0,
-          0,
-          0
-        );
-      }
-      {
-        const colors = tool.mesh.getAttribute("colors");
-        colors.push(
-          //v1
-          0,
-          0,
-          0,
-          //v2
-          0,
-          0,
-          0,
-          //v3
-          0,
-          0,
-          0
-        );
-      }
-    } */
-    static addQuad(tool, origin, quad) {
-        if (!tool.mesh)
-            return;
-        const worldLight = tool.vars.light;
-        const worldAO = tool.vars.ao;
-        const animData = tool.vars.animation;
-        const texture = tool.vars.textureIndex;
-        const overlayTextures = tool.vars.overlayTextures;
-        const topRightPos = quad.positions.vertices[0];
-        const topLeftPos = quad.positions.vertices[1];
-        const bottomLeftPos = quad.positions.vertices[2];
-        const bottomRightPos = quad.positions.vertices[3];
-        const topRightNor = quad.normals.vertices[0];
-        const topLeftNor = quad.normals.vertices[1];
-        const bottomLeftNor = quad.normals.vertices[2];
-        const bottomRightNor = quad.normals.vertices[3];
-        const topRightVoxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopRight], animData.vertices[QuadVerticies.TopRight]);
-        const topLeftVoxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.TopLeft], animData.vertices[QuadVerticies.TopLeft]);
-        const bottomLeftVoxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomLeft], animData.vertices[QuadVerticies.BottomLeft]);
-        const bottomRightVoxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.BottomRight]);
-        const indices = tool.mesh.indices;
-        let indIndex = tool.mesh.indicieCount;
-        let sides = quad.doubleSided ? 2 : 1;
-        const flip = quad.flip;
-        let orientation = quad.orientation;
-        while (sides--) {
-            const baseIndex = tool.mesh.vertexCount;
-            if (!flip) {
-                tool.mesh.buffer.setIndex(baseIndex);
-                structCursor.data = tool.mesh.buffer.currentArray;
-                structCursor.index = tool.mesh.buffer.curentIndex;
-                addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, topRightPos, topRightNor, quad.uvs.vertices[QuadVerticies.TopRight], topRightVoxelData, texture, overlayTextures);
-                tool.mesh.buffer.setIndex(baseIndex + 1);
-                structCursor.data = tool.mesh.buffer.currentArray;
-                structCursor.index = tool.mesh.buffer.curentIndex;
-                addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, quad.uvs.vertices[QuadVerticies.TopLeft], topLeftVoxelData, texture, overlayTextures);
-                tool.mesh.buffer.setIndex(baseIndex + 2);
-                structCursor.data = tool.mesh.buffer.currentArray;
-                structCursor.index = tool.mesh.buffer.curentIndex;
-                addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, quad.uvs.vertices[QuadVerticies.BottomLeft], bottomLeftVoxelData, texture, overlayTextures);
-                tool.mesh.buffer.setIndex(baseIndex + 3);
-                structCursor.data = tool.mesh.buffer.currentArray;
-                structCursor.index = tool.mesh.buffer.curentIndex;
-                addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, bottomRightPos, bottomRightNor, quad.uvs.vertices[QuadVerticies.BottomRight], bottomRightVoxelData, texture, overlayTextures);
-            }
-            if (flip) {
-                tool.mesh.buffer.setIndex(baseIndex);
-                structCursor.data = tool.mesh.buffer.currentArray;
-                structCursor.index = tool.mesh.buffer.curentIndex;
-                addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, quad.uvs.vertices[QuadVerticies.TopLeft], topLeftVoxelData, texture, overlayTextures);
-                tool.mesh.buffer.setIndex(baseIndex + 1);
-                structCursor.data = tool.mesh.buffer.currentArray;
-                structCursor.index = tool.mesh.buffer.curentIndex;
-                addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, topRightPos, topRightNor, quad.uvs.vertices[QuadVerticies.TopRight], topRightVoxelData, texture, overlayTextures);
-                tool.mesh.buffer.setIndex(baseIndex + 2);
-                structCursor.data = tool.mesh.buffer.currentArray;
-                structCursor.index = tool.mesh.buffer.curentIndex;
-                addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, bottomRightPos, bottomRightNor, quad.uvs.vertices[QuadVerticies.BottomRight], bottomRightVoxelData, texture, overlayTextures);
-                tool.mesh.buffer.setIndex(baseIndex + 3);
-                structCursor.data = tool.mesh.buffer.currentArray;
-                structCursor.index = tool.mesh.buffer.curentIndex;
-                addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, quad.uvs.vertices[QuadVerticies.BottomLeft], bottomLeftVoxelData, texture, overlayTextures);
-            }
-            if (!orientation && !flip) {
-                indices.setIndex(indIndex).currentArray[indices.curentIndex] =
-                    baseIndex;
-                indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
-                    baseIndex + 1;
-                indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
-                    baseIndex + 2;
-                indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
-                    baseIndex + 2;
-                indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
-                    baseIndex + 3;
-                indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] =
-                    baseIndex;
-            }
-            else if (!orientation && flip) {
-                indices.setIndex(indIndex).currentArray[indices.curentIndex] =
-                    baseIndex;
-                indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
-                    baseIndex + 3;
-                indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
-                    baseIndex + 2;
-                indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
-                    baseIndex + 2;
-                indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
-                    baseIndex + 1;
-                indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] =
-                    baseIndex;
-            }
-            if (orientation && !flip) {
-                indices.setIndex(indIndex).currentArray[indices.curentIndex] =
-                    baseIndex;
-                indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
-                    baseIndex + 3;
-                indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
-                    baseIndex + 2;
-                indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
-                    baseIndex + 2;
-                indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
-                    baseIndex + 1;
-                indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] =
-                    baseIndex;
-            }
-            else if (orientation && flip) {
-                indices.setIndex(indIndex).currentArray[indices.curentIndex] =
-                    baseIndex;
-                indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
-                    baseIndex + 1;
-                indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
-                    baseIndex + 2;
-                indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
-                    baseIndex + 2;
-                indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
-                    baseIndex + 3;
-                indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] =
-                    baseIndex;
-            }
-            tool.mesh.addVerticies(4, 6);
+}
+export function addVoxelQuad(tool, origin, quad) {
+    if (!tool.mesh)
+        return;
+    const worldLight = tool.vars.light;
+    const worldAO = tool.vars.ao;
+    const animData = tool.vars.animation;
+    const texture = tool.vars.textureIndex;
+    const overlayTextures = tool.vars.overlayTextures;
+    const topRightPos = quad.positions.vertices[0];
+    const topLeftPos = quad.positions.vertices[1];
+    const bottomLeftPos = quad.positions.vertices[2];
+    const bottomRightPos = quad.positions.vertices[3];
+    const topRightNor = quad.normals.vertices[0];
+    const topLeftNor = quad.normals.vertices[1];
+    const bottomLeftNor = quad.normals.vertices[2];
+    const bottomRightNor = quad.normals.vertices[3];
+    const topRightVoxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopRight], animData.vertices[QuadVerticies.TopRight]);
+    const topLeftVoxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.TopLeft], animData.vertices[QuadVerticies.TopLeft]);
+    const bottomLeftVoxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomLeft], animData.vertices[QuadVerticies.BottomLeft]);
+    const bottomRightVoxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.BottomRight]);
+    const indices = tool.mesh.indices;
+    let indIndex = tool.mesh.indicieCount;
+    let sides = quad.doubleSided ? 2 : 1;
+    const flip = quad.flip;
+    let orientation = quad.orientation;
+    while (sides--) {
+        const baseIndex = tool.mesh.vertexCount;
+        if (!flip) {
+            tool.mesh.buffer.setIndex(baseIndex);
+            structCursor.data = tool.mesh.buffer.currentArray;
+            structCursor.index = tool.mesh.buffer.curentIndex;
+            addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, topRightPos, topRightNor, quad.uvs.vertices[QuadVerticies.TopRight], topRightVoxelData, texture, overlayTextures);
+            tool.mesh.buffer.setIndex(baseIndex + 1);
+            structCursor.data = tool.mesh.buffer.currentArray;
+            structCursor.index = tool.mesh.buffer.curentIndex;
+            addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, quad.uvs.vertices[QuadVerticies.TopLeft], topLeftVoxelData, texture, overlayTextures);
+            tool.mesh.buffer.setIndex(baseIndex + 2);
+            structCursor.data = tool.mesh.buffer.currentArray;
+            structCursor.index = tool.mesh.buffer.curentIndex;
+            addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, quad.uvs.vertices[QuadVerticies.BottomLeft], bottomLeftVoxelData, texture, overlayTextures);
+            tool.mesh.buffer.setIndex(baseIndex + 3);
+            structCursor.data = tool.mesh.buffer.currentArray;
+            structCursor.index = tool.mesh.buffer.curentIndex;
+            addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, bottomRightPos, bottomRightNor, quad.uvs.vertices[QuadVerticies.BottomRight], bottomRightVoxelData, texture, overlayTextures);
+        }
+        if (flip) {
+            tool.mesh.buffer.setIndex(baseIndex);
+            structCursor.data = tool.mesh.buffer.currentArray;
+            structCursor.index = tool.mesh.buffer.curentIndex;
+            addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, quad.uvs.vertices[QuadVerticies.TopLeft], topLeftVoxelData, texture, overlayTextures);
+            tool.mesh.buffer.setIndex(baseIndex + 1);
+            structCursor.data = tool.mesh.buffer.currentArray;
+            structCursor.index = tool.mesh.buffer.curentIndex;
+            addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, topRightPos, topRightNor, quad.uvs.vertices[QuadVerticies.TopRight], topRightVoxelData, texture, overlayTextures);
+            tool.mesh.buffer.setIndex(baseIndex + 2);
+            structCursor.data = tool.mesh.buffer.currentArray;
+            structCursor.index = tool.mesh.buffer.curentIndex;
+            addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, bottomRightPos, bottomRightNor, quad.uvs.vertices[QuadVerticies.BottomRight], bottomRightVoxelData, texture, overlayTextures);
+            tool.mesh.buffer.setIndex(baseIndex + 3);
+            structCursor.data = tool.mesh.buffer.currentArray;
+            structCursor.index = tool.mesh.buffer.curentIndex;
+            addVertex(tool.mesh.buffer.curentIndex, tool.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, quad.uvs.vertices[QuadVerticies.BottomLeft], bottomLeftVoxelData, texture, overlayTextures);
+        }
+        if (!orientation && !flip) {
+            indices.setIndex(indIndex).currentArray[indices.curentIndex] = baseIndex;
+            indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+                baseIndex + 1;
+            indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+                baseIndex + 2;
+            indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+                baseIndex + 2;
+            indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+                baseIndex + 3;
+            indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] =
+                baseIndex;
+        }
+        else if (!orientation && flip) {
+            indices.setIndex(indIndex).currentArray[indices.curentIndex] = baseIndex;
+            indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+                baseIndex + 3;
+            indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+                baseIndex + 2;
+            indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+                baseIndex + 2;
+            indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+                baseIndex + 1;
+            indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] =
+                baseIndex;
         }
+        if (orientation && !flip) {
+            indices.setIndex(indIndex).currentArray[indices.curentIndex] = baseIndex;
+            indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+                baseIndex + 3;
+            indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+                baseIndex + 2;
+            indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+                baseIndex + 2;
+            indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+                baseIndex + 1;
+            indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] =
+                baseIndex;
+        }
+        else if (orientation && flip) {
+            indices.setIndex(indIndex).currentArray[indices.curentIndex] = baseIndex;
+            indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+                baseIndex + 1;
+            indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+                baseIndex + 2;
+            indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+                baseIndex + 2;
+            indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+                baseIndex + 3;
+            indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] =
+                baseIndex;
+        }
+        tool.mesh.addVerticies(4, 6);
     }
 }
-const addVertex = (index, array, origin, position, normal, uvs, voxelData, texture, overlayTextures) => {
+function addVertex(index, array, origin, position, normal, uvs, voxelData, texture, overlayTextures) {
     index *= VoxelMeshVertexConstants.VertexFloatSize;
     array[VoxelMeshVertexConstants.PositionOffset + index] =
         position.x + origin.x;
@@ -222,4 +143,4 @@ const addVertex = (index, array, origin, position, normal, uvs, voxelData, textu
     array[VoxelMeshVertexConstants.TextureIndexOffset + index + 2] =
         VoxelShaderData.createTextureIndex(overlayTextures.w, 0);
     array[VoxelMeshVertexConstants.VoxelDataOFfset + index] = voxelData;
-};
+}

package/Mesher/Geomtry/VoxelMesh.js

@@ -6,8 +6,8 @@ export class VoxelMesh {
     vertexCount = 0;
     minBounds = Vector3Like.Create(Infinity, Infinity, Infinity);
     maxBounds = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
-    buffer = new VoxelVertexBuffer(VoxelMeshVertexStructCursor.VertexFloatSize, 1000);
-    indices = new VoxelIndiceBuffer(1000);
+    buffer = new VoxelVertexBuffer(VoxelMeshVertexStructCursor.VertexFloatSize, 1024);
+    indices = new VoxelIndiceBuffer(1024);
     addVerticies(vertexCount, indicesCount) {
         this.vertexCount += vertexCount;
         this.indicieCount += indicesCount;

package/Mesher/Geomtry/VoxelMeshBVHBuilder.d.ts

@@ -1,78 +1,16 @@
-/**
- * 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;
-    private index;
-    setIndex(index: number): void;
-    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;
-}
+import { Vec3Array } from "@amodx/math";
+import { VoxelMeshBVHStructCursor } from "./VoxelMeshBVHStructCursor";
+import { FlatBinaryTreeIndex } from "../../Util/Binary/BinaryTree";
 export declare class VoxelMeshBVHBuilder {
     static AABBStructByteSize: number;
     treeIndex: FlatBinaryTreeIndex;
     tree: Float32Array;
-    structCursor: StructCursor;
+    structCursor: VoxelMeshBVHStructCursor;
     indices: Uint32Array;
     reset(): void;
+    getMeshBounds(): {
+        min: Vec3Array;
+        max: Vec3Array;
+    };
     updateVoxel(voxelX: number, voxelY: number, voxelZ: number, meshIndex: number, indicesStart: number, indicesEnd: number, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
 }
-export {};

package/Mesher/Geomtry/VoxelMeshBVHBuilder.js

@@ -1,197 +1,32 @@
 import { WorldSpaces } from "../../World/WorldSpaces";
+import { VoxelMeshBVHStructCursor } from "./VoxelMeshBVHStructCursor";
+import { FlatBinaryTreeIndex } from "../../Util/Binary/BinaryTree";
 const MAX_FLOAT32 = new Float32Array([Infinity])[0];
-/**
- * A class to help with indexing a full flat binary tree defined by the number of levels it has.
- */
-class FlatBinaryTreeIndex {
-    levels;
-    constructor(levels) {
-        this.levels = levels;
-    }
-    /** Gets the number of nodes at a level of the tree */
-    getLevelSize(level) {
-        if (level < 0 || level >= this.levels) {
-            throw new Error("Invalid level");
-        }
-        return 1 << level; // Equivalent to 2^level
-    }
-    /**
-     * Gets the flat index of a node indexed by the level it's on and its relative index in that level.
-     */
-    getIndexAtLevel(level, node) {
-        if (level < 0 || level >= this.levels) {
-            throw new Error("Invalid level");
-        }
-        const levelSize = this.getLevelSize(level);
-        if (node < 0 || node >= levelSize) {
-            throw new Error("Invalid node index at the given level");
-        }
-        return (1 << level) - 1 + node;
-    }
-    /**
-     * Gets the level and relative index of a node's flat index.
-     */
-    getLevelAndIndex(index) {
-        const totalNodes = (1 << this.levels) - 1;
-        if (index < 0 || index >= totalNodes) {
-            throw new Error("Invalid node index");
-        }
-        const level = Math.floor(Math.log2(index + 1));
-        const firstIndexAtLevel = (1 << level) - 1;
-        const relativeIndex = index - firstIndexAtLevel;
-        return [level, relativeIndex];
-    }
-    /**
-     * 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, node) {
-        if (level + 1 >= this.levels) {
-            return -1;
-        }
-        const nodeIndex = this.getIndexAtLevel(level, node);
-        return this.getLeftChild(nodeIndex);
-    }
-    /**
-     * 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, node) {
-        if (level + 1 >= this.levels) {
-            return -1;
-        }
-        const nodeIndex = this.getIndexAtLevel(level, node);
-        return this.getRightChild(nodeIndex);
-    }
-    /**
-     * 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, node) {
-        if (level === 0) {
-            return -1;
-        }
-        const nodeIndex = this.getIndexAtLevel(level, node);
-        return this.getParent(nodeIndex);
-    }
-    /** Gets the flat index of the left child of the node.
-     * @returns -1 if no child exist
-     */
-    getLeftChild(node) {
-        const leftChildIndex = 2 * node + 1;
-        const totalNodes = (1 << this.levels) - 1;
-        return leftChildIndex < totalNodes ? leftChildIndex : -1;
-    }
-    /** Gets the flat index of the right child of the node.
-     * @returns -1 if no child exist
-     */
-    getRightChild(node) {
-        const rightChildIndex = 2 * node + 2;
-        const totalNodes = (1 << this.levels) - 1;
-        return rightChildIndex < totalNodes ? rightChildIndex : -1;
-    }
-    /** Gets the flat index of the parent of the node.
-     * @returns -1 if no parent exist
-     */
-    getParent(node) {
-        if (node === 0) {
-            return -1; // Root node has no parent
-        }
-        return Math.floor((node - 1) / 2);
-    }
-    /** Gets the total number of nodes in the tree */
-    getTotalSize() {
-        return (1 << this.levels) - 1; // Equivalent to 2^levels - 1
-    }
-}
-export class StructCursor {
-    data;
-    get minX() {
-        return this.data[this.trueIndex];
-    }
-    get minY() {
-        return this.data[this.trueIndex + 1];
-    }
-    get minZ() {
-        return this.data[this.trueIndex + 2];
-    }
-    get maxX() {
-        return this.data[this.trueIndex + 4];
-    }
-    get maxY() {
-        return this.data[this.trueIndex + 5];
-    }
-    get maxZ() {
-        return this.data[this.trueIndex + 6];
-    }
-    get voxelIndex() {
-        return this.data[this.trueIndex + 3];
-    }
-    get active() {
-        return this.data[this.trueIndex + 3];
-    }
-    get nodeType() {
-        return this.data[this.trueIndex + 7];
-    }
-    trueIndex = 0;
-    index = 0;
-    setIndex(index) {
-        this.trueIndex = index * 8;
-    }
-    constructor(data) {
-        this.data = data;
-    }
-    setActive() {
-        this.data[this.trueIndex + 3] = 1;
-    }
-    setVoxelIndex(value) {
-        this.data[this.trueIndex + 3] = value;
-    }
-    setInnerNode() {
-        this.data[this.trueIndex + 7] = 1;
-    }
-    setGeomtryNode() {
-        this.data[this.trueIndex + 7] = 2;
-    }
-    updateMin(x, y, z) {
-        const ix = this.trueIndex;
-        const iy = this.trueIndex + 1;
-        const iz = this.trueIndex + 2;
-        if (x < this.data[ix] || this.data[ix] == -MAX_FLOAT32) {
-            this.data[ix] = x;
-        }
-        if (y < this.data[iy] || this.data[iy] == -MAX_FLOAT32) {
-            this.data[iy] = y;
-        }
-        if (z < this.data[iz] || this.data[iz] == -MAX_FLOAT32) {
-            this.data[iz] = z;
-        }
-    }
-    updateMax(x, y, z) {
-        const ix = this.trueIndex + 4;
-        const iy = this.trueIndex + 5;
-        const iz = this.trueIndex + 6;
-        if (x > this.data[ix] || this.data[ix] == -MAX_FLOAT32) {
-            this.data[ix] = x;
-        }
-        if (y > this.data[iy] || this.data[iy] == -MAX_FLOAT32) {
-            this.data[iy] = y;
-        }
-        if (z > this.data[iz] || this.data[iz] == -MAX_FLOAT32) {
-            this.data[iz] = z;
-        }
-    }
-}
 export class VoxelMeshBVHBuilder {
     static AABBStructByteSize = (4 + 4) * 4;
     treeIndex = new FlatBinaryTreeIndex(13);
     tree = new Float32Array(new ArrayBuffer(this.treeIndex.getTotalSize() * VoxelMeshBVHBuilder.AABBStructByteSize));
-    structCursor = new StructCursor(this.tree);
+    structCursor = new VoxelMeshBVHStructCursor(this.tree);
     indices = new Uint32Array(this.treeIndex.getLevelSize(12) * 2);
     reset() {
         this.tree.fill(-MAX_FLOAT32);
         this.indices.fill(0);
     }
+    getMeshBounds() {
+        const leafIndex = this.treeIndex.getIndexAtLevel(0, 0);
+        return {
+            min: [
+                this.tree[leafIndex],
+                this.tree[leafIndex + 1],
+                this.tree[leafIndex + 2],
+            ],
+            max: [
+                this.tree[leafIndex + 4],
+                this.tree[leafIndex + 5],
+                this.tree[leafIndex + 6],
+            ],
+        };
+    }
     updateVoxel(voxelX, voxelY, voxelZ, meshIndex, indicesStart, indicesEnd, minX, minY, minZ, maxX, maxY, maxZ) {
         const voxelIndex = WorldSpaces.voxel.getIndex(voxelX, voxelY, voxelZ);
         const leafIndex = this.treeIndex.getIndexAtLevel(12, voxelIndex);

package/Mesher/Geomtry/VoxelMeshBVHStructCursor.d.ts

@@ -0,0 +1,22 @@
+export declare class VoxelMeshBVHStructCursor {
+    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;
+    private index;
+    setIndex(index: number): void;
+    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;
+}