@divinevoxel/vlox 0.0.0

package/Data/RegionHeaderRegister.d.ts

@@ -0,0 +1,29 @@
+import type { LocationData } from "../Math";
+import { RemoteBinaryStruct } from "@amodx/binary/";
+export declare const RegionHeaderTags: RemoteBinaryStruct;
+type RegionHeaderData = Map<string, Map<string, {
+    data: DataView;
+    buffer: SharedArrayBuffer;
+}>>;
+export declare const RegionHeaderRegister: {
+    _headers: RegionHeaderData;
+    remove(location: LocationData): boolean;
+    add(location: LocationData, buffer: SharedArrayBuffer): void;
+    get(location: LocationData): false | {
+        data: DataView;
+        buffer: SharedArrayBuffer;
+    } | undefined;
+    /**# isStored
+     * @param location
+     * @returns
+     *
+     * Returns 1 if stored
+     *
+     * Returns 0 if not stored
+     *
+     * Returns -1 if region header is not loaded
+     *
+     */
+    isStored(location: LocationData): 0 | 1 | -1;
+};
+export {};

package/Data/RegionHeaderRegister.js

@@ -0,0 +1,56 @@
+;
+import { RemoteBinaryStruct } from "@amodx/binary/";
+import { WorldSpaces } from "../Data/World/WorldSpaces";
+export const RegionHeaderTags = new RemoteBinaryStruct("region-header-tags");
+export const RegionHeaderRegister = {
+    _headers: new Map(),
+    remove(location) {
+        const [dimensionId, x, y, z] = location;
+        const dimension = this._headers.get(dimensionId);
+        if (!dimension)
+            return false;
+        const regionKey = WorldSpaces.region.getKeyXYZ(x, y, z);
+        return dimension.delete(regionKey);
+    },
+    add(location, buffer) {
+        const [dimensionId, x, y, z] = location;
+        let dimension = this._headers.get(dimensionId);
+        if (!dimension) {
+            dimension = new Map();
+            this._headers.set(dimensionId, dimension);
+        }
+        const regionKey = WorldSpaces.region.getKeyXYZ(x, y, z);
+        dimension.set(regionKey, {
+            buffer: buffer,
+            data: new DataView(buffer),
+        });
+    },
+    get(location) {
+        const [dimensionId, x, y, z] = location;
+        let dimension = this._headers.get(dimensionId);
+        if (!dimension)
+            return false;
+        return dimension.get(WorldSpaces.region.getKeyXYZ(x, y, z));
+    },
+    /**# isStored
+     * @param location
+     * @returns
+     *
+     * Returns 1 if stored
+     *
+     * Returns 0 if not stored
+     *
+     * Returns -1 if region header is not loaded
+     *
+     */
+    isStored(location) {
+        const header = this.get(location);
+        if (!header)
+            return -1;
+        RegionHeaderTags.setBuffer(header.data);
+        const columnIndex = WorldSpaces.column.getIndexXYZ(location[1], location[2], location[3]);
+        return RegionHeaderTags.getArrayPropertyValue("#dved-column-save-timestamp", columnIndex) != 0
+            ? 1
+            : 0;
+    },
+};

package/Data/Register/MappedDataRegister.d.ts

@@ -0,0 +1,5 @@
+import { MappedRegisterBase } from "./MappedRegisterBase.js";
+export declare class MappedDataRegister {
+    static stringMaps: MappedRegisterBase<string>;
+    static objectMaps: MappedRegisterBase<any>;
+}

package/Data/Register/MappedDataRegister.js

@@ -0,0 +1,8 @@
+import { MappedRegisterBase } from "./MappedRegisterBase.js";
+export class MappedDataRegister {
+    static stringMaps = new MappedRegisterBase();
+    static objectMaps = new MappedRegisterBase();
+}
+MappedDataRegister.stringMaps.addSegment("voxel");
+MappedDataRegister.stringMaps.addSegment("substance");
+MappedDataRegister.objectMaps.addSegment("substance");

package/Data/Register/MappedRegisterBase.d.ts

@@ -0,0 +1,14 @@
+declare class MappedRegisterSegment<Data> extends EventTarget {
+    entries: Map<string, Data[]>;
+    onEntryAdded(id: string, run: (data: Data[]) => void): void;
+    add(id: string, data: Data[]): void;
+    get(id: string): Data[] | undefined;
+}
+export declare class MappedRegisterBase<Data> {
+    segments: Map<string, MappedRegisterSegment<Data>>;
+    addSegment(id: string): MappedRegisterSegment<Data>;
+    getSegment(id: string): MappedRegisterSegment<Data>;
+    sync(segment: string, id: string, value: Data[]): void;
+    get(segment: string, id: string, index: number): Data | null;
+}
+export {};

package/Data/Register/MappedRegisterBase.js

@@ -0,0 +1,50 @@
+const getSyncId = (id) => `entry-synced-${id}`;
+class MappedRegisterSegment extends EventTarget {
+    entries = new Map();
+    onEntryAdded(id, run) {
+        const entrySyncedId = getSyncId(id);
+        const listener = () => {
+            run(this.entries.get(id));
+            this.removeEventListener(entrySyncedId, listener);
+        };
+        this.addEventListener(entrySyncedId, listener);
+    }
+    add(id, data) {
+        this.entries.set(id, data);
+        this.dispatchEvent(new Event(getSyncId(id)));
+    }
+    get(id) {
+        return this.entries.get(id);
+    }
+}
+export class MappedRegisterBase {
+    segments = new Map();
+    addSegment(id) {
+        if (this.segments.has(id))
+            return this.segments.get(id);
+        const newSegment = new MappedRegisterSegment();
+        this.segments.set(id, newSegment);
+        return newSegment;
+    }
+    getSegment(id) {
+        const segment = this.segments.get(id);
+        if (!segment)
+            throw new Error(`Segment with id ${id} does not exist`);
+        return segment;
+    }
+    sync(segment, id, value) {
+        const segmentMap = this.addSegment(segment);
+        segmentMap.add(id, value);
+        return;
+    }
+    get(segment, id, index) {
+        const segmentMap = this.segments.get(segment);
+        if (!segmentMap)
+            return null;
+        const mapped = segmentMap.get(id);
+        if (!mapped) {
+            return null;
+        }
+        return mapped[index];
+    }
+}

package/Data/Settings/EngineSettings.d.ts

@@ -0,0 +1,27 @@
+import { EngineSettingsData } from "../../Types/EngineSettings.types.js";
+import { Observable } from "@amodx/core/Observers/Observable.js";
+/**# Engine Settings
+ * ---
+ * Handles common settings for all contexts
+ */
+export declare class EngineSettings {
+    static observers: {
+        updated: Observable<EngineSettingsData>;
+    };
+    static enviorment: "node" | "browser";
+    static settings: EngineSettingsData;
+    static getSettings(): EngineSettingsData;
+    static syncSettings(data: EngineSettingsData): void;
+    static getSettingsCopy(): any;
+    static syncChunkInRichWorldThread(): boolean;
+    static richDataEnabled(): boolean;
+    static syncChunkInDataThread(): boolean;
+    static syncChunksInNexusThread(): boolean;
+    static doSunPropagation(): boolean;
+    static doRGBPropagation(): boolean;
+    static doLight(): boolean;
+    static doFlow(): boolean;
+    static saveWorldData(): boolean;
+    static isServer(): boolean;
+    static isClient(): boolean;
+}

package/Data/Settings/EngineSettings.js

@@ -0,0 +1,81 @@
+import { EngineSettingsData } from "../../Types/EngineSettings.types.js";
+import { WorldBounds } from "../World/WorldBounds.js";
+import { InitWorldSpaces } from "../World/WorldSpaces.js";
+import { Environment } from "@amodx/core/Environment/Environment.js";
+import { Observable } from "@amodx/core/Observers/Observable.js";
+/**# Engine Settings
+ * ---
+ * Handles common settings for all contexts
+ */
+export class EngineSettings {
+    static observers = {
+        updated: new Observable(),
+    };
+    static enviorment = Environment.nodeJS.isNode
+        ? "node"
+        : "browser";
+    static settings = new EngineSettingsData();
+    static getSettings() {
+        return this.settings;
+    }
+    static syncSettings(data) {
+        //safetly set data without prototype pollution
+        for (const settingsKey of Object.keys(data)) {
+            if (settingsKey.includes("__")) {
+                throw new Error("Can not include properties with multpile underscores.");
+            }
+            if (this.settings[settingsKey] !== undefined) {
+                for (const propertyKey of Object.keys(data[settingsKey])) {
+                    if (propertyKey.includes("__")) {
+                        throw new Error("Can not include properties with multpile underscores.");
+                    }
+                    if (this.settings[settingsKey][propertyKey] !== undefined) {
+                        //@ts-ignore
+                        this.settings[settingsKey][propertyKey] = data[settingsKey][propertyKey];
+                    }
+                }
+            }
+        }
+        InitWorldSpaces(this.settings);
+        if (this.settings.world) {
+            WorldBounds.setWorldBounds(this.settings.world.minX, this.settings.world.maxX, this.settings.world.minZ, this.settings.world.maxZ, this.settings.world.minY, this.settings.world.maxY);
+        }
+        this.observers.updated.notify(this.settings);
+    }
+    static getSettingsCopy() {
+        return JSON.parse(JSON.stringify(this.settings));
+    }
+    static syncChunkInRichWorldThread() {
+        return (this.settings.richWorld.enabled && this.settings.richWorld.autoSyncChunks);
+    }
+    static richDataEnabled() {
+        return this.settings.richWorld.enabled;
+    }
+    static syncChunkInDataThread() {
+        return this.settings.data.enabled && this.settings.data.autoSyncChunks;
+    }
+    static syncChunksInNexusThread() {
+        return this.settings.nexus.enabled && this.settings.nexus.autoSyncChunks;
+    }
+    static doSunPropagation() {
+        return this.settings.lighting.autoSunLight == true;
+    }
+    static doRGBPropagation() {
+        return this.settings.lighting.autoRGBLight == true;
+    }
+    static doLight() {
+        return this.doRGBPropagation() || this.doSunPropagation();
+    }
+    static doFlow() {
+        return this.settings.flow.enable;
+    }
+    static saveWorldData() {
+        return this.settings.data.enabled;
+    }
+    static isServer() {
+        return this.settings.server.enabled && this.enviorment == "node";
+    }
+    static isClient() {
+        return this.enviorment != "browser";
+    }
+}

package/Data/Substance/SubstancePalette.d.ts

@@ -0,0 +1,9 @@
+export declare const SubstancePaletteReader: {
+    _palette: string[];
+    _map: Map<string, number>;
+    setPalette(palette: string[], map: Record<string, number>): void;
+    id: {
+        stringFromNumber(id: number): string;
+        numberFromString(id: string): number;
+    };
+};

package/Data/Substance/SubstancePalette.js

@@ -0,0 +1,16 @@
+export const SubstancePaletteReader = {
+    _palette: [],
+    _map: new Map(),
+    setPalette(palette, map) {
+        this._palette = palette;
+        this._map = new Map(Object.entries(map));
+    },
+    id: {
+        stringFromNumber(id) {
+            return SubstancePaletteReader._palette[id];
+        },
+        numberFromString(id) {
+            return SubstancePaletteReader._map.get(id);
+        },
+    },
+};

package/Data/Substance/SubstanceStruct.d.ts

@@ -0,0 +1,20 @@
+import { BinaryStructData, InstantiatedStruct } from "@amodx/binary/";
+import { SubstanceTagIds } from "../../Data/Constants/SubstanceTagIds.js";
+export interface SubstanceStruct {
+    [SubstanceTagIds.parent]: number;
+    [SubstanceTagIds.rendered]: number;
+    [SubstanceTagIds.isSolid]: number;
+    [SubstanceTagIds.isTransparent]: number;
+    [SubstanceTagIds.isLiquid]: number;
+    [SubstanceTagIds.flowRate]: number;
+    [SubstanceTagIds.culledSubstnaces]: number;
+    [SubstanceTagIds.cullDense]: number;
+    [SubstanceTagIds.isWindAffected]: number;
+    [SubstanceTagIds.isBackFaceCulled]: number;
+}
+export declare class SubstanceStruct extends InstantiatedStruct<SubstanceStruct> {
+    static instance: SubstanceStruct;
+    static init(data: BinaryStructData): void;
+    static setSubstance(id: string | number): void;
+    static initData: BinaryStructData;
+}

package/Data/Substance/SubstanceStruct.js

@@ -0,0 +1,19 @@
+import { RemoteBinaryStruct, InstantiatedStruct, } from "@amodx/binary/";
+import { SubstanceTagIds } from "../../Data/Constants/SubstanceTagIds.js";
+import { SubstancePaletteReader } from "./SubstancePalette.js";
+const remote = new RemoteBinaryStruct("voxel-data");
+export class SubstanceStruct extends InstantiatedStruct {
+    static instance;
+    static init(data) {
+        remote.init(data);
+        const instance = remote.instantiate();
+        this.initData = data;
+        SubstanceStruct.instance = instance;
+    }
+    static setSubstance(id) {
+        this.instance.setIndex(typeof id == "string"
+            ? SubstancePaletteReader.id.numberFromString(id)
+            : id);
+    }
+    static initData;
+}

package/Data/Types/DataSync.types.d.ts

@@ -0,0 +1,3 @@
+import { LocationData } from "../../Math";
+export type DataSyncTypes = "chunk" | "voxel-data" | "iten-data" | "shape-map";
+export type WorldDataSync = [location: LocationData, buffer: SharedArrayBuffer];

package/Data/Types/DataSync.types.js

@@ -0,0 +1 @@
+export {};

package/Data/Types/DimensionData.types.d.ts

@@ -0,0 +1,9 @@
+export type DimensionOptions = {
+    liquidFlowSpeed: number;
+    magmaFlowSpeed: number;
+    sunLight: boolean;
+};
+export type DimensionData = {
+    id: string;
+    options: DimensionOptions;
+};

package/Data/Types/DimensionData.types.js

@@ -0,0 +1 @@
+export {};

package/Data/Types/RichWorldData.types.d.ts

@@ -0,0 +1,15 @@
+export type RichDataSchema = Record<string, Record<string, any>>;
+export type RichColumn = {
+    data: RichDataSchema;
+};
+export type RichRegion = {
+    columns: Map<string, RichColumn>;
+};
+export type RichWorldDimensions = Map<string, Map<string, RichRegion>>;
+export type SetRichVoxel = [
+    id: string,
+    dimesnion: string,
+    x: number,
+    y: number,
+    z: number
+];

package/Data/Types/RichWorldData.types.js

@@ -0,0 +1 @@
+export {};

package/Data/Types/VoxelData.types.d.ts

@@ -0,0 +1,7 @@
+export type RawVoxelData = [
+    id: number,
+    light: number,
+    state: number,
+    secondaryId: number,
+    mod: number
+];

package/Data/Types/VoxelData.types.js

@@ -0,0 +1 @@
+export {};

package/Data/Types/WorldData.types.d.ts

@@ -0,0 +1,10 @@
+export declare class AddVoxelData {
+    id: string;
+    mod: number;
+    shapeState: number;
+    level: number;
+    levelState: number;
+    secondaryVoxelId: string;
+    static Create(data: Partial<AddVoxelData>): AddVoxelData;
+    private constructor();
+}

package/Data/Types/WorldData.types.js

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

package/Data/Voxel/VoxelPalette.d.ts

@@ -0,0 +1,12 @@
+import { StringPalette } from "../../Interfaces/Data/StringPalette";
+export declare class VoxelPalette {
+    static _nameToIdMap: Map<string, string>;
+    static _idToNameMap: Map<string, string>;
+    static ids: StringPalette;
+    static setVoxelIdPalette(voxelPalette: string[], voxelPaletteMap: Record<string, number>): void;
+    static setVoxelNamePalette(nameToIdMap: Record<string, string>, idToNameMap: Record<string, string>): void;
+    static name: {
+        getId: (name: string) => string;
+        getName: (id: string) => string;
+    };
+}

package/Data/Voxel/VoxelPalette.js

@@ -0,0 +1,22 @@
+import { StringPalette } from "../../Interfaces/Data/StringPalette";
+export class VoxelPalette {
+    static _nameToIdMap = new Map();
+    static _idToNameMap = new Map();
+    static ids = new StringPalette();
+    static setVoxelIdPalette(voxelPalette, voxelPaletteMap) {
+        this.ids._map = voxelPaletteMap;
+        this.ids._palette = voxelPalette;
+    }
+    static setVoxelNamePalette(nameToIdMap, idToNameMap) {
+        this._nameToIdMap = new Map(Object.entries(nameToIdMap));
+        this._idToNameMap = new Map(Object.entries(idToNameMap));
+    }
+    static name = {
+        getId: (name) => {
+            return this._nameToIdMap.get(name);
+        },
+        getName: (id) => {
+            return this._idToNameMap.get(id);
+        },
+    };
+}

package/Data/Voxel/VoxelStruct.d.ts

@@ -0,0 +1,26 @@
+import { BinaryStructData, InstantiatedStruct } from "@amodx/binary/";
+import { VoxelTagIDs } from "../../Data/Constants/VoxelTagIds";
+export interface VoxelStruct {
+    [VoxelTagIDs.substance]: number;
+    [VoxelTagIDs.shapeID]: number;
+    [VoxelTagIDs.material]: number;
+    [VoxelTagIDs.hardness]: number;
+    [VoxelTagIDs.colliderID]: number;
+    [VoxelTagIDs.checkCollisions]: number;
+    [VoxelTagIDs.isLightSource]: number;
+    [VoxelTagIDs.noAO]: number;
+    [VoxelTagIDs.lightValue]: number;
+    [VoxelTagIDs.isRich]: number;
+    [VoxelTagIDs.canHaveSecondary]: number;
+    [VoxelTagIDs.isTransparent]: number;
+}
+export declare class VoxelStruct extends InstantiatedStruct<VoxelStruct> {
+    static instance: VoxelStruct;
+    static init(data: BinaryStructData): void;
+    static clone(): InstantiatedStruct<VoxelStruct> & VoxelStruct;
+    static sync(voxelMap: Uint16Array): void;
+    static setVoxel(id: number): void;
+    static setStringVoxel(id: string): void;
+    static voxelIndex: Uint16Array;
+    static initData: BinaryStructData;
+}

package/Data/Voxel/VoxelStruct.js

@@ -0,0 +1,29 @@
+import { RemoteBinaryStruct, InstantiatedStruct, } from "@amodx/binary/";
+import { VoxelTagIDs } from "../../Data/Constants/VoxelTagIds";
+import { VoxelPalette } from "./VoxelPalette";
+const remote = new RemoteBinaryStruct("voxel-data");
+export class VoxelStruct extends InstantiatedStruct {
+    static instance;
+    static init(data) {
+        remote.init(data);
+        const instance = remote.instantiate();
+        this.initData = data;
+        VoxelStruct.instance = instance;
+    }
+    static clone() {
+        return this.instance.createClone();
+    }
+    static sync(voxelMap) {
+        this.voxelIndex = voxelMap;
+    }
+    static setVoxel(id) {
+        const index = this.voxelIndex[id];
+        this.instance.setIndex(index);
+    }
+    static setStringVoxel(id) {
+        const index = this.voxelIndex[VoxelPalette.ids.getNumberId(id)];
+        this.instance.setIndex(index);
+    }
+    static voxelIndex = new Uint16Array();
+    static initData;
+}

package/Data/VoxelShaderData.d.ts

@@ -0,0 +1,17 @@
+declare enum WindAffectedAnimStates {
+    Panel = 1,
+    CrossPanel = 2,
+    Box = 3
+}
+export declare class VoxelShaderData {
+    static AnimationStates: {
+        WindAffected: typeof WindAffectedAnimStates;
+    };
+    static LightMask: number;
+    static AOMask: number;
+    static AnimationMask: number;
+    static TextureIndexMax: number;
+    static createTextureIndex(index1: number, index2: number): number;
+    static createAttribute(light: number, ao: number, animation: number): number;
+}
+export {};

package/Data/VoxelShaderData.js

@@ -0,0 +1,34 @@
+var WindAffectedAnimStates;
+(function (WindAffectedAnimStates) {
+    WindAffectedAnimStates[WindAffectedAnimStates["Panel"] = 1] = "Panel";
+    WindAffectedAnimStates[WindAffectedAnimStates["CrossPanel"] = 2] = "CrossPanel";
+    WindAffectedAnimStates[WindAffectedAnimStates["Box"] = 3] = "Box";
+})(WindAffectedAnimStates || (WindAffectedAnimStates = {}));
+export class VoxelShaderData {
+    static AnimationStates = {
+        WindAffected: WindAffectedAnimStates,
+    };
+    static LightMask = 0xffff;
+    static AOMask = 0xf;
+    static AnimationMask = 0xfff;
+    static TextureIndexMax = 0xffff;
+    static createTextureIndex(index1, index2) {
+        let value = 0;
+        value =
+            (value & ~(this.TextureIndexMax << 0)) |
+                ((index1 & this.TextureIndexMax) << 0);
+        value =
+            (value & ~(this.TextureIndexMax << 16)) |
+                ((index2 & this.TextureIndexMax) << 16);
+        return value;
+    }
+    static createAttribute(light, ao, animation) {
+        let value = 0;
+        value = (value & ~(this.LightMask << 0)) | ((light & this.LightMask) << 0);
+        value = (value & ~(this.AOMask << 16)) | ((ao & this.AOMask) << 16);
+        value =
+            (value & ~(this.AnimationMask << 20)) |
+                ((animation & this.AnimationMask) << 20);
+        return value;
+    }
+}

package/Data/VoxelStateReader.d.ts

@@ -0,0 +1,12 @@
+/**# Voxel Reader
+ * ---
+ * Used to decode voxel state data.
+ */
+export declare class VoxelStateReader {
+    static getLevel(stateData: number): number;
+    static setLevel(stateData: number, level: number): number;
+    static getLevelState(stateData: number): number;
+    static setLevelState(stateData: number, levelState: number): number;
+    static getShapeState(voxelData: number): number;
+    static setShapeState(voxelData: number, shapeState: number): number;
+}

package/Data/VoxelStateReader.js

@@ -0,0 +1,30 @@
+var StateMasks;
+(function (StateMasks) {
+    StateMasks[StateMasks["Level"] = 15] = "Level";
+    StateMasks[StateMasks["LevelState"] = 48] = "LevelState";
+    StateMasks[StateMasks["ShapeState"] = 65472] = "ShapeState";
+})(StateMasks || (StateMasks = {}));
+/**# Voxel Reader
+ * ---
+ * Used to decode voxel state data.
+ */
+export class VoxelStateReader {
+    static getLevel(stateData) {
+        return stateData & StateMasks.Level;
+    }
+    static setLevel(stateData, level) {
+        return (stateData & ~StateMasks.Level) | level;
+    }
+    static getLevelState(stateData) {
+        return (stateData & StateMasks.LevelState) >> 4;
+    }
+    static setLevelState(stateData, levelState) {
+        return (stateData & ~StateMasks.LevelState) | (levelState << 4);
+    }
+    static getShapeState(voxelData) {
+        return (voxelData & StateMasks.ShapeState) >> 6;
+    }
+    static setShapeState(voxelData, shapeState) {
+        return (voxelData & ~StateMasks.ShapeState) | (shapeState << 6);
+    }
+}

package/Data/World/Classes/Chunk.d.ts

@@ -0,0 +1,21 @@
+import { RemoteBinaryStruct } from "@amodx/binary/";
+export interface VoxelDataArrays {
+    ids: Uint16Array;
+    light: Uint16Array;
+    state: Uint16Array;
+    secondary: Uint16Array;
+    mod: Uint16Array;
+}
+export interface ChunkData extends VoxelDataArrays {
+    stateBuffer: ArrayBuffer;
+}
+export interface Chunk extends ChunkData {
+}
+export declare class Chunk {
+    static CreateNew(): ChunkData;
+    static toObject(data: ChunkData): Chunk;
+    static StateStruct: RemoteBinaryStruct;
+    chunkState: DataView;
+    constructor(data: ChunkData);
+    serialize(): ChunkData;
+}