@divinevoxel/vlox 0.0.73 → 0.0.75

package/Mesher/Models/Nodes/VoxelGeometryConstructor.js

@@ -1,68 +1,32 @@
-import { VoxelFaceCullResultsIndex } from "../../../Models/Indexing/VoxelFaceCullResultsIndex";
-import { VoxelAOResultsIndex } from "../../../Models/Indexing/VoxelAOResultsIndex";
-import { BoxVoxelGometryNode } from "./Ruled/BoxVoxelGeometryNode";
-import { QuadVoxelGometryNode } from "./Ruled/QuadVoxelGeometryNode";
-import { RulelessQuadVoxelGeometryNode } from "./Ruleless/RulelessQuadVoxelGeometryNode";
-import { RulelessBoxVoxelGeometryNode } from "./Ruleless/RulelessBoxVoxelGeometryNode";
+import { QuadVoxelGometryNode } from "./Default/QuadVoxelGeometryNode";
+import { TriangleVoxelGeometryNode } from "./Default/TriangleVoxelGeometryNode";
 import { VoxelModelConstructorRegister } from "../VoxelModelConstructorRegister";
 export class VoxelGeometryConstructor {
     geometryPaletteId;
     nodes = [];
-    faceCullMap;
-    vertexHitMap;
-    cullIndex;
-    aoIndex;
+    cullingProcedure;
     constructor(geometryPaletteId, data) {
         this.geometryPaletteId = geometryPaletteId;
+        this.cullingProcedure = data.cullingProcedure;
         for (const node of data.nodes) {
-            if (node.node.type == "custom") {
-                const nodeClass = VoxelModelConstructorRegister.getCustomNode(node.node.id);
-                const newNode = new nodeClass(geometryPaletteId, this, node.node, node.tranform);
+            if (node.type == "custom") {
+                const nodeClass = VoxelModelConstructorRegister.getCustomNode(node.id);
+                const newNode = new nodeClass(geometryPaletteId, this, node);
                 newNode.init();
                 this.nodes.push(newNode);
             }
         }
-        if (data?.ruleless) {
-            data = data;
-            for (const node of data.nodes) {
-                if (node.node.type == "box") {
-                    const newNode = new RulelessBoxVoxelGeometryNode(geometryPaletteId, this, node.node, node.tranform);
-                    newNode.init();
-                    this.nodes.push(newNode);
-                }
-                if (node.node.type == "quad") {
-                    const newNode = new RulelessQuadVoxelGeometryNode(geometryPaletteId, this, node.node, node.tranform);
-                    newNode.init();
-                    this.nodes.push(newNode);
-                }
+        for (const node of data.nodes) {
+            if (node.type == "quad") {
+                const newNode = new QuadVoxelGometryNode(geometryPaletteId, this, node);
+                newNode.init();
+                this.nodes.push(newNode);
             }
-        }
-        else {
-            data = data;
-            this.faceCullMap = data.faceCullMap;
-            this.vertexHitMap = data.vertexHitMap;
-            this.cullIndex = new VoxelFaceCullResultsIndex(data.cullIndex);
-            this.aoIndex = new VoxelAOResultsIndex(data.aoIndex);
-            for (const node of data.nodes) {
-                if (node.node.type == "box") {
-                    const newNode = new BoxVoxelGometryNode(geometryPaletteId, this, node.node, node.tranform);
-                    newNode.init();
-                    this.nodes.push(newNode);
-                }
-                if (node.node.type == "quad") {
-                    const newNode = new QuadVoxelGometryNode(geometryPaletteId, this, node.node, node.tranform);
-                    newNode.init();
-                    this.nodes.push(newNode);
-                }
+            if (node.type == "triangle") {
+                const newNode = new TriangleVoxelGeometryNode(geometryPaletteId, this, node);
+                newNode.init();
+                this.nodes.push(newNode);
             }
         }
-        let faceCount = 0;
-        let vertexCount = 0;
-        for (const node of this.nodes) {
-            node.faceIndex = faceCount;
-            node.vertexIndex = vertexCount;
-            faceCount += node.faceCount;
-            vertexCount += node.vertexCount;
-        }
     }
 }

package/Mesher/Models/Procedures/Default/ConsistentRotationTextureProcedure.d.ts

@@ -0,0 +1,25 @@
+import { Vec3Array, Vector4Like } from "@amodx/math";
+import type { Quad } from "../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import { TextureId } from "Textures";
+import { VoxelFaces } from "Math";
+/**
+ * Extend your data type so we can add a seed if we want, and define
+ * the rotations we can choose from.
+ */
+interface VoxelGeometryConsistentRotationTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+    type: "consistent-rotation";
+    texture: TextureId | number;
+    /**
+     * You can allow (0 | 90 | 180 | 270), or remove 0 if you don’t want an unrotated option
+     */
+    rotations: (0 | 90 | 180 | 270)[];
+    rotationBounds?: Vec3Array;
+}
+export declare class ConsistentRotationTextureProcedure extends TextureProcedure<VoxelGeometryConsistentRotationTextureProcedureData> {
+    getTexture(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
+    getOverlayTexture(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
+    transformUVs(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
+}
+export {};

package/Mesher/Models/Procedures/Default/ConsistentRotationTextureProcedure.js

@@ -0,0 +1,44 @@
+import { Vector3Like } from "@amodx/math";
+import { TextureProcedure, } from "../TextureProcedure";
+import { WorldSpaces } from "../../../../World/WorldSpaces";
+import { GetYXZOrderArrayIndex } from "../../../../Math/Indexing";
+const voxelPos = Vector3Like.Create();
+const defaultBounds = [4, 4, 4];
+export class ConsistentRotationTextureProcedure extends TextureProcedure {
+    getTexture(builder, data, closestFace, primitive) {
+        return data.texture;
+    }
+    getOverlayTexture(builder, data, closestFace, primitive, ref) {
+        return ref;
+    }
+    transformUVs(builder, data, closestFace, primitive) {
+        const bounds = data.rotationBounds ? data.rotationBounds : defaultBounds;
+        WorldSpaces.voxel.getPositionFromIndex(builder.voxel._index, voxelPos);
+        const x = voxelPos.x - Math.floor(voxelPos.x / bounds[0]) * bounds[0];
+        const y = voxelPos.y - Math.floor(voxelPos.y / bounds[1]) * bounds[1];
+        const z = voxelPos.z - Math.floor(voxelPos.z / bounds[2]) * bounds[2];
+        const rotationIndex = GetYXZOrderArrayIndex(x, y, z, ...bounds) % data.rotations.length;
+        const rotation = data.rotations[rotationIndex];
+        for (const v of primitive.uvs.vertices) {
+            const oldX = v.x;
+            const oldY = v.y;
+            switch (rotation) {
+                case 90:
+                    v.x = 1 - oldY;
+                    v.y = oldX;
+                    break;
+                case 180:
+                    v.x = 1 - oldX;
+                    v.y = 1 - oldY;
+                    break;
+                case 270:
+                    v.x = oldY;
+                    v.y = 1 - oldX;
+                    break;
+                case 0:
+                default:
+                    break;
+            }
+        }
+    }
+}

package/Mesher/Models/Procedures/Default/OutlinedTextureProcedure.d.ts

@@ -0,0 +1,28 @@
+import { Vector4Like } from "@amodx/math";
+import type { Quad } from "../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import { TextureId } from "Textures";
+import { VoxelFaces } from "../../../../Math/index.js";
+interface OutlinedTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+    type: "outlined";
+    texture: TextureId | number;
+    textureRecrod: {
+        top: TextureId | number;
+        "corner-top-right": TextureId | number;
+        "corner-top-left": TextureId | number;
+        "corner-top-left-top-right": TextureId | number;
+        bottom: TextureId | number;
+        "corner-bottom-right": TextureId | number;
+        "corner-bottom-left": TextureId | number;
+        "corner-bottom-left-bottom-right": TextureId | number;
+        right: TextureId | number;
+        left: TextureId | number;
+    };
+}
+export declare class OutlinedTextureProcedure extends TextureProcedure<OutlinedTextureProcedureData> {
+    getTexture(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
+    getOverlayTexture(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
+    transformUVs(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
+}
+export {};

package/Mesher/Models/Procedures/Default/OutlinedTextureProcedure.js

@@ -0,0 +1,162 @@
+import { TextureProcedure } from "../TextureProcedure";
+import { VoxelFaces } from "../../../../Math/index.js";
+const textureMap = [
+    "top",
+    "corner-top-right",
+    "corner-top-left",
+    "corner-top-left-top-right",
+    "bottom",
+    "corner-bottom-right",
+    "corner-bottom-left",
+    "corner-bottom-left-bottom-right",
+    "right",
+    "left",
+];
+/*
+0 -> normal direction
+1 -> top right
+2 -> top left
+*/
+const uvsSets = {
+    //top bottom faces
+    north: {
+        0b0: 0,
+        0b101: 1,
+        0b011: 2,
+        0b001: 3,
+    },
+    south: {
+        0b0: 4,
+        0b101: 5,
+        0b011: 6,
+        0b001: 7,
+    },
+    east: {
+        0b0: 8,
+    },
+    west: {
+        0b0: 9,
+    },
+    //side faces
+    top: {
+        0b0: 0,
+        0b101: 1,
+        0b011: 2,
+        0b001: 3,
+    },
+    bottom: {
+        0b0: 4,
+        0b101: 5,
+        0b011: 6,
+        0b001: 7,
+    },
+    right: {
+        0b0: 8,
+    },
+    left: {
+        0b0: 9,
+    },
+};
+const topAndDown = {
+    north: [
+        [0, 0, 1],
+        [1, 0, 1],
+        [-1, 0, 1],
+    ],
+    south: [
+        [0, 0, -1],
+        [1, 0, -1],
+        [-1, 0, -1],
+    ],
+    east: [[1, 0, 0]],
+    west: [[-1, 0, 0]],
+};
+const eastAndWest = {
+    top: [
+        [0, 1, 0],
+        [0, 1, 1],
+        [0, 1, -1],
+    ],
+    bottom: [
+        [0, -1, 0],
+        [0, -1, 1],
+        [0, -1, -1],
+    ],
+    right: [[0, 0, 1]],
+    left: [[0, 0, -1]],
+};
+const northAndSouth = {
+    top: [
+        [0, 1, 0],
+        [1, 1, 0],
+        [-1, 1, 0],
+    ],
+    bottom: [
+        [0, -1, 0],
+        [1, -1, 0],
+        [-1, -1, 0],
+    ],
+    right: [[1, 0, 0]],
+    left: [[-1, 0, 0]],
+};
+const CheckSets = {
+    [VoxelFaces.Up]: topAndDown,
+    [VoxelFaces.Down]: topAndDown,
+    [VoxelFaces.North]: northAndSouth,
+    [VoxelFaces.South]: northAndSouth,
+    [VoxelFaces.East]: eastAndWest,
+    [VoxelFaces.West]: eastAndWest,
+};
+const generateCheck = (direction, tool, normal, sets) => {
+    const { x, y, z } = tool.position;
+    let key = 0b0;
+    for (let i = 0; i < sets.length; i++) {
+        const set = sets[i];
+        const cx = x + set[0];
+        const cy = y + set[1];
+        const cz = z + set[2];
+        const sameLevelCheck = tool.nVoxel
+            .getVoxel(cx, cy, cz)
+            ?.isSameVoxel(tool.voxel);
+        let normalCheck = true;
+        const nVoxel = tool.nVoxel.getVoxel(cx + normal[0], cy + normal[1], cz + normal[2]);
+        if (nVoxel && nVoxel.isRenderable() && nVoxel.isOpaque()) {
+            normalCheck = false;
+        }
+        if (sameLevelCheck && normalCheck) {
+            key |= 0b1 << i;
+        }
+        else {
+            key |= 0b0 << i;
+            if (i == 0)
+                break;
+        }
+    }
+    if (uvsSets[direction][key] == undefined)
+        return 0;
+    const index = uvsSets[direction][key];
+    return textureMap[index];
+};
+const normal = [0, 0, 0];
+export class OutlinedTextureProcedure extends TextureProcedure {
+    getTexture(builder, data, closestFace, primitive) {
+        return data.texture;
+    }
+    getOverlayTexture(builder, data, closestFace, primitive, ref) {
+        const set = CheckSets[closestFace];
+        const x = generateCheck("north", builder, normal, set.north);
+        if (x)
+            ref.x = data.textureRecrod[x];
+        const y = generateCheck("south", builder, normal, set.south);
+        if (y)
+            ref.y = data.textureRecrod[y];
+        const z = generateCheck("east", builder, normal, set.east);
+        if (z)
+            ref.z = data.textureRecrod[z];
+        const w = generateCheck("west", builder, normal, set.west);
+        if (w)
+            ref.w = data.textureRecrod[w];
+        return ref;
+    }
+    transformUVs(builder, data, closestFace, primitive) { }
+}

package/Mesher/Models/Procedures/TextureProcedure.d.ts

@@ -0,0 +1,16 @@
+import { Vector4Like } from "@amodx/math";
+import { Quad, Triangle } from "../../Geomtry";
+import { VoxelModelBuilder } from "../VoxelModelBuilder";
+import { VoxelFaces } from "../../../Math";
+import { TextureId } from "../../../Textures";
+export interface BaseVoxelGeomtryTextureProcedureData {
+    type: string;
+    texture?: TextureId | number;
+    textureRecrod?: Record<string, TextureId | number>;
+    [key: string]: any;
+}
+export declare abstract class TextureProcedure<Data = any> {
+    abstract getTexture(builder: VoxelModelBuilder, data: Data, closestFace: VoxelFaces, primitive: Quad | Triangle): number;
+    abstract getOverlayTexture(builder: VoxelModelBuilder, data: Data, closestFace: VoxelFaces, primitive: Quad | Triangle, ref: Vector4Like): Vector4Like;
+    abstract transformUVs(builder: VoxelModelBuilder, data: Data, closestFace: VoxelFaces, primitive: Quad | Triangle): void;
+}

package/Mesher/Models/Procedures/TextureProcedure.js

@@ -0,0 +1,2 @@
+export class TextureProcedure {
+}

package/Mesher/Models/Procedures/TextureProcedureRegister.d.ts

@@ -0,0 +1,6 @@
+import { TextureProcedure } from "./TextureProcedure";
+export declare class TextureProcedureRegister {
+    static procedures: Map<string, TextureProcedure<any>>;
+    static register(id: string, procedure: TextureProcedure): void;
+    static get(id: string): TextureProcedure<any>;
+}

package/Mesher/Models/Procedures/TextureProcedureRegister.js

@@ -0,0 +1,16 @@
+import { ConsistentRotationTextureProcedure } from "./Default/ConsistentRotationTextureProcedure";
+import { OutlinedTextureProcedure } from "./Default/OutlinedTextureProcedure";
+export class TextureProcedureRegister {
+    static procedures = new Map();
+    static register(id, procedure) {
+        this.procedures.set(id, procedure);
+    }
+    static get(id) {
+        const procedure = this.procedures.get(id);
+        if (!procedure)
+            throw new Error(`Procedure with id ${id} does not exist`);
+        return procedure;
+    }
+}
+TextureProcedureRegister.register("consistent-rotation", new ConsistentRotationTextureProcedure());
+TextureProcedureRegister.register("outlined", new OutlinedTextureProcedure());

package/Mesher/Models/VoxelConstructor.d.ts

@@ -1,8 +1,7 @@
 import { VoxelModelBuilder } from "./VoxelModelBuilder";
-import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Types/VoxelModelCompiledData.types";
+import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Models/CompiledVoxelModel.types";
 import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
 import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
-import { VoxelFaceTransparentResultsIndex } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
 import { VoxelModelEffect } from "./VoxelModelEffect";
 import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
 export declare class VoxelConstructor {
@@ -13,15 +12,12 @@ export declare class VoxelConstructor {
     geometries: number[][];
     modSchema: StateSchema;
     modTree: StateTreeReader;
-    transparentIndex: VoxelFaceTransparentResultsIndex;
     baseInputMap: any[];
     conditonalInputMap: any[];
     schema: StateSchema;
     effects: VoxelModelEffect;
-    shapeStateTree: StateTreeReader;
+    stateTree: StateTreeReader;
     condtioanlShapeStateTree: CondtionalTreeReader;
     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(): boolean;
 }

package/Mesher/Models/VoxelConstructor.js

@@ -1,7 +1,6 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
 import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
 import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
-import { VoxelFaceTransparentResultsIndex } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
 import { VoxelModelEffect } from "./VoxelModelEffect";
 import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
 export class VoxelConstructor {
@@ -12,12 +11,11 @@ export class VoxelConstructor {
     geometries = [];
     modSchema;
     modTree;
-    transparentIndex;
     baseInputMap;
     conditonalInputMap;
     schema;
     effects;
-    shapeStateTree;
+    stateTree;
     condtioanlShapeStateTree;
     constructor(id, builder, data, voxleData) {
         this.id = id;
@@ -25,20 +23,13 @@ export class VoxelConstructor {
         this.data = data;
         this.baseInputMap = voxleData.baseGeometryInputMap;
         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);
-    }
-    isCondtionalStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[shapeState][geoId]], faceIndex) == 1);
-    }
     process() {
         let added = false;
         const builder = this.builder;
@@ -46,8 +37,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++) {
@@ -73,9 +64,8 @@ export class VoxelConstructor {
                 const geometriesLength = geometries.length;
                 const inputs = this.conditonalInputMap[modState][c];
                 for (let i = 0; i < geometriesLength; i++) {
-                    const nodeId = geometries[i];
                     const geoInputs = inputs[i];
-                    const geomtry = VoxelModelConstructorRegister.geometry[this.data.geoLinkMap[nodeId]];
+                    const geomtry = VoxelModelConstructorRegister.geometry[geometries[i]];
                     const nodesLength = geomtry.nodes.length;
                     for (let k = 0; k < nodesLength; k++) {
                         const geo = geomtry.nodes[k];

package/Mesher/Models/VoxelGeometryBuilderCacheSpace.d.ts

@@ -15,8 +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;
     private hashState;
 }

package/Mesher/Models/VoxelGeometryBuilderCacheSpace.js

@@ -42,13 +42,13 @@ 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 VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.condiotnalShapeStateGeometryMap[this.conditonalStateCache[index]];
+            return null;
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.condiotanlGeometryStatePalette[this.conditonalStateCache[index]];
     }
     getHash(dataCursor, x, y, z) {
         const hashed = this.getIndex(x, y, z);
@@ -59,26 +59,26 @@ export class VoxelGeometryBuilderCacheSpace {
     }
     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 || !voxel.isRenderable()) {
             this.foundHash[index] = 1;
-            return -1;
+            return;
         }
-        const voxelId = voxel.getId();
+        const voxelId = voxel.getVoxelId();
         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());
@@ -91,6 +91,5 @@ export class VoxelGeometryBuilderCacheSpace {
         voxelConstructor.schema.dataCursor = dataCursor;
         const conditonalState = voxelConstructor.condtioanlShapeStateTree.getState();
         this.conditonalStateCache[index] = conditonalState;
-        return 1;
     }
 }

package/Mesher/Models/VoxelModelBuilder.d.ts

@@ -8,7 +8,6 @@ import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface.js";
 import { VoxelGeometryBuilderCacheSpace } from "./VoxelGeometryBuilderCacheSpace";
 declare class VoxelVars {
-    faceFlipped: boolean;
     textureIndex: number;
     overlayTextures: Vector4Like;
     light: QuadScalarVertexData;

package/Mesher/Models/VoxelModelBuilder.js

@@ -7,7 +7,6 @@ import calculateFaceData from "./Common/Calc/FaceDataCalc.js";
 import { VoxelMesh } from "../Geomtry/VoxelMesh";
 import { Vector3Like, Vector4Like } from "@amodx/math";
 class VoxelVars {
-    faceFlipped = false;
     textureIndex = 0;
     overlayTextures = Vector4Like.Create();
     light = new QuadScalarVertexData();
@@ -15,11 +14,11 @@ class VoxelVars {
     animation = new QuadScalarVertexData();
     level = new QuadScalarVertexData();
     reset() {
-        this.faceFlipped = false;
         this.textureIndex = 0;
         this.overlayTextures.x = 0;
         this.overlayTextures.y = 0;
         this.overlayTextures.z = 0;
+        this.overlayTextures.w = 0;
     }
 }
 export class VoxelModelBuilder {
@@ -86,7 +85,7 @@ export class VoxelModelBuilder {
         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();
@@ -94,13 +93,6 @@ export class VoxelModelBuilder {
             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;
     }

package/Mesher/Models/VoxelModelConstructorRegister.d.ts

@@ -1,12 +1,18 @@
 import { StringPalette } from "../../Util/StringPalette";
-import { CompiledVoxelGeometryRulessData, CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../Voxels/Types/VoxelModelCompiledData.types";
+import { CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../Voxels/Models/CompiledVoxelModel.types";
 import { GeoemtryNodeConstructor } from "./Nodes/GeometryNode";
 import { VoxelConstructor } from "./VoxelConstructor";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
+import { AOOcclusionFaceIndex } from "../../Voxels/Models/Indexing/AOOcclusionFaceIndex";
+import { CulledOcclusionFaceIndex } from "../../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
 export declare class VoxelModelConstructorRegister {
     static geometryPalette: StringPalette;
     static geometry: VoxelGeometryConstructor[];
     static rulesless: boolean[];
+    static aoIndex: AOOcclusionFaceIndex;
+    static faceCullIndex: CulledOcclusionFaceIndex;
+    static vertexHitMap: number[][][];
+    static faceCullMap: number[][];
     static setGeometryPalette(palette: string[]): void;
     static modelData: Map<string, CompiledVoxelModelData>;
     static customNodes: Map<string, GeoemtryNodeConstructor<any, any>>;
@@ -17,5 +23,5 @@ export declare class VoxelModelConstructorRegister {
     static constructors: Map<string, VoxelConstructor>;
     static getConstructor(id: string): VoxelConstructor;
     static registerVoxel(voxel: VoxelConstructor | VoxelConstructor[]): void;
-    static registerGeometry(geometries: (CompiledVoxelGeometrySyncData | CompiledVoxelGeometryRulessData)[]): void;
+    static registerGeometry(geometries: CompiledVoxelGeometrySyncData[]): void;
 }