@divinevoxel/vlox 0.0.4 → 0.0.6

package/{Data → Voxels}/Cursor/VoxelCursor.js

@@ -1,5 +1,5 @@
-import { VoxelCursorInterface } from "./Interfaces/VoxelCursor.interface";
-import { VoxelPalette } from "../Palettes/VoxelPalette";
+import { VoxelCursorInterface } from "./VoxelCursor.interface";
+import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette";
 import { VoxelStateReader } from "../../Voxels/VoxelStateReader";
 export class VoxelCursor extends VoxelCursorInterface {
     static VoxelDataToRaw(data, light = 0) {
@@ -7,17 +7,16 @@ export class VoxelCursor extends VoxelCursorInterface {
         const secondaryId = (data.secondaryVoxelId !== undefined &&
             VoxelPalette.ids.getNumberId(data.secondaryVoxelId)) ||
             0;
-        let stateData = 0;
+        let levleData = 0;
         if (data.level !== undefined)
-            stateData = VoxelStateReader.setLevel(stateData, data.level);
+            levleData = VoxelStateReader.setLevel(levleData, data.level);
         if (data.levelState !== undefined)
-            stateData = VoxelStateReader.setLevelState(stateData, data.levelState);
-        if (data.shapeState !== undefined)
-            stateData = VoxelStateReader.setShapeState(stateData, data.shapeState);
-        return [id, light, stateData, secondaryId, data.mod || 0];
+            levleData = VoxelStateReader.setLevelState(levleData, data.levelState);
+        return [id, light, levleData, data.state || 0, data.mod || 0, secondaryId];
     }
     ids = [0];
     light = [0];
+    level = [0];
     state = [0];
     secondary = [0];
     mod = [0];

package/Voxels/Cursor/VoxelLightData.d.ts

@@ -0,0 +1,45 @@
+type AllLight = [s: number, r: number, g: number, b: number];
+/**# Light Data
+ * ---
+ * Used to decode light color info.
+ */
+export declare class VoxelLightData {
+    _lightValues: AllLight;
+    sumRGB(value: number): number;
+    getS(value: number): number;
+    getR(value: number): number;
+    getG(value: number): number;
+    getB(value: number): number;
+    setS(value: number, sl: number): number;
+    setR(value: number, sl: number): number;
+    setG(value: number, sl: number): number;
+    setB(value: number, sl: number): number;
+    removeS(sl: number): number;
+    hasRGBLight(sl: number): boolean;
+    hasSunLight(sl: number): boolean;
+    mixLight(l1: number, l2: number): number;
+    getRGB(sl: number): number;
+    setRGB(value: number, sl: number): number;
+    decodeLightFromVoxelData(voxelData: number): number;
+    encodeLightIntoVoxelData(voxelData: number, encodedLight: number): number;
+    /**# Set Light Values
+     * ---
+     * Give an array of light values it will return an encoded light number.
+     * @param values
+     */
+    setLightValues(values: ArrayLike<number>): number;
+    /**# Get Light Values
+     * ---
+     * Given an encoded light number it will return an array of its values.
+     * - 0: Sun Light
+     * - 1: Red Light
+     * - 2: Green Light
+     * - 3: Blue Light
+     * @param value
+     */
+    getLightValues(value: number): AllLight;
+    getLightValuesToRef(value: number, values: AllLight): AllLight;
+    addLightValues(sl: number, sl2: number): number;
+    divideLightValue(sl: number, divisor: number): number;
+}
+export {};

package/Voxels/Cursor/VoxelLightData.js

@@ -0,0 +1,146 @@
+/**# Light Data
+ * ---
+ * Used to decode light color info.
+ */
+export class VoxelLightData {
+    _lightValues = new Uint16Array([0, 0, 0, 0]);
+    sumRGB(value) {
+        return this.getR(value) + this.getG(value) + this.getB(value);
+    }
+    getS(value) {
+        return value & 0xf;
+    }
+    getR(value) {
+        return (value & (0xf << 4)) >> 4;
+    }
+    getG(value) {
+        return (value & (0xf << 8)) >> 8;
+    }
+    getB(value) {
+        return (value & (0xf << 12)) >> 12;
+    }
+    setS(value, sl) {
+        return (sl & ~0xf) | value;
+    }
+    setR(value, sl) {
+        return (sl & ~(0xf << 4)) | (value << 4);
+    }
+    setG(value, sl) {
+        return (sl & ~(0xf << 8)) | (value << 8);
+    }
+    setB(value, sl) {
+        return (sl & ~(0xf << 12)) | (value << 12);
+    }
+    removeS(sl) {
+        return this.setS(0, sl);
+    }
+    hasRGBLight(sl) {
+        if (sl <= 0)
+            return false;
+        if (this.getR(sl) > 0)
+            return true;
+        if (this.getG(sl) > 0)
+            return true;
+        if (this.getB(sl) > 0)
+            return true;
+        return false;
+    }
+    hasSunLight(sl) {
+        if (sl <= 0)
+            return false;
+        if (this.getS(sl) > 0)
+            return true;
+        return false;
+    }
+    mixLight(l1, l2) {
+        const s1 = this.getS(l1);
+        const s2 = this.getS(l2);
+        const s = s1 < s2 ? s2 : s1;
+        const r1 = this.getR(l1);
+        const r2 = this.getR(l2);
+        const r = r1 < r2 ? r2 : r1;
+        const g1 = this.getG(l1);
+        const g2 = this.getG(l2);
+        const g = g1 < g2 ? g2 : g1;
+        const b1 = this.getB(l1);
+        const b2 = this.getB(l2);
+        const b = b1 < b2 ? b2 : b1;
+        let nl = this.setS(s, 0);
+        nl = this.setR(r, nl);
+        nl = this.setG(g, nl);
+        nl = this.setB(b, nl);
+        return nl;
+    }
+    getRGB(sl) {
+        if (sl < 0)
+            return 0;
+        return (sl & 0xfff0) >> 4;
+    }
+    setRGB(value, sl) {
+        if (sl < 0)
+            return 0;
+        return (sl & ~0xfff0) | (value << 4);
+    }
+    decodeLightFromVoxelData(voxelData) {
+        return (voxelData & (0xffff << 0)) >> 0;
+    }
+    encodeLightIntoVoxelData(voxelData, encodedLight) {
+        return (voxelData & ~(0xffff << 0)) | (encodedLight << 0);
+    }
+    /**# Set Light Values
+     * ---
+     * Give an array of light values it will return an encoded light number.
+     * @param values
+     */
+    setLightValues(values) {
+        let value = this.setS(values[0], 0);
+        value = this.setR(values[1], value);
+        value = this.setG(values[2], value);
+        return this.setB(values[3], value);
+    }
+    /**# Get Light Values
+     * ---
+     * Given an encoded light number it will return an array of its values.
+     * - 0: Sun Light
+     * - 1: Red Light
+     * - 2: Green Light
+     * - 3: Blue Light
+     * @param value
+     */
+    getLightValues(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) {
+        values[0] = this.getS(value);
+        values[1] = this.getR(value);
+        values[2] = this.getG(value);
+        values[3] = this.getB(value);
+        return values;
+    }
+    addLightValues(sl, sl2) {
+        this._lightValues[0] = this.getS(sl) + this.getS(sl2);
+        this._lightValues[1] = this.getR(sl) + this.getR(sl2);
+        this._lightValues[2] = this.getG(sl) + this.getG(sl2);
+        this._lightValues[3] = this.getB(sl) + this.getB(sl2);
+        if (this._lightValues[0] > 15)
+            this._lightValues[0] = 15;
+        if (this._lightValues[1] > 15)
+            this._lightValues[1] = 15;
+        if (this._lightValues[2] > 15)
+            this._lightValues[2] = 15;
+        if (this._lightValues[3] > 15)
+            this._lightValues[3] = 15;
+        return this.setLightValues(this._lightValues);
+    }
+    divideLightValue(sl, divisor) {
+        this._lightValues[0] = Math.ceil(this.getS(sl) / divisor);
+        this._lightValues[1] = Math.ceil(this.getR(sl) / divisor);
+        this._lightValues[2] = Math.ceil(this.getG(sl) / divisor);
+        this._lightValues[3] = Math.ceil(this.getB(sl) / divisor);
+        return this.setLightValues(this._lightValues);
+    }
+}

package/Voxels/Effects/VoxelEffect.d.ts

@@ -1,11 +1,11 @@
-import { ChunkMesh } from "../../Renderer/Classes/ChunkMesh";
+import { SectionMesh } from "../../Renderer/Classes/SectionMesh";
 export interface VoxelEffectConstructor {
     id: string;
-    new (mesh: ChunkMesh): VoxelEffect;
+    new (mesh: SectionMesh): VoxelEffect;
 }
 export declare abstract class VoxelEffect {
-    mesh: ChunkMesh;
-    constructor(mesh: ChunkMesh);
+    mesh: SectionMesh;
+    constructor(mesh: SectionMesh);
     abstract init(): void;
     abstract setPoints(pointss: Float32Array): void;
     abstract dispose(): void;

package/Voxels/Functions/BuildStateData.js

@@ -2,7 +2,7 @@ import { StateCompareOperationsMap, StateLogicOperationsMap, } from "../State/St
 import { StringPalette } from "../../Util/StringPalette";
 import { VoxelModelManager } from "../../Models/Rules/VoxelModelManager";
 import { VoxelTagStates } from "../State/VoxelTagStates";
-import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { VoxelPalette } from "../Palettes/VoxelPalette";
 import { StateSchema } from "../State/Schema/StateSchema";
 function bitsNeeded(n) {
     if (n < 0)

package/Voxels/Indexes/VoxelIndex.d.ts

@@ -1,5 +1,5 @@
-import { PaintVoxelData } from "../../Data/Types/WorldData.types";
-import { VoxelData, RawVoxelData, VoxelNamedStateData } from "../Voxel.types";
+import { PaintVoxelData } from "../Types/Voxel.types";
+import { VoxelData, RawVoxelData, VoxelNamedStateData } from "../Types/Voxel.types";
 export declare class VoxelNamedState {
     voxelId: string;
     data: VoxelNamedStateData;

package/Voxels/Indexes/VoxelIndex.js

@@ -1,6 +1,6 @@
-import { PaintVoxelData } from "../../Data/Types/WorldData.types";
+import { PaintVoxelData } from "../Types/Voxel.types";
 import { SchemaRegister } from "../State/SchemaRegister";
-import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { VoxelPalette } from "../Palettes/VoxelPalette";
 export class VoxelNamedState {
     voxelId;
     data;
@@ -23,13 +23,13 @@ export class VoxelNamedState {
                 this.compiled.shapeStateAny = true;
             }
             else if (this.data.state) {
-                this.compiled.shapeState = schema.shapeState.readString(this.data.state);
+                this.compiled.shapeState = schema.state.readString(this.data.state);
             }
             if (this.data.mod == "*") {
                 this.compiled.modAny = true;
             }
             else if (this.data.mod) {
-                this.compiled.mod = schema.modState.readString(this.data.mod);
+                this.compiled.mod = schema.mod.readString(this.data.mod);
             }
         }
         else {
@@ -43,7 +43,7 @@ export class VoxelNamedState {
             id: this.voxelId,
             level: 0,
             levelState: 0,
-            shapeState: this.compiled.shapeState,
+            state: this.compiled.shapeState,
             mod: this.compiled.mod,
         });
     }
@@ -108,7 +108,7 @@ export class VoxelIndex {
         const conatiner = this.states.get(data.id);
         if (!conatiner)
             return false;
-        const { mod, shapeState } = data;
+        const { mod, state: shapeState } = data;
         for (const state of conatiner?.stateArray) {
             if ((mod == state.compiled.mod || state.compiled.modAny) &&
                 (shapeState == state.compiled.shapeState ||

package/Voxels/InitVoxelData.d.ts

@@ -1,9 +1,13 @@
 import { VoxelGeometryData, VoxelModelData } from "../Models/VoxelModel.types";
-import { VoxelData } from "./Voxel.types";
-import { ConstructorVoxelModelSyncData } from "./VoxelSyncData";
+import { VoxelData } from "./Types/Voxel.types";
+import { CompiledVoxelData } from "./Types/VoxelModelCompiledData.types";
+import { VoxelMaterialData } from "./Types/VoxelMaterial.types";
+import { VoxelSubstanceData } from "./Types/VoxelSubstances.types";
 export type InitVoxelDataProps = {
     geometry?: VoxelGeometryData[];
     models?: VoxelModelData[];
     voxels: VoxelData[];
+    materials?: VoxelMaterialData[];
+    substances?: VoxelSubstanceData[];
 };
-export declare function InitVoxelData(data: InitVoxelDataProps): ConstructorVoxelModelSyncData;
+export declare function InitVoxelData(data: InitVoxelDataProps): CompiledVoxelData;

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];