@divinevoxel/vlox 0.0.4 → 0.0.6

package/Mesher/Models/Nodes/Ruleless/RulelessBoxVoxelGeometryNode.js

@@ -1,7 +1,7 @@
-import { VoxelGeometry } from "../../../../Mesher/Geometry/VoxelGeometry";
+import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
 import { BoxVoxelGometryInputs, } from "../../../../Models/Input/BoxVoxelGometryInputs";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
-import { LightData } from "../../../../Voxels/LightData";
+import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
 import { GeoemtryNode } from "../GeometryNode";
 import { GetBoxGeometryNodeData } from "../../Common/BoxGeometryNode";
 import { UpdateBounds } from "../../Common/BoundsFunctions";
@@ -12,6 +12,7 @@ export class RulelessBoxVoxelGeometryNode extends GeoemtryNode {
     vertexWeights;
     worldLight;
     worldAO;
+    lightData = new VoxelLightData();
     init() {
         this.faceCount = 6;
         this.vertexCount = this.faceCount * 4;
@@ -36,14 +37,14 @@ export class RulelessBoxVoxelGeometryNode extends GeoemtryNode {
     shouldFlip() {
         if (shouldCauseFlip(this.worldAO.vertices[0], this.worldAO.vertices[1], this.worldAO.vertices[2], this.worldAO.vertices[3]))
             return true;
-        return (shouldCauseFlip(LightData.getS(this.worldLight.vertices[0]), LightData.getS(this.worldLight.vertices[1]), LightData.getS(this.worldLight.vertices[2]), LightData.getS(this.worldLight.vertices[3])) ||
-            shouldCauseFlip(LightData.sumRGB(this.worldLight.vertices[0]), LightData.sumRGB(this.worldLight.vertices[1]), LightData.sumRGB(this.worldLight.vertices[2]), LightData.sumRGB(this.worldLight.vertices[3])));
+        return (shouldCauseFlip(this.lightData.getS(this.worldLight.vertices[0]), this.lightData.getS(this.worldLight.vertices[1]), this.lightData.getS(this.worldLight.vertices[2]), this.lightData.getS(this.worldLight.vertices[3])) ||
+            shouldCauseFlip(this.lightData.sumRGB(this.worldLight.vertices[0]), this.lightData.sumRGB(this.worldLight.vertices[1]), this.lightData.sumRGB(this.worldLight.vertices[2]), this.lightData.sumRGB(this.worldLight.vertices[3])));
     }
     add(tool, originHash, origin, args) {
         this.tool = tool;
         this.origin = tool.position;
-        this.worldAO = tool.getWorldAO();
-        this.worldLight = tool.getWorldLight();
+        this.worldAO = tool.vars.ao;
+        this.worldLight = tool.vars.light;
         for (let face = 0; face < 6; face++) {
             if (args[face][ArgIndexes.Enabled]) {
                 tool.calculateFaceData(face);
@@ -51,7 +52,7 @@ export class RulelessBoxVoxelGeometryNode extends GeoemtryNode {
                 const faceArgs = args[face];
                 const quad = this.quads[face];
                 quad.flip = this.shouldFlip() || faceArgs[ArgIndexes.Fliped];
-                tool.setTexture(faceArgs[ArgIndexes.Texture]);
+                tool.vars.textureIndex = faceArgs[ArgIndexes.Texture];
                 const uvs = faceArgs[ArgIndexes.UVs];
                 //1
                 quad.uvs.vertices[0].x = uvs[0][0];
@@ -65,7 +66,7 @@ export class RulelessBoxVoxelGeometryNode extends GeoemtryNode {
                 //4
                 quad.uvs.vertices[3].x = uvs[3][0];
                 quad.uvs.vertices[3].y = uvs[3][1];
-                VoxelGeometry.addQuad(tool, origin, quad);
+                VoxelGeometryBuilder.addQuad(tool, origin, quad);
                 UpdateBounds(tool, origin, this.quadBounds[face]);
             }
         }

package/Mesher/Models/Nodes/Ruleless/RulelessQuadVoxelGeometryNode.d.ts

@@ -1,11 +1,12 @@
 import { Vec3Array, Vec4Array, Vector3Like } from "@amodx/math";
 import { VoxelFaces } from "../../../../Math";
-import { QuadScalarVertexData } from "@amodx/meshing";
+import { QuadScalarVertexData } from "../../../Geomtry/Primitives/QuadVertexData";
 import { VoxelQuadGeometryNode } from "../../../../Models/VoxelModel.types";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { Quad } from "../../../Geomtry/Primitives/Quad";
 import { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool";
 import { QuadVoxelGometryArgs } from "../../../../Models/Input/QuadVoxelGometryInputs";
 import { GeoemtryNode } from "../GeometryNode";
+import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
 export declare class RulelessQuadVoxelGeometryNode extends GeoemtryNode<VoxelQuadGeometryNode, QuadVoxelGometryArgs> {
     quad: Quad;
     quadBounds: [Vec3Array, Vec3Array];
@@ -13,6 +14,7 @@ export declare class RulelessQuadVoxelGeometryNode extends GeoemtryNode<VoxelQua
     worldLight: QuadScalarVertexData;
     worldAO: QuadScalarVertexData;
     closestFace: VoxelFaces;
+    lightData: VoxelLightData;
     init(): void;
     determineShading(): void;
     shouldFlip(): boolean;

package/Mesher/Models/Nodes/Ruleless/RulelessQuadVoxelGeometryNode.js

@@ -1,11 +1,11 @@
 import { VoxelFaces } from "../../../../Math";
-import { VoxelGeometry } from "../../../../Mesher/Geometry/VoxelGeometry";
+import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
-import { LightData } from "../../../../Voxels/LightData";
 import { QuadVoxelGometryInputs, } from "../../../../Models/Input/QuadVoxelGometryInputs";
 import { GeoemtryNode } from "../GeometryNode";
 import { GetQuadGeometryData } from "../../Common/QuadGeometryNode";
 import { UpdateBounds } from "../../Common/BoundsFunctions";
+import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
 const ArgIndexes = QuadVoxelGometryInputs.ArgIndexes;
 export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
     quad;
@@ -17,6 +17,7 @@ export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
     worldLight;
     worldAO;
     closestFace;
+    lightData = new VoxelLightData();
     init() {
         this.faceCount = 6;
         this.vertexCount = this.faceCount * 4;
@@ -42,20 +43,20 @@ export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
     shouldFlip() {
         if (shouldCauseFlip(this.worldAO.vertices[0], this.worldAO.vertices[1], this.worldAO.vertices[2], this.worldAO.vertices[3]))
             return true;
-        return (shouldCauseFlip(LightData.getS(this.worldLight.vertices[0]), LightData.getS(this.worldLight.vertices[1]), LightData.getS(this.worldLight.vertices[2]), LightData.getS(this.worldLight.vertices[3])) ||
-            shouldCauseFlip(LightData.sumRGB(this.worldLight.vertices[0]), LightData.sumRGB(this.worldLight.vertices[1]), LightData.sumRGB(this.worldLight.vertices[2]), LightData.sumRGB(this.worldLight.vertices[3])));
+        return (shouldCauseFlip(this.lightData.getS(this.worldLight.vertices[0]), this.lightData.getS(this.worldLight.vertices[1]), this.lightData.getS(this.worldLight.vertices[2]), this.lightData.getS(this.worldLight.vertices[3])) ||
+            shouldCauseFlip(this.lightData.sumRGB(this.worldLight.vertices[0]), this.lightData.sumRGB(this.worldLight.vertices[1]), this.lightData.sumRGB(this.worldLight.vertices[2]), this.lightData.sumRGB(this.worldLight.vertices[3])));
     }
     add(tool, originHash, origin, args) {
         this.tool = tool;
         this.origin = tool.position;
-        this.worldAO = tool.getWorldAO();
-        this.worldLight = tool.getWorldLight();
+        this.worldAO = tool.vars.ao;
+        this.worldLight = tool.vars.light;
         if (args[ArgIndexes.Enabled]) {
             tool.calculateFaceData(this.closestFace);
             this.determineShading();
             const quad = this.quad;
             quad.flip = this.shouldFlip() || args[ArgIndexes.Fliped];
-            tool.setTexture(args[ArgIndexes.Texture]);
+            tool.vars.textureIndex = args[ArgIndexes.Texture];
             quad.doubleSided = args[ArgIndexes.DoubleSided];
             const uvs = args[ArgIndexes.UVs];
             //1
@@ -70,7 +71,7 @@ export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
             //4
             quad.uvs.vertices[3].x = uvs[3][0];
             quad.uvs.vertices[3].y = uvs[3][1];
-            VoxelGeometry.addQuad(tool, origin, quad);
+            VoxelGeometryBuilder.addQuad(tool, origin, quad);
             UpdateBounds(tool, origin, this.quadBounds);
         }
         this.worldLight.setAll(0);

package/Mesher/Models/Nodes/VoxelGeometryConstructor.d.ts

@@ -1,6 +1,6 @@
 import { VoxelFaceCullResultsIndex } from "../../../Models/Indexing/VoxelFaceCullResultsIndex";
 import { VoxelAOResultsIndex } from "../../../Models/Indexing/VoxelAOResultsIndex";
-import { VoxelGeometryRulelessSyncData, VoxelGeometrySyncData } from "../../../Voxels/VoxelSyncData";
+import { CompiledVoxelGeometryRulessData, CompiledVoxelGeometrySyncData } from "../../../Voxels/Types/VoxelModelCompiledData.types";
 import { GeoemtryNode } from "./GeometryNode";
 export declare class VoxelGeometryConstructor {
     geometryPaletteId: number;
@@ -9,5 +9,5 @@ export declare class VoxelGeometryConstructor {
     vertexHitMap: number[][];
     cullIndex: VoxelFaceCullResultsIndex;
     aoIndex: VoxelAOResultsIndex;
-    constructor(geometryPaletteId: number, data: VoxelGeometrySyncData | VoxelGeometryRulelessSyncData);
+    constructor(geometryPaletteId: number, data: CompiledVoxelGeometrySyncData | CompiledVoxelGeometryRulessData);
 }

package/Mesher/Models/Nodes/VoxelGeometryConstructor.js

@@ -61,7 +61,7 @@ export class VoxelGeometryConstructor {
         for (const node of this.nodes) {
             node.faceIndex = faceCount;
             node.vertexIndex = vertexCount;
-            faceCount += node.faceCount;
+            faceCount += node.faceCount - 1;
             vertexCount += node.vertexCount;
         }
     }

package/Mesher/Models/VoxelConstructor.d.ts

@@ -1,6 +1,6 @@
 import { TextureRegister } from "../../Textures/TextureRegister";
 import { VoxelMesherDataTool } from "../../Mesher/Tools/VoxelMesherDataTool";
-import { VoxelInputsSyncData, VoxelModelSyncData } from "../../Voxels/VoxelSyncData";
+import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Types/VoxelModelCompiledData.types";
 import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
 import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
 import { VoxelFaceTransparentResultsIndex } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
@@ -8,7 +8,7 @@ import { VoxelModelEffect } from "./VoxelModelEffect";
 import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
 export declare class VoxelConstructor {
     id: string;
-    data: VoxelModelSyncData;
+    data: CompiledVoxelModelData;
     isModel: true;
     geometries: number[][];
     modSchema: StateSchema;
@@ -20,7 +20,7 @@ export declare class VoxelConstructor {
     effects: VoxelModelEffect;
     shapeStateTree: StateTreeReader;
     condtioanlShapeStateTree: CondtionalTreeReader;
-    constructor(id: string, data: VoxelModelSyncData, voxleData: VoxelInputsSyncData);
+    constructor(id: string, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
     getShapeStateTransaprentByteIndex(shapeState: number, geomtryId: number): number;
     getCondtionalStateTransaprentByteIndex(shapeState: number, geomtryId: number): number;
     isShapeStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;

package/Mesher/Models/VoxelConstructor.js

@@ -46,8 +46,8 @@ export class VoxelConstructor {
     }
     process(tool) {
         const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x, tool.position.y, tool.position.z);
-        const treeState = VoxelGeometryLookUp.stateCache[hashed];
-        const modState = VoxelGeometryLookUp.modCache[hashed];
+        const treeState = VoxelGeometryLookUp.space.stateCache[hashed];
+        const modState = VoxelGeometryLookUp.space.modCache[hashed];
         if (treeState !== undefined && treeState > -1) {
             const geoLinks = this.data.shapeStateMap[treeState];
             const geometries = this.data.shapeStateGeometryMap[treeState];
@@ -63,7 +63,7 @@ export class VoxelConstructor {
                 }
             }
         }
-        const conditonalTreeState = VoxelGeometryLookUp.conditonalStateCache[hashed];
+        const conditonalTreeState = VoxelGeometryLookUp.space.conditonalStateCache[hashed];
         if (conditonalTreeState !== undefined && conditonalTreeState > -1) {
             const condiotnalNodes = this.data.condiotnalShapeStateMap[conditonalTreeState];
             const condiotnalNodesLength = condiotnalNodes.length;
@@ -82,7 +82,7 @@ export class VoxelConstructor {
                 }
             }
         }
-        this.effects.addEffects(tool.voxel.getShapeState(), tool.origin, tool.effects);
+        this.effects.addEffects(tool.voxel.getState(), tool.origin, tool.effects);
         tool.clearCalculatedData();
     }
     onTexturesRegistered(textureManager) { }

package/Mesher/Models/VoxelGeometryLookUp.d.ts

@@ -1,19 +1,28 @@
-import { DataCursorInterface } from "../../Data/Cursor/Interfaces/DataCursor.interface";
-import { VoxelConstructor } from "./VoxelConstructor";
-import { Vec3Array } from "@amodx/math";
-import { VoxelCursor } from "../../Data/Cursor/VoxelCursor";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { Vec3Array, Vector3Like } from "@amodx/math";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+export declare class VoxelGeometryLookUpSpace {
+    bounds: Vector3Like;
+    foundHash: Uint8Array;
+    voxelHash: Uint16Array;
+    modCache: Int32Array;
+    stateCache: Int32Array;
+    conditonalStateCache: Int32Array;
+    noCastAO: Uint8Array;
+    offset: Vec3Array;
+    constructor(bounds: Vector3Like);
+    start(x: number, y: number, z: number): void;
+    getIndex(x: number, y: number, z: number): number;
+    getConstructor(index: number): import("./VoxelConstructor").VoxelConstructor | null;
+    getGeomtry(index: number): false | number[];
+    getConditionalGeomtry(index: number): false | number[][];
+}
 export declare class VoxelGeometryLookUp {
-    static voxelHash: VoxelConstructor[];
-    static modCache: number[];
-    static stateCache: number[];
-    static conditonalStateCache: number[];
-    static geometryCache: number[][];
-    static conditionalGeometryCache: number[][][];
-    static noCastAO: boolean[];
-    static offset: Vec3Array;
+    static space: VoxelGeometryLookUpSpace | null;
     static voxelCursor: VoxelCursor;
+    static createSpace(x: number, y: number, z: number): VoxelGeometryLookUpSpace;
     static init(): void;
-    static start(dimension: string, x: number, y: number, z: number): void;
+    static start(space: VoxelGeometryLookUpSpace): void;
     static isRulesless(geoId: number): boolean;
     static stop(): void;
     static getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;

package/Mesher/Models/VoxelGeometryLookUp.js

@@ -1,67 +1,106 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
-import { Vector3Like } from "@amodx/math";
-import { VoxelCursor } from "../../Data/Cursor/VoxelCursor";
-export class VoxelGeometryLookUp {
-    static voxelHash = [];
-    static modCache = [];
-    static stateCache = [];
-    static conditonalStateCache = [];
-    static geometryCache = [];
-    static conditionalGeometryCache = [];
-    static noCastAO = [];
-    static offset = [0, 0, 0];
-    static voxelCursor = new VoxelCursor();
-    static init() { }
-    static start(dimension, x, y, z) {
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+import { GetYXZOrderArrayIndex } from "../../Math/Indexing";
+export class VoxelGeometryLookUpSpace {
+    bounds;
+    foundHash;
+    voxelHash;
+    modCache;
+    stateCache;
+    conditonalStateCache;
+    noCastAO;
+    offset = [0, 0, 0];
+    constructor(bounds) {
+        this.bounds = bounds;
+        const volume = bounds.x * bounds.y * bounds.z;
+        this.foundHash = new Uint8Array(volume);
+        this.voxelHash = new Uint16Array(volume);
+        this.modCache = new Int32Array(volume);
+        this.stateCache = new Int32Array(volume);
+        this.conditonalStateCache = new Int32Array(volume);
+        this.noCastAO = new Uint8Array(volume);
+    }
+    start(x, y, z) {
         this.offset[0] = x;
         this.offset[1] = y;
         this.offset[2] = z;
+        this.foundHash.fill(0);
+        this.conditonalStateCache.fill(-1);
+        this.stateCache.fill(-1);
+        this.modCache.fill(-1);
+    }
+    getIndex(x, y, z) {
+        return GetYXZOrderArrayIndex(x - this.offset[0], y - this.offset[1], z - this.offset[2], this.bounds.x, this.bounds.y, this.bounds.z);
+    }
+    getConstructor(index) {
+        if (this.foundHash[index] !== 2)
+            return null;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]];
+    }
+    getGeomtry(index) {
+        if (this.foundHash[index] !== 2)
+            return false;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]].data.shapeStateGeometryMap[this.stateCache[index]];
+    }
+    getConditionalGeomtry(index) {
+        if (this.foundHash[index] !== 2)
+            return false;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]].data.condiotnalShapeStateGeometryMap[this.conditonalStateCache[index]];
+    }
+}
+export class VoxelGeometryLookUp {
+    static space = null;
+    static voxelCursor = new VoxelCursor();
+    static createSpace(x, y, z) {
+        return new VoxelGeometryLookUpSpace({ x, y, z });
+    }
+    static init() { }
+    static start(space) {
+        this.space = space;
     }
     static isRulesless(geoId) {
         return VoxelModelConstructorRegister.rulesless[geoId] == true;
     }
-    static stop() {
-        this.stateCache.length = 0;
-        this.voxelHash.length = 0;
-        this.modCache.length = 0;
-        this.geometryCache.length = 0;
-        this.conditionalGeometryCache.length = 0;
-        this.conditonalStateCache.length = 0;
-        this.noCastAO.length = 0;
-    }
+    static stop() { }
     static getHash(dataCursor, x, y, z) {
-        const hashed = Vector3Like.HashXYZ(x - this.offset[0], y - this.offset[1], z - this.offset[2]);
-        if (!this.stateCache[hashed])
+        if (!this.space)
+            throw new Error(`Voxel geomtry look up must have space set`);
+        const hashed = this.space?.getIndex(x, y, z);
+        if (this.space.foundHash[hashed] == 0)
             this.hashState(dataCursor, hashed, x, y, z);
         return hashed;
     }
-    static hashState(dataCursor, hashed, x, y, z) {
-        if (this.stateCache[hashed] !== undefined)
-            return this.stateCache[hashed];
+    static hashState(dataCursor, index, x, y, z) {
+        if (!this.space)
+            throw new Error(`Voxel geomtry look up must have space set`);
+        if (this.space.foundHash[index] == 2)
+            return this.space.stateCache[index];
         const voxel = dataCursor.getVoxel(x, y, z);
         if (!voxel) {
-            this.stateCache[hashed] = -1;
+            this.space.foundHash[index] = 1;
             return -1;
         }
         if (!voxel.isRenderable()) {
-            this.stateCache[hashed] = -1;
+            this.space.foundHash[index] = 1;
             return -1;
         }
         const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getId()];
+        this.space.voxelHash[index] = voxel.getId();
         if (!voxelConstructor || !voxelConstructor.isModel) {
-            this.stateCache[hashed] = -1;
+            this.space.foundHash[index] = 1;
             return -1;
         }
+        this.space.foundHash[index] = 2;
         //no ao
-        this.noCastAO[hashed] = voxel.isLightSource() || voxel.noAO();
+        this.space.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
         //state
-        const shapeState = voxel.getShapeState();
+        const shapeState = voxel.getState();
         const state = voxelConstructor.shapeStateTree.getState(shapeState);
-        this.stateCache[hashed] = state;
+        this.space.stateCache[index] = state;
         //mod
         const mod = voxel.getMod();
         const modState = voxelConstructor.modTree.getState(mod);
-        this.modCache[hashed] = modState;
+        this.space.modCache[index] = modState;
         this.voxelCursor.copy(voxel).process();
         voxelConstructor.schema.position.x = x;
         voxelConstructor.schema.position.y = y;
@@ -69,12 +108,7 @@ export class VoxelGeometryLookUp {
         voxelConstructor.schema.voxel = this.voxelCursor;
         voxelConstructor.schema.dataCursor = dataCursor;
         const conditonalState = voxelConstructor.condtioanlShapeStateTree.getState();
-        this.voxelHash[hashed] = voxelConstructor;
-        this.conditonalStateCache[hashed] = conditonalState;
-        this.geometryCache[hashed] =
-            voxelConstructor.data.shapeStateGeometryMap[state];
-        this.conditionalGeometryCache[hashed] =
-            voxelConstructor.data.condiotnalShapeStateGeometryMap[conditonalState];
+        this.space.conditonalStateCache[index] = conditonalState;
         return state;
     }
 }

package/Mesher/Models/VoxelModelConstructorRegister.d.ts

@@ -1,5 +1,5 @@
 import { StringPalette } from "../../Util/StringPalette";
-import { VoxelGeometryRulelessSyncData, VoxelGeometrySyncData, VoxelModelSyncData } from "../../Voxels/VoxelSyncData";
+import { CompiledVoxelGeometryRulessData, CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../Voxels/Types/VoxelModelCompiledData.types";
 import { GeoemtryNodeConstructor } from "./Nodes/GeometryNode";
 import { VoxelConstructor } from "./VoxelConstructor";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
@@ -8,14 +8,14 @@ export declare class VoxelModelConstructorRegister {
     static geometry: VoxelGeometryConstructor[];
     static rulesless: boolean[];
     static setGeometryPalette(palette: string[]): void;
-    static modelData: Map<string, VoxelModelSyncData>;
+    static modelData: Map<string, CompiledVoxelModelData>;
     static customNodes: Map<string, GeoemtryNodeConstructor<any, any>>;
-    static registerModels(models: VoxelModelSyncData[]): void;
+    static registerModels(models: CompiledVoxelModelData[]): void;
     static registerCustomNode(id: string, node: GeoemtryNodeConstructor<any, any>): void;
     static getCustomNode(id: string): GeoemtryNodeConstructor<any, any>;
     static constructorsPaltte: VoxelConstructor[];
     static constructors: Map<string, VoxelConstructor>;
     static getConstructor(id: string): VoxelConstructor;
     static registerVoxel(voxel: VoxelConstructor | VoxelConstructor[]): void;
-    static registerGeometry(geometries: (VoxelGeometrySyncData | VoxelGeometryRulelessSyncData)[]): void;
+    static registerGeometry(geometries: (CompiledVoxelGeometrySyncData | CompiledVoxelGeometryRulessData)[]): void;
 }

package/Mesher/Models/VoxelModelConstructorRegister.js

@@ -1,4 +1,4 @@
-import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette";
 import { StringPalette } from "../../Util/StringPalette";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
 export class VoxelModelConstructorRegister {

package/Mesher/RenderedMaterials.d.ts

@@ -0,0 +1,6 @@
+import { VoxelMesherDataTool } from "./Tools/VoxelMesherDataTool";
+export declare class RenderedMaterials {
+    static meshersMap: Map<string, VoxelMesherDataTool>;
+    static meshers: VoxelMesherDataTool[];
+    static register(materials: string[]): void;
+}

package/Mesher/RenderedMaterials.js

@@ -0,0 +1,12 @@
+import { VoxelMesherDataTool } from "./Tools/VoxelMesherDataTool";
+export class RenderedMaterials {
+    static meshersMap = new Map();
+    static meshers = [];
+    static register(materials) {
+        for (let i = 0; i < materials.length; i++) {
+            const newTool = new VoxelMesherDataTool(materials[i], i);
+            this.meshersMap.set(materials[i], newTool);
+            this.meshers[i] = newTool;
+        }
+    }
+}

package/Mesher/Tools/OutlinedVoxelTool.d.ts

@@ -1,15 +1,6 @@
-import { VoxelMesherDataTool } from "./VoxelMesherDataTool.js";
-import type { ConstructorTextureData } from "../../Textures/Constructor.types.js";
+import type { TextureId } from "../../Textures/Texture.types.js";
 export declare class OutlinedVoxelTool {
     static _currentTexts: number[];
     static setCurrentTextures(textures: number[]): void;
-    static addTo: {
-        top: (tool: VoxelMesherDataTool) => void;
-        bottom: (tool: VoxelMesherDataTool) => void;
-        north: (tool: VoxelMesherDataTool) => void;
-        south: (tool: VoxelMesherDataTool) => void;
-        east: (tool: VoxelMesherDataTool) => void;
-        west: (tool: VoxelMesherDataTool) => void;
-    };
-    static getOutlineUVs(texture: ConstructorTextureData, onRegister: (uvs: number[]) => void): void;
+    static getOutlineUVs(texture: TextureId, onRegister: (uvs: number[]) => void): void;
 }

package/Mesher/Tools/OutlinedVoxelTool.js

@@ -1,4 +1,4 @@
-import { VoxelFaceDirections, VoxelFaces } from "../../Math/index.js";
+import { VoxelFaces } from "../../Math/index.js";
 /*
 0 -> normal direction
 1 -> top right
@@ -131,50 +131,80 @@ export class OutlinedVoxelTool {
     static setCurrentTextures(textures) {
         this._currentTexts = textures;
     }
-    static addTo = {
-        top: (tool) => {
-            const normal = VoxelFaceDirections[VoxelFaces.Up];
-            const set = CheckSets[VoxelFaces.Up];
-            tool
-                .getOverlayTextures()
-                .set(generateCheck("north", tool, normal, set.north), generateCheck("south", tool, normal, set.south), generateCheck("east", tool, normal, set.east), generateCheck("west", tool, normal, set.west));
+    /*   static addTo = {
+        top: (tool: VoxelMesherDataTool) => {
+          const normal = VoxelFaceDirections[VoxelFaces.Up];
+          const set = CheckSets[VoxelFaces.Up];
+          tool
+            .getOverlayTextures()
+            .set(
+              generateCheck("north", tool, normal, set.north),
+              generateCheck("south", tool, normal, set.south),
+              generateCheck("east", tool, normal, set.east),
+              generateCheck("west", tool, normal, set.west)
+            );
         },
-        bottom: (tool) => {
-            const normal = VoxelFaceDirections[VoxelFaces.Down];
-            const set = CheckSets[VoxelFaces.Down];
-            tool
-                .getOverlayTextures()
-                .set(generateCheck("north", tool, normal, set.north), generateCheck("south", tool, normal, set.south), generateCheck("east", tool, normal, set.east), generateCheck("west", tool, normal, set.west));
+        bottom: (tool: VoxelMesherDataTool) => {
+          const normal = VoxelFaceDirections[VoxelFaces.Down];
+          const set = CheckSets[VoxelFaces.Down];
+          tool
+            .getOverlayTextures()
+            .set(
+              generateCheck("north", tool, normal, set.north),
+              generateCheck("south", tool, normal, set.south),
+              generateCheck("east", tool, normal, set.east),
+              generateCheck("west", tool, normal, set.west)
+            );
         },
-        north: (tool) => {
-            const normal = VoxelFaceDirections[VoxelFaces.North];
-            const set = CheckSets[VoxelFaces.North];
-            tool
-                .getOverlayTextures()
-                .set(generateCheck("top", tool, normal, set.top), generateCheck("bottom", tool, normal, set.bottom), generateCheck("left", tool, normal, set.left), generateCheck("right", tool, normal, set.right));
+        north: (tool: VoxelMesherDataTool) => {
+          const normal = VoxelFaceDirections[VoxelFaces.North];
+          const set = CheckSets[VoxelFaces.North];
+          tool
+            .getOverlayTextures()
+            .set(
+              generateCheck("top", tool, normal, set.top),
+              generateCheck("bottom", tool, normal, set.bottom),
+              generateCheck("left", tool, normal, set.left),
+              generateCheck("right", tool, normal, set.right)
+            );
         },
-        south: (tool) => {
-            const normal = VoxelFaceDirections[VoxelFaces.South];
-            const set = CheckSets[VoxelFaces.South];
-            tool
-                .getOverlayTextures()
-                .set(generateCheck("top", tool, normal, set.top), generateCheck("bottom", tool, normal, set.bottom), generateCheck("left", tool, normal, set.left), generateCheck("right", tool, normal, set.right));
+        south: (tool: VoxelMesherDataTool) => {
+          const normal = VoxelFaceDirections[VoxelFaces.South];
+          const set = CheckSets[VoxelFaces.South];
+          tool
+            .getOverlayTextures()
+            .set(
+              generateCheck("top", tool, normal, set.top),
+              generateCheck("bottom", tool, normal, set.bottom),
+              generateCheck("left", tool, normal, set.left),
+              generateCheck("right", tool, normal, set.right)
+            );
         },
-        east: (tool) => {
-            const normal = VoxelFaceDirections[VoxelFaces.East];
-            const set = CheckSets[VoxelFaces.East];
-            tool
-                .getOverlayTextures()
-                .set(generateCheck("top", tool, normal, set.top), generateCheck("bottom", tool, normal, set.bottom), generateCheck("left", tool, normal, set.left), generateCheck("right", tool, normal, set.right));
+        east: (tool: VoxelMesherDataTool) => {
+          const normal = VoxelFaceDirections[VoxelFaces.East];
+          const set = CheckSets[VoxelFaces.East];
+          tool
+            .getOverlayTextures()
+            .set(
+              generateCheck("top", tool, normal, set.top),
+              generateCheck("bottom", tool, normal, set.bottom),
+              generateCheck("left", tool, normal, set.left),
+              generateCheck("right", tool, normal, set.right)
+            );
         },
-        west: (tool) => {
-            const normal = VoxelFaceDirections[VoxelFaces.West];
-            const set = CheckSets[VoxelFaces.West];
-            tool
-                .getOverlayTextures()
-                .set(generateCheck("top", tool, normal, set.top), generateCheck("bottom", tool, normal, set.bottom), generateCheck("left", tool, normal, set.left), generateCheck("right", tool, normal, set.right));
+        west: (tool: VoxelMesherDataTool) => {
+          const normal = VoxelFaceDirections[VoxelFaces.West];
+          const set = CheckSets[VoxelFaces.West];
+          tool
+            .getOverlayTextures()
+            .set(
+              generateCheck("top", tool, normal, set.top),
+              generateCheck("bottom", tool, normal, set.bottom),
+              generateCheck("left", tool, normal, set.left),
+              generateCheck("right", tool, normal, set.right)
+            );
         },
-    };
+      }; */
     static getOutlineUVs(texture, onRegister) {
         const overlayTextures = [];
         /*     DVEMesher.observers.texturesRegistered.subscribeOnce((textureManager) => {

package/Mesher/Tools/VoxelMeshBVHBuilder.d.ts

@@ -80,6 +80,6 @@ export declare class VoxelMeshBVHBuilder {
     structCursor: StructCursor;
     indices: Uint32Array;
     reset(): void;
-    updateVoxel(voxelX: number, voxelY: number, voxelZ: number, indicesStart: number, indicesEnd: number, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
+    updateVoxel(voxelX: number, voxelY: number, voxelZ: number, meshIndex: number, indicesStart: number, indicesEnd: number, minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
 }
 export {};