@divinevoxel/vlox 0.0.72 → 0.0.73

package/Util/Binary/BinaryArrays.js

@@ -0,0 +1,25 @@
+import { getBitValue, setBitValue } from "./BinaryFunctions";
+export function getBitArrayIndex(data, arrayIndex) {
+    const arrayByteIndex = Math.floor(arrayIndex / 8);
+    const bitPosition = arrayIndex % 8;
+    return getBitValue(data[arrayByteIndex], bitPosition, 1);
+}
+export function setBitArrayIndex(data, arrayIndex, value) {
+    const arrayByteIndex = Math.floor(arrayIndex / 8);
+    const bitPosition = arrayIndex % 8;
+    data[arrayByteIndex] = setBitValue(data[arrayByteIndex], bitPosition, value & 1, 1);
+}
+export function getNibbleArrayIndex(data, arrayIndex) {
+    return getBitValue(data[(arrayIndex / 2) >> 0], arrayIndex % 2 === 0 ? 4 : 0, 4);
+}
+export function setNibbleArrayIndex(data, arrayIndex, value) {
+    const arrayByteIndex = (arrayIndex / 2) >> 0;
+    data[arrayByteIndex] = setBitValue(data[arrayByteIndex], arrayIndex % 2 === 0 ? 4 : 0, value, 4);
+}
+export function getHalfNibbleArrayIndex(data, arrayIndex) {
+    return getBitValue(data[(arrayIndex / 4) >> 0], (arrayIndex % 4) * 2, 2);
+}
+export function setHalfNibbleArrayIndex(data, arrayIndex, value) {
+    const arrayByteIndex = (arrayIndex / 4) >> 0;
+    data[arrayByteIndex] = setBitValue(data[arrayByteIndex], (arrayIndex % 4) * 2, value, 2);
+}

package/Util/Binary/BinaryBuffer.d.ts

@@ -0,0 +1,29 @@
+export type BinaryBufferTypes = 
+/**If the buffer compressed to a single value the type will be a vlaue */
+"value" | "1-bit" | "2-bit" | "4-bit" | "8-bit" | "16-bit";
+export interface BinaryBufferData {
+    type?: BinaryBufferTypes;
+    buffer: number | Uint8Array | Uint16Array;
+}
+export interface BinaryBuffer extends BinaryBufferData {
+}
+export declare class BinaryBuffer {
+    static BytePaletteMax: number;
+    static NibblePaletteMax: number;
+    static HalfNibblePaletteMax: number;
+    static BitPaletteMax: number;
+    static DetermineSubByteArray: (paletteSize: number) => BinaryBufferTypes | null;
+    static CreateBufferForType(type: BinaryBufferTypes, length: number): Uint16Array | Uint8Array;
+    static GetConvertedBufferSize(source: Uint8Array | Uint16Array, type: BinaryBufferTypes): number;
+    static GetIndexLength(source: Uint8Array | Uint16Array, type: BinaryBufferTypes): number;
+    static ReadBufferAtIndex(source: Uint8Array | Uint16Array, type: BinaryBufferTypes, index: number): number;
+    static SetBufferAtIndex(source: Uint8Array | Uint16Array, type: BinaryBufferTypes, index: number, value: number): number | void;
+    static Convert(source: Uint8Array | Uint16Array, sourceType: BinaryBufferTypes, destinationType: BinaryBufferTypes): Uint16Array | Uint8Array;
+    static Create(data: Partial<BinaryBufferData>): BinaryBufferData;
+    constructor(data: BinaryBufferData);
+    getValue(index: number): number;
+    toJSON(): {
+        type?: BinaryBufferTypes | undefined;
+        buffer: number | Uint16Array | Uint8Array;
+    };
+}

package/Util/Binary/BinaryBuffer.js

@@ -0,0 +1,130 @@
+import { getBitArrayIndex, getHalfNibbleArrayIndex, getNibbleArrayIndex, setBitArrayIndex, setHalfNibbleArrayIndex, setNibbleArrayIndex, } from "./BinaryArrays";
+const excludeStore = ["16-bit", "8-bit", "value"];
+export class BinaryBuffer {
+    static BytePaletteMax = 256;
+    static NibblePaletteMax = 16;
+    static HalfNibblePaletteMax = 4;
+    static BitPaletteMax = 2;
+    static DetermineSubByteArray = (paletteSize) => {
+        if (paletteSize == BinaryBuffer.BitPaletteMax)
+            return "1-bit";
+        if (paletteSize > BinaryBuffer.BitPaletteMax &&
+            paletteSize <= BinaryBuffer.HalfNibblePaletteMax)
+            return "2-bit";
+        if (paletteSize > BinaryBuffer.HalfNibblePaletteMax &&
+            paletteSize <= BinaryBuffer.NibblePaletteMax)
+            return "4-bit";
+        if (paletteSize > BinaryBuffer.NibblePaletteMax &&
+            paletteSize <= BinaryBuffer.BytePaletteMax)
+            return "8-bit";
+        return null;
+    };
+    static CreateBufferForType(type, length) {
+        if (type == "16-bit")
+            return new Uint16Array(length);
+        if (type == "8-bit")
+            return new Uint8Array(length);
+        if (type == "1-bit")
+            return new Uint8Array(length);
+        if (type == "2-bit")
+            return new Uint8Array(length);
+        if (type == "4-bit")
+            return new Uint8Array(length);
+        return new Uint8Array(length);
+    }
+    static GetConvertedBufferSize(source, type) {
+        if (type == "16-bit" || type == "8-bit")
+            return source.length;
+        if (type == "1-bit")
+            return source.length / 8;
+        if (type == "4-bit")
+            return source.length / 2;
+        if (type == "2-bit")
+            return source.length / 4;
+        if (type == "value")
+            return 1;
+        return source.length;
+    }
+    static GetIndexLength(source, type) {
+        if (type == "16-bit" || type == "8-bit")
+            return source.length;
+        if (type == "1-bit")
+            return source.length * 8;
+        if (type == "4-bit")
+            return source.length * 2;
+        if (type == "2-bit")
+            return source.length * 4;
+        if (type == "value")
+            return 1;
+        return source.length;
+    }
+    static ReadBufferAtIndex(source, type, index) {
+        if (type == "16-bit" || type == "8-bit")
+            return source[index];
+        if (type == "1-bit")
+            return getBitArrayIndex(source, index);
+        if (type == "4-bit")
+            return getNibbleArrayIndex(source, index);
+        if (type == "2-bit")
+            return getHalfNibbleArrayIndex(source, index);
+        return source[index];
+    }
+    static SetBufferAtIndex(source, type, index, value) {
+        if (type == "16-bit" || type == "8-bit") {
+            return (source[index] = value);
+        }
+        if (type == "1-bit")
+            return setBitArrayIndex(source, index, value);
+        if (type == "4-bit")
+            return setNibbleArrayIndex(source, index, value);
+        if (type == "2-bit")
+            return setHalfNibbleArrayIndex(source, index, value);
+        return source[index];
+    }
+    static Convert(source, sourceType, destinationType) {
+        if (sourceType == destinationType ||
+            (sourceType == "16-bit" && destinationType == "8-bit") ||
+            (sourceType == "8-bit" && destinationType == "16-bit")) {
+            const destination = this.CreateBufferForType(destinationType, this.GetConvertedBufferSize(source, destinationType));
+            destination.set(source);
+            return destination;
+        }
+        const length = this.GetIndexLength(source, sourceType);
+        const destination = this.CreateBufferForType(destinationType, this.GetConvertedBufferSize(source, destinationType));
+        for (let i = 0; i < length; i++) {
+            this.SetBufferAtIndex(destination, destinationType, i, this.ReadBufferAtIndex(source, sourceType, i));
+        }
+        return destination;
+    }
+    static Create(data) {
+        return {
+            buffer: 0,
+            ...data,
+        };
+    }
+    constructor(data) {
+        this.buffer = data.buffer;
+        if (data.type) {
+            this.type = data.type;
+        }
+        else {
+            if (typeof data.buffer === "number")
+                this.type = "value";
+            if (data.buffer instanceof Uint16Array)
+                this.type = "16-bit";
+            if (data.buffer instanceof Uint8Array)
+                this.type = "8-bit";
+        }
+    }
+    getValue(index) {
+        if (typeof this.buffer == "number")
+            return this.buffer;
+        return BinaryBuffer.ReadBufferAtIndex(this.buffer, this.type, index);
+    }
+    toJSON() {
+        return {
+            buffer: this.buffer,
+            ...(excludeStore.includes(this.type) ? {} : { type: this.type }),
+        };
+    }
+}

package/Util/Binary/{BitArray.d.ts → BinaryFunctions.d.ts}

@@ -1,4 +1,3 @@
 export declare function getBitValue(data: number, bitIndex: number, bitSize: number): number;
 export declare function setBitValue(data: number, bitIndex: number, value: number, bitSize: number): number;
-export declare function getBitArrayIndex(data: Uint8Array, arrayIndex: number): number;
-export declare function setBitArrayIndex(data: Uint8Array, arrayIndex: number, value: number): void;
+export declare function forceMultipleOf2(n: number): number;

package/Util/Binary/BinaryFunctions.js

@@ -0,0 +1,11 @@
+export function getBitValue(data, bitIndex, bitSize) {
+    const mask = (1 << bitSize) - 1;
+    return (data >>> bitIndex) & mask;
+}
+export function setBitValue(data, bitIndex, value, bitSize) {
+    const mask = (1 << bitSize) - 1;
+    return (data & ~(mask << bitIndex)) | ((value & mask) << bitIndex);
+}
+export function forceMultipleOf2(n) {
+    return n % 2 === 0 ? n : n + 1;
+}

package/Voxels/Cursor/DataCursor.interface.d.ts

@@ -0,0 +1,5 @@
+import { VoxelCursorInterface } from "./VoxelCursor.interface";
+export interface DataCursorInterface {
+    getVoxel(x: number, y: number, z: number): VoxelCursorInterface | null;
+    inBounds(x: number, y: number, z: number): boolean;
+}

package/Voxels/Cursor/VoxelCursor.interface.d.ts

@@ -59,7 +59,7 @@ export declare abstract class VoxelCursorInterface {
     setId(id: number): this;
     setStringId(id: string): this;
     getStringId(): string;
-    setName(name: string): void;
+    setName(name: string): this;
     getName(): string;
     isSameVoxel(voxel: VoxelCursorInterface): boolean;
     copy(cursor: VoxelCursorInterface): this;

package/Voxels/Cursor/VoxelCursor.interface.js

@@ -54,7 +54,7 @@ export class VoxelCursorInterface {
         return this._substanceTags;
     }
     isOpaque() {
-        return this._tags[VoxelTagIds.isTransparent];
+        return !this._tags[VoxelTagIds.isTransparent];
     }
     getMod() {
         return this.mod[this._index];
@@ -105,17 +105,14 @@ export class VoxelCursorInterface {
     getLight() {
         if (this._loadedId == 0)
             return this.light[this._index];
-        const lightValue = this._tags[VoxelTagIds.lightValue];
         if (this.isOpaque()) {
-            if (this.isLightSource() && lightValue) {
-                return lightValue;
-            }
-            else {
-                return -1;
+            if (this.isLightSource()) {
+                return this._tags[VoxelTagIds.lightValue];
             }
+            return -1;
         }
-        if (this.isLightSource() && lightValue) {
-            return this._lightData.mixLight(this.light[this._index], lightValue);
+        if (this.isLightSource()) {
+            return this._lightData.mixLight(this.light[this._index], this._tags[VoxelTagIds.lightValue]);
         }
         return this.light[this._index];
     }
@@ -178,10 +175,10 @@ export class VoxelCursorInterface {
         return VoxelPalettesRegister.voxels.getStringId(this.id);
     }
     setName(name) {
-        this.setStringId(VoxelPalettesRegister.voxelName.getId(name));
+        return this.setStringId(VoxelPalettesRegister.voxelNametoIdMap.get(name));
     }
     getName() {
-        return this.getStringId();
+        return VoxelPalettesRegister.voxelIdToNameMap.get(this.getStringId());
     }
     isSameVoxel(voxel) {
         return this.getId() == voxel.getId();

package/Voxels/Data/VoxelPalettesRegister.d.ts

@@ -5,9 +5,4 @@ export declare class VoxelPalettesRegister {
     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

@@ -5,13 +5,4 @@ export class VoxelPalettesRegister {
     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/VoxelTagsRegister.js

@@ -1,4 +1,4 @@
-import { VoxelSubstanceTagIdds, VoxelTagIds, } from "./VoxelTag.types";
+import { VoxelSubstanceTagIdds as VoxelSubstanceTagIds, VoxelTagIds, } from "./VoxelTag.types";
 export class VoxelTagsRegister {
     static IncludedVoxelTags = [
         VoxelTagIds.substance,
@@ -14,12 +14,12 @@ export class VoxelTagsRegister {
         VoxelTagIds.canHaveSecondary,
     ];
     static IncludedSubstnacesTags = [
-        VoxelSubstanceTagIdds.parent,
-        VoxelSubstanceTagIdds.isSolid,
-        VoxelSubstanceTagIdds.isTransparent,
-        VoxelSubstanceTagIdds.isLiquid,
-        VoxelSubstanceTagIdds.flowRate,
-        VoxelSubstanceTagIdds.isWindAffected,
+        VoxelSubstanceTagIds.parent,
+        VoxelSubstanceTagIds.isSolid,
+        VoxelSubstanceTagIds.isTransparent,
+        VoxelSubstanceTagIds.isLiquid,
+        VoxelSubstanceTagIds.flowRate,
+        VoxelSubstanceTagIds.isWindAffected,
     ];
     static VoxelTagDefaults = {
         [VoxelTagIds.renderedMaterial]: "dve_solid",

package/Voxels/Functions/BuildStateData.js

@@ -1,6 +1,6 @@
 import { StateCompareOperationsMap, StateLogicOperationsMap, } from "../State/State.types";
 import { StringPalette } from "../../Util/StringPalette";
-import { VoxelModelManager } from "../../Models/Rules/VoxelModelManager";
+import { VoxelModelRuleBuilderRegister } from "../../Models/Rules/VoxelModelRuleBuilderRegister";
 import { VoxelTagStates } from "../Data/VoxelTagStates";
 import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
 import { StateSchema } from "../State/Schema/StateSchema";
@@ -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(" ");

package/Voxels/Functions/BuildTagAndPaletteData.js

@@ -4,10 +4,8 @@ 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);
-        }
+        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;

package/Voxels/InitVoxelData.js

@@ -4,7 +4,7 @@ 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 { VoxelModelRuleBuilderRegister } from "../Models/Rules/VoxelModelRuleBuilderRegister";
 import { BuildRules } from "../Models/Rules/Functions/BuildRules";
 import { BuildStateData } from "./Functions/BuildStateData";
 import { BuildFinalInputs } from "../Models/Rules/Functions/BuildFinalInputs";
@@ -30,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: [],
@@ -43,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,
@@ -58,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({
@@ -90,7 +90,7 @@ 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);
@@ -115,8 +115,7 @@ function GetModelData(data) {
 }
 export function InitVoxelData(data) {
     const lightData = new VoxelLightData();
-    const voxelIndex = new VoxelIndex(data.voxels);
-    console.warn(voxelIndex, voxelIndex.dataMap);
+    new VoxelIndex(data.voxels);
     const materials = [
         { id: "dve_solid", properties: {} },
         { id: "dve_flora", properties: {} },

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 "../../../Tools/DataCursor.interface";
+import { DataCursorInterface } from "../../Cursor/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,6 +1,22 @@
 import { TextureId } from "../../Textures/index";
 import { VoxelModelConstructorData } from "../../Models/VoxelModel.types";
 import { VoxelTags } from "../Data/VoxelTag.types";
+export interface VoxelDataArrays {
+    /**The runtime numeric voxel ids */
+    ids: Uint16Array;
+    /**The light data for voxels stored as 4 nibbles. 0 -> sun light 1 -> red light 2 -> green light 3 -> blue light */
+    light: Uint16Array;
+    /**The levels of the voxel. Used mainly for waterflow now. */
+    level: Uint8Array;
+    /**The state of the voxel. Used mainly be the voxel model system to get the model shape. */
+    state: Uint16Array;
+    /**The mod state of the voxel. Used mainly by the voxel model system to change model inputs. */
+    mod: Uint16Array;
+    /**The secondary state of the voxel. Can be set to a voxel id to make things like water logged voxels.
+     * But the main voxel itself must not use state or mod because the secondary voxel will use the same state and mod.
+     */
+    secondary: Uint16Array;
+}
 export type VoxelNamedStateData = {
     id: string;
     name?: string;
@@ -20,11 +36,13 @@ export type VoxelNamedStateData = {
 };
 export declare class PaintVoxelData {
     id: string;
+    name: string;
     mod: number;
     state: number;
     level: number;
     levelState: number;
     secondaryVoxelId: string;
+    secondaryVoxeName: string;
     static Create(data: Partial<PaintVoxelData>): PaintVoxelData;
     private constructor();
 }

package/Voxels/Types/Voxel.types.js

@@ -1,19 +1,23 @@
 export class PaintVoxelData {
     id;
+    name;
     mod;
     state;
     level;
     levelState;
     secondaryVoxelId;
+    secondaryVoxeName;
     static Create(data) {
-        return new PaintVoxelData(data.id, data.mod, data.state, data.level, data.levelState, data.secondaryVoxelId);
+        return new PaintVoxelData(data.id, data.name, data.mod, data.state, data.level, data.levelState, data.secondaryVoxelId, data.secondaryVoxeName);
     }
-    constructor(id = "dve_air", mod = 0, state = 0, level = 0, levelState = 0, secondaryVoxelId = "dve_air") {
+    constructor(id = "dve_air", name = "", mod = 0, state = 0, level = 0, levelState = 0, secondaryVoxelId = "dve_air", secondaryVoxeName = "") {
         this.id = id;
+        this.name = name;
         this.mod = mod;
         this.state = state;
         this.level = level;
         this.levelState = levelState;
         this.secondaryVoxelId = secondaryVoxelId;
+        this.secondaryVoxeName = secondaryVoxeName;
     }
 }