@divinevoxel/vlox 0.0.71 → 0.0.73

package/Mesher/Geomtry/Primitives/QuadVertexData.d.ts

@@ -1,8 +1,9 @@
 import { QuadVerticies } from "../Geometry.types.js";
 import { Vector3Like, Vector2Like, Vec3Array } from "@amodx/math";
+type QuadDataType<Data> = [Data, Data, Data, Data];
 export declare class QuadVertexData<Data> {
-    vertices: Record<QuadVerticies, Data>;
-    constructor(vertices: Record<QuadVerticies, Data>);
+    vertices: QuadDataType<Data>;
+    constructor(vertices: QuadDataType<Data>);
     getAsArray(): Data[];
     setVertex(vertex: QuadVerticies, value: Data): void;
     getVertex(vertex: QuadVerticies): Data;
@@ -14,8 +15,8 @@ export declare class QuadVertexData<Data> {
     clone(): QuadVertexData<Data>;
 }
 export declare class QuadVec3ArrayVertexData extends QuadVertexData<Vec3Array> {
-    vertices: Record<QuadVerticies, Vec3Array>;
-    constructor(vertices?: Record<QuadVerticies, Vec3Array>);
+    vertices: QuadDataType<Vec3Array>;
+    constructor(vertices?: QuadDataType<Vec3Array>);
     setFromQuadData(vertexData: QuadVertexData<Vec3Array>): void;
     addToVertex(vertex: QuadVerticies, value: Vec3Array): void;
     subtractFromVertex(vertex: QuadVerticies, value: Vec3Array): void;
@@ -26,8 +27,8 @@ export declare class QuadVec3ArrayVertexData extends QuadVertexData<Vec3Array> {
     clone(): QuadVec3ArrayVertexData;
 }
 export declare class QuadVector3VertexData extends QuadVertexData<Vector3Like> {
-    vertices: Record<QuadVerticies, Vector3Like>;
-    constructor(vertices?: Record<QuadVerticies, Vector3Like>);
+    vertices: QuadDataType<Vector3Like>;
+    constructor(vertices?: QuadDataType<Vector3Like>);
     setFromQuadData(vertexData: QuadVertexData<Vector3Like>): void;
     addToVertex(vertex: QuadVerticies, value: Vector3Like): void;
     subtractFromVertex(vertex: QuadVerticies, value: Vector3Like): void;
@@ -38,8 +39,8 @@ export declare class QuadVector3VertexData extends QuadVertexData<Vector3Like> {
     clone(): QuadVector3VertexData;
 }
 export declare class QuadVector2VertexData extends QuadVertexData<Vector2Like> {
-    vertices: Record<QuadVerticies, Vector2Like>;
-    constructor(vertices?: Record<QuadVerticies, Vector2Like>);
+    vertices: QuadDataType<Vector2Like>;
+    constructor(vertices?: QuadDataType<Vector2Like>);
     setFromQuadData(vertexData: QuadVertexData<Vector3Like>): void;
     addToVertex(vertex: QuadVerticies, value: Vector2Like): void;
     subtractFromVertex(vertex: QuadVerticies, value: Vector2Like): void;
@@ -50,8 +51,8 @@ export declare class QuadVector2VertexData extends QuadVertexData<Vector2Like> {
     clone(): QuadVector2VertexData;
 }
 export declare class QuadScalarVertexData extends QuadVertexData<number> {
-    vertices: Record<QuadVerticies, number>;
-    constructor(vertices?: Record<QuadVerticies, number>);
+    vertices: QuadDataType<number>;
+    constructor(vertices?: QuadDataType<number>);
     setFromQuadData(vertexData: QuadVertexData<number>): void;
     subtractFromVertex(vertex: QuadVerticies, value: number): void;
     addAll(value: number): void;
@@ -64,3 +65,4 @@ export declare class QuadScalarVertexData extends QuadVertexData<number> {
     isAllLessThan(value: number): boolean;
     clone(): QuadScalarVertexData;
 }
+export {};

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;
+    static addQuad(tool: VoxelModelBuilder, origin: Vector3Like, quad: Quad): void;
 }

package/Mesher/Geomtry/VoxelGeometryBuilder.js

@@ -1,6 +1,6 @@
-import { VoxelShaderData } from "../VoxelShaderData";
+import { VoxelShaderData } from "./VoxelShaderData";
 import { QuadVerticies } from "./Geometry.types";
-import { VoxelMeshVertexStructCursor } from "../../Mesher/Tools/VoxelMeshVertexStructCursor";
+import { VoxelMeshVertexConstants, VoxelMeshVertexStructCursor, } from "./VoxelMeshVertexStructCursor";
 const empty = [];
 const structCursor = new VoxelMeshVertexStructCursor();
 export class VoxelGeometryBuilder {
@@ -82,7 +82,6 @@ export class VoxelGeometryBuilder {
     static addQuad(tool, origin, quad) {
         if (!tool.mesh)
             return;
-        structCursor.data = tool.mesh.buffer;
         const worldLight = tool.vars.light;
         const worldAO = tool.vars.ao;
         const animData = tool.vars.animation;
@@ -96,6 +95,10 @@ export class VoxelGeometryBuilder {
         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;
@@ -104,139 +107,119 @@ export class VoxelGeometryBuilder {
         while (sides--) {
             const baseIndex = tool.mesh.vertexCount;
             if (!flip) {
-                //1
-                structCursor.index = baseIndex;
-                structCursor.positionX = topRightPos.x + origin.x;
-                structCursor.positionY = topRightPos.y + origin.y;
-                structCursor.positionZ = topRightPos.z + origin.z;
-                structCursor.voxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopRight], animData.vertices[QuadVerticies.TopRight]);
-                structCursor.uvX = quad.uvs.vertices[QuadVerticies.TopRight].x;
-                structCursor.uvY = quad.uvs.vertices[QuadVerticies.TopRight].y;
-                //2
-                structCursor.index = baseIndex + 1;
-                structCursor.positionX = topLeftPos.x + origin.x;
-                structCursor.positionY = topLeftPos.y + origin.y;
-                structCursor.positionZ = topLeftPos.z + origin.z;
-                structCursor.voxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.TopLeft], animData.vertices[QuadVerticies.TopLeft]);
-                structCursor.uvX = quad.uvs.vertices[QuadVerticies.TopLeft].x;
-                structCursor.uvY = quad.uvs.vertices[QuadVerticies.TopLeft].y;
-                //3
-                structCursor.index = baseIndex + 2;
-                structCursor.positionX = bottomLeftPos.x + origin.x;
-                structCursor.positionY = bottomLeftPos.y + origin.y;
-                structCursor.positionZ = bottomLeftPos.z + origin.z;
-                structCursor.voxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomLeft], animData.vertices[QuadVerticies.BottomLeft]);
-                structCursor.uvX = quad.uvs.vertices[QuadVerticies.BottomLeft].x;
-                structCursor.uvY = quad.uvs.vertices[QuadVerticies.BottomLeft].y;
-                //4
-                structCursor.index = baseIndex + 3;
-                structCursor.positionX = bottomRightPos.x + origin.x;
-                structCursor.positionY = bottomRightPos.y + origin.y;
-                structCursor.positionZ = bottomRightPos.z + origin.z;
-                structCursor.voxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.BottomRight]);
-                structCursor.uvX = quad.uvs.vertices[QuadVerticies.BottomRight].x;
-                structCursor.uvY = quad.uvs.vertices[QuadVerticies.BottomRight].y;
+                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);
             }
-            else {
-                //1
-                structCursor.index = baseIndex;
-                structCursor.positionX = topLeftPos.x + origin.x;
-                structCursor.positionY = topLeftPos.y + origin.y;
-                structCursor.positionZ = topLeftPos.z + origin.z;
-                structCursor.voxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.TopLeft], animData.vertices[QuadVerticies.TopLeft]);
-                structCursor.uvX = quad.uvs.vertices[QuadVerticies.TopLeft].x;
-                structCursor.uvY = quad.uvs.vertices[QuadVerticies.TopLeft].y;
-                //2
-                structCursor.index = baseIndex + 1;
-                structCursor.positionX = topRightPos.x + origin.x;
-                structCursor.positionY = topRightPos.y + origin.y;
-                structCursor.positionZ = topRightPos.z + origin.z;
-                structCursor.voxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopRight], animData.vertices[QuadVerticies.TopRight]);
-                structCursor.uvX = quad.uvs.vertices[QuadVerticies.TopRight].x;
-                structCursor.uvY = quad.uvs.vertices[QuadVerticies.TopRight].y;
-                //3
-                structCursor.index = baseIndex + 2;
-                structCursor.positionX = bottomRightPos.x + origin.x;
-                structCursor.positionY = bottomRightPos.y + origin.y;
-                structCursor.positionZ = bottomRightPos.z + origin.z;
-                structCursor.voxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.BottomRight]);
-                structCursor.uvX = quad.uvs.vertices[QuadVerticies.BottomRight].x;
-                structCursor.uvY = quad.uvs.vertices[QuadVerticies.BottomRight].y;
-                //4
-                structCursor.index = baseIndex + 3;
-                structCursor.positionX = bottomLeftPos.x + origin.x;
-                structCursor.positionY = bottomLeftPos.y + origin.y;
-                structCursor.positionZ = bottomLeftPos.z + origin.z;
-                structCursor.voxelData = VoxelShaderData.createAttribute(worldLight.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomLeft], animData.vertices[QuadVerticies.BottomLeft]);
-                structCursor.uvX = quad.uvs.vertices[QuadVerticies.BottomLeft].x;
-                structCursor.uvY = quad.uvs.vertices[QuadVerticies.BottomLeft].y;
+            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);
             }
-            //1
-            structCursor.index = baseIndex;
-            structCursor.textureIndexX = VoxelShaderData.createTextureIndex(texture, overlayTextures.vertices[QuadVerticies.TopRight]);
-            structCursor.textureIndexY = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.TopLeft], overlayTextures.vertices[QuadVerticies.BottomLeft]);
-            structCursor.textureIndexZ = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.BottomRight], 0);
-            structCursor.normalX = topRightNor.x;
-            structCursor.normalY = topRightNor.y;
-            structCursor.normalZ = topRightNor.z;
-            //2
-            structCursor.index = baseIndex + 1;
-            structCursor.textureIndexX = VoxelShaderData.createTextureIndex(texture, overlayTextures.vertices[QuadVerticies.TopRight]);
-            structCursor.textureIndexY = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.TopLeft], overlayTextures.vertices[QuadVerticies.BottomLeft]);
-            structCursor.textureIndexZ = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.BottomRight], 0);
-            structCursor.normalX = topLeftNor.x;
-            structCursor.normalY = topLeftNor.y;
-            structCursor.normalZ = topLeftNor.z;
-            //3
-            structCursor.index = baseIndex + 2;
-            structCursor.textureIndexX = VoxelShaderData.createTextureIndex(texture, overlayTextures.vertices[QuadVerticies.TopRight]);
-            structCursor.textureIndexY = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.TopLeft], overlayTextures.vertices[QuadVerticies.BottomLeft]);
-            structCursor.textureIndexZ = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.BottomRight], 0);
-            structCursor.normalX = bottomLeftNor.x;
-            structCursor.normalY = bottomLeftNor.y;
-            structCursor.normalZ = bottomLeftNor.z;
-            //4
-            structCursor.index = baseIndex + 3;
-            structCursor.textureIndexX = VoxelShaderData.createTextureIndex(texture, overlayTextures.vertices[QuadVerticies.TopRight]);
-            structCursor.textureIndexY = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.TopLeft], overlayTextures.vertices[QuadVerticies.BottomLeft]);
-            structCursor.textureIndexZ = VoxelShaderData.createTextureIndex(overlayTextures.vertices[QuadVerticies.BottomRight], 0);
-            structCursor.normalX = bottomRightNor.x;
-            structCursor.normalY = bottomRightNor.y;
-            structCursor.normalZ = bottomRightNor.z;
             if (!orientation && !flip) {
-                indices[indIndex++] = baseIndex;
-                indices[indIndex++] = baseIndex + 1;
-                indices[indIndex++] = baseIndex + 2;
-                indices[indIndex++] = baseIndex + 2;
-                indices[indIndex++] = baseIndex + 3;
-                indices[indIndex++] = baseIndex;
+                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[indIndex++] = baseIndex;
-                indices[indIndex++] = baseIndex + 3;
-                indices[indIndex++] = baseIndex + 2;
-                indices[indIndex++] = baseIndex + 2;
-                indices[indIndex++] = baseIndex + 1;
-                indices[indIndex++] = baseIndex;
+                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[indIndex++] = baseIndex;
-                indices[indIndex++] = baseIndex + 3;
-                indices[indIndex++] = baseIndex + 2;
-                indices[indIndex++] = baseIndex + 2;
-                indices[indIndex++] = baseIndex + 1;
-                indices[indIndex++] = baseIndex;
+                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[indIndex++] = baseIndex;
-                indices[indIndex++] = baseIndex + 1;
-                indices[indIndex++] = baseIndex + 2;
-                indices[indIndex++] = baseIndex + 2;
-                indices[indIndex++] = baseIndex + 3;
-                indices[indIndex++] = baseIndex;
+                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);
         }
-        structCursor.data = empty;
     }
 }
+const addVertex = (index, array, origin, position, normal, uvs, voxelData, texture, overlayTextures) => {
+    index *= VoxelMeshVertexConstants.VertexFloatSize;
+    array[VoxelMeshVertexConstants.PositionOffset + index] =
+        position.x + origin.x;
+    array[VoxelMeshVertexConstants.PositionOffset + index + 1] =
+        position.y + origin.y;
+    array[VoxelMeshVertexConstants.PositionOffset + index + 2] =
+        position.z + origin.z;
+    array[VoxelMeshVertexConstants.UVOffset + index] = uvs.x;
+    array[VoxelMeshVertexConstants.UVOffset + index + 1] = uvs.y;
+    array[VoxelMeshVertexConstants.NormalOffset + index] = normal.x;
+    array[VoxelMeshVertexConstants.NormalOffset + index + 1] = normal.y;
+    array[VoxelMeshVertexConstants.NormalOffset + index + 2] = normal.z;
+    array[VoxelMeshVertexConstants.TextureIndexOffset + index] =
+        VoxelShaderData.createTextureIndex(texture, overlayTextures.x);
+    array[VoxelMeshVertexConstants.TextureIndexOffset + index + 1] =
+        VoxelShaderData.createTextureIndex(overlayTextures.y, overlayTextures.z);
+    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,6 +1,6 @@
 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;

package/Mesher/{Tools → Geomtry}/VoxelMeshBVHBuilder.d.ts

@@ -56,9 +56,8 @@ export declare class StructCursor {
     get active(): number;
     get nodeType(): number;
     trueIndex: number;
-    _index: number;
-    get index(): number;
-    set index(index: number);
+    private index;
+    setIndex(index: number): void;
     constructor(data: Float32Array);
     setActive(): void;
     setVoxelIndex(value: number): void;
@@ -66,12 +65,6 @@ export declare class StructCursor {
     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;

package/Mesher/{Tools → Geomtry}/VoxelMeshBVHBuilder.js

@@ -134,12 +134,8 @@ export class StructCursor {
         return this.data[this.trueIndex + 7];
     }
     trueIndex = 0;
-    _index = 0;
-    get index() {
-        return this._index;
-    }
-    set index(index) {
-        this._index = index;
+    index = 0;
+    setIndex(index) {
         this.trueIndex = index * 8;
     }
     constructor(data) {
@@ -185,14 +181,6 @@ export class StructCursor {
             this.data[iz] = z;
         }
     }
-    toJSON() {
-        return {
-            min: [this.minX, this.minY, this.minZ],
-            max: [this.maxX, this.maxY, this.maxZ],
-            active: this.active,
-            nodeType: this.nodeType,
-        };
-    }
 }
 export class VoxelMeshBVHBuilder {
     static AABBStructByteSize = (4 + 4) * 4;
@@ -209,7 +197,7 @@ export class VoxelMeshBVHBuilder {
         const leafIndex = this.treeIndex.getIndexAtLevel(12, voxelIndex);
         this.indices[voxelIndex * 2] = indicesStart;
         this.indices[voxelIndex * 2 + 1] = indicesEnd;
-        this.structCursor.index = leafIndex;
+        this.structCursor.setIndex(leafIndex);
         this.structCursor.updateMin(minX, minY, minZ);
         this.structCursor.updateMax(maxX, maxY, maxZ);
         this.structCursor.setVoxelIndex(voxelIndex);
@@ -217,7 +205,7 @@ export class VoxelMeshBVHBuilder {
         let current = leafIndex;
         for (let level = 1; level < 13; level++) {
             let parentNode = this.treeIndex.getParent(current);
-            this.structCursor.index = parentNode;
+            this.structCursor.setIndex(parentNode);
             this.structCursor.updateMin(minX, minY, minZ);
             this.structCursor.updateMax(maxX, maxY, maxZ);
             this.structCursor.setActive();

package/Mesher/Geomtry/{Buffers.d.ts → VoxelMeshBuffers.d.ts}

@@ -1,19 +1,20 @@
-export interface VoxelVertexBuffer {
-    [index: number]: number;
-}
 export declare class VoxelVertexBuffer {
     vertexFloatSize: number;
     sectorVertexSize: number;
     _buffers: Float32Array[];
+    sectorSize: number;
     constructor(vertexFloatSize: number, sectorVertexSize: number, startingSectorSize?: number);
-    get length(): number;
-}
-export interface VoxelIndiceBuffer {
-    [index: number]: number;
+    currentArray: Float32Array;
+    curentIndex: number;
+    _index: number;
+    setIndex(index: number): void;
 }
 export declare class VoxelIndiceBuffer {
     sectorSize: number;
     _buffers: Uint32Array[];
     constructor(sectorSize: number, startingSectorSize?: number);
-    get length(): number;
+    currentArray: Uint32Array;
+    curentIndex: number;
+    _index: number;
+    setIndex(index: number): this;
 }