@divinevoxel/vlox 0.0.77 → 0.0.79

package/Voxels/Models/VoxelModel.types.d.ts

@@ -1,115 +1,8 @@
-import { Vec2Array, Vec3Array } from "@amodx/math";
-import { VoxelFaceNames } from "../../Math";
+import { Vec3Array } from "@amodx/math";
 import { VoxelModelRelationsSchemaNodes, VoxelBinaryStateSchemaNode } from "../../Voxels/State/State.types";
 import { VoxelEffectData } from "../../Voxels/Effects/VoxelEffects.types";
 import { VoxelBaseProperties } from "../Types/Voxel.types";
-/**Define a custom geomtry node */
-export interface VoxelCustomGeomtryNode {
-    type: "custom";
-    id: string;
-    inputs: Record<string, any>;
-}
-export interface VoxelBoxGeometryNode {
-    type: "box";
-    /**Divisor used for transform of this specific node.*/
-    divisor?: Vec3Array;
-    points: [start: Vec3Array, end: Vec3Array];
-    rotation?: Vec3Array;
-    faces: Record<VoxelFaceNames, BaseVoxelQuadData>;
-}
-export interface BaseVoxelQuadData {
-    doubleSided?: boolean | string;
-    enabled?: boolean;
-    /**Id for an input arg for the texture */
-    texture: string;
-    /**UV for the face or id for an input arg. */
-    uv: [x1: number, y1: number, x2: number, y2: number] | string;
-    /**UV rotation or id for an input arg */
-    rotation?: number | string;
-}
-export interface VoxelQuadGeometryNode extends BaseVoxelQuadData {
-    type: "quad";
-    /**Divisor used for transform of this specific node.*/
-    divisor?: Vec3Array;
-    points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array];
-}
-export interface BaseVoxelTriangleData {
-    doubleSided?: boolean;
-    /**Id for the input arg for the texture */
-    texture: string;
-    /**UV for the triangle or id for the input arg. */
-    uv: [v1: Vec2Array, v2: Vec2Array, v3: Vec2Array] | string;
-    /**UV rotation or id for an input arg */
-    rotation?: number | string;
-}
-export interface VoxelTriangleGeometryNode extends BaseVoxelTriangleData {
-    type: "triangle";
-    /**Divisor used for transform of this specific node.*/
-    divisor?: Vec3Array;
-    points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array];
-}
-export interface VoxelGeometryTextureArgument {
-    type: "texture";
-}
-/**Creates a way to set multiple arguments to the same thing. What ever value is passed in will be passed to the arguments. */
-export interface VoxelGeometryArgumentAliasList {
-    type: "arg-list";
-    arguments: string[];
-}
-export interface VoxelGeometryBooleanArgument {
-    type: "boolean";
-    default: boolean;
-}
-export interface VoxelGeometryIntArgument {
-    type: "int";
-    default: number;
-}
-export interface VoxelGeometryFloatArgument {
-    type: "float";
-    default: number;
-}
-export interface VoxelGeometryBoxUVArgument {
-    type: "box-uv";
-    default: [x1: number, y1: number, x2: number, y2: number];
-}
-export interface VoxelGeometryUVArgument {
-    type: "uv";
-    default: Vec2Array[];
-}
-export interface VoxelGeometryVector3Argument {
-    type: "vector3";
-    default?: Vec3Array;
-    min?: Vec3Array;
-    max?: Vec3Array;
-}
-export type VoxelGeometryNodes = VoxelCustomGeomtryNode | VoxelBoxGeometryNode | VoxelTriangleGeometryNode | VoxelQuadGeometryNode;
-export type CullingProcedureData = {
-    type: "default";
-} | {
-    type: "none";
-} | {
-    type: "transparent";
-} | {
-    type: "custom";
-    id: string;
-    data: any;
-};
-export interface VoxelGeometryData {
-    id: string;
-    nodes: VoxelGeometryNodes[];
-    divisor?: Vec3Array;
-    /**
-     * If this is set the voxel geometry will not be included in the
-     * geometry rules and will be fall back to custom inputs.
-     * Ideal for advanced or non cubic models.
-     * */
-    doNotBuildRules?: true;
-    /**
-     * Define the culling procedure for faces
-     */
-    cullingProcedure?: CullingProcedureData;
-    arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument | VoxelGeometryArgumentAliasList>;
-}
+import { CullingProcedureData, VoxelGeometryTextureArgument, VoxelGeometryBoxUVArgument, VoxelGeometryVector3Argument, VoxelGeometryIntArgument, VoxelGeometryBooleanArgument, VoxelGeometryFloatArgument } from "../Geometry/VoxelGeometry.types";
 export interface VoxelGeometryLinkData {
     geometryId: string;
     /**

package/Voxels/State/{Schema → Reltional}/Conditions/SameVoxelConditions.d.ts

@@ -1,8 +1,8 @@
 import { SameVoxelRelationsConditionData } from "../../State.types";
 import { ShapeStateSchemaRelationsCondition } from "./ShapeStateSchemaRelationsCondition";
-import { StateSchema } from "../StateSchema";
+import { ReltionalStateBuilder } from "../ReltionalStateBuilder";
 export declare class SameVoxelCondition extends ShapeStateSchemaRelationsCondition {
     data: SameVoxelRelationsConditionData;
-    constructor(schema: StateSchema, data: SameVoxelRelationsConditionData);
+    constructor(builder: ReltionalStateBuilder, data: SameVoxelRelationsConditionData);
     evulate(): boolean;
 }

package/Voxels/State/Reltional/Conditions/SameVoxelConditions.js

@@ -0,0 +1,19 @@
+import { ShapeStateSchemaRelationsCondition } from "./ShapeStateSchemaRelationsCondition";
+export class SameVoxelCondition extends ShapeStateSchemaRelationsCondition {
+    data;
+    constructor(builder, data) {
+        super(builder);
+        this.data = data;
+    }
+    evulate() {
+        const nx = this.builder.position.x + this.data.direction[0];
+        const ny = this.builder.position.y + this.data.direction[1];
+        const nz = this.builder.position.z + this.data.direction[2];
+        if (!this.builder.dataCursor.inBounds(nx, ny, nz))
+            return false;
+        const nVoxel = this.builder.dataCursor.getVoxel(nx, ny, nz);
+        if (!nVoxel)
+            return false;
+        return this.builder.voxel.isSameVoxel(nVoxel);
+    }
+}

package/Voxels/State/Reltional/Conditions/ShapeStateSchemaRelationsCondition.d.ts

@@ -0,0 +1,6 @@
+import { ReltionalStateBuilder } from "../ReltionalStateBuilder";
+export declare abstract class ShapeStateSchemaRelationsCondition {
+    builder: ReltionalStateBuilder;
+    constructor(builder: ReltionalStateBuilder);
+    abstract evulate(): boolean;
+}

package/Voxels/State/Reltional/Conditions/ShapeStateSchemaRelationsCondition.js

@@ -0,0 +1,6 @@
+export class ShapeStateSchemaRelationsCondition {
+    builder;
+    constructor(builder) {
+        this.builder = builder;
+    }
+}

package/Voxels/State/Reltional/ReltionalStateBuilder.d.ts

@@ -0,0 +1,18 @@
+import { Vector3Like } from "@amodx/math";
+import { VoxelModelRelationsSchemaNodes } from "../State.types";
+import { ShapeStateSchemaRelationsCondition } from "./Conditions/ShapeStateSchemaRelationsCondition";
+import { VoxelCursorInterface } from "../../Cursor/VoxelCursor.interface";
+import { DataCursorInterface } from "../../Cursor/DataCursor.interface";
+import { BinarySchema } from "../Schema/BinarySchema";
+export declare class ReltionalStateBuilder {
+    binarySchema: BinarySchema;
+    readonly schemaNodes: VoxelModelRelationsSchemaNodes[];
+    name: string;
+    position: Vector3Like;
+    voxel: VoxelCursorInterface;
+    dataCursor: DataCursorInterface;
+    nodes: Map<string, ShapeStateSchemaRelationsCondition[]>;
+    constructor(binarySchema: BinarySchema, schemaNodes: VoxelModelRelationsSchemaNodes[]);
+    buildState(): number;
+    getSchema(): VoxelModelRelationsSchemaNodes[];
+}

package/Voxels/State/Reltional/ReltionalStateBuilder.js

@@ -0,0 +1,42 @@
+import { Vector3Like } from "@amodx/math";
+import { SameVoxelCondition } from "./Conditions/SameVoxelConditions";
+export class ReltionalStateBuilder {
+    binarySchema;
+    schemaNodes;
+    name;
+    position = Vector3Like.Create();
+    voxel;
+    dataCursor;
+    nodes = new Map();
+    constructor(binarySchema, schemaNodes) {
+        this.binarySchema = binarySchema;
+        this.schemaNodes = schemaNodes;
+        for (const node of schemaNodes) {
+            const conditions = [];
+            for (const cond of node.conditions) {
+                if (cond.type == "same-voxel") {
+                    conditions.push(new SameVoxelCondition(this, cond));
+                }
+            }
+            this.nodes.set(node.name, conditions);
+        }
+    }
+    buildState() {
+        this.binarySchema.startEncoding(0);
+        for (const [nodeId, conditions] of this.nodes) {
+            let value = 1;
+            const conditionsLength = conditions.length;
+            for (let i = 0; i < conditionsLength; i++) {
+                if (!conditions[i].evulate()) {
+                    value = 0;
+                    break;
+                }
+            }
+            this.binarySchema.setNumber(nodeId, value);
+        }
+        return this.binarySchema.getEncoded();
+    }
+    getSchema() {
+        return this.schemaNodes;
+    }
+}

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

@@ -18,5 +18,6 @@ export declare class BinarySchema {
     setNumber(id: string, value: number): this;
     setValue(id: string, value: string): this;
     getEncoded(): number;
+    getSchema(): VoxelBinaryStateSchemaNode[];
 }
 export {};

package/Voxels/State/Schema/BinarySchema.js

@@ -146,4 +146,7 @@ export class BinarySchema {
     getEncoded() {
         return this._value;
     }
+    getSchema() {
+        return this.nodes.map((_) => _.data);
+    }
 }

package/Voxels/State/State.types.d.ts

@@ -24,28 +24,3 @@ export interface VoxelModelRelationsSchemaNodes {
     name: string;
     conditions: VoxelStateRelationsConditionData[];
 }
-export declare enum StateCompareOperations {
-    Equals = 0,
-    NotEquals = 1,
-    GreaterThan = 2,
-    LessThan = 3
-}
-export declare enum StateLogiceOperations {
-    And = 0,
-    Or = 1
-}
-export declare const StateCompareOperationsMap: Record<string, StateCompareOperations>;
-export declare const StateLogicOperationsMap: Record<string, StateLogiceOperations>;
-export type StateLogicNode = [
-    schemaId: number,
-    operation: StateCompareOperations,
-    value: number
-];
-export type StateLogicStatement = (StateLogicNode | StateLogiceOperations)[];
-/**
- * Voxel State
- */
-export type VoxelStateSchemaData = {
-    binary: VoxelBinaryStateSchemaNode[];
-    relational: VoxelModelRelationsSchemaNodes[];
-};

package/Voxels/State/State.types.js

@@ -1,22 +1 @@
-export var StateCompareOperations;
-(function (StateCompareOperations) {
-    StateCompareOperations[StateCompareOperations["Equals"] = 0] = "Equals";
-    StateCompareOperations[StateCompareOperations["NotEquals"] = 1] = "NotEquals";
-    StateCompareOperations[StateCompareOperations["GreaterThan"] = 2] = "GreaterThan";
-    StateCompareOperations[StateCompareOperations["LessThan"] = 3] = "LessThan";
-})(StateCompareOperations || (StateCompareOperations = {}));
-export var StateLogiceOperations;
-(function (StateLogiceOperations) {
-    StateLogiceOperations[StateLogiceOperations["And"] = 0] = "And";
-    StateLogiceOperations[StateLogiceOperations["Or"] = 1] = "Or";
-})(StateLogiceOperations || (StateLogiceOperations = {}));
-export const StateCompareOperationsMap = {
-    "=": StateCompareOperations.Equals,
-    "!=": StateCompareOperations.NotEquals,
-    ">": StateCompareOperations.GreaterThan,
-    "<": StateCompareOperations.LessThan,
-};
-export const StateLogicOperationsMap = {
-    "&&": StateLogiceOperations.And,
-    "||": StateLogiceOperations.Or,
-};
+export {};

package/Voxels/State/VoxelSchemas.d.ts

@@ -0,0 +1,22 @@
+import { ReltionalStateBuilder } from "./Reltional/ReltionalStateBuilder";
+import { BinarySchema } from "./Schema/BinarySchema";
+import { VoxelBinaryStateSchemaNode, VoxelModelRelationsSchemaNodes } from "./State.types";
+export type VoxelSchemasExport = {
+    state: [key: string, VoxelBinaryStateSchemaNode[]][];
+    mod: [key: string, VoxelBinaryStateSchemaNode[]][];
+    reltioanlState: [key: string, VoxelBinaryStateSchemaNode[]][];
+    reltionalStateBuilder: [key: string, VoxelModelRelationsSchemaNodes[]][];
+    reltioanlMod: [key: string, VoxelBinaryStateSchemaNode[]][];
+    reltionalModBuilder: [key: string, VoxelModelRelationsSchemaNodes[]][];
+};
+export declare class VoxelSchemas {
+    static state: Map<string, BinarySchema>;
+    static mod: Map<string, BinarySchema>;
+    static reltioanlState: Map<string, BinarySchema>;
+    static reltionalStateBuilder: Map<string, ReltionalStateBuilder>;
+    static reltioanlMod: Map<string, BinarySchema>;
+    static reltionalModBuilder: Map<string, ReltionalStateBuilder>;
+    static getStateSchema(voxelId: string): BinarySchema | undefined;
+    static export(): VoxelSchemasExport;
+    static import(exported: VoxelSchemasExport): void;
+}

package/Voxels/State/VoxelSchemas.js

@@ -0,0 +1,60 @@
+import { VoxelLUT } from "../Data/VoxelLUT";
+import { ReltionalStateBuilder } from "./Reltional/ReltionalStateBuilder";
+import { BinarySchema } from "./Schema/BinarySchema";
+export class VoxelSchemas {
+    //maps voxel model ids to the their state scehma
+    static state = new Map();
+    //maps voxel ids to their mod schemao
+    static mod = new Map();
+    //maps voxel model ids to their reltional state schema
+    static reltioanlState = new Map();
+    //maps voxel model ids = their reltional state builder
+    static reltionalStateBuilder = new Map();
+    //maps voxel ids to their reltional mod schema
+    static reltioanlMod = new Map();
+    //maps voxel ids = their reltional mod builder
+    static reltionalModBuilder = new Map();
+    static getStateSchema(voxelId) {
+        const modelId = VoxelLUT.models.getStringId(VoxelLUT.modelsIndex[VoxelLUT.voxelIds.getNumberId(voxelId)]);
+        return this.state.get(modelId);
+    }
+    static export() {
+        return {
+            state: [...this.state].map(([key, value]) => [key, value.getSchema()]),
+            mod: [...this.mod].map(([key, value]) => [key, value.getSchema()]),
+            reltioanlState: [...this.reltioanlState].map(([key, value]) => [
+                key,
+                value.getSchema(),
+            ]),
+            reltionalStateBuilder: [...this.reltionalStateBuilder].map(([key, value]) => [key, value.getSchema()]),
+            reltioanlMod: [...this.reltioanlMod].map(([key, value]) => [
+                key,
+                value.getSchema(),
+            ]),
+            reltionalModBuilder: [...this.reltionalModBuilder].map(([key, value]) => [
+                key,
+                value.getSchema(),
+            ]),
+        };
+    }
+    static import(exported) {
+        this.state = new Map(exported.state.map(([key, nodes]) => [key, new BinarySchema(nodes)]));
+        this.mod = new Map(exported.mod.map(([key, nodes]) => [key, new BinarySchema(nodes)]));
+        this.reltioanlState = new Map(exported.reltioanlState.map(([key, nodes]) => [
+            key,
+            new BinarySchema(nodes),
+        ]));
+        this.reltionalStateBuilder = new Map(exported.reltionalStateBuilder.map(([key, nodes]) => [
+            key,
+            new ReltionalStateBuilder(this.reltioanlState.get(key), nodes),
+        ]));
+        this.reltioanlMod = new Map(exported.reltioanlMod.map(([key, nodes]) => [
+            key,
+            new BinarySchema(nodes),
+        ]));
+        this.reltionalModBuilder = new Map(exported.reltionalModBuilder.map(([key, nodes]) => [
+            key,
+            new ReltionalStateBuilder(this.reltioanlMod.get(key), nodes),
+        ]));
+    }
+}

package/Voxels/Types/PaintVoxelData.js

@@ -1,6 +1,6 @@
-import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
+import { VoxelLUT } from "../Data/VoxelLUT";
 import { VoxelLevelReader } from "../Cursor/VoxelLevelReader";
-import { SchemaRegister } from "../../Voxels/State/SchemaRegister";
+import { VoxelSchemas } from "../../Voxels/State/VoxelSchemas";
 export class PaintVoxelData {
     id;
     name;
@@ -21,20 +21,18 @@ export class PaintVoxelData {
     }
     /**Transforms numeric voxel data into a PaintVoxelData object */
     static FromRaw(data, paintData = PaintVoxelData.Create()) {
-        const [trueVoxelId, state, mod] = VoxelPalettesRegister.voxels[data[0]];
-        paintData.id = VoxelPalettesRegister.voxelIds.getStringId(trueVoxelId);
+        const [trueVoxelId, state, mod] = VoxelLUT.voxels[data[0]];
+        paintData.id = VoxelLUT.voxelIds.getStringId(trueVoxelId);
         paintData.state = state;
         paintData.mod = mod;
-        paintData.name =
-            VoxelPalettesRegister.voxelIdToNameMap.get(paintData.id) || "";
+        paintData.name = VoxelLUT.voxelIdToNameMap.get(paintData.id) || "";
         if (data[3] !== 0) {
-            const [trueVoxelId, state, mod] = VoxelPalettesRegister.voxels[data[3]];
-            paintData.secondaryVoxelId =
-                VoxelPalettesRegister.voxelIds.getStringId(trueVoxelId);
+            const [trueVoxelId, state, mod] = VoxelLUT.voxels[data[3]];
+            paintData.secondaryVoxelId = VoxelLUT.voxelIds.getStringId(trueVoxelId);
             paintData.secondaryState = state;
             paintData.secondaryMod = mod;
             paintData.secondaryName =
-                VoxelPalettesRegister.voxelIdToNameMap.get(paintData.secondaryVoxelId) || "";
+                VoxelLUT.voxelIdToNameMap.get(paintData.secondaryVoxelId) || "";
         }
         paintData.level = VoxelLevelReader.getLevel(data[2]);
         paintData.levelState = VoxelLevelReader.getLevel(data[2]);
@@ -45,41 +43,47 @@ export class PaintVoxelData {
         let stringId = data.id
             ? data.id
             : data.name
-                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                ? VoxelLUT.voxelNametoIdMap.get(data.name)
                 : "dve_air";
         let secondaryStringId = data.secondaryName
             ? data.secondaryVoxelId
             : data.secondaryName
-                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.secondaryName)
+                ? VoxelLUT.voxelNametoIdMap.get(data.secondaryName)
                 : "dve_air";
         let state = data.state || 0;
         let mod = data.mod || 0;
         let secondaryState = data.secondaryState || 0;
         let secondaryMod = data.secondaryMod || 0;
-        if (SchemaRegister.hasVoxelSchema(stringId)) {
-            const schema = SchemaRegister.getVoxelSchemas(stringId);
-            if (data.stateString && data.stateString !== "") {
-                state = schema.state.readString(data.stateString);
-            }
-            if (data.modString && data.modString !== "") {
-                mod = schema.mod.readString(data.modString);
-            }
+        const trueId = VoxelLUT.voxelIds.getNumberId(stringId);
+        const stateSchema = VoxelSchemas.state.get(VoxelLUT.models.getStringId(VoxelLUT.modelsIndex[trueId]));
+        if (stateSchema && data.stateString && data.stateString !== "") {
+            state = stateSchema.readString(data.stateString);
+        }
+        const modSchema = VoxelSchemas.mod.get(stringId);
+        if (modSchema && data.modString && data.modString !== "") {
+            mod = modSchema.readString(data.modString);
         }
-        if (secondaryStringId && SchemaRegister.hasVoxelSchema(secondaryStringId)) {
-            const schema = SchemaRegister.getVoxelSchemas(secondaryStringId);
-            if (data.secondaryStateString && data.secondaryStateString !== "") {
-                secondaryState = schema.state.readString(data.secondaryStateString);
+        if (secondaryStringId) {
+            const trueId = VoxelLUT.voxelIds.getNumberId(secondaryStringId);
+            const stateSchema = VoxelSchemas.state.get(VoxelLUT.models.getStringId(VoxelLUT.modelsIndex[trueId]));
+            if (stateSchema &&
+                data.secondaryStateString &&
+                data.secondaryStateString !== "") {
+                secondaryState = stateSchema.readString(data.secondaryStateString);
             }
-            if (data.secondaryModString && data.secondaryModString !== "") {
-                secondaryMod = schema.mod.readString(data.secondaryModString);
+            const modSchema = VoxelSchemas.mod.get(secondaryStringId);
+            if (modSchema &&
+                data.secondaryModString &&
+                data.secondaryModString !== "") {
+                secondaryMod = modSchema.readString(data.secondaryModString);
             }
         }
         const id = stringId !== "dve_air"
-            ? VoxelPalettesRegister.getVoxelIdFromString(stringId, state || 0, mod || 0)
+            ? VoxelLUT.getVoxelIdFromString(stringId, state || 0, mod || 0)
             : 0;
         const secondaryId = secondaryStringId !== "dve_air"
             ? secondaryStringId
-                ? VoxelPalettesRegister.getVoxelIdFromString(secondaryStringId, secondaryState || 0, secondaryMod || 0)
+                ? VoxelLUT.getVoxelIdFromString(secondaryStringId, secondaryState || 0, secondaryMod || 0)
                 : 0
             : 0;
         let levleData = 0;
@@ -145,15 +149,15 @@ export class PaintVoxelData {
         let stringId = data.id
             ? data.id
             : data.name
-                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                ? VoxelLUT.voxelNametoIdMap.get(data.name)
                 : "dve_air";
         let secondaryStringId = data.secondaryName
             ? data.secondaryVoxelId
             : data.secondaryName
-                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.secondaryName)
+                ? VoxelLUT.voxelNametoIdMap.get(data.secondaryName)
                 : "dve_air";
         if (data.name && !data.id) {
-            data.id = VoxelPalettesRegister.voxelNametoIdMap.get(data.name);
+            data.id = VoxelLUT.voxelNametoIdMap.get(data.name);
         }
         if (!data.name && !data.id) {
             data.id = "dve_air";
@@ -161,14 +165,14 @@ export class PaintVoxelData {
         delete data.name;
         let state = data.state || 0;
         let mod = data.mod || 0;
-        if (SchemaRegister.hasVoxelSchema(stringId)) {
-            const schema = SchemaRegister.getVoxelSchemas(stringId);
-            if (data.stateString && data.stateString !== "") {
-                state = schema.state.readString(data.stateString);
-            }
-            if (data.modString && data.modString !== "") {
-                mod = schema.mod.readString(data.modString);
-            }
+        const trueId = VoxelLUT.voxelIds.getNumberId(stringId);
+        const stateSchema = VoxelSchemas.state.get(VoxelLUT.models.getStringId(VoxelLUT.modelsIndex[trueId]));
+        if (stateSchema && data.stateString && data.stateString !== "") {
+            state = stateSchema.readString(data.stateString);
+        }
+        const modSchema = VoxelSchemas.mod.get(stringId);
+        if (modSchema && data.modString && data.modString !== "") {
+            mod = modSchema.readString(data.modString);
         }
         data.state = state;
         data.mod = mod;
@@ -176,13 +180,19 @@ export class PaintVoxelData {
         delete data.modString;
         let secondaryState = data.secondaryState || 0;
         let secondaryMod = data.secondaryMod || 0;
-        if (secondaryStringId && SchemaRegister.hasVoxelSchema(secondaryStringId)) {
-            const schema = SchemaRegister.getVoxelSchemas(secondaryStringId);
-            if (data.secondaryStateString && data.secondaryStateString !== "") {
-                secondaryState = schema.state.readString(data.secondaryStateString);
+        if (secondaryStringId) {
+            const trueId = VoxelLUT.voxelIds.getNumberId(secondaryStringId);
+            const stateSchema = VoxelSchemas.state.get(VoxelLUT.models.getStringId(VoxelLUT.modelsIndex[trueId]));
+            if (stateSchema &&
+                data.secondaryStateString &&
+                data.secondaryStateString !== "") {
+                secondaryState = stateSchema.readString(data.secondaryStateString);
             }
-            if (data.secondaryModString && data.secondaryModString !== "") {
-                secondaryMod = schema.mod.readString(data.secondaryModString);
+            const modSchema = VoxelSchemas.mod.get(secondaryStringId);
+            if (modSchema &&
+                data.secondaryModString &&
+                data.secondaryModString !== "") {
+                secondaryMod = modSchema.readString(data.secondaryModString);
             }
         }
         data.secondaryState = secondaryState;

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

@@ -1,25 +1,7 @@
 import { VoxelSubstanceTags, VoxelTags } from "../Data/VoxelTag.types";
 import { VoxelLogicData } from "../Logic/VoxelLogic.types";
-import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
-import { FinalCompiledVoxelModelData } from "../Models/CompiledVoxelModel.types";
-export type CompiledVoxelTagAndPaletteData = {
-    data: {
-        logic: Record<string, VoxelLogicData[]>;
-        tags: VoxelTags[];
-        idPalette: string[];
-        palette: typeof VoxelPalettesRegister.voxels;
-        record: typeof VoxelPalettesRegister.voxelRecord;
-        nameToIdMap: [string, string][];
-        idToNameMap: [string, string][];
-    };
-    substances: {
-        tags: VoxelSubstanceTags[];
-        palette: string[];
-    };
-    materials: {
-        palette: string[];
-    };
+export type CompiledvVxelTags = {
+    logic: Record<string, VoxelLogicData[]>;
+    tags: VoxelTags[];
+    substanceTags: VoxelSubstanceTags[];
 };
-export type CompiledVoxelData = {
-    models: FinalCompiledVoxelModelData;
-} & CompiledVoxelTagAndPaletteData;

package/World/Archive/Classes/ImportedSection.js

@@ -1,6 +1,6 @@
 import { NumberPalette } from "../../../Util/NumberPalette";
 import { BinaryBuffer, BinaryBufferFormat, } from "../../../Util/BinaryBuffer/index";
-import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
 import { lightSegments, lightSemgnetSet, } from "../Functions/Shared/LightSegments";
 import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
 import { WorldSpaces } from "../../WorldSpaces";
@@ -110,12 +110,12 @@ export class ImportedSection {
     getId(index) {
         const value = this.buffers.ids.getValue(index);
         if (this.buffers.ids.isValue) {
-            return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
+            return VoxelLUT.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
         }
         if (this.palettes.voxels) {
-            return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(this.palettes.voxels.getValue(value)));
+            return VoxelLUT.getVoxelIdFromString(...this.sector.voxels.getVoxelData(this.palettes.voxels.getValue(value)));
         }
-        return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
+        return VoxelLUT.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
     }
     getLight(index) {
         let finalLight = 0;
@@ -153,16 +153,16 @@ export class ImportedSection {
         return value;
     }
     getSecondary(index) {
-        const trueVoxelId = VoxelPalettesRegister.voxels[this.getId(index)][0];
+        const trueVoxelId = VoxelLUT.voxels[this.getId(index)][0];
         const value = this.buffers.secondary.getValue(index);
         if (VoxelTagsRegister.VoxelTags[trueVoxelId]["dve_can_have_secondary"]) {
             if (this.buffers.ids.isValue) {
-                return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
+                return VoxelLUT.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
             }
             if (this.palettes.secondaryVoxels) {
-                return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(this.palettes.secondaryVoxels.getValue(value)));
+                return VoxelLUT.getVoxelIdFromString(...this.sector.voxels.getVoxelData(this.palettes.secondaryVoxels.getValue(value)));
             }
-            return VoxelPalettesRegister.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
+            return VoxelLUT.getVoxelIdFromString(...this.sector.voxels.getVoxelData(value));
         }
         return value;
     }