@divinevoxel/vlox 0.0.72 → 0.0.74

package/Mesher/Models/Nodes/Ruled/BoxVoxelGeometryNode.js

@@ -4,13 +4,14 @@ import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcC
 import { VoxelRelativeCubeIndexPositionMap } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
 import { GetBoxGeometryNodeData } from "../../Common/BoxGeometryNode";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
-import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelQuad, } from "../../../Geomtry/VoxelGeometryBuilder";
 import { VoxelModelConstructorRegister } from "../../../Models/VoxelModelConstructorRegister";
 const ArgIndexes = BoxVoxelGometryInputs.ArgIndexes;
 export class BoxVoxelGometryNode extends GeoemtryNode {
     quads;
     quadBounds = [];
     vertexWeights;
+    _wasAOShaded = false;
     lightData = new VoxelLightData();
     init() {
         this.faceCount = 6;
@@ -25,15 +26,15 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
         const faceIndexes = this.geomtry.faceCullMap[trueFaceIndex];
         if (!faceIndexes)
             return true;
-        const tool = this.builder;
+        const builder = this.builder;
         for (let positionIndex = 0; positionIndex < faceIndexes.length; positionIndex++) {
             const currentIndex = faceIndexes[positionIndex];
             const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
-            const hashed = this.builder.space.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
+            const hashed = this.builder.space.getHash(builder.nVoxel, builder.position.x + p[0], builder.position.y + p[1], builder.position.z + p[2]);
             if (this.builder.space.foundHash[hashed] < 2)
                 continue;
+            const constructor = this.builder.space.getConstructor(hashed);
             const offsetBaseGometry = this.builder.space.getGeomtry(hashed);
-            const offsetConditonalGeometry = this.builder.space.getConditionalGeomtry(hashed);
             if (offsetBaseGometry) {
                 for (let i = 0; i < offsetBaseGometry.length; i++) {
                     const geoId = offsetBaseGometry[i];
@@ -41,27 +42,24 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                         continue;
                     const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !this.builder
-                            .space.getConstructor(hashed)
-                            ?.isShapeStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex)) {
+                        !constructor.isShapeStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex)) {
                         return false;
                     }
                 }
             }
-            if (!offsetConditonalGeometry)
-                continue;
-            for (let i = 0; i < offsetConditonalGeometry.length; i++) {
-                const cond = offsetConditonalGeometry[i];
-                for (let k = 0; k < cond.length; k++) {
-                    const geoId = cond[k];
-                    if (VoxelModelConstructorRegister.rulesless[geoId])
-                        continue;
-                    const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
-                    if (faceIndex > -1 &&
-                        !this.builder
-                            .space.getConstructor(hashed)
-                            ?.isCondtionalStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex))
-                        return false;
+            const offsetConditonalGeometry = this.builder.space.getConditionalGeomtry(hashed);
+            if (offsetConditonalGeometry) {
+                for (let i = 0; i < offsetConditonalGeometry.length; i++) {
+                    const cond = offsetConditonalGeometry[i];
+                    for (let k = 0; k < cond.length; k++) {
+                        const geoId = cond[k];
+                        if (VoxelModelConstructorRegister.rulesless[geoId])
+                            continue;
+                        const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
+                        if (faceIndex > -1 &&
+                            !constructor.isCondtionalStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex))
+                            return false;
+                    }
                 }
             }
         }
@@ -99,21 +97,28 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                     length = baseGeo.length;
                     for (let geoIndex = 0; geoIndex < length; geoIndex++) {
                         if (this.geomtry.aoIndex.getValue(baseGeo[geoIndex], currentIndex, trueVertexIndex)) {
-                            worldAO.vertices[v] = 1;
-                            shaded = true;
-                            break;
+                            this._wasAOShaded = true;
+                            worldAO.vertices[v]++;
+                            if (worldAO.vertices[v] >= 3) {
+                                shaded = true;
+                                break;
+                            }
                         }
                     }
                 }
-                if (!conditonalGeo)
+                if (!conditonalGeo || shaded)
                     continue;
                 length = conditonalGeo.length;
                 for (let condtionsIndex = 0; condtionsIndex < length; condtionsIndex++) {
                     const condiotnalength = conditonalGeo[condtionsIndex].length;
                     for (let geoIndex = 0; geoIndex < condiotnalength; geoIndex++) {
                         if (this.geomtry.aoIndex.getValue(conditonalGeo[condtionsIndex][geoIndex], currentIndex, trueVertexIndex)) {
-                            worldAO.vertices[v] = 1;
-                            break;
+                            this._wasAOShaded = true;
+                            worldAO.vertices[v]++;
+                            if (worldAO.vertices[v] >= 3) {
+                                shaded = true;
+                                break;
+                            }
                         }
                     }
                 }
@@ -122,9 +127,12 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
     }
     shouldFlip() {
         const worldAO = this.builder.vars.ao;
-        const worldLight = this.builder.vars.light;
-        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]))
+        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]) &&
+            this._wasAOShaded)
             return true;
+        if (this._wasAOShaded)
+            return false;
+        const worldLight = this.builder.vars.light;
         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])));
     }
@@ -134,10 +142,10 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
         for (let face = 0; face < 6; face++) {
             if (args[face][ArgIndexes.Enabled] && this.isExposed(face)) {
                 added = true;
+                const quad = this.quads[face];
                 tool.calculateFaceData(face);
                 this.determineShading(face);
                 const faceArgs = args[face];
-                const quad = this.quads[face];
                 quad.flip = this.shouldFlip() || faceArgs[ArgIndexes.Fliped];
                 tool.vars.textureIndex = faceArgs[ArgIndexes.Texture];
                 const uvs = faceArgs[ArgIndexes.UVs];
@@ -153,12 +161,13 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                 //4
                 quad.uvs.vertices[3].x = uvs[3][0];
                 quad.uvs.vertices[3].y = uvs[3][1];
-                VoxelGeometryBuilder.addQuad(tool, this.builder.origin, quad);
+                addVoxelQuad(tool, this.builder.origin, quad);
                 tool.updateBounds(this.quadBounds[face]);
             }
         }
         this.builder.vars.ao.setAll(0);
         this.builder.vars.light.setAll(0);
+        this._wasAOShaded = false;
         return added;
     }
 }

package/Mesher/Models/Nodes/Ruled/QuadVoxelGeometryNode.js

@@ -1,5 +1,5 @@
 import { VoxelFaces } from "../../../../Math";
-import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelQuad } from "../../../Geomtry/VoxelGeometryBuilder";
 import { GeoemtryNode } from "../GeometryNode";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
 import { VoxelRelativeCubeIndexPositionMap } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
@@ -148,7 +148,7 @@ export class QuadVoxelGometryNode extends GeoemtryNode {
         //4
         quad.uvs.vertices[3].x = uvs[3][0];
         quad.uvs.vertices[3].y = uvs[3][1];
-        VoxelGeometryBuilder.addQuad(this.builder, this.builder.origin, quad);
+        addVoxelQuad(this.builder, this.builder.origin, quad);
         this.builder.updateBounds(this.quadBounds);
         this.builder.vars.light.setAll(0);
         this.builder.vars.ao.setAll(0);

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

@@ -1,4 +1,4 @@
-import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelQuad } from "../../../Geomtry/VoxelGeometryBuilder";
 import { BoxVoxelGometryInputs, } from "../../../../Models/Input/BoxVoxelGometryInputs";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
@@ -64,7 +64,7 @@ export class RulelessBoxVoxelGeometryNode extends GeoemtryNode {
                 //4
                 quad.uvs.vertices[3].x = uvs[3][0];
                 quad.uvs.vertices[3].y = uvs[3][1];
-                VoxelGeometryBuilder.addQuad(tool, tool.position, quad);
+                addVoxelQuad(tool, tool.position, quad);
                 this.builder.updateBounds(this.quadBounds[face]);
             }
         }

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

@@ -1,5 +1,5 @@
 import { VoxelFaces } from "../../../../Math";
-import { VoxelGeometryBuilder } from "../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelQuad, } from "../../../Geomtry/VoxelGeometryBuilder";
 import { getInterpolationValue, shouldCauseFlip, } from "../../Common/Calc/CalcConstants";
 import { QuadVoxelGometryInputs, } from "../../../../Models/Input/QuadVoxelGometryInputs";
 import { GeoemtryNode } from "../GeometryNode";
@@ -68,7 +68,7 @@ export class RulelessQuadVoxelGeometryNode extends GeoemtryNode {
         //4
         quad.uvs.vertices[3].x = uvs[3][0];
         quad.uvs.vertices[3].y = uvs[3][1];
-        VoxelGeometryBuilder.addQuad(tool, tool.position, quad);
+        addVoxelQuad(tool, tool.position, quad);
         this.builder.updateBounds(this.quadBounds);
         this.builder.vars.light.setAll(0);
         this.builder.vars.ao.setAll(0);

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,4 +1,4 @@
-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";
@@ -7,7 +7,7 @@ import { VoxelModelEffect } from "./VoxelModelEffect";
 import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
 export declare class VoxelConstructor {
     id: string;
-    builder: VoxelMesherDataTool;
+    builder: VoxelModelBuilder;
     data: CompiledVoxelModelData;
     isModel: true;
     geometries: number[][];
@@ -18,10 +18,10 @@ export declare class VoxelConstructor {
     conditonalInputMap: any[];
     schema: StateSchema;
     effects: VoxelModelEffect;
-    shapeStateTree: StateTreeReader;
+    stateTree: StateTreeReader;
     condtioanlShapeStateTree: CondtionalTreeReader;
-    constructor(id: string, builder: VoxelMesherDataTool, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
-    isShapeStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
-    isCondtionalStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
+    constructor(id: string, builder: VoxelModelBuilder, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
+    isShapeStateFaceTransparent(modState: number, stateTree: number, geoId: number, faceIndex: number): boolean;
+    isCondtionalStateFaceTransparent(modState: number, state: number, geoId: number, faceIndex: number): boolean;
     process(): boolean;
 }

package/Mesher/Models/VoxelConstructor.js

@@ -17,7 +17,7 @@ export class VoxelConstructor {
     conditonalInputMap;
     schema;
     effects;
-    shapeStateTree;
+    stateTree;
     condtioanlShapeStateTree;
     constructor(id, builder, data, voxleData) {
         this.id = id;
@@ -27,17 +27,17 @@ export class VoxelConstructor {
         this.conditonalInputMap = voxleData.condiotnalGeometryInputMap;
         this.transparentIndex = new VoxelFaceTransparentResultsIndex(voxleData.transparentFaceIndex);
         this.schema = new StateSchema(data.schema);
-        this.shapeStateTree = new StateTreeReader(this.schema, 0, data.shapeStateTree);
+        this.stateTree = new StateTreeReader(this.schema, 0, data.stateTree);
         this.condtioanlShapeStateTree = new CondtionalTreeReader(this.schema, data.condiotnalStatements, data.condiotnalStateTree);
         this.modSchema = new StateSchema(voxleData.modSchema);
         this.modTree = new StateTreeReader(this.modSchema, 0, voxleData.modStateTree);
         this.effects = new VoxelModelEffect(this);
     }
-    isShapeStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.shapeStateRelativeGeometryMap[shapeState][geoId]], faceIndex) == 1);
+    isShapeStateFaceTransparent(modState, stateTree, geoId, faceIndex) {
+        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.stateRelativeGeometryMap[stateTree][geoId]], faceIndex) == 1);
     }
-    isCondtionalStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[shapeState][geoId]], faceIndex) == 1);
+    isCondtionalStateFaceTransparent(modState, state, geoId, faceIndex) {
+        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[state][geoId]], faceIndex) == 1);
     }
     process() {
         let added = false;
@@ -46,8 +46,8 @@ export class VoxelConstructor {
         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];
+            const geoLinks = this.data.stateMap[treeState];
+            const geometries = this.data.stateGeometryMap[treeState];
             const geometriesLength = geoLinks.length;
             const inputs = this.baseInputMap[modState][treeState];
             for (let i = 0; i < geometriesLength; i++) {

package/Mesher/Models/VoxelGeometryBuilderCacheSpace.d.ts

@@ -1,11 +1,10 @@
-import { DataCursorInterface } from "../../Tools/DataCursor.interface";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { Vec3Array, Vector3Like } from "@amodx/math";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
 export declare class VoxelGeometryBuilderCacheSpace {
     bounds: Vector3Like;
     foundHash: Uint8Array;
     voxelCache: Uint16Array;
-    lightCache: Int32Array;
     modCache: Int32Array;
     stateCache: Int32Array;
     conditonalStateCache: Int32Array;
@@ -16,9 +15,8 @@ export declare class VoxelGeometryBuilderCacheSpace {
     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[][];
+    getGeomtry(index: number): number[] | null;
+    getConditionalGeomtry(index: number): number[][] | null;
     getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
-    getLight(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
     private hashState;
 }

package/Mesher/Models/VoxelGeometryBuilderCacheSpace.js

@@ -5,7 +5,6 @@ export class VoxelGeometryBuilderCacheSpace {
     bounds;
     foundHash;
     voxelCache;
-    lightCache;
     modCache;
     stateCache;
     conditonalStateCache;
@@ -16,7 +15,6 @@ export class VoxelGeometryBuilderCacheSpace {
         this.bounds = bounds;
         const volume = bounds.x * bounds.y * bounds.z;
         this.foundHash = new Uint8Array(volume);
-        this.lightCache = new Int32Array(volume);
         this.voxelCache = new Uint16Array(volume);
         this.modCache = new Int32Array(volume);
         this.stateCache = new Int32Array(volume);
@@ -27,7 +25,6 @@ export class VoxelGeometryBuilderCacheSpace {
         this.offset[0] = x;
         this.offset[1] = y;
         this.offset[2] = z;
-        this.lightCache.fill(-1);
         this.foundHash.fill(0);
         this.voxelCache.fill(0);
         this.modCache.fill(-1);
@@ -45,12 +42,12 @@ export class VoxelGeometryBuilderCacheSpace {
     }
     getGeomtry(index) {
         if (this.foundHash[index] < 2)
-            return false;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.shapeStateGeometryMap[this.stateCache[index]];
+            return null;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.stateGeometryMap[this.stateCache[index]];
     }
     getConditionalGeomtry(index) {
         if (this.foundHash[index] < 2)
-            return false;
+            return null;
         return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.condiotnalShapeStateGeometryMap[this.conditonalStateCache[index]];
     }
     getHash(dataCursor, x, y, z) {
@@ -60,48 +57,28 @@ export class VoxelGeometryBuilderCacheSpace {
         }
         return hashed;
     }
-    getLight(dataCursor, x, y, z) {
-        const index = this.getIndex(x, y, z);
-        if (this.lightCache[index] == -1) {
-            this.lightCache[index] = 0;
-            const voxel = dataCursor.getVoxel(x, y, z);
-            if (voxel) {
-                const light = voxel.getLight();
-                if (light > 0) {
-                    this.lightCache[index] = light;
-                }
-            }
-        }
-        return this.lightCache[index];
-    }
     hashState(dataCursor, index, x, y, z) {
         if (this.foundHash[index] == 1)
-            return -1;
+            return;
         if (this.foundHash[index] == 2)
-            return this.stateCache[index];
+            return;
         const voxel = dataCursor.getVoxel(x, y, z);
-        if (voxel) {
-            const light = voxel.getLight();
-            if (light > 0) {
-                this.lightCache[index] = light;
-            }
-        }
         if (!voxel || !voxel.isRenderable()) {
             this.foundHash[index] = 1;
-            return -1;
+            return;
         }
         const voxelId = voxel.getId();
         const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxelId];
         if (!voxelConstructor) {
             this.foundHash[index] = 1;
-            return -1;
+            return;
         }
         this.voxelCache[index] = voxelId;
         this.foundHash[index] = 2;
         //no ao
         this.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
         //state
-        const state = voxelConstructor.shapeStateTree.getState(voxel.getState());
+        const state = voxelConstructor.stateTree.getState(voxel.getState());
         this.stateCache[index] = state;
         //mod
         const mod = voxelConstructor.modTree.getState(voxel.getMod());
@@ -114,6 +91,5 @@ export class VoxelGeometryBuilderCacheSpace {
         voxelConstructor.schema.dataCursor = dataCursor;
         const conditonalState = voxelConstructor.condtioanlShapeStateTree.getState();
         this.conditonalStateCache[index] = conditonalState;
-        return 1;
     }
 }

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

@@ -1,13 +1,12 @@
-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 { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
 import { Vec3Array, Vector3Like, Vector4Like } from "@amodx/math";
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.js";
-import { DataCursorInterface } from "../../Tools/DataCursor.interface.js";
-import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface.js";
+import { VoxelGeometryBuilderCacheSpace } from "./VoxelGeometryBuilderCacheSpace";
 declare class VoxelVars {
     faceFlipped: boolean;
     textureIndex: number;
@@ -18,7 +17,7 @@ declare class VoxelVars {
     level: QuadScalarVertexData;
     reset(): void;
 }
-export declare class VoxelMesherDataTool extends MesherDataTool {
+export declare class VoxelModelBuilder {
     id: string;
     materialIndex: number;
     space: VoxelGeometryBuilderCacheSpace;

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

@@ -1,10 +1,9 @@
 //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 calculateFaceData from "../Models/Common/Calc/FaceDataCalc.js";
+import calculateFaceData from "./Common/Calc/FaceDataCalc.js";
 import { VoxelMesh } from "../Geomtry/VoxelMesh";
 import { Vector3Like, Vector4Like } from "@amodx/math";
 class VoxelVars {
@@ -23,7 +22,7 @@ class VoxelVars {
         this.overlayTextures.z = 0;
     }
 }
-export class VoxelMesherDataTool extends MesherDataTool {
+export class VoxelModelBuilder {
     id;
     materialIndex;
     space;
@@ -41,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;
@@ -74,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],
@@ -89,7 +86,7 @@ export class VoxelMesherDataTool extends MesherDataTool {
         this.bounds.max[0] = -Infinity;
         this.bounds.max[1] = -Infinity;
         this.bounds.max[2] = -Infinity;
-        this._boundsUpdate = true;
+        this._boundsUpdate = false;
     }
     endConstruction() {
         this.vars.reset();

package/Mesher/Types/Mesher.types.d.ts

@@ -1,4 +1,5 @@
 import { Vec3Array } from "@amodx/math";
+export type SetSectionMeshTask = ArrayBuffer;
 export type CompactSubMesh = [
     materialId: string,
     vertexBuffer: Float32Array,

package/Models/Defaults/CubeVoxelGeometry.js

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