@divinevoxel/vlox 0.0.80 → 0.0.81

package/Mesher/Items/MeshTexture.js

@@ -1,10 +1,8 @@
-import { QuadVerticies } from "../Geometry/Geometry.types";
 import { Quad } from "../Geometry/Primitives/Quad";
 import { ItemModelBuilder } from "./Models/ItemModelBuilder";
 import { addItemQuad } from "./Geometry/ItemGeometryBuilder";
 import { Flat2DIndex, Vector3Like } from "@amodx/math";
 import { Box } from "../Geometry/Shapes/Box";
-import { VoxelFaces } from "../../Math";
 import { CompactItemMesh } from "./Base/CompactItemMesh";
 const { quads: Quads } = Box.Create([
     [0, 0, 0],
@@ -15,14 +13,14 @@ const addUvs = (quad, factor, sx, sy, ex, ey) => {
     const uL = sx * factor;
     const vT = ey * factor;
     const vB = sy * factor;
-    quad.uvs.vertices[QuadVerticies.TopRight].x = uR;
-    quad.uvs.vertices[QuadVerticies.TopRight].y = vT;
-    quad.uvs.vertices[QuadVerticies.TopLeft].x = uL;
-    quad.uvs.vertices[QuadVerticies.TopLeft].y = vT;
-    quad.uvs.vertices[QuadVerticies.BottomLeft].x = uL;
-    quad.uvs.vertices[QuadVerticies.BottomLeft].y = vB;
-    quad.uvs.vertices[QuadVerticies.BottomRight].x = uR;
-    quad.uvs.vertices[QuadVerticies.BottomRight].y = vB;
+    quad.uvs.vertices[0 /* QuadVerticies.TopRight */].x = uR;
+    quad.uvs.vertices[0 /* QuadVerticies.TopRight */].y = vT;
+    quad.uvs.vertices[1 /* QuadVerticies.TopLeft */].x = uL;
+    quad.uvs.vertices[1 /* QuadVerticies.TopLeft */].y = vT;
+    quad.uvs.vertices[2 /* QuadVerticies.BottomLeft */].x = uL;
+    quad.uvs.vertices[2 /* QuadVerticies.BottomLeft */].y = vB;
+    quad.uvs.vertices[3 /* QuadVerticies.BottomRight */].x = uR;
+    quad.uvs.vertices[3 /* QuadVerticies.BottomRight */].y = vB;
 };
 class TextureVoxelData {
     width;
@@ -45,8 +43,8 @@ class TextureVoxelData {
         return a > 0.01;
     }
 }
-Quads[VoxelFaces.North].setUVs(Quad.FullUVs);
-Quads[VoxelFaces.South].setUVs(Quad.FullUVs);
+Quads[2 /* VoxelFaces.North */].setUVs(Quad.FullUVs);
+Quads[3 /* VoxelFaces.South */].setUVs(Quad.FullUVs);
 const tool = new ItemModelBuilder("dve_item");
 export function MeshTexture(textureId, textureData, origin = Vector3Like.Create(), thickness = null) {
     const width = Math.sqrt(textureData.length / 4);
@@ -54,25 +52,22 @@ export function MeshTexture(textureId, textureData, origin = Vector3Like.Create(
     const factor = 1 / width;
     const data = new TextureVoxelData(width, height, textureData);
     tool.origin = origin;
+    // South face
     {
-        //south face
         tool.vars.textureIndex = textureId;
-        addItemQuad(tool, Quads[VoxelFaces.South]);
+        addItemQuad(tool, Quads[3 /* VoxelFaces.South */]);
     }
+    // North face
     {
-        //north face
         const backPositionZ = factor;
-        Quads[VoxelFaces.North].positions.vertices[QuadVerticies.TopRight].z =
-            backPositionZ;
-        Quads[VoxelFaces.North].positions.vertices[QuadVerticies.TopLeft].z =
-            backPositionZ;
-        Quads[VoxelFaces.North].positions.vertices[QuadVerticies.BottomLeft].z =
-            backPositionZ;
-        Quads[VoxelFaces.North].positions.vertices[QuadVerticies.BottomRight].z =
-            backPositionZ;
+        Quads[2 /* VoxelFaces.North */].positions.vertices[0 /* QuadVerticies.TopRight */].z = backPositionZ;
+        Quads[2 /* VoxelFaces.North */].positions.vertices[1 /* QuadVerticies.TopLeft */].z = backPositionZ;
+        Quads[2 /* VoxelFaces.North */].positions.vertices[2 /* QuadVerticies.BottomLeft */].z = backPositionZ;
+        Quads[2 /* VoxelFaces.North */].positions.vertices[3 /* QuadVerticies.BottomRight */].z = backPositionZ;
         tool.vars.textureIndex = textureId;
-        addItemQuad(tool, Quads[VoxelFaces.North]);
+        addItemQuad(tool, Quads[2 /* VoxelFaces.North */]);
     }
+    // East/West faces
     for (let x = 0; x < width; x++) {
         let eastFace = null;
         let westFace = null;
@@ -95,17 +90,16 @@ export function MeshTexture(textureId, textureData, origin = Vector3Like.Create(
                 const y1 = y * factor;
                 const z0 = 0;
                 const z1 = factor;
-                // Flip winding vs previous: (p1 <-> p3)
                 const newQuad = Quad.Create([
-                    [x1, y0, z0], // p0
-                    [x1, y0, z1], // p1 (was p3)
-                    [x1, y1, z1], // p2
-                    [x1, y1, z0], // p3 (was p1)
+                    [x1, y0, z0],
+                    [x1, y0, z1],
+                    [x1, y1, z1],
+                    [x1, y1, z0],
                 ], Quad.FullUVs, false);
                 let [sx, sy] = eastFace;
                 let ex = x + 1;
                 let ey = y;
-                addUvs(newQuad, factor, sx, sy, ex, ey);
+                addUvs(newQuad, factor, sx, ey, ex, sy);
                 eastFace = null;
                 tool.vars.textureIndex = textureId;
                 addItemQuad(tool, newQuad);
@@ -116,17 +110,16 @@ export function MeshTexture(textureId, textureData, origin = Vector3Like.Create(
                 const y1 = y * factor;
                 const z0 = 0;
                 const z1 = factor;
-                // Flip winding vs previous: (p1 <-> p3)
                 const newQuad = Quad.Create([
-                    [x0, y0, z0], // p0
-                    [x0, y1, z0], // p1 (was p3)
-                    [x0, y1, z1], // p2
-                    [x0, y0, z1], // p3 (was p1)
+                    [x0, y0, z0],
+                    [x0, y1, z0],
+                    [x0, y1, z1],
+                    [x0, y0, z1],
                 ], Quad.FullUVs, false);
                 let [sx, sy] = westFace;
                 let ex = x + 1;
                 let ey = y;
-                addUvs(newQuad, factor, sx, sy, ex, ey);
+                addUvs(newQuad, factor, sx, ey, ex, sy);
                 westFace = null;
                 tool.vars.textureIndex = textureId;
                 addItemQuad(tool, newQuad);
@@ -139,7 +132,47 @@ export function MeshTexture(textureId, textureData, origin = Vector3Like.Create(
                 westFace = [x, y];
             }
         }
+        // FLUSH: emit any remaining faces at the top edge
+        if (eastFace) {
+            const x1 = x * factor + factor;
+            const y0 = eastFace[1] * factor;
+            const y1 = height * factor;
+            const z0 = 0;
+            const z1 = factor;
+            const newQuad = Quad.Create([
+                [x1, y0, z0],
+                [x1, y0, z1],
+                [x1, y1, z1],
+                [x1, y1, z0],
+            ], Quad.FullUVs, false);
+            let [sx, sy] = eastFace;
+            let ex = x + 1;
+            let ey = height;
+            addUvs(newQuad, factor, sx, sy, ex, ey);
+            tool.vars.textureIndex = textureId;
+            addItemQuad(tool, newQuad);
+        }
+        if (westFace) {
+            const x0 = x * factor;
+            const y0 = westFace[1] * factor;
+            const y1 = height * factor;
+            const z0 = 0;
+            const z1 = factor;
+            const newQuad = Quad.Create([
+                [x0, y0, z0],
+                [x0, y1, z0],
+                [x0, y1, z1],
+                [x0, y0, z1],
+            ], Quad.FullUVs, false);
+            let [sx, sy] = westFace;
+            let ex = x + 1;
+            let ey = height;
+            addUvs(newQuad, factor, sx, sy, ex, ey);
+            tool.vars.textureIndex = textureId;
+            addItemQuad(tool, newQuad);
+        }
     }
+    // Up/Down faces
     for (let y = 0; y < height; y++) {
         let upFace = null;
         let downFace = null;
@@ -162,18 +195,15 @@ export function MeshTexture(textureId, textureData, origin = Vector3Like.Create(
                 const y1 = y * factor + factor;
                 const z0 = 0;
                 const z1 = factor;
-                // +Y normal — CCW when viewed from +Y
                 const newQuad = Quad.Create([
-                    [x0, y1, z0], // p0
-                    [x1, y1, z0], // p1
-                    [x1, y1, z1], // p2
-                    [x0, y1, z1], // p3
-                ], Quad.FullUVs, false
-                // 0
-                );
+                    [x0, y1, z0],
+                    [x1, y1, z0],
+                    [x1, y1, z1],
+                    [x0, y1, z1],
+                ], Quad.FullUVs, false);
                 let [sx, sy] = upFace;
-                let [ex, ey] = [x, y];
-                ey += 1;
+                let ex = x;
+                let ey = y + 1;
                 addUvs(newQuad, factor, sx, sy, ex, ey);
                 upFace = null;
                 tool.vars.textureIndex = textureId;
@@ -185,18 +215,15 @@ export function MeshTexture(textureId, textureData, origin = Vector3Like.Create(
                 const y0 = y * factor;
                 const z0 = 0;
                 const z1 = factor;
-                // -Y normal — flip winding relative to +Y
                 const newQuad = Quad.Create([
-                    [x0, y0, z0], // p0
-                    [x0, y0, z1], // p1
-                    [x1, y0, z1], // p2
-                    [x1, y0, z0], // p3
-                ], Quad.FullUVs, false
-                // 1
-                );
+                    [x0, y0, z0],
+                    [x0, y0, z1],
+                    [x1, y0, z1],
+                    [x1, y0, z0],
+                ], Quad.FullUVs, false);
                 let [sx, sy] = downFace;
-                let [ex, ey] = [x, y];
-                ey += 1;
+                let ex = x;
+                let ey = y + 1;
                 addUvs(newQuad, factor, sx, sy, ex, ey);
                 downFace = null;
                 tool.vars.textureIndex = textureId;
@@ -210,6 +237,47 @@ export function MeshTexture(textureId, textureData, origin = Vector3Like.Create(
                 downFace = [x, y];
             }
         }
+        // FLUSH: emit any remaining faces at the right edge
+        if (upFace) {
+            const x0 = upFace[0] * factor;
+            const x1 = width * factor;
+            const y1 = y * factor + factor;
+            const z0 = 0;
+            const z1 = factor;
+            const newQuad = Quad.Create([
+                [x0, y1, z0],
+                [x1, y1, z0],
+                [x1, y1, z1],
+                [x0, y1, z1],
+            ], Quad.FullUVs, false);
+            let [sx, sy] = upFace;
+            let ex = width;
+            let ey = y + 1;
+            addUvs(newQuad, factor, sx, sy, ex, ey);
+            tool.vars.textureIndex = textureId;
+            addItemQuad(tool, newQuad);
+        }
+        if (downFace) {
+            const x0 = downFace[0] * factor;
+            const x1 = width * factor;
+            const y0 = y * factor;
+            const z0 = 0;
+            const z1 = factor;
+            const newQuad = Quad.Create([
+                [x0, y0, z0],
+                [x0, y0, z1],
+                [x1, y0, z1],
+                [x1, y0, z0],
+            ], Quad.FullUVs, false);
+            let [sx, sy] = downFace;
+            let ex = width;
+            let ey = y + 1;
+            addUvs(newQuad, factor, sx, sy, ex, ey);
+            tool.vars.textureIndex = textureId;
+            addItemQuad(tool, newQuad);
+        }
     }
-    return CompactItemMesh([tool]);
+    const compacted = CompactItemMesh([tool]);
+    tool.clear();
+    return compacted;
 }

package/Mesher/Voxels/Base/BuildVoxel.d.ts

@@ -0,0 +1,6 @@
+import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface";
+import { VoxelModelBuilder } from "../Models/VoxelModelBuilder";
+import { Vector3Like } from "@amodx/math";
+import { VoxelCursorInterface } from "Voxels/Cursor/VoxelCursor.interface";
+export declare function BuildVoxelBase(builder: VoxelModelBuilder, secondary?: boolean): boolean;
+export declare function BuildVoxel(x: number, y: number, z: number, voxel: VoxelCursorInterface, worldCursor: DataCursorInterface, origin: Vector3Like): boolean;

package/Mesher/Voxels/Base/BuildVoxel.js

@@ -0,0 +1,101 @@
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
+import { GeometryLUT } from "../../../Voxels/Data/GeometryLUT";
+import { VoxelGeometryConstructorRegister } from "../Models/VoxelGeometryConstructorRegister";
+import { RenderedMaterials } from "../Models/RenderedMaterials";
+export function BuildVoxelBase(builder, secondary = false) {
+    let added = false;
+    const hashed = builder.space.getHash(builder.nVoxel, builder.position.x, builder.position.y, builder.position.z);
+    if (secondary && !builder.space.getHasSecondary(hashed))
+        return false;
+    const trueVoxelId = builder.space.getTrueVoxelId(hashed, secondary);
+    const voxelId = builder.space.getVoxelId(hashed, secondary);
+    const reltionalVoxelId = builder.space.getRelationalVoxelId(hashed, secondary);
+    const geomtriesIndex = VoxelLUT.getGeometryIndex(voxelId, reltionalVoxelId);
+    const geomtries = GeometryLUT.geometryIndex[geomtriesIndex];
+    const inputsIndex = VoxelLUT.getGeometryInputIndex(voxelId, reltionalVoxelId);
+    const inputs = GeometryLUT.geometryInputsIndex[inputsIndex];
+    const geometriesLength = geomtries.length;
+    for (let i = 0; i < geometriesLength; i++) {
+        const nodeId = geomtries[i];
+        const inputsIndex = inputs[i];
+        const geoInputs = GeometryLUT.geometryInputs[inputsIndex];
+        const geometry = VoxelGeometryConstructorRegister.geometry[nodeId];
+        const nodesLength = geometry.nodes.length;
+        for (let k = 0; k < nodesLength; k++) {
+            const geo = geometry.nodes[k];
+            geo.builder = builder;
+            const addedGeo = geo.add(geoInputs[k]);
+            if (addedGeo)
+                added = true;
+        }
+    }
+    const conditioanlNodes = VoxelLUT.getConditionalGeometryNodes(VoxelLUT.modelsIndex[trueVoxelId]);
+    if (conditioanlNodes) {
+        const modelState = VoxelLUT.voxelIdToState[voxelId];
+        const reltionalState = builder.space.getRelationalState(hashed, secondary);
+        const nodesLength = conditioanlNodes.length;
+        for (let i = 0; i < nodesLength; i++) {
+            const [geoId, requiredModelState, requiredModelReltionalState] = conditioanlNodes[i];
+            if (requiredModelState !== modelState ||
+                !requiredModelReltionalState[reltionalState])
+                continue;
+            const geomtries = GeometryLUT.geometryIndex[geoId];
+            const inputsIndex = VoxelLUT.getConditionalGeometryInputIndex(geoId, voxelId, reltionalVoxelId);
+            const inputs = GeometryLUT.geometryInputsIndex[inputsIndex];
+            const geometriesLength = geomtries.length;
+            for (let i = 0; i < geometriesLength; i++) {
+                const nodeId = geomtries[i];
+                const inputsIndex = inputs[i];
+                const geoInputs = GeometryLUT.geometryInputs[inputsIndex];
+                const geometry = VoxelGeometryConstructorRegister.geometry[nodeId];
+                const nodesLength = geometry.nodes.length;
+                for (let k = 0; k < nodesLength; k++) {
+                    const geo = geometry.nodes[k];
+                    geo.builder = builder;
+                    const addedGeo = geo.add(geoInputs[k]);
+                    if (addedGeo)
+                        added = true;
+                }
+            }
+        }
+    }
+    /*     this.effects.addEffects(
+        builder.voxel.getState(),
+        builder.origin,
+        builder.effects
+      ); */
+    builder.clearCalculatedData();
+    return added;
+}
+export function BuildVoxel(x, y, z, voxel, worldCursor, origin) {
+    const builder = RenderedMaterials.meshers[VoxelLUT.materialMap[voxel.getVoxelId()]];
+    builder.origin.x = origin.x;
+    builder.origin.y = origin.y;
+    builder.origin.z = origin.z;
+    builder.position.x = x;
+    builder.position.y = y;
+    builder.position.z = z;
+    builder.voxel = voxel;
+    builder.nVoxel = worldCursor;
+    builder.startConstruction();
+    const added = BuildVoxelBase(builder);
+    builder.endConstruction();
+    let addedSecondary = false;
+    if (voxel.canHaveSecondaryVoxel()) {
+        voxel.setSecondary(true);
+        const builder = RenderedMaterials.meshers[VoxelLUT.materialMap[voxel.getVoxelId()]];
+        builder.origin.x = origin.x;
+        builder.origin.y = origin.y;
+        builder.origin.z = origin.z;
+        builder.position.x = x;
+        builder.position.y = y;
+        builder.position.z = z;
+        builder.voxel = voxel;
+        builder.nVoxel = worldCursor;
+        builder.startConstruction();
+        addedSecondary = BuildVoxelBase(builder, true);
+        builder.endConstruction();
+        voxel.setSecondary(false);
+    }
+    return added || addedSecondary;
+}

package/Mesher/Voxels/Base/CompactVoxelSectionMesh.js

@@ -2,39 +2,29 @@ import { VoxelMeshVertexStructCursor } from "../Geometry/VoxelMeshVertexStructCu
 import { CompactedSectionVoxelMesh, CompactedMeshData, } from "../Geometry/CompactedSectionVoxelMesh";
 const meshData = new CompactedMeshData();
 const compactedMesh = new CompactedSectionVoxelMesh();
-/** Utility to ensure a value is aligned to 4 bytes. */
 function align4(value) {
     return (value + 3) & ~3;
 }
 export function CompactVoxelSectionMesh(location, tools, transfers = []) {
-    // 1) First compute how large the final buffer needs to be (with 4-byte alignment).
     let headerSize = CompactedSectionVoxelMesh.GetHeaderByteSize(tools.length);
-    // Make the header itself 4-byte aligned
     headerSize = align4(headerSize);
     let totalByteCount = headerSize;
     for (let i = 0; i < tools.length; i++) {
         const tool = tools[i];
-        // Add the vertex data
         const vertexByteSize = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexByteSize;
         totalByteCount += vertexByteSize;
-        // Align after writing vertex data
         totalByteCount = align4(totalByteCount);
-        // Add the index data
         const indexByteSize = tool.mesh.indicieCount * 4;
         totalByteCount += indexByteSize;
-        // Align after writing index data
         totalByteCount = align4(totalByteCount);
     }
-    // 2) Allocate the final buffer
     const buffer = new ArrayBuffer(totalByteCount);
     compactedMesh.setData(buffer);
     compactedMesh.setLocation(...location);
     compactedMesh.setTotalMeshes(tools.length);
-    // We'll track our position in the buffer here
     let byteCount = headerSize;
     for (let i = 0; i < tools.length; i++) {
         const tool = tools[i];
-        // Fill out the meshData structure
         meshData.materialId = tool.id;
         const minBounds = tool.mesh.minBounds;
         const maxBounds = tool.mesh.maxBounds;
@@ -44,27 +34,20 @@ export function CompactVoxelSectionMesh(location, tools, transfers = []) {
         meshData.maxBounds[0] = maxBounds.x;
         meshData.maxBounds[1] = maxBounds.y;
         meshData.maxBounds[2] = maxBounds.z;
-        // Vertex info
         const totalVertFloats = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexFloatSize;
         const vertexByteCount = totalVertFloats * 4;
         meshData.vertexIndex[0] = byteCount;
         meshData.vertexIndex[1] = totalVertFloats;
-        // Now move the pointer
         byteCount += vertexByteCount;
-        // Align to 4 bytes again before writing indices
         byteCount = align4(byteCount);
-        // Index info
         meshData.indiceIndex[0] = byteCount;
         meshData.indiceIndex[1] = tool.mesh.indicieCount;
         const indexByteCount = tool.mesh.indicieCount * 4;
         byteCount += indexByteCount;
-        // Align to 4 bytes for the next iteration (or final)
         byteCount = align4(byteCount);
-        // Store the meta info
         compactedMesh.setMeshData(i, meshData);
-        // Write vertex data
         const vertexArray = new Float32Array(buffer, meshData.vertexIndex[0], totalVertFloats);
-        const vertexBuffers = tool.mesh.buffer._buffers;
+        const vertexBuffers = tool.mesh.buffer._float32Views;
         let start = 0;
         let done = false;
         for (let b = 0; b < vertexBuffers.length; b++) {
@@ -80,7 +63,6 @@ export function CompactVoxelSectionMesh(location, tools, transfers = []) {
             if (done)
                 break;
         }
-        // Write index data
         const indicesArray = new Uint32Array(buffer, meshData.indiceIndex[0], tool.mesh.indicieCount);
         const indiceBuffers = tool.mesh.indices._buffers;
         start = 0;
@@ -99,8 +81,6 @@ export function CompactVoxelSectionMesh(location, tools, transfers = []) {
                 break;
         }
     }
-    // Transfer the ArrayBuffer to your worker if needed
     transfers.push(buffer);
-    // Return the buffer or the task object as needed
     return buffer;
 }

package/Mesher/Voxels/Base/MeshSectionBase.js

@@ -2,30 +2,13 @@
 import { WorldSpaces } from "../../../World/WorldSpaces.js";
 //tools
 import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace.js";
-import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
 import { VoxelMeshBVHBuilder } from "../Geometry/VoxelMeshBVHBuilder";
 import { Vector3Like } from "@amodx/math";
 import { RenderedMaterials } from "../Models/RenderedMaterials";
 import { CompactVoxelSectionMesh } from "./CompactVoxelSectionMesh";
+import { BuildVoxel } from "./BuildVoxel";
 let space;
 const bvhTool = new VoxelMeshBVHBuilder();
-function meshVoxel(x, y, z, voxel, worldCursor, sectionCursor) {
-    let added = false;
-    const constructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getVoxelId()];
-    const builder = constructor.builder;
-    builder.origin.x = sectionCursor._voxelPosition.x;
-    builder.origin.y = sectionCursor._voxelPosition.y;
-    builder.origin.z = sectionCursor._voxelPosition.z;
-    builder.position.x = x;
-    builder.position.y = y;
-    builder.position.z = z;
-    builder.voxel = voxel;
-    builder.nVoxel = worldCursor;
-    builder.startConstruction();
-    added = constructor.process();
-    builder.endConstruction();
-    return added;
-}
 const padding = Vector3Like.Create(5, 5, 5);
 export function MeshSectionBase(worldCursor, sectionCursor, location, transfers = []) {
     if (!space)
@@ -53,6 +36,7 @@ export function MeshSectionBase(worldCursor, sectionCursor, location, transfers
     const slice = WorldSpaces.section.bounds.x * WorldSpaces.section.bounds.z;
     const startY = minY * slice;
     const endY = (maxY + 1) * slice;
+    let first = false;
     for (let i = startY; i < endY; i++) {
         if (!(i % slice)) {
             const y = i / slice;
@@ -68,16 +52,9 @@ export function MeshSectionBase(worldCursor, sectionCursor, location, transfers
         const y = cy + sectionCursor._voxelPosition.y;
         const z = cz + sectionCursor._voxelPosition.z;
         let addedVoxel = false;
-        if (meshVoxel(x, y, z, voxel, worldCursor, sectionCursor)) {
+        if (BuildVoxel(x, y, z, voxel, worldCursor, sectionCursor._voxelPosition)) {
             addedVoxel = true;
         }
-        if (voxel.hasSecondaryVoxel()) {
-            voxel.setSecondary(true);
-            if (meshVoxel(x, y, z, voxel, worldCursor, sectionCursor)) {
-                addedVoxel = true;
-            }
-            voxel.setSecondary(false);
-        }
         section.setBuried(i, !addedVoxel);
     }
     const meshed = [];

package/Mesher/Voxels/Geometry/VoxelGeometryBuilder.js

@@ -1,6 +1,5 @@
 import { Vector4Like } from "@amodx/math";
 import { VoxelShaderData } from "./VoxelShaderData";
-import { QuadVerticies } from "../../Geometry/Geometry.types";
 import { VoxelMeshVertexConstants } from "./VoxelMeshVertexStructCursor";
 const vector1ShaderData = Vector4Like.Create();
 const vector2ShaderData = Vector4Like.Create();
@@ -21,9 +20,9 @@ export function addVoxelTriangle(builder, tri) {
     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 topRightVoxelData = VoxelShaderData.create(worldLight.vertices[0 /* QuadVerticies.TopRight */], worldLight.vertices[1 /* QuadVerticies.TopLeft */], worldLight.vertices[2 /* QuadVerticies.BottomLeft */], worldLight.vertices[3 /* QuadVerticies.BottomRight */], worldAO.vertices[0 /* QuadVerticies.TopRight */], worldAO.vertices[1 /* QuadVerticies.TopLeft */], worldAO.vertices[2 /* QuadVerticies.BottomLeft */], worldAO.vertices[3 /* QuadVerticies.BottomRight */], animData.vertices[0 /* QuadVerticies.TopRight */], 0 /* QuadVerticies.TopRight */, vector1ShaderData);
+    const topLeftVoxelData = VoxelShaderData.create(worldLight.vertices[0 /* QuadVerticies.TopRight */], worldLight.vertices[1 /* QuadVerticies.TopLeft */], worldLight.vertices[2 /* QuadVerticies.BottomLeft */], worldLight.vertices[3 /* QuadVerticies.BottomRight */], worldAO.vertices[0 /* QuadVerticies.TopRight */], worldAO.vertices[1 /* QuadVerticies.TopLeft */], worldAO.vertices[2 /* QuadVerticies.BottomLeft */], worldAO.vertices[3 /* QuadVerticies.BottomRight */], animData.vertices[1 /* QuadVerticies.TopLeft */], 1 /* QuadVerticies.TopLeft */, vector2ShaderData);
+    const bottomLeftVoxelData = VoxelShaderData.create(worldLight.vertices[0 /* QuadVerticies.TopRight */], worldLight.vertices[1 /* QuadVerticies.TopLeft */], worldLight.vertices[2 /* QuadVerticies.BottomLeft */], worldLight.vertices[3 /* QuadVerticies.BottomRight */], worldAO.vertices[0 /* QuadVerticies.TopRight */], worldAO.vertices[1 /* QuadVerticies.TopLeft */], worldAO.vertices[2 /* QuadVerticies.BottomLeft */], worldAO.vertices[3 /* QuadVerticies.BottomRight */], animData.vertices[2 /* QuadVerticies.BottomLeft */], 2 /* QuadVerticies.BottomLeft */, vector3ShaderData);
     const indices = builder.mesh.indices;
     let indIndex = builder.mesh.indicieCount;
     let sides = tri.doubleSided ? 2 : 1;
@@ -31,11 +30,11 @@ export function addVoxelTriangle(builder, tri) {
     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);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, builder.mesh.buffer.currentUint32Array, origin, topRightPos, topRightNor, tri.uvs.vertices[0 /* 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);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, builder.mesh.buffer.currentUint32Array, origin, topLeftPos, topLeftNor, tri.uvs.vertices[1 /* 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);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, builder.mesh.buffer.currentUint32Array, origin, bottomLeftPos, bottomLeftNor, tri.uvs.vertices[2 /* QuadVerticies.BottomLeft */], bottomLeftVoxelData, texture, overlayTextures);
         builder.mesh.addVerticies(3, 3);
     }
     if (!tri.doubleSided) {
@@ -80,21 +79,21 @@ export function addVoxelQuad(builder, quad) {
     const topLeftNor = quad.normals.vertices[1];
     const bottomLeftNor = quad.normals.vertices[2];
     const bottomRightNor = quad.normals.vertices[3];
-    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 topRightVoxelData = VoxelShaderData.create(worldLight.vertices[0 /* QuadVerticies.TopRight */], worldLight.vertices[1 /* QuadVerticies.TopLeft */], worldLight.vertices[2 /* QuadVerticies.BottomLeft */], worldLight.vertices[3 /* QuadVerticies.BottomRight */], worldAO.vertices[0 /* QuadVerticies.TopRight */], worldAO.vertices[1 /* QuadVerticies.TopLeft */], worldAO.vertices[2 /* QuadVerticies.BottomLeft */], worldAO.vertices[3 /* QuadVerticies.BottomRight */], animData.vertices[0 /* QuadVerticies.TopRight */], 0 /* QuadVerticies.TopRight */, vector1ShaderData);
+    const topLeftVoxelData = VoxelShaderData.create(worldLight.vertices[0 /* QuadVerticies.TopRight */], worldLight.vertices[1 /* QuadVerticies.TopLeft */], worldLight.vertices[2 /* QuadVerticies.BottomLeft */], worldLight.vertices[3 /* QuadVerticies.BottomRight */], worldAO.vertices[0 /* QuadVerticies.TopRight */], worldAO.vertices[1 /* QuadVerticies.TopLeft */], worldAO.vertices[2 /* QuadVerticies.BottomLeft */], worldAO.vertices[3 /* QuadVerticies.BottomRight */], animData.vertices[1 /* QuadVerticies.TopLeft */], 1 /* QuadVerticies.TopLeft */, vector2ShaderData);
+    const bottomLeftVoxelData = VoxelShaderData.create(worldLight.vertices[0 /* QuadVerticies.TopRight */], worldLight.vertices[1 /* QuadVerticies.TopLeft */], worldLight.vertices[2 /* QuadVerticies.BottomLeft */], worldLight.vertices[3 /* QuadVerticies.BottomRight */], worldAO.vertices[0 /* QuadVerticies.TopRight */], worldAO.vertices[1 /* QuadVerticies.TopLeft */], worldAO.vertices[2 /* QuadVerticies.BottomLeft */], worldAO.vertices[3 /* QuadVerticies.BottomRight */], animData.vertices[2 /* QuadVerticies.BottomLeft */], 2 /* QuadVerticies.BottomLeft */, vector3ShaderData);
+    const bottomRightVoxelData = VoxelShaderData.create(worldLight.vertices[0 /* QuadVerticies.TopRight */], worldLight.vertices[1 /* QuadVerticies.TopLeft */], worldLight.vertices[2 /* QuadVerticies.BottomLeft */], worldLight.vertices[3 /* QuadVerticies.BottomRight */], worldAO.vertices[0 /* QuadVerticies.TopRight */], worldAO.vertices[1 /* QuadVerticies.TopLeft */], worldAO.vertices[2 /* QuadVerticies.BottomLeft */], worldAO.vertices[3 /* QuadVerticies.BottomRight */], animData.vertices[3 /* QuadVerticies.BottomRight */], 3 /* 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);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, builder.mesh.buffer.currentUint32Array, origin, topRightPos, topRightNor, quad.uvs.vertices[0 /* 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);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, builder.mesh.buffer.currentUint32Array, origin, topLeftPos, topLeftNor, quad.uvs.vertices[1 /* 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);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, builder.mesh.buffer.currentUint32Array, origin, bottomLeftPos, bottomLeftNor, quad.uvs.vertices[2 /* 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);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, builder.mesh.buffer.currentUint32Array, origin, bottomRightPos, bottomRightNor, quad.uvs.vertices[3 /* QuadVerticies.BottomRight */], bottomRightVoxelData, texture, overlayTextures);
     if (!quad.doubleSided) {
         let index = baseIndex;
         indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;
@@ -136,27 +135,30 @@ export function addVoxelQuad(builder, quad) {
     }
     builder.vars.reset();
 }
-function addVertex(index, array, origin, position, normal, uvs, voxelData, texture, overlayTextures) {
+function addVertex(index, float32Array, uint32Array, origin, position, normal, uvs, voxelData, texture, overlayTextures) {
     index *= VoxelMeshVertexConstants.VertexFloatSize;
-    array[VoxelMeshVertexConstants.PositionOffset + index] =
+    float32Array[VoxelMeshVertexConstants.PositionOffset + index] =
         position.x + origin.x;
-    array[VoxelMeshVertexConstants.PositionOffset + index + 1] =
+    float32Array[VoxelMeshVertexConstants.PositionOffset + index + 1] =
         position.y + origin.y;
-    array[VoxelMeshVertexConstants.PositionOffset + index + 2] =
+    float32Array[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] =
+    float32Array[VoxelMeshVertexConstants.UVOffset + index] = uvs.x;
+    float32Array[VoxelMeshVertexConstants.UVOffset + index + 1] = uvs.y;
+    float32Array[VoxelMeshVertexConstants.NormalOffset + index] = normal.x;
+    float32Array[VoxelMeshVertexConstants.NormalOffset + index + 1] = normal.y;
+    float32Array[VoxelMeshVertexConstants.NormalOffset + index + 2] = normal.z;
+    uint32Array[VoxelMeshVertexConstants.TextureIndexOffset + index] =
         VoxelShaderData.createTextureIndex(texture, overlayTextures.x);
-    array[VoxelMeshVertexConstants.TextureIndexOffset + index + 1] =
+    uint32Array[VoxelMeshVertexConstants.TextureIndexOffset + index + 1] =
         VoxelShaderData.createTextureIndex(overlayTextures.y, overlayTextures.z);
-    array[VoxelMeshVertexConstants.TextureIndexOffset + index + 2] =
+    uint32Array[VoxelMeshVertexConstants.TextureIndexOffset + index + 2] =
         VoxelShaderData.createTextureIndex(overlayTextures.w, 0);
-    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;
+    uint32Array[VoxelMeshVertexConstants.VoxelDataOFfset + index] = voxelData.x;
+    uint32Array[VoxelMeshVertexConstants.VoxelDataOFfset + index + 1] =
+        voxelData.y;
+    uint32Array[VoxelMeshVertexConstants.VoxelDataOFfset + index + 2] =
+        voxelData.z;
+    uint32Array[VoxelMeshVertexConstants.VoxelDataOFfset + index + 3] =
+        voxelData.w;
 }