@divinevoxel/vlox 0.0.74 → 0.0.76

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;

package/Voxels/Interaction/Functions/PickVoxel.js

@@ -0,0 +1,95 @@
+import { Vec3ArrayLike, Vector3Like } from "@amodx/math";
+import { VoxelPickResult } from "../VoxelPickResult";
+import { closestUnitNormal, closestVoxelFace, } from "../../../Math/UtilFunctions";
+const step = (val) => (val > 0 ? 1 : val < 0 ? -1 : 0);
+const calculateNormal = (intersectPoint, voxelMin, voxelMax) => {
+    const epsilon = 1e-4;
+    let normal = [0, 0, 0];
+    if (Math.abs(intersectPoint[0] - voxelMin[0]) < epsilon)
+        normal = [1, 0, 0];
+    else if (Math.abs(intersectPoint[0] - voxelMax[0]) < epsilon)
+        normal = [-1, 0, 0];
+    else if (Math.abs(intersectPoint[1] - voxelMin[1]) < epsilon)
+        normal = [0, 1, 0];
+    else if (Math.abs(intersectPoint[1] - voxelMax[1]) < epsilon)
+        normal = [0, -1, 0];
+    else if (Math.abs(intersectPoint[2] - voxelMin[2]) < epsilon)
+        normal = [0, 0, 1];
+    else if (Math.abs(intersectPoint[2] - voxelMax[2]) < epsilon)
+        normal = [0, 0, -1];
+    return normal;
+};
+/**
+ * # 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, rayStart, rayDirection, rayLength) {
+    const invDir = [
+        1 / rayDirection[0],
+        1 / rayDirection[1],
+        1 / rayDirection[2],
+    ];
+    const voxelSize = 1.0;
+    const tDelta = [
+        Math.abs(invDir[0]) * voxelSize,
+        Math.abs(invDir[1]) * voxelSize,
+        Math.abs(invDir[2]) * voxelSize,
+    ];
+    const tMax = [
+        (Math.floor(rayStart[0]) - rayStart[0] + (rayDirection[0] > 0 ? 1 : 0)) *
+            invDir[0],
+        (Math.floor(rayStart[1]) - rayStart[1] + (rayDirection[1] > 0 ? 1 : 0)) *
+            invDir[1],
+        (Math.floor(rayStart[2]) - rayStart[2] + (rayDirection[2] > 0 ? 1 : 0)) *
+            invDir[2],
+    ];
+    const pos = [
+        Math.floor(rayStart[0]),
+        Math.floor(rayStart[1]),
+        Math.floor(rayStart[2]),
+    ];
+    const stepDir = [
+        step(rayDirection[0]),
+        step(rayDirection[1]),
+        step(rayDirection[2]),
+    ];
+    for (let i = 0; i < rayLength; i++) {
+        const [tx, ty, tz] = tMax;
+        let axis = 0;
+        if (tx < ty) {
+            if (tx < tz)
+                axis = 0;
+            else
+                axis = 2;
+        }
+        else {
+            if (ty < tz)
+                axis = 1;
+            else
+                axis = 2;
+        }
+        pos[axis] += stepDir[axis];
+        tMax[axis] += tDelta[axis];
+        if (!cursor.inBounds(...pos))
+            continue;
+        const voxel = cursor.getVoxel(...pos);
+        if (voxel && voxel.isRenderable()) {
+            const normal = calculateNormal([
+                rayStart[0] + rayDirection[0] * tMax[axis],
+                rayStart[1] + rayDirection[1] * tMax[axis],
+                rayStart[2] + rayDirection[2] * tMax[axis],
+            ], [pos[0] * voxelSize, pos[1] * voxelSize, pos[2] * voxelSize], [
+                pos[0] * voxelSize + voxelSize,
+                pos[1] * voxelSize + voxelSize,
+                pos[2] * voxelSize + voxelSize,
+            ]);
+            const rd = Vector3Like.Create(...rayDirection);
+            const urd = Vector3Like.FromArray(closestUnitNormal(rd));
+            const n = Vector3Like.Create(...normal);
+            const un = Vector3Like.FromArray(closestUnitNormal(n));
+            return new VoxelPickResult(Vector3Like.Create(...rayStart), rd, rayLength, voxel.getRaw(), Vector3Like.Create(...pos), n, tMax[axis], Vector3Like.Create(...Vec3ArrayLike.Add(pos, normal)), Vector3Like.FromArray(closestUnitNormal(rd)), closestVoxelFace(urd), Vector3Like.FromArray(closestUnitNormal(n)), closestVoxelFace(un), 0);
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,8 @@
+import { Vec3Array } from "@amodx/math";
+import { WorldCursor } from "../../../World";
+/**# PickVoxelWorld
+ * Will pick the voxel world and make sure each sector is available before picking it.
+ *
+ * Useful if the engine is not using shared memory.
+ */
+export default function PickVoxelWorld(cursor: WorldCursor, rayStart: Vec3Array, rayDirection: Vec3Array, rayLength: number): Promise<import("../VoxelPickResult").VoxelPickResult | null>;

package/Voxels/Interaction/Functions/PickVoxelWorld.js

@@ -0,0 +1,38 @@
+import { Vector3Like } from "@amodx/math";
+import PickVoxel from "./PickVoxel";
+import { WorldSpaces } from "../../../World/WorldSpaces";
+import { WorldRegister } from "../../../World/WorldRegister";
+import { SectorCursor } from "../../../World/Cursor/SectorCursor";
+/**# PickVoxelWorld
+ * Will pick the voxel world and make sure each sector is available before picking it.
+ *
+ * Useful if the engine is not using shared memory.
+ */
+export default async function PickVoxelWorld(cursor, rayStart, rayDirection, rayLength) {
+    let t = 0;
+    const d = 8;
+    const rayPosition = Vector3Like.Create();
+    const visited = new Set();
+    const sectorCursor = new SectorCursor();
+    while (t < rayLength) {
+        rayPosition.x = rayStart[0] + t * rayDirection[0];
+        rayPosition.y = rayStart[1] + t * rayDirection[1];
+        rayPosition.z = rayStart[2] + t * rayDirection[2];
+        t += d;
+        const { x, y, z } = WorldSpaces.sector.transformPosition(rayPosition);
+        if (!WorldSpaces.world.inBounds(x, y, z))
+            continue;
+        const sector = WorldRegister.sectors.get(cursor.dimension, x, y, z);
+        if (!sector)
+            continue;
+        if (visited.has(sector))
+            continue;
+        visited.add(sector);
+        await sector.waitTillCheckedIn();
+        sectorCursor.loadSector(cursor.dimension, x, y, z);
+        const result = PickVoxel(sectorCursor, rayStart, rayDirection, rayLength);
+        if (result !== null)
+            return result;
+    }
+    return null;
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.d.ts

@@ -0,0 +1,9 @@
+import { VoxelFaceNames } from "../../../Math";
+import { VoxelPlacingStrategyData } from "./VoxelPlacingStrategy.types";
+import { VoxelPickResult } from "../VoxelPickResult";
+export declare class VoxelModelPlacingStrategy {
+    _faceMap: Map<VoxelFaceNames, VoxelPlacingStrategyData[]>;
+    _defaultState: string;
+    constructor(data: VoxelPlacingStrategyData[] | string);
+    getState(picked: VoxelPickResult, alt?: number | null): string | null;
+}