@divinevoxel/vlox 0.0.78 → 0.0.80

package/Mesher/Voxels/Models/Common/Faces/CullRulledFace.js

@@ -1,7 +1,8 @@
-import { VoxelRelativeCubeIndexPositionMap } from "../../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
-import { VoxelModelConstructorRegister } from "../../VoxelModelConstructorRegister";
+import { VoxelLUT } from "../../../../../Voxels/Data/VoxelLUT";
+import { GeometryLUT } from "../../../../../Voxels/Data/GeometryLUT";
+import { VoxelRelativeCubeIndexPositionMap } from "../../../../../Voxels/Geometry/VoxelRelativeCubeIndex";
 export function CullRulledFace(builder, trueFaceIndex) {
-    const faceIndexes = VoxelModelConstructorRegister.faceCullMap[trueFaceIndex];
+    const faceIndexes = GeometryLUT.faceCullMap[trueFaceIndex];
     if (!faceIndexes)
         return true;
     for (let i = 0; i < faceIndexes.length; i++) {
@@ -10,47 +11,57 @@ export function CullRulledFace(builder, trueFaceIndex) {
         const hashed = builder.space.getHash(builder.nVoxel, builder.position.x + p[0], builder.position.y + p[1], builder.position.z + p[2]);
         if (builder.space.foundHash[hashed] < 2)
             continue;
-        const constructor = builder.space.getConstructor(hashed);
-        const offsetBaseGometry = builder.space.getGeomtry(hashed);
+        const voxelStringId = VoxelLUT.voxelIds.getStringId(builder.space.trueVoxelCache[hashed]);
+        const voxelId = builder.space.voxelCache[hashed];
+        const reltionalVoxelId = builder.space.reltionalVoxelCache[hashed];
+        const geometryIndex = VoxelLUT.getGeometryIndex(voxelId, reltionalVoxelId);
+        const offsetBaseGometry = GeometryLUT.geometryIndex[geometryIndex];
         if (offsetBaseGometry) {
             for (let i = 0; i < offsetBaseGometry.length; i++) {
                 const geoId = offsetBaseGometry[i];
-                if (VoxelModelConstructorRegister.rulesless[geoId])
+                if (GeometryLUT.rulelessIndex[geoId])
                     continue;
-                const cullingProcedure = VoxelModelConstructorRegister.geometry[geoId].cullingProcedure;
+                const cullingProcedure = GeometryLUT.geometryCullingProcedures[GeometryLUT.geometryCullingProceduresIndex[geoId]];
                 if (cullingProcedure.type == "transparent") {
-                    if (constructor.id != builder.voxel.getStringId())
+                    if (voxelStringId != builder.voxel.getStringId())
                         continue;
                 }
                 else {
                     if (cullingProcedure.type != "default")
                         continue;
                 }
-                if (VoxelModelConstructorRegister.faceCullIndex.getValue(geoId, directionIndex, trueFaceIndex) == 1) {
+                if (GeometryLUT.faceCullIndex.getValue(geoId, directionIndex, trueFaceIndex) == 1) {
                     return false;
                 }
             }
         }
-        const offsetConditonalGeometry = builder.space.getConditionalGeomtry(hashed);
+        const trueVoxelId = builder.space.trueVoxelCache[hashed];
+        const offsetConditonalGeometry = VoxelLUT.getConditionalGeometryNodes(trueVoxelId);
         if (offsetConditonalGeometry) {
+            const modelState = VoxelLUT.voxelIdToModelState[voxelId];
+            const reltioanlModSeltate = builder.space.reltionalStateCache[hashed];
             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])
+                const [geoId, requiredModelState, requiredReltionalModelState] = offsetConditonalGeometry[i];
+                if (requiredModelState !== modelState ||
+                    !requiredReltionalModelState[reltioanlModSeltate])
+                    continue;
+                const geomerties = GeometryLUT.geometryIndex[geoId];
+                for (let k = 0; k < geomerties.length; k++) {
+                    const geoId = geomerties[k];
+                    if (GeometryLUT.rulelessIndex[geoId])
                         continue;
-                    const cullingProcedure = VoxelModelConstructorRegister.geometry[geoId].cullingProcedure;
+                    const cullingProcedure = GeometryLUT.geometryCullingProcedures[GeometryLUT.geometryCullingProceduresIndex[geoId]];
                     if (cullingProcedure.type == "transparent") {
-                        if (constructor.id != builder.voxel.getStringId())
+                        if (voxelStringId != builder.voxel.getStringId())
                             continue;
                     }
                     else {
                         if (cullingProcedure.type != "default")
                             continue;
                     }
-                    if (VoxelModelConstructorRegister.rulesless[geoId])
+                    if (GeometryLUT.rulelessIndex[geoId])
                         continue;
-                    if (VoxelModelConstructorRegister.faceCullIndex.getValue(geoId, directionIndex, trueFaceIndex) == 1)
+                    if (GeometryLUT.faceCullIndex.getValue(geoId, directionIndex, trueFaceIndex) == 1)
                         return false;
                 }
             }

package/Mesher/Voxels/Models/Common/Faces/ShadeRulelessFace.d.ts

@@ -1,4 +1,4 @@
-import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
+import { QuadVerticies } from "../../../../Geometry/Geometry.types";
 import { VoxelModelBuilder } from "../../../Models/VoxelModelBuilder";
 import { Vec4Array } from "@amodx/math";
 export declare function ShadeRulelessFace(builder: VoxelModelBuilder, lightData: Record<QuadVerticies, number>, vertexWeights: Vec4Array[], verticesStride: number): void;

package/Mesher/Voxels/Models/Common/Faces/ShadeRulledFace.d.ts

@@ -1,4 +1,4 @@
 import { VoxelModelBuilder } from "../../VoxelModelBuilder";
 import { Vec4Array } from "@amodx/math";
-import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
+import { QuadVerticies } from "../../../../Geometry/Geometry.types";
 export declare function ShadeRulledFace(builder: VoxelModelBuilder, trueFaceIndex: number, lightData: Record<QuadVerticies, number>, vertexWeights: Vec4Array[], vertexStride: number): void;

package/Mesher/Voxels/Models/Common/Faces/ShadeRulledFace.js

@@ -1,6 +1,7 @@
-import { VoxelRelativeCubeIndexPositionMap } from "../../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
-import { VoxelModelConstructorRegister } from "../../VoxelModelConstructorRegister";
+import { VoxelRelativeCubeIndexPositionMap } from "../../../../../Voxels/Geometry/VoxelRelativeCubeIndex";
+import { GeometryLUT } from "../../../../../Voxels/Data/GeometryLUT";
 import { getInterpolationValue } from "../Calc/CalcConstants";
+import { VoxelLUT } from "../../../../../Voxels/Data/VoxelLUT";
 export function ShadeRulledFace(builder, trueFaceIndex, lightData, vertexWeights, vertexStride) {
     const noAO = builder.voxel.isLightSource() || builder.voxel.noAO();
     const worldLight = builder.vars.light;
@@ -10,7 +11,7 @@ export function ShadeRulledFace(builder, trueFaceIndex, lightData, vertexWeights
         worldLight.vertices[v] = getInterpolationValue(lightData, vertexWeights[v]);
         if (noAO)
             continue;
-        const aoIndexes = VoxelModelConstructorRegister.vertexHitMap[trueFaceIndex][v];
+        const aoIndexes = GeometryLUT.aoVertexHitMap[trueFaceIndex][v];
         if (!aoIndexes)
             continue;
         for (let i = 0; i < aoIndexes.length; i++) {
@@ -20,16 +21,15 @@ export function ShadeRulledFace(builder, trueFaceIndex, lightData, vertexWeights
             if (builder.space.foundHash[hashed] < 2 ||
                 builder.space.noCastAO[hashed] === 1)
                 continue;
-            const baseGeo = builder.space.getGeomtry(hashed);
-            const conditonalGeo = builder.space.getConditionalGeomtry(hashed);
-            if (!baseGeo && !conditonalGeo)
-                continue;
-            let length = 0;
+            const voxelId = builder.space.voxelCache[hashed];
+            const reltionalVoxelId = builder.space.reltionalVoxelCache[hashed];
+            const geometryIndex = VoxelLUT.getGeometryIndex(voxelId, reltionalVoxelId);
+            const baseGeo = GeometryLUT.geometryIndex[geometryIndex];
+            //  if (!baseGeo && !conditonalGeo) continue;
             let shaded = false;
             if (baseGeo) {
-                length = baseGeo.length;
-                for (let geoIndex = 0; geoIndex < length; geoIndex++) {
-                    if (VoxelModelConstructorRegister.aoIndex.getValue(baseGeo[geoIndex], directionIndex, trueFaceIndex, v)) {
+                for (let geoIndex = 0; geoIndex < baseGeo.length; geoIndex++) {
+                    if (GeometryLUT.aoIndex.getValue(baseGeo[geoIndex], directionIndex, trueFaceIndex, v)) {
                         worldAO.vertices[v]++;
                         if (worldAO.vertices[v] >= 3) {
                             shaded = true;
@@ -38,17 +38,27 @@ export function ShadeRulledFace(builder, trueFaceIndex, lightData, vertexWeights
                     }
                 }
             }
-            if (!conditonalGeo || shaded)
+            if (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 (VoxelModelConstructorRegister.aoIndex.getValue(conditonalGeo[condtionsIndex][geoIndex], directionIndex, trueFaceIndex, v)) {
-                        worldAO.vertices[v]++;
-                        if (worldAO.vertices[v] >= 3) {
-                            shaded = true;
-                            break;
+            const trueVoxelId = builder.space.trueVoxelCache[hashed];
+            const offsetConditonalGeometry = VoxelLUT.getConditionalGeometryNodes(trueVoxelId);
+            if (offsetConditonalGeometry) {
+                const modelState = VoxelLUT.voxelIdToModelState[voxelId];
+                const reltioanlModSeltate = builder.space.reltionalStateCache[hashed];
+                for (let i = 0; i < offsetConditonalGeometry.length; i++) {
+                    const [geoId, requiredModelState, requiredReltionalModelState] = offsetConditonalGeometry[i];
+                    if (requiredModelState !== modelState ||
+                        !requiredReltionalModelState[reltioanlModSeltate])
+                        continue;
+                    const geomerties = GeometryLUT.geometryIndex[geoId];
+                    for (let geoIndex = 0; geoIndex < geomerties.length; geoIndex++) {
+                        const geoId = geomerties[geoIndex];
+                        if (GeometryLUT.aoIndex.getValue(geoId, directionIndex, trueFaceIndex, v)) {
+                            worldAO.vertices[v]++;
+                            if (worldAO.vertices[v] >= 3) {
+                                shaded = true;
+                                break;
+                            }
                         }
                     }
                 }

package/Mesher/Voxels/Models/Common/GetTexture.d.ts

@@ -1,6 +1,6 @@
-import { BaseVoxelGeomtryTextureProcedureData } from "../Procedures/TextureProcedure";
+import { BaseVoxelGeometryTextureProcedureData } from "../Procedures/TextureProcedure";
 import { VoxelModelBuilder } from "../VoxelModelBuilder";
-import { Quad } from "../../../Geomtry";
+import { Quad } from "../../../Geometry";
 import { VoxelFaces } from "../../../../Math";
-import { Triangle } from "../../../Geomtry";
-export declare function GetTexture(builder: VoxelModelBuilder, data: number | BaseVoxelGeomtryTextureProcedureData, closestFace: VoxelFaces, primitive: Quad | Triangle): void;
+import { Triangle } from "../../../Geometry";
+export declare function GetTexture(builder: VoxelModelBuilder, data: number | BaseVoxelGeometryTextureProcedureData, closestFace: VoxelFaces, primitive: Quad | Triangle): void;

package/Mesher/Voxels/Models/Nodes/Custom/Liquid/FlowGradient.d.ts

@@ -1,5 +1,5 @@
 import type { VoxelModelBuilder } from "../../../VoxelModelBuilder";
-import { QuadScalarVertexData } from "../../../../../Geomtry/Primitives/QuadVertexData";
+import { QuadScalarVertexData } from "../../../../../Geometry/Primitives/QuadVertexData";
 import { CompassAngles } from "@amodx/math";
 export declare enum FlowVerticies {
     NorthEast = 0,

package/Mesher/Voxels/Models/Nodes/Custom/Liquid/FlowGradient.js

@@ -1,4 +1,4 @@
-import { QuadVerticies } from "../../../../../Geomtry/Geometry.types";
+import { QuadVerticies } from "../../../../../Geometry/Geometry.types";
 import { CompassAngles } from "@amodx/math";
 var FlowStates;
 (function (FlowStates) {

package/Mesher/Voxels/Models/Nodes/Custom/Liquid/{LiquidGeomtryNode.d.ts → LiquidGeometryNode.d.ts}

@@ -1,8 +1,8 @@
 import { GeoemtryNode } from "../../GeometryNode";
-import { VoxelCustomGeomtryNode } from "../../../../../../Voxels/Models/VoxelModel.types";
+import { VoxelCustomGeometryNode } from "../../../../../../Voxels/Geometry/VoxelGeometry.types";
 import { VoxelFaces } from "../../../../../../Math";
 import type { LiquidVoxelModelArgs } from "../../../../../../Voxels/Models/Defaults/LiquidVoxelModel";
-export declare class LiquidGeometryNode extends GeoemtryNode<VoxelCustomGeomtryNode, LiquidVoxelModelArgs> {
+export declare class LiquidGeometryNode extends GeoemtryNode<VoxelCustomGeometryNode, LiquidVoxelModelArgs> {
     init(): void;
     isExposed(face: VoxelFaces): boolean;
     determineShading(face: VoxelFaces): void;

package/Mesher/Voxels/Models/Nodes/Custom/Liquid/{LiquidGeomtryNode.js → LiquidGeometryNode.js}

@@ -1,14 +1,14 @@
 import { GeoemtryNode } from "../../GeometryNode";
 import { CompassAngles } from "@amodx/math";
-import { Quad } from "../../../../../Geomtry/Primitives/Quad";
-import { QuadVerticies, } from "../../../../../Geomtry/Geometry.types";
-import { QuadScalarVertexData } from "../../../../../Geomtry/Primitives/QuadVertexData";
+import { Quad } from "../../../../../Geometry/Primitives/Quad";
+import { QuadVerticies, } from "../../../../../Geometry/Geometry.types";
+import { QuadScalarVertexData } from "../../../../../Geometry/Primitives/QuadVertexData";
 import { VoxelFaceDirections, VoxelFaces } from "../../../../../../Math";
 import { getFlowAngle, getFlowGradient, FlowVerticies } from "./FlowGradient";
 import { VoxelLightData } from "../../../../../../Voxels/Cursor/VoxelLightData";
-import { addVoxelQuad } from "../../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelQuad } from "../../../../Geometry/VoxelGeometryBuilder";
 import { GetTexture } from "../../../Common/GetTexture";
-import { Box } from "../../../../../Geomtry/Shapes/Box";
+import { Box } from "../../../../../Geometry/Shapes/Box";
 const vertexValue = new QuadScalarVertexData();
 const vertexLevel = new QuadScalarVertexData();
 const lightData = new VoxelLightData();

package/Mesher/Voxels/Models/Nodes/Default/QuadVoxelGeometryNode.d.ts

@@ -1,9 +1,9 @@
 import { Vec4Array } from "@amodx/math";
 import { VoxelFaces } from "../../../../../Math";
-import { Quad } from "../../../../Geomtry/Primitives/Quad";
+import { Quad } from "../../../../Geometry/Primitives/Quad";
 import { GeoemtryNode } from "../GeometryNode";
-import { CompiledQuadVoxelGeomtryNode, QuadVoxelGometryArgs } from "../Types/QuadVoxelGometryNodeTypes";
-export declare class QuadVoxelGometryNode extends GeoemtryNode<CompiledQuadVoxelGeomtryNode, QuadVoxelGometryArgs> {
+import { CompiledQuadVoxelGeometryNode, QuadVoxelGometryArgs } from "../Types/QuadVoxelGometryNodeTypes";
+export declare class QuadVoxelGometryNode extends GeoemtryNode<CompiledQuadVoxelGeometryNode, QuadVoxelGometryArgs> {
     quad: Quad;
     vertexWeights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
     closestFace: VoxelFaces;

package/Mesher/Voxels/Models/Nodes/Default/QuadVoxelGeometryNode.js

@@ -1,5 +1,5 @@
-import { Quad } from "../../../../Geomtry/Primitives/Quad";
-import { addVoxelQuad } from "../../../Geomtry/VoxelGeometryBuilder";
+import { Quad } from "../../../../Geometry/Primitives/Quad";
+import { addVoxelQuad } from "../../../Geometry/VoxelGeometryBuilder";
 import { GeoemtryNode } from "../GeometryNode";
 import { QuadVoxelGometryInputs, } from "../Types/QuadVoxelGometryNodeTypes";
 import { GetTexture } from "../../Common/GetTexture";

package/Mesher/Voxels/Models/Nodes/Default/TriangleVoxelGeometryNode.d.ts

@@ -1,9 +1,9 @@
 import { Vec4Array } from "@amodx/math";
 import { VoxelFaces } from "../../../../../Math";
 import { GeoemtryNode } from "../GeometryNode";
-import { CompiledTriangleVoxelGeomtryNode, TriangleVoxelGometryArgs } from "../Types/TriangleVoxelGometryNodeTypes";
-import { Triangle } from "../../../../Geomtry/Primitives/Triangle";
-export declare class TriangleVoxelGeometryNode extends GeoemtryNode<CompiledTriangleVoxelGeomtryNode, TriangleVoxelGometryArgs> {
+import { CompiledTriangleVoxelGeometryNode, TriangleVoxelGometryArgs } from "../Types/TriangleVoxelGometryNodeTypes";
+import { Triangle } from "../../../../Geometry/Primitives/Triangle";
+export declare class TriangleVoxelGeometryNode extends GeoemtryNode<CompiledTriangleVoxelGeometryNode, TriangleVoxelGometryArgs> {
     triangle: Triangle;
     vertexWeights: Vec4Array[];
     closestFace: VoxelFaces;

package/Mesher/Voxels/Models/Nodes/Default/TriangleVoxelGeometryNode.js

@@ -1,8 +1,8 @@
-import { addVoxelTriangle } from "../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelTriangle } from "../../../Geometry/VoxelGeometryBuilder";
 import { GeoemtryNode } from "../GeometryNode";
 import { GetTexture } from "../../Common/GetTexture";
 import { TriangleVoxelGometryInputs, } from "../Types/TriangleVoxelGometryNodeTypes";
-import { Triangle } from "../../../../Geomtry/Primitives/Triangle";
+import { Triangle } from "../../../../Geometry/Primitives/Triangle";
 import { CullRulledFace } from "../../Common/Faces/CullRulledFace";
 import { ShadeRulledFace } from "../../Common/Faces/ShadeRulledFace";
 import { ShadeRulelessFace } from "../../Common/Faces/ShadeRulelessFace";

package/Mesher/Voxels/Models/Nodes/GeometryNode.d.ts

@@ -1,14 +1,14 @@
 import { VoxelModelBuilder } from "../VoxelModelBuilder";
 import { VoxelGeometryConstructor } from "./VoxelGeometryConstructor";
 export interface GeoemtryNodeConstructor<Data = any, Args = any> {
-    new (geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data): GeoemtryNode<Data, Args>;
+    new (geometryPaletteId: number, geometry: VoxelGeometryConstructor, data: Data): GeoemtryNode<Data, Args>;
 }
 export declare abstract class GeoemtryNode<Data = any, Args = any> {
     geometryPaletteId: number;
-    geomtry: VoxelGeometryConstructor;
+    geometry: VoxelGeometryConstructor;
     data: Data;
     builder: VoxelModelBuilder;
-    constructor(geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data);
+    constructor(geometryPaletteId: number, geometry: VoxelGeometryConstructor, data: Data);
     abstract init(): void;
     abstract add(args: Args): boolean;
 }

package/Mesher/Voxels/Models/Nodes/GeometryNode.js

@@ -1,11 +1,11 @@
 export class GeoemtryNode {
     geometryPaletteId;
-    geomtry;
+    geometry;
     data;
     builder;
-    constructor(geometryPaletteId, geomtry, data) {
+    constructor(geometryPaletteId, geometry, data) {
         this.geometryPaletteId = geometryPaletteId;
-        this.geomtry = geomtry;
+        this.geometry = geometry;
         this.data = data;
     }
 }

package/Mesher/Voxels/Models/Nodes/Types/GeometryNode.types.d.ts

@@ -0,0 +1,7 @@
+import { CompiledQuadVoxelGeometryNode } from "./QuadVoxelGometryNodeTypes";
+import { CompiledTriangleVoxelGeometryNode } from "./TriangleVoxelGometryNodeTypes";
+export type CompiledCustomGeometryNode = {
+    type: "custom";
+    id: string;
+};
+export type CompiledGeometryNodes = CompiledQuadVoxelGeometryNode | CompiledTriangleVoxelGeometryNode | CompiledCustomGeometryNode;

package/Mesher/Voxels/Models/Nodes/Types/QuadVoxelGometryNodeTypes.d.ts

@@ -1,9 +1,9 @@
 import { Vec3Array, Vec4Array } from "@amodx/math";
-import { QuadUVData } from "../../../../Geomtry/Geometry.types";
+import { QuadUVData } from "../../../../Geometry/Geometry.types";
 import { VoxelFaces } from "../../../../../Math";
 export type QuadVoxelGometryArgs = [
     enabled: boolean,
-    texture: number,
+    texture: any,
     rotation: number,
     doubleSided: boolean,
     uvs: QuadUVData
@@ -15,7 +15,7 @@ declare enum ArgIndexes {
     DoubleSided = 3,
     UVs = 4
 }
-export type CompiledQuadVoxelGeomtryNode = {
+export type CompiledQuadVoxelGeometryNode = {
     type: "quad";
     positions: [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
     weights: [Vec4Array, Vec4Array, Vec4Array, Vec4Array];

package/Mesher/Voxels/Models/Nodes/Types/TriangleVoxelGometryNodeTypes.d.ts

@@ -2,7 +2,7 @@ import { Vec2Array, Vec3Array, Vec4Array } from "@amodx/math";
 import { VoxelFaces } from "../../../../../Math";
 export type TriangleVoxelGometryArgs = [
     enabled: boolean,
-    texture: number,
+    texture: any,
     rotation: number,
     doubleSided: boolean,
     uvs: [v1: Vec2Array, v2: Vec2Array, v3: Vec2Array]
@@ -14,7 +14,7 @@ declare enum ArgIndexes {
     DoubleSided = 3,
     UVs = 4
 }
-export type CompiledTriangleVoxelGeomtryNode = {
+export type CompiledTriangleVoxelGeometryNode = {
     type: "triangle";
     positions: [Vec3Array, Vec3Array, Vec3Array];
     weights: [Vec4Array, Vec4Array, Vec4Array];

package/Mesher/Voxels/Models/Nodes/VoxelGeometryConstructor.d.ts

@@ -1,9 +1,8 @@
-import { CompiledVoxelGeometrySyncData } from "../../../../Voxels/Models/CompiledVoxelModel.types";
 import { GeoemtryNode } from "./GeometryNode";
-import { CullingProcedureData } from "../../../../Voxels/Models/VoxelModel.types";
+import { CullingProcedureData } from "../../../../Voxels/Geometry/VoxelGeometry.types";
 export declare class VoxelGeometryConstructor {
     geometryPaletteId: number;
     nodes: GeoemtryNode<any, any>[];
     cullingProcedure: CullingProcedureData;
-    constructor(geometryPaletteId: number, data: CompiledVoxelGeometrySyncData);
+    constructor(geometryPaletteId: number);
 }

package/Mesher/Voxels/Models/Nodes/VoxelGeometryConstructor.js

@@ -1,22 +1,23 @@
 import { QuadVoxelGometryNode } from "./Default/QuadVoxelGeometryNode";
 import { TriangleVoxelGeometryNode } from "./Default/TriangleVoxelGeometryNode";
 import { VoxelModelConstructorRegister } from "../VoxelModelConstructorRegister";
+import { GeometryLUT } from "../../../../Voxels/Data/GeometryLUT";
 export class VoxelGeometryConstructor {
     geometryPaletteId;
     nodes = [];
     cullingProcedure;
-    constructor(geometryPaletteId, data) {
+    constructor(geometryPaletteId) {
         this.geometryPaletteId = geometryPaletteId;
-        this.cullingProcedure = data.cullingProcedure;
-        for (const node of data.nodes) {
+        this.cullingProcedure =
+            GeometryLUT.geometryCullingProcedures[GeometryLUT.geometryCullingProceduresIndex[geometryPaletteId]];
+        const nodes = GeometryLUT.compiledGeometry[geometryPaletteId];
+        for (const node of nodes) {
             if (node.type == "custom") {
                 const nodeClass = VoxelModelConstructorRegister.getCustomNode(node.id);
                 const newNode = new nodeClass(geometryPaletteId, this, node);
                 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();

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

@@ -1,14 +1,14 @@
 import { Vec3Array, Vector4Like } from "@amodx/math";
-import type { Quad } from "../../../../Geomtry";
-import { VoxelModelBuilder } from "Mesher/Voxels/Models/VoxelModelBuilder";
-import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import type { Quad } from "../../../../Geometry";
+import { VoxelModelBuilder } from "../../../Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeometryTextureProcedureData } 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.
  */
-export interface ConsistentRotationTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+export interface ConsistentRotationTextureProcedureData extends BaseVoxelGeometryTextureProcedureData {
     type: "consistent-rotation";
     texture: TextureId | number;
     /**

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

@@ -1,10 +1,10 @@
 import { Vector4Like } from "@amodx/math";
-import type { Quad } from "../../../../Geomtry";
-import { VoxelModelBuilder } from "Mesher/Voxels/Models/VoxelModelBuilder";
-import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import type { Quad } from "../../../../Geometry";
+import { VoxelModelBuilder } from "../../../Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeometryTextureProcedureData } from "../TextureProcedure";
 import { TextureId } from "Textures";
 import { VoxelFaces } from "../../../../../Math/index.js";
-export interface OutlinedTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+export interface OutlinedTextureProcedureData extends BaseVoxelGeometryTextureProcedureData {
     type: "outlined";
     texture: TextureId | number;
     textureRecrod: {

package/Mesher/Voxels/Models/Procedures/Default/PillarTextureProcedure.d.ts

@@ -1,14 +1,14 @@
 import { Vector4Like } from "@amodx/math";
-import type { Quad } from "../../../../Geomtry";
-import { VoxelModelBuilder } from "Mesher/Voxels/Models/VoxelModelBuilder";
-import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import type { Quad } from "../../../../Geometry";
+import { VoxelModelBuilder } from "../../../Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeometryTextureProcedureData } 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.
  */
-export interface PillarTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+export interface PillarTextureProcedureData extends BaseVoxelGeometryTextureProcedureData {
     type: "pillar";
     texture: TextureId | number;
     textureRecrod: {

package/Mesher/Voxels/Models/Procedures/Default/PillarTextureProcedure.js

@@ -1,5 +1,6 @@
 import { TextureProcedure, } from "../TextureProcedure";
 import { VoxelFaces } from "../../../../../Math";
+import { VoxelLUT } from "../../../../../Voxels/Data/VoxelLUT";
 export class PillarTextureProcedure extends TextureProcedure {
     getTexture(builder, data, closestFace, primitive) {
         if (data.direction == "up-down") {
@@ -8,11 +9,16 @@ export class PillarTextureProcedure extends TextureProcedure {
             if (closestFace == VoxelFaces.Down)
                 return data.textureRecrod.downTex;
             let sideTexture = data.textureRecrod.sideDisconnectedTex;
+            const currentState = VoxelLUT.voxelIdToModelState[builder.voxel.getId()];
             const topVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y + 1, builder.position.z);
-            const topSame = topVoxel ? builder.voxel.isSameVoxel(topVoxel) : false;
+            const topSame = topVoxel
+                ? builder.voxel.isSameVoxel(topVoxel) &&
+                    VoxelLUT.voxelIdToModelState[topVoxel.getId()] == currentState
+                : false;
             const bottomVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y - 1, builder.position.z);
             const bottomSame = bottomVoxel
-                ? builder.voxel.isSameVoxel(bottomVoxel)
+                ? builder.voxel.isSameVoxel(bottomVoxel) &&
+                    VoxelLUT.voxelIdToModelState[bottomVoxel.getId()] == currentState
                 : false;
             if (topSame && !bottomSame) {
                 sideTexture = data.textureRecrod.sideDownTex;
@@ -35,13 +41,16 @@ export class PillarTextureProcedure extends TextureProcedure {
             if (closestFace == VoxelFaces.South)
                 return data.textureRecrod.downTex;
             let sideTexture = data.textureRecrod.sideDisconnectedTex;
+            const currentState = VoxelLUT.voxelIdToModelState[builder.voxel.getId()];
             const northVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y, builder.position.z + 1);
             const northSame = northVoxel
-                ? builder.voxel.isSameVoxel(northVoxel)
+                ? builder.voxel.isSameVoxel(northVoxel) &&
+                    VoxelLUT.voxelIdToModelState[northVoxel.getId()] == currentState
                 : false;
             const southVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y, builder.position.z - 1);
             const southSame = southVoxel
-                ? builder.voxel.isSameVoxel(southVoxel)
+                ? builder.voxel.isSameVoxel(southVoxel) &&
+                    VoxelLUT.voxelIdToModelState[southVoxel.getId()] == currentState
                 : false;
             if (northSame && !southSame) {
                 sideTexture = data.textureRecrod.sideDownTex;
@@ -64,12 +73,17 @@ export class PillarTextureProcedure extends TextureProcedure {
             if (closestFace == VoxelFaces.West)
                 return data.textureRecrod.downTex;
             let sideTexture = data.textureRecrod.sideDisconnectedTex;
+            const currentState = VoxelLUT.voxelIdToModelState[builder.voxel.getId()];
             const eastVoxel = builder.nVoxel.getVoxel(builder.position.x + 1, builder.position.y, builder.position.z);
             const northSame = eastVoxel
-                ? builder.voxel.isSameVoxel(eastVoxel)
+                ? builder.voxel.isSameVoxel(eastVoxel) &&
+                    VoxelLUT.voxelIdToModelState[eastVoxel.getId()] == currentState
                 : false;
             const westVoxel = builder.nVoxel.getVoxel(builder.position.x - 1, builder.position.y, builder.position.z);
-            const westSame = westVoxel ? builder.voxel.isSameVoxel(westVoxel) : false;
+            const westSame = westVoxel
+                ? builder.voxel.isSameVoxel(westVoxel) &&
+                    VoxelLUT.voxelIdToModelState[westVoxel.getId()] == currentState
+                : false;
             if (northSame && !westSame) {
                 sideTexture = data.textureRecrod.sideDownTex;
             }

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

@@ -1,9 +1,9 @@
 import { Vector4Like } from "@amodx/math";
-import { Quad, Triangle } from "../../../Geomtry";
+import { Quad, Triangle } from "../../../Geometry";
 import { VoxelModelBuilder } from "../VoxelModelBuilder";
 import { VoxelFaces } from "../../../../Math";
 import { TextureId } from "../../../../Textures";
-export interface BaseVoxelGeomtryTextureProcedureData {
+export interface BaseVoxelGeometryTextureProcedureData {
     type: string;
     texture?: TextureId | number;
     textureRecrod?: Record<string, TextureId | number>;

package/Mesher/Voxels/Models/VoxelConstructor.d.ts

@@ -1,23 +1,8 @@
 import { VoxelModelBuilder } from "./VoxelModelBuilder";
-import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../../Voxels/Models/CompiledVoxelModel.types";
-import { StateSchema } from "../../../Voxels/State/Schema/StateSchema";
-import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
-import { VoxelModelEffect } from "./VoxelModelEffect";
-import { CondtionalTreeReader } from "../../../Voxels/State/CondiotnalTreeReader";
 export declare class VoxelConstructor {
     id: string;
     builder: VoxelModelBuilder;
-    data: CompiledVoxelModelData;
     isModel: true;
-    geometries: number[][];
-    modSchema: StateSchema;
-    modTree: StateTreeReader;
-    baseInputMap: any[];
-    conditonalInputMap: any[];
-    schema: StateSchema;
-    effects: VoxelModelEffect;
-    stateTree: StateTreeReader;
-    condtioanlShapeStateTree: CondtionalTreeReader;
-    constructor(id: string, builder: VoxelModelBuilder, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
+    constructor(id: string, builder: VoxelModelBuilder);
     process(): boolean;
 }