@divinevoxel/vlox 0.0.1 → 0.0.3

package/Archive/Functions/ArchiveColumn.js

@@ -1,9 +1,9 @@
-import { StringPalette } from "../../Interfaces/Data/StringPalette";
-import { NumberPalette } from "../../Interfaces/Data/NumberPalette";
+import { StringPalette } from "../../Util/StringPalette";
+import { NumberPalette } from "../../Util/NumberPalette";
 import { WorldRegister } from "../../Data/World/WorldRegister";
-import { VoxelPalette } from "../../Data/Voxel/VoxelPalette";
-import { VoxelStruct } from "../../Data/Voxel/VoxelStruct";
-import { VoxelTagIDs } from "../../Data/Constants/VoxelTagIds";
+import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { VoxelStruct } from "../../Data/Structs/VoxelStruct";
+import { VoxelStructIds } from "../../Voxels/Voxel.types";
 import { Chunk, Column } from "../../Data/World/Classes";
 import { convertToPaletteBuffer } from "./Palettes";
 const getArchiveChunkState = (chunk) => {
@@ -77,25 +77,25 @@ export default function ArchiveColumn(archiveData) {
             const voxelState = !statePalette.isRegistered(chunk.state[i])
                 ? statePalette.register(chunk.state[i])
                 : statePalette.getId(chunk.state[i]);
-            if (!archivedChunk.statePalette.isRegistered(voxelState))
-                archivedChunk.statePalette.register(voxelState);
+            if (!archivedChunk.statePalette.isRegistered(chunk.state[i]))
+                archivedChunk.statePalette.register(chunk.state[i]);
             if (firstState == -1)
                 firstState = voxelState;
             const voxelMod = !modPalette.isRegistered(chunk.mod[i])
                 ? modPalette.register(chunk.mod[i])
                 : modPalette.getId(chunk.mod[i]);
-            if (!archivedChunk.modPalette.isRegistered(voxelMod))
-                archivedChunk.modPalette.register(voxelMod);
+            if (!archivedChunk.modPalette.isRegistered(chunk.mod[i]))
+                archivedChunk.modPalette.register(chunk.mod[i]);
             if (firstMod == -1)
                 firstMod = voxelMod;
             const voxelLight = !lightPalette.isRegistered(chunk.light[i])
                 ? lightPalette.register(chunk.light[i])
                 : lightPalette.getId(chunk.light[i]);
-            if (!archivedChunk.lightPalette.isRegistered(voxelLight))
-                archivedChunk.lightPalette.register(voxelLight);
+            if (!archivedChunk.lightPalette.isRegistered(chunk.light[i]))
+                archivedChunk.lightPalette.register(chunk.light[i]);
             if (firstLight == -1)
                 firstLight = voxelLight;
-            const secondaryId = VoxelStruct.instance[VoxelTagIDs.canHaveSecondary] == 1 &&
+            const secondaryId = VoxelStruct.instance[VoxelStructIds.canHaveSecondary] == 1 &&
                 VoxelPalette.ids.getStringId(chunk.secondary[i]);
             const voxelSecondary = secondaryId
                 ? !secondaryPalette.isRegistered(secondaryId)
@@ -170,14 +170,14 @@ export default function ArchiveColumn(archiveData) {
             if (reMapIds)
                 chunk.ids[i] = chunk.idPalette.getId(chunk.ids[i]);
             if (reMapState)
-                chunk.state[i] = chunk.statePalette.getId(chunk.state[i]);
+                chunk.state[i] = chunk.statePalette.getId(chunk.chunk.state[i]);
             if (reMapMod)
-                chunk.mod[i] = chunk.modPalette.getId(chunk.mod[i]);
+                chunk.mod[i] = chunk.modPalette.getId(chunk.chunk.mod[i]);
             if (reMapLight)
-                chunk.light[i] = chunk.lightPalette.getId(chunk.light[i]);
+                chunk.light[i] = chunk.lightPalette.getId(chunk.chunk.light[i]);
             if (reMapSecondary)
                 chunk.secondary[i] =
-                    VoxelStruct.instance[VoxelTagIDs.canHaveSecondary] == 1
+                    VoxelStruct.instance[VoxelStructIds.canHaveSecondary] == 1
                         ? chunk.secondaryPalette.getId(chunk.secondary[i])
                         : chunk.secondaryStatePalette.getId(chunk.secondary[i]);
         }
@@ -220,7 +220,7 @@ export default function ArchiveColumn(archiveData) {
                 : {}),
         },
         chunks: states.map((archiveChunk) => {
-            chunkStructInstance.setBuffer(archiveChunk.chunk.stateBuffer);
+            chunkStructInstance.setBuffer(archiveChunk.chunk.buffer);
             const serializeChunkState = chunkStructInstance.serialize();
             return {
                 palettes: {

package/Archive/Functions/ImportColumn.js

@@ -1,9 +1,9 @@
-import { VoxelPalette } from "../../Data/Voxel/VoxelPalette";
-import { Chunk, Column, } from "../../Data/World/Classes";
-import { VoxelStruct } from "../../Data/Voxel/VoxelStruct";
-import { VoxelTagIDs } from "../../Data/Constants/VoxelTagIds";
-import { NumberPalette } from "../../Interfaces/Data/NumberPalette";
-import { StringPalette } from "../../Interfaces/Data/StringPalette";
+import { VoxelPalette } from "../../Data/Palettes/VoxelPalette";
+import { Chunk, Column } from "../../Data/World/Classes";
+import { VoxelStruct } from "../../Data/Structs/VoxelStruct";
+import { VoxelStructIds } from "../../Voxels/Voxel.types";
+import { NumberPalette } from "../../Util/NumberPalette";
+import { StringPalette } from "../../Util/StringPalette";
 import { getPaletteArray } from "./Palettes";
 let columnStructInstance;
 let chunkStructInstance;
@@ -100,8 +100,8 @@ const getLight = (value, importedColumn, importedChunk) => {
     if (typeof importedChunk.chunk.buffers.light == "number") {
         return value;
     }
-    if (importedChunk.lightPalette && importedColumn.lightPalette) {
-        return importedColumn.lightPalette.getValue(importedChunk.lightPalette.getValue(value));
+    if (importedChunk.lightPalette) {
+        return importedChunk.lightPalette.getValue(value);
     }
     if (importedColumn.lightPalette) {
         return importedColumn.lightPalette.getValue(value);
@@ -114,8 +114,8 @@ const getState = (value, importedColumn, importedChunk) => {
     if (typeof importedChunk.chunk.buffers.state == "number") {
         return value;
     }
-    if (importedChunk.statePalette && importedColumn.statePalette) {
-        return importedColumn.statePalette.getValue(importedChunk.statePalette.getValue(value));
+    if (importedChunk.statePalette) {
+        return importedChunk.statePalette.getValue(value);
     }
     if (importedColumn.statePalette) {
         return importedColumn.statePalette.getValue(value);
@@ -128,8 +128,8 @@ const getMod = (value, importedColumn, importedChunk) => {
     if (typeof importedChunk.chunk.buffers.mod == "number") {
         return value;
     }
-    if (importedChunk.modPalette && importedColumn.modPalette) {
-        return importedColumn.modPalette.getValue(importedChunk.modPalette.getValue(value));
+    if (importedChunk.modPalette) {
+        return importedChunk.modPalette.getValue(value);
     }
     if (importedColumn.modPalette) {
         return importedColumn.modPalette.getValue(value);
@@ -140,7 +140,7 @@ const getSecondary = (voxelId, value, importedColumn, importedChunk) => {
     if (importedChunk.chunk.buffers.state instanceof Uint16Array)
         return value;
     VoxelStruct.setVoxel(voxelId);
-    if (VoxelStruct.instance[VoxelTagIDs.canHaveSecondary] == 1) {
+    if (VoxelStruct.instance[VoxelStructIds.canHaveSecondary] == 1) {
         if (typeof importedChunk.chunk.buffers.secondary == "number") {
             return VoxelPalette.ids.getNumberId(importedColumn.column.palettes.secondaryId[importedChunk.chunk.buffers.secondary]);
         }
@@ -184,7 +184,7 @@ export default function ImportColumn(column, archiveData) {
         }
         updateChunkBuffers(column, chunk);
         if (!archiveData.loadChunkState) {
-            chunkStructInstance.setBuffer(newChunk.stateBuffer);
+            chunkStructInstance.setBuffer(newChunk.buffer);
             chunkStructInstance.deserialize(chunkState);
         }
         else {

package/Archive/Functions/Palettes.d.ts

@@ -1,5 +1,5 @@
 import { BitArray } from "@amodx/binary/Arrays/BitArray";
 import { HalfNibbleArray } from "@amodx/binary/Arrays/HalfNibbleArray";
 import { NibbleArray } from "@amodx/binary/Arrays/NibbleArray";
-export declare const convertToPaletteBuffer: (paletteSize: number, data: Uint16Array, sharedMemory?: boolean) => Uint16Array | Uint8Array;
+export declare const convertToPaletteBuffer: (paletteSize: number, data: any, sharedMemory?: boolean) => Uint16Array | Uint8Array;
 export declare const getPaletteArray: (size: number, buffer: ArrayBufferLike) => ArrayBuffer | NibbleArray | HalfNibbleArray | BitArray;

package/Cache/Cache.types.d.ts

@@ -0,0 +1,17 @@
+import { CompactMeshData } from "../Mesher/Types/Mesher.types";
+import { TextureData } from "../Textures/Texture.types";
+import { ConstructorVoxelModelSyncData } from "../Voxels/VoxelSyncData";
+export interface CachedVoxelModelData extends ConstructorVoxelModelSyncData {
+}
+export interface CachedDisplayIndex {
+    textures: Record<string, Record<string, string>>;
+    meshes: Record<string, Record<string, {
+        model: CompactMeshData;
+        material: string;
+    }>>;
+}
+export interface CacheData {
+    models: CachedVoxelModelData;
+    textures: TextureData[];
+    displayIndex: CachedDisplayIndex;
+}

package/Cache/CacheManager.d.ts

@@ -0,0 +1,11 @@
+import { TextureData } from "Textures/Texture.types";
+import { CacheData, CachedDisplayIndex, CachedVoxelModelData } from "./Cache.types";
+export declare class CacheManager {
+    static cacheStoreEnabled: boolean;
+    static cacheLoadEnabled: boolean;
+    static cachedData: CacheData | null;
+    static cachedModelData: CachedVoxelModelData | null;
+    static cachedTextureData: TextureData[] | null;
+    static cachedDisplayData: CachedDisplayIndex | null;
+    static getCachedData(): CacheData;
+}

package/Cache/CacheManager.js

@@ -0,0 +1,17 @@
+export class CacheManager {
+    static cacheStoreEnabled = false;
+    static cacheLoadEnabled = false;
+    static cachedData = null;
+    static cachedModelData = null;
+    static cachedTextureData = null;
+    static cachedDisplayData = null;
+    static getCachedData() {
+        if (!this.cacheStoreEnabled)
+            throw new Error(`cacheStoreEnabled must be set to true`);
+        return {
+            models: this.cachedModelData,
+            textures: this.cachedTextureData,
+            displayIndex: this.cachedDisplayData,
+        };
+    }
+}

package/{Data → Contexts/Base}/DataHooks.d.ts

@@ -1,15 +1,15 @@
 import { Observable } from "@amodx/core/Observers/index.js";
-import { AsyncPipeline, Pipeline } from "@amodx/core/Pipelines/";
-import type { LocationData } from "../Math/index.js";
-import { DimensionData } from "./Types/DimensionData.types";
-import { EngineSettingsData } from "../Types/EngineSettings.types";
-import { ChunkData, ColumnData, RegionData } from "./World/Classes/index.js";
+import { Pipeline } from "@amodx/core/Pipelines/";
+import type { LocationData } from "../../Math/index.js";
+import { DimensionData } from "../../Data/Types/DimensionData.types.js";
+import { EngineSettingsData } from "../../Settings/EngineSettings.types.js";
+import { ChunkData, ColumnData, RegionData } from "../../Data/World/Classes/index.js";
 export declare const DataHooks: {
     dimension: {
         onRegisterDimension: Pipeline<DimensionData>;
     };
     chunk: {
-        onGetAsync: AsyncPipeline<{
+        onGetAsync: Pipeline<{
             location: LocationData;
             chunk: ChunkData | null;
         }>;
@@ -21,7 +21,7 @@ export declare const DataHooks: {
         onRemove: Observable<LocationData>;
     };
     column: {
-        onGetAsync: AsyncPipeline<{
+        onGetAsync: Pipeline<{
             location: LocationData;
             column: ColumnData | null;
         }>;
@@ -33,7 +33,7 @@ export declare const DataHooks: {
         onRemove: Observable<LocationData>;
     };
     region: {
-        onGetAsync: AsyncPipeline<{
+        onGetAsync: Pipeline<{
             location: LocationData;
             region: RegionData | null;
         }>;

package/{Data → Contexts/Base}/DataHooks.js

@@ -1,23 +1,23 @@
 import { Observable } from "@amodx/core/Observers/index.js";
-import { AsyncPipeline, Pipeline } from "@amodx/core/Pipelines/";
+import { Pipeline } from "@amodx/core/Pipelines/";
 export const DataHooks = {
     dimension: {
         onRegisterDimension: new Pipeline(),
     },
     chunk: {
-        onGetAsync: new AsyncPipeline(),
+        onGetAsync: new Pipeline(),
         onGetSync: new Pipeline(),
         onNew: new Observable(),
         onRemove: new Observable(),
     },
     column: {
-        onGetAsync: new AsyncPipeline(),
+        onGetAsync: new Pipeline(),
         onGetSync: new Pipeline(),
         onNew: new Observable(),
         onRemove: new Observable(),
     },
     region: {
-        onGetAsync: new AsyncPipeline(),
+        onGetAsync: new Pipeline(),
         onGetSync: new Pipeline(),
         onNew: new Observable(),
         onRemove: new Observable(),

package/Contexts/Base/Main/Generator/DataGenerator.types.d.ts

@@ -0,0 +1,12 @@
+import { DataSyncData } from "../../Remote/Sync/DataSync.types";
+import { VoxelSubstanceData } from "../../../../Voxels/VoxelSubstances.types";
+import { VoxelData } from "../../../../Voxels/Voxel.types";
+import { CachedVoxelModelData } from "../../../../Cache/Cache.types";
+import { VoxelMaterialData } from "Voxels";
+export type DataGeneratorData = {
+    voxels: VoxelData[];
+    materials?: VoxelMaterialData[];
+    substances?: VoxelSubstanceData[];
+    threads: DataSyncData["threads"];
+    voxelModels?: CachedVoxelModelData;
+};

package/Contexts/Base/Main/Generator/InitDataGenerator.d.ts

@@ -0,0 +1,3 @@
+import { DataSyncData } from "../../Remote/Sync/DataSync.types";
+import { DataGeneratorData } from "./DataGenerator.types";
+export default function InitDataGenerator(data: DataGeneratorData): DataSyncData;

package/Contexts/Base/Main/Generator/InitDataGenerator.js

@@ -0,0 +1,201 @@
+import { VoxelDataGenerator } from "./Segments/VoxelDataGenerator";
+import { SubstanceDataGenerator } from "./Segments/SubstanceDataGenerator";
+import { VoxelStructBuilder } from "../../../../Data/Structs/Builder/VoxelStructBuilder";
+import { SubstanceStructBuilder } from "../../../../Data/Structs/Builder/SubstanceStructBuilder";
+import { VoxelStruct } from "../../../../Data/Structs/VoxelStruct";
+import { SubstanceStruct } from "../../../../Data/Structs/SubstanceStruct";
+import { LightData } from "../../../../Voxels/LightData";
+import { InitalizeChunkTags } from "../../../../Data/Structs/ChunkStruct.js";
+import { InitalizeColumnTags } from "../../../../Data/Structs/ColumnStruct.js";
+import { InitalizeRegionTags } from "../../../../Data/Structs/RegionStruct.js";
+import { EngineSettings } from "../../../../Settings/EngineSettings";
+import { VoxelStructIds } from "../../../../Voxels/Voxel.types";
+import { WorldRegister } from "../../../../Data/World/WorldRegister";
+import { MappedDataRegister } from "../../../../Data/Register/MappedDataRegister";
+import { MaterialPalette } from "../../../../Data/Palettes/MaterialPalette";
+import { MaterialDataGenerator } from "./Segments/MaterialDataGenerator";
+import { Chunk, Column, Region } from "../../../../Data/World/Classes";
+export default function InitDataGenerator(data) {
+    const register = new WorldRegister();
+    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",
+            },
+        },
+        {
+            id: "dve_barrier",
+            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);
+    InitalizeChunkTags();
+    InitalizeColumnTags();
+    InitalizeRegionTags();
+    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 {
+        settings: EngineSettings.settings,
+        threads: data.threads,
+        modelData: data.voxelModels,
+        materials: {
+            palette: MaterialPalette.palette._palette,
+        },
+        worldData: {
+            chunkStruct: Chunk.StateStruct.structData,
+            columnStruct: Column.StateStruct.structData,
+            regionStruct: Region.StateStruct.structData,
+        },
+        voxel: {
+            palette: VoxelDataGenerator.palette._palette,
+            nameToIdMap: VoxelDataGenerator.nameToIdMap,
+            idToNameMap: VoxelDataGenerator.idToNameMap,
+            ...voxelMaps,
+            struct: VoxelStruct.initData,
+            index: VoxelStruct.voxelIndex,
+        },
+        substance: {
+            palette: SubstanceDataGenerator.palette._palette,
+            ...substanceMaps,
+            struct: SubstanceStruct.initData,
+        },
+    };
+}

package/Contexts/Base/Main/Generator/Segments/MaterialDataGenerator.d.ts

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

package/Contexts/Base/Main/Generator/Segments/MaterialDataGenerator.js

@@ -0,0 +1,12 @@
+import { MaterialPalette } from "../../../../../Data/Palettes/MaterialPalette";
+import { StringPalette } from "../../../../../Util/StringPalette";
+export const MaterialDataGenerator = {
+    generate(data) {
+        //build palette
+        for (const substance of data) {
+            this.palette.register(substance.id);
+        }
+        MaterialPalette.setPalette(this.palette._palette);
+    },
+    palette: new StringPalette(),
+};

package/Contexts/Base/Main/Generator/Segments/SubstanceDataGenerator.d.ts

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

package/Contexts/Base/Main/Generator/Segments/SubstanceDataGenerator.js

@@ -0,0 +1,35 @@
+import { SubstanceStructBuilder } from "../../../../../Data/Structs/Builder/SubstanceStructBuilder";
+import { SubstanceStruct } from "../../../../../Data/Structs/SubstanceStruct";
+import { SubstancePalette } from "../../../../../Data/Palettes/SubstancePalette";
+import { StringPalette } from "../../../../../Util/StringPalette";
+export const SubstanceDataGenerator = {
+    generate(data) {
+        //build palette
+        for (const substance of data) {
+            this.palette.register(substance.id);
+        }
+        SubstancePalette.setPalette(this.palette._palette);
+        //create data buffer
+        const tags = SubstanceStructBuilder.build(this.palette.size);
+        const buffer = new SharedArrayBuffer(tags.structData.bufferSize);
+        tags.structData.buffer = buffer;
+        tags.setBuffer(buffer);
+        //build data
+        for (const substance of data) {
+            const substanceID = SubstancePalette.id.numberFromString(substance.id);
+            if (typeof substanceID == undefined)
+                continue;
+            tags.setStructArrayIndex(substanceID);
+            SubstanceStructBuilder.setDefaults(tags);
+            for (const id in substance.properties) {
+                const value = substance.properties[id];
+                if (!SubstanceStructBuilder.hasNode(id))
+                    continue;
+                SubstanceStructBuilder.setNode(id, value, tags);
+            }
+        }
+        SubstanceStruct.init(tags.structData);
+        SubstanceStruct.instance.setBuffer(buffer);
+    },
+    palette: new StringPalette(),
+};

package/Contexts/{World/Data/Generators → Base/Main/Generator/Segments}/VoxelDataGenerator.d.ts

@@ -1,9 +1,10 @@
 import { BinaryStruct } from "@amodx/binary";
-import { StringPalette } from "../../../../Interfaces/Data/StringPalette.js";
+import { StringPalette } from "../../../../../Util/StringPalette";
+import { VoxelData } from "../../../../../Voxels/Voxel.types";
 export declare class VoxelDataGenerator {
     static overrides: Map<string, (tags: BinaryStruct, value: unknown, id: string) => void>;
     static nameToIdMap: Record<string, string>;
     static idToNameMap: Record<string, string>;
-    static generate(): void;
+    static generate(data: VoxelData[]): void;
     static palette: StringPalette;
 }

package/Contexts/{World/Data/Generators → Base/Main/Generator/Segments}/VoxelDataGenerator.js

@@ -1,27 +1,23 @@
-//types
-import { VoxelTagIDs } from "../../../../Data/Constants/VoxelTagIds.js";
 //objects
-import { VoxelTagBuilder } from "../StructBuilders/VoxelStructBuilder.js";
-import { VoxelPalette } from "../../../../Data/Voxel/VoxelPalette.js";
-import { VoxelStruct } from "../../../../Data/Voxel/VoxelStruct.js";
-import { VoxelManager } from "../Managers/DataManagers.js";
-import { SubstanceDataGenerator } from "./SubstanceDataGenerator.js";
-import { StringPalette } from "../../../../Interfaces/Data/StringPalette.js";
+import { VoxelStructBuilder } from "../../../../../Data/Structs/Builder/VoxelStructBuilder";
+import { VoxelPalette } from "../../../../../Data/Palettes/VoxelPalette";
+import { VoxelStruct } from "../../../../../Data/Structs/VoxelStruct";
+import { StringPalette } from "../../../../../Util/StringPalette";
 export class VoxelDataGenerator {
     static overrides = new Map();
     static nameToIdMap = {};
     static idToNameMap = {};
-    static generate() {
+    static generate(data) {
         //build palette
-        for (const [key, voxel] of VoxelManager.data) {
+        for (const voxel of data) {
             if (this.palette.isRegistered(voxel.id))
                 throw new Error(`Duplicate voxel id ${voxel.id}`);
             this.palette.register(voxel.id);
             this.nameToIdMap[voxel.name ? voxel.name : voxel.id] = voxel.id;
             this.idToNameMap[voxel.id] = voxel.name ? voxel.name : voxel.id;
         }
-        VoxelPalette.setVoxelIdPalette(this.palette._palette, this.palette._map);
-        VoxelPalette.setVoxelNamePalette(this.nameToIdMap, this.idToNameMap);
+        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);
         const voxelIndex = new Uint16Array(indexBuffer);
@@ -29,28 +25,28 @@ export class VoxelDataGenerator {
             voxelIndex[i] = i;
         }
         //create data bufferv
-        const tags = VoxelTagBuilder.build(this.palette.size);
+        const tags = VoxelStructBuilder.build(this.palette.size);
         const buffer = new SharedArrayBuffer(tags.structData.bufferSize);
         tags.structData.buffer = buffer;
         tags.setBuffer(buffer);
         //  VoxelStruct.init(initData);
         //  VoxelStruct.setBuffer(buffer);
         //build data
-        for (const [key, voxel] of VoxelManager.data) {
-            const baseID = VoxelPalette.ids.getNumberId(key);
+        for (const voxel of data) {
+            const baseID = VoxelPalette.ids.getNumberId(voxel.id);
             if (!baseID)
                 continue;
             tags.setStructArrayIndex(voxelIndex[baseID]);
-            VoxelTagBuilder.setDefaults(tags);
-            for (const tag of voxel.tags) {
-                const [id, value] = tag;
-                if (!VoxelTagBuilder.hasNode(id))
+            VoxelStructBuilder.setDefaults(tags);
+            for (const id in voxel.properties) {
+                const value = voxel.properties[id];
+                if (!VoxelStructBuilder.hasNode(id))
                     continue;
                 if (this.overrides.has(id)) {
                     this.overrides.get(id)(tags, value, id);
                     continue;
                 }
-                VoxelTagBuilder.setNode(id, value, tags);
+                VoxelStructBuilder.setNode(id, value, tags);
             }
         }
         VoxelStruct.sync(voxelIndex);
@@ -59,6 +55,3 @@ export class VoxelDataGenerator {
     }
     static palette = new StringPalette();
 }
-VoxelDataGenerator.overrides.set(VoxelTagIDs.substance, (tags, value, id) => {
-    tags.setProperty(id, SubstanceDataGenerator.palette._map[value]);
-});