@divinevoxel/vlox 0.0.72 → 0.0.74

package/Mesher/Geomtry/Primitives/QuadVertexData.js

@@ -68,22 +68,22 @@ export class QuadVertexData {
         };
     }
     clone() {
-        return new QuadVertexData({
-            [QuadVerticies.TopRight]: structuredClone(this.vertices[QuadVerticies.TopRight]),
-            [QuadVerticies.TopLeft]: structuredClone(this.vertices[QuadVerticies.TopLeft]),
-            [QuadVerticies.BottomLeft]: structuredClone(this.vertices[QuadVerticies.BottomLeft]),
-            [QuadVerticies.BottomRight]: structuredClone(this.vertices[QuadVerticies.BottomRight]),
-        });
+        return new QuadVertexData([
+            structuredClone(this.vertices[QuadVerticies.TopRight]),
+            structuredClone(this.vertices[QuadVerticies.TopLeft]),
+            structuredClone(this.vertices[QuadVerticies.BottomLeft]),
+            structuredClone(this.vertices[QuadVerticies.BottomRight]),
+        ]);
     }
 }
 export class QuadVec3ArrayVertexData extends QuadVertexData {
     vertices;
-    constructor(vertices = {
-        [QuadVerticies.TopRight]: [0, 0, 0],
-        [QuadVerticies.TopLeft]: [0, 0, 0],
-        [QuadVerticies.BottomLeft]: [0, 0, 0],
-        [QuadVerticies.BottomRight]: [0, 0, 0],
-    }) {
+    constructor(vertices = [
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0],
+    ]) {
         super(vertices);
         this.vertices = vertices;
     }
@@ -124,24 +124,22 @@ export class QuadVec3ArrayVertexData extends QuadVertexData {
             Vector3Like.EqualsArray(this.vertices[QuadVerticies.BottomRight], v1));
     }
     clone() {
-        return new QuadVec3ArrayVertexData({
-            [QuadVerticies.TopRight]: [...this.vertices[QuadVerticies.TopRight]],
-            [QuadVerticies.TopLeft]: [...this.vertices[QuadVerticies.TopLeft]],
-            [QuadVerticies.BottomLeft]: [...this.vertices[QuadVerticies.BottomLeft]],
-            [QuadVerticies.BottomRight]: [
-                ...this.vertices[QuadVerticies.BottomRight],
-            ],
-        });
+        return new QuadVec3ArrayVertexData([
+            [...this.vertices[QuadVerticies.TopRight]],
+            [...this.vertices[QuadVerticies.TopLeft]],
+            [...this.vertices[QuadVerticies.BottomLeft]],
+            [...this.vertices[QuadVerticies.BottomRight]],
+        ]);
     }
 }
 export class QuadVector3VertexData extends QuadVertexData {
     vertices;
-    constructor(vertices = {
-        [QuadVerticies.TopRight]: Vector3Like.Create(),
-        [QuadVerticies.TopLeft]: Vector3Like.Create(),
-        [QuadVerticies.BottomLeft]: Vector3Like.Create(),
-        [QuadVerticies.BottomRight]: Vector3Like.Create(),
-    }) {
+    constructor(vertices = [
+        Vector3Like.Create(),
+        Vector3Like.Create(),
+        Vector3Like.Create(),
+        Vector3Like.Create(),
+    ]) {
         super(vertices);
         this.vertices = vertices;
     }
@@ -182,22 +180,22 @@ export class QuadVector3VertexData extends QuadVertexData {
             Vector3Like.Equals(this.vertices[QuadVerticies.BottomRight], v1));
     }
     clone() {
-        return new QuadVector3VertexData({
-            [QuadVerticies.TopRight]: Vector3Like.Clone(this.vertices[QuadVerticies.TopRight]),
-            [QuadVerticies.TopLeft]: Vector3Like.Clone(this.vertices[QuadVerticies.TopLeft]),
-            [QuadVerticies.BottomLeft]: Vector3Like.Clone(this.vertices[QuadVerticies.BottomLeft]),
-            [QuadVerticies.BottomRight]: Vector3Like.Clone(this.vertices[QuadVerticies.BottomRight]),
-        });
+        return new QuadVector3VertexData([
+            Vector3Like.Clone(this.vertices[QuadVerticies.TopRight]),
+            Vector3Like.Clone(this.vertices[QuadVerticies.TopLeft]),
+            Vector3Like.Clone(this.vertices[QuadVerticies.BottomLeft]),
+            Vector3Like.Clone(this.vertices[QuadVerticies.BottomRight]),
+        ]);
     }
 }
 export class QuadVector2VertexData extends QuadVertexData {
     vertices;
-    constructor(vertices = {
-        [QuadVerticies.TopRight]: Vector2Like.Create(),
-        [QuadVerticies.TopLeft]: Vector2Like.Create(),
-        [QuadVerticies.BottomLeft]: Vector2Like.Create(),
-        [QuadVerticies.BottomRight]: Vector2Like.Create(),
-    }) {
+    constructor(vertices = [
+        Vector2Like.Create(),
+        Vector2Like.Create(),
+        Vector2Like.Create(),
+        Vector2Like.Create(),
+    ]) {
         super(vertices);
         this.vertices = vertices;
     }
@@ -238,22 +236,17 @@ export class QuadVector2VertexData extends QuadVertexData {
             Vector2Like.Equals(this.vertices[QuadVerticies.BottomRight], v1));
     }
     clone() {
-        return new QuadVector2VertexData({
-            [QuadVerticies.TopRight]: Vector2Like.Clone(this.vertices[QuadVerticies.TopRight]),
-            [QuadVerticies.TopLeft]: Vector2Like.Clone(this.vertices[QuadVerticies.TopLeft]),
-            [QuadVerticies.BottomLeft]: Vector2Like.Clone(this.vertices[QuadVerticies.BottomLeft]),
-            [QuadVerticies.BottomRight]: Vector2Like.Clone(this.vertices[QuadVerticies.BottomRight]),
-        });
+        return new QuadVector2VertexData([
+            Vector2Like.Clone(this.vertices[QuadVerticies.TopRight]),
+            Vector2Like.Clone(this.vertices[QuadVerticies.TopLeft]),
+            Vector2Like.Clone(this.vertices[QuadVerticies.BottomLeft]),
+            Vector2Like.Clone(this.vertices[QuadVerticies.BottomRight]),
+        ]);
     }
 }
 export class QuadScalarVertexData extends QuadVertexData {
     vertices;
-    constructor(vertices = {
-        [QuadVerticies.TopRight]: 0,
-        [QuadVerticies.TopLeft]: 0,
-        [QuadVerticies.BottomLeft]: 0,
-        [QuadVerticies.BottomRight]: 0,
-    }) {
+    constructor(vertices = [0, 0, 0, 0]) {
         super(vertices);
         this.vertices = vertices;
     }
@@ -339,11 +332,11 @@ export class QuadScalarVertexData extends QuadVertexData {
         return true;
     }
     clone() {
-        return new QuadScalarVertexData({
-            [QuadVerticies.TopRight]: this.vertices[QuadVerticies.TopRight],
-            [QuadVerticies.TopLeft]: this.vertices[QuadVerticies.TopLeft],
-            [QuadVerticies.BottomLeft]: this.vertices[QuadVerticies.BottomLeft],
-            [QuadVerticies.BottomRight]: this.vertices[QuadVerticies.BottomRight],
-        });
+        return new QuadScalarVertexData([
+            this.vertices[QuadVerticies.TopRight],
+            this.vertices[QuadVerticies.TopLeft],
+            this.vertices[QuadVerticies.BottomLeft],
+            this.vertices[QuadVerticies.BottomRight],
+        ]);
     }
 }

package/Mesher/Geomtry/VoxelGeometryBuilder.d.ts

@@ -1,6 +1,6 @@
 import { Vector3Like } from "@amodx/math";
-import { VoxelMesherDataTool } from "../Tools/VoxelMesherDataTool";
+import { VoxelModelBuilder } from "../Models/VoxelModelBuilder";
 import { Quad } from "./Primitives/Quad";
 export declare class VoxelGeometryBuilder {
-    static addQuad(tool: VoxelMesherDataTool, origin: Vector3Like, quad: Quad): void;
 }
+export declare function addVoxelQuad(tool: VoxelModelBuilder, origin: Vector3Like, quad: Quad): void;

package/Mesher/Geomtry/VoxelGeometryBuilder.js

@@ -1,208 +1,129 @@
-import { VoxelShaderData } from "../VoxelShaderData";
+import { VoxelShaderData } from "./VoxelShaderData";
 import { QuadVerticies } from "./Geometry.types";
-import { VoxelMeshVertexConstants, VoxelMeshVertexStructCursor, } from "../../Mesher/Tools/VoxelMeshVertexStructCursor";
+import { VoxelMeshVertexConstants, VoxelMeshVertexStructCursor, } from "./VoxelMeshVertexStructCursor";
 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.d.ts

@@ -1,5 +1,5 @@
 import { Vector3Like } from "@amodx/math";
-import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./Buffers";
+import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./VoxelMeshBuffers";
 export declare class VoxelMesh {
     indicieCount: number;
     vertexCount: number;

package/Mesher/Geomtry/VoxelMesh.js

@@ -1,13 +1,13 @@
 import { Vector3Like } from "@amodx/math";
-import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./Buffers";
-import { VoxelMeshVertexStructCursor } from "../Tools/VoxelMeshVertexStructCursor";
+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, 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

@@ -0,0 +1,16 @@
+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: 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;
+}

package/Mesher/Geomtry/VoxelMeshBVHBuilder.js

@@ -0,0 +1,51 @@
+import { WorldSpaces } from "../../World/WorldSpaces";
+import { VoxelMeshBVHStructCursor } from "./VoxelMeshBVHStructCursor";
+import { FlatBinaryTreeIndex } from "../../Util/Binary/BinaryTree";
+const MAX_FLOAT32 = new Float32Array([Infinity])[0];
+export class VoxelMeshBVHBuilder {
+    static AABBStructByteSize = (4 + 4) * 4;
+    treeIndex = new FlatBinaryTreeIndex(13);
+    tree = new Float32Array(new ArrayBuffer(this.treeIndex.getTotalSize() * VoxelMeshBVHBuilder.AABBStructByteSize));
+    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);
+        this.indices[voxelIndex * 2] = indicesStart;
+        this.indices[voxelIndex * 2 + 1] = indicesEnd;
+        this.structCursor.setIndex(leafIndex);
+        this.structCursor.updateMin(minX, minY, minZ);
+        this.structCursor.updateMax(maxX, maxY, maxZ);
+        this.structCursor.setVoxelIndex(voxelIndex);
+        this.structCursor.setGeomtryNode();
+        let current = leafIndex;
+        for (let level = 1; level < 13; level++) {
+            let parentNode = this.treeIndex.getParent(current);
+            this.structCursor.setIndex(parentNode);
+            this.structCursor.updateMin(minX, minY, minZ);
+            this.structCursor.updateMax(maxX, maxY, maxZ);
+            this.structCursor.setActive();
+            this.structCursor.setInnerNode();
+            current = parentNode;
+        }
+    }
+}

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;
+}