@divinevoxel/vlox 0.0.3 → 0.0.5

package/Voxels/InitVoxelData.js

@@ -5,6 +5,7 @@ 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";
@@ -13,9 +14,18 @@ import { simpleCrossedPannel, simpleThinPannel, } from "../Models/Defaults/Panel
 import { VoxelTagStates } from "../Voxels/State/VoxelTagStates";
 import { VoxelIndex } from "../Voxels/Indexes/VoxelIndex";
 import { CacheManager } from "../Cache/CacheManager";
-export function InitVoxelData(data) {
+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";
+function GetModelData(data) {
     if (CacheManager.cacheLoadEnabled && CacheManager.cachedData) {
-        console.warn("load sync data");
         const syncData = CacheManager.cachedData.models;
         for (let i = 0; i < syncData.models.length; i++) {
             const model = syncData.models[i];
@@ -26,14 +36,8 @@ export function InitVoxelData(data) {
             SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
         }
         VoxelTagStates.load(syncData.tagState);
-        const t = performance.now();
-        console.log("sent the data", performance.now() - t);
-        const t2 = performance.now();
-        const voxelIndex = new VoxelIndex(data.voxels);
-        console.log("built the index", performance.now() - t2);
         return syncData;
     }
-    const initTime = performance.now();
     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 || []));
     const syncData = {
@@ -53,8 +57,6 @@ export function InitVoxelData(data) {
             throw new Error(`Voxel model with id ${voxelData.id} does not exist.`);
         model.voxels.set(voxel.id, voxelData);
     }
-    const output = {};
-    const startTime = performance.now();
     for (const [mainKey, mainGeo] of VoxelModelManager.geometry) {
         if (mainGeo.data.ogData.doNotBuildRules) {
             syncData.geometry.push({
@@ -71,8 +73,6 @@ export function InitVoxelData(data) {
             ...output,
         });
     }
-    console.log("done building rules", performance.now() - startTime);
-    const inputStartTime = performance.now();
     for (const [mainKey, model] of VoxelModelManager.models) {
         const stateData = BuildStateData(model, VoxelModelManager.geometryPalette);
         model.stateData = stateData;
@@ -116,24 +116,177 @@ export function InitVoxelData(data) {
     }
     syncData.tagState = VoxelTagStates.toJSON();
     if (CacheManager.cacheStoreEnabled) {
-        console.warn("Store sync data", syncData);
         CacheManager.cachedModelData = syncData;
     }
-    console.log(syncData);
-    console.log(syncData.voxels.find((_) => _.id == "dve_liquid_dream_ether"));
-    console.log("done building inputs", performance.now() - inputStartTime);
-    console.log("init voxel models done | totle time: ", performance.now() - initTime);
-    const voxelIndex = new VoxelIndex(data.voxels);
-    /*
-    const blob = new Blob([JSON.stringify(output, null, 1)], {});
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement("a");
-    a.href = url;
-    a.download = "rules.json";
-    document.body.appendChild(a);
-    a.click();
-    document.body.removeChild(a);
-    URL.revokeObjectURL(url);
-   */
     return syncData;
 }
+export function InitVoxelData(data) {
+    const lightData = new VoxelLightData();
+    const voxelIndex = new VoxelIndex(data.voxels);
+    const materials = [
+        { id: "dve_solid", properties: {} },
+        { id: "dve_flora", properties: {} },
+        {
+            id: "dve_transparent",
+            properties: {
+                dve_is_transparent: true,
+            },
+        },
+        { id: "dve_glow", properties: {} },
+        {
+            id: "dve_liquid",
+            properties: {
+                dve_is_transparent: true,
+            },
+        },
+        ...(data.materials || []),
+    ];
+    MaterialDataGenerator.generate(materials);
+    const substances = [
+        {
+            id: "dve_air",
+            properties: {
+                dve_parent_substance: "dve_air",
+                dve_is_solid: false,
+                dve_is_liquid: false,
+                dve_is_transparent: true,
+                dve_flow_rate: 0,
+            },
+        },
+        {
+            id: "dve_solid",
+            properties: {
+                dve_parent_substance: "dve_solid",
+                dve_is_solid: true,
+                dve_is_liquid: false,
+                dve_is_transparent: false,
+                dve_flow_rate: 0,
+            },
+        },
+        {
+            id: "dve_glow",
+            properties: {
+                dve_parent_substance: "dve_solid",
+                dve_is_solid: true,
+                dve_is_liquid: false,
+                dve_is_transparent: false,
+                dve_flow_rate: 0,
+            },
+        },
+        {
+            id: "dve_translucent",
+            properties: {
+                dve_parent_substance: "dve_solid",
+                dve_is_solid: true,
+                dve_is_liquid: false,
+                dve_is_transparent: true,
+                dve_flow_rate: 0,
+            },
+        },
+        {
+            id: "dve_transparent",
+            properties: {
+                dve_parent_substance: "dve_solid",
+                dve_is_solid: true,
+                dve_is_liquid: false,
+                dve_is_transparent: true,
+                dve_flow_rate: 0,
+            },
+        },
+        {
+            id: "dve_flora",
+            properties: {
+                dve_parent_substance: "dve_solid",
+                dve_is_solid: true,
+                dve_is_liquid: false,
+                dve_is_transparent: true,
+                dve_flow_rate: 0,
+                dve_is_wind_affected: true,
+            },
+        },
+        {
+            id: "dve_liquid",
+            properties: {
+                dve_parent_substance: "dve_liquid",
+                dve_is_solid: false,
+                dve_is_liquid: true,
+                dve_is_transparent: true,
+                dve_flow_rate: 1,
+            },
+        },
+        {
+            id: "dve_magma",
+            properties: {
+                dve_parent_substance: "dve_liquid",
+                dve_is_solid: false,
+                dve_is_liquid: true,
+                dve_is_transparent: false,
+                dve_flow_rate: 3,
+            },
+        },
+        ...(data.substances || []),
+    ];
+    SubstanceDataGenerator.generate(substances);
+    const voxels = [
+        {
+            id: "dve_air",
+            properties: {
+                dve_substance: "dve_air",
+            },
+        },
+        ...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]);
+    });
+    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,
+        },
+    };
+}

package/Voxels/Segments/MaterialDataGenerator.d.ts

@@ -0,0 +1,6 @@
+import { StringPalette } from "../../Util/StringPalette";
+import { VoxelMaterialData } from "..";
+export declare const MaterialDataGenerator: {
+    generate(data: VoxelMaterialData[]): void;
+    palette: StringPalette;
+};

package/{Contexts/Base/Main/Generator → Voxels}/Segments/MaterialDataGenerator.js

@@ -1,5 +1,5 @@
-import { MaterialPalette } from "../../../../../Data/Palettes/MaterialPalette";
-import { StringPalette } from "../../../../../Util/StringPalette";
+import { MaterialPalette } from "../Palettes/MaterialPalette";
+import { StringPalette } from "../../Util/StringPalette";
 export const MaterialDataGenerator = {
     generate(data) {
         //build palette

package/Voxels/Segments/SubstanceDataGenerator.d.ts

@@ -0,0 +1,6 @@
+import { StringPalette } from "../../Util/StringPalette";
+import { VoxelSubstanceData } from "../Types/VoxelSubstances.types";
+export declare const SubstanceDataGenerator: {
+    generate(data: VoxelSubstanceData[]): void;
+    palette: StringPalette;
+};

package/{Contexts/Base/Main/Generator → Voxels}/Segments/SubstanceDataGenerator.js

@@ -1,7 +1,7 @@
-import { SubstanceStructBuilder } from "../../../../../Data/Structs/Builder/SubstanceStructBuilder";
-import { SubstanceStruct } from "../../../../../Data/Structs/SubstanceStruct";
-import { SubstancePalette } from "../../../../../Data/Palettes/SubstancePalette";
-import { StringPalette } from "../../../../../Util/StringPalette";
+import { SubstancePalette } from "../Palettes/SubstancePalette";
+import { StringPalette } from "../../Util/StringPalette";
+import { SubstanceStructBuilder } from "../Structs/Builder/SubstanceStructBuilder";
+import { SubstanceStruct } from "..//Structs/SubstanceStruct";
 export const SubstanceDataGenerator = {
     generate(data) {
         //build palette

package/{Contexts/Base/Main/Generator → Voxels}/Segments/VoxelDataGenerator.d.ts

@@ -1,6 +1,6 @@
 import { BinaryStruct } from "@amodx/binary";
-import { StringPalette } from "../../../../../Util/StringPalette";
-import { VoxelData } from "../../../../../Voxels/Voxel.types";
+import { StringPalette } from "../../Util/StringPalette";
+import { VoxelData } from "../Types/Voxel.types";
 export declare class VoxelDataGenerator {
     static overrides: Map<string, (tags: BinaryStruct, value: unknown, id: string) => void>;
     static nameToIdMap: Record<string, string>;

package/{Contexts/Base/Main/Generator → Voxels}/Segments/VoxelDataGenerator.js

@@ -1,8 +1,8 @@
 //objects
-import { VoxelStructBuilder } from "../../../../../Data/Structs/Builder/VoxelStructBuilder";
-import { VoxelPalette } from "../../../../../Data/Palettes/VoxelPalette";
-import { VoxelStruct } from "../../../../../Data/Structs/VoxelStruct";
-import { StringPalette } from "../../../../../Util/StringPalette";
+import { VoxelStructBuilder } from "../Structs/Builder/VoxelStructBuilder";
+import { VoxelPalette } from "../Palettes/VoxelPalette";
+import { VoxelStruct } from "../Structs/VoxelStruct";
+import { StringPalette } from "../../Util/StringPalette";
 export class VoxelDataGenerator {
     static overrides = new Map();
     static nameToIdMap = {};
@@ -16,7 +16,6 @@ export class VoxelDataGenerator {
             this.nameToIdMap[voxel.name ? voxel.name : voxel.id] = voxel.id;
             this.idToNameMap[voxel.id] = voxel.name ? voxel.name : voxel.id;
         }
-        console.warn("create voxel palette", VoxelPalette.ids, this.palette);
         VoxelPalette.loadIn(this.palette._palette, this.nameToIdMap, this.idToNameMap);
         //build index
         const indexBuffer = new SharedArrayBuffer(this.palette.size * 2);

package/Voxels/State/LogicStatementReader.js

@@ -17,7 +17,7 @@ export class LogicStatementReader {
                 currentOperation = node;
                 continue;
             }
-            const value = this.schema.nodes[node[0]].getValue(this.schema.voxel.getShapeState());
+            const value = this.schema.nodes[node[0]].getValue(this.schema.voxel.getState());
             switch (node[1]) {
                 case StateCompareOperations.Equals:
                     currentValue = value == node[2];

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

@@ -1,11 +1,14 @@
 import { BinarySchemaNode } from "./BinarySchemaNode";
 import { BinarySchemaNodeData } from "../State.types";
+type StateObject = (string | number)[];
 export declare class BinarySchema {
     nodeMap: Map<string, BinarySchemaNode>;
     nodes: BinarySchemaNode[];
     constructor(schema: BinarySchemaNodeData[]);
     private _value;
     readString(stateString: string): number;
+    fromStateObject(stateObject: StateObject): number;
+    getStateObject(stateValue: number): StateObject;
     compareString(stateString: string, ecnoded: number): boolean;
     startEncoding(value?: number): this;
     getNmber(id: string): number;
@@ -14,3 +17,4 @@ export declare class BinarySchema {
     setValue(id: string, value: string): this;
     getEncoded(): number;
 }
+export {};

package/Voxels/State/Schema/BinarySchema.js

@@ -27,7 +27,7 @@ export class BinarySchema {
             if (node.valuePalette) {
                 const value = node.valuePalette.getNumberId(v);
                 if (value === undefined)
-                    throw new Error(`Binary schema string node value  with id ${v} does not exist.`);
+                    throw new Error(`Binary schema string node value with id ${v} does not exist.`);
                 ecnoded = node.setValue(ecnoded, value);
             }
             else {
@@ -36,6 +36,37 @@ export class BinarySchema {
         }
         return ecnoded;
     }
+    fromStateObject(stateObject) {
+        let encodedValue = 0;
+        for (let i = 0; i < stateObject.length; i += 2) {
+            const key = stateObject[i];
+            if (typeof key !== "string")
+                continue;
+            const value = stateObject[i + 1];
+            const node = this.nodeMap.get(key);
+            if (!node)
+                continue;
+            if (typeof value == "string") {
+                if (!node.valuePalette)
+                    continue;
+                encodedValue = node.setValue(encodedValue, node.valuePalette.getNumberId(value) || 0);
+                continue;
+            }
+            encodedValue = node.setValue(encodedValue, value);
+        }
+        return encodedValue;
+    }
+    getStateObject(stateValue) {
+        const stateArray = [];
+        for (const node of this.nodes) {
+            if (node.valuePalette) {
+                stateArray.push(node.id, node.valuePalette.getStringId(node.getValue(stateValue)));
+                continue;
+            }
+            stateArray.push(node.id, node.getValue(stateValue));
+        }
+        return stateArray;
+    }
     compareString(stateString, ecnoded) {
         if (stateString == "*")
             return true;

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

@@ -1,9 +1,9 @@
 import { ShapeStateRelationsNode } from "./ShapeStateRelationsNode";
 import { BinarySchemaNode } from "./BinarySchemaNode";
 import { VoxelModelStateSchemaData } from "../State.types";
-import { DataCursorInterface } from "../../../Data/Cursor/Interfaces/DataCursor.interface";
+import { DataCursorInterface } from "../../../Data/Cursor/DataCursor.interface";
 import { Vector3Like } from "@amodx/math";
-import { VoxelCursorInterface } from "../../../Data/Cursor/Interfaces/VoxelCursor.interface";
+import { VoxelCursorInterface } from "../../Cursor/VoxelCursor.interface";
 export declare class StateSchema {
     nodes: (BinarySchemaNode | ShapeStateRelationsNode)[];
     position: Vector3Like;

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

@@ -1,7 +1,7 @@
 import { BinarySchema } from "./BinarySchema";
-export declare class VoxelSceham {
+export declare class VoxelSchema {
     id: string;
-    shapeState: BinarySchema;
-    modState: BinarySchema;
-    constructor(id: string, shapeState: BinarySchema, modState: BinarySchema);
+    state: BinarySchema;
+    mod: BinarySchema;
+    constructor(id: string, state: BinarySchema, mod: BinarySchema);
 }

package/Voxels/State/Schema/VoxelSchema.js

@@ -1,10 +1,10 @@
-export class VoxelSceham {
+export class VoxelSchema {
     id;
-    shapeState;
-    modState;
-    constructor(id, shapeState, modState) {
+    state;
+    mod;
+    constructor(id, state, mod) {
         this.id = id;
-        this.shapeState = shapeState;
-        this.modState = modState;
+        this.state = state;
+        this.mod = mod;
     }
 }

package/Voxels/State/SchemaRegister.d.ts

@@ -1,5 +1,5 @@
 import { BinarySchema } from "./Schema/BinarySchema";
-import { VoxelSceham } from "./Schema/VoxelSchema";
+import { VoxelSchema } from "./Schema/VoxelSchema";
 import { BinarySchemaNodeData, VoxelModelStateSchemaData } from "./State.types";
 export declare class SchemaRegister {
     static modelStaeBaseSchemaData: Map<string, VoxelModelStateSchemaData[]>;
@@ -8,8 +8,9 @@ export declare class SchemaRegister {
     static modelStaeSchemas: Map<string, BinarySchema>;
     static voxelModSchemas: Map<string, BinarySchema>;
     static voxelModelMap: Map<string, string>;
-    static voxelSchemas: Map<string, VoxelSceham>;
-    static getVoxelSchemas(voxelId: string): VoxelSceham;
+    static voxelSchemas: Map<string, VoxelSchema>;
+    static hasVoxelSchema(voxelId: string): boolean;
+    static getVoxelSchemas(voxelId: string): VoxelSchema;
     static registerModel(id: string, data: VoxelModelStateSchemaData[]): void;
     static registerVoxel(id: string, modelId: string, data: VoxelModelStateSchemaData[]): void;
 }

package/Voxels/State/SchemaRegister.js

@@ -1,5 +1,5 @@
 import { BinarySchema } from "./Schema/BinarySchema";
-import { VoxelSceham } from "./Schema/VoxelSchema";
+import { VoxelSchema } from "./Schema/VoxelSchema";
 export class SchemaRegister {
     static modelStaeBaseSchemaData = new Map();
     static modelStateSchemaData = new Map();
@@ -8,6 +8,9 @@ export class SchemaRegister {
     static voxelModSchemas = new Map();
     static voxelModelMap = new Map();
     static voxelSchemas = new Map();
+    static hasVoxelSchema(voxelId) {
+        return this.voxelSchemas.has(voxelId);
+    }
     static getVoxelSchemas(voxelId) {
         if (this.voxelSchemas.has(voxelId)) {
             return this.voxelSchemas.get(voxelId);
@@ -29,7 +32,7 @@ export class SchemaRegister {
                 throw new Error(`Voxel ${voxelId} is not registered`);
             modSchema = new BinarySchema(schemaData);
         }
-        const voxelSchema = new VoxelSceham(voxelId, shapeStateSchema, modSchema);
+        const voxelSchema = new VoxelSchema(voxelId, shapeStateSchema, modSchema);
         this.voxelSchemas.set(voxelId, voxelSchema);
         return voxelSchema;
     }

package/Voxels/State/VoxelTagStates.js

@@ -1,4 +1,4 @@
-import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { VoxelPalette } from "../Palettes/VoxelPalette";
 import { StateSchema } from "./Schema/StateSchema";
 import { StateTreeReader } from "./StateTreeReader";
 import { SchemaRegister } from "./SchemaRegister";

package/Voxels/Structs/Builder/SubstanceStructBuilder.d.ts

@@ -0,0 +1,2 @@
+import { StructBuilder } from "../../../Data/Structs/StructBuilder.js";
+export declare const SubstanceStructBuilder: StructBuilder;

package/{Data → Voxels}/Structs/Builder/SubstanceStructBuilder.js

@@ -1,6 +1,6 @@
 import { BinaryNumberTypes } from "@amodx/binary";
-import { SubstanceStructIds } from "../../../Voxels/VoxelSubstances.types";
-import { StructBuilder } from "./StructBuilder.js";
+import { SubstanceStructIds } from "../../Types/VoxelSubstances.types";
+import { StructBuilder } from "../../../Data/Structs/StructBuilder.js";
 export const SubstanceStructBuilder = new StructBuilder("substance-tag-manager", "substance");
 SubstanceStructBuilder.addNode([
     {

package/Voxels/Structs/Builder/VoxelStructBuilder.d.ts

@@ -0,0 +1,2 @@
+import { StructBuilder } from "../../../Data/Structs/StructBuilder.js";
+export declare const VoxelStructBuilder: StructBuilder;

package/{Data → Voxels}/Structs/Builder/VoxelStructBuilder.js

@@ -1,6 +1,6 @@
 import { BinaryNumberTypes } from "@amodx/binary";
-import { VoxelStructIds } from "../../../Voxels/Voxel.types";
-import { StructBuilder } from "./StructBuilder.js";
+import { VoxelStructIds } from "../../Types/Voxel.types";
+import { StructBuilder } from "../../../Data/Structs/StructBuilder.js";
 export const VoxelStructBuilder = new StructBuilder("voxel-tag-manager", "voxel");
 VoxelStructBuilder.addNode([
     {
@@ -8,11 +8,6 @@ VoxelStructBuilder.addNode([
         type: "string-map",
         allowedComms: ["constructor", "nexus", "fx", "world", "render"],
     },
-    {
-        id: VoxelStructIds.shapeID,
-        type: "string-map",
-        allowedComms: ["constructor"],
-    },
     {
         id: VoxelStructIds.colliderID,
         type: "string-map",

package/{Data → Voxels}/Structs/SubstanceStruct.d.ts

@@ -1,6 +1,7 @@
 import { BinaryStructData, InstantiatedStruct } from "@amodx/binary/";
-import { SubstanceStructIds } from "../../Voxels/VoxelSubstances.types.js";
+import { SubstanceStructIds } from "../Types/VoxelSubstances.types.js";
 export interface SubstanceStruct {
+    [key: string]: any;
     [SubstanceStructIds.parent]: number;
     [SubstanceStructIds.isSolid]: number;
     [SubstanceStructIds.isTransparent]: number;

package/{Data → Voxels}/Structs/SubstanceStruct.js

@@ -1,5 +1,5 @@
 import { RemoteBinaryStruct, InstantiatedStruct, } from "@amodx/binary/";
-import { SubstanceStructIds } from "../../Voxels/VoxelSubstances.types.js";
+import { SubstanceStructIds } from "../Types/VoxelSubstances.types.js";
 import { SubstancePalette } from "../Palettes/SubstancePalette.js";
 const remote = new RemoteBinaryStruct("voxel-data");
 export class SubstanceStruct extends InstantiatedStruct {
@@ -11,9 +11,7 @@ export class SubstanceStruct extends InstantiatedStruct {
         SubstanceStruct.instance = instance;
     }
     static setSubstance(id) {
-        this.instance.setIndex(typeof id == "string"
-            ? SubstancePalette.id.numberFromString(id)
-            : id);
+        this.instance.setIndex(typeof id == "string" ? SubstancePalette.id.numberFromString(id) : id);
     }
     static initData;
 }

package/{Data → Voxels}/Structs/VoxelStruct.d.ts

@@ -1,8 +1,8 @@
 import { BinaryStructData, InstantiatedStruct } from "@amodx/binary/";
-import { VoxelStructIds } from "../../Voxels/Voxel.types";
+import { VoxelStructIds } from "../Types/Voxel.types";
 export interface VoxelStruct {
+    [key: string]: any;
     [VoxelStructIds.substance]: number;
-    [VoxelStructIds.shapeID]: number;
     [VoxelStructIds.renderedMaterial]: number;
     [VoxelStructIds.voxelMaterial]: number;
     [VoxelStructIds.hardness]: number;

package/{Data → Voxels}/Structs/VoxelStruct.js

@@ -1,5 +1,5 @@
 import { RemoteBinaryStruct, InstantiatedStruct, } from "@amodx/binary/";
-import { VoxelStructIds } from "../../Voxels/Voxel.types";
+import { VoxelStructIds } from "../Types/Voxel.types";
 import { VoxelPalette } from "../Palettes/VoxelPalette";
 const remote = new RemoteBinaryStruct("voxel-data");
 export class VoxelStruct extends InstantiatedStruct {

package/Voxels/{Voxel.types.d.ts → Types/Voxel.types.d.ts}

@@ -1,5 +1,5 @@
-import { ConstructorTextureData } from "../Textures/Constructor.types";
-import { VoxelModelConstructorData } from "../Models/VoxelModel.types";
+import { TextureId } from "../../Textures/index";
+import { VoxelModelConstructorData } from "../../Models/VoxelModel.types";
 export type VoxelNamedStateData = {
     id: string;
     name?: string;
@@ -10,13 +10,23 @@ export type VoxelNamedStateData = {
     };
     display: {
         type: "texture";
-        source: ConstructorTextureData | string;
+        source: TextureId | string;
     } | {
         type: "model";
         state?: string;
         mod?: string;
     };
 };
+export declare class PaintVoxelData {
+    id: string;
+    mod: number;
+    state: number;
+    level: number;
+    levelState: number;
+    secondaryVoxelId: string;
+    static Create(data: Partial<PaintVoxelData>): PaintVoxelData;
+    private constructor();
+}
 /**
  * An array representing the raw data of a voxel.
  */
@@ -25,16 +35,17 @@ export type RawVoxelData = [
     id: number,
     /**The light of the voxel */
     light: number,
+    /**The level of the voxel */
+    level: number,
     /**The state of the voxel */
     state: number,
-    /**The secondary id of the voxel */
-    secondaryId: number,
     /**The mod of the voxel */
-    mod: number
+    mod: number,
+    /**The secondary id of the voxel */
+    secondary: number
 ];
 export declare enum VoxelStructIds {
     substance = "dve_substance",
-    shapeID = "dve_shape_id",
     renderedMaterial = "dve_rendered_material",
     voxelMaterial = "dve_voxel_material",
     hardness = "dve_hardness",