@divinevoxel/vlox 0.0.71 → 0.0.73

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

@@ -4,7 +4,6 @@ import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcC
 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 {
@@ -14,8 +13,6 @@ export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
         [0, 0, 0],
     ];
     vertexWeights;
-    worldLight;
-    worldAO;
     closestFace;
     lightData = new VoxelLightData();
     init() {
@@ -28,11 +25,11 @@ export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
         this.closestFace = closestFace;
     }
     determineShading() {
-        const tool = this.tool;
+        const tool = this.builder;
         const lightData = tool.lightData[VoxelFaces.Up];
-        const noAO = this.tool.voxel.isLightSource() || this.tool.voxel.noAO();
-        const worldLight = this.worldLight;
-        const worldAO = this.worldAO;
+        const noAO = this.builder.voxel.isLightSource() || this.builder.voxel.noAO();
+        const worldLight = this.builder.vars.light;
+        const worldAO = this.builder.vars.ao;
         for (let v = 0; v < 4; v++) {
             worldAO.vertices[v] = 0;
             worldLight.vertices[v] = getInterpolationValue(lightData, this.vertexWeights[v]);
@@ -41,40 +38,40 @@ export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
         }
     }
     shouldFlip() {
-        if (shouldCauseFlip(this.worldAO.vertices[0], this.worldAO.vertices[1], this.worldAO.vertices[2], this.worldAO.vertices[3]))
+        const worldLight = this.builder.vars.light;
+        const worldAO = this.builder.vars.ao;
+        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]))
             return true;
-        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])));
+        return (shouldCauseFlip(this.lightData.getS(worldLight.vertices[0]), this.lightData.getS(worldLight.vertices[1]), this.lightData.getS(worldLight.vertices[2]), this.lightData.getS(worldLight.vertices[3])) ||
+            shouldCauseFlip(this.lightData.sumRGB(worldLight.vertices[0]), this.lightData.sumRGB(worldLight.vertices[1]), this.lightData.sumRGB(worldLight.vertices[2]), this.lightData.sumRGB(worldLight.vertices[3])));
     }
-    add(tool, originHash, origin, args) {
-        this.tool = tool;
-        this.origin = tool.position;
-        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.vars.textureIndex = args[ArgIndexes.Texture];
-            quad.doubleSided = args[ArgIndexes.DoubleSided];
-            const uvs = args[ArgIndexes.UVs];
-            //1
-            quad.uvs.vertices[0].x = uvs[0][0];
-            quad.uvs.vertices[0].y = uvs[0][1];
-            //2
-            quad.uvs.vertices[1].x = uvs[1][0];
-            quad.uvs.vertices[1].y = uvs[1][1];
-            //3
-            quad.uvs.vertices[2].x = uvs[2][0];
-            quad.uvs.vertices[2].y = uvs[2][1];
-            //4
-            quad.uvs.vertices[3].x = uvs[3][0];
-            quad.uvs.vertices[3].y = uvs[3][1];
-            VoxelGeometryBuilder.addQuad(tool, origin, quad);
-            UpdateBounds(tool, origin, this.quadBounds);
-        }
-        this.worldLight.setAll(0);
-        this.worldAO.setAll(0);
+    add(args) {
+        if (!args[ArgIndexes.Enabled])
+            return false;
+        const tool = this.builder;
+        tool.calculateFaceData(this.closestFace);
+        this.determineShading();
+        const quad = this.quad;
+        quad.flip = this.shouldFlip() || args[ArgIndexes.Fliped];
+        tool.vars.textureIndex = args[ArgIndexes.Texture];
+        quad.doubleSided = args[ArgIndexes.DoubleSided];
+        const uvs = args[ArgIndexes.UVs];
+        //1
+        quad.uvs.vertices[0].x = uvs[0][0];
+        quad.uvs.vertices[0].y = uvs[0][1];
+        //2
+        quad.uvs.vertices[1].x = uvs[1][0];
+        quad.uvs.vertices[1].y = uvs[1][1];
+        //3
+        quad.uvs.vertices[2].x = uvs[2][0];
+        quad.uvs.vertices[2].y = uvs[2][1];
+        //4
+        quad.uvs.vertices[3].x = uvs[3][0];
+        quad.uvs.vertices[3].y = uvs[3][1];
+        VoxelGeometryBuilder.addQuad(tool, tool.position, quad);
+        this.builder.updateBounds(this.quadBounds);
+        this.builder.vars.light.setAll(0);
+        this.builder.vars.ao.setAll(0);
+        return true;
     }
 }

package/Mesher/{Tools → Models/Protocols}/OutlinedVoxelTool.d.ts

@@ -1,4 +1,4 @@
-import type { TextureId } from "../../Textures/Texture.types.js";
+import type { TextureId } from "../../../Textures/Texture.types.js";
 export declare class OutlinedVoxelTool {
     static _currentTexts: number[];
     static setCurrentTextures(textures: number[]): void;

package/Mesher/{Tools → Models/Protocols}/OutlinedVoxelTool.js

@@ -1,4 +1,4 @@
-import { VoxelFaces } from "../../Math/index.js";
+import { VoxelFaces } from "../../../Math/index.js";
 /*
 0 -> normal direction
 1 -> top right

package/Mesher/Models/RenderedMaterials.d.ts

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

package/Mesher/{RenderedMaterials.js → Models/RenderedMaterials.js}

@@ -1,10 +1,10 @@
-import { VoxelMesherDataTool } from "./Tools/VoxelMesherDataTool";
+import { VoxelModelBuilder } from "./VoxelModelBuilder";
 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);
+            const newTool = new VoxelModelBuilder(materials[i], i);
             this.meshersMap.set(materials[i], newTool);
             this.meshers[i] = newTool;
         }

package/Mesher/Models/VoxelConstructor.d.ts

@@ -1,5 +1,4 @@
-import { TextureRegister } from "../../Textures/TextureRegister";
-import { VoxelMesherDataTool } from "../../Mesher/Tools/VoxelMesherDataTool";
+import { VoxelModelBuilder } from "./VoxelModelBuilder";
 import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Types/VoxelModelCompiledData.types";
 import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
 import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
@@ -8,6 +7,7 @@ import { VoxelModelEffect } from "./VoxelModelEffect";
 import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
 export declare class VoxelConstructor {
     id: string;
+    builder: VoxelModelBuilder;
     data: CompiledVoxelModelData;
     isModel: true;
     geometries: number[][];
@@ -20,9 +20,8 @@ export declare class VoxelConstructor {
     effects: VoxelModelEffect;
     shapeStateTree: StateTreeReader;
     condtioanlShapeStateTree: CondtionalTreeReader;
-    constructor(id: string, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
+    constructor(id: string, builder: VoxelModelBuilder, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
     isShapeStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
     isCondtionalStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
-    process(tool: VoxelMesherDataTool): void;
-    onTexturesRegistered(textureManager: typeof TextureRegister): void;
+    process(): boolean;
 }

package/Mesher/Models/VoxelConstructor.js

@@ -1,5 +1,4 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
-import { VoxelGeometryLookUp } from "./VoxelGeometryLookUp";
 import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
 import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
 import { VoxelFaceTransparentResultsIndex } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
@@ -7,6 +6,7 @@ import { VoxelModelEffect } from "./VoxelModelEffect";
 import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
 export class VoxelConstructor {
     id;
+    builder;
     data;
     isModel = true;
     geometries = [];
@@ -19,8 +19,9 @@ export class VoxelConstructor {
     effects;
     shapeStateTree;
     condtioanlShapeStateTree;
-    constructor(id, data, voxleData) {
+    constructor(id, builder, data, voxleData) {
         this.id = id;
+        this.builder = builder;
         this.data = data;
         this.baseInputMap = voxleData.baseGeometryInputMap;
         this.conditonalInputMap = voxleData.condiotnalGeometryInputMap;
@@ -38,10 +39,12 @@ export class VoxelConstructor {
     isCondtionalStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
         return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[shapeState][geoId]], faceIndex) == 1);
     }
-    process(tool) {
-        const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x, tool.position.y, tool.position.z);
-        const treeState = VoxelGeometryLookUp.space.stateCache[hashed];
-        const modState = VoxelGeometryLookUp.space.modCache[hashed];
+    process() {
+        let added = false;
+        const builder = this.builder;
+        const hashed = builder.space.getHash(builder.nVoxel, builder.position.x, builder.position.y, builder.position.z);
+        const treeState = builder.space.stateCache[hashed];
+        const modState = builder.space.modCache[hashed];
         if (treeState > -1) {
             const geoLinks = this.data.shapeStateMap[treeState];
             const geometries = this.data.shapeStateGeometryMap[treeState];
@@ -53,11 +56,15 @@ export class VoxelConstructor {
                 const geomtry = VoxelModelConstructorRegister.geometry[geometries[i]];
                 const nodesLength = geomtry.nodes.length;
                 for (let k = 0; k < nodesLength; k++) {
-                    geomtry.nodes[k].add(tool, hashed, tool.origin, geoInputs[k]);
+                    const geo = geomtry.nodes[k];
+                    geo.builder = this.builder;
+                    const addedGeo = geo.add(geoInputs[k]);
+                    if (addedGeo)
+                        added = true;
                 }
             }
         }
-        const conditonalTreeState = VoxelGeometryLookUp.space.conditonalStateCache[hashed];
+        const conditonalTreeState = builder.space.conditonalStateCache[hashed];
         if (conditonalTreeState > -1) {
             const condiotnalNodes = this.data.condiotnalShapeStateMap[conditonalTreeState];
             const condiotnalNodesLength = condiotnalNodes.length;
@@ -71,13 +78,17 @@ export class VoxelConstructor {
                     const geomtry = VoxelModelConstructorRegister.geometry[this.data.geoLinkMap[nodeId]];
                     const nodesLength = geomtry.nodes.length;
                     for (let k = 0; k < nodesLength; k++) {
-                        geomtry.nodes[k].add(tool, hashed, tool.origin, geoInputs[k]);
+                        const geo = geomtry.nodes[k];
+                        geo.builder = this.builder;
+                        const addedGeo = geo.add(geoInputs[k]);
+                        if (addedGeo)
+                            added = true;
                     }
                 }
             }
         }
-        this.effects.addEffects(tool.voxel.getState(), tool.origin, tool.effects);
-        tool.clearCalculatedData();
+        this.effects.addEffects(builder.voxel.getState(), builder.origin, builder.effects);
+        builder.clearCalculatedData();
+        return added;
     }
-    onTexturesRegistered(textureManager) { }
 }

package/Mesher/Models/{VoxelGeometryLookUp.d.ts → VoxelGeometryBuilderCacheSpace.d.ts}

@@ -1,30 +1,22 @@
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { Vec3Array, Vector3Like } from "@amodx/math";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
-export declare class VoxelGeometryLookUpSpace {
+export declare class VoxelGeometryBuilderCacheSpace {
     bounds: Vector3Like;
     foundHash: Uint8Array;
-    voxelHash: Uint16Array;
+    voxelCache: Uint16Array;
     modCache: Int32Array;
     stateCache: Int32Array;
     conditonalStateCache: Int32Array;
     noCastAO: Uint8Array;
     offset: Vec3Array;
+    voxelCursor: VoxelCursor;
     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 space: VoxelGeometryLookUpSpace | null;
-    static voxelCursor: VoxelCursor;
-    static createSpace(x: number, y: number, z: number): VoxelGeometryLookUpSpace;
-    static init(): 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;
-    private static hashState;
+    getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
+    private hashState;
 }

package/Mesher/Models/{VoxelGeometryLookUp.js → VoxelGeometryBuilderCacheSpace.js}

@@ -1,20 +1,21 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
 import { GetYXZOrderArrayIndex } from "../../Math/Indexing";
-export class VoxelGeometryLookUpSpace {
+export class VoxelGeometryBuilderCacheSpace {
     bounds;
     foundHash;
-    voxelHash;
+    voxelCache;
     modCache;
     stateCache;
     conditonalStateCache;
     noCastAO;
     offset = [0, 0, 0];
+    voxelCursor = new VoxelCursor();
     constructor(bounds) {
         this.bounds = bounds;
         const volume = bounds.x * bounds.y * bounds.z;
         this.foundHash = new Uint8Array(volume);
-        this.voxelHash = new Uint16Array(volume);
+        this.voxelCache = new Uint16Array(volume);
         this.modCache = new Int32Array(volume);
         this.stateCache = new Int32Array(volume);
         this.conditonalStateCache = new Int32Array(volume);
@@ -25,7 +26,7 @@ export class VoxelGeometryLookUpSpace {
         this.offset[1] = y;
         this.offset[2] = z;
         this.foundHash.fill(0);
-        this.voxelHash.fill(0);
+        this.voxelCache.fill(0);
         this.modCache.fill(-1);
         this.stateCache.fill(-1);
         this.conditonalStateCache.fill(-1);
@@ -35,72 +36,53 @@ export class VoxelGeometryLookUpSpace {
         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)
+        if (this.foundHash[index] < 2)
             return null;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]];
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]];
     }
     getGeomtry(index) {
-        if (this.foundHash[index] !== 2)
+        if (this.foundHash[index] < 2)
             return false;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]].data.shapeStateGeometryMap[this.stateCache[index]];
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.shapeStateGeometryMap[this.stateCache[index]];
     }
     getConditionalGeomtry(index) {
-        if (this.foundHash[index] !== 2)
+        if (this.foundHash[index] < 2)
             return false;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelHash[index]].data.condiotnalShapeStateGeometryMap[this.conditonalStateCache[index]];
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[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() { }
-    static getHash(dataCursor, x, y, z) {
-        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) {
+    getHash(dataCursor, x, y, z) {
+        const hashed = this.getIndex(x, y, z);
+        if (this.foundHash[hashed] == 0) {
             this.hashState(dataCursor, hashed, x, y, z);
         }
         return 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] == 1)
+    hashState(dataCursor, index, x, y, z) {
+        if (this.foundHash[index] == 1)
             return -1;
-        if (this.space.foundHash[index] == 2)
-            return this.space.stateCache[index];
+        if (this.foundHash[index] == 2)
+            return this.stateCache[index];
         const voxel = dataCursor.getVoxel(x, y, z);
         if (!voxel || !voxel.isRenderable()) {
-            this.space.foundHash[index] = 1;
+            this.foundHash[index] = 1;
             return -1;
         }
         const voxelId = voxel.getId();
         const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxelId];
         if (!voxelConstructor) {
-            this.space.foundHash[index] = 1;
+            this.foundHash[index] = 1;
             return -1;
         }
-        this.space.voxelHash[index] = voxelId;
-        this.space.foundHash[index] = 2;
+        this.voxelCache[index] = voxelId;
+        this.foundHash[index] = 2;
         //no ao
-        this.space.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
+        this.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
         //state
         const state = voxelConstructor.shapeStateTree.getState(voxel.getState());
-        this.space.stateCache[index] = state;
+        this.stateCache[index] = state;
         //mod
         const mod = voxelConstructor.modTree.getState(voxel.getMod());
-        this.space.modCache[index] = mod;
+        this.modCache[index] = mod;
         this.voxelCursor.copy(voxel).process();
         voxelConstructor.schema.position.x = x;
         voxelConstructor.schema.position.y = y;
@@ -108,7 +90,7 @@ export class VoxelGeometryLookUp {
         voxelConstructor.schema.voxel = this.voxelCursor;
         voxelConstructor.schema.dataCursor = dataCursor;
         const conditonalState = voxelConstructor.condtioanlShapeStateTree.getState();
-        this.space.conditonalStateCache[index] = conditonalState;
+        this.conditonalStateCache[index] = conditonalState;
         return 1;
     }
 }

package/Mesher/{Tools/VoxelMesherDataTool.d.ts → Models/VoxelModelBuilder.d.ts}

@@ -1,25 +1,26 @@
-import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
 import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces } from "../../Math";
 import { QuadVerticies } from "../Geomtry/Geometry.types";
 import { VoxelMesh } from "../Geomtry/VoxelMesh";
-import { VoxelMeshBVHBuilder } from "./VoxelMeshBVHBuilder";
-import { Vec3Array, Vector3Like } from "@amodx/math";
+import { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
+import { Vec3Array, Vector3Like, Vector4Like } from "@amodx/math";
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.js";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface.js";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface.js";
+import { VoxelGeometryBuilderCacheSpace } from "./VoxelGeometryBuilderCacheSpace";
 declare class VoxelVars {
     faceFlipped: boolean;
     textureIndex: number;
+    overlayTextures: Vector4Like;
     light: QuadScalarVertexData;
     ao: QuadScalarVertexData;
     animation: QuadScalarVertexData;
     level: QuadScalarVertexData;
-    overlayTextures: QuadScalarVertexData;
     reset(): void;
 }
-export declare class VoxelMesherDataTool extends MesherDataTool {
+export declare class VoxelModelBuilder {
     id: string;
     materialIndex: number;
+    space: VoxelGeometryBuilderCacheSpace;
     voxel: VoxelCursorInterface;
     nVoxel: DataCursorInterface;
     /**The current world position */
@@ -41,9 +42,10 @@ export declare class VoxelMesherDataTool extends MesherDataTool {
     _indexStart: number;
     startConstruction(): void;
     endConstruction(): boolean;
+    _boundsUpdate: boolean;
+    updateBounds(bounds: [Vec3Array, Vec3Array]): void;
     calculateFaceData(direction: VoxelFaces): true | undefined;
     clearCalculatedData(): void;
-    reset(): void;
-    resetAll(): this;
+    clear(): this;
 }
 export {};

package/Mesher/{Tools/VoxelMesherDataTool.js → Models/VoxelModelBuilder.js}

@@ -1,28 +1,31 @@
 //tools
-import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
 //data
 import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces, VoxelFacesArray } from "../../Math";
 import { QuadVerticies } from "../Geomtry/Geometry.types";
-import { FaceDataCalc } from "../Models/Common/Calc/FaceDataCalc.js";
+import calculateFaceData from "./Common/Calc/FaceDataCalc.js";
 import { VoxelMesh } from "../Geomtry/VoxelMesh";
-import { Vector3Like } from "@amodx/math";
+import { Vector3Like, Vector4Like } from "@amodx/math";
 class VoxelVars {
     faceFlipped = false;
     textureIndex = 0;
+    overlayTextures = Vector4Like.Create();
     light = new QuadScalarVertexData();
     ao = new QuadScalarVertexData();
     animation = new QuadScalarVertexData();
     level = new QuadScalarVertexData();
-    overlayTextures = new QuadScalarVertexData();
     reset() {
         this.faceFlipped = false;
         this.textureIndex = 0;
+        this.overlayTextures.x = 0;
+        this.overlayTextures.y = 0;
+        this.overlayTextures.z = 0;
     }
 }
-export class VoxelMesherDataTool extends MesherDataTool {
+export class VoxelModelBuilder {
     id;
     materialIndex;
+    space;
     voxel;
     nVoxel;
     /**The current world position */
@@ -37,11 +40,10 @@ export class VoxelMesherDataTool extends MesherDataTool {
     lightData;
     effects;
     constructor(id, materialIndex) {
-        super();
-        this.id = id;
-        this.materialIndex = materialIndex;
         //  this.faceDataOverride.currentVoxel = this.voxel;
         //  this.faceDataOverride.neighborVoxel = this.nVoxel;
+        this.id = id;
+        this.materialIndex = materialIndex;
         this.dataCalculated = [];
         for (const face of VoxelFacesArray) {
             this.dataCalculated[face] = false;
@@ -70,7 +72,6 @@ export class VoxelMesherDataTool extends MesherDataTool {
             this.lightData[face][QuadVerticies.BottomLeft] = 0;
             this.lightData[face][QuadVerticies.BottomRight] = 0;
         }
-        this.startNewMesh(new VoxelMesh());
     }
     bounds = {
         min: [0, 0, 0],
@@ -78,27 +79,54 @@ export class VoxelMesherDataTool extends MesherDataTool {
     };
     _indexStart = 0;
     startConstruction() {
-        this._indexStart = this.mesh.indices.length;
+        this._indexStart = this.mesh.indicieCount;
         this.bounds.min[0] = Infinity;
         this.bounds.min[1] = Infinity;
         this.bounds.min[2] = Infinity;
         this.bounds.max[0] = -Infinity;
         this.bounds.max[1] = -Infinity;
         this.bounds.max[2] = -Infinity;
+        this._boundsUpdate = true;
     }
     endConstruction() {
-        if (this.bounds.min.includes(Infinity) ||
-            this.bounds.max.includes(-Infinity))
-            return false;
+        this.vars.reset();
         if (this.bvhTool) {
-            this.bvhTool.updateVoxel(this.position.x, this.position.y, this.position.z, this._indexStart, this.materialIndex, this.mesh.indices.length, this.bounds.min[0], this.bounds.min[1], this.bounds.min[2], this.bounds.max[0], this.bounds.max[1], this.bounds.max[2]);
+            if (!this._boundsUpdate)
+                return false;
+            this.bvhTool.updateVoxel(this.position.x, this.position.y, this.position.z, this._indexStart, this.materialIndex, this.mesh.indicieCount, this.bounds.min[0], this.bounds.min[1], this.bounds.min[2], this.bounds.max[0], this.bounds.max[1], this.bounds.max[2]);
+            this.bvhTool.structCursor.setIndex(0);
+            this.mesh.minBounds.x = this.bvhTool.structCursor.minX;
+            this.mesh.minBounds.y = this.bvhTool.structCursor.minY;
+            this.mesh.minBounds.z = this.bvhTool.structCursor.minZ;
+            this.mesh.maxBounds.x = this.bvhTool.structCursor.maxX;
+            this.mesh.maxBounds.y = this.bvhTool.structCursor.maxY;
+            this.mesh.maxBounds.z = this.bvhTool.structCursor.maxZ;
         }
         return true;
     }
+    _boundsUpdate = false;
+    updateBounds(bounds) {
+        const origin = this.origin;
+        //min
+        if (origin.x + bounds[0][0] < this.bounds.min[0])
+            this.bounds.min[0] = origin.x + bounds[0][0];
+        if (origin.y + bounds[0][1] < this.bounds.min[1])
+            this.bounds.min[1] = origin.y + bounds[0][1];
+        if (origin.z + bounds[0][2] < this.bounds.min[2])
+            this.bounds.min[2] = origin.z + bounds[0][2];
+        //max
+        if (origin.x + bounds[1][0] > this.bounds.max[0])
+            this.bounds.max[0] = origin.x + bounds[1][0];
+        if (origin.y + bounds[1][1] > this.bounds.max[1])
+            this.bounds.max[1] = origin.y + bounds[1][1];
+        if (origin.z + bounds[1][2] > this.bounds.max[2])
+            this.bounds.max[2] = origin.z + bounds[1][2];
+        this._boundsUpdate = true;
+    }
     calculateFaceData(direction) {
         if (this.dataCalculated[direction])
             return true;
-        FaceDataCalc.calculate(direction, this);
+        calculateFaceData(direction, this);
         this.dataCalculated[direction] = true;
     }
     clearCalculatedData() {
@@ -109,10 +137,7 @@ export class VoxelMesherDataTool extends MesherDataTool {
         this.dataCalculated[VoxelFaces.East] = false;
         this.dataCalculated[VoxelFaces.West] = false;
     }
-    reset() {
-        this.vars.reset();
-    }
-    resetAll() {
+    clear() {
         this.vars.reset();
         this.mesh.clear();
         return this;

package/Mesher/Models/VoxelModelConstructorRegister.js

@@ -1,6 +1,6 @@
-import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette";
 import { StringPalette } from "../../Util/StringPalette";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
 export class VoxelModelConstructorRegister {
     static geometryPalette;
     static geometry = [];
@@ -31,11 +31,11 @@ export class VoxelModelConstructorRegister {
         if (Array.isArray(voxel)) {
             for (const vox of voxel) {
                 this.constructors.set(vox.id, vox);
-                this.constructorsPaltte[VoxelPalette.ids.getNumberId(vox.id)] = vox;
+                this.constructorsPaltte[VoxelPalettesRegister.voxels.getNumberId(vox.id)] = vox;
             }
             return;
         }
-        this.constructorsPaltte[VoxelPalette.ids.getNumberId(voxel.id)] = voxel;
+        this.constructorsPaltte[VoxelPalettesRegister.voxels.getNumberId(voxel.id)] = voxel;
         this.constructors.set(voxel.id, voxel);
     }
     static registerGeometry(geometries) {

package/Models/Defaults/CubeVoxelGeometry.js

@@ -42,6 +42,10 @@ export const cube = {
             type: "int",
             default: 0,
         },
+        northTexTransparent: {
+            type: "boolean",
+            default: false,
+        },
         southTex: {
             type: "texture",
         },