@divinevoxel/vlox 0.0.2 → 0.0.3

package/Mesher/Tools/VoxelMeshBVHBuilder.js

@@ -0,0 +1,233 @@
+import { WorldSpaces } from "../../Data/World/WorldSpaces";
+/**
+ * A class to help with indexing a full flat binary tree defined by the number of levels it has.
+ */
+class FlatBinaryTreeIndex {
+    levels;
+    constructor(levels) {
+        this.levels = levels;
+    }
+    /** Gets the number of nodes at a level of the tree */
+    getLevelSize(level) {
+        if (level < 0 || level >= this.levels) {
+            throw new Error("Invalid level");
+        }
+        return 1 << level; // Equivalent to 2^level
+    }
+    /**
+     * Gets the flat index of a node indexed by the level it's on and its relative index in that level.
+     */
+    getIndexAtLevel(level, node) {
+        if (level < 0 || level >= this.levels) {
+            throw new Error("Invalid level");
+        }
+        const levelSize = this.getLevelSize(level);
+        if (node < 0 || node >= levelSize) {
+            throw new Error("Invalid node index at the given level");
+        }
+        return (1 << level) - 1 + node;
+    }
+    /**
+     * Gets the level and relative index of a node's flat index.
+     */
+    getLevelAndIndex(index) {
+        const totalNodes = (1 << this.levels) - 1;
+        if (index < 0 || index >= totalNodes) {
+            throw new Error("Invalid node index");
+        }
+        const level = Math.floor(Math.log2(index + 1));
+        const firstIndexAtLevel = (1 << level) - 1;
+        const relativeIndex = index - firstIndexAtLevel;
+        return [level, relativeIndex];
+    }
+    /**
+     * Gets the flat left child of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if no child exist
+     */
+    getLeftChildAtLevel(level, node) {
+        if (level + 1 >= this.levels) {
+            return -1;
+        }
+        const nodeIndex = this.getIndexAtLevel(level, node);
+        return this.getLeftChild(nodeIndex);
+    }
+    /**
+     * Gets the flat right child of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if no child exist
+     */
+    getRightChildAtLevel(level, node) {
+        if (level + 1 >= this.levels) {
+            return -1;
+        }
+        const nodeIndex = this.getIndexAtLevel(level, node);
+        return this.getRightChild(nodeIndex);
+    }
+    /**
+     * Gets the flat index of the parent of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if level has no parent
+     */
+    getParentAtLevel(level, node) {
+        if (level === 0) {
+            return -1;
+        }
+        const nodeIndex = this.getIndexAtLevel(level, node);
+        return this.getParent(nodeIndex);
+    }
+    /** Gets the flat index of the left child of the node.
+     * @returns -1 if no child exist
+     */
+    getLeftChild(node) {
+        const leftChildIndex = 2 * node + 1;
+        const totalNodes = (1 << this.levels) - 1;
+        return leftChildIndex < totalNodes ? leftChildIndex : -1;
+    }
+    /** Gets the flat index of the right child of the node.
+     * @returns -1 if no child exist
+     */
+    getRightChild(node) {
+        const rightChildIndex = 2 * node + 2;
+        const totalNodes = (1 << this.levels) - 1;
+        return rightChildIndex < totalNodes ? rightChildIndex : -1;
+    }
+    /** Gets the flat index of the parent of the node.
+     * @returns -1 if no parent exist
+     */
+    getParent(node) {
+        if (node === 0) {
+            return -1; // Root node has no parent
+        }
+        return Math.floor((node - 1) / 2);
+    }
+    /** Gets the total number of nodes in the tree */
+    getTotalSize() {
+        return (1 << this.levels) - 1; // Equivalent to 2^levels - 1
+    }
+}
+export class StructCursor {
+    data;
+    get minX() {
+        return this.data[this.trueIndex];
+    }
+    get minY() {
+        return this.data[this.trueIndex + 1];
+    }
+    get minZ() {
+        return this.data[this.trueIndex + 2];
+    }
+    get maxX() {
+        return this.data[this.trueIndex + 4];
+    }
+    get maxY() {
+        return this.data[this.trueIndex + 5];
+    }
+    get maxZ() {
+        return this.data[this.trueIndex + 6];
+    }
+    get voxelIndex() {
+        return this.data[this.trueIndex + 3];
+    }
+    get active() {
+        return this.data[this.trueIndex + 3];
+    }
+    get nodeType() {
+        return this.data[this.trueIndex + 7];
+    }
+    trueIndex = 0;
+    _index = 0;
+    get index() {
+        return this._index;
+    }
+    set index(index) {
+        this._index = index;
+        this.trueIndex = index * 8;
+    }
+    constructor(data) {
+        this.data = data;
+    }
+    setActive() {
+        this.data[this.trueIndex + 3] = 1;
+    }
+    setVoxelIndex(value) {
+        this.data[this.trueIndex + 3] = value;
+    }
+    setInnerNode() {
+        this.data[this.trueIndex + 7] = 1;
+    }
+    setGeomtryNode() {
+        this.data[this.trueIndex + 7] = 2;
+    }
+    updateMin(x, y, z) {
+        const ix = this.trueIndex;
+        const iy = this.trueIndex + 1;
+        const iz = this.trueIndex + 2;
+        this.data[ix] =
+            this.data[ix] == -Infinity || x < this.data[ix] ? x : this.data[ix];
+        this.data[iy] =
+            this.data[iy] == -Infinity || y < this.data[iy] ? y : this.data[iy];
+        this.data[iz] =
+            this.data[iz] == -Infinity || z < this.data[iz] ? z : this.data[iz];
+    }
+    updateMax(x, y, z) {
+        const ix = this.trueIndex + 4;
+        const iy = this.trueIndex + 5;
+        const iz = this.trueIndex + 6;
+        this.data[ix] =
+            this.data[ix] == -Infinity || x > this.data[ix] ? x : this.data[ix];
+        this.data[iy] =
+            this.data[iy] == -Infinity || y > this.data[iy] ? y : this.data[iy];
+        this.data[iz] =
+            this.data[iz] == -Infinity || z > this.data[iz] ? z : this.data[iz];
+    }
+    toJSON() {
+        return {
+            min: [this.minX, this.minY, this.minZ],
+            max: [this.maxX, this.maxY, this.maxZ],
+            active: this.active,
+            nodeType: this.nodeType,
+        };
+    }
+}
+export class VoxelMeshBVHBuilder {
+    static AABBStructByteSize = (4 + 4) * 4;
+    treeIndex = new FlatBinaryTreeIndex(13);
+    tree = new Float32Array(new ArrayBuffer(this.treeIndex.getTotalSize() * VoxelMeshBVHBuilder.AABBStructByteSize));
+    structCursor = new StructCursor(this.tree);
+    indices = new Uint32Array(this.treeIndex.getLevelSize(12) * 2);
+    reset() {
+        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);
+        const leafIndex = this.treeIndex.getIndexAtLevel(12, voxelIndex);
+        this.indices[voxelIndex * 2] = indicesStart;
+        this.indices[voxelIndex * 2 + 1] = indicesEnd;
+        this.structCursor.index = leafIndex;
+        this.structCursor.updateMin(minX, minY, minZ);
+        this.structCursor.updateMax(maxX, maxY, maxZ);
+        this.structCursor.setVoxelIndex(voxelIndex);
+        this.structCursor.setGeomtryNode();
+        let current = leafIndex;
+        for (let level = 1; level < 13; level++) {
+            let parentNode = this.treeIndex.getParent(current);
+            this.structCursor.index = parentNode;
+            this.structCursor.updateMin(minX, minY, minZ);
+            this.structCursor.updateMax(maxX, maxY, maxZ);
+            this.structCursor.setActive();
+            this.structCursor.setInnerNode();
+            current = parentNode;
+        }
+    }
+}
+/*
+console.warn(
+  [voxelX, voxelY, voxelZ],
+  "add gometry",
+     [minX, minY, minZ],
+  [maxX, maxY, maxZ],
+  [voxelX, voxelY, voxelZ],
+  [indicesStart, indicesEnd],
+  indicesEnd - indicesStart,
+  (indicesEnd - indicesStart) / 3
+);
+*/

package/Mesher/Tools/VoxelMeshVertexStructCursor.d.ts

@@ -0,0 +1,54 @@
+export declare class VoxelMeshVertexStructCursor {
+    static VertexFloatSize: number;
+    static VertexByteSize: number;
+    static PositionOffset: number;
+    static NormalOffset: number;
+    static TextureIndexOffset: number;
+    static UVOffset: number;
+    static ColorOffset: number;
+    static VoxelDataOFfset: number;
+    get positionX(): number;
+    set positionX(value: number);
+    get positionY(): number;
+    set positionY(value: number);
+    get positionZ(): number;
+    set positionZ(value: number);
+    get normalX(): number;
+    set normalX(value: number);
+    get normalY(): number;
+    set normalY(value: number);
+    get normalZ(): number;
+    set normalZ(value: number);
+    get voxelData(): number;
+    set voxelData(value: number);
+    get textureIndexX(): number;
+    set textureIndexX(value: number);
+    get textureIndexY(): number;
+    set textureIndexY(value: number);
+    get textureIndexZ(): number;
+    set textureIndexZ(value: number);
+    get uvX(): number;
+    set uvX(value: number);
+    get uvY(): number;
+    set uvY(value: number);
+    get colorR(): number;
+    set colorR(value: number);
+    get colorG(): number;
+    set colorG(value: number);
+    get colorB(): number;
+    set colorB(value: number);
+    trueIndex: number;
+    _index: number;
+    data: Float32Array;
+    get index(): number;
+    set index(index: number);
+    constructor(data?: Float32Array);
+    toJSON(): {
+        position: number[];
+        normal: number[];
+        voxelData: number;
+        textureIndex: number[];
+        uv: number[];
+        color: number[];
+    };
+}

package/Mesher/Tools/VoxelMeshVertexStructCursor.js

@@ -0,0 +1,145 @@
+export class VoxelMeshVertexStructCursor {
+    static VertexFloatSize = 24;
+    static VertexByteSize = this.VertexFloatSize * 4;
+    static PositionOffset = 0;
+    static NormalOffset = 4;
+    static TextureIndexOffset = 8;
+    static UVOffset = 12;
+    static ColorOffset = 14;
+    static VoxelDataOFfset = 18;
+    // position
+    get positionX() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.PositionOffset];
+    }
+    set positionX(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.PositionOffset] =
+            value;
+    }
+    get positionY() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.PositionOffset + 1];
+    }
+    set positionY(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.PositionOffset + 1] =
+            value;
+    }
+    get positionZ() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.PositionOffset + 2];
+    }
+    set positionZ(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.PositionOffset + 2] =
+            value;
+    }
+    // normal
+    get normalX() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.NormalOffset];
+    }
+    set normalX(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.NormalOffset] =
+            value;
+    }
+    get normalY() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.NormalOffset + 1];
+    }
+    set normalY(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.NormalOffset + 1] =
+            value;
+    }
+    get normalZ() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.NormalOffset + 2];
+    }
+    set normalZ(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.NormalOffset + 2] =
+            value;
+    }
+    // voxel data
+    get voxelData() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset];
+    }
+    set voxelData(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset] =
+            value;
+    }
+    // texture index
+    get textureIndexX() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.TextureIndexOffset];
+    }
+    set textureIndexX(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.TextureIndexOffset] =
+            value;
+    }
+    get textureIndexY() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.TextureIndexOffset + 1];
+    }
+    set textureIndexY(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.TextureIndexOffset + 1] = value;
+    }
+    get textureIndexZ() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.TextureIndexOffset + 2];
+    }
+    set textureIndexZ(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.TextureIndexOffset + 2] = value;
+    }
+    // uv
+    get uvX() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.UVOffset];
+    }
+    set uvX(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.UVOffset] = value;
+    }
+    get uvY() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.UVOffset + 1];
+    }
+    set uvY(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.UVOffset + 1] =
+            value;
+    }
+    // color
+    get colorR() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.ColorOffset];
+    }
+    set colorR(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.ColorOffset] = value;
+    }
+    get colorG() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.ColorOffset + 1];
+    }
+    set colorG(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.ColorOffset + 1] =
+            value;
+    }
+    get colorB() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.ColorOffset + 2];
+    }
+    set colorB(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.ColorOffset + 2] =
+            value;
+    }
+    trueIndex = 0;
+    _index = 0;
+    data;
+    get index() {
+        return this._index;
+    }
+    set index(index) {
+        this._index = index;
+        this.trueIndex = index * VoxelMeshVertexStructCursor.VertexFloatSize;
+    }
+    constructor(data) {
+        if (data)
+            this.data = data;
+    }
+    toJSON() {
+        return {
+            position: [this.positionX, this.positionY, this.positionZ],
+            normal: [this.normalX, this.normalY, this.normalZ],
+            voxelData: this.voxelData,
+            textureIndex: [
+                this.textureIndexX,
+                this.textureIndexY,
+                this.textureIndexZ,
+            ],
+            uv: [this.uvX, this.uvY],
+            color: [this.colorR, this.colorG, this.colorB],
+        };
+    }
+}

package/Mesher/Tools/VoxelMesherDataTool.d.ts

@@ -1,31 +1,42 @@
-import type { FaceDataOverride } from "../Types/Override.types";
-import { BuilderDataTool } from "./BuilderDataTool.js";
 import { MesherDataTool } from "@amodx/meshing/Tools/MesherDataTools";
-import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
 import { VoxelTemplateDataTool } from "./VoxelTemplateDataTool.js";
 import { VoxelFaces } from "../../Math";
 import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+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";
 export declare class VoxelMesherDataTool extends MesherDataTool {
+    id: string;
     template: VoxelTemplateDataTool;
-    voxel: BuilderDataTool;
-    nVoxel: BuilderDataTool;
+    voxel: VoxelCursorInterface;
+    nVoxel: DataCursorInterface;
+    /**The current world position */
+    position: Vector3Like;
+    /**The current local origin  */
+    origin: Vector3Like;
+    bvhTool: VoxelMeshBVHBuilder;
     dataCalculated: Record<VoxelFaces, boolean>;
     condiotnalGeometryData: Record<VoxelFaces, Record<QuadVerticies, [number[][], number[][], number[][]]>>;
     lightData: Record<VoxelFaces, Record<QuadVerticies, number>>;
-    faceDataOverride: FaceDataOverride;
-    constructor();
+    effects: Record<string, number[]>;
+    constructor(id: string);
+    bounds: {
+        min: Vec3Array;
+        max: Vec3Array;
+    };
+    _indexStart: number;
+    startConstruction(): void;
+    endConstruction(): boolean;
     calculateFaceData(direction: VoxelFaces): true | undefined;
     clearCalculatedData(): void;
-    calculateLight(direction: VoxelFaces, ignoreAO?: boolean): void;
-    calculateFlow(): void;
     getAnimationData(): QuadScalarVertexData;
     getWorldLight(): QuadScalarVertexData;
     getWorldAO(): QuadScalarVertexData;
-    getWorldLevel(): QuadScalarVertexData;
     getOverlayTextures(): QuadScalarVertexData;
     setTexture(uv: number): this;
     getTexture(): number;
     setFaceFlipped(value: boolean): this;
     isFaceFlipped(): boolean;
-    isFaceExposed(face: VoxelFaces): boolean;
 }

package/Mesher/Tools/VoxelMesherDataTool.js

@@ -1,35 +1,35 @@
-//objects
-import { LightGradient } from "../Calc/Light/LightGradient.js";
-import { FlowGradient } from "../Calc/Flow/FlowGradient.js";
-import { OverrideManager } from "../Rules/Overrides/OverridesManager.js";
-import { SubstanceRules } from "../Rules/SubstanceRules.js";
 //tools
-import { BuilderDataTool } from "./BuilderDataTool.js";
 import { MesherDataTool } from "@amodx/meshing/Tools/MesherDataTools";
 //data
-import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
 import { VoxelTemplateDataTool } from "./VoxelTemplateDataTool.js";
 import { BinaryNumberTypes } from "@amodx/binary";
-import { VoxelFaces, VoxelFaceDirections, VoxelFacesArray, } from "../../Math";
+import { VoxelFaces, VoxelFacesArray } from "../../Math";
 import { QuadVerticies } from "@amodx/meshing/Geometry.types";
-import { FaceDataCalc } from "../Calc/Light/FaceDataCalc";
+import { FaceDataCalc } from "../Models/Common/Calc/FaceDataCalc.js";
+import { Mesh } from "@amodx/meshing/Mesh/Mesh";
+import { VoxelMeshBVHBuilder } from "./VoxelMeshBVHBuilder";
+import { Vector3Like } from "@amodx/math";
+import { WorldSpaces } from "../../Data/World/WorldSpaces";
 export class VoxelMesherDataTool extends MesherDataTool {
+    id;
     template = new VoxelTemplateDataTool();
-    voxel = new BuilderDataTool();
-    nVoxel = new BuilderDataTool();
+    voxel;
+    nVoxel;
+    /**The current world position */
+    position = Vector3Like.Create();
+    /**The current local origin  */
+    origin = Vector3Like.Create();
+    bvhTool = new VoxelMeshBVHBuilder();
     dataCalculated;
     condiotnalGeometryData;
     lightData;
-    faceDataOverride = {
-        face: VoxelFaces.South,
-        default: false,
-        currentVoxel: {},
-        neighborVoxel: {},
-    };
-    constructor() {
+    effects;
+    constructor(id) {
         super();
-        this.faceDataOverride.currentVoxel = this.voxel;
-        this.faceDataOverride.neighborVoxel = this.nVoxel;
+        this.id = id;
+        //  this.faceDataOverride.currentVoxel = this.voxel;
+        //  this.faceDataOverride.neighborVoxel = this.nVoxel;
         this.dataCalculated = [];
         for (const face of VoxelFacesArray) {
             this.dataCalculated[face] = false;
@@ -58,12 +58,13 @@ export class VoxelMesherDataTool extends MesherDataTool {
             this.lightData[face][QuadVerticies.BottomLeft] = 0;
             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.attributes.set(key, data));
+        ].forEach(([key, data]) => this.mesh.attributes.set(key, data));
         [
             ["light", new QuadScalarVertexData()],
             ["ao", new QuadScalarVertexData()],
@@ -76,6 +77,28 @@ export class VoxelMesherDataTool extends MesherDataTool {
             ["texture-index", 0],
         ].forEach(([key, data]) => this.vars.set(key, data));
     }
+    bounds = {
+        min: [0, 0, 0],
+        max: [0, 0, 0],
+    };
+    _indexStart = 0;
+    startConstruction() {
+        this._indexStart = this.mesh.indices.length;
+        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;
+    }
+    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]);
+        return true;
+    }
     calculateFaceData(direction) {
         if (this.dataCalculated[direction])
             return true;
@@ -90,20 +113,6 @@ export class VoxelMesherDataTool extends MesherDataTool {
         this.dataCalculated[VoxelFaces.East] = false;
         this.dataCalculated[VoxelFaces.West] = false;
     }
-    calculateLight(direction, ignoreAO = false) {
-        /*     if (this.template.isAcive()) {
-          this.template._light = this.template._lights[direction];
-          this.template._ao = this.template._aos[direction];
-          return;
-        } */
-        LightGradient.calculate(direction, this, ignoreAO);
-    }
-    calculateFlow() {
-        if (this.template.isAcive()) {
-            return;
-        }
-        FlowGradient.calculate(this);
-    }
     getAnimationData() {
         return this.quadVertexData.get("animation");
     }
@@ -119,12 +128,6 @@ export class VoxelMesherDataTool extends MesherDataTool {
         }
         return this.quadVertexData.get("ao");
     }
-    getWorldLevel() {
-        if (this.template.isAcive()) {
-            return this.template._level;
-        }
-        return this.quadVertexData.get("level");
-    }
     getOverlayTextures() {
         return this.quadVertexData.get("overlay-uvs");
     }
@@ -142,25 +145,4 @@ export class VoxelMesherDataTool extends MesherDataTool {
     isFaceFlipped() {
         return this.vars.get("face-flipped") == 1;
     }
-    isFaceExposed(face) {
-        /*     if (this.template.isAcive()) {
-          return this.template.isFaceExposed(face);
-        } */
-        const voxelExists = this.nVoxel.loadInAt(VoxelFaceDirections[face][0] + this.voxel.x, VoxelFaceDirections[face][1] + this.voxel.y, VoxelFaceDirections[face][2] + this.voxel.z);
-        if (!voxelExists || !this.nVoxel.isRenderable())
-            return true;
-        let finalResult = false;
-        let substanceRuleResult = SubstanceRules.exposedCheck(this.voxel.getSubstance(), this.nVoxel.getSubstance());
-        this.faceDataOverride.face = face;
-        this.faceDataOverride.default = substanceRuleResult;
-        finalResult = substanceRuleResult;
-        this.faceDataOverride.default = finalResult;
-        finalResult = OverrideManager.FaceExposedShapeCheck.run(this.voxel.getShapeId(), OverrideManager.ANY, this.faceDataOverride);
-        this.faceDataOverride.default = finalResult;
-        finalResult = OverrideManager.FaceExposedShapeCheck.run(this.voxel.getShapeId(), this.nVoxel.getShapeId(), this.faceDataOverride);
-        this.faceDataOverride.default = finalResult;
-        finalResult = OverrideManager.FaceExposedVoxelCheck.run(this.voxel.getId(true), OverrideManager.ANY, this.faceDataOverride);
-        finalResult = OverrideManager.FaceExposedVoxelCheck.run(this.voxel.getId(true), this.nVoxel.getId(true), this.faceDataOverride);
-        return finalResult;
-    }
 }

package/Mesher/Tools/VoxelTemplateDataTool.d.ts

@@ -1,5 +1,5 @@
-import type { DirectionNames } from "../../Types/Util.types.js";
-import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+import type { DirectionNames } from "../../Util/Util.types.js";
+import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
 export declare class VoxelTemplateDataTool {
     _active: boolean;
     _faces: Record<DirectionNames, number>;

package/Mesher/Tools/VoxelTemplateDataTool.js

@@ -1,5 +1,5 @@
 //data
-import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
 export class VoxelTemplateDataTool {
     _active = false;
     _faces = {

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

@@ -0,0 +1,21 @@
+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[]] | [
+    type: 1,
+    vertexBuffer: ArrayBuffer,
+    indexBuffer: Uint32Array,
+    bvhTreeBuffer: Float32Array,
+    bvhIndexBuffer: Uint32Array,
+    minBounds: Vec3Array,
+    maxBounds: Vec3Array
+];

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

@@ -0,0 +1,5 @@
+export declare class VoxelMeshTypes {
+    static vertexStrideBytes: number;
+    static vertexStrideFloats: number;
+    static VoxelMeshStructWGSL: string;
+}