@divinevoxel/vlox 0.0.7 → 0.0.72

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,13 @@
+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>;
+    static loadInVoxel(voxelPalette: string[], nameToIdMap: Record<string, string>, idToNameMap: Record<string, string>): void;
+    static voxelName: {
+        getId: (name: string) => string;
+        getName: (id: string) => string;
+    };
+}

package/Voxels/Data/VoxelPalettesRegister.js

@@ -0,0 +1,17 @@
+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();
+    static loadInVoxel(voxelPalette, nameToIdMap, idToNameMap) {
+        this.voxels = new StringPalette(voxelPalette);
+        this.voxelNametoIdMap = new Map(Object.entries(nameToIdMap));
+        this.voxelIdToNameMap = new Map(Object.entries(idToNameMap));
+    }
+    static voxelName = {
+        getId: (name) => this.voxelNametoIdMap.get(name),
+        getName: (id) => this.voxelIdToNameMap.get(id),
+    };
+}

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, 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 = [
+        VoxelSubstanceTagIdds.parent,
+        VoxelSubstanceTagIdds.isSolid,
+        VoxelSubstanceTagIdds.isTransparent,
+        VoxelSubstanceTagIdds.isLiquid,
+        VoxelSubstanceTagIdds.flowRate,
+        VoxelSubstanceTagIdds.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 { VoxelTagStates } from "../Data/VoxelTagStates";
+import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
 import { StateSchema } from "../State/Schema/StateSchema";
 function bitsNeeded(n) {
     if (n < 0)
@@ -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,57 @@
+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);
+        if (voxel.name) {
+            VoxelPalettesRegister.voxelIdToNameMap.set(voxel.id, voxel.name || "");
+            VoxelPalettesRegister.voxelNametoIdMap.set(voxel.name || "", 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

@@ -5,25 +5,17 @@ import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanelDown, th
 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 { 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;
@@ -105,6 +97,7 @@ function GetModelData(data) {
             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,
@@ -123,6 +116,7 @@ function GetModelData(data) {
 export function InitVoxelData(data) {
     const lightData = new VoxelLightData();
     const voxelIndex = new VoxelIndex(data.voxels);
+    console.warn(voxelIndex, voxelIndex.dataMap);
     const materials = [
         { id: "dve_solid", properties: {} },
         { id: "dve_flora", properties: {} },
@@ -141,7 +135,6 @@ export function InitVoxelData(data) {
         },
         ...(data.materials || []),
     ];
-    MaterialDataGenerator.generate(materials);
     const substances = [
         {
             id: "dve_air",
@@ -226,7 +219,6 @@ export function InitVoxelData(data) {
         },
         ...(data.substances || []),
     ];
-    SubstanceDataGenerator.generate(substances);
     const voxels = [
         {
             id: "dve_air",
@@ -236,57 +228,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,
     };
 }

package/Voxels/State/Schema/StateSchema.d.ts

@@ -1,7 +1,7 @@
 import { ShapeStateRelationsNode } from "./ShapeStateRelationsNode";
 import { BinarySchemaNode } from "./BinarySchemaNode";
 import { VoxelModelStateSchemaData } from "../State.types";
-import { DataCursorInterface } from "../../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../../Tools/DataCursor.interface";
 import { Vector3Like } from "@amodx/math";
 import { VoxelCursorInterface } from "../../Cursor/VoxelCursor.interface";
 export declare class StateSchema {

package/Voxels/Types/Voxel.types.d.ts

@@ -1,5 +1,6 @@
 import { TextureId } from "../../Textures/index";
 import { VoxelModelConstructorData } from "../../Models/VoxelModel.types";
+import { VoxelTags } from "../Data/VoxelTag.types";
 export type VoxelNamedStateData = {
     id: string;
     name?: string;
@@ -44,49 +45,8 @@ export type RawVoxelData = [
     /**The secondary id of the voxel */
     secondary: number
 ];
-export declare enum VoxelStructIds {
-    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",
-    isRich = "dve_is_rich",
-    canHaveSecondary = "dve_can_have_secondary"
-}
-interface VoxelProperties {
+interface VoxelProperties extends Partial<VoxelTags> {
     [key: string]: any;
-    /** The material used to render the voxel. Used by the engine to assign meshes to the proper material. */
-    [VoxelStructIds.renderedMaterial]?: string;
-    /** A description of the material used for the voxel. Not used by the engine directly. */
-    [VoxelStructIds.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.
-     * */
-    [VoxelStructIds.substance]?: string;
-    /** Indicates whether the voxel is a light source. */
-    [VoxelStructIds.isLightSource]?: boolean;
-    /** Indicates if the voxel lets light through */
-    [VoxelStructIds.isTransparent]?: boolean;
-    /** Disables ambient occlusion for this voxel if set to true. */
-    [VoxelStructIds.noAO]?: boolean;
-    /** Defines the light value emitted by the voxel (r, g, z). */
-    [VoxelStructIds.lightValue]?: [r: number, g: number, z: number];
-    /** The collider ID for the voxel, used for collision detection. */
-    [VoxelStructIds.colliderID]?: string;
-    /** Specifies if the voxel participates in collision checks. */
-    [VoxelStructIds.checkCollisions]?: boolean;
-    /** Indicates if the voxel can have a secondary voxel. */
-    [VoxelStructIds.canHaveSecondary]?: boolean;
-    /** The hardness level of the voxel, affecting how it is broken or interacted with. */
-    [VoxelStructIds.hardness]?: number;
-    /** Marks the voxel as "rich" for specialized interactions or rendering. */
-    [VoxelStructIds.isRich]?: boolean;
     /** Named states associated with the voxel. */
     dve_named_states?: VoxelNamedStateData[];
     /** Model data used to construct the voxel's appearance. */

package/Voxels/Types/Voxel.types.js

@@ -17,18 +17,3 @@ export class PaintVoxelData {
         this.secondaryVoxelId = secondaryVoxelId;
     }
 }
-export var VoxelStructIds;
-(function (VoxelStructIds) {
-    VoxelStructIds["substance"] = "dve_substance";
-    VoxelStructIds["renderedMaterial"] = "dve_rendered_material";
-    VoxelStructIds["voxelMaterial"] = "dve_voxel_material";
-    VoxelStructIds["hardness"] = "dve_hardness";
-    VoxelStructIds["colliderID"] = "dve_collider_id";
-    VoxelStructIds["checkCollisions"] = "dve_check_collisions";
-    VoxelStructIds["isLightSource"] = "dve_is_light_source";
-    VoxelStructIds["noAO"] = "dve_no_ao";
-    VoxelStructIds["isTransparent"] = "dve_is_transparent";
-    VoxelStructIds["lightValue"] = "dve_light_value";
-    VoxelStructIds["isRich"] = "dve_is_rich";
-    VoxelStructIds["canHaveSecondary"] = "dve_can_have_secondary";
-})(VoxelStructIds || (VoxelStructIds = {}));

package/Voxels/Types/VoxelModelCompiledData.types.d.ts

@@ -5,29 +5,26 @@ import { VoxelFaceTransparentResultsIndexData } from "../../Models/Indexing/Voxe
 import { VoxelModelStateSchemaData, StateLogicStatement } from "../State/State.types";
 import { VoxelGeometryData, VoxelGeometryNodes } from "../../Models/VoxelModel.types";
 import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
-import { VoxelTagStatesData } from "../State/VoxelTagStates";
-import { BinaryStructData } from "@amodx/binary";
-export type CompiledVoxelData = {
-    models: FinalCompiledVoxelModelData;
+import { VoxelTagStatesData } from "../Data/VoxelTagStates";
+import { VoxelSubstanceTags, VoxelTags } from "../Data/VoxelTag.types";
+export type CompiledVoxelTagAndPaletteData = {
     data: {
-        struct: BinaryStructData;
-        index: Uint16Array;
+        tags: VoxelTags[];
         palette: string[];
-        nameToIdMap: Record<string, string>;
-        idToNameMap: Record<string, string>;
-        stringMaps: Record<string, string[]>;
-        objectMaps: Record<string, any[]>;
+        nameToIdMap: [string, string][];
+        idToNameMap: [string, string][];
     };
     substances: {
-        struct: BinaryStructData;
+        tags: VoxelSubstanceTags[];
         palette: string[];
-        stringMaps: Record<string, string[]>;
-        objectMaps: Record<string, any[]>;
     };
     materials: {
         palette: string[];
     };
 };
+export type CompiledVoxelData = {
+    models: FinalCompiledVoxelModelData;
+} & CompiledVoxelTagAndPaletteData;
 export interface CompiledVoxelGeometryNodes {
     node: VoxelGeometryNodes;
     tranform: VoxelGeometryTransform;
@@ -77,6 +74,7 @@ export interface CompiledVoxelModelData {
 }
 export interface CompiledVoxelModelInputData {
     id: string;
+    materialId: string;
     modelId: string;
     transparentFaceIndex: VoxelFaceTransparentResultsIndexData;
     modSchema: VoxelModelStateSchemaData[];

package/Voxels/Types/VoxelSubstances.types.d.ts

@@ -1,19 +1,6 @@
-export declare enum SubstanceStructIds {
-    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 VoxelSubstanceDataProperties {
+import { VoxelSubstanceTags } from "../Data/VoxelTag.types";
+export interface VoxelSubstanceDataProperties extends Partial<VoxelSubstanceTags> {
     [key: string]: any;
-    [SubstanceStructIds.parent]?: string;
-    [SubstanceStructIds.isTransparent]?: boolean;
-    [SubstanceStructIds.isSolid]?: boolean;
-    [SubstanceStructIds.isLiquid]?: boolean;
-    [SubstanceStructIds.flowRate]?: number;
-    [SubstanceStructIds.isWindAffected]?: boolean;
 }
 export type VoxelSubstanceData = {
     id: string;

package/Voxels/Types/VoxelSubstances.types.js

@@ -1,9 +1 @@
-export var SubstanceStructIds;
-(function (SubstanceStructIds) {
-    SubstanceStructIds["parent"] = "dve_parent_substance";
-    SubstanceStructIds["isSolid"] = "dve_is_solid";
-    SubstanceStructIds["isTransparent"] = "dve_is_transparent";
-    SubstanceStructIds["isLiquid"] = "dve_is_liquid";
-    SubstanceStructIds["flowRate"] = "dve_flow_rate";
-    SubstanceStructIds["isWindAffected"] = "dve_is_wind_affected";
-})(SubstanceStructIds || (SubstanceStructIds = {}));
+export {};