@divinevoxel/vlox 0.0.74 → 0.0.75

package/Mesher/Geomtry/Transform/TransformQuad.js

@@ -0,0 +1,113 @@
+import { QuadVerticies } from "../Geometry.types";
+import { Quad } from "../Primitives";
+import { AMath, Vector3Like } from "@amodx/math";
+export function TransformQuad(quad, transform) {
+    const p1 = { ...quad.positions.vertices[QuadVerticies.TopRight] };
+    const p2 = { ...quad.positions.vertices[QuadVerticies.TopLeft] };
+    const p3 = { ...quad.positions.vertices[QuadVerticies.BottomLeft] };
+    const p4 = { ...quad.positions.vertices[QuadVerticies.BottomRight] };
+    // Create an array of vertices
+    const vertices = [p1, p2, p3, p4];
+    // Compute the centroid of the quad
+    const centroid = {
+        x: (p1.x + p2.x + p3.x + p4.x) / 4,
+        y: (p1.y + p2.y + p3.y + p4.y) / 4,
+        z: (p1.z + p2.z + p3.z + p4.z) / 4,
+    };
+    // Initialize effective scales
+    let effectiveScaleX = 1;
+    let effectiveScaleY = 1;
+    let effectiveScaleZ = 1;
+    // Apply scale if specified
+    if (transform.scale) {
+        const [scaleX, scaleY, scaleZ] = transform.scale;
+        effectiveScaleX = scaleX;
+        effectiveScaleY = scaleY;
+        effectiveScaleZ = scaleZ;
+    }
+    // Apply flips by negating effective scales
+    if (transform.flip) {
+        const [flipX, flipY, flipZ] = transform.flip;
+        if (flipX)
+            effectiveScaleX *= -1;
+        if (flipY)
+            effectiveScaleY *= -1;
+        if (flipZ)
+            effectiveScaleZ *= -1;
+    }
+    // Compute determinant
+    const determinant = effectiveScaleX * effectiveScaleY * effectiveScaleZ;
+    // Apply scaling and flips
+    for (const vertex of vertices) {
+        vertex.x = centroid.x + (vertex.x - centroid.x) * effectiveScaleX;
+        vertex.y = centroid.y + (vertex.y - centroid.y) * effectiveScaleY;
+        vertex.z = centroid.z + (vertex.z - centroid.z) * effectiveScaleZ;
+    }
+    // Rotate vertices around the pivot point if rotation is specified
+    if (transform.rotation) {
+        const [rotXDeg, rotYDeg, rotZDeg] = transform.rotation;
+        const rotX = AMath.DegreesToRadians(rotXDeg);
+        const rotY = AMath.DegreesToRadians(rotYDeg);
+        const rotZ = AMath.DegreesToRadians(rotZDeg);
+        const pivot = transform.rotationPivot
+            ? {
+                x: transform.rotationPivot[0],
+                y: transform.rotationPivot[1],
+                z: transform.rotationPivot[2],
+            }
+            : centroid;
+        for (const vertex of vertices) {
+            // Translate vertex to pivot point
+            let x = vertex.x - pivot.x;
+            let y = vertex.y - pivot.y;
+            let z = vertex.z - pivot.z;
+            // Rotation around X-axis
+            if (rotX) {
+                const cosX = Math.cos(rotX);
+                const sinX = Math.sin(rotX);
+                const y1 = y * cosX - z * sinX;
+                const z1 = y * sinX + z * cosX;
+                y = y1;
+                z = z1;
+            }
+            // Rotation around Y-axis
+            if (rotY) {
+                const cosY = Math.cos(rotY);
+                const sinY = Math.sin(rotY);
+                const x1 = x * cosY + z * sinY;
+                const z1 = -x * sinY + z * cosY;
+                x = x1;
+                z = z1;
+            }
+            // Rotation around Z-axis
+            if (rotZ) {
+                const cosZ = Math.cos(rotZ);
+                const sinZ = Math.sin(rotZ);
+                const x1 = x * cosZ - y * sinZ;
+                const y1 = x * sinZ + y * cosZ;
+                x = x1;
+                y = y1;
+            }
+            // Translate vertex back from pivot point
+            vertex.x = x + pivot.x;
+            vertex.y = y + pivot.y;
+            vertex.z = z + pivot.z;
+        }
+    }
+    // Translate vertices if position is specified
+    if (transform.position) {
+        const [dx, dy, dz] = transform.position;
+        for (const vertex of vertices) {
+            vertex.x += dx;
+            vertex.y += dy;
+            vertex.z += dz;
+        }
+    }
+    // If determinant is negative, reverse vertex order
+    if (determinant < 0) {
+        vertices.reverse();
+    }
+    // Create a new quad with the transformed vertices
+    const transformedQuad = Quad.Create(vertices.map((vertex) => Vector3Like.ToArray(vertex)));
+    return transformedQuad;
+}

package/Mesher/Geomtry/Transform/TransformTriangle.d.ts

@@ -0,0 +1,3 @@
+import { VoxelGeometryTransform } from "../Geometry.types";
+import { Triangle } from "../Primitives/Triangle";
+export declare function TransformTriangle(quad: Triangle, transform: VoxelGeometryTransform): Triangle;

package/Mesher/Geomtry/Transform/TransformTriangle.js

@@ -0,0 +1,112 @@
+import { TriangleVerticies } from "../Geometry.types";
+import { AMath, Vector3Like } from "@amodx/math";
+import { Triangle } from "../Primitives/Triangle";
+export function TransformTriangle(quad, transform) {
+    const p1 = { ...quad.positions.vertices[TriangleVerticies.One] };
+    const p2 = { ...quad.positions.vertices[TriangleVerticies.Two] };
+    const p3 = { ...quad.positions.vertices[TriangleVerticies.Three] };
+    // Create an array of vertices
+    const vertices = [p1, p2, p3];
+    // Compute the centroid of the quad
+    const centroid = {
+        x: (p1.x + p2.x + p3.x) / 4,
+        y: (p1.y + p2.y + p3.y) / 4,
+        z: (p1.z + p2.z + p3.z) / 4,
+    };
+    // Initialize effective scales
+    let effectiveScaleX = 1;
+    let effectiveScaleY = 1;
+    let effectiveScaleZ = 1;
+    // Apply scale if specified
+    if (transform.scale) {
+        const [scaleX, scaleY, scaleZ] = transform.scale;
+        effectiveScaleX = scaleX;
+        effectiveScaleY = scaleY;
+        effectiveScaleZ = scaleZ;
+    }
+    // Apply flips by negating effective scales
+    if (transform.flip) {
+        const [flipX, flipY, flipZ] = transform.flip;
+        if (flipX)
+            effectiveScaleX *= -1;
+        if (flipY)
+            effectiveScaleY *= -1;
+        if (flipZ)
+            effectiveScaleZ *= -1;
+    }
+    // Compute determinant
+    const determinant = effectiveScaleX * effectiveScaleY * effectiveScaleZ;
+    // Apply scaling and flips
+    for (const vertex of vertices) {
+        vertex.x = centroid.x + (vertex.x - centroid.x) * effectiveScaleX;
+        vertex.y = centroid.y + (vertex.y - centroid.y) * effectiveScaleY;
+        vertex.z = centroid.z + (vertex.z - centroid.z) * effectiveScaleZ;
+    }
+    // Rotate vertices around the pivot point if rotation is specified
+    if (transform.rotation) {
+        const [rotXDeg, rotYDeg, rotZDeg] = transform.rotation;
+        const rotX = AMath.DegreesToRadians(rotXDeg);
+        const rotY = AMath.DegreesToRadians(rotYDeg);
+        const rotZ = AMath.DegreesToRadians(rotZDeg);
+        const pivot = transform.rotationPivot
+            ? {
+                x: transform.rotationPivot[0],
+                y: transform.rotationPivot[1],
+                z: transform.rotationPivot[2],
+            }
+            : centroid;
+        for (const vertex of vertices) {
+            // Translate vertex to pivot point
+            let x = vertex.x - pivot.x;
+            let y = vertex.y - pivot.y;
+            let z = vertex.z - pivot.z;
+            // Rotation around X-axis
+            if (rotX) {
+                const cosX = Math.cos(rotX);
+                const sinX = Math.sin(rotX);
+                const y1 = y * cosX - z * sinX;
+                const z1 = y * sinX + z * cosX;
+                y = y1;
+                z = z1;
+            }
+            // Rotation around Y-axis
+            if (rotY) {
+                const cosY = Math.cos(rotY);
+                const sinY = Math.sin(rotY);
+                const x1 = x * cosY + z * sinY;
+                const z1 = -x * sinY + z * cosY;
+                x = x1;
+                z = z1;
+            }
+            // Rotation around Z-axis
+            if (rotZ) {
+                const cosZ = Math.cos(rotZ);
+                const sinZ = Math.sin(rotZ);
+                const x1 = x * cosZ - y * sinZ;
+                const y1 = x * sinZ + y * cosZ;
+                x = x1;
+                y = y1;
+            }
+            // Translate vertex back from pivot point
+            vertex.x = x + pivot.x;
+            vertex.y = y + pivot.y;
+            vertex.z = z + pivot.z;
+        }
+    }
+    // Translate vertices if position is specified
+    if (transform.position) {
+        const [dx, dy, dz] = transform.position;
+        for (const vertex of vertices) {
+            vertex.x += dx;
+            vertex.y += dy;
+            vertex.z += dz;
+        }
+    }
+    // If determinant is negative, reverse vertex order
+    if (determinant < 0) {
+        vertices.reverse();
+    }
+    // Create a new quad with the transformed vertices
+    const transformedQuad = Triangle.Create(vertices.map((vertex) => Vector3Like.ToArray(vertex)));
+    return transformedQuad;
+}

package/Mesher/Geomtry/VoxelGeometryBuilder.d.ts

@@ -1,6 +1,5 @@
-import { Vector3Like } from "@amodx/math";
 import { VoxelModelBuilder } from "../Models/VoxelModelBuilder";
 import { Quad } from "./Primitives/Quad";
-export declare class VoxelGeometryBuilder {
-}
-export declare function addVoxelQuad(tool: VoxelModelBuilder, origin: Vector3Like, quad: Quad): void;
+import { Triangle } from "./Primitives";
+export declare function addVoxelTriangle(builder: VoxelModelBuilder, tri: Triangle): void;
+export declare function addVoxelQuad(builder: VoxelModelBuilder, quad: Quad): void;

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,6 +1,6 @@
 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;

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