@divinevoxel/vlox 0.0.73 → 0.0.75

package/Util/FlatBinaryTreeIndex.js

@@ -0,0 +1,104 @@
+/**
+ * A class to help with indexing a full flat binary tree defined by the number of levels it has.
+ */
+export class FlatBinaryTreeIndex {
+    levels;
+    constructor(levels) {
+        this.levels = levels;
+    }
+    /** Gets the number of nodes at a level of the tree */
+    getLevelSize(level) {
+        if (level < 0 || level >= this.levels) {
+            throw new Error("Invalid level");
+        }
+        return 1 << level; // Equivalent to 2^level
+    }
+    /**
+     * Gets the flat index of a node indexed by the level it's on and its relative index in that level.
+     */
+    getIndexAtLevel(level, node) {
+        if (level < 0 || level >= this.levels) {
+            throw new Error("Invalid level");
+        }
+        const levelSize = this.getLevelSize(level);
+        if (node < 0 || node >= levelSize) {
+            throw new Error("Invalid node index at the given level");
+        }
+        return (1 << level) - 1 + node;
+    }
+    /**
+     * Gets the level and relative index of a node's flat index.
+     */
+    getLevelAndIndex(index) {
+        const totalNodes = (1 << this.levels) - 1;
+        if (index < 0 || index >= totalNodes) {
+            throw new Error("Invalid node index");
+        }
+        const level = Math.floor(Math.log2(index + 1));
+        const firstIndexAtLevel = (1 << level) - 1;
+        const relativeIndex = index - firstIndexAtLevel;
+        return [level, relativeIndex];
+    }
+    /**
+     * Gets the flat left child of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if no child exist
+     */
+    getLeftChildAtLevel(level, node) {
+        if (level + 1 >= this.levels) {
+            return -1;
+        }
+        const nodeIndex = this.getIndexAtLevel(level, node);
+        return this.getLeftChild(nodeIndex);
+    }
+    /**
+     * Gets the flat right child of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if no child exist
+     */
+    getRightChildAtLevel(level, node) {
+        if (level + 1 >= this.levels) {
+            return -1;
+        }
+        const nodeIndex = this.getIndexAtLevel(level, node);
+        return this.getRightChild(nodeIndex);
+    }
+    /**
+     * Gets the flat index of the parent of a node, where the node is indexed by its level and its relative index at that level.
+     * @returns -1 if level has no parent
+     */
+    getParentAtLevel(level, node) {
+        if (level === 0) {
+            return -1;
+        }
+        const nodeIndex = this.getIndexAtLevel(level, node);
+        return this.getParent(nodeIndex);
+    }
+    /** Gets the flat index of the left child of the node.
+     * @returns -1 if no child exist
+     */
+    getLeftChild(node) {
+        const leftChildIndex = 2 * node + 1;
+        const totalNodes = (1 << this.levels) - 1;
+        return leftChildIndex < totalNodes ? leftChildIndex : -1;
+    }
+    /** Gets the flat index of the right child of the node.
+     * @returns -1 if no child exist
+     */
+    getRightChild(node) {
+        const rightChildIndex = 2 * node + 2;
+        const totalNodes = (1 << this.levels) - 1;
+        return rightChildIndex < totalNodes ? rightChildIndex : -1;
+    }
+    /** Gets the flat index of the parent of the node.
+     * @returns -1 if no parent exist
+     */
+    getParent(node) {
+        if (node === 0) {
+            return -1; // Root node has no parent
+        }
+        return Math.floor((node - 1) / 2);
+    }
+    /** Gets the total number of nodes in the tree */
+    getTotalSize() {
+        return (1 << this.levels) - 1; // Equivalent to 2^levels - 1
+    }
+}

package/Util/LocationData.d.ts

@@ -0,0 +1,3 @@
+import { LocationData } from "Math";
+export declare function getLocationData(view: DataView, location?: LocationData): LocationData;
+export declare function setLocationData(view: DataView, location: LocationData): DataView;

package/Util/LocationData.js

@@ -0,0 +1,16 @@
+import { BinaryTaskType } from "@amodx/threads";
+const tempLocation = [0, 0, 0, 0];
+export function getLocationData(view, location = tempLocation) {
+    location[0] = view.getUint32(BinaryTaskType.HeaderSize);
+    location[1] = view.getInt32(BinaryTaskType.HeaderSize + 4);
+    location[2] = view.getInt32(BinaryTaskType.HeaderSize + 8);
+    location[3] = view.getInt32(BinaryTaskType.HeaderSize + 12);
+    return location;
+}
+export function setLocationData(view, location) {
+    view.setUint32(BinaryTaskType.HeaderSize, location[0]);
+    view.setInt32(BinaryTaskType.HeaderSize + 4, location[1]);
+    view.setInt32(BinaryTaskType.HeaderSize + 8, location[2]);
+    view.setInt32(BinaryTaskType.HeaderSize + 12, location[3]);
+    return view;
+}

package/Util/PriorityQueue.d.ts

@@ -0,0 +1,18 @@
+interface Node {
+    priority: number;
+}
+export declare class PriorityQueue<T extends Node> {
+    private heap;
+    private parentIndex;
+    private leftChildIndex;
+    private rightChildIndex;
+    private swap;
+    enqueue(item: T): void;
+    dequeue(): T | undefined;
+    peek(): T | undefined;
+    private heapifyUp;
+    private heapifyDown;
+    isEmpty(): boolean;
+    size(): number;
+}
+export {};

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