@divinevoxel/vlox 0.0.3 → 0.0.5

package/Mesher/Geomtry/Primitives/QuadVertexData.js

@@ -0,0 +1,349 @@
+import { QuadVerticies } from "../Geometry.types.js";
+import { Vector3Like, Vector2Like } from "@amodx/math";
+export class QuadVertexData {
+    vertices;
+    constructor(vertices) {
+        this.vertices = vertices;
+    }
+    getAsArray() {
+        return [
+            this.vertices[QuadVerticies.TopRight],
+            this.vertices[QuadVerticies.TopLeft],
+            this.vertices[QuadVerticies.BottomLeft],
+            this.vertices[QuadVerticies.BottomRight],
+        ];
+    }
+    setVertex(vertex, value) {
+        this.vertices[vertex] = value;
+    }
+    getVertex(vertex) {
+        return this.vertices[vertex];
+    }
+    setAll(value) {
+        this.vertices[QuadVerticies.TopRight] = value;
+        this.vertices[QuadVerticies.TopLeft] = value;
+        this.vertices[QuadVerticies.BottomLeft] = value;
+        this.vertices[QuadVerticies.BottomRight] = value;
+    }
+    set(v1, v2, v3, v4) {
+        this.vertices[QuadVerticies.TopRight] = v1;
+        this.vertices[QuadVerticies.TopLeft] = v2;
+        this.vertices[QuadVerticies.BottomLeft] = v3;
+        this.vertices[QuadVerticies.BottomRight] = v4;
+    }
+    isEqualTo(v1, v2, v3, v4) {
+        if (this.vertices[QuadVerticies.TopRight] != v1)
+            return false;
+        if (this.vertices[QuadVerticies.TopLeft] != v2)
+            return false;
+        if (this.vertices[QuadVerticies.BottomLeft] != v3)
+            return false;
+        if (this.vertices[QuadVerticies.BottomRight] != v4)
+            return false;
+        return true;
+    }
+    isAllEqualTo(value) {
+        if (this.vertices[QuadVerticies.TopRight] != value)
+            return false;
+        if (this.vertices[QuadVerticies.TopLeft] != value)
+            return false;
+        if (this.vertices[QuadVerticies.BottomLeft] != value)
+            return false;
+        if (this.vertices[QuadVerticies.BottomRight] != value)
+            return false;
+        return true;
+    }
+    [Symbol.iterator]() {
+        let index = QuadVerticies.TopRight;
+        const items = this.vertices;
+        return {
+            next() {
+                if (index < QuadVerticies.BottomRight) {
+                    return { value: items[index++], done: false };
+                }
+                else {
+                    return { value: undefined, done: true };
+                }
+            },
+        };
+    }
+    clone() {
+        return new QuadVertexData({
+            [QuadVerticies.TopRight]: structuredClone(this.vertices[QuadVerticies.TopRight]),
+            [QuadVerticies.TopLeft]: structuredClone(this.vertices[QuadVerticies.TopLeft]),
+            [QuadVerticies.BottomLeft]: structuredClone(this.vertices[QuadVerticies.BottomLeft]),
+            [QuadVerticies.BottomRight]: structuredClone(this.vertices[QuadVerticies.BottomRight]),
+        });
+    }
+}
+export class QuadVec3ArrayVertexData extends QuadVertexData {
+    vertices;
+    constructor(vertices = {
+        [QuadVerticies.TopRight]: [0, 0, 0],
+        [QuadVerticies.TopLeft]: [0, 0, 0],
+        [QuadVerticies.BottomLeft]: [0, 0, 0],
+        [QuadVerticies.BottomRight]: [0, 0, 0],
+    }) {
+        super(vertices);
+        this.vertices = vertices;
+    }
+    setFromQuadData(vertexData) {
+        Vector3Like.CopyArray(this.vertices[QuadVerticies.TopRight], vertexData.vertices[QuadVerticies.TopRight]);
+        Vector3Like.CopyArray(this.vertices[QuadVerticies.TopLeft], vertexData.vertices[QuadVerticies.TopLeft]);
+        Vector3Like.CopyArray(this.vertices[QuadVerticies.BottomLeft], vertexData.vertices[QuadVerticies.BottomLeft]);
+        Vector3Like.CopyArray(this.vertices[QuadVerticies.BottomRight], vertexData.vertices[QuadVerticies.BottomRight]);
+    }
+    addToVertex(vertex, value) {
+        Vector3Like.AddArrayInPlace(this.vertices[vertex], value);
+    }
+    subtractFromVertex(vertex, value) {
+        Vector3Like.SubtractArrayInPlace(this.vertices[vertex], value);
+    }
+    addAll(value) {
+        this.addToVertex(QuadVerticies.TopRight, value);
+        this.addToVertex(QuadVerticies.TopLeft, value);
+        this.addToVertex(QuadVerticies.BottomLeft, value);
+        this.addToVertex(QuadVerticies.BottomRight, value);
+    }
+    subtractAll(value) {
+        this.subtractFromVertex(QuadVerticies.TopRight, value);
+        this.subtractFromVertex(QuadVerticies.TopLeft, value);
+        this.subtractFromVertex(QuadVerticies.BottomLeft, value);
+        this.subtractFromVertex(QuadVerticies.BottomRight, value);
+    }
+    isEqualTo(v1, v2, v3, v4) {
+        return (Vector3Like.EqualsArray(this.vertices[QuadVerticies.TopRight], v1) &&
+            Vector3Like.EqualsArray(this.vertices[QuadVerticies.TopLeft], v2) &&
+            Vector3Like.EqualsArray(this.vertices[QuadVerticies.BottomLeft], v3) &&
+            Vector3Like.EqualsArray(this.vertices[QuadVerticies.BottomRight], v4));
+    }
+    isAllEqualTo(v1) {
+        return (Vector3Like.EqualsArray(this.vertices[QuadVerticies.TopRight], v1) &&
+            Vector3Like.EqualsArray(this.vertices[QuadVerticies.TopLeft], v1) &&
+            Vector3Like.EqualsArray(this.vertices[QuadVerticies.BottomLeft], v1) &&
+            Vector3Like.EqualsArray(this.vertices[QuadVerticies.BottomRight], v1));
+    }
+    clone() {
+        return new QuadVec3ArrayVertexData({
+            [QuadVerticies.TopRight]: [...this.vertices[QuadVerticies.TopRight]],
+            [QuadVerticies.TopLeft]: [...this.vertices[QuadVerticies.TopLeft]],
+            [QuadVerticies.BottomLeft]: [...this.vertices[QuadVerticies.BottomLeft]],
+            [QuadVerticies.BottomRight]: [
+                ...this.vertices[QuadVerticies.BottomRight],
+            ],
+        });
+    }
+}
+export class QuadVector3VertexData extends QuadVertexData {
+    vertices;
+    constructor(vertices = {
+        [QuadVerticies.TopRight]: Vector3Like.Create(),
+        [QuadVerticies.TopLeft]: Vector3Like.Create(),
+        [QuadVerticies.BottomLeft]: Vector3Like.Create(),
+        [QuadVerticies.BottomRight]: Vector3Like.Create(),
+    }) {
+        super(vertices);
+        this.vertices = vertices;
+    }
+    setFromQuadData(vertexData) {
+        Vector3Like.Copy(this.vertices[QuadVerticies.TopRight], vertexData.vertices[QuadVerticies.TopRight]);
+        Vector3Like.Copy(this.vertices[QuadVerticies.TopLeft], vertexData.vertices[QuadVerticies.TopLeft]);
+        Vector3Like.Copy(this.vertices[QuadVerticies.BottomLeft], vertexData.vertices[QuadVerticies.BottomLeft]);
+        Vector3Like.Copy(this.vertices[QuadVerticies.BottomRight], vertexData.vertices[QuadVerticies.BottomRight]);
+    }
+    addToVertex(vertex, value) {
+        Vector3Like.AddInPlace(this.vertices[vertex], value);
+    }
+    subtractFromVertex(vertex, value) {
+        Vector3Like.SubtractInPlace(this.vertices[vertex], value);
+    }
+    addAll(value) {
+        this.addToVertex(QuadVerticies.TopRight, value);
+        this.addToVertex(QuadVerticies.TopLeft, value);
+        this.addToVertex(QuadVerticies.BottomLeft, value);
+        this.addToVertex(QuadVerticies.BottomRight, value);
+    }
+    subtractAll(value) {
+        this.subtractFromVertex(QuadVerticies.TopRight, value);
+        this.subtractFromVertex(QuadVerticies.TopLeft, value);
+        this.subtractFromVertex(QuadVerticies.BottomLeft, value);
+        this.subtractFromVertex(QuadVerticies.BottomRight, value);
+    }
+    isEqualTo(v1, v2, v3, v4) {
+        return (Vector3Like.Equals(this.vertices[QuadVerticies.TopRight], v1) &&
+            Vector3Like.Equals(this.vertices[QuadVerticies.TopLeft], v2) &&
+            Vector3Like.Equals(this.vertices[QuadVerticies.BottomLeft], v3) &&
+            Vector3Like.Equals(this.vertices[QuadVerticies.BottomRight], v4));
+    }
+    isAllEqualTo(v1) {
+        return (Vector3Like.Equals(this.vertices[QuadVerticies.TopRight], v1) &&
+            Vector3Like.Equals(this.vertices[QuadVerticies.TopLeft], v1) &&
+            Vector3Like.Equals(this.vertices[QuadVerticies.BottomLeft], v1) &&
+            Vector3Like.Equals(this.vertices[QuadVerticies.BottomRight], v1));
+    }
+    clone() {
+        return new QuadVector3VertexData({
+            [QuadVerticies.TopRight]: Vector3Like.Clone(this.vertices[QuadVerticies.TopRight]),
+            [QuadVerticies.TopLeft]: Vector3Like.Clone(this.vertices[QuadVerticies.TopLeft]),
+            [QuadVerticies.BottomLeft]: Vector3Like.Clone(this.vertices[QuadVerticies.BottomLeft]),
+            [QuadVerticies.BottomRight]: Vector3Like.Clone(this.vertices[QuadVerticies.BottomRight]),
+        });
+    }
+}
+export class QuadVector2VertexData extends QuadVertexData {
+    vertices;
+    constructor(vertices = {
+        [QuadVerticies.TopRight]: Vector2Like.Create(),
+        [QuadVerticies.TopLeft]: Vector2Like.Create(),
+        [QuadVerticies.BottomLeft]: Vector2Like.Create(),
+        [QuadVerticies.BottomRight]: Vector2Like.Create(),
+    }) {
+        super(vertices);
+        this.vertices = vertices;
+    }
+    setFromQuadData(vertexData) {
+        Vector2Like.Copy(this.vertices[QuadVerticies.TopRight], vertexData.vertices[QuadVerticies.TopRight]);
+        Vector2Like.Copy(this.vertices[QuadVerticies.TopLeft], vertexData.vertices[QuadVerticies.TopLeft]);
+        Vector2Like.Copy(this.vertices[QuadVerticies.BottomLeft], vertexData.vertices[QuadVerticies.BottomLeft]);
+        Vector2Like.Copy(this.vertices[QuadVerticies.BottomRight], vertexData.vertices[QuadVerticies.BottomRight]);
+    }
+    addToVertex(vertex, value) {
+        Vector2Like.AddInPlace(this.vertices[vertex], value);
+    }
+    subtractFromVertex(vertex, value) {
+        Vector2Like.SubtractInPlace(this.vertices[vertex], value);
+    }
+    addAll(value) {
+        this.addToVertex(QuadVerticies.TopRight, value);
+        this.addToVertex(QuadVerticies.TopLeft, value);
+        this.addToVertex(QuadVerticies.BottomLeft, value);
+        this.addToVertex(QuadVerticies.BottomRight, value);
+    }
+    subtractAll(value) {
+        this.subtractFromVertex(QuadVerticies.TopRight, value);
+        this.subtractFromVertex(QuadVerticies.TopLeft, value);
+        this.subtractFromVertex(QuadVerticies.BottomLeft, value);
+        this.subtractFromVertex(QuadVerticies.BottomRight, value);
+    }
+    isEqualTo(v1, v2, v3, v4) {
+        return (Vector2Like.Equals(this.vertices[QuadVerticies.TopRight], v1) &&
+            Vector2Like.Equals(this.vertices[QuadVerticies.TopLeft], v2) &&
+            Vector2Like.Equals(this.vertices[QuadVerticies.BottomLeft], v3) &&
+            Vector2Like.Equals(this.vertices[QuadVerticies.BottomRight], v4));
+    }
+    isAllEqualTo(v1) {
+        return (Vector2Like.Equals(this.vertices[QuadVerticies.TopRight], v1) &&
+            Vector2Like.Equals(this.vertices[QuadVerticies.TopLeft], v1) &&
+            Vector2Like.Equals(this.vertices[QuadVerticies.BottomLeft], v1) &&
+            Vector2Like.Equals(this.vertices[QuadVerticies.BottomRight], v1));
+    }
+    clone() {
+        return new QuadVector2VertexData({
+            [QuadVerticies.TopRight]: Vector2Like.Clone(this.vertices[QuadVerticies.TopRight]),
+            [QuadVerticies.TopLeft]: Vector2Like.Clone(this.vertices[QuadVerticies.TopLeft]),
+            [QuadVerticies.BottomLeft]: Vector2Like.Clone(this.vertices[QuadVerticies.BottomLeft]),
+            [QuadVerticies.BottomRight]: Vector2Like.Clone(this.vertices[QuadVerticies.BottomRight]),
+        });
+    }
+}
+export class QuadScalarVertexData extends QuadVertexData {
+    vertices;
+    constructor(vertices = {
+        [QuadVerticies.TopRight]: 0,
+        [QuadVerticies.TopLeft]: 0,
+        [QuadVerticies.BottomLeft]: 0,
+        [QuadVerticies.BottomRight]: 0,
+    }) {
+        super(vertices);
+        this.vertices = vertices;
+    }
+    setFromQuadData(vertexData) {
+        this.vertices[QuadVerticies.TopRight] =
+            vertexData.vertices[QuadVerticies.TopRight];
+        this.vertices[QuadVerticies.TopLeft] =
+            vertexData.vertices[QuadVerticies.TopLeft];
+        this.vertices[QuadVerticies.BottomLeft] =
+            vertexData.vertices[QuadVerticies.BottomLeft];
+        this.vertices[QuadVerticies.BottomRight] =
+            vertexData.vertices[QuadVerticies.BottomRight];
+    }
+    subtractFromVertex(vertex, value) {
+        this.vertices[vertex] -= value;
+    }
+    addAll(value) {
+        this.vertices[QuadVerticies.TopRight] += value;
+        this.vertices[QuadVerticies.TopLeft] += value;
+        this.vertices[QuadVerticies.BottomLeft] += value;
+        this.vertices[QuadVerticies.BottomRight] += value;
+    }
+    add(v1, v2, v3, v4) {
+        this.vertices[QuadVerticies.TopRight] += v1;
+        this.vertices[QuadVerticies.TopLeft] += v2;
+        this.vertices[QuadVerticies.BottomLeft] += v3;
+        this.vertices[QuadVerticies.BottomRight] += v4;
+    }
+    subtractAll(value) {
+        this.vertices[QuadVerticies.TopRight] -= value;
+        this.vertices[QuadVerticies.TopLeft] -= value;
+        this.vertices[QuadVerticies.BottomLeft] -= value;
+        this.vertices[QuadVerticies.BottomRight] -= value;
+    }
+    subtract(v1, v2, v3, v4) {
+        this.vertices[QuadVerticies.TopRight] += v1;
+        this.vertices[QuadVerticies.TopLeft] += v2;
+        this.vertices[QuadVerticies.BottomLeft] += v3;
+        this.vertices[QuadVerticies.BottomRight] += v4;
+    }
+    isGreaterThan(v1, v2, v3, v4) {
+        if (this.vertices[QuadVerticies.TopRight] < v1)
+            return false;
+        if (this.vertices[QuadVerticies.TopLeft] < v2)
+            return false;
+        if (this.vertices[QuadVerticies.BottomLeft] < v3)
+            return false;
+        if (this.vertices[QuadVerticies.BottomRight] < v4)
+            return false;
+        return true;
+    }
+    isAllGreaterThan(value) {
+        if (this.vertices[QuadVerticies.TopRight] < value)
+            return false;
+        if (this.vertices[QuadVerticies.TopLeft] < value)
+            return false;
+        if (this.vertices[QuadVerticies.BottomLeft] < value)
+            return false;
+        if (this.vertices[QuadVerticies.BottomRight] < value)
+            return false;
+        return true;
+    }
+    isLessThan(v1, v2, v3, v4) {
+        if (this.vertices[QuadVerticies.TopRight] > v1)
+            return false;
+        if (this.vertices[QuadVerticies.TopLeft] > v2)
+            return false;
+        if (this.vertices[QuadVerticies.BottomLeft] > v3)
+            return false;
+        if (this.vertices[QuadVerticies.BottomRight] > v4)
+            return false;
+        return true;
+    }
+    isAllLessThan(value) {
+        if (this.vertices[QuadVerticies.TopRight] > value)
+            return false;
+        if (this.vertices[QuadVerticies.TopLeft] > value)
+            return false;
+        if (this.vertices[QuadVerticies.BottomLeft] > value)
+            return false;
+        if (this.vertices[QuadVerticies.BottomRight] > value)
+            return false;
+        return true;
+    }
+    clone() {
+        return new QuadScalarVertexData({
+            [QuadVerticies.TopRight]: this.vertices[QuadVerticies.TopRight],
+            [QuadVerticies.TopLeft]: this.vertices[QuadVerticies.TopLeft],
+            [QuadVerticies.BottomLeft]: this.vertices[QuadVerticies.BottomLeft],
+            [QuadVerticies.BottomRight]: this.vertices[QuadVerticies.BottomRight],
+        });
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from "./Quad";
+export * from "./QuadVertexData";

package/Mesher/Geomtry/Primitives/index.js

@@ -0,0 +1,2 @@
+export * from "./Quad";
+export * from "./QuadVertexData";

package/Mesher/Geomtry/Tools/MesherDataTools.d.ts

@@ -0,0 +1,7 @@
+import { Mesh } from "../Mesh.js";
+export declare class MesherDataTool {
+    segments: Map<string, number[]>;
+    mesh: Mesh | null;
+    startNewMesh(mesh?: Mesh): void;
+    resetAll(): this;
+}

package/Mesher/Geomtry/Tools/MesherDataTools.js

@@ -0,0 +1,12 @@
+import { Mesh } from "../Mesh.js";
+export class MesherDataTool {
+    segments = new Map();
+    mesh = null;
+    startNewMesh(mesh) {
+        this.mesh = mesh ? mesh : new Mesh();
+    }
+    resetAll() {
+        this.mesh?.clear();
+        return this;
+    }
+}

package/Mesher/Geomtry/Tools/index.d.ts

@@ -0,0 +1 @@
+export * from "./MesherDataTools.js";

package/Mesher/Geomtry/Tools/index.js

@@ -0,0 +1 @@
+export * from "./MesherDataTools.js";

package/Mesher/Geomtry/VoxelGeometryBuilder.d.ts

@@ -0,0 +1,6 @@
+import { Vector3Like } from "@amodx/math";
+import { VoxelMesherDataTool } from "../Tools/VoxelMesherDataTool";
+import { Quad } from "./Primitives/Quad";
+export declare class VoxelGeometryBuilder {
+    static addQuad(tool: VoxelMesherDataTool, origin: Vector3Like, quad: Quad): void;
+}

package/Mesher/Geomtry/VoxelGeometryBuilder.js

@@ -0,0 +1,242 @@
+import { VoxelShaderData } from "../VoxelShaderData";
+import { QuadVerticies } from "./Geometry.types";
+import { VoxelMeshVertexStructCursor } from "../../Mesher/Tools/VoxelMeshVertexStructCursor";
+const empty = [];
+const structCursor = new VoxelMeshVertexStructCursor();
+export class VoxelGeometryBuilder {
+    /*   static addTriangle(
+      tool: VoxelMesherDataTool,
+      origin: Vector3Like,
+      points: [Vec3Array, Vec3Array, Vec3Array],
+      [[u1, v1], [u2, v2], [u3, v3]]: [Vec2Array, Vec2Array, Vec2Array]
+    ) {
+      if (!tool.mesh) return;
+      const worldLight = tool.vars.light;
+      const worldAO = tool.vars.ao;
+      const texture = tool.vars.textureIndex;
+      GeometryBuilder.addTriangle(tool, origin, points);
+      {
+        const attribute = tool.mesh.getAttribute("voxelData");
+  
+        attribute.push(
+          VoxelShaderData.createAttribute(
+            worldLight.vertices[1],
+            worldAO.vertices[1],
+            0
+          ),
+          VoxelShaderData.createAttribute(
+            worldLight.vertices[2],
+            worldAO.vertices[2],
+            0
+          ),
+          VoxelShaderData.createAttribute(
+            worldLight.vertices[3],
+            worldAO.vertices[3],
+            9
+          )
+        );
+      }
+      {
+        const uvs = tool.mesh.getAttribute("uv");
+        uvs.push(u1, v1, texture, u2, v2, texture, u3, v3, texture);
+      }
+      {
+        const uvs = tool.mesh.getAttribute("textureIndex");
+  
+        uvs.push(
+          //v1
+          0,
+          0,
+          0,
+          0,
+          //v2
+          0,
+          0,
+          0,
+          0,
+          //v3
+          0,
+          0,
+          0,
+          0
+        );
+      }
+      {
+        const colors = tool.mesh.getAttribute("colors");
+        colors.push(
+          //v1
+          0,
+          0,
+          0,
+          //v2
+          0,
+          0,
+          0,
+          //v3
+          0,
+          0,
+          0
+        );
+      }
+    } */
+    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;
+        const texture = tool.vars.textureIndex;
+        const overlayTextures = tool.vars.overlayTextures;
+        const topRightPos = quad.positions.vertices[0];
+        const topLeftPos = quad.positions.vertices[1];
+        const bottomLeftPos = quad.positions.vertices[2];
+        const bottomRightPos = quad.positions.vertices[3];
+        const topRightNor = quad.normals.vertices[0];
+        const topLeftNor = quad.normals.vertices[1];
+        const bottomLeftNor = quad.normals.vertices[2];
+        const bottomRightNor = quad.normals.vertices[3];
+        const indices = tool.mesh.indices;
+        let indIndex = indices.length;
+        let sides = quad.doubleSided ? 2 : 1;
+        const flip = quad.flip;
+        let orientation = quad.orientation;
+        while (sides--) {
+            const baseIndex = tool.mesh.indicieIndex;
+            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;
+            }
+            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;
+            }
+            //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;
+            }
+            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;
+            }
+            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;
+            }
+            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;
+            }
+            tool.mesh.indicieIndex += 4;
+        }
+        structCursor.data = empty;
+    }
+}

package/Mesher/Geomtry/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Primitives/index";
+export * from "./Tools/index.js";

package/Mesher/Geomtry/index.js

@@ -0,0 +1,2 @@
+export * from "./Primitives/index";
+export * from "./Tools/index.js";

package/Mesher/InitMesher.d.ts

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

package/Mesher/InitMesher.js

@@ -0,0 +1,23 @@
+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);
+    VoxelModelConstructorRegister.registerCustomNode("liquid", LiquidGeometryNode);
+    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));
+    }
+}

package/Mesher/InitTask.d.ts

@@ -0,0 +1,2 @@
+import { Thread } from "@amodx/threads";
+export default function (rendererThread: Thread): void;