@divinevoxel/vlox 0.0.74 → 0.0.75

package/Voxels/Functions/BuildPaletteData.js

@@ -0,0 +1,87 @@
+import { SchemaRegister } from "../State/SchemaRegister";
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { EngineStats } from "../../Stats/EngineStats";
+function recurse(index, current, result, valuePairs) {
+    if (index === valuePairs.length) {
+        result.push(current.join(","));
+        return;
+    }
+    const [key, values] = valuePairs[index];
+    for (const value of values) {
+        current.push(`${key}=${value}`);
+        recurse(index + 1, current, result, valuePairs);
+        current.pop();
+    }
+}
+function getAllCombinations(valuePairs) {
+    const result = [];
+    recurse(0, [], result, valuePairs);
+    return result;
+}
+export function BuildPaletteData(props) {
+    const models = new Map(props.models.models.map((_) => [_.id, _]));
+    const modelStateArray = new Map();
+    for (const [, model] of models) {
+        const schema = SchemaRegister.getModelSchema(model.id);
+        const valuePairs = [];
+        for (const node of schema.nodes) {
+            valuePairs.push([
+                node.name,
+                node.valuePalette
+                    ? node.valuePalette._palette
+                    : new Array(node.bitMask + 1).fill(0).map((_, i) => `${i}`),
+            ]);
+        }
+        const stateStrings = getAllCombinations(valuePairs);
+        const statePalette = [];
+        for (const state of stateStrings) {
+            const value = schema.readString(!state ? "*" : state);
+            statePalette.push(value);
+        }
+        modelStateArray.set(model.id, statePalette);
+    }
+    const finalPalette = [[0, 0, 0]];
+    const finalPaletteRecord = [[[0]]];
+    let paletteCount = 1;
+    for (const voxel of props.models.voxels) {
+        const schema = SchemaRegister.getVoxelModSchema(voxel.id);
+        const valuePairs = [];
+        for (const node of schema.nodes) {
+            valuePairs.push([
+                node.name,
+                node.valuePalette
+                    ? node.valuePalette._palette
+                    : new Array(node.bitMask + 1).fill(0).map((_, i) => `${i}`),
+            ]);
+        }
+        const stateStrings = getAllCombinations(valuePairs);
+        const modPalette = [];
+        if (valuePairs.length) {
+            for (const state of stateStrings) {
+                const value = schema.readString(!state ? "*" : state);
+                modPalette.push(value);
+            }
+        }
+        else {
+            modPalette.push(0);
+        }
+        const voxelId = VoxelPalettesRegister.voxelIds.getNumberId(voxel.id);
+        const statePalette = modelStateArray.get(voxel.modelId);
+        finalPaletteRecord[voxelId] = new Array(modPalette.length).fill(-1);
+        for (let modIndex = 0; modIndex < modPalette.length; modIndex++) {
+            finalPaletteRecord[voxelId][modPalette[modIndex]] = new Array(statePalette.length).fill(-1);
+            for (let stateIndex = 0; stateIndex < statePalette.length; stateIndex++) {
+                finalPalette[paletteCount] = [
+                    voxelId,
+                    statePalette[stateIndex],
+                    modPalette[modIndex],
+                ];
+                finalPaletteRecord[voxelId][modPalette[modIndex]][statePalette[stateIndex]] = paletteCount;
+                paletteCount++;
+            }
+        }
+    }
+    EngineStats.palette.paletteSize = finalPalette.length;
+    VoxelPalettesRegister.voxels = finalPalette;
+    VoxelPalettesRegister.voxelRecord = finalPaletteRecord;
+}

package/Voxels/Functions/BuildStateData.d.ts

@@ -1,16 +1,14 @@
-import { BinarySchemaNodeData, VoxelRelationsScehmaNodeData, StateLogicStatement } from "../State/State.types";
-import { VoxelRulesModoel } from "../../Models/Rules/Classes/VoxelRulesModel";
+import { StateLogicStatement, VoxelStateSchemaData } from "../State/State.types";
+import { VoxelRulesModoel } from "../Models/Rules/Classes/VoxelRulesModel";
 import { StringPalette } from "../../Util/StringPalette";
 import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
 export declare function BuildStateData(model: VoxelRulesModoel, geoPalette: StringPalette): {
-    schema: (BinarySchemaNodeData | VoxelRelationsScehmaNodeData)[];
+    schema: VoxelStateSchemaData;
     effects: VoxelEffectSyncData[];
     stateGeometryPalette: number[][];
     condiotnalShapeStateGeometryPalette: number[][];
     stateTree: any[];
-    geometryLinkPalette: Record<string, number>;
-    geometryLinkStateMap: number[];
-    relativeByteCount: number;
+    geometryLinkStateMap: Record<string, Record<number, number>>;
     statePalette: number[][];
     stateRecord: Record<string, number>;
     condiotnalNodeStateTree: any;

package/Voxels/Functions/BuildStateData.js

@@ -1,19 +1,6 @@
 import { StateCompareOperationsMap, StateLogicOperationsMap, } from "../State/State.types";
 import { StringPalette } from "../../Util/StringPalette";
-import { VoxelModelRuleBuilderRegister } from "../../Models/Rules/VoxelModelRuleBuilderRegister";
-import { VoxelTagStates } from "../Data/VoxelTagStates";
-import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
-import { StateSchema } from "../State/Schema/StateSchema";
-function bitsNeeded(n) {
-    if (n < 0)
-        throw new Error("Input must be a non-negative integer.");
-    let bits = 0;
-    while (n > 0) {
-        bits++;
-        n >>= 1;
-    }
-    return bits;
-}
+import { VoxelModelRuleBuilderRegister } from "../Models/Rules/VoxelModelRuleBuilderRegister";
 class StateTreeNode {
     id;
     children = new Map();
@@ -116,51 +103,23 @@ function reMapTree(schemaIdPalette, schemaValuePalette, baseObj, newObj, modelOr
     return newObj;
 }
 function buildSchemas(binaryNodes, relationNodes) {
-    const baseSchema = [];
+    const baseSchema = {
+        binary: [],
+        relational: [],
+    };
     const schemaIdPalette = new StringPalette();
     const schemaValuePalette = new Map();
-    {
-        let bitIndex = 0;
-        for (const schemaNode of binaryNodes) {
-            schemaIdPalette.register(schemaNode.name);
-            const maxBits = bitsNeeded(schemaNode.type == "string"
-                ? Object.keys(schemaNode.values)
-                    .map((_) => Number(_))
-                    .sort((a, b) => a - b)
-                    .pop()
-                : schemaNode.maxValue);
-            const nodeData = {
-                id: schemaNode.name,
-                type: "binary",
-                index: bitIndex,
-                mask: (1 << maxBits) - 1,
-            };
-            bitIndex += maxBits;
-            if (schemaNode.type == "string") {
-                const valuePalette = new StringPalette();
-                for (const vIndex in schemaNode.values) {
-                    const vValue = schemaNode.values[vIndex];
-                    valuePalette.register(vValue);
-                }
-                schemaValuePalette.set(schemaNode.name, valuePalette);
-                nodeData.valuePalette = valuePalette._palette;
-            }
-            baseSchema.push(nodeData);
+    for (const schemaNode of binaryNodes) {
+        schemaIdPalette.register(schemaNode.name);
+        if (schemaNode.values) {
+            schemaValuePalette.set(schemaNode.name, new StringPalette(schemaNode.values));
         }
+        baseSchema.binary.push(schemaNode);
     }
-    {
-        for (const schemaNode of relationNodes) {
-            schemaIdPalette.register(schemaNode.name);
-            baseSchema.push({
-                id: schemaNode.name,
-                type: "relation",
-                conditions: schemaNode.conditions,
-            });
-            const valuePalette = new StringPalette();
-            valuePalette.register("false");
-            valuePalette.register("true");
-            schemaValuePalette.set(schemaNode.name, valuePalette);
-        }
+    for (const schemaNode of relationNodes) {
+        schemaIdPalette.register(schemaNode.name);
+        baseSchema.relational.push(schemaNode);
+        schemaValuePalette.set(schemaNode.name, new StringPalette(["false", "true"]));
     }
     return {
         baseSchema,
@@ -171,28 +130,24 @@ function buildSchemas(binaryNodes, relationNodes) {
 export function BuildStateData(model, geoPalette) {
     const data = model.data;
     const { baseSchema, schemaIdPalette, schemaValuePalette } = buildSchemas(data.stateSchema, data.relationsSchema);
-    const geometryLinkPalette = new StringPalette();
     //maps geo link ids to geomtry ids
-    const geometryLinkStateMap = [];
-    const log = model.data.id == "dve_simple_stair";
+    const geometryLinkStateMap = {};
     //add geomtry from main shape states
     for (const key in data.stateNodes) {
         const nodeData = data.stateNodes[key];
-        for (const node of nodeData) {
-            if (geometryLinkPalette.isRegistered(node.id))
-                continue;
-            const linkId = geometryLinkPalette.register(node.id);
-            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
+        for (let i = 0; i < nodeData.length; i++) {
+            geometryLinkStateMap[key] ??= {};
+            const node = nodeData[i];
+            geometryLinkStateMap[key][i] ??= geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
         }
     }
     //add geomtry from condiotnal  shape states
     for (const key in data.conditonalNodes) {
         const nodeData = data.conditonalNodes[key];
-        for (const node of nodeData) {
-            if (geometryLinkPalette.isRegistered(node.id))
-                continue;
-            const linkId = geometryLinkPalette.register(node.id);
-            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
+        for (let i = 0; i < nodeData.length; i++) {
+            geometryLinkStateMap[key] ??= {};
+            const node = nodeData[i];
+            geometryLinkStateMap[key][i] ??= geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
         }
     }
     const stateRelativeGeometryMap = [];
@@ -205,7 +160,7 @@ export function BuildStateData(model, geoPalette) {
     let relativeByteCount = 0;
     const stateRecord = {};
     for (const key in data.stateNodes) {
-        stateGeoLinkPalette.push(data.stateNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
+        stateGeoLinkPalette.push(data.stateNodes[key].map((_, index) => geometryLinkStateMap[key][index]));
         stateGeometryPalette.push(data.stateNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
         stateRecord[key] = stateGeometryPalette.length - 1;
         stateRelativeGeometryMap[stateRecord[key]] ??= [];
@@ -214,7 +169,6 @@ export function BuildStateData(model, geoPalette) {
             stateRelativeGeometryMap[stateRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] = relativeGeoId;
             relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
             relativeGeoId++;
-            relativeByteCount += Math.ceil(VoxelModelRuleBuilderRegister.getGeomtryFromLink(node).faceCount / 8);
         }
         addPathToTree(stateTree, key
             .split(",")
@@ -228,18 +182,16 @@ export function BuildStateData(model, geoPalette) {
     const condiotnalStatements = [];
     const compareOperations = Object.keys(StateCompareOperationsMap);
     for (const key in data.conditonalNodes) {
-        condiotnalShapeStateNodePalette.push(data.conditonalNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
+        condiotnalShapeStateNodePalette.push(data.conditonalNodes[key].map((_, index) => geometryLinkStateMap[key][index]));
         condiotnalShapeStateGeometryPalette.push(data.conditonalNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
         condiotnalShapeStateNodeRecord[key] =
             condiotnalShapeStateGeometryPalette.length - 1;
         condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]] ??= [];
         const nodeData = data.conditonalNodes[key];
         for (const node of nodeData) {
-            condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] =
-                relativeGeoId;
+            condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] = relativeGeoId;
             relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
             relativeGeoId++;
-            relativeByteCount += Math.ceil(VoxelModelRuleBuilderRegister.getGeomtryFromLink(node).faceCount / 8);
         }
         const statement = [];
         const nodes = key.split(" ");
@@ -328,14 +280,10 @@ export function BuildStateData(model, geoPalette) {
             }
         }
     }
-    const schema = new StateSchema(baseSchema);
     for (const [voxelId, voxelData] of model.voxels) {
         const modeStateTree = new StateTreeNode("root");
         const modStatePalette = [];
         const modStateRecord = {};
-        for (const tag of tagEffects) {
-            VoxelTagStates.register(VoxelPalettesRegister.voxels.getNumberId(voxelId), tag.tagId, schema, tag.tree, tag.treePalette);
-        }
         const { baseSchema, schemaIdPalette, schemaValuePalette } = buildSchemas(voxelData.modSchema || [], voxelData.modRelationSchema || []);
         for (const key in voxelData.inputs) {
             modStatePalette.push(voxelData.inputs[key]);
@@ -361,9 +309,7 @@ export function BuildStateData(model, geoPalette) {
         stateGeometryPalette: stateGeometryPalette,
         condiotnalShapeStateGeometryPalette,
         stateTree: newShapeStateTree,
-        geometryLinkPalette: geometryLinkPalette._map,
         geometryLinkStateMap,
-        relativeByteCount,
         statePalette: stateGeoLinkPalette,
         stateRecord: stateRecord,
         condiotnalNodeStateTree,

package/Voxels/Functions/{BuildTagAndPaletteData.d.ts → BuildTagData.d.ts}

@@ -2,7 +2,7 @@ import { VoxelData } from "../Types/Voxel.types";
 import { VoxelMaterialData } from "../Types/VoxelMaterial.types";
 import { VoxelSubstanceData } from "../Types/VoxelSubstances.types";
 import { CompiledVoxelTagAndPaletteData } from "../Types/VoxelModelCompiledData.types";
-export type BuildTagAndPaletteDataProps = {
+export type BuildTagDataProps = {
     voxels: VoxelData[];
     voxelsOverrides?: Record<string, (value: any) => any>;
     substances: VoxelSubstanceData[];
@@ -10,4 +10,4 @@ export type BuildTagAndPaletteDataProps = {
     materials: VoxelMaterialData[];
     materialsOverrides?: Record<string, (value: any) => any>;
 };
-export declare function BuildTagAndPaletteData(props: BuildTagAndPaletteDataProps): CompiledVoxelTagAndPaletteData;
+export declare function BuildTagAndPaletteData(props: BuildTagDataProps): CompiledVoxelTagAndPaletteData;

package/Voxels/Functions/{BuildTagAndPaletteData.js → BuildTagData.js}

@@ -1,10 +1,29 @@
 import { VoxelTagsRegister } from "../Data/VoxelTagsRegister";
 import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
+import { VoxelModelRuleBuilderRegister } from "../Models/Rules/VoxelModelRuleBuilderRegister";
+import { VoxelPropertiesRegister } from "../Data/VoxelPropertiesRegister";
+import { VoxelPlacingStrategyRegister } from "../../Voxels/Interaction/Placing/VoxelPlacingStrategyRegister";
 export function BuildTagAndPaletteData(props) {
     const logic = {};
     for (const voxel of props.voxels) {
         const tags = {};
-        const voxelId = VoxelPalettesRegister.voxels.register(voxel.id);
+        if (VoxelPalettesRegister.voxelIds._map[voxel.id] !== undefined) {
+            throw new Error(`Voxel with id [${voxel.id}] is already registered.`);
+        }
+        const voxelId = VoxelPalettesRegister.voxelIds.register(voxel.id);
+        VoxelPropertiesRegister.VoxelProperties[voxelId] = voxel.properties;
+        if (voxel.properties["dve_model_data"]) {
+            tags["dve_model_id"] = voxel.properties["dve_model_data"].id;
+            const model = VoxelModelRuleBuilderRegister.models.get(voxel.properties["dve_model_data"].id);
+            if (model?.data.properties) {
+                for (const tagId in model.data.properties) {
+                    voxel.properties[tagId] = model.data.properties[tagId];
+                }
+            }
+        }
+        if (voxel.properties["dve_placing_strategy"]) {
+            VoxelPlacingStrategyRegister.register(voxel.id, voxel.properties["dve_placing_strategy"]);
+        }
         VoxelPalettesRegister.voxelIdToNameMap.set(voxel.id, voxel.name || "");
         VoxelPalettesRegister.voxelNametoIdMap.set(voxel.name || voxel.id, voxel.id);
         if (voxel.properties["dve_logic_data"]) {
@@ -46,7 +65,9 @@ export function BuildTagAndPaletteData(props) {
     return {
         data: {
             logic,
-            palette: VoxelPalettesRegister.voxels._palette,
+            palette: [],
+            record: [],
+            idPalette: VoxelPalettesRegister.voxelIds._palette,
             tags: VoxelTagsRegister.VoxelTags,
             idToNameMap: [...VoxelPalettesRegister.voxelIdToNameMap.entries()],
             nameToIdMap: [...VoxelPalettesRegister.voxelNametoIdMap.entries()],

package/Voxels/Indexes/VoxelIndex.d.ts

@@ -1,4 +1,4 @@
-import { PaintVoxelData } from "../Types/Voxel.types";
+import { PaintVoxelData } from "../Types/PaintVoxelData";
 import { VoxelData, RawVoxelData, VoxelNamedStateData } from "../Types/Voxel.types";
 export declare class VoxelNamedState {
     voxelId: string;

package/Voxels/Indexes/VoxelIndex.js

@@ -1,4 +1,4 @@
-import { PaintVoxelData } from "../Types/Voxel.types";
+import { PaintVoxelData } from "../Types/PaintVoxelData";
 import { SchemaRegister } from "../State/SchemaRegister";
 import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
 export class VoxelNamedState {
@@ -17,7 +17,7 @@ export class VoxelNamedState {
         for (const key in data.properties) {
             this.tags.set(key, data.properties[key]);
         }
-        if (SchemaRegister.voxelModSchemaData.has(this.voxelId)) {
+        if (SchemaRegister.modSchemaData.has(this.voxelId)) {
             const schema = SchemaRegister.getVoxelSchemas(this.voxelId);
             if (this.data.state == "*") {
                 this.compiled.stateAny = true;
@@ -117,8 +117,9 @@ export class VoxelIndex {
         return false;
     }
     getStateFromRawData(data) {
-        const [id, light, state, secondary, mod] = data;
-        const conatiner = this.states.get(VoxelPalettesRegister.voxels.getStringId(id));
+        const [id, light, secondary] = data;
+        const [, mod, state] = VoxelPalettesRegister.voxels[id];
+        const conatiner = this.states.get(VoxelPalettesRegister.voxelIds.getStringId(id));
         if (!conatiner)
             return false;
         for (const modelState of conatiner?.stateArray) {

package/Voxels/InitVoxelData.d.ts

@@ -1,4 +1,4 @@
-import { VoxelGeometryData, VoxelModelData } from "../Models/VoxelModel.types";
+import { VoxelGeometryData, VoxelModelData } from "./Models/VoxelModel.types";
 import { VoxelData } from "./Types/Voxel.types";
 import { CompiledVoxelData } from "./Types/VoxelModelCompiledData.types";
 import { VoxelMaterialData } from "./Types/VoxelMaterial.types";

package/Voxels/InitVoxelData.js

@@ -1,22 +1,29 @@
-import { candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, candlesModel, carpetGeometry, carpetModel, chainGeometry, chainModel, fence, fenceEastWest, fenceNorthsouth, fencePost, leverGeometry, leverModel, } from "../Models/Examples";
-import { cube, halfDownCube, eighthCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, halfSouthCube, halfWestCube, } from "../Models/Defaults/CubeVoxelGeometry";
-import { orientedCube, pillarCube, simpleCube, simpleHalfCube, } from "../Models/Defaults/CubeVoxelModels";
-import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanelDown, thinPanelSouth, thinPanelWest, } from "../Models/Defaults/PanelVoxelGeometry";
-import { stair } from "../Models/Defaults/StairVoxelModel";
-import { liquidGeometry, liquidModel, } from "../Models/Defaults/LiquidVoxelModel";
-import { VoxelModelRuleBuilderRegister } from "../Models/Rules/VoxelModelRuleBuilderRegister";
-import { BuildRules } from "../Models/Rules/Functions/BuildRules";
+import { candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, candlesModel, carpetGeometry, carpetModel, chainGeometry, chainModel, fence, fenceEastWest, fenceNorthsouth, fencePost, leverGeometry, leverModel, } from "./Models/Defaults/Examples";
+import { cube, halfDownCube, eighthCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, halfSouthCube, halfWestCube, } from "./Models/Defaults/CubeVoxelGeometry";
+import { orientedCube, pillarCube, simpleCube, simpleNoCulledCube, simpleHalfCube, simpleTransparentCube, } from "./Models/Defaults/CubeVoxelModels";
+import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanelDown, thinPanelSouth, thinPanelWest, } from "./Models/Defaults/PanelVoxelGeometry";
+import { stair } from "./Models/Defaults/StairVoxelModel";
+import { liquidGeometry, liquidModel, } from "./Models/Defaults/LiquidVoxelModel";
+import { VoxelModelRuleBuilderRegister } from "./Models/Rules/VoxelModelRuleBuilderRegister";
 import { BuildStateData } from "./Functions/BuildStateData";
-import { BuildFinalInputs } from "../Models/Rules/Functions/BuildFinalInputs";
+import { BuildFinalInputs } from "./Models/Rules/Functions/BuildFinalInputs";
 import { SchemaRegister } from "../Voxels/State/SchemaRegister";
-import { simpleCrossedPannel, simpleThinPannel, } from "../Models/Defaults/PanelVoxelModels";
-import { VoxelTagStates } from "./Data/VoxelTagStates";
+import { simpleCrossedPannel, simpleThinPannel, } from "./Models/Defaults/PanelVoxelModels";
 import { VoxelIndex } from "../Voxels/Indexes/VoxelIndex";
 import { CacheManager } from "../Cache/CacheManager";
 import { VoxelLightData } from "./Cursor/VoxelLightData";
 import { VoxelTagIds } from "./Data/VoxelTag.types";
-import { BuildTagAndPaletteData } from "./Functions/BuildTagAndPaletteData";
+import { BuildTagAndPaletteData as BuildTagData } from "./Functions/BuildTagData";
+import { VoxelPalettesRegister } from "./Data/VoxelPalettesRegister";
 import { VoxelLogicRegister } from "./Logic/VoxelLogicRegister";
+import { BuildPaletteData } from "./Functions/BuildPaletteData";
+import { BuildRules } from "./Models/Rules/Functions/BuildRules";
+import { VoxelTagsRegister } from "./Data/VoxelTagsRegister";
+import { farmGeomtry, farmModels } from "./Models/Defaults/FarmVoxelModels";
+function RegisterModels(data) {
+    VoxelModelRuleBuilderRegister.registerGeometry(cube, halfDownCube, halfSouthCube, halfWestCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, eighthCube, thinPanelDown, thinPanelSouth, thinPanelWest, diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, fencePost, fenceEastWest, fenceNorthsouth, chainGeometry, carpetGeometry, candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, liquidGeometry, ...leverGeometry, ...farmGeomtry, ...(data.geometry || []));
+    VoxelModelRuleBuilderRegister.registerModels(simpleCube, simpleTransparentCube, simpleNoCulledCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, stair, simpleCrossedPannel, chainModel, carpetModel, candlesModel, leverModel, fence, liquidModel, ...farmModels, ...(data.models || []));
+}
 function GetModelData(data) {
     if (CacheManager.cacheLoadEnabled && CacheManager.cachedData) {
         const syncData = CacheManager.cachedData.models;
@@ -28,18 +35,8 @@ function GetModelData(data) {
             const voxel = syncData.voxels[i];
             SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
         }
-        VoxelTagStates.load(syncData.tagState);
         return syncData;
     }
-    VoxelModelRuleBuilderRegister.registerGeometry(cube, halfDownCube, halfSouthCube, halfWestCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, eighthCube, thinPanelDown, thinPanelSouth, thinPanelWest, diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, fencePost, fenceEastWest, fenceNorthsouth, chainGeometry, carpetGeometry, candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, liquidGeometry, ...leverGeometry, ...(data.geometry || []));
-    VoxelModelRuleBuilderRegister.registerModels(simpleCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, stair, simpleCrossedPannel, chainModel, carpetModel, candlesModel, leverModel, fence, liquidModel, ...(data.models || []));
-    const syncData = {
-        geometryPalette: VoxelModelRuleBuilderRegister.geometryPalette._palette,
-        geometry: [],
-        models: [],
-        voxels: [],
-        tagState: [],
-    };
     for (const voxel of data.voxels) {
         const voxelData = voxel.properties["dve_model_data"];
         if (!voxelData)
@@ -50,20 +47,18 @@ function GetModelData(data) {
             throw new Error(`Voxel model with id ${voxelData.id} does not exist.`);
         model.voxels.set(voxel.id, voxelData);
     }
+    const syncData = {
+        geometryPalette: VoxelModelRuleBuilderRegister.geometryPalette._palette,
+        ...BuildRules(VoxelModelRuleBuilderRegister.geometryPalette),
+        geometry: [],
+        models: [],
+        voxels: [],
+    };
     for (const [mainKey, mainGeo] of VoxelModelRuleBuilderRegister.geometry) {
-        if (mainGeo.data.ogData.doNotBuildRules) {
-            syncData.geometry.push({
-                id: mainKey,
-                nodes: mainGeo.data.nodes,
-                ruleless: true,
-            });
-            continue;
-        }
-        const output = BuildRules(mainGeo, VoxelModelRuleBuilderRegister.geometryPalette);
         syncData.geometry.push({
             id: mainKey,
-            nodes: mainGeo.data.nodes,
-            ...output,
+            nodes: mainGeo.compiled,
+            cullingProcedure: mainGeo.data.cullingProcedure,
         });
     }
     for (const [mainKey, model] of VoxelModelRuleBuilderRegister.models) {
@@ -74,7 +69,7 @@ function GetModelData(data) {
             id: mainKey,
             effects: stateData.effects,
             schema: stateData.schema,
-            geoLinkMap: stateData.geometryLinkStateMap,
+            //   geoLinkMap: stateData.geometryLinkStateMap,
             stateMap: stateData.statePalette,
             stateGeometryMap: stateData.stateGeometryPalette,
             stateTree: stateData.stateTree,
@@ -82,7 +77,7 @@ function GetModelData(data) {
             condiotnalStatements: stateData.condiotnalStatements,
             condiotnalStateMap: stateData.condiotnalStatePalette,
             condiotnalShapeStateMap: stateData.condiotanlStatePalette,
-            condiotnalShapeStateGeometryMap: stateData.condiotanlGeometryStatePalette,
+            condiotanlGeometryStatePalette: stateData.condiotanlGeometryStatePalette,
             stateRelativeGeometryMap: stateData.stateRelativeGeometryMap,
             relativeGeometryByteIndexMap: stateData.relativeGeometryByteIndexMap,
             condiotnalShapeStateRelativeGeometryMap: stateData.condiotnalShapeStateRelativeGeometryMap,
@@ -92,15 +87,14 @@ function GetModelData(data) {
       BuildGeomtryInputs(geometry);
     } */
     for (const [mainKey, model] of VoxelModelRuleBuilderRegister.models) {
-        const { stateVoxelInputs, conditionalShapeStateVoxelInputs, transparentVoxelFaceIndexes, } = BuildFinalInputs(model);
+        const { stateVoxelInputs, conditionalShapeStateVoxelInputs } = BuildFinalInputs(model);
         for (const v in stateVoxelInputs) {
             const stateData = model.voxelModData.get(v);
             SchemaRegister.registerVoxel(v, mainKey, stateData.modSchema);
             syncData.voxels.push({
                 id: v,
-                materialId: VoxelIndex.instance.dataMap.get(v)?.properties["dve_rendered_material"] || "dve_solid",
+                materialId: VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxelIds.getNumberId(v)]["dve_rendered_material"] || "dve_solid",
                 modelId: mainKey,
-                transparentFaceIndex: transparentVoxelFaceIndexes[v].data,
                 modSchema: stateData.modSchema,
                 modStateTree: stateData.modStateTree,
                 baseGeometryInputMap: stateVoxelInputs[v],
@@ -108,7 +102,6 @@ function GetModelData(data) {
             });
         }
     }
-    syncData.tagState = VoxelTagStates.toJSON();
     if (CacheManager.cacheStoreEnabled) {
         CacheManager.cachedModelData = syncData;
     }
@@ -116,10 +109,10 @@ function GetModelData(data) {
 }
 export function InitVoxelData(data) {
     const lightData = new VoxelLightData();
-    new VoxelIndex(data.voxels);
     const materials = [
         { id: "dve_solid", properties: {} },
         { id: "dve_flora", properties: {} },
+        { id: "dve_flora_transparent", properties: {} },
         {
             id: "dve_transparent",
             properties: {
@@ -228,7 +221,8 @@ export function InitVoxelData(data) {
         },
         ...data.voxels,
     ];
-    const voxelData = BuildTagAndPaletteData({
+    RegisterModels(data);
+    const voxelData = BuildTagData({
         voxels,
         voxelsOverrides: {
             [VoxelTagIds.lightValue]: (value) => {
@@ -244,9 +238,13 @@ export function InitVoxelData(data) {
         materials,
     });
     let models = GetModelData(data);
+    BuildPaletteData({ models });
+    voxelData.data.palette = VoxelPalettesRegister.voxels;
+    voxelData.data.record = VoxelPalettesRegister.voxelRecord;
     for (const id in voxelData.data.logic) {
         VoxelLogicRegister.register(id, voxelData.data.logic[id]);
     }
+    new VoxelIndex(data.voxels);
     return {
         models,
         ...voxelData,

package/Voxels/Interaction/Functions/PickVoxel.d.ts

@@ -0,0 +1,9 @@
+import { Vec3Array } from "@amodx/math";
+import { DataCursorInterface } from "../../Cursor/DataCursor.interface";
+import { VoxelPickResult } from "../VoxelPickResult";
+/**
+ * # PickVoxel
+ * Used to a pick a voxel from any data cursor interface.
+ * The function assumes the data that is loaded into the cursor is available
+ */
+export default function PickVoxel(cursor: DataCursorInterface, rayStart: Vec3Array, rayDirection: Vec3Array, rayLength: number): VoxelPickResult | null;