@divinevoxel/vlox 0.0.1 → 0.0.3

package/Mesher/Mesher.d.ts

@@ -1,80 +1,16 @@
 import { LocationData } from "../Math/index.js";
-import { VoxelConstructorsRegister } from "./Constructors/Voxel/VoxelConstructorsRegister.js";
 import { ChunkProcessor } from "./Processors/ChunkProcessor.js";
-import { OverrideManager } from "./Rules/Overrides/OverridesManager.js";
-import { RenderedSubstances } from "./Rules/RenderedSubstances.js";
 import { BuildNodeMesh } from "./Tasks/BuidlerTasks.types.js";
-import { VoxelConstructor } from "./Constructors/Voxel/Classes/VoxelConstructor.js";
-import { VoxelShapeManager } from "./Shapes/VoxelShapeManager.js";
-import { Observable } from "@amodx/core/Observers";
-export type DVEMesherInitData = {
-    constructors: VoxelConstructor[];
-};
+import { DataSyncData } from "../Contexts/Base/Remote/Sync/DataSync.types.js";
 export declare class DVEMesher {
-    static observers: {
-        texturesRegistered: Observable<{
-            textureDataHasBeenSet: boolean;
-            data: import("../Textures/Texture.types.js").TextureTypeUVMap;
-            getTextureUV(data: import("../Textures/Constructor.types.js").ConstructorTextureData, overlay?: boolean): number;
-            setTextureIndex(data: import("../Textures/Texture.types.js").TextureTypeUVMap): void;
-            releaseTextureData(): void;
-            isReady(): boolean;
-        }>;
-    };
     static instance: DVEMesher;
-    static get defaults(): {
-        cube: {
-            mod(id: string, textures: import("../Textures/Constructor.types.js").ConstructorTextureData[] | Record<import("../Math/index.js").VoxelFaces, import("../Textures/Constructor.types.js").ConstructorTextureData[]>): import("./Constructors/Voxel/Classes/Cube/ModCube.constructor.js").ModCubeVoxelConstructor;
-            simple(id: string, textures: import("../Textures/Constructor.types.js").ConstructorTextureData | Record<import("../Types/Util.types.js").DirectionNames, import("../Textures/Constructor.types.js").ConstructorTextureData>): import("./Constructors/Voxel/Classes/Cube/SimpleCube.constructor.js").SimpleCubeVoxelConstructor;
-            pillar(id: string, textures: import("./Constructors/Voxel/Classes/Cube/PillarCube.constructor.js").PillarCubeVoxelConstructorData): import("./Constructors/Voxel/Classes/Cube/PillarCube.constructor.js").PillarCubeVoxelConstructor;
-        };
-        halfCube: {
-            mod(id: string, textures: import("../Textures/Constructor.types.js").ConstructorTextureData[]): import("./Constructors/Voxel/Classes/HalfCube/ModHalfCube.constructor.js").ModHalfCubeVoxelConstructor;
-            simple(id: string, textures: import("./Constructors/Voxel/Classes/HalfCube/SimpleHalfCube.constructor.js").SimpleHalfCubeVoxelConstructor["textureData"]): import("./Constructors/Voxel/Classes/HalfCube/SimpleHalfCube.constructor.js").SimpleHalfCubeVoxelConstructor;
-        };
-        stair: {
-            mod(id: string, textures: import("../Textures/Constructor.types.js").ConstructorTextureData[]): import("./Constructors/Voxel/Classes/Stair/ModStair.constructor.js").ModStairVoxelConstructor;
-            simple(id: string, texture: import("../Textures/Constructor.types.js").ConstructorTextureData): import("./Constructors/Voxel/Classes/Stair/SimpleStair.constructor.js").SimpleStairVoxelConstructor;
-        };
-        panel: {
-            simple(id: string, texture: import("../Textures/Constructor.types.js").ConstructorTextureData): import("./Constructors/Voxel/Classes/Panel/SimplePanel.constructor.js").SimplePanelVoxelConstructor;
-        };
-        crossedPanel: {
-            simple(id: string, texture: import("../Textures/Constructor.types.js").ConstructorTextureData): import("./Constructors/Voxel/Classes/Panel/SimpleCrossedPanel.constructor.js").SimpleCrossedPanelVoxelConstructor;
-        };
-        liquid: {
-            simple(id: string, textures: [import("../Textures/Constructor.types.js").ConstructorTextureData, import("../Textures/Constructor.types.js").ConstructorTextureData]): import("./Constructors/Voxel/Classes/Liquid/SimpleLiquid.constructor.js").SimpleLiquidConstructor;
-        };
-    };
-    constructors: typeof VoxelConstructorsRegister;
-    textureManager: {
-        textureDataHasBeenSet: boolean;
-        data: import("../Textures/Texture.types.js").TextureTypeUVMap;
-        getTextureUV(data: import("../Textures/Constructor.types.js").ConstructorTextureData, overlay?: boolean): number;
-        setTextureIndex(data: import("../Textures/Texture.types.js").TextureTypeUVMap): void;
-        releaseTextureData(): void;
-        isReady(): boolean;
-    };
     chunkProcessor: ChunkProcessor;
     nodes: {
-        builders: Map<string, import("./Meshers/Classes/Mesher.js").Mesher>;
-        registerBuilder(builder: import("./Meshers/Classes/Mesher.js").Mesher): void;
+        builders: Map<string, import("./Meshers/MesherInterface.js").MesherInterface>;
+        registerBuilder(builder: import("./Meshers/MesherInterface.js").MesherInterface): void;
         buildNode(data: BuildNodeMesh): [import("./Tasks/BuidlerTasks.types.js").SetNodeMesh, ArrayBuffer[]] | false;
     };
-    overrides: typeof OverrideManager;
-    renderedSubstances: typeof RenderedSubstances;
-    shapes: typeof VoxelShapeManager;
-    observers: {
-        texturesRegistered: Observable<{
-            textureDataHasBeenSet: boolean;
-            data: import("../Textures/Texture.types.js").TextureTypeUVMap;
-            getTextureUV(data: import("../Textures/Constructor.types.js").ConstructorTextureData, overlay?: boolean): number;
-            setTextureIndex(data: import("../Textures/Texture.types.js").TextureTypeUVMap): void;
-            releaseTextureData(): void;
-            isReady(): boolean;
-        }>;
-    };
-    constructor(data: DVEMesherInitData);
-    init(): void;
+    constructor();
+    init(data: DataSyncData): void;
     meshChunk(location: LocationData, LOD?: number, priority?: number): boolean;
 }

package/Mesher/Mesher.js

@@ -1,59 +1,41 @@
-import { VoxelConstructorsRegister } from "./Constructors/Voxel/VoxelConstructorsRegister.js";
 import { ChunkProcessor } from "./Processors/ChunkProcessor.js";
-import { OverrideManager } from "./Rules/Overrides/OverridesManager.js";
-import { RenderedSubstances } from "./Rules/RenderedSubstances.js";
-import { TextureRegister } from "../Textures/TextureRegister.js";
 import { MesherManager } from "./Meshers/MesherManager.js";
-import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-import { SubstanceRules } from "./Rules/SubstanceRules.js";
-import { VoxelShapeManager } from "./Shapes/VoxelShapeManager.js";
-import { Observable } from "@amodx/core/Observers";
+import { RenderedSubstances } from "./Substances/RenderedSubstances.js";
+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 class DVEMesher {
-    static observers = {
-        texturesRegistered: new Observable(),
-    };
     static instance;
-    static get defaults() {
-        return VoxelConstructorsRegister.defaults;
-    }
-    constructors = VoxelConstructorsRegister;
-    textureManager = TextureRegister;
     chunkProcessor = new ChunkProcessor();
     nodes = MesherManager;
-    overrides = OverrideManager;
-    renderedSubstances = RenderedSubstances;
-    shapes = VoxelShapeManager;
-    observers = DVEMesher.observers;
-    constructor(data) {
+    constructor() {
         if (!DVEMesher.instance)
             DVEMesher.instance = this;
-        this.constructors.registerVoxel(data.constructors);
         return DVEMesher.instance;
     }
-    init() {
-        this.shapes.init();
-        DivineVoxelEngineConstructor.instance.TC.registerTasks("sync-texuture-index", (data) => {
-            this.textureManager.setTextureIndex(data);
-            this.constructors.constructors.forEach((_) => {
-                try {
-                    _.onTexturesRegistered(this.textureManager);
-                }
-                catch (error) {
-                    console.log("error when loading textures into constructors");
-                    console.log(_);
-                    console.error(error);
-                }
-            });
-            this.observers.texturesRegistered.notify(this.textureManager);
-            this.textureManager.releaseTextureData();
-            SubstanceRules.buildRules();
-        });
-        DivineVoxelEngineConstructor.instance.TC.registerTasks("build-node-mesh", (data, onDone) => {
-            const nodeData = this.nodes.buildNode(data);
-            if (!nodeData)
-                return onDone ? onDone(false) : 0;
-            onDone ? onDone(nodeData[0], nodeData[1]) : 0;
-        }, "deferred");
+    init(data) {
+        for (const mat of data.materials.palette) {
+            RenderedSubstances.add(mat);
+        }
+        if (data.modelData) {
+            const modelData = data.modelData;
+            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));
+            }
+        }
     }
     meshChunk(location, LOD = 1, priority = 0) {
         this.chunkProcessor.build(location);

package/Mesher/Meshers/MesherInterface.d.ts

@@ -0,0 +1,5 @@
+import { BuildNodeMesh, SetNodeMesh } from "../Tasks/BuidlerTasks.types";
+export interface MesherInterface {
+    id: string;
+    build(data: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]] | false;
+}

package/Mesher/Meshers/MesherManager.d.ts

@@ -1,7 +1,7 @@
-import type { Mesher } from "./Classes/Mesher";
+import type { MesherInterface } from "./MesherInterface";
 import { BuildNodeMesh, SetNodeMesh } from "../Tasks/BuidlerTasks.types";
 export declare const MesherManager: {
-    builders: Map<string, Mesher>;
-    registerBuilder(builder: Mesher): void;
+    builders: Map<string, MesherInterface>;
+    registerBuilder(builder: MesherInterface): void;
     buildNode(data: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]] | false;
 };

package/Mesher/Meshers/MesherManager.js

@@ -1,5 +1,5 @@
-import { TextureBuilder } from "./Meshers/TextureMesher.js";
-import { VoxelBuilder } from "./Meshers/VoxelMesher.js";
+import { TextureBuilder } from "./TextureMesher.js";
+import { VoxelBuilder } from "./VoxelMesher.js";
 export const MesherManager = {
     builders: new Map(),
     registerBuilder(builder) {

package/Mesher/Meshers/{Meshers/TextureMesher.d.ts → TextureMesher.d.ts}

@@ -1,12 +1,14 @@
-import { Mesher } from "../Classes/Mesher.js";
-import { BuildNodeMesh, SetNodeMesh } from "../../Tasks/BuidlerTasks.types.js";
+import { MesherInterface } from "./MesherInterface.js";
+import { BuildNodeMesh, SetNodeMesh } from "../Tasks/BuidlerTasks.types.js";
 /**
  * @todo
  * For 32x32 textures the uvs and pixels are not correct.
  * Some pixels seem to be missing and the uvs are off slightly.
  * Added the uv offset for now to make it look a little better but pixels are still missing.
  */
-declare class TXTBuilderBase extends Mesher {
+declare class TXTBuilderBase implements MesherInterface {
+    id: string;
+    constructor(id: string);
     build(buildTask: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]];
 }
 export declare const TextureBuilder: TXTBuilderBase;

package/Mesher/Meshers/{Meshers/TextureMesher.js → TextureMesher.js}

@@ -1,10 +1,10 @@
 import { MesherDataTool } from "@amodx/meshing/Tools/MesherDataTools.js";
-import { Mesher } from "../Classes/Mesher.js";
 import { BinaryNumberTypes } from "@amodx/binary";
-import { Quad } from "@amodx/meshing/Classes/Quad.js";
+import { Quad } from "@amodx/meshing/Primitives/Quad.js";
 import { QuadVerticies } from "@amodx/meshing/Geometry.types.js";
 import { GeometryBuilder } from "@amodx/meshing";
 import { Flat2DIndex, Vector3Like } from "@amodx/math";
+import { CompactMesh } from "../Functions/CompactMesh.js";
 const Quads = {
     north: Quad.Create([
         [0, 0, 0],
@@ -16,15 +16,20 @@ const Quads = {
     ], Quad.FullUVs, false, 0),
 };
 const tool = new MesherDataTool();
-tool.attributes.set("uv", [[], 2, BinaryNumberTypes.Float32]);
-tool.attributes.set("textureIndex", [[], 3, BinaryNumberTypes.Float32]);
+tool.startNewMesh();
+tool.mesh.attributes.set("uv", [[], 2, BinaryNumberTypes.Float32]);
+tool.mesh.attributes.set("textureIndex", [[], 3, BinaryNumberTypes.Float32]);
 /**
  * @todo
  * For 32x32 textures the uvs and pixels are not correct.
  * Some pixels seem to be missing and the uvs are off slightly.
  * Added the uv offset for now to make it look a little better but pixels are still missing.
  */
-class TXTBuilderBase extends Mesher {
+class TXTBuilderBase {
+    id;
+    constructor(id) {
+        this.id = id;
+    }
     build(buildTask) {
         const [location, type, data] = buildTask;
         const textureId = data.textureId;
@@ -43,8 +48,8 @@ class TXTBuilderBase extends Mesher {
             textureData[textureDataIndex.getIndexXY(x, y) * 4 + 3] > 0.01
             ? true
             : false;
-        const uvs = tool.getAttribute("uv");
-        const textureIndex = tool.getAttribute("textureIndex");
+        const uvs = tool.mesh.getAttribute("uv");
+        const textureIndex = tool.mesh.getAttribute("textureIndex");
         const uvOffset = width > 16 ? -(2 / Math.max(width, height)) : 0;
         const addUvs = (sx, sy, ex, ey) => {
             uvs.push((ex + uvOffset) * factor, (ey + uvOffset) * factor, (sx - uvOffset) * factor, (ey + uvOffset) * factor, (sx - uvOffset) * factor, (sy - uvOffset) * factor, (ex + uvOffset) * factor, (sy - uvOffset) * factor);
@@ -168,9 +173,8 @@ class TXTBuilderBase extends Mesher {
                 }
             }
         }
-        const [attributes, transfers] = tool.getAllAttributes();
-        for (const [type, data] of attributes) {
-            if (type == "position") {
+        for (const [key, [data]] of tool.mesh.attributes) {
+            if (key == "position") {
                 for (let i = 0; i < data.length; i += 3) {
                     data[i] -= 0.5;
                     data[i + 1] -= 0.5;
@@ -178,9 +182,10 @@ class TXTBuilderBase extends Mesher {
                 }
             }
         }
+        const compacted = CompactMesh("dve_node", tool);
         tool.resetVars();
-        tool.resetAttributes();
-        return [[location, attributes], transfers];
+        tool.mesh.clear();
+        return [[location, compacted], [compacted[1]]];
     }
 }
-export const TextureBuilder = new TXTBuilderBase("#dve_node_texture");
+export const TextureBuilder = new TXTBuilderBase("dve_node");

package/Mesher/Meshers/VoxelMesher.d.ts

@@ -0,0 +1,15 @@
+import { MesherInterface } from "./MesherInterface.js";
+import { BuildNodeMesh, SetNodeMesh } from "../Tasks/BuidlerTasks.types.js";
+import { TemplateCursor } from "../../Data/Cursor/Template/TemplateCursor.js";
+import { VoxelCursor } from "../../Data/Cursor/VoxelCursor.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+declare class VoxelBuilderBase implements MesherInterface {
+    id: string;
+    templateCursor: TemplateCursor;
+    voxelCursor: VoxelCursor;
+    substanceData: SubstanceDataTool;
+    constructor(id: string);
+    build([location, type, rawVoxelData]: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]] | false;
+}
+export declare const VoxelBuilder: VoxelBuilderBase;
+export {};

package/Mesher/Meshers/VoxelMesher.js

@@ -0,0 +1,47 @@
+import { RenderedSubstances } from "../Substances/RenderedSubstances.js";
+import { VoxelGeometryLookUp } from "../Models/VoxelGeometryLookUp.js";
+import { TemplateCursor } from "../../Data/Cursor/Template/TemplateCursor.js";
+import { VoxelCursor } from "../../Data/Cursor/VoxelCursor.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+import { FullVoxelTemplate } from "../../Templates/FullVoxelTemplate.js";
+import { CompactVoxelMesh } from "../Functions/CompactVoxelMesh.js";
+import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
+class VoxelBuilderBase {
+    id;
+    templateCursor = new TemplateCursor();
+    voxelCursor = new VoxelCursor();
+    substanceData = new SubstanceDataTool();
+    constructor(id) {
+        this.id = id;
+        this.templateCursor.setTemplate(new FullVoxelTemplate(FullVoxelTemplate.CreateNew([3, 3, 3], 0xf)));
+    }
+    build([location, type, rawVoxelData]) {
+        const voxel = this.templateCursor.getVoxel(1, 1, 1);
+        voxel.copyRaw(rawVoxelData);
+        voxel.process();
+        if (!voxel.isRenderable())
+            return false;
+        const constructor = VoxelModelConstructorRegister.getConstructor(voxel.getStringId());
+        const mesher = RenderedSubstances.meshers.get(voxel.getRenderedMaterialStringId());
+        if (!mesher || !constructor)
+            return false;
+        mesher.resetAll();
+        VoxelGeometryLookUp.start("main", 0, 0, 0);
+        mesher.origin.x = -0.5;
+        mesher.origin.y = -0.5;
+        mesher.origin.z = -0.5;
+        mesher.position.x = 1;
+        mesher.position.y = 1;
+        mesher.position.z = 1;
+        mesher.voxel = this.voxelCursor.copy(voxel);
+        mesher.nVoxel = this.templateCursor;
+        constructor.process(mesher);
+        mesher.resetVars();
+        VoxelGeometryLookUp.stop();
+        const compacted = CompactVoxelMesh(mesher);
+        mesher.resetVars();
+        mesher.mesh.clear();
+        return [[location, compacted], [compacted[1]]];
+    }
+}
+export const VoxelBuilder = new VoxelBuilderBase("dve_node_voxel");

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

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

package/Mesher/Models/Common/BoundsFunctions.js

@@ -0,0 +1,56 @@
+export function UpdateBounds(tool, origin, bounds) {
+    //min
+    if (origin.x + bounds[0][0] < tool.bounds.min[0])
+        tool.bounds.min[0] = origin.x + bounds[0][0];
+    if (origin.y + bounds[0][1] < tool.bounds.min[1])
+        tool.bounds.min[1] = origin.y + bounds[0][1];
+    if (origin.z + bounds[0][2] < tool.bounds.min[2])
+        tool.bounds.min[2] = origin.z + bounds[0][2];
+    //max
+    if (origin.x + bounds[1][0] > tool.bounds.max[0])
+        tool.bounds.max[0] = origin.x + bounds[1][0];
+    if (origin.y + bounds[1][1] > tool.bounds.max[1])
+        tool.bounds.max[1] = origin.y + bounds[1][1];
+    if (origin.z + bounds[1][2] > tool.bounds.max[2])
+        tool.bounds.max[2] = origin.z + bounds[1][2];
+}
+export function GetBounds(vectors) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    const EPSILON = 0;
+    for (let i = 0; i < vectors.length; i++) {
+        const [x, y, z] = vectors[i];
+        if (x < minX)
+            minX = x;
+        if (y < minY)
+            minY = y;
+        if (z < minZ)
+            minZ = z;
+        if (x > maxX)
+            maxX = x;
+        if (y > maxY)
+            maxY = y;
+        if (z > maxZ)
+            maxZ = z;
+    }
+    /*   if (maxX - minX < EPSILON) {
+        minX -= EPSILON / 2;
+        maxX += Number.EPSILON / 2;
+      }
+      if (maxY - minY < EPSILON) {
+        maxY -= EPSILON / 2;
+        minY += Number.EPSILON / 2;
+      }
+      if (maxZ - minZ < EPSILON) {
+        maxZ -= EPSILON / 2;
+        minZ += EPSILON / 2;
+      } */
+    return [
+        [minX, minY, minZ],
+        [maxX, maxY, maxZ],
+    ];
+}

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

@@ -0,0 +1,10 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelFaces } from "../../../Math";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { QuadVertexWeights } from "./Calc/CalcConstants";
+import { VoxelGeometryTransform } from "../../../Voxels/VoxelSyncData";
+export declare function GetBoxGeometryNodeData(points: [Vec3Array, Vec3Array], transform: VoxelGeometryTransform): {
+    quads: Record<VoxelFaces, Quad>;
+    vertexWeights: Record<VoxelFaces, QuadVertexWeights>;
+    quadBounds: [Vec3Array, Vec3Array][];
+};

package/Mesher/Models/Common/BoxGeometryNode.js

@@ -0,0 +1,74 @@
+import { Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../../Math";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { addQuadWeights } from "./Calc/CalcConstants";
+import { TransformBox } from "../../../Models/Shared/Transform";
+import { GetBounds } from "./BoundsFunctions";
+export function GetBoxGeometryNodeData(points, transform) {
+    const quads = [];
+    const vertexWeights = [];
+    const [start, end] = points.map((_) => Vector3Like.Create(..._));
+    const quadPoints = [
+        //top
+        [
+            [end.x, end.y, end.z],
+            [start.x, end.y, end.z],
+            [start.x, end.y, start.z],
+            [end.x, end.y, start.z],
+        ],
+        //bottom
+        [
+            [start.x, start.y, end.z],
+            [end.x, start.y, end.z],
+            [end.x, start.y, start.z],
+            [start.x, start.y, start.z],
+        ],
+        //north
+        [
+            [start.x, end.y, end.z],
+            [end.x, end.y, end.z],
+            [end.x, start.y, end.z],
+            [start.x, start.y, end.z],
+        ],
+        //south
+        [
+            [end.x, end.y, start.z],
+            [start.x, end.y, start.z],
+            [start.x, start.y, start.z],
+            [end.x, start.y, start.z],
+        ],
+        //east
+        [
+            [end.x, end.y, end.z],
+            [end.x, end.y, start.z],
+            [end.x, start.y, start.z],
+            [end.x, start.y, end.z],
+        ],
+        //west
+        [
+            [start.x, end.y, start.z],
+            [start.x, end.y, end.z],
+            [start.x, start.y, end.z],
+            [start.x, start.y, start.z],
+        ],
+    ];
+    const tranformed = TransformBox(quadPoints.map((_) => Quad.Create(_)), transform);
+    const quadBounds = tranformed.map((_) => GetBounds(_.positions.getAsArray().map((_) => Vector3Like.ToArray(_))));
+    quads[VoxelFaces.Up] = tranformed[VoxelFaces.Up];
+    vertexWeights[VoxelFaces.Up] = addQuadWeights(quads[VoxelFaces.Up], VoxelFaces.Up);
+    quads[VoxelFaces.Down] = tranformed[VoxelFaces.Down];
+    vertexWeights[VoxelFaces.Down] = addQuadWeights(quads[VoxelFaces.Down], VoxelFaces.Down);
+    quads[VoxelFaces.North] = tranformed[VoxelFaces.North];
+    vertexWeights[VoxelFaces.North] = addQuadWeights(quads[VoxelFaces.North], VoxelFaces.North);
+    quads[VoxelFaces.South] = tranformed[VoxelFaces.South];
+    vertexWeights[VoxelFaces.South] = addQuadWeights(quads[VoxelFaces.South], VoxelFaces.South);
+    quads[VoxelFaces.East] = tranformed[VoxelFaces.East];
+    vertexWeights[VoxelFaces.East] = addQuadWeights(quads[VoxelFaces.East], VoxelFaces.East);
+    quads[VoxelFaces.West] = tranformed[VoxelFaces.West];
+    vertexWeights[VoxelFaces.West] = addQuadWeights(quads[VoxelFaces.West], VoxelFaces.West);
+    return {
+        quads,
+        vertexWeights,
+        quadBounds,
+    };
+}

package/Mesher/{Calc → Models/Common/Calc}/CalcConstants.d.ts

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

package/Mesher/{Calc → Models/Common/Calc}/CalcConstants.js

@@ -1,7 +1,7 @@
 import { QuadVerticies, QuadVerticiesArray, } from "@amodx/meshing/Geometry.types";
-import { VoxelFaces, VoxelFacesArray } from "../../Math";
-import { VoxelRelativeCubeIndex } from "../../VoxelModels/Indexing/VoxelRelativeCubeIndex";
-import { LightData } from ".../../Data/LightData";
+import { VoxelFaces, VoxelFacesArray } from "../../../../Math";
+import { VoxelRelativeCubeIndex } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
+import { LightData } from "../../../../Voxels/LightData";
 export const GradientCheckSets = [];
 GradientCheckSets[VoxelFaces.Up] = [];
 GradientCheckSets[VoxelFaces.Up][QuadVerticies.TopRight] = [

package/Mesher/{Calc/Light → Models/Common/Calc}/FaceDataCalc.d.ts

@@ -1,5 +1,5 @@
-import type { VoxelMesherDataTool } from "../../Tools/VoxelMesherDataTool.js";
-import { VoxelFaces } from "../../../Math";
+import type { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool.js";
+import { VoxelFaces } from "../../../../Math/index.js";
 export declare const FaceDataCalc: {
     settings: {
         doAO: boolean;

package/Mesher/{Calc/Light → Models/Common/Calc}/FaceDataCalc.js

@@ -1,6 +1,6 @@
-import { LightData } from "../../../Data/LightData.js";
-import { VoxelFaceDirections } from "../../../Math";
-import { GradientCheckSets } from "../CalcConstants.js";
+import { LightData } from "../../../../Voxels/LightData.js";
+import { VoxelFaceDirections } from "../../../../Math/index.js";
+import { GradientCheckSets } from "./CalcConstants.js";
 const currentLightValues = new Uint16Array([0, 0, 0, 0]);
 const loadedLightValues = new Uint16Array([0, 0, 0, 0]);
 const faceLength = 9 * 4;
@@ -13,21 +13,19 @@ export const FaceDataCalc = {
     calculate(face, tool) {
         let light = tool.voxel.getLight();
         const faceNormal = VoxelFaceDirections[face];
-        tool.nVoxel.loadInAt(tool.voxel.x + faceNormal[0], tool.voxel.y + faceNormal[1], tool.voxel.z + faceNormal[2]);
-        const otherLight = tool.nVoxel.getLight();
+        const nVoxel = tool.nVoxel.getVoxel(tool.position.x + faceNormal[0], tool.position.y + faceNormal[1], tool.position.z + faceNormal[2]);
+        const otherLight = nVoxel?.getLight() || 0;
         light = otherLight >= 0 ? otherLight : light >= 0 ? light : 0;
-        const baseIndex = face * faceLength;
         for (let vertex = 0; vertex < 4; vertex++) {
-            const checkSetIndex = baseIndex + vertex * 9;
             if (settings.doLight) {
                 tool.lightData[face][vertex] = light;
                 LightData.getLightValuesToRef(light, currentLightValues);
             }
             for (let i = 0; i < 9; i += 3) {
-                const didLoad = tool.nVoxel.loadInAt(GradientCheckSets[face][vertex][i] + tool.voxel.x, GradientCheckSets[face][vertex][i + 1] + tool.voxel.y, GradientCheckSets[face][vertex][i + 2] + tool.voxel.z);
-                if (!settings.doLight || !didLoad)
+                const loadedVoxel = tool.nVoxel.getVoxel(GradientCheckSets[face][vertex][i] + tool.position.x, GradientCheckSets[face][vertex][i + 1] + tool.position.y, GradientCheckSets[face][vertex][i + 2] + tool.position.z);
+                if (!settings.doLight || !loadedVoxel)
                     continue;
-                const nl = tool.nVoxel.getLight();
+                const nl = loadedVoxel.getLight();
                 if (nl <= 0)
                     continue;
                 /*

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

@@ -0,0 +1,11 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelFaces } from "../../../Math";
+import { VoxelQuadGeometryNode } from "../../../Models/VoxelModel.types";
+import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { VoxelGeometryTransform } from "../../../Voxels/VoxelSyncData";
+export declare function GetQuadGeometryData(data: VoxelQuadGeometryNode, transform: VoxelGeometryTransform): {
+    quad: Quad;
+    vertexWeights: import("./Calc/CalcConstants").QuadVertexWeights;
+    closestFace: VoxelFaces;
+    quadBounds: [Vec3Array, Vec3Array];
+};