@divinevoxel/vlox 0.0.74 → 0.0.76

package/Mesher/Geomtry/VoxelGeometryBuilder.js

@@ -1,18 +1,77 @@
+import { Vector4Like } from "@amodx/math";
 import { VoxelShaderData } from "./VoxelShaderData";
 import { QuadVerticies } from "./Geometry.types";
-import { VoxelMeshVertexConstants, VoxelMeshVertexStructCursor, } from "./VoxelMeshVertexStructCursor";
-const empty = [];
-const structCursor = new VoxelMeshVertexStructCursor();
-export class VoxelGeometryBuilder {
+import { VoxelMeshVertexConstants } from "./VoxelMeshVertexStructCursor";
+const vector1ShaderData = Vector4Like.Create();
+const vector2ShaderData = Vector4Like.Create();
+const vector3ShaderData = Vector4Like.Create();
+const vector4ShaderData = Vector4Like.Create();
+export function addVoxelTriangle(builder, tri) {
+    if (!builder.mesh)
+        return;
+    const origin = builder.origin;
+    const worldLight = builder.vars.light;
+    const worldAO = builder.vars.ao;
+    const animData = builder.vars.animation;
+    const texture = builder.vars.textureIndex;
+    const overlayTextures = builder.vars.overlayTextures;
+    const topRightPos = tri.positions.vertices[0];
+    const topLeftPos = tri.positions.vertices[1];
+    const bottomLeftPos = tri.positions.vertices[2];
+    const topRightNor = tri.normals.vertices[0];
+    const topLeftNor = tri.normals.vertices[1];
+    const bottomLeftNor = tri.normals.vertices[2];
+    const topRightVoxelData = VoxelShaderData.create(worldLight.vertices[QuadVerticies.TopRight], worldLight.vertices[QuadVerticies.TopLeft], worldLight.vertices[QuadVerticies.BottomLeft], worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.TopRight], QuadVerticies.TopRight, vector1ShaderData);
+    const topLeftVoxelData = VoxelShaderData.create(worldLight.vertices[QuadVerticies.TopRight], worldLight.vertices[QuadVerticies.TopLeft], worldLight.vertices[QuadVerticies.BottomLeft], worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.TopLeft], QuadVerticies.TopLeft, vector2ShaderData);
+    const bottomLeftVoxelData = VoxelShaderData.create(worldLight.vertices[QuadVerticies.TopRight], worldLight.vertices[QuadVerticies.TopLeft], worldLight.vertices[QuadVerticies.BottomLeft], worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.BottomLeft], QuadVerticies.BottomLeft, vector3ShaderData);
+    const indices = builder.mesh.indices;
+    let indIndex = builder.mesh.indicieCount;
+    let sides = tri.doubleSided ? 2 : 1;
+    const baseIndex = builder.mesh.vertexCount;
+    while (sides--) {
+        const baseIndex = builder.mesh.vertexCount;
+        builder.mesh.buffer.setIndex(baseIndex);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topRightPos, topRightNor, tri.uvs.vertices[QuadVerticies.TopRight], topRightVoxelData, texture, overlayTextures);
+        builder.mesh.buffer.setIndex(baseIndex + 1);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, tri.uvs.vertices[QuadVerticies.TopLeft], topLeftVoxelData, texture, overlayTextures);
+        builder.mesh.buffer.setIndex(baseIndex + 2);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, tri.uvs.vertices[QuadVerticies.BottomLeft], bottomLeftVoxelData, texture, overlayTextures);
+        builder.mesh.addVerticies(3, 3);
+    }
+    if (!tri.doubleSided) {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+    }
+    else {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        index += 3;
+        indIndex += 3;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index + 3;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 1;
+    }
+    builder.vars.reset();
 }
-export function addVoxelQuad(tool, origin, quad) {
-    if (!tool.mesh)
+export function addVoxelQuad(builder, quad) {
+    if (!builder.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 origin = builder.origin;
+    const worldLight = builder.vars.light;
+    const worldAO = builder.vars.ao;
+    const animData = builder.vars.animation;
+    const texture = builder.vars.textureIndex;
+    const overlayTextures = builder.vars.overlayTextures;
     const topRightPos = quad.positions.vertices[0];
     const topLeftPos = quad.positions.vertices[1];
     const bottomLeftPos = quad.positions.vertices[2];
@@ -21,107 +80,61 @@ export function addVoxelQuad(tool, origin, quad) {
     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 topRightVoxelData = VoxelShaderData.create(worldLight.vertices[QuadVerticies.TopRight], worldLight.vertices[QuadVerticies.TopLeft], worldLight.vertices[QuadVerticies.BottomLeft], worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.TopRight], QuadVerticies.TopRight, vector1ShaderData);
+    const topLeftVoxelData = VoxelShaderData.create(worldLight.vertices[QuadVerticies.TopRight], worldLight.vertices[QuadVerticies.TopLeft], worldLight.vertices[QuadVerticies.BottomLeft], worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.TopLeft], QuadVerticies.TopLeft, vector2ShaderData);
+    const bottomLeftVoxelData = VoxelShaderData.create(worldLight.vertices[QuadVerticies.TopRight], worldLight.vertices[QuadVerticies.TopLeft], worldLight.vertices[QuadVerticies.BottomLeft], worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.BottomLeft], QuadVerticies.BottomLeft, vector3ShaderData);
+    const bottomRightVoxelData = VoxelShaderData.create(worldLight.vertices[QuadVerticies.TopRight], worldLight.vertices[QuadVerticies.TopLeft], worldLight.vertices[QuadVerticies.BottomLeft], worldLight.vertices[QuadVerticies.BottomRight], worldAO.vertices[QuadVerticies.TopRight], worldAO.vertices[QuadVerticies.TopLeft], worldAO.vertices[QuadVerticies.BottomLeft], worldAO.vertices[QuadVerticies.BottomRight], animData.vertices[QuadVerticies.BottomRight], QuadVerticies.BottomRight, vector4ShaderData);
+    const indices = builder.mesh.indices;
+    let indIndex = builder.mesh.indicieCount;
+    const baseIndex = builder.mesh.vertexCount;
+    builder.mesh.buffer.setIndex(baseIndex);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topRightPos, topRightNor, quad.uvs.vertices[QuadVerticies.TopRight], topRightVoxelData, texture, overlayTextures);
+    builder.mesh.buffer.setIndex(baseIndex + 1);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, quad.uvs.vertices[QuadVerticies.TopLeft], topLeftVoxelData, texture, overlayTextures);
+    builder.mesh.buffer.setIndex(baseIndex + 2);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, quad.uvs.vertices[QuadVerticies.BottomLeft], bottomLeftVoxelData, texture, overlayTextures);
+    builder.mesh.buffer.setIndex(baseIndex + 3);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomRightPos, bottomRightNor, quad.uvs.vertices[QuadVerticies.BottomRight], bottomRightVoxelData, texture, overlayTextures);
+    if (!quad.doubleSided) {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+            index + 3;
+        indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] = index;
+        builder.mesh.addVerticies(4, 6);
+    }
+    else {
+        let index = baseIndex;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+            index + 3;
+        indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] = index;
+        indIndex += 6;
+        indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
+        indices.setIndex(indIndex + 1).currentArray[indices.curentIndex] =
+            index + 3;
+        indices.setIndex(indIndex + 2).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 3).currentArray[indices.curentIndex] =
+            index + 2;
+        indices.setIndex(indIndex + 4).currentArray[indices.curentIndex] =
+            index + 1;
+        indices.setIndex(indIndex + 5).currentArray[indices.curentIndex] = index;
+        builder.mesh.addVerticies(4, 12);
     }
+    builder.vars.reset();
 }
 function addVertex(index, array, origin, position, normal, uvs, voxelData, texture, overlayTextures) {
     index *= VoxelMeshVertexConstants.VertexFloatSize;
@@ -142,5 +155,8 @@ function addVertex(index, array, origin, position, normal, uvs, voxelData, textu
         VoxelShaderData.createTextureIndex(overlayTextures.y, overlayTextures.z);
     array[VoxelMeshVertexConstants.TextureIndexOffset + index + 2] =
         VoxelShaderData.createTextureIndex(overlayTextures.w, 0);
-    array[VoxelMeshVertexConstants.VoxelDataOFfset + index] = voxelData;
+    array[VoxelMeshVertexConstants.VoxelDataOFfset + index] = voxelData.x;
+    array[VoxelMeshVertexConstants.VoxelDataOFfset + index + 1] = voxelData.y;
+    array[VoxelMeshVertexConstants.VoxelDataOFfset + index + 2] = voxelData.z;
+    array[VoxelMeshVertexConstants.VoxelDataOFfset + index + 3] = voxelData.w;
 }

package/Mesher/Geomtry/VoxelMeshBVHBuilder.d.ts

@@ -1,12 +1,12 @@
 import { Vec3Array } from "@amodx/math";
 import { VoxelMeshBVHStructCursor } from "./VoxelMeshBVHStructCursor";
-import { FlatBinaryTreeIndex } from "../../Util/Binary/BinaryTree";
+import { FlatBinaryTreeIndex } from "../../Util/FlatBinaryTreeIndex";
 export declare class VoxelMeshBVHBuilder {
     static AABBStructByteSize: number;
     treeIndex: FlatBinaryTreeIndex;
-    tree: Float32Array;
+    tree: Float32Array<ArrayBuffer>;
     structCursor: VoxelMeshBVHStructCursor;
-    indices: Uint32Array;
+    indices: Uint32Array<ArrayBuffer>;
     reset(): void;
     getMeshBounds(): {
         min: Vec3Array;

package/Mesher/Geomtry/VoxelMeshBVHBuilder.js

@@ -1,6 +1,6 @@
 import { WorldSpaces } from "../../World/WorldSpaces";
 import { VoxelMeshBVHStructCursor } from "./VoxelMeshBVHStructCursor";
-import { FlatBinaryTreeIndex } from "../../Util/Binary/BinaryTree";
+import { FlatBinaryTreeIndex } from "../../Util/FlatBinaryTreeIndex";
 const MAX_FLOAT32 = new Float32Array([Infinity])[0];
 export class VoxelMeshBVHBuilder {
     static AABBStructByteSize = (4 + 4) * 4;

package/Mesher/Geomtry/VoxelMeshVertexStructCursor.d.ts

@@ -29,8 +29,14 @@ export declare class VoxelMeshVertexStructCursor {
     set normalY(value: number);
     get normalZ(): number;
     set normalZ(value: number);
-    get voxelData(): number;
-    set voxelData(value: number);
+    get voxelDataX(): number;
+    set voxelDataX(value: number);
+    get voxelDataY(): number;
+    set voxelDataY(value: number);
+    get voxelDataZ(): number;
+    set voxelDataZ(value: number);
+    get voxelDataW(): number;
+    set voxelDataW(value: number);
     get textureIndexX(): number;
     set textureIndexX(value: number);
     get textureIndexY(): number;
@@ -58,7 +64,7 @@ export declare class VoxelMeshVertexStructCursor {
     toJSON(): {
         position: number[];
         normal: number[];
-        voxelData: number;
+        voxelData: number[];
         textureIndex: number[];
         uv: number[];
         color: number[];

package/Mesher/Geomtry/VoxelMeshVertexStructCursor.js

@@ -62,13 +62,31 @@ export class VoxelMeshVertexStructCursor {
             value;
     }
     // voxel data
-    get voxelData() {
+    get voxelDataX() {
         return this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset];
     }
-    set voxelData(value) {
+    set voxelDataX(value) {
         this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset] =
             value;
     }
+    get voxelDataY() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 1];
+    }
+    set voxelDataY(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 1] = value;
+    }
+    get voxelDataZ() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 2];
+    }
+    set voxelDataZ(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 2] = value;
+    }
+    get voxelDataW() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 3];
+    }
+    set voxelDataW(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 3] = value;
+    }
     // texture index
     get textureIndexX() {
         return this.data[this.trueIndex + VoxelMeshVertexStructCursor.TextureIndexOffset];
@@ -142,7 +160,12 @@ export class VoxelMeshVertexStructCursor {
         return {
             position: [this.positionX, this.positionY, this.positionZ],
             normal: [this.normalX, this.normalY, this.normalZ],
-            voxelData: this.voxelData,
+            voxelData: [
+                this.voxelDataX,
+                this.voxelDataY,
+                this.voxelDataZ,
+                this.voxelDataW,
+            ],
             textureIndex: [
                 this.textureIndexX,
                 this.textureIndexY,

package/Mesher/Geomtry/VoxelShaderData.d.ts

@@ -1,3 +1,4 @@
+import { Vector4Like } from "@amodx/math";
 declare enum WindAffectedAnimStates {
     Panel = 1,
     CrossPanel = 2,
@@ -7,11 +8,13 @@ export declare class VoxelShaderData {
     static AnimationStates: {
         WindAffected: typeof WindAffectedAnimStates;
     };
+    static v: number;
     static LightMask: number;
     static AOMask: number;
+    static VertexMask: number;
     static AnimationMask: number;
     static TextureIndexMax: number;
     static createTextureIndex(index1: number, index2: number): number;
-    static createAttribute(light: number, ao: number, animation: number): number;
+    static create(light1: number, light2: number, light3: number, light4: number, ao1: number, ao2: number, ao3: number, ao4: number, animation: number, vertexIndex: number, ref?: Vector4Like): Vector4Like;
 }
 export {};

package/Mesher/Geomtry/VoxelShaderData.js

@@ -1,3 +1,4 @@
+import { Vector4Like } from "@amodx/math";
 var WindAffectedAnimStates;
 (function (WindAffectedAnimStates) {
     WindAffectedAnimStates[WindAffectedAnimStates["Panel"] = 1] = "Panel";
@@ -8,9 +9,11 @@ export class VoxelShaderData {
     static AnimationStates = {
         WindAffected: WindAffectedAnimStates,
     };
+    static v = 0xffff + 0xf + 0xf;
     static LightMask = 0xffff;
-    static AOMask = 0xf;
-    static AnimationMask = 0xfff;
+    static AOMask = 0b11;
+    static VertexMask = 0b11;
+    static AnimationMask = 0b11;
     static TextureIndexMax = 0xffff;
     static createTextureIndex(index1, index2) {
         let value = 0;
@@ -22,13 +25,25 @@ export class VoxelShaderData {
                 ((index2 & this.TextureIndexMax) << 16);
         return value;
     }
-    static createAttribute(light, ao, animation) {
-        let value = 0;
-        value = (value & ~(this.LightMask << 0)) | ((light & this.LightMask) << 0);
-        value = (value & ~(this.AOMask << 16)) | ((ao & this.AOMask) << 16);
-        value =
-            (value & ~(this.AnimationMask << 20)) |
-                ((animation & this.AnimationMask) << 20);
-        return value;
+    static create(light1, light2, light3, light4, ao1, ao2, ao3, ao4, animation, vertexIndex, ref = Vector4Like.Create()) {
+        let x = 0;
+        x |= (light1 & this.LightMask) << 0;
+        x |= (ao1 & this.AOMask) << 16;
+        x |= (ao2 & this.AOMask) << 18;
+        x |= (ao3 & this.AOMask) << 20;
+        x |= (ao4 & this.AOMask) << 22;
+        ref.x = x;
+        let y = 0;
+        y |= (light2 & this.LightMask) << 0;
+        y |= (animation & this.AnimationMask) << 16;
+        ref.y = y;
+        let z = 0;
+        z |= (light3 & this.LightMask) << 0;
+        z |= (vertexIndex & this.VertexMask) << 16;
+        ref.z = z;
+        let w = 0;
+        w |= (light4 & this.LightMask) << 0;
+        ref.w = w;
+        return ref;
     }
 }

package/Mesher/InitMesher.d.ts

@@ -1,2 +1,2 @@
-import { FinalCompiledVoxelModelData } from "../Voxels/Types/VoxelModelCompiledData.types";
+import { FinalCompiledVoxelModelData } from "../Voxels/Models/CompiledVoxelModel.types";
 export default function (materials: string[], modelData: FinalCompiledVoxelModelData): void;

package/Mesher/InitMesher.js

@@ -2,12 +2,18 @@ import { RenderedMaterials } from "./Models/RenderedMaterials";
 import { VoxelModelConstructorRegister } from "./Models/VoxelModelConstructorRegister.js";
 import { LiquidGeometryNode } from "./Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js";
 import { VoxelConstructor } from "./Models/VoxelConstructor.js";
+import { AOOcclusionFaceIndex } from "../Voxels/Models/Indexing/AOOcclusionFaceIndex";
+import { CulledOcclusionFaceIndex } from "../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
 export default function (materials, modelData) {
     RenderedMaterials.register(materials);
     VoxelModelConstructorRegister.registerCustomNode("liquid", LiquidGeometryNode);
     VoxelModelConstructorRegister.setGeometryPalette(modelData.geometryPalette);
     VoxelModelConstructorRegister.registerGeometry(modelData.geometry);
     VoxelModelConstructorRegister.registerModels(modelData.models);
+    VoxelModelConstructorRegister.aoIndex = new AOOcclusionFaceIndex(modelData.aoIndex);
+    VoxelModelConstructorRegister.faceCullIndex = new CulledOcclusionFaceIndex(modelData.faceCullIndex);
+    VoxelModelConstructorRegister.vertexHitMap = modelData.vertexHitMap;
+    VoxelModelConstructorRegister.faceCullMap = modelData.faceCullMap;
     for (const voxel of modelData.voxels) {
         VoxelModelConstructorRegister.registerVoxel(new VoxelConstructor(voxel.id, RenderedMaterials.meshersMap.get(voxel.materialId), VoxelModelConstructorRegister.modelData.get(voxel.modelId), voxel));
     }

package/Mesher/InitTask.js

@@ -2,15 +2,29 @@ import { Threads } from "@amodx/threads";
 import { WorldRegister } from "../World/WorldRegister";
 import { MeshSection } from "./Functions/MeshSection";
 import { TasksIds } from "../Tasks/TasksIds";
+import { getLocationData } from "../Util/LocationData";
+import { MeshSectionSnapShot } from "./Functions/MeshSectionSnapShot";
+import { SectionSnapShot, } from "../World/SnapShot/SectionSnapShot";
 export default function (rendererThread) {
-    Threads.registerTask(TasksIds.BuildSection, (location) => {
+    Threads.registerBinaryTask(TasksIds.BuildSection, (view) => {
         const transfers = [];
-        const section = MeshSection(location, transfers);
+        const section = MeshSection(getLocationData(view), transfers);
         if (!section)
             return;
         rendererThread.runTask("set-section", section, transfers);
     });
-    Threads.registerTask(TasksIds.BuildSector, (location, origin) => {
+    const snapShot = new SectionSnapShot();
+    Threads.registerTask(TasksIds.BuildSectionSnapShot, (data, origin) => {
+        snapShot.restore(data);
+        const transfers = [];
+        const section = MeshSectionSnapShot(snapShot, transfers);
+        origin.runTask("cache-snap-shot", ...snapShot.transfer());
+        if (!section)
+            return;
+        rendererThread.runTask("set-section", section, transfers);
+    });
+    Threads.registerBinaryTask(TasksIds.BuildSector, (view, origin) => {
+        const location = getLocationData(view);
         const sector = WorldRegister.sectors.getAt(location);
         if (!sector) {
             console.warn("Tried building a sector that does not exists.", location);
@@ -27,9 +41,6 @@ export default function (rendererThread) {
             if (!sectionMesh)
                 continue;
             rendererThread.runTask("set-section", sectionMesh, transfers);
-            const buildTime = performance.now() - t;
-            origin.runTask("add-build-time", buildTime);
-            console.log("BUILD TIME", buildTime);
         }
     });
 }

package/Mesher/Models/Common/Calc/CalcConstants.d.ts

@@ -1,15 +1,11 @@
 import { QuadVerticies } from "../../../Geomtry/Geometry.types";
 import { VoxelFaces } from "../../../../Math";
-import { Vec3Array, Vec4Array } from "@amodx/math";
-import { Quad } from "../../../Geomtry/Primitives/Quad";
+import { Vec4Array } from "@amodx/math";
 export declare const GradientCheckSets: Record<VoxelFaces, Record<QuadVerticies, number[]>>;
-export declare const GradientCheckSetsArray: Int8Array;
+export declare const GradientCheckSetsArray: Int8Array<ArrayBuffer>;
 export declare const GeometryCheckSetIndexes: Record<VoxelFaces, Record<QuadVerticies, [number, number, number]>>;
 export declare const CenterDirectionIndex: number;
 export declare const DirectionIndexes: Record<VoxelFaces, number>;
 export declare function shouldCauseFlip(topRight: number, topLeft: number, bottomLeft: number, bottomRight: number): boolean;
-export declare function getVertexWeights(face: VoxelFaces, x: number, y: number, z: number): Vec4Array;
 export declare function getInterpolationValue(value: Vec4Array, weights: Vec4Array): number;
 export type QuadVertexWeights = [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
-export declare const getQuadWeights: (quad: Quad, direction: VoxelFaces) => QuadVertexWeights;
-export declare function closestUnitNormal(v: Vec3Array): Vec3Array;

package/Mesher/Models/Common/Calc/CalcConstants.js

@@ -1,6 +1,6 @@
-import { QuadVerticies, QuadVerticiesArray, } from "../../../Geomtry/Geometry.types";
+import { QuadVerticies, } from "../../../Geomtry/Geometry.types";
 import { VoxelFaces, VoxelFacesArray } from "../../../../Math";
-import { VoxelRelativeCubeIndex } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
+import { VoxelRelativeCubeIndex } from "../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
 export const GradientCheckSets = [];
 GradientCheckSets[VoxelFaces.Up] = [];
@@ -267,49 +267,6 @@ export function shouldCauseFlip(topRight, topLeft, bottomLeft, bottomRight) {
         return true;
     return (topRight + bottomLeft) / 2 > (topLeft + bottomRight) / 2;
 }
-function getInterpolationWeights(x, y, flip = false) {
-    x = Math.max(0, Math.min(1, x));
-    y = Math.max(0, Math.min(1, y));
-    let w1 = (1 - x) * (1 - y); // Weight for v1 = (0, 0)
-    let w2 = x * (1 - y); // Weight for v2 = (1, 0)
-    let w3 = x * y; // Weight for v3 = (1, 1)
-    let w4 = (1 - x) * y; // Weight for v4 = (0, 1)
-    return flip ? [w4, w3, w2, w1] : [w3, w4, w1, w2];
-}
-export function getVertexWeights(face, x, y, z) {
-    let flip = false;
-    let u, v;
-    switch (face) {
-        case VoxelFaces.Up:
-            u = x;
-            v = z;
-            break;
-        case VoxelFaces.Down:
-            u = x;
-            v = z;
-            flip = true;
-            break;
-        case VoxelFaces.North:
-            u = x;
-            v = y;
-            flip = true;
-            break;
-        case VoxelFaces.South:
-            u = x;
-            v = y;
-            break;
-        case VoxelFaces.East:
-            u = z;
-            v = y;
-            break;
-        case VoxelFaces.West:
-            u = z;
-            v = y;
-            flip = true;
-            break;
-    }
-    return getInterpolationWeights(u, v, flip);
-}
 const lightData = new VoxelLightData();
 export function getInterpolationValue(value, weights) {
     return lightData.createLightValue(lightData.getS(value[0]) * weights[0] +
@@ -326,34 +283,3 @@ export function getInterpolationValue(value, weights) {
         lightData.getB(value[2]) * weights[2] +
         lightData.getB(value[3]) * weights[3]);
 }
-export const getQuadWeights = (quad, direction) => {
-    const returnArray = [];
-    for (const vertex of QuadVerticiesArray) {
-        const { x, y, z } = quad.positions.vertices[vertex];
-        returnArray[vertex] = getVertexWeights(direction, x, y, z);
-    }
-    return returnArray;
-};
-export function closestUnitNormal(v) {
-    const [x, y, z] = v;
-    let maxDotOverMagnitude = -Infinity;
-    let bestS = [0, 0, 0];
-    for (const sx of [-1, 0, 1]) {
-        for (const sy of [-1, 0, 1]) {
-            for (const sz of [-1, 0, 1]) {
-                if (sx === 0 && sy === 0 && sz === 0)
-                    continue; // Skip the zero vector
-                const sMagnitude = Math.sqrt(sx * sx + sy * sy + sz * sz);
-                const vDotS = x * sx + y * sy + z * sz;
-                const dotOverMagnitude = vDotS / sMagnitude;
-                if (dotOverMagnitude > maxDotOverMagnitude) {
-                    maxDotOverMagnitude = dotOverMagnitude;
-                    bestS = [sx, sy, sz];
-                }
-            }
-        }
-    }
-    // Normalize the best vector to unit length
-    const sMagnitude = Math.sqrt(bestS[0] * bestS[0] + bestS[1] * bestS[1] + bestS[2] * bestS[2]);
-    return [bestS[0] / sMagnitude, bestS[1] / sMagnitude, bestS[2] / sMagnitude];
-}

package/Mesher/Models/Common/Faces/CullRulledFace.d.ts

@@ -0,0 +1,2 @@
+import { VoxelModelBuilder } from "../../VoxelModelBuilder";
+export declare function CullRulledFace(builder: VoxelModelBuilder, trueFaceIndex: number): boolean;