@divinevoxel/vlox 0.0.71 → 0.0.73

package/Voxels/Cursor/VoxelCursor.js

@@ -1,11 +1,13 @@
 import { VoxelCursorInterface } from "./VoxelCursor.interface";
-import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette";
-import { VoxelLevelReader } from "../VoxelLevelReader";
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLevelReader } from "./VoxelLevelReader";
 export class VoxelCursor extends VoxelCursorInterface {
     static VoxelDataToRaw(data, light = 0) {
-        const id = (data.id !== undefined && VoxelPalette.ids.getNumberId(data.id)) || 0;
+        const id = (data.id !== undefined &&
+            VoxelPalettesRegister.voxels.getNumberId(data.id)) ||
+            0;
         const secondaryId = (data.secondaryVoxelId !== undefined &&
-            VoxelPalette.ids.getNumberId(data.secondaryVoxelId)) ||
+            VoxelPalettesRegister.voxels.getNumberId(data.secondaryVoxelId)) ||
             0;
         let levleData = 0;
         if (data.level !== undefined)
@@ -14,13 +16,12 @@ export class VoxelCursor extends VoxelCursorInterface {
             levleData = VoxelLevelReader.setLevelState(levleData, data.levelState);
         return [id, light, levleData, data.state || 0, data.mod || 0, secondaryId];
     }
-    ids = [0];
-    light = [0];
-    level = [0];
-    state = [0];
-    secondary = [0];
-    mod = [0];
+    ids = new Uint16Array(1);
+    light = new Uint16Array(1);
+    level = new Uint8Array(1);
+    state = new Uint16Array(1);
+    mod = new Uint16Array(1);
+    secondary = new Uint16Array(1);
     loadIn() { }
-    updateVoxel(mode) {
-    }
+    updateVoxel(mode) { }
 }

package/Voxels/Cursor/VoxelLightData.d.ts

@@ -20,8 +20,7 @@ export declare class VoxelLightData {
     mixLight(l1: number, l2: number): number;
     getRGB(sl: number): number;
     setRGB(value: number, sl: number): number;
-    decodeLightFromVoxelData(voxelData: number): number;
-    encodeLightIntoVoxelData(voxelData: number, encodedLight: number): number;
+    createLightValue(s: number, r: number, g: number, b: number): number;
     /**# Set Light Values
      * ---
      * Give an array of light values it will return an encoded light number.
@@ -37,8 +36,8 @@ export declare class VoxelLightData {
      * - 3: Blue Light
      * @param value
      */
-    getLightValues(value: number): AllLight;
-    getLightValuesToRef(value: number, values: AllLight): AllLight;
+    getLightValuesArray(value: number): AllLight;
+    getLightValuesArrayToRef(value: number, values: AllLight): AllLight;
     addLightValues(sl: number, sl2: number): number;
     divideLightValue(sl: number, divisor: number): number;
 }

package/Voxels/Cursor/VoxelLightData.js

@@ -81,11 +81,12 @@ export class VoxelLightData {
             return 0;
         return (sl & ~0xfff0) | (value << 4);
     }
-    decodeLightFromVoxelData(voxelData) {
-        return (voxelData & (0xffff << 0)) >> 0;
-    }
-    encodeLightIntoVoxelData(voxelData, encodedLight) {
-        return (voxelData & ~(0xffff << 0)) | (encodedLight << 0);
+    createLightValue(s, r, g, b) {
+        let v = 0;
+        v = this.setS(s, v);
+        v = this.setR(r, v);
+        v = this.setG(r, v);
+        return this.setB(r, v);
     }
     /**# Set Light Values
      * ---
@@ -107,14 +108,14 @@ export class VoxelLightData {
      * - 3: Blue Light
      * @param value
      */
-    getLightValues(value) {
+    getLightValuesArray(value) {
         this._lightValues[0] = this.getS(value);
         this._lightValues[1] = this.getR(value);
         this._lightValues[2] = this.getG(value);
         this._lightValues[3] = this.getB(value);
         return this._lightValues;
     }
-    getLightValuesToRef(value, values) {
+    getLightValuesArrayToRef(value, values) {
         values[0] = this.getS(value);
         values[1] = this.getR(value);
         values[2] = this.getG(value);

package/Voxels/Data/VoxelPalettesRegister.d.ts

@@ -0,0 +1,8 @@
+import { StringPalette } from "../../Util/StringPalette";
+export declare class VoxelPalettesRegister {
+    static material: StringPalette;
+    static substance: StringPalette;
+    static voxels: StringPalette;
+    static voxelNametoIdMap: Map<string, string>;
+    static voxelIdToNameMap: Map<string, string>;
+}

package/Voxels/Data/VoxelPalettesRegister.js

@@ -0,0 +1,8 @@
+import { StringPalette } from "../../Util/StringPalette";
+export class VoxelPalettesRegister {
+    static material = new StringPalette();
+    static substance = new StringPalette();
+    static voxels = new StringPalette();
+    static voxelNametoIdMap = new Map();
+    static voxelIdToNameMap = new Map();
+}

package/Voxels/Data/VoxelTag.types.d.ts

@@ -0,0 +1,56 @@
+export declare enum VoxelTagIds {
+    substance = "dve_substance",
+    renderedMaterial = "dve_rendered_material",
+    voxelMaterial = "dve_voxel_material",
+    hardness = "dve_hardness",
+    colliderID = "dve_collider_id",
+    checkCollisions = "dve_check_collisions",
+    isLightSource = "dve_is_light_source",
+    noAO = "dve_no_ao",
+    isTransparent = "dve_is_transparent",
+    lightValue = "dve_light_value",
+    canHaveSecondary = "dve_can_have_secondary"
+}
+export interface VoxelTags {
+    /** The material used to render the voxel. Used by the engine to assign meshes to the proper material. */
+    [VoxelTagIds.renderedMaterial]: string;
+    /** A description of the material used for the voxel. Not used by the engine directly. */
+    [VoxelTagIds.voxelMaterial]: string;
+    /** Specifies the substance of the voxel.
+     * The voxel will inherit properties from the substance and change how it acts in the world.
+     * Properties include being solid or liquid.
+     * */
+    [VoxelTagIds.substance]: string;
+    /** Indicates whether the voxel is a light source. */
+    [VoxelTagIds.isLightSource]: boolean;
+    /** Indicates if the voxel lets light through */
+    [VoxelTagIds.isTransparent]: boolean;
+    /** Disables ambient occlusion for this voxel if set to true. */
+    [VoxelTagIds.noAO]: boolean;
+    /** Defines the light value emitted by the voxel (r, g, z). */
+    [VoxelTagIds.lightValue]: [r: number, g: number, z: number] | number;
+    /** The collider ID for the voxel, used for collision detection. */
+    [VoxelTagIds.colliderID]: string;
+    /** Specifies if the voxel participates in collision checks. */
+    [VoxelTagIds.checkCollisions]: boolean;
+    /** Indicates if the voxel can have a secondary voxel. */
+    [VoxelTagIds.canHaveSecondary]: boolean;
+    /** The hardness level of the voxel, affecting how it is broken or interacted with. */
+    [VoxelTagIds.hardness]: number;
+}
+export declare enum VoxelSubstanceTagIdds {
+    parent = "dve_parent_substance",
+    isSolid = "dve_is_solid",
+    isTransparent = "dve_is_transparent",
+    isLiquid = "dve_is_liquid",
+    flowRate = "dve_flow_rate",
+    isWindAffected = "dve_is_wind_affected"
+}
+export interface VoxelSubstanceTags {
+    [VoxelSubstanceTagIdds.parent]: string;
+    [VoxelSubstanceTagIdds.isTransparent]: boolean;
+    [VoxelSubstanceTagIdds.isSolid]: boolean;
+    [VoxelSubstanceTagIdds.isLiquid]: boolean;
+    [VoxelSubstanceTagIdds.flowRate]: number;
+    [VoxelSubstanceTagIdds.isWindAffected]: boolean;
+}

package/Voxels/Data/VoxelTag.types.js

@@ -0,0 +1,23 @@
+export var VoxelTagIds;
+(function (VoxelTagIds) {
+    VoxelTagIds["substance"] = "dve_substance";
+    VoxelTagIds["renderedMaterial"] = "dve_rendered_material";
+    VoxelTagIds["voxelMaterial"] = "dve_voxel_material";
+    VoxelTagIds["hardness"] = "dve_hardness";
+    VoxelTagIds["colliderID"] = "dve_collider_id";
+    VoxelTagIds["checkCollisions"] = "dve_check_collisions";
+    VoxelTagIds["isLightSource"] = "dve_is_light_source";
+    VoxelTagIds["noAO"] = "dve_no_ao";
+    VoxelTagIds["isTransparent"] = "dve_is_transparent";
+    VoxelTagIds["lightValue"] = "dve_light_value";
+    VoxelTagIds["canHaveSecondary"] = "dve_can_have_secondary";
+})(VoxelTagIds || (VoxelTagIds = {}));
+export var VoxelSubstanceTagIdds;
+(function (VoxelSubstanceTagIdds) {
+    VoxelSubstanceTagIdds["parent"] = "dve_parent_substance";
+    VoxelSubstanceTagIdds["isSolid"] = "dve_is_solid";
+    VoxelSubstanceTagIdds["isTransparent"] = "dve_is_transparent";
+    VoxelSubstanceTagIdds["isLiquid"] = "dve_is_liquid";
+    VoxelSubstanceTagIdds["flowRate"] = "dve_flow_rate";
+    VoxelSubstanceTagIdds["isWindAffected"] = "dve_is_wind_affected";
+})(VoxelSubstanceTagIdds || (VoxelSubstanceTagIdds = {}));

package/Voxels/{State → Data}/VoxelTagStates.d.ts

@@ -1,5 +1,5 @@
-import { StateSchema } from "./Schema/StateSchema";
-import { StateTreeReader } from "./StateTreeReader";
+import { StateSchema } from "../State/Schema/StateSchema";
+import { StateTreeReader } from "../State/StateTreeReader";
 export type VoxelTagStatesData = Record<string, {
     tree: any;
     treePalette: any;

package/Voxels/{State → Data}/VoxelTagStates.js

@@ -1,7 +1,7 @@
-import { VoxelPalette } from "../Palettes/VoxelPalette";
-import { StateSchema } from "./Schema/StateSchema";
-import { StateTreeReader } from "./StateTreeReader";
-import { SchemaRegister } from "./SchemaRegister";
+import { VoxelPalettesRegister } from "./VoxelPalettesRegister";
+import { StateSchema } from "../State/Schema/StateSchema";
+import { StateTreeReader } from "../State/StateTreeReader";
+import { SchemaRegister } from "../State/SchemaRegister";
 export class VoxelTagStates {
     static voxelTags = [];
     static toJSON() {
@@ -18,7 +18,7 @@ export class VoxelTagStates {
         data.forEach((v, index) => {
             if (!v)
                 return;
-            const stateSceham = new StateSchema(SchemaRegister.modelStaeBaseSchemaData.get(SchemaRegister.voxelModelMap.get(VoxelPalette.ids.getStringId(index))));
+            const stateSceham = new StateSchema(SchemaRegister.modelStaeBaseSchemaData.get(SchemaRegister.voxelModelMap.get(VoxelPalettesRegister.voxels.getStringId(index))));
             for (const tag in v) {
                 this.register(index, tag, stateSceham, v[tag].tree, v[tag].treePalette);
             }

package/Voxels/Data/VoxelTagsRegister.d.ts

@@ -0,0 +1,9 @@
+import { VoxelSubstanceTags, VoxelTags } from "./VoxelTag.types";
+export declare class VoxelTagsRegister {
+    static IncludedVoxelTags: string[];
+    static IncludedSubstnacesTags: string[];
+    static VoxelTagDefaults: Record<string, any>;
+    static VoxelTags: VoxelTags[];
+    static SubstanceStagDefaults: Record<string, any>;
+    static SubstanceStags: VoxelSubstanceTags[];
+}

package/Voxels/Data/VoxelTagsRegister.js

@@ -0,0 +1,32 @@
+import { VoxelSubstanceTagIdds as VoxelSubstanceTagIds, VoxelTagIds, } from "./VoxelTag.types";
+export class VoxelTagsRegister {
+    static IncludedVoxelTags = [
+        VoxelTagIds.substance,
+        VoxelTagIds.renderedMaterial,
+        VoxelTagIds.voxelMaterial,
+        VoxelTagIds.hardness,
+        VoxelTagIds.colliderID,
+        VoxelTagIds.checkCollisions,
+        VoxelTagIds.isLightSource,
+        VoxelTagIds.lightValue,
+        VoxelTagIds.noAO,
+        VoxelTagIds.isTransparent,
+        VoxelTagIds.canHaveSecondary,
+    ];
+    static IncludedSubstnacesTags = [
+        VoxelSubstanceTagIds.parent,
+        VoxelSubstanceTagIds.isSolid,
+        VoxelSubstanceTagIds.isTransparent,
+        VoxelSubstanceTagIds.isLiquid,
+        VoxelSubstanceTagIds.flowRate,
+        VoxelSubstanceTagIds.isWindAffected,
+    ];
+    static VoxelTagDefaults = {
+        [VoxelTagIds.renderedMaterial]: "dve_solid",
+        [VoxelTagIds.substance]: "dve_solid",
+        [VoxelTagIds.colliderID]: "dve_cube",
+    };
+    static VoxelTags = [];
+    static SubstanceStagDefaults = {};
+    static SubstanceStags = [];
+}

package/Voxels/Functions/BuildStateData.js

@@ -1,8 +1,8 @@
 import { StateCompareOperationsMap, StateLogicOperationsMap, } from "../State/State.types";
 import { StringPalette } from "../../Util/StringPalette";
-import { VoxelModelManager } from "../../Models/Rules/VoxelModelManager";
-import { VoxelTagStates } from "../State/VoxelTagStates";
-import { VoxelPalette } from "../Palettes/VoxelPalette";
+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)
@@ -182,7 +182,7 @@ export function BuildStateData(model, geoPalette) {
             if (geometryLinkPalette.isRegistered(node.id))
                 continue;
             const linkId = geometryLinkPalette.register(node.id);
-            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node));
+            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
         }
     }
     //add geomtry from condiotnal  shape states
@@ -192,7 +192,7 @@ export function BuildStateData(model, geoPalette) {
             if (geometryLinkPalette.isRegistered(node.id))
                 continue;
             const linkId = geometryLinkPalette.register(node.id);
-            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node));
+            geometryLinkStateMap[linkId] = geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node));
         }
     }
     const shapeStateRelativeGeometryMap = [];
@@ -206,15 +206,15 @@ export function BuildStateData(model, geoPalette) {
     const shapeStateRecord = {};
     for (const key in data.shapeStatesNodes) {
         shapeStateGeoLinkPalette.push(data.shapeStatesNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
-        shapeStateGeometryPalette.push(data.shapeStatesNodes[key].map((_) => geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(_))));
+        shapeStateGeometryPalette.push(data.shapeStatesNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
         shapeStateRecord[key] = shapeStateGeometryPalette.length - 1;
         shapeStateRelativeGeometryMap[shapeStateRecord[key]] ??= [];
         const nodeData = data.shapeStatesNodes[key];
         for (const node of nodeData) {
-            shapeStateRelativeGeometryMap[shapeStateRecord[key]][geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node))] = relativeGeoId;
+            shapeStateRelativeGeometryMap[shapeStateRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] = relativeGeoId;
             relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
             relativeGeoId++;
-            relativeByteCount += Math.ceil(VoxelModelManager.getGeomtryFromLink(node).faceCount / 8);
+            relativeByteCount += Math.ceil(VoxelModelRuleBuilderRegister.getGeomtryFromLink(node).faceCount / 8);
         }
         addPathToTree(shapeStateTree, key
             .split(",")
@@ -229,17 +229,17 @@ export function BuildStateData(model, geoPalette) {
     const compareOperations = Object.keys(StateCompareOperationsMap);
     for (const key in data.shapeStatesConditonalNodes) {
         condiotnalShapeStateNodePalette.push(data.shapeStatesConditonalNodes[key].map((_) => geometryLinkPalette.getNumberId(_.id)));
-        condiotnalShapeStateGeometryPalette.push(data.shapeStatesConditonalNodes[key].map((_) => geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(_))));
+        condiotnalShapeStateGeometryPalette.push(data.shapeStatesConditonalNodes[key].map((_) => geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(_))));
         condiotnalShapeStateNodeRecord[key] =
             condiotnalShapeStateGeometryPalette.length - 1;
         condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]] ??= [];
         const nodeData = data.shapeStatesConditonalNodes[key];
         for (const node of nodeData) {
-            condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]][geoPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node))] =
+            condiotnalShapeStateRelativeGeometryMap[condiotnalShapeStateNodeRecord[key]][geoPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))] =
                 relativeGeoId;
             relativeGeometryByteIndexMap[relativeGeoId] = relativeByteCount;
             relativeGeoId++;
-            relativeByteCount += Math.ceil(VoxelModelManager.getGeomtryFromLink(node).faceCount / 8);
+            relativeByteCount += Math.ceil(VoxelModelRuleBuilderRegister.getGeomtryFromLink(node).faceCount / 8);
         }
         const statement = [];
         const nodes = key.split(" ");
@@ -334,7 +334,7 @@ export function BuildStateData(model, geoPalette) {
         const modStatePalette = [];
         const modStateRecord = {};
         for (const tag of tagEffects) {
-            VoxelTagStates.register(VoxelPalette.ids.getNumberId(voxelId), tag.tagId, schema, tag.tree, tag.treePalette);
+            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) {

package/Voxels/Functions/BuildTagAndPaletteData.d.ts

@@ -0,0 +1,13 @@
+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 = {
+    voxels: VoxelData[];
+    voxelsOverrides?: Record<string, (value: any) => any>;
+    substances: VoxelSubstanceData[];
+    substancesOverrides?: Record<string, (value: any) => any>;
+    materials: VoxelMaterialData[];
+    materialsOverrides?: Record<string, (value: any) => any>;
+};
+export declare function BuildTagAndPaletteData(props: BuildTagAndPaletteDataProps): CompiledVoxelTagAndPaletteData;

package/Voxels/Functions/BuildTagAndPaletteData.js

@@ -0,0 +1,55 @@
+import { VoxelTagsRegister } from "../Data/VoxelTagsRegister";
+import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
+export function BuildTagAndPaletteData(props) {
+    for (const voxel of props.voxels) {
+        const tags = {};
+        const voxelId = VoxelPalettesRegister.voxels.register(voxel.id);
+        VoxelPalettesRegister.voxelIdToNameMap.set(voxel.id, voxel.name || "");
+        VoxelPalettesRegister.voxelNametoIdMap.set(voxel.name || voxel.id, voxel.id);
+        for (const tag of VoxelTagsRegister.IncludedVoxelTags) {
+            if (voxel.properties[tag] === undefined) {
+                tags[tag] = VoxelTagsRegister.VoxelTagDefaults[tag] || false;
+                continue;
+            }
+            if (props?.voxelsOverrides?.[tag]) {
+                tags[tag] = props.voxelsOverrides[tag](voxel.properties[tag]);
+                continue;
+            }
+            tags[tag] = voxel.properties[tag];
+        }
+        VoxelTagsRegister.VoxelTags[voxelId] = tags;
+    }
+    for (const substance of props.substances) {
+        const tags = {};
+        const substanceId = VoxelPalettesRegister.substance.register(substance.id);
+        for (const tag of VoxelTagsRegister.IncludedSubstnacesTags) {
+            if (substance.properties[tag] === undefined) {
+                tags[tag] =
+                    VoxelTagsRegister.SubstanceStagDefaults[tag] || false;
+                continue;
+            }
+            if (props?.substancesOverrides?.[tag]) {
+                tags[tag] = props.substancesOverrides[tag](substance.properties[tag]);
+                continue;
+            }
+            tags[tag] = substance.properties[tag];
+        }
+        VoxelTagsRegister.SubstanceStags[substanceId] = tags;
+    }
+    for (const material of props.materials) {
+        VoxelPalettesRegister.material.register(material.id);
+    }
+    return {
+        data: {
+            palette: VoxelPalettesRegister.voxels._palette,
+            tags: VoxelTagsRegister.VoxelTags,
+            idToNameMap: [...VoxelPalettesRegister.voxelIdToNameMap.entries()],
+            nameToIdMap: [...VoxelPalettesRegister.voxelNametoIdMap.entries()],
+        },
+        substances: {
+            tags: VoxelTagsRegister.SubstanceStags,
+            palette: VoxelPalettesRegister.substance._palette,
+        },
+        materials: { palette: VoxelPalettesRegister.material._palette },
+    };
+}

package/Voxels/Indexes/VoxelIndex.js

@@ -1,6 +1,6 @@
 import { PaintVoxelData } from "../Types/Voxel.types";
 import { SchemaRegister } from "../State/SchemaRegister";
-import { VoxelPalette } from "../Palettes/VoxelPalette";
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
 export class VoxelNamedState {
     voxelId;
     data;
@@ -82,11 +82,11 @@ export class VoxelIndex {
         if (!VoxelIndex.instance)
             VoxelIndex.instance = this;
         for (const voxelData of data) {
+            this.dataMap.set(voxelData.id, voxelData);
             const namedStates = voxelData.properties["dve_named_states"];
             if (!namedStates)
                 continue;
             const states = new VoxelNamedStateContainer(voxelData.id, namedStates.map((_) => new VoxelNamedState(voxelData.id, _)));
-            this.dataMap.set(voxelData.id, voxelData);
             this.stateArray.push(states);
             this.states.set(voxelData.id, states);
             for (const [id, state] of states.states) {
@@ -119,7 +119,7 @@ export class VoxelIndex {
     }
     getStateFromRawData(data) {
         const [id, light, shapeState, secondary, mod] = data;
-        const conatiner = this.states.get(VoxelPalette.ids.getStringId(id));
+        const conatiner = this.states.get(VoxelPalettesRegister.voxels.getStringId(id));
         if (!conatiner)
             return false;
         for (const state of conatiner?.stateArray) {

package/Voxels/InitVoxelData.js

@@ -4,26 +4,18 @@ import { orientedCube, pillarCube, simpleCube, simpleHalfCube, } from "../Models
 import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanelDown, thinPanelSouth, thinPanelWest, } from "../Models/Defaults/PanelVoxelGeometry";
 import { stair } from "../Models/Defaults/StairVoxelModel";
 import { liquidGeometry, liquidModel, } from "../Models/Defaults/LiquidVoxelModel";
-import { VoxelModelManager } from "../Models/Rules/VoxelModelManager";
-import { VoxelStructIds } from "./Types/Voxel.types";
+import { VoxelModelRuleBuilderRegister } from "../Models/Rules/VoxelModelRuleBuilderRegister";
 import { BuildRules } from "../Models/Rules/Functions/BuildRules";
 import { BuildStateData } from "./Functions/BuildStateData";
 import { BuildFinalInputs } from "../Models/Rules/Functions/BuildFinalInputs";
 import { SchemaRegister } from "../Voxels/State/SchemaRegister";
 import { simpleCrossedPannel, simpleThinPannel, } from "../Models/Defaults/PanelVoxelModels";
-import { VoxelTagStates } from "../Voxels/State/VoxelTagStates";
+import { VoxelTagStates } from "./Data/VoxelTagStates";
 import { VoxelIndex } from "../Voxels/Indexes/VoxelIndex";
 import { CacheManager } from "../Cache/CacheManager";
 import { VoxelLightData } from "./Cursor/VoxelLightData";
-import { MaterialDataGenerator } from "./Segments/MaterialDataGenerator";
-import { SubstanceDataGenerator } from "./Segments/SubstanceDataGenerator";
-import { VoxelDataGenerator } from "./Segments/VoxelDataGenerator";
-import { SubstanceStructBuilder } from "./Structs/Builder/SubstanceStructBuilder";
-import { MappedDataRegister } from "../Data/Register/MappedDataRegister";
-import { MaterialPalette } from "./Palettes/MaterialPalette";
-import { VoxelStruct } from "./Structs/VoxelStruct";
-import { SubstanceStruct } from "./Structs/SubstanceStruct";
-import { VoxelStructBuilder } from "./Structs/Builder/VoxelStructBuilder";
+import { VoxelTagIds } from "./Data/VoxelTag.types";
+import { BuildTagAndPaletteData } from "./Functions/BuildTagAndPaletteData";
 function GetModelData(data) {
     if (CacheManager.cacheLoadEnabled && CacheManager.cachedData) {
         const syncData = CacheManager.cachedData.models;
@@ -38,10 +30,10 @@ function GetModelData(data) {
         VoxelTagStates.load(syncData.tagState);
         return syncData;
     }
-    VoxelModelManager.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 || []));
-    VoxelModelManager.registerModels(simpleCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, stair, simpleCrossedPannel, chainModel, carpetModel, candlesModel, leverModel, fence, liquidModel, ...(data.models || []));
+    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: VoxelModelManager.geometryPalette._palette,
+        geometryPalette: VoxelModelRuleBuilderRegister.geometryPalette._palette,
         geometry: [],
         models: [],
         voxels: [],
@@ -51,13 +43,13 @@ function GetModelData(data) {
         const voxelData = voxel.properties["dve_model_data"];
         if (!voxelData)
             continue;
-        VoxelModelManager.registerVoxel(voxel.id, voxelData);
-        const model = VoxelModelManager.models.get(voxelData.id);
+        VoxelModelRuleBuilderRegister.registerVoxel(voxel.id, voxelData);
+        const model = VoxelModelRuleBuilderRegister.models.get(voxelData.id);
         if (!model)
             throw new Error(`Voxel model with id ${voxelData.id} does not exist.`);
         model.voxels.set(voxel.id, voxelData);
     }
-    for (const [mainKey, mainGeo] of VoxelModelManager.geometry) {
+    for (const [mainKey, mainGeo] of VoxelModelRuleBuilderRegister.geometry) {
         if (mainGeo.data.ogData.doNotBuildRules) {
             syncData.geometry.push({
                 id: mainKey,
@@ -66,15 +58,15 @@ function GetModelData(data) {
             });
             continue;
         }
-        const output = BuildRules(mainGeo, VoxelModelManager.geometryPalette);
+        const output = BuildRules(mainGeo, VoxelModelRuleBuilderRegister.geometryPalette);
         syncData.geometry.push({
             id: mainKey,
             nodes: mainGeo.data.nodes,
             ...output,
         });
     }
-    for (const [mainKey, model] of VoxelModelManager.models) {
-        const stateData = BuildStateData(model, VoxelModelManager.geometryPalette);
+    for (const [mainKey, model] of VoxelModelRuleBuilderRegister.models) {
+        const stateData = BuildStateData(model, VoxelModelRuleBuilderRegister.geometryPalette);
         model.stateData = stateData;
         SchemaRegister.registerModel(mainKey, stateData.schema);
         syncData.models.push({
@@ -98,13 +90,14 @@ function GetModelData(data) {
     /*   for (const [mainKey, geometry] of VoxelModelManager.geometry) {
       BuildGeomtryInputs(geometry);
     } */
-    for (const [mainKey, model] of VoxelModelManager.models) {
+    for (const [mainKey, model] of VoxelModelRuleBuilderRegister.models) {
         const { shapeStateVoxelInputs, conditionalShapeStateVoxelInputs, transparentVoxelFaceIndexes, } = BuildFinalInputs(model);
         for (const v in shapeStateVoxelInputs) {
             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",
                 modelId: mainKey,
                 transparentFaceIndex: transparentVoxelFaceIndexes[v].data,
                 modSchema: stateData.modSchema,
@@ -122,7 +115,7 @@ function GetModelData(data) {
 }
 export function InitVoxelData(data) {
     const lightData = new VoxelLightData();
-    const voxelIndex = new VoxelIndex(data.voxels);
+    new VoxelIndex(data.voxels);
     const materials = [
         { id: "dve_solid", properties: {} },
         { id: "dve_flora", properties: {} },
@@ -141,7 +134,6 @@ export function InitVoxelData(data) {
         },
         ...(data.materials || []),
     ];
-    MaterialDataGenerator.generate(materials);
     const substances = [
         {
             id: "dve_air",
@@ -226,7 +218,6 @@ export function InitVoxelData(data) {
         },
         ...(data.substances || []),
     ];
-    SubstanceDataGenerator.generate(substances);
     const voxels = [
         {
             id: "dve_air",
@@ -236,57 +227,24 @@ export function InitVoxelData(data) {
         },
         ...data.voxels,
     ];
-    VoxelDataGenerator.overrides.set(VoxelStructIds.lightValue, (tags, value) => {
-        const v = value;
-        let sl = 0;
-        sl = lightData.setR(v[0], sl);
-        sl = lightData.setG(v[1], sl);
-        sl = lightData.setB(v[2], sl);
-        tags.setProperty(VoxelStructIds.lightValue, sl);
-    });
-    VoxelDataGenerator.overrides.set(VoxelStructIds.renderedMaterial, (tags, value) => {
-        tags.setProperty(VoxelStructIds.renderedMaterial, MaterialDataGenerator.palette._map[value]);
-    });
-    VoxelDataGenerator.overrides.set(VoxelStructIds.substance, (tags, value) => {
-        tags.setProperty(VoxelStructIds.substance, SubstanceDataGenerator.palette._map[value]);
+    const voxelData = BuildTagAndPaletteData({
+        voxels,
+        voxelsOverrides: {
+            [VoxelTagIds.lightValue]: (value) => {
+                const v = value;
+                let sl = 0;
+                sl = lightData.setR(v[0], sl);
+                sl = lightData.setG(v[1], sl);
+                sl = lightData.setB(v[2], sl);
+                return sl;
+            },
+        },
+        substances,
+        materials,
     });
-    VoxelDataGenerator.generate(voxels);
     let models = GetModelData(data);
-    const voxelMaps = VoxelStructBuilder.getMaps();
-    const voxelStringMaps = MappedDataRegister.stringMaps.getSegment("voxel");
-    for (const key in voxelMaps.stringMaps) {
-        voxelStringMaps.add(key, voxelMaps.stringMaps[key]);
-    }
-    const voxelObjectMaps = MappedDataRegister.objectMaps.getSegment("voxel");
-    for (const key in voxelMaps.objectMaps) {
-        voxelObjectMaps.add(key, voxelMaps.objectMaps[key]);
-    }
-    const substanceMaps = SubstanceStructBuilder.getMaps();
-    const substanceStringMaps = MappedDataRegister.stringMaps.getSegment("substance");
-    for (const key in substanceMaps.stringMaps) {
-        substanceStringMaps.add(key, substanceMaps.stringMaps[key]);
-    }
-    const substanceObjectMaps = MappedDataRegister.objectMaps.getSegment("substance");
-    for (const key in substanceMaps.objectMaps) {
-        substanceObjectMaps.add(key, substanceMaps.objectMaps[key]);
-    }
     return {
-        materials: {
-            palette: MaterialPalette.palette._palette,
-        },
         models,
-        data: {
-            palette: VoxelDataGenerator.palette._palette,
-            nameToIdMap: VoxelDataGenerator.nameToIdMap,
-            idToNameMap: VoxelDataGenerator.idToNameMap,
-            ...voxelMaps,
-            struct: VoxelStruct.initData,
-            index: VoxelStruct.voxelIndex,
-        },
-        substances: {
-            palette: SubstanceDataGenerator.palette._palette,
-            ...substanceMaps,
-            struct: SubstanceStruct.initData,
-        },
+        ...voxelData,
     };
 }