@divinevoxel/vlox 0.0.7 → 0.0.72

package/Mesher/Geomtry/Tools/MesherDataTools.js

@@ -5,7 +5,7 @@ export class MesherDataTool {
     startNewMesh(mesh) {
         this.mesh = mesh ? mesh : new VoxelMesh();
     }
-    resetAll() {
+    clear() {
         this.mesh?.clear();
         return this;
     }

package/Mesher/Geomtry/VoxelGeometryBuilder.js

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

@@ -1,8 +1,6 @@
 import { RenderedMaterials } from "./RenderedMaterials";
 import { VoxelModelConstructorRegister } from "./Models/VoxelModelConstructorRegister.js";
 import { LiquidGeometryNode } from "./Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js";
-import { SchemaRegister } from "../Voxels/State/SchemaRegister.js";
-import { VoxelTagStates } from "../Voxels/State/VoxelTagStates.js";
 import { VoxelConstructor } from "./Models/VoxelConstructor.js";
 export default function (materials, modelData) {
     RenderedMaterials.register(materials);
@@ -10,14 +8,7 @@ export default function (materials, modelData) {
     VoxelModelConstructorRegister.setGeometryPalette(modelData.geometryPalette);
     VoxelModelConstructorRegister.registerGeometry(modelData.geometry);
     VoxelModelConstructorRegister.registerModels(modelData.models);
-    for (const model of modelData.models) {
-        SchemaRegister.registerModel(model.id, model.schema);
-    }
-    for (const voxel of modelData.voxels) {
-        SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
-    }
-    VoxelTagStates.load(modelData.tagState);
     for (const voxel of modelData.voxels) {
-        VoxelModelConstructorRegister.registerVoxel(new VoxelConstructor(voxel.id, VoxelModelConstructorRegister.modelData.get(voxel.modelId), voxel));
+        VoxelModelConstructorRegister.registerVoxel(new VoxelConstructor(voxel.id, RenderedMaterials.meshersMap.get(voxel.materialId), VoxelModelConstructorRegister.modelData.get(voxel.modelId), voxel));
     }
 }

package/Mesher/InitTask.js

@@ -5,10 +5,11 @@ import { MeshSection } from "./Functions/MeshSection";
 import { TasksIds } from "../Tasks/TasksIds";
 export default function (rendererThread) {
     Threads.registerTask(TasksIds.BuildSection, (location) => {
-        const section = MeshSection(location);
+        const transfers = [];
+        const section = MeshSection(location, transfers);
         if (!section)
             return;
-        rendererThread.runTask("set-section", section[0], section[1]);
+        rendererThread.runTask("set-section", section, transfers);
     });
     Threads.registerTask(TasksIds.BuildSector, (location) => {
         const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
@@ -25,19 +26,24 @@ export default function (rendererThread) {
             console.warn("Tried building a sector with no sections.", sector.position);
             return;
         }
+        const transfers = [];
         for (let i = 0; i < sector.sections.length; i++) {
             const section = sector.sections[i];
             if (!section)
                 continue;
+            let [minY, maxY] = section.getMinMax();
+            if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
+                continue;
+            transfers.length = 0;
             const sectionMesh = MeshSection([
                 location[0],
                 sector.position[0],
                 sector.position[1] + i * WorldSpaces.section.bounds.y,
                 sector.position[2],
-            ]);
+            ], transfers);
             if (!sectionMesh)
                 continue;
-            rendererThread.runTask("set-section", sectionMesh[0], sectionMesh[1]);
+            rendererThread.runTask("set-section", sectionMesh, transfers);
         }
     });
 }

package/Mesher/Models/Common/BoundsFunctions.d.ts

@@ -1,4 +1,2 @@
-import { Vec3Array, Vector3Like } from "@amodx/math";
-import { VoxelMesherDataTool } from "../../../Mesher/Tools/VoxelMesherDataTool";
-export declare function UpdateBounds(tool: VoxelMesherDataTool, origin: Vector3Like, bounds: [Vec3Array, Vec3Array]): void;
+import { Vec3Array } from "@amodx/math";
 export declare function GetBounds(vectors: Vec3Array[]): [Vec3Array, Vec3Array];

package/Mesher/Models/Common/BoundsFunctions.js

@@ -1,19 +1,3 @@
-export function UpdateBounds(tool, origin, bounds) {
-    //min
-    if (origin.x + bounds[0][0] < tool.bounds.min[0])
-        tool.bounds.min[0] = origin.x + bounds[0][0];
-    if (origin.y + bounds[0][1] < tool.bounds.min[1])
-        tool.bounds.min[1] = origin.y + bounds[0][1];
-    if (origin.z + bounds[0][2] < tool.bounds.min[2])
-        tool.bounds.min[2] = origin.z + bounds[0][2];
-    //max
-    if (origin.x + bounds[1][0] > tool.bounds.max[0])
-        tool.bounds.max[0] = origin.x + bounds[1][0];
-    if (origin.y + bounds[1][1] > tool.bounds.max[1])
-        tool.bounds.max[1] = origin.y + bounds[1][1];
-    if (origin.z + bounds[1][2] > tool.bounds.max[2])
-        tool.bounds.max[2] = origin.z + bounds[1][2];
-}
 export function GetBounds(vectors) {
     let minX = Infinity;
     let minY = Infinity;

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

@@ -2,7 +2,6 @@ import { QuadVerticies, QuadVerticiesArray, } from "../../../Geomtry/Geometry.ty
 import { VoxelFaces, VoxelFacesArray } from "../../../../Math";
 import { VoxelRelativeCubeIndex } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-const lightData = new VoxelLightData();
 export const GradientCheckSets = [];
 GradientCheckSets[VoxelFaces.Up] = [];
 GradientCheckSets[VoxelFaces.Up][QuadVerticies.TopRight] = [
@@ -311,37 +310,21 @@ export function getVertexWeights(face, x, y, z) {
     }
     return getInterpolationWeights(u, v, flip);
 }
-const lightValues1 = [0, 0, 0, 0];
-const lightValues2 = [0, 0, 0, 0];
-const lightValues3 = [0, 0, 0, 0];
-const lightValues4 = [0, 0, 0, 0];
-const lightValues5 = [0, 0, 0, 0];
+const lightData = new VoxelLightData();
 export function getInterpolationValue(value, weights) {
-    lightData.getLightValuesToRef(value[0], lightValues1);
-    lightData.getLightValuesToRef(value[1], lightValues2);
-    lightData.getLightValuesToRef(value[2], lightValues3);
-    lightData.getLightValuesToRef(value[3], lightValues4);
-    lightValues5[0] =
-        lightValues1[0] * weights[0] +
-            lightValues2[0] * weights[1] +
-            lightValues3[0] * weights[2] +
-            lightValues4[0] * weights[3];
-    lightValues5[1] =
-        lightValues1[1] * weights[0] +
-            lightValues2[1] * weights[1] +
-            lightValues3[1] * weights[2] +
-            lightValues4[1] * weights[3];
-    lightValues5[2] =
-        lightValues1[2] * weights[0] +
-            lightValues2[2] * weights[1] +
-            lightValues3[2] * weights[2] +
-            lightValues4[2] * weights[3];
-    lightValues5[3] =
-        lightValues1[3] * weights[0] +
-            lightValues2[3] * weights[1] +
-            lightValues3[3] * weights[2] +
-            lightValues4[3] * weights[3];
-    return lightData.setLightValues(lightValues5);
+    return lightData.createLightValue(lightData.getS(value[0]) * weights[0] +
+        lightData.getS(value[1]) * weights[1] +
+        lightData.getS(value[2]) * weights[2] +
+        lightData.getS(value[3]) * weights[3], lightData.getR(value[0]) * weights[0] +
+        lightData.getR(value[1]) * weights[1] +
+        lightData.getR(value[2]) * weights[2] +
+        lightData.getR(value[3]) * weights[3], lightData.getG(value[0]) * weights[0] +
+        lightData.getG(value[1]) * weights[1] +
+        lightData.getG(value[2]) * weights[2] +
+        lightData.getG(value[3]) * weights[3], lightData.getB(value[0]) * weights[0] +
+        lightData.getB(value[1]) * weights[1] +
+        lightData.getB(value[2]) * weights[2] +
+        lightData.getB(value[3]) * weights[3]);
 }
 export const addQuadWeights = (quad, direction) => {
     const returnArray = [];

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

@@ -1,9 +1,3 @@
 import type { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool.js";
 import { VoxelFaces } from "../../../../Math/index.js";
-export declare const FaceDataCalc: {
-    settings: {
-        doAO: boolean;
-        doLight: boolean;
-    };
-    calculate(face: VoxelFaces, tool: VoxelMesherDataTool): void;
-};
+export default function calculateFaceData(face: VoxelFaces, builder: VoxelMesherDataTool): void;

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

@@ -4,54 +4,45 @@ import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData.js";
 const lightData = new VoxelLightData();
 const currentLightValues = new Uint16Array([0, 0, 0, 0]);
 const loadedLightValues = new Uint16Array([0, 0, 0, 0]);
-const faceLength = 9 * 4;
-const settings = {
-    doAO: true,
-    doLight: true,
-};
-export const FaceDataCalc = {
-    settings,
-    calculate(face, tool) {
-        let light = tool.voxel.getLight();
-        const faceNormal = VoxelFaceDirections[face];
-        const nVoxel = tool.nVoxel.getVoxel(tool.position.x + faceNormal[0], tool.position.y + faceNormal[1], tool.position.z + faceNormal[2]);
-        const otherLight = nVoxel?.getLight() || 0;
-        light = otherLight >= 0 ? otherLight : light >= 0 ? light : 0;
-        for (let vertex = 0; vertex < 4; vertex++) {
-            if (settings.doLight) {
-                tool.lightData[face][vertex] = light;
-                lightData.getLightValuesToRef(light, currentLightValues);
-            }
-            for (let i = 0; i < 9; i += 3) {
-                const loadedVoxel = tool.nVoxel.getVoxel(GradientCheckSets[face][vertex][i] + tool.position.x, GradientCheckSets[face][vertex][i + 1] + tool.position.y, GradientCheckSets[face][vertex][i + 2] + tool.position.z);
-                if (!settings.doLight || !loadedVoxel)
-                    continue;
-                const nl = loadedVoxel.getLight();
-                if (nl <= 0)
-                    continue;
-                /*
-              Do Light
-              */
-                lightData.getLightValuesToRef(nl, loadedLightValues);
-                currentLightValues[0] =
-                    currentLightValues[0] < loadedLightValues[0]
-                        ? loadedLightValues[0]
-                        : currentLightValues[0];
-                currentLightValues[1] =
-                    currentLightValues[1] < loadedLightValues[1]
-                        ? loadedLightValues[1]
-                        : currentLightValues[1];
-                currentLightValues[2] =
-                    currentLightValues[2] < loadedLightValues[2]
-                        ? loadedLightValues[2]
-                        : currentLightValues[2];
-                currentLightValues[3] =
-                    currentLightValues[3] < loadedLightValues[3]
-                        ? loadedLightValues[3]
-                        : currentLightValues[3];
-            }
-            tool.lightData[face][vertex] =
-                lightData.setLightValues(currentLightValues);
+export default function calculateFaceData(face, builder) {
+    let light = builder.voxel.getLight();
+    const faceNormal = VoxelFaceDirections[face];
+    const x = builder.position.x;
+    const y = builder.position.y;
+    const z = builder.position.z;
+    const vertexData = builder.lightData[face];
+    const nVoxel = builder.nVoxel;
+    const checkSet = GradientCheckSets[face];
+    const otherLight = builder.space.getLight(builder.nVoxel, x + faceNormal[0], y + faceNormal[1], z + faceNormal[2]) || 0;
+    light = otherLight >= 0 ? otherLight : light >= 0 ? light : 0;
+    for (let vertex = 0; vertex < 4; vertex++) {
+        vertexData[vertex] = light;
+        lightData.getLightValuesArrayToRef(light, currentLightValues);
+        for (let i = 0; i < 9; i += 3) {
+            const nl = builder.space.getLight(nVoxel, checkSet[vertex][i] + x, checkSet[vertex][i + 1] + y, checkSet[vertex][i + 2] + z);
+            if (nl <= 0)
+                continue;
+            /*
+            Do Light
+            */
+            lightData.getLightValuesArrayToRef(nl, loadedLightValues);
+            currentLightValues[0] =
+                currentLightValues[0] < loadedLightValues[0]
+                    ? loadedLightValues[0]
+                    : currentLightValues[0];
+            currentLightValues[1] =
+                currentLightValues[1] < loadedLightValues[1]
+                    ? loadedLightValues[1]
+                    : currentLightValues[1];
+            currentLightValues[2] =
+                currentLightValues[2] < loadedLightValues[2]
+                    ? loadedLightValues[2]
+                    : currentLightValues[2];
+            currentLightValues[3] =
+                currentLightValues[3] < loadedLightValues[3]
+                    ? loadedLightValues[3]
+                    : currentLightValues[3];
         }
-    },
-};
+        vertexData[vertex] = lightData.setLightValues(currentLightValues);
+    }
+}

package/Mesher/Models/Nodes/Custom/Liquid/LiquidGeomtryNode.d.ts

@@ -1,15 +1,11 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelMesherDataTool } from "Mesher/Tools/VoxelMesherDataTool";
 import { GeoemtryNode } from "../../GeometryNode";
 import { VoxelCustomGeomtryNode } from "../../../../../Models/VoxelModel.types";
-import { QuadScalarVertexData } from "../../../../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces } from "../../../../../Math";
 import type { LiquidVoxelModelArgs } from "../../../../../Models/Defaults/LiquidVoxelModel";
 export declare class LiquidGeometryNode extends GeoemtryNode<VoxelCustomGeomtryNode, LiquidVoxelModelArgs> {
-    worldLight: QuadScalarVertexData;
     init(): void;
     isExposed(face: VoxelFaces): boolean;
     determineShading(face: VoxelFaces): void;
     shouldFlip(): boolean;
-    add(tool: VoxelMesherDataTool, originHash: number, origin: Vector3Like, args: LiquidVoxelModelArgs): void;
+    add(args: LiquidVoxelModelArgs): boolean;
 }