@divinevoxel/vlox 0.0.3 → 0.0.5

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

@@ -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,7 +1,7 @@
-import { DataCursorInterface } from "../../Data/Cursor/Interfaces/DataCursor.interface";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
 import { VoxelConstructor } from "./VoxelConstructor";
 import { Vec3Array } from "@amodx/math";
-import { VoxelCursor } from "../../Data/Cursor/VoxelCursor";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
 export declare class VoxelGeometryLookUp {
     static voxelHash: VoxelConstructor[];
     static modCache: number[];

package/Mesher/Models/VoxelGeometryLookUp.js

@@ -1,6 +1,6 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
 import { Vector3Like } from "@amodx/math";
-import { VoxelCursor } from "../../Data/Cursor/VoxelCursor";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
 export class VoxelGeometryLookUp {
     static voxelHash = [];
     static modCache = [];
@@ -55,7 +55,7 @@ export class VoxelGeometryLookUp {
         //no ao
         this.noCastAO[hashed] = voxel.isLightSource() || voxel.noAO();
         //state
-        const shapeState = voxel.getShapeState();
+        const shapeState = voxel.getState();
         const state = voxelConstructor.shapeStateTree.getState(shapeState);
         this.stateCache[hashed] = state;
         //mod

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 {};

package/Mesher/Tools/VoxelMeshBVHBuilder.js

@@ -1,4 +1,4 @@
-import { WorldSpaces } from "../../Data/World/WorldSpaces";
+import { WorldSpaces } from "../../World/WorldSpaces";
 /**
  * A class to help with indexing a full flat binary tree defined by the number of levels it has.
  */
@@ -197,8 +197,8 @@ export class VoxelMeshBVHBuilder {
         this.tree.fill(-Infinity);
         this.indices.fill(0);
     }
-    updateVoxel(voxelX, voxelY, voxelZ, indicesStart, indicesEnd, minX, minY, minZ, maxX, maxY, maxZ) {
-        const voxelIndex = WorldSpaces.voxel.getIndexXYZ(voxelX, voxelY, voxelZ);
+    updateVoxel(voxelX, voxelY, voxelZ, meshIndex, indicesStart, indicesEnd, minX, minY, minZ, maxX, maxY, maxZ) {
+        const voxelIndex = WorldSpaces.voxel.getIndex(voxelX, voxelY, voxelZ);
         const leafIndex = this.treeIndex.getIndexAtLevel(12, voxelIndex);
         this.indices[voxelIndex * 2] = indicesStart;
         this.indices[voxelIndex * 2 + 1] = indicesEnd;

package/Mesher/Tools/VoxelMeshVertexStructCursor.d.ts

@@ -39,7 +39,7 @@ export declare class VoxelMeshVertexStructCursor {
     set colorB(value: number);
     trueIndex: number;
     _index: number;
-    data: Float32Array;
+    data: Float32Array | number[];
     get index(): number;
     set index(index: number);
     constructor(data?: Float32Array);

package/Mesher/Tools/VoxelMesherDataTool.d.ts

@@ -1,27 +1,39 @@
-import { MesherDataTool } from "@amodx/meshing/Tools/MesherDataTools";
-import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
-import { VoxelTemplateDataTool } from "./VoxelTemplateDataTool.js";
+import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
+import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces } from "../../Math";
-import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+import { QuadVerticies } from "../Geomtry/Geometry.types";
+import { Mesh } from "../Geomtry/Mesh";
 import { VoxelMeshBVHBuilder } from "./VoxelMeshBVHBuilder";
 import { Vec3Array, Vector3Like } from "@amodx/math";
-import { VoxelCursorInterface } from "../../Data/Cursor/Interfaces/VoxelCursor.interface";
-import { DataCursorInterface } from "../../Data/Cursor/Interfaces/DataCursor.interface";
+import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.js";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface.js";
+declare class VoxelVars {
+    faceFlipped: boolean;
+    textureIndex: number;
+    light: QuadScalarVertexData;
+    ao: QuadScalarVertexData;
+    animation: QuadScalarVertexData;
+    level: QuadScalarVertexData;
+    overlayTextures: QuadScalarVertexData;
+    reset(): void;
+}
 export declare class VoxelMesherDataTool extends MesherDataTool {
     id: string;
-    template: VoxelTemplateDataTool;
+    materialIndex: number;
     voxel: VoxelCursorInterface;
     nVoxel: DataCursorInterface;
     /**The current world position */
     position: Vector3Like;
     /**The current local origin  */
     origin: Vector3Like;
-    bvhTool: VoxelMeshBVHBuilder;
+    mesh: Mesh;
+    bvhTool: VoxelMeshBVHBuilder | null;
+    vars: VoxelVars;
     dataCalculated: Record<VoxelFaces, boolean>;
     condiotnalGeometryData: Record<VoxelFaces, Record<QuadVerticies, [number[][], number[][], number[][]]>>;
     lightData: Record<VoxelFaces, Record<QuadVerticies, number>>;
     effects: Record<string, number[]>;
-    constructor(id: string);
+    constructor(id: string, materialIndex: number);
     bounds: {
         min: Vec3Array;
         max: Vec3Array;
@@ -31,12 +43,6 @@ export declare class VoxelMesherDataTool extends MesherDataTool {
     endConstruction(): boolean;
     calculateFaceData(direction: VoxelFaces): true | undefined;
     clearCalculatedData(): void;
-    getAnimationData(): QuadScalarVertexData;
-    getWorldLight(): QuadScalarVertexData;
-    getWorldAO(): QuadScalarVertexData;
-    getOverlayTextures(): QuadScalarVertexData;
-    setTexture(uv: number): this;
-    getTexture(): number;
-    setFaceFlipped(value: boolean): this;
-    isFaceFlipped(): boolean;
+    reset(): void;
 }
+export {};

package/Mesher/Tools/VoxelMesherDataTool.js

@@ -1,33 +1,45 @@
 //tools
-import { MesherDataTool } from "@amodx/meshing/Tools/MesherDataTools";
+import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
 //data
-import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
-import { VoxelTemplateDataTool } from "./VoxelTemplateDataTool.js";
-import { BinaryNumberTypes } from "@amodx/binary";
+import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces, VoxelFacesArray } from "../../Math";
-import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+import { QuadVerticies } from "../Geomtry/Geometry.types";
 import { FaceDataCalc } from "../Models/Common/Calc/FaceDataCalc.js";
-import { Mesh } from "@amodx/meshing/Mesh/Mesh";
-import { VoxelMeshBVHBuilder } from "./VoxelMeshBVHBuilder";
+import { Mesh } from "../Geomtry/Mesh";
 import { Vector3Like } from "@amodx/math";
-import { WorldSpaces } from "../../Data/World/WorldSpaces";
+class VoxelVars {
+    faceFlipped = false;
+    textureIndex = 0;
+    light = new QuadScalarVertexData();
+    ao = new QuadScalarVertexData();
+    animation = new QuadScalarVertexData();
+    level = new QuadScalarVertexData();
+    overlayTextures = new QuadScalarVertexData();
+    reset() {
+        this.faceFlipped = false;
+        this.textureIndex = 0;
+    }
+}
 export class VoxelMesherDataTool extends MesherDataTool {
     id;
-    template = new VoxelTemplateDataTool();
+    materialIndex;
     voxel;
     nVoxel;
     /**The current world position */
     position = Vector3Like.Create();
     /**The current local origin  */
     origin = Vector3Like.Create();
-    bvhTool = new VoxelMeshBVHBuilder();
+    mesh = new Mesh();
+    bvhTool = null;
+    vars = new VoxelVars();
     dataCalculated;
     condiotnalGeometryData;
     lightData;
     effects;
-    constructor(id) {
+    constructor(id, materialIndex) {
         super();
         this.id = id;
+        this.materialIndex = materialIndex;
         //  this.faceDataOverride.currentVoxel = this.voxel;
         //  this.faceDataOverride.neighborVoxel = this.nVoxel;
         this.dataCalculated = [];
@@ -59,23 +71,6 @@ export class VoxelMesherDataTool extends MesherDataTool {
             this.lightData[face][QuadVerticies.BottomRight] = 0;
         }
         this.startNewMesh(new Mesh(true));
-        [
-            ["voxelData", [[], 1, BinaryNumberTypes.Float32]],
-            ["uv", [[], 2, BinaryNumberTypes.Float32]],
-            ["textureIndex", [[], 3, BinaryNumberTypes.Float32]],
-            ["colors", [[], 3, BinaryNumberTypes.Float32]],
-        ].forEach(([key, data]) => this.mesh.attributes.set(key, data));
-        [
-            ["light", new QuadScalarVertexData()],
-            ["ao", new QuadScalarVertexData()],
-            ["animation", new QuadScalarVertexData()],
-            ["level", new QuadScalarVertexData()],
-            ["overlay-uvs", new QuadScalarVertexData()],
-        ].forEach(([key, data]) => this.quadVertexData.set(key, data));
-        [
-            ["face-flipped", 0],
-            ["texture-index", 0],
-        ].forEach(([key, data]) => this.vars.set(key, data));
     }
     bounds = {
         min: [0, 0, 0],
@@ -92,11 +87,12 @@ export class VoxelMesherDataTool extends MesherDataTool {
         this.bounds.max[2] = -Infinity;
     }
     endConstruction() {
-        const position = WorldSpaces.voxel.getPositionXYZ(this.position.x, this.position.y, this.position.z);
         if (this.bounds.min.includes(Infinity) ||
             this.bounds.max.includes(-Infinity))
             return false;
-        this.bvhTool.updateVoxel(position.x, position.y, position.z, this._indexStart, 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.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]);
+        }
         return true;
     }
     calculateFaceData(direction) {
@@ -113,36 +109,7 @@ export class VoxelMesherDataTool extends MesherDataTool {
         this.dataCalculated[VoxelFaces.East] = false;
         this.dataCalculated[VoxelFaces.West] = false;
     }
-    getAnimationData() {
-        return this.quadVertexData.get("animation");
-    }
-    getWorldLight() {
-        if (this.template.isAcive()) {
-            return this.template._light;
-        }
-        return this.quadVertexData.get("light");
-    }
-    getWorldAO() {
-        if (this.template.isAcive()) {
-            return this.template._ao;
-        }
-        return this.quadVertexData.get("ao");
-    }
-    getOverlayTextures() {
-        return this.quadVertexData.get("overlay-uvs");
-    }
-    setTexture(uv) {
-        this.vars.set("texture-index", uv);
-        return this;
-    }
-    getTexture() {
-        return this.vars.get("texture-index");
-    }
-    setFaceFlipped(value) {
-        this.vars.set("face-flipped", value ? 1 : 0);
-        return this;
-    }
-    isFaceFlipped() {
-        return this.vars.get("face-flipped") == 1;
+    reset() {
+        this.vars.reset();
     }
 }

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

@@ -1,16 +1,12 @@
-import { BinaryNumberTypes, TypedArrays } from "@amodx/binary";
 import { Vec3Array } from "@amodx/math";
-export type CompactMeshIndex = [
-    id: string,
-    array: TypedArrays,
-    length: number,
-    startByte: number,
-    endByte: number,
-    stride: number,
-    type: BinaryNumberTypes
-][];
-export type CompactSubMesh = [materialId: string, index: CompactMeshIndex];
-export type CompactMeshData = [type: 0, buffer: ArrayBuffer, meshes: CompactSubMesh[]] | [
+export type CompactSubMesh = [
+    materialId: string,
+    vertexBuffer: Float32Array,
+    indexBuffer: Uint32Array | Uint16Array,
+    minBounds: Vec3Array,
+    maxBounds: Vec3Array
+];
+export type CompactMeshData = [type: 0, meshes: CompactSubMesh[]] | [
     type: 1,
     vertexBuffer: ArrayBuffer,
     indexBuffer: Uint32Array,