@divinevoxel/vlox 0.0.0

package/Contexts/World/Data/Classes/StructBuilder.js

@@ -0,0 +1,173 @@
+import { BinaryNumberTypes, } from "@amodx/binary/";
+import { BinaryStruct } from "@amodx/binary/";
+import { MappedDataRegister } from "../../../../Data/Register/MappedDataRegister.js";
+import { DivineVoxelEngineWorld } from "../../DivineVoxelEngineWorld.js";
+export class StructBuilder {
+    id;
+    dataSegment;
+    _built = false;
+    _nodeMap = new Map();
+    _stringMaps = new Map();
+    _objectMaps = new Map();
+    _defaults = new Map();
+    _initData;
+    constructor(id, dataSegment) {
+        this.id = id;
+        this.dataSegment = dataSegment;
+    }
+    addNode(node) {
+        if (Array.isArray(node)) {
+            for (const n of node) {
+                this._nodeMap.set(n.id, n);
+            }
+            return;
+        }
+        this._nodeMap.set(node.id, node);
+    }
+    getNode(id) {
+        return this._nodeMap.get(id);
+    }
+    setDefaults(tagManager) {
+        for (const [key, node] of this._nodeMap) {
+            const defaultValue = this._defaults.get(key);
+            if (!defaultValue)
+                continue;
+            tagManager.setProperty(key, Number(defaultValue));
+        }
+    }
+    hasNode(id) {
+        return this._nodeMap.has(id);
+    }
+    setNode(id, value, tagManager) {
+        const node = this.getNode(id);
+        if (!node)
+            return;
+        if (node.type == "number") {
+            tagManager.setProperty(node.id, Number(value));
+        }
+        if (node.type == "boolean") {
+            tagManager.setProperty(node.id, Number(value));
+        }
+        if (node.type == "number-array") {
+            if (!Array.isArray(value))
+                return false;
+            let i = value.length;
+            while (i--) {
+                tagManager.setArrayPropertyValue(node.id, i, value[i]);
+            }
+        }
+        if (node.type == "string-map") {
+            const data = this._stringMaps.get(node.id);
+            if (!data)
+                return false;
+            const v = String(value).trim();
+            if (data.found[v] === undefined) {
+                data.map.push(v);
+                data.found[v] = data.count;
+                data.count++;
+            }
+            tagManager.setProperty(node.id, data.found[v]);
+        }
+        if (node.type == "object-map") {
+            const data = this._objectMaps.get(node.id);
+            if (!data)
+                return false;
+            const v = JSON.stringify(value);
+            if (data.found[v] === undefined) {
+                data.map[data.count] = value;
+                data.found[v] = data.count;
+                data.count++;
+            }
+            tagManager.setProperty(node.id, data.found[v]);
+        }
+    }
+    build(totalTagIndexes = 0) {
+        const tags = new BinaryStruct(this.id);
+        for (const [key, node] of this._nodeMap) {
+            if (node.type == "number") {
+                tags.registerProperty({
+                    id: node.id,
+                    type: "typed-number",
+                    numberType: node.numberType,
+                });
+                this._defaults.set(node.id, node.default);
+                continue;
+            }
+            if (node.type == "number-array") {
+                tags.registerProperty({
+                    id: node.id,
+                    type: "typed-number-array",
+                    numberType: node.numberType,
+                    length: node.length,
+                });
+                continue;
+            }
+            if (node.type == "boolean") {
+                tags.registerProperty({
+                    id: node.id,
+                    type: "boolean",
+                });
+                this._defaults.set(node.id, node.default ? 1 : 0);
+            }
+            if (node.type == "string-map") {
+                tags.registerProperty({
+                    id: node.id,
+                    type: "typed-number",
+                    numberType: BinaryNumberTypes.Uint16,
+                });
+                this._stringMaps.set(node.id, {
+                    count: 0,
+                    found: {},
+                    map: [],
+                    allowedComms: node.allowedComms,
+                });
+            }
+            if (node.type == "object-map") {
+                tags.registerProperty({
+                    id: node.id,
+                    type: "typed-number",
+                    numberType: BinaryNumberTypes.Uint16,
+                });
+                this._objectMaps.set(node.id, {
+                    count: 0,
+                    found: {},
+                    map: [],
+                    allowedComms: node.allowedComms,
+                });
+            }
+        }
+        tags.init({
+            indexBufferMode: "shared",
+            numberOfIndexes: totalTagIndexes,
+        });
+        return tags;
+    }
+    sync() {
+        for (const [key, map] of this._stringMaps) {
+            const data = [this.dataSegment, key, map.map];
+            if (map.allowedComms.includes("world")) {
+                MappedDataRegister.stringMaps.sync(data[0], data[1], data[2]);
+            }
+            DivineVoxelEngineWorld.instance.dataSync.loopThroughComms((comm) => {
+                if (comm.name == "world")
+                    return;
+                if (map.allowedComms.includes(comm.name)) {
+                    DivineVoxelEngineWorld.instance.dataSync.maps.strings.syncInThread(comm.name, data);
+                }
+            });
+        }
+        for (const [key, map] of this._objectMaps) {
+            const data = [this.dataSegment, key, map.map];
+            if (map.allowedComms.includes("world")) {
+                MappedDataRegister.objectMaps.sync(data[0], data[1], data[2]);
+            }
+            DivineVoxelEngineWorld.instance.dataSync.loopThroughComms((comm) => {
+                if (comm.name == "world")
+                    return;
+                if (map.allowedComms.includes(comm.name)) {
+                    DivineVoxelEngineWorld.instance.dataSync.maps.objects.syncInThread(comm.name, data);
+                }
+            });
+        }
+    }
+}

package/Contexts/World/Data/DVEFDataStructs.d.ts

@@ -0,0 +1,7 @@
+import { DataStructBuilders } from "./DataStructBuilders";
+export declare class DVEFDataStructs extends DataStructBuilders {
+    chunkTags: import("@amodx/binary").BinaryStruct;
+    columnTags: import("@amodx/binary").BinaryStruct;
+    regionTags: import("@amodx/binary").BinaryStruct;
+    constructor();
+}

package/Contexts/World/Data/DVEFDataStructs.js

@@ -0,0 +1,21 @@
+import { DataStructBuilders } from "./DataStructBuilders";
+import { ChunkStatStruct } from "./Structs/ChunkStruct";
+import { ColumnStateStruct } from "./Structs/ColumnStruct";
+import { RegionStateStruct } from "./Structs/RegionStruct";
+import { LightData } from "../../../Data/LightData";
+export class DVEFDataStructs extends DataStructBuilders {
+    chunkTags = ChunkStatStruct;
+    columnTags = ColumnStateStruct;
+    regionTags = RegionStateStruct;
+    constructor() {
+        super();
+        this.voxels.overrides.set("#dve_light_value", (tags, value, id) => {
+            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("#dve_light_value", sl);
+        });
+    }
+}

package/Contexts/World/Data/DataRegister.d.ts

@@ -0,0 +1,8 @@
+import { DimensionsRegister } from "../../../Data/World/DimensionsRegister";
+import { WorldRegister } from "../../../Data/World/WorldRegister";
+export declare class DataRegister {
+    voxels: import("./Classes/RegisterDataManager").RegisterDataManager<import("../../../Types").VoxelData>;
+    substances: import("./Classes/RegisterDataManager").RegisterDataManager<import("../../../Types/Substances.types").SubstanceData>;
+    dimensions: DimensionsRegister;
+    world: WorldRegister;
+}

package/Contexts/World/Data/DataRegister.js

@@ -0,0 +1,9 @@
+import { SubstanceManager, VoxelManager } from "./Managers/DataManagers";
+import { DimensionsRegister } from "../../../Data/World/DimensionsRegister";
+import { WorldRegister } from "../../../Data/World/WorldRegister";
+export class DataRegister {
+    voxels = VoxelManager;
+    substances = SubstanceManager;
+    dimensions = new DimensionsRegister();
+    world = new WorldRegister();
+}

package/Contexts/World/Data/DataStructBuilders.d.ts

@@ -0,0 +1,12 @@
+import { VoxelDataGenerator } from "./Generators/VoxelDataGenerator";
+export declare class DataStructBuilders {
+    voxels: typeof VoxelDataGenerator;
+    substances: {
+        $generate(): void;
+        palette: import("../../../Interfaces/Data/StringPalette").StringPalette;
+    };
+    chunkTags: import("@amodx/binary").BinaryStruct;
+    columnTags: import("@amodx/binary").BinaryStruct;
+    regionTags: import("@amodx/binary").BinaryStruct;
+    constructor();
+}

package/Contexts/World/Data/DataStructBuilders.js

@@ -0,0 +1,23 @@
+import { VoxelDataGenerator } from "./Generators/VoxelDataGenerator";
+import { SubstanceDataGenerator } from "./Generators/SubstanceDataGenerator";
+import { ChunkStatStruct } from "./Structs/ChunkStruct";
+import { ColumnStateStruct } from "./Structs/ColumnStruct";
+import { RegionStateStruct } from "./Structs/RegionStruct";
+import { LightData } from "../../../Data/LightData";
+export class DataStructBuilders {
+    voxels = VoxelDataGenerator;
+    substances = SubstanceDataGenerator;
+    chunkTags = ChunkStatStruct;
+    columnTags = ColumnStateStruct;
+    regionTags = RegionStateStruct;
+    constructor() {
+        this.voxels.overrides.set("#dve_light_value", (tags, value, id) => {
+            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("#dve_light_value", sl);
+        });
+    }
+}

package/Contexts/World/Data/DataSync.d.ts

@@ -0,0 +1,51 @@
+import type { Thread, ThreadPool } from "@amodx/threads/";
+import type { PaletteSyncData, RegisterObjectMapSync, RegisterStringMapSync } from "Types/DataSync.types.js";
+import type { BinaryStructData } from "@amodx/binary/";
+import { CommSyncOptions } from "./DataSyncNode.js";
+import { DataSyncNode } from "./DataSyncNode.js";
+import { Pipeline, AsyncPipeline } from "@amodx/core/Pipelines/";
+import type { LocationData } from "../../../Math/index.js";
+import type { WorldDataSync } from "../../../Data/Types/DataSync.types.js";
+import type { DimensionData } from "../../../Data/Types/DimensionData.types.js";
+import { Chunk, Column, Region } from "../../../Data/World/Classes/index.js";
+import { DivineVoxelEngineWorld } from "../index.js";
+export declare class DataSync {
+    static instance: DataSync;
+    static constructorPipeLine: Pipeline<DataSync>;
+    commMap: Map<string, Thread | ThreadPool>;
+    comms: (Thread | ThreadPool)[];
+    commOptions: WeakMap<any, CommSyncOptions>;
+    _ready: boolean;
+    pipelines: {
+        init: AsyncPipeline<DataSync>;
+    };
+    constructor();
+    init(world: DivineVoxelEngineWorld): Promise<void>;
+    isReady(): boolean;
+    registerComm(comm: Thread | ThreadPool, data?: Partial<CommSyncOptions>): void;
+    loopThroughComms(func: (comm: Thread | ThreadPool, options: CommSyncOptions) => void): void;
+    worldDataTags: {
+        chunk: DataSyncNode<void, BinaryStructData, void, false>;
+        column: DataSyncNode<void, BinaryStructData, void, false>;
+        region: DataSyncNode<void, [BinaryStructData, BinaryStructData], void, false>;
+    };
+    worldData: {
+        dimesnion: DataSyncNode<string | number, DimensionData, string | number, boolean>;
+        chunk: DataSyncNode<LocationData, [LocationData, Chunk], LocationData, LocationData>;
+        column: DataSyncNode<LocationData, [LocationData, Column], LocationData, LocationData>;
+        region: DataSyncNode<LocationData, [LocationData, Region], LocationData, LocationData>;
+        regionHeader: DataSyncNode<LocationData, WorldDataSync, LocationData, boolean>;
+    };
+    tags: {
+        voxel: DataSyncNode<void, [BinaryStructData, SharedArrayBuffer], void, false>;
+        substance: DataSyncNode<void, BinaryStructData, void, false>;
+    };
+    palettes: {
+        voxel: DataSyncNode<void, PaletteSyncData, void, false>;
+        substance: DataSyncNode<void, PaletteSyncData, void, false>;
+    };
+    maps: {
+        strings: DataSyncNode<RegisterStringMapSync, RegisterStringMapSync, void, false>;
+        objects: DataSyncNode<RegisterObjectMapSync, RegisterObjectMapSync, void, false>;
+    };
+}

package/Contexts/World/Data/DataSync.js

@@ -0,0 +1,215 @@
+//objects
+import { VoxelStruct } from "../../../Data/Voxel/VoxelStruct.js";
+import { VoxelTagBuilder } from "./StructBuilders/VoxelStructBuilder.js";
+import { SubstanceDataGenerator } from "./Generators/SubstanceDataGenerator.js";
+import { SubstanceStruct } from "../../../Data/Substance/SubstanceStruct.js";
+import { SubstanceTagBuilder } from "./StructBuilders/SubstanceStructBuilder.js";
+import { DataSyncNode } from "./DataSyncNode.js";
+import { VoxelDataGenerator } from "./Generators/VoxelDataGenerator.js";
+import { Pipeline, AsyncPipeline } from "@amodx/core/Pipelines/";
+import { DataSyncIds } from "../../../Interfaces/Common/DataSyncIds.js";
+//objects
+import { WorldRegister } from "../../../Data/World/WorldRegister.js";
+import { ChunkStatStruct } from "./Structs/ChunkStruct.js";
+import { ColumnStateStruct, } from "./Structs/ColumnStruct.js";
+import { RegionStateStruct, RegionHeaderTagManager, } from "./Structs/RegionStruct.js";
+import { RegionHeaderRegister } from "../../../Data/RegionHeaderRegister.js";
+import { DimensionsRegister } from "../../../Data/World/DimensionsRegister.js";
+import { DVEFDataSyncIds } from "../../../Data/Constants/DVEFDataSyncIds.js";
+export class DataSync {
+    static instance;
+    static constructorPipeLine = new Pipeline();
+    commMap = new Map();
+    comms = [];
+    commOptions = new WeakMap();
+    _ready = false;
+    pipelines = {
+        init: new AsyncPipeline(),
+    };
+    constructor() {
+        if (DataSync.instance)
+            return DataSync.instance;
+        DataSync.instance = DataSync.constructorPipeLine.pipe(this);
+        return DataSync.instance;
+    }
+    async init(world) {
+        for (const comm of world.threads.comms) {
+            if (!comm.isReady())
+                continue;
+            this.registerComm(comm);
+        }
+        this.loopThroughComms((comm) => {
+            this.commMap.set(comm.name, comm);
+        });
+        SubstanceDataGenerator.$generate();
+        SubstanceTagBuilder.sync();
+        VoxelDataGenerator.generate();
+        VoxelTagBuilder.sync();
+        this.palettes.voxel.sync();
+        this.palettes.substance.sync();
+        this.tags.voxel.sync();
+        this.tags.substance.sync();
+        await this.pipelines.init.pipe(this);
+        this._ready = true;
+    }
+    isReady() {
+        return this._ready;
+    }
+    registerComm(comm, data = {}) {
+        this.comms.push(comm);
+        this.commOptions.set(comm, {
+            worldData: data.worldData !== undefined ? data.worldData : true,
+            voxelPalette: data.voxelPalette !== undefined ? data.voxelPalette : true,
+            voxelTags: data.voxelTags !== undefined ? data.voxelTags : true,
+            materials: data.materials !== undefined ? data.materials : true,
+            colliders: data.colliders !== undefined ? data.colliders : true,
+            worldDataTags: data.worldDataTags !== undefined ? data.worldDataTags : true,
+        });
+    }
+    loopThroughComms(func) {
+        for (const comm of this.comms) {
+            const options = this.commOptions.get(comm);
+            if (!comm.isReady())
+                continue;
+            func(comm, options);
+        }
+    }
+    worldDataTags = {
+        chunk: new DataSyncNode({
+            dataSyncType: DVEFDataSyncIds.ChunkTags,
+            commCheck: (options) => options.worldDataTags,
+            getSyncData: () => ChunkStatStruct.structData,
+            getUnSyncData: () => false,
+        }, this),
+        column: new DataSyncNode({
+            dataSyncType: DVEFDataSyncIds.ColumnTags,
+            commCheck: (options) => options.worldDataTags,
+            getSyncData: () => ColumnStateStruct.structData,
+            getUnSyncData: () => false,
+        }, this),
+        region: new DataSyncNode({
+            dataSyncType: DVEFDataSyncIds.RegionTags,
+            commCheck: (options) => options.worldDataTags,
+            getSyncData: () => [
+                RegionStateStruct.structData,
+                RegionHeaderTagManager.structData,
+            ],
+            getUnSyncData: () => false,
+        }, this),
+    };
+    worldData = {
+        dimesnion: new DataSyncNode({
+            dataSyncType: DVEFDataSyncIds.Dimesnion,
+            commCheck: (options) => options.worldData,
+            getSyncData: (input) => {
+                const dimensionData = DimensionsRegister.instance.getDimension(input);
+                if (!dimensionData)
+                    return false;
+                return dimensionData;
+            },
+            getUnSyncData: () => true,
+        }, this),
+        chunk: new DataSyncNode({
+            dataSyncType: DVEFDataSyncIds.Chunk,
+            commCheck: (options) => options.worldData,
+            getSyncData: (input) => {
+                WorldRegister.instance.setDimension(input[0]);
+                const chunk = WorldRegister.instance.chunk.get(input[1], input[2], input[3]);
+                if (!chunk)
+                    return false;
+                return [input, chunk];
+            },
+            getUnSyncData: (input) => input,
+        }, this),
+        column: new DataSyncNode({
+            dataSyncType: DVEFDataSyncIds.Column,
+            commCheck: (options) => options.worldData,
+            getSyncData: (input) => {
+                WorldRegister.instance.setDimension(input[0]);
+                const column = WorldRegister.instance.column.get(input[1], input[2], input[3]);
+                if (!column)
+                    return false;
+                return [input, column];
+            },
+            getUnSyncData: (input) => input,
+        }, this),
+        region: new DataSyncNode({
+            dataSyncType: DVEFDataSyncIds.Region,
+            commCheck: (options) => options.worldData,
+            getSyncData: (input) => {
+                WorldRegister.instance.setDimension(input[0]);
+                const region = WorldRegister.instance.region.get(input[1], input[2], input[3]);
+                if (!region)
+                    return false;
+                return [input, region];
+            },
+            getUnSyncData: (input) => input,
+        }, this),
+        regionHeader: new DataSyncNode({
+            dataSyncType: DVEFDataSyncIds.RegionHeader,
+            commCheck: (options) => options.worldData,
+            getSyncData: (input) => {
+                const regionHeader = RegionHeaderRegister.get(input);
+                if (!regionHeader)
+                    return false;
+                return [input, regionHeader.buffer];
+            },
+            getUnSyncData: () => true,
+        }, this),
+    };
+    tags = {
+        voxel: new DataSyncNode({
+            dataSyncType: DataSyncIds.VoxelTags,
+            commCheck: (options) => options.voxelTags,
+            getSyncData: () => [
+                VoxelStruct.initData,
+                VoxelStruct.voxelIndex.buffer,
+            ],
+            getUnSyncData: () => false,
+        }, this),
+        substance: new DataSyncNode({
+            dataSyncType: DataSyncIds.SubstanceTags,
+            commCheck: (options) => options.voxelTags,
+            getSyncData: () => SubstanceStruct.initData,
+            getUnSyncData: () => false,
+        }, this),
+    };
+    palettes = {
+        voxel: new DataSyncNode({
+            dataSyncType: DataSyncIds.VoxelPalette,
+            commCheck: (options) => options.worldDataTags,
+            getSyncData: () => [
+                VoxelDataGenerator.palette._palette,
+                VoxelDataGenerator.palette._map,
+                VoxelDataGenerator.nameToIdMap,
+                VoxelDataGenerator.idToNameMap,
+            ],
+            getUnSyncData: () => false,
+        }, this),
+        substance: new DataSyncNode({
+            dataSyncType: DataSyncIds.SubstancePalette,
+            commCheck: (options) => options.worldDataTags,
+            getSyncData: () => [
+                SubstanceDataGenerator.palette._palette,
+                SubstanceDataGenerator.palette._map,
+                {},
+                {},
+            ],
+            getUnSyncData: () => false,
+        }, this),
+    };
+    maps = {
+        strings: new DataSyncNode({
+            dataSyncType: DataSyncIds.RegisterStringMap,
+            commCheck: () => true,
+            getSyncData: (data) => data,
+            getUnSyncData: () => false,
+        }, this),
+        objects: new DataSyncNode({
+            dataSyncType: DataSyncIds.RegisterObjectMap,
+            commCheck: () => true,
+            getSyncData: (data) => data,
+            getUnSyncData: () => false,
+        }, this),
+    };
+}

package/Contexts/World/Data/DataSyncNode.d.ts

@@ -0,0 +1,28 @@
+import { DataSync } from "./DataSync";
+export type CommSyncOptions = {
+    worldData: boolean;
+    worldDataTags: boolean;
+    voxelPalette: boolean;
+    voxelTags: boolean;
+    materials: boolean;
+    colliders: boolean;
+};
+export declare class DataSyncNode<SyncInput, SyncOutput, UnSyncInput, UnSyncOutput> {
+    data: {
+        dataSyncType: number | string;
+        commCheck: (options: CommSyncOptions, threadId?: string) => boolean;
+        getSyncData: (data: SyncInput, threadId?: string) => SyncOutput | false;
+        getUnSyncData: (data: UnSyncInput, threadId?: string) => UnSyncOutput | false;
+    };
+    dataSync: DataSync;
+    constructor(data: {
+        dataSyncType: number | string;
+        commCheck: (options: CommSyncOptions, threadId?: string) => boolean;
+        getSyncData: (data: SyncInput, threadId?: string) => SyncOutput | false;
+        getUnSyncData: (data: UnSyncInput, threadId?: string) => UnSyncOutput | false;
+    }, dataSync: DataSync);
+    unSync(input: UnSyncInput): false | undefined;
+    unSyncInThread(commName: string, input: UnSyncInput): false | undefined;
+    sync(input: SyncInput): false | undefined;
+    syncInThread(commName: string, input: SyncInput): false | undefined;
+}

package/Contexts/World/Data/DataSyncNode.js

@@ -0,0 +1,54 @@
+export class DataSyncNode {
+    data;
+    dataSync;
+    constructor(data, dataSync) {
+        this.data = data;
+        this.dataSync = dataSync;
+    }
+    unSync(input) {
+        const output = this.data.getUnSyncData(input);
+        if (!output)
+            return false;
+        this.dataSync.loopThroughComms((comm, options) => {
+            if (options && !this.data.commCheck(options))
+                return false;
+            comm.unSyncData(this.data.dataSyncType, output);
+        });
+    }
+    unSyncInThread(commName, input) {
+        const comm = this.dataSync.commMap.get(commName);
+        if (!comm) {
+            console.warn("Could not find thread when trying to sync data", commName);
+            return;
+        }
+        const output = this.data.getUnSyncData(input);
+        if (!output)
+            return false;
+        if (!this.data.commCheck(this.dataSync.commOptions.get(comm)))
+            return false;
+        comm.unSyncData(this.data.dataSyncType, output);
+    }
+    sync(input) {
+        const output = this.data.getSyncData(input);
+        if (!output)
+            return false;
+        this.dataSync.loopThroughComms((comm, options) => {
+            if (!this.data.commCheck(options))
+                return false;
+            comm.syncData(this.data.dataSyncType, output);
+        });
+    }
+    syncInThread(commName, input) {
+        const comm = this.dataSync.commMap.get(commName);
+        if (!comm) {
+            console.warn("Could not find thread when trying to sync data", commName);
+            return;
+        }
+        const output = this.data.getSyncData(input);
+        if (!output)
+            return false;
+        if (!this.data.commCheck(this.dataSync.commOptions.get(comm)))
+            return false;
+        comm.syncData(this.data.dataSyncType, output);
+    }
+}

package/Contexts/World/Data/Generators/SubstanceDataGenerator.d.ts

@@ -0,0 +1,5 @@
+import { StringPalette } from "../../../../Interfaces/Data/StringPalette.js";
+export declare const SubstanceDataGenerator: {
+    $generate(): void;
+    palette: StringPalette;
+};

package/Contexts/World/Data/Generators/SubstanceDataGenerator.js

@@ -0,0 +1,36 @@
+import { SubstanceTagBuilder } from "../StructBuilders/SubstanceStructBuilder.js";
+import { SubstanceStruct } from "../../../../Data/Substance/SubstanceStruct.js";
+import { SubstancePaletteReader } from "../../../../Data/Substance/SubstancePalette.js";
+import { SubstanceManager } from "../Managers/DataManagers.js";
+import { StringPalette } from "../../../../Interfaces/Data/StringPalette.js";
+export const SubstanceDataGenerator = {
+    $generate() {
+        //build palette
+        for (const [key, substance] of SubstanceManager.data) {
+            this.palette.register(substance.id);
+        }
+        SubstancePaletteReader.setPalette(this.palette._palette, this.palette._map);
+        //create data buffer
+        const tags = SubstanceTagBuilder.build(this.palette.size);
+        const buffer = new SharedArrayBuffer(tags.structData.bufferSize);
+        tags.structData.buffer = buffer;
+        tags.setBuffer(buffer);
+        //build data
+        for (const [key, substance] of SubstanceManager.data) {
+            const substanceID = SubstancePaletteReader.id.numberFromString(key);
+            if (typeof substanceID == undefined)
+                continue;
+            tags.setStructArrayIndex(substanceID);
+            SubstanceTagBuilder.setDefaults(tags);
+            for (const tag of substance.tags) {
+                const [id, value] = tag;
+                if (!SubstanceTagBuilder.hasNode(id))
+                    continue;
+                SubstanceTagBuilder.setNode(id, value, tags);
+            }
+        }
+        SubstanceStruct.init(tags.structData);
+        SubstanceStruct.instance.setBuffer(buffer);
+    },
+    palette: new StringPalette(),
+};

package/Contexts/World/Data/Generators/VoxelDataGenerator.d.ts

@@ -0,0 +1,9 @@
+import { BinaryStruct } from "@amodx/binary";
+import { StringPalette } from "../../../../Interfaces/Data/StringPalette.js";
+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 palette: StringPalette;
+}