@divinevoxel/vlox 0.0.74 → 0.0.76

package/Util/PriorityQueue.js

@@ -0,0 +1,62 @@
+export class PriorityQueue {
+    heap = [];
+    parentIndex(index) {
+        return Math.floor((index - 1) / 2);
+    }
+    leftChildIndex(index) {
+        return 2 * index + 1;
+    }
+    rightChildIndex(index) {
+        return 2 * index + 2;
+    }
+    swap(i, j) {
+        [this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]];
+    }
+    enqueue(item) {
+        this.heap.push(item);
+        this.heapifyUp();
+    }
+    dequeue() {
+        if (this.heap.length === 0)
+            return undefined;
+        if (this.heap.length === 1)
+            return this.heap.pop();
+        const root = this.heap[0];
+        this.heap[0] = this.heap.pop();
+        this.heapifyDown();
+        return root;
+    }
+    peek() {
+        return this.heap[0];
+    }
+    heapifyUp() {
+        let index = this.heap.length - 1;
+        while (index > 0 &&
+            this.heap[this.parentIndex(index)].priority > this.heap[index].priority) {
+            this.swap(index, this.parentIndex(index));
+            index = this.parentIndex(index);
+        }
+    }
+    heapifyDown() {
+        let index = 0;
+        while (this.leftChildIndex(index) < this.heap.length) {
+            let smallerChildIndex = this.leftChildIndex(index);
+            if (this.rightChildIndex(index) < this.heap.length &&
+                this.heap[this.rightChildIndex(index)].priority <
+                    this.heap[smallerChildIndex].priority) {
+                smallerChildIndex = this.rightChildIndex(index);
+            }
+            if (this.heap[index].priority <= this.heap[smallerChildIndex].priority) {
+                break;
+            }
+            this.swap(index, smallerChildIndex);
+            index = smallerChildIndex;
+        }
+    }
+    isEmpty() {
+        return this.heap.length === 0;
+    }
+    size() {
+        return this.heap.length;
+    }
+}

package/Util/TickInterval.d.ts

@@ -0,0 +1,16 @@
+/** # Tick Interval
+ * Creates a predictable tick interval.
+ */
+export declare class TickInterval {
+    stopOnError: boolean;
+    private _active;
+    private interval;
+    private currentTimeout;
+    private __timeoutFunc;
+    constructor(run?: () => void | Promise<void>, interval?: number, stopOnError?: boolean);
+    setOnRun(run: () => void | Promise<void>): this;
+    setInterval(interval: number): this;
+    private runInterval;
+    start(): this;
+    stop(): this;
+}

package/Util/TickInterval.js

@@ -0,0 +1,49 @@
+/** # Tick Interval
+ * Creates a predictable tick interval.
+ */
+export class TickInterval {
+    stopOnError;
+    _active = false;
+    interval = 1;
+    currentTimeout;
+    __timeoutFunc;
+    constructor(run, interval, stopOnError = true) {
+        this.stopOnError = stopOnError;
+        if (run)
+            this.setOnRun(run);
+        if (interval !== undefined)
+            this.setInterval(interval);
+    }
+    setOnRun(run) {
+        this.__timeoutFunc = () => {
+            if (!this._active)
+                return;
+            run();
+            this.runInterval();
+        };
+        return this;
+    }
+    setInterval(interval) {
+        this.interval = interval;
+        return this;
+    }
+    runInterval() {
+        if (!this._active)
+            return;
+        this.currentTimeout = setTimeout(this.__timeoutFunc, this.interval);
+    }
+    start() {
+        if (!this._active) {
+            this._active = true;
+            this.runInterval();
+        }
+        return this;
+    }
+    stop() {
+        this._active = false;
+        if (this.currentTimeout !== undefined)
+            clearTimeout(this.currentTimeout);
+        this.currentTimeout = undefined;
+        return this;
+    }
+}

package/Util/TypedEventTarget.d.ts

@@ -1,4 +1,5 @@
 export declare class TypedEventTarget<T extends Record<string, any>> extends EventTarget {
+    createEventListener<K extends keyof T>(type: K, listener: ((event: CustomEvent<T[K]>) => void) | EventListenerObject | null): ((event: CustomEvent<T[K]>) => void) | EventListenerObject | null;
     addEventListener<K extends keyof T>(type: K, listener: ((event: CustomEvent<T[K]>) => void) | EventListenerObject | null, options?: AddEventListenerOptions): void;
     removeEventListener<K extends keyof T>(type: K, listener: ((event: CustomEvent<T[K]>) => void) | EventListenerObject | null): void;
     dispatch<K extends keyof T>(type: K, detail: T[K]): boolean;

package/Util/TypedEventTarget.js

@@ -1,4 +1,7 @@
 export class TypedEventTarget extends EventTarget {
+    createEventListener(type, listener) {
+        return listener;
+    }
     addEventListener(type, listener, options) {
         super.addEventListener(type, listener, options);
     }

package/Util/Util.types.d.ts

@@ -1,3 +1,7 @@
 export type RecursivePartial<T> = {
     [P in keyof T]?: RecursivePartial<T[P]>;
 };
+export interface NumberArray {
+    length: number;
+    [key: number]: number;
+}

package/Util/WorkItemProgress.d.ts

@@ -0,0 +1,23 @@
+type ProgressUpdateFunction = (completed: number, status: string) => void;
+type ProgressTaskFunction = (task: string) => void;
+export declare class WorkItemProgress {
+    private _currentStatus;
+    private _compltedWorkItems;
+    private _workItems;
+    private _onUpdate;
+    private _startTask;
+    private _endTask;
+    private _currentTask;
+    private _dispatchUpdate;
+    get compltedWorkItems(): number;
+    onStartTask(run: ProgressTaskFunction): void;
+    onEndTask(run: ProgressTaskFunction): void;
+    startTask(id: string): void;
+    endTask(): void;
+    setWorkLoad(amount: number): void;
+    onUpdate(run: ProgressUpdateFunction): void;
+    completeWorkItems(amount: number): void;
+    setStatus(status: string): void;
+    wait(time: number): Promise<unknown>;
+}
+export {};

package/Util/WorkItemProgress.js

@@ -0,0 +1,52 @@
+export class WorkItemProgress {
+    _currentStatus = "";
+    _compltedWorkItems = 0;
+    _workItems = 0;
+    _onUpdate = [];
+    _startTask = [];
+    _endTask = [];
+    _currentTask = "";
+    _dispatchUpdate() {
+        for (const update of this._onUpdate) {
+            update(this._compltedWorkItems / this._workItems, this._currentStatus);
+        }
+    }
+    get compltedWorkItems() {
+        return this._compltedWorkItems;
+    }
+    onStartTask(run) {
+        this._startTask.push(run);
+    }
+    onEndTask(run) {
+        this._endTask.push(run);
+    }
+    startTask(id) {
+        this._currentTask = id;
+        for (const run of this._startTask) {
+            run(id);
+        }
+    }
+    endTask() {
+        for (const run of this._endTask) {
+            run(this._currentTask);
+        }
+    }
+    setWorkLoad(amount) {
+        this._workItems = amount;
+        this._compltedWorkItems = 0;
+    }
+    onUpdate(run) {
+        this._onUpdate.push(run);
+    }
+    completeWorkItems(amount) {
+        this._compltedWorkItems += amount;
+        this._dispatchUpdate();
+    }
+    setStatus(status) {
+        this._currentStatus = status;
+        this._dispatchUpdate();
+    }
+    wait(time) {
+        return new Promise((resolve) => setTimeout(() => resolve(true), time));
+    }
+}

package/Voxels/Archive/VoxelArchive.types.d.ts

@@ -0,0 +1,43 @@
+import { BinaryBufferData, JSONBinaryBufferData } from "../../Util/BinaryBuffer/BinaryBuffer.types";
+import { VoxelBinaryStateSchemaNode } from "../../Voxels/State/State.types";
+export interface ArchivedVoxelDataForPalette {
+    id: string;
+    name?: string;
+    stateSchemaId?: string;
+    modSchema?: VoxelBinaryStateSchemaNode[];
+}
+export declare enum VoxelPaletteCompents {
+    VoxelId = "voxelId",
+    ModValue = "modValue",
+    StateValue = "stateValue"
+}
+export interface VoxelPaletteComponent {
+    type: VoxelPaletteCompents;
+    index: number;
+}
+export interface ArchivedVoxelPaletteDataKey {
+    stride: number;
+    components: VoxelPaletteComponent[];
+}
+export interface VoxelArchivePaletteData {
+    /**Palette of voxel string ids */
+    voxels: ArchivedVoxelDataForPalette[];
+    /**A palette of voxels and their states and mods in sets 5 of numbers.
+     * 1 -> voxel palette id
+     * 2 -> state value
+     * 3 -> mod value
+     */
+    voxelPalette: BinaryBufferData;
+    stateSchemas: Record<string, VoxelBinaryStateSchemaNode[]>;
+}
+export interface VoxelArchiPaveletteExportedJSONData {
+    /**Palette of voxel string ids */
+    voxels: ArchivedVoxelDataForPalette[];
+    /**A palette of voxels and their states and mods in sets 5 of numbers.
+     * 1 -> voxel palette id
+     * 2 -> state value
+     * 3 -> mod value
+     */
+    voxelPalette: JSONBinaryBufferData;
+    stateSchemas: Record<string, VoxelBinaryStateSchemaNode[]>;
+}

package/Voxels/Archive/VoxelArchive.types.js

@@ -0,0 +1,6 @@
+export var VoxelPaletteCompents;
+(function (VoxelPaletteCompents) {
+    VoxelPaletteCompents["VoxelId"] = "voxelId";
+    VoxelPaletteCompents["ModValue"] = "modValue";
+    VoxelPaletteCompents["StateValue"] = "stateValue";
+})(VoxelPaletteCompents || (VoxelPaletteCompents = {}));

package/Voxels/Archive/VoxelPaletteArchiveReader.d.ts

@@ -0,0 +1,11 @@
+import { BinarySchema } from "../State/Schema/BinarySchema";
+import { ArchivedVoxelDataForPalette, VoxelArchivePaletteData } from "./VoxelArchive.types";
+export declare class VoxelPaletteArchiveReader {
+    voxelPalette: Uint16Array;
+    _voxels: ArchivedVoxelDataForPalette[];
+    _voxelStateSchema: Map<string, BinarySchema>;
+    _stateSchemas: Map<string, BinarySchema>;
+    _modSchema: Map<string, BinarySchema>;
+    constructor(palettes: VoxelArchivePaletteData);
+    getVoxelData(id: number): [id: string, state: number, mod: number];
+}

package/Voxels/Archive/VoxelPaletteArchiveReader.js

@@ -0,0 +1,73 @@
+import { SchemaRegister } from "../State/SchemaRegister";
+import { BinarySchema } from "../State/Schema/BinarySchema";
+import { BinaryBuffer } from "../../Util/BinaryBuffer/BinaryBuffer";
+const temp = ["", 0, 0];
+export class VoxelPaletteArchiveReader {
+    voxelPalette;
+    _voxels = [];
+    _voxelStateSchema = new Map();
+    _stateSchemas = new Map();
+    _modSchema = new Map();
+    constructor(palettes) {
+        this._voxels = palettes.voxels;
+        for (const key in palettes.stateSchemas) {
+            const nodes = palettes.stateSchemas[key];
+            this._stateSchemas.set(key, new BinarySchema(nodes));
+        }
+        for (let i = 0; i < this._voxels.length; i++) {
+            const voxel = this._voxels[i];
+            if (voxel.modSchema) {
+                const binarySchema = new BinarySchema(voxel.modSchema);
+                this._modSchema.set(voxel.id, binarySchema);
+            }
+            if (voxel.stateSchemaId && this._stateSchemas.has(voxel.stateSchemaId)) {
+                this._voxelStateSchema.set(voxel.stateSchemaId, this._stateSchemas.get(voxel.stateSchemaId));
+            }
+        }
+        this.voxelPalette = BinaryBuffer.ToTypedArray(palettes.voxelPalette);
+    }
+    getVoxelData(id) {
+        const index = id * 3;
+        const voxelId = this._voxels[this.voxelPalette[index]]?.id;
+        temp[0] = voxelId;
+        if (temp[0] == "dve_air") {
+            temp[1] = 0;
+            temp[2] = 0;
+            return temp;
+        }
+        const voxelSchema = SchemaRegister.getVoxelSchemas(voxelId);
+        let finalStateValue = 0;
+        if (this._voxelStateSchema.has(voxelId)) {
+            const stateSchema = this._voxelStateSchema.get(voxelId);
+            const stateValue = this.voxelPalette[index + 1];
+            stateSchema.startEncoding(stateValue);
+            for (const node of stateSchema.nodes) {
+                if (node.valuePalette) {
+                    voxelSchema.state.setValue(node.name, stateSchema.getValue(node.name));
+                }
+                else {
+                    voxelSchema.state.setNumber(node.name, stateSchema.getNumber(node.name));
+                }
+            }
+            finalStateValue = stateSchema.getEncoded();
+        }
+        temp[1] = finalStateValue;
+        let finalModValue = 0;
+        if (this._modSchema.has(voxelId)) {
+            const modSchema = this._modSchema.get(voxelId);
+            const modValue = this.voxelPalette[index + 2];
+            modSchema.startEncoding(modValue);
+            for (const node of modSchema.nodes) {
+                if (node.valuePalette) {
+                    voxelSchema.mod.setValue(node.name, modSchema.getValue(node.name));
+                }
+                else {
+                    voxelSchema.mod.setNumber(node.name, modSchema.getNumber(node.name));
+                }
+            }
+            finalModValue = modSchema.getEncoded();
+        }
+        temp[2] = finalModValue;
+        return temp;
+    }
+}

package/Voxels/Archive/VoxelPaletteArechive.d.ts

@@ -0,0 +1,15 @@
+import { StringPalette } from "../../Util/StringPalette";
+import { VoxelBinaryStateSchemaNode } from "../State/State.types";
+import { ArchivedVoxelDataForPalette, VoxelArchivePaletteData, ArchivedVoxelPaletteDataKey } from "./VoxelArchive.types";
+export declare class VoxelArchivePalette {
+    static GetVoxelPaletteDataKey(): ArchivedVoxelPaletteDataKey;
+    get size(): number;
+    _voxelsRegistered: Map<number, number>;
+    _ids: StringPalette;
+    _voxels: ArchivedVoxelDataForPalette[];
+    _stateShemas: Record<string, VoxelBinaryStateSchemaNode[]>;
+    _voxelPalette: number[];
+    private _voxelCount;
+    register(id: number): number;
+    toJSON(): VoxelArchivePaletteData;
+}

package/Voxels/Archive/VoxelPaletteArechive.js

@@ -0,0 +1,81 @@
+import { BinaryBufferFormat } from "../../Util/BinaryBuffer";
+import { BinaryBuffer } from "../../Util/BinaryBuffer/BinaryBuffer";
+import { StringPalette } from "../../Util/StringPalette";
+import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
+import { SchemaRegister } from "../State/SchemaRegister";
+import { VoxelPaletteCompents, } from "./VoxelArchive.types";
+export class VoxelArchivePalette {
+    static GetVoxelPaletteDataKey() {
+        return {
+            stride: 3,
+            components: [
+                {
+                    type: VoxelPaletteCompents.VoxelId,
+                    index: 0,
+                },
+                {
+                    type: VoxelPaletteCompents.StateValue,
+                    index: 1,
+                },
+                {
+                    type: VoxelPaletteCompents.ModValue,
+                    index: 2,
+                },
+            ],
+        };
+    }
+    get size() {
+        return this._voxelCount;
+    }
+    _voxelsRegistered = new Map();
+    _ids = new StringPalette();
+    _voxels = [];
+    _stateShemas = {};
+    _voxelPalette = [];
+    _voxelCount = 0;
+    register(id) {
+        if (this._voxelsRegistered.has(id))
+            return this._voxelsRegistered.get(id);
+        const stringId = VoxelPalettesRegister.voxelIds.getStringId(VoxelPalettesRegister.voxels[id][0]);
+        let voxelId = 0;
+        if (!this._ids.isRegistered(stringId)) {
+            voxelId = this._ids.register(stringId);
+            const modelId = SchemaRegister.voxelModelMap.get(stringId);
+            const stateData = SchemaRegister.stateSchemaData.get(modelId);
+            const modData = SchemaRegister.modSchemaData.get(stringId);
+            if (stateData && stateData?.length) {
+                this._stateShemas[modelId] = stateData;
+            }
+            const voxelData = {
+                id: stringId,
+                ...(modData && modData.length ? { modSchema: modData } : {}),
+                ...(this._stateShemas[modelId] ? { stateSchemaId: modelId } : {}),
+            };
+            const name = VoxelPalettesRegister.voxelNametoIdMap.get(stringId);
+            if (name !== undefined && name !== stringId) {
+                voxelData.name = name;
+            }
+            this._voxels[voxelId] = voxelData;
+        }
+        else {
+            voxelId = this._ids.getNumberId(stringId);
+        }
+        const [, state, mod] = VoxelPalettesRegister.voxels[id];
+        this._voxelPalette.push(voxelId, state, mod);
+        const paletteId = this._voxelCount;
+        this._voxelsRegistered.set(id, paletteId);
+        this._voxelCount++;
+        return paletteId;
+    }
+    toJSON() {
+        return {
+            voxels: this._voxels,
+            voxelPalette: BinaryBuffer.Create({
+                format: BinaryBufferFormat.Uint16,
+                byteLength: this._voxelPalette.length,
+                buffer: new Uint16Array(this._voxelPalette).buffer,
+            }),
+            stateSchemas: this._stateShemas,
+        };
+    }
+}

package/Voxels/Cursor/DataCursor.interface.d.ts

@@ -2,4 +2,5 @@ import { VoxelCursorInterface } from "./VoxelCursor.interface";
 export interface DataCursorInterface {
     getVoxel(x: number, y: number, z: number): VoxelCursorInterface | null;
     inBounds(x: number, y: number, z: number): boolean;
+    clone(): DataCursorInterface;
 }

package/Voxels/Cursor/VoxelCursor.d.ts

@@ -1,13 +1,12 @@
 import { VoxelCursorInterface } from "./VoxelCursor.interface";
-import { PaintVoxelData, RawVoxelData } from "../Types/Voxel.types";
+import { RawVoxelData } from "../Types/Voxel.types";
+import { PaintVoxelData } from "../Types/PaintVoxelData";
 export declare class VoxelCursor extends VoxelCursorInterface {
     static VoxelDataToRaw(data: Partial<PaintVoxelData>, light?: number): RawVoxelData;
-    ids: Uint16Array;
-    light: Uint16Array;
-    level: Uint8Array;
-    state: Uint16Array;
-    mod: Uint16Array;
-    secondary: Uint16Array;
+    ids: number[];
+    light: number[];
+    level: number[];
+    secondary: number[];
     loadIn(): void;
     updateVoxel(mode: 0 | 1): void;
 }

package/Voxels/Cursor/VoxelCursor.interface.d.ts

@@ -1,27 +1,24 @@
 import { VoxelLightData } from "./VoxelLightData";
 import { RawVoxelData } from "../Types/Voxel.types";
 import { VoxelSubstanceTags, VoxelTags } from "../../Voxels/Data/VoxelTag.types";
-interface WritableArrayLike<T> {
-    length: number;
-    [index: number]: T;
-}
+import { VoxelSchema } from "../../Voxels/State/Schema/VoxelSchema";
+import { NumberArray } from "../../Util/Util.types";
 export declare abstract class VoxelCursorInterface {
-    _loadedId: number;
+    _voxelId: number;
     id: number;
     secondaryId: number;
-    _tags: VoxelTags;
-    _substanceTags: VoxelSubstanceTags;
-    __secondary: boolean;
+    schema: VoxelSchema;
+    tags: VoxelTags;
+    substanceTags: VoxelSubstanceTags;
+    __readingSecondaryVoxel: boolean;
     _index: number;
-    abstract ids: WritableArrayLike<number>;
-    abstract light: WritableArrayLike<number>;
-    abstract level: WritableArrayLike<number>;
-    abstract state: WritableArrayLike<number>;
-    abstract secondary: WritableArrayLike<number>;
-    abstract mod: WritableArrayLike<number>;
+    abstract ids: NumberArray;
+    abstract light: NumberArray;
+    abstract level: NumberArray;
+    abstract secondary: NumberArray;
     /**
      *
-     * @param mode 0 for add 1 for remove 2 for the voxel needs a buried and logic check only
+     * @param mode 0 for add 1 for remove 2 for the voxel needs a buried and logic check only, 3 for propagatin check only
      */
     abstract updateVoxel(mode: 0 | 1 | 2): void;
     _lightData: VoxelLightData;
@@ -35,14 +32,10 @@ export declare abstract class VoxelCursorInterface {
     getSubstance(): string;
     getSubstanceData(): VoxelSubstanceTags;
     isOpaque(): boolean;
-    getMod(): number;
-    setMod(mod: number): this;
     getLevel(): number;
     setLevel(level: number): this;
     getLevelState(): number;
     setLevelState(state: number): this;
-    getState(): number;
-    setState(state: number): this;
     hasSecondaryVoxel(): boolean;
     canHaveSecondaryVoxel(): boolean;
     hasRGBLight(): boolean;
@@ -54,22 +47,30 @@ export declare abstract class VoxelCursorInterface {
     getLightSourceValue(): number;
     getPower(): number;
     setPower(level: number): this;
-    isPowerSource(): boolean;
+    isPowerSource(): any;
     getPowerSourceValue(): number;
     noAO(): boolean;
     isRenderable(): boolean;
     isAir(): boolean;
     setAir(): this;
+    /**Get the voxels palette id. The id is the combination of the true id, state, and mod. */
     getId(): number;
     setId(id: number): this;
-    setStringId(id: string): this;
+    /**Get the true voxel id. Meaning the numeric id for the string id of the voxel */
+    getVoxelId(): number;
+    setVoxelId(id: number, state?: number, mod?: number): this;
+    setStringId(id: string, state?: number, mod?: number): this;
     getStringId(): string;
-    setName(name: string): this;
+    setName(name: string, state?: number, mod?: number): this;
     getName(): string;
+    getIndexData(): [voxelId: number, state: number, mod: number];
+    getMod(): number;
+    setMod(mod: number): this;
+    getState(): number;
+    setState(state: number): this;
     isSameVoxel(voxel: VoxelCursorInterface): boolean;
     copy(cursor: VoxelCursorInterface): this;
-    copyRaw(raw: RawVoxelData): this;
+    setRaw(raw: RawVoxelData): this;
     getRaw(): RawVoxelData;
     getRawToRef(raw: RawVoxelData): RawVoxelData;
 }
-export {};