@divinevoxel/vlox 0.0.0

package/Tools/Data/RichDataTool.js

@@ -0,0 +1,121 @@
+import { BinaryObject } from "@amodx/binary";
+import { Threads } from "@amodx/threads/";
+import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
+export class RichDataTool extends LocationBoundTool {
+    segment = "voxels";
+    comm;
+    _enabled = false;
+    constructor() {
+        super();
+        this.comm = Threads.getThread("rich-world");
+        if (!this.comm || !this.comm.isPortSet()) {
+            this._enabled = false;
+            if (this.comm) {
+                this.comm.onSetPort(() => {
+                    this._enabled = true;
+                });
+            }
+            return;
+        }
+        if (this.comm.isPortSet()) {
+            this._enabled = true;
+        }
+    }
+    isEnabled() {
+        return this._enabled;
+    }
+    setSegment(segment) {
+        this.segment = segment;
+        return this;
+    }
+    columnHasData(check) {
+        this.comm.runPromiseTasks("has-data", this.location, [], (hadData) => {
+            check(hadData);
+        });
+    }
+    columnHasDataAsync() {
+        return new Promise((resolve) => {
+            this.columnHasData((hasData) => {
+                resolve(hasData);
+            });
+        });
+    }
+    getData(onDone) {
+        this.comm.runPromiseTasks("get-data", [this.location, this.segment], [], (data) => {
+            if (!data)
+                return onDone(false);
+            onDone(BinaryObject.bufferToObject(data));
+        });
+    }
+    getDataAsync() {
+        return new Promise((resolve) => {
+            this.getData((data) => {
+                resolve(data);
+            });
+        });
+    }
+    setData(data, onDone = (data) => { }) {
+        const buffer = BinaryObject.objectToBuffer(data);
+        this.comm.runPromiseTasks("set-data", [this.location, this.segment, buffer], [buffer], (success) => {
+            onDone(success);
+        });
+    }
+    setDataAsync(data) {
+        return new Promise((resolve) => {
+            this.setData(data, (updated) => {
+                resolve(updated);
+            });
+        });
+    }
+    removeData(onDone) {
+        this.comm.runPromiseTasks("remove-data", [this.location, this.segment], [], (removed) => {
+            onDone(removed);
+        });
+    }
+    removeDataAsync() {
+        return new Promise((resolve) => {
+            this.removeData((removed) => {
+                resolve(removed);
+            });
+        });
+    }
+    removeColumn(onDone) {
+        this.comm.runPromiseTasks("remove-column", this.location, [], (removed) => {
+            onDone(removed);
+        });
+    }
+    removeColumnAsync() {
+        return new Promise((resolve) => {
+            this.removeData((removed) => {
+                resolve(removed);
+            });
+        });
+    }
+    getColumn(onDone) {
+        this.comm.runPromiseTasks("get-column", this.location, [], (data) => {
+            onDone(data);
+        });
+    }
+    getColumnAsync() {
+        return new Promise((resolve) => {
+            this.getColumn((data) => {
+                resolve(data);
+            });
+        });
+    }
+    setColumn(column, onDone) {
+        this.comm.runPromiseTasks("set-column", [this.location, column], [], (success) => {
+            onDone(success);
+        });
+    }
+    setColumnAsync(column) {
+        return new Promise((resolve) => {
+            this.setColumn(column, (success) => {
+                resolve(success);
+            });
+        });
+    }
+    releaeAllData() {
+        this.comm.runTasks("release-all-data", [], []);
+    }
+}

package/Tools/Data/SubstanceDataTool.d.ts

@@ -0,0 +1,16 @@
+import { SubstanceStruct } from "../../Data/Substance/SubstanceStruct.js";
+export declare class SubstanceDataTool {
+    static tags: typeof SubstanceStruct;
+    substanceTagIndex: number;
+    setSubstanceFromString(substance: string): void;
+    setSubstance(substance: number): void;
+    getSubstanceStringId(): string;
+    isLiquid(): boolean;
+    isWindAffected(): boolean;
+    isBackFaceCulled(): boolean;
+    cullDense(): boolean;
+    getParent(): string;
+    getRendered(): string;
+    getCulled(): string[];
+    getFlowRate(): number;
+}

package/Tools/Data/SubstanceDataTool.js

@@ -0,0 +1,62 @@
+import { SubstanceStructProperties } from "../../Data/Constants/Structs/SubstanceStructProperties.js";
+import { SubstancePaletteReader } from "../../Data/Substance/SubstancePalette.js";
+import { SubstanceStruct } from "../../Data/Substance/SubstanceStruct.js";
+import { MappedDataRegister } from "../../Data/Register/MappedDataRegister.js";
+import { SubstanceTagIds } from "../../Data/Constants/SubstanceTagIds.js";
+export class SubstanceDataTool {
+    static tags = SubstanceStruct;
+    //substance = "";
+    substanceTagIndex = 0;
+    setSubstanceFromString(substance) {
+        //   this.substance = substance;
+        this.substanceTagIndex =
+            SubstancePaletteReader.id.numberFromString(substance);
+        SubstanceStruct.setSubstance(this.substanceTagIndex);
+    }
+    setSubstance(substance) {
+        //  this.substance = substance;
+        this.substanceTagIndex = substance;
+        SubstanceStruct.setSubstance(this.substanceTagIndex);
+    }
+    getSubstanceStringId() {
+        return SubstancePaletteReader.id.stringFromNumber(this.substanceTagIndex);
+    }
+    /*   isTransparent() {
+      return SubstanceStruct.instance[SubstanceTagIds.isTransparent] == 1;
+    }
+  
+    isSolid() {
+      return SubstanceStruct.instance[SubstanceTagIds.isSolid] == 1;
+    } */
+    isLiquid() {
+        return SubstanceStruct.instance[SubstanceTagIds.isLiquid] == 1;
+    }
+    isWindAffected() {
+        return SubstanceStruct.instance[SubstanceTagIds.isWindAffected] == 1;
+    }
+    isBackFaceCulled() {
+        return SubstanceStruct.instance[SubstanceTagIds.isBackFaceCulled] == 1;
+    }
+    cullDense() {
+        return SubstanceStruct.instance[SubstanceTagIds.cullDense] == 1;
+    }
+    /*   isOpaque() {
+      return this.isSolid() && !this.isTransparent();
+    }
+   */
+    /*   allowLight() {
+      return this.isTransparent();
+    } */
+    getParent() {
+        return MappedDataRegister.stringMaps.get("substance", SubstanceStructProperties.parent, SubstanceStruct.instance[SubstanceTagIds.parent]);
+    }
+    getRendered() {
+        return MappedDataRegister.stringMaps.get("substance", SubstanceStructProperties.rendered, SubstanceStruct.instance[SubstanceTagIds.rendered]);
+    }
+    getCulled() {
+        return MappedDataRegister.objectMaps.get("substance", SubstanceStructProperties.culledSubstnaces, SubstanceStruct.instance[SubstanceTagIds.culledSubstnaces]);
+    }
+    getFlowRate() {
+        return SubstanceStruct.instance[SubstanceTagIds.flowRate];
+    }
+}

package/Tools/Data/WorldData/ChunkDataTool.d.ts

@@ -0,0 +1,11 @@
+import { DataToolBase } from "../../Classes/DataToolBase.js";
+import { Chunk } from "../../../Data/World/Classes/Chunk.js";
+import { RawVoxelData } from "../../../Data/Types/VoxelData.types.js";
+export declare class ChunkDataTool extends DataToolBase {
+    struct: import("@amodx/binary").RemoteBinaryStruct;
+    _chunk: Chunk;
+    loadIn(): boolean;
+    setChunk(chunk: Chunk): this;
+    loadInRaw(index: number, raw: RawVoxelData): void;
+    setRaw(index: number, raw: RawVoxelData): void;
+}

package/Tools/Data/WorldData/ChunkDataTool.js

@@ -0,0 +1,38 @@
+//objects
+import { DataToolBase } from "../../Classes/DataToolBase.js";
+import { WorldRegister } from "../../../Data/World/WorldRegister.js";
+import { Chunk } from "../../../Data/World/Classes/Chunk.js";
+export class ChunkDataTool extends DataToolBase {
+    struct = Chunk.StateStruct;
+    _chunk;
+    loadIn() {
+        WorldRegister.instance.setDimension(this.dimension);
+        const chunk = WorldRegister.instance.chunk.get(this.x, this.y, this.z);
+        if (!chunk)
+            return false;
+        this.struct.setBuffer(chunk.chunkState);
+        this._c = chunk.chunkState;
+        this._chunk = chunk;
+        return true;
+    }
+    setChunk(chunk) {
+        this.struct.setBuffer(chunk.chunkState);
+        this._c = chunk.chunkState;
+        this._chunk = chunk;
+        return this;
+    }
+    loadInRaw(index, raw) {
+        raw[0] = this._chunk.ids[index];
+        raw[1] = this._chunk.light[index];
+        raw[2] = this._chunk.state[index];
+        raw[3] = this._chunk.secondary[index];
+        raw[4] = this._chunk.mod[index];
+    }
+    setRaw(index, raw) {
+        this._chunk.ids[index] = raw[0];
+        this._chunk.light[index] = raw[1];
+        this._chunk.state[index] = raw[2];
+        this._chunk.secondary[index] = raw[3];
+        this._chunk.mod[index] = raw[4];
+    }
+}

package/Tools/Data/WorldData/ColumnDataTool.d.ts

@@ -0,0 +1,26 @@
+import { DataToolBase } from "../../Classes/DataToolBase.js";
+import { Column } from "../../../Data/World/Classes/Column.js";
+export declare class ColumnDataTool extends DataToolBase {
+    struct: import("@amodx/binary").RemoteBinaryStruct;
+    _column: Column;
+    loadIn(): boolean;
+    setColumn(column: Column): this;
+    getColumn(): Column;
+    getNumChunks(): number;
+    getBufferSizeForWholeColumn(): number;
+    isStored(): boolean;
+    markAsNotStored(): this;
+    markAsStored(): this;
+    isPersistent(): boolean;
+    setPersistence(value: boolean): void;
+    isDirty(): boolean;
+    setDirty(value: boolean): void;
+    getLastSaveTimestamp(): number;
+    setLastSaveTimestamp(): boolean;
+    getLastAnalyzerUpdateTimestamp(): number;
+    setLastAnalyzerUpdateTimestamp(): boolean;
+    hasRichData(): boolean;
+    setRichData(value: boolean): void;
+    hasEntityData(): boolean;
+    setEntityData(value: boolean): void;
+}

package/Tools/Data/WorldData/ColumnDataTool.js

@@ -0,0 +1,81 @@
+//objects
+import { WorldRegister } from "../../../Data/World/WorldRegister.js";
+import { DataToolBase } from "../../Classes/DataToolBase.js";
+import { Column } from "../../../Data/World/Classes/Column.js";
+export class ColumnDataTool extends DataToolBase {
+    struct = Column.StateStruct;
+    _column = {};
+    loadIn() {
+        WorldRegister.instance.setDimension(this.dimension);
+        const column = WorldRegister.instance.column.get(this.x, this.y, this.z);
+        if (!column)
+            return false;
+        this.struct.setBuffer(column.columnState);
+        this._c = column.columnState;
+        this._column = column;
+        return true;
+    }
+    setColumn(column) {
+        this.struct.setBuffer(column.columnState);
+        this._c = column.columnState;
+        this._column = column;
+        return this;
+    }
+    getColumn() {
+        return this._column;
+    }
+    getNumChunks() {
+        return this._column.chunks.length;
+    }
+    getBufferSizeForWholeColumn() {
+        return (Column.StateStruct.structSize +
+            Column.StateStruct.structSize * this.getNumChunks());
+    }
+    isStored() {
+        return this.getStructValue("#dve_is_stored") == 1;
+    }
+    markAsNotStored() {
+        this.setTagValue("#dve_is_stored", 0);
+        return this;
+    }
+    markAsStored() {
+        this.setTagValue("#dve_is_stored", 1);
+        return this;
+    }
+    isPersistent() {
+        return this.getStructValue("#dve_persistent") == 1;
+    }
+    setPersistence(value) {
+        this.setTagValue("#dve_persistent", value ? 1 : 0);
+    }
+    isDirty() {
+        return this.getStructValue("#dve_is_dirty") == 1;
+    }
+    setDirty(value) {
+        this.setTagValue("#dve_is_dirty", value ? 1 : 0);
+    }
+    getLastSaveTimestamp() {
+        return this.getStructValue("#dve_last_save_timestamp");
+    }
+    setLastSaveTimestamp() {
+        return this.setTagValue("#dve_last_save_timestamp", Date.now());
+    }
+    getLastAnalyzerUpdateTimestamp() {
+        return this.getStructValue("#dve_last_analyzer_update_timestamp");
+    }
+    setLastAnalyzerUpdateTimestamp() {
+        return this.setTagValue("#dve_last_analyzer_update_timestamp", Date.now());
+    }
+    hasRichData() {
+        return this.getStructValue("#dve_has_rich_data") == 1;
+    }
+    setRichData(value) {
+        this.setTagValue("#dve_has_rich_data", value ? 1 : 0);
+    }
+    hasEntityData() {
+        return this.getStructValue("#dve_has_entity_data") == 1;
+    }
+    setEntityData(value) {
+        this.setTagValue("#dve_has_entity_data", value ? 1 : 0);
+    }
+}

package/Tools/Data/WorldData/HeightMapTool.d.ts

@@ -0,0 +1,24 @@
+import { Chunk } from "../../../Data/World/Classes/index.js";
+import type { LocationData } from "../../../Math";
+import { LocationBoundTool } from "../../../Tools/Classes/LocationBoundTool.js";
+import { ChunkDataTool } from "./ChunkDataTool.js";
+export declare class HeightMapTool extends LocationBoundTool {
+    static _chunkTool: ChunkDataTool;
+    chunk: {
+        _c: DataView;
+        _y: number;
+        loadInAt: (x: number, y: number, z: number) => false | undefined;
+        loadInAtLocation(location: LocationData): false | undefined;
+        setChunk(chunk: Chunk): void;
+        setY(y: number): any;
+        getMinMax(): number[];
+        hasVoxels(): boolean;
+        isDirty(): boolean;
+        setHasVoxels(hasVoxels: boolean): number | void;
+        setDirty(isDirty: boolean): number | void;
+    };
+    column: {
+        getRelative(location: LocationData): number;
+        getAbsolute: (location: LocationData) => number;
+    };
+}

package/Tools/Data/WorldData/HeightMapTool.js

@@ -0,0 +1,117 @@
+//Data
+import { WorldRegister } from "../../../Data/World/WorldRegister.js";
+import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
+import { WorldBounds } from "../../../Data/World/WorldBounds.js";
+//tools
+import { LocationBoundTool } from "../../../Tools/Classes/LocationBoundTool.js";
+import { ChunkDataTool } from "./ChunkDataTool.js";
+//constants
+import { ChunkStructProperties } from "../../../Data/Constants/Structs/ChunkStructProperties.js";
+import { $2dMooreNeighborhood } from "../../../Math/Constants/CardinalNeighbors.js";
+export class HeightMapTool extends LocationBoundTool {
+    static _chunkTool = new ChunkDataTool();
+    chunk = {
+        _c: new DataView(new ArrayBuffer(0)),
+        _y: 0,
+        loadInAt: (x, y, z) => {
+            WorldRegister.instance.setDimension(this.dimension);
+            const chunk = WorldRegister.instance.chunk.get(x, y, z);
+            if (!chunk)
+                return false;
+            HeightMapTool._chunkTool.setChunk(chunk);
+            this.chunk._c = chunk.chunkState;
+        },
+        loadInAtLocation(location) {
+            WorldRegister.instance.setDimension(location[0]);
+            const chunk = WorldRegister.instance.chunk.get(location[1], location[2], location[3]);
+            if (!chunk)
+                return false;
+            HeightMapTool._chunkTool.setChunk(chunk);
+            this._c = chunk.chunkState;
+        },
+        setChunk(chunk) {
+            HeightMapTool._chunkTool.setChunk(chunk);
+            this._c = chunk.chunkState;
+        },
+        setY(y) {
+            WorldSpaces.voxel.setXYZ(0, y, 0);
+            this._y = WorldSpaces.voxel.getPosition().y;
+            return this;
+        },
+        getMinMax() {
+            HeightMapTool._chunkTool._c = this._c;
+            let min = Infinity;
+            let max = -Infinity;
+            let i = WorldSpaces.chunk.getHeight();
+            while (i--) {
+                if (this.setY(i).hasVoxels() || this.setY(i).isDirty()) {
+                    if (i < min)
+                        min = i;
+                    if (i > max)
+                        max = i;
+                }
+            }
+            return [min, max];
+        },
+        hasVoxels() {
+            HeightMapTool._chunkTool._c = this._c;
+            return (HeightMapTool._chunkTool.getArrayTagValue(ChunkStructProperties.heightMap, this._y) == 1);
+        },
+        isDirty() {
+            HeightMapTool._chunkTool._c = this._c;
+            return (HeightMapTool._chunkTool.getArrayTagValue(ChunkStructProperties.dirtyMap, this._y) == 1);
+        },
+        setHasVoxels(hasVoxels) {
+            HeightMapTool._chunkTool._c = this._c;
+            return HeightMapTool._chunkTool.setArrayTagValue(ChunkStructProperties.heightMap, this._y, hasVoxels ? 1 : 0);
+        },
+        setDirty(isDirty) {
+            HeightMapTool._chunkTool._c = this._c;
+            return HeightMapTool._chunkTool.setArrayTagValue(ChunkStructProperties.dirtyMap, this._y, isDirty ? 1 : 0);
+        },
+    };
+    column = {
+        getRelative(location) {
+            location = [...location];
+            const chunkWidth = WorldSpaces.chunk._bounds.x;
+            const chunkDepth = WorldSpaces.chunk._bounds.z;
+            let maxHeight = -Infinity;
+            const [dimension, x, y, z] = location;
+            for (const check of $2dMooreNeighborhood) {
+                location[1] = check[0] * chunkWidth + x;
+                location[3] = check[1] * chunkDepth + z;
+                const height = this.getAbsolute(location);
+                if (height > maxHeight) {
+                    maxHeight = height;
+                }
+            }
+            return maxHeight;
+        },
+        getAbsolute: (location) => {
+            WorldRegister.instance.setDimension(location[0]);
+            const column = WorldRegister.instance.column.get(location[1], location[2], location[3]);
+            if (!column)
+                return WorldBounds.bounds.MinY;
+            if (column.chunks.length == 0)
+                return WorldBounds.bounds.MinY;
+            let maxHeight = WorldBounds.bounds.MinY;
+            const positon = [location[1], location[2], location[3]];
+            let y = positon[1];
+            for (let i = 0; i < column.chunks.length; i++) {
+                const chunk = column.chunks[i];
+                if (!chunk)
+                    continue;
+                this.chunk.setChunk(chunk);
+                const chunkPOS = y + i * WorldSpaces.chunk._bounds.y;
+                let [chunkMin, chunkMax] = this.chunk.getMinMax();
+                if (Math.abs(chunkMax) == Infinity)
+                    continue;
+                chunkMax = chunkPOS + chunkMax;
+                if (maxHeight < chunkMax) {
+                    maxHeight = chunkMax;
+                }
+            }
+            return maxHeight + 1;
+        },
+    };
+}

package/Tools/Data/WorldData/RegionDataTool.d.ts

@@ -0,0 +1,13 @@
+import { Region } from "../../../Data/World/Classes/Region.js";
+import { EncodedPositionDataTool } from "../../Classes/DataToolBase.js";
+export declare class RegionDataTool extends EncodedPositionDataTool {
+    struct: import("@amodx/binary").RemoteBinaryStruct;
+    _region: Region;
+    loadIn(): boolean;
+    setRegion(region: Region): this;
+    getRegion(): Region;
+    getRegionDataCount(): {
+        chunks: number;
+        columns: number;
+    };
+}

package/Tools/Data/WorldData/RegionDataTool.js

@@ -0,0 +1,39 @@
+//types
+//objects
+import { Region } from "../../../Data/World/Classes/Region.js";
+import { WorldRegister } from "../../../Data/World/WorldRegister.js";
+import { EncodedPositionDataTool } from "../../Classes/DataToolBase.js";
+export class RegionDataTool extends EncodedPositionDataTool {
+    struct = Region.StateStruct;
+    _region = {};
+    loadIn() {
+        WorldRegister.instance.setDimension(this.dimension);
+        const region = WorldRegister.instance.region.get(this.x, this.y, this.z);
+        if (!region)
+            return false;
+        this.struct.setBuffer(region.stateBuffer);
+        this._region = region;
+        this._c = region.stateBuffer;
+        return true;
+    }
+    setRegion(region) {
+        this.struct.setBuffer(region.stateBuffer);
+        this._region = region;
+        this._c = region.stateBuffer;
+        return this;
+    }
+    getRegion() {
+        return this._region;
+    }
+    getRegionDataCount() {
+        const region = this._region;
+        let totalChunks = 0;
+        region.columns.forEach((column) => {
+            totalChunks += column.chunks.length;
+        });
+        return {
+            chunks: totalChunks,
+            columns: region.columns.size,
+        };
+    }
+}

package/Tools/Mesher/MesherTool.d.ts

@@ -0,0 +1,19 @@
+import { ChunkDataTool } from "../Data/WorldData/ChunkDataTool.js";
+import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
+import { TaskTool } from "../Tasks/TasksTool.js";
+export declare class MesherTool extends LocationBoundTool {
+    static _chunkTool: ChunkDataTool;
+    tasks: TaskTool;
+    data: {
+        LOD: number;
+    };
+    setLOD(lod: number): this;
+    clearAll(): void;
+    addChukBuildToQuee(): void;
+    runChunkBuildQueue(): void;
+    buildChunk(): this;
+    buildColumn(onDone?: (data: any) => void): this;
+    removeColumn(): false | this;
+    fillColumn(): this;
+    removeColumnsOutsideRadius(radius: number): void;
+}

package/Tools/Mesher/MesherTool.js

@@ -0,0 +1,52 @@
+import { WorldRegister } from "../../Data/World/WorldRegister.js";
+import { ChunkDataTool } from "../Data/WorldData/ChunkDataTool.js";
+import { Threads } from "@amodx/threads/";
+import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
+import { TaskTool } from "../Tasks/TasksTool.js";
+const parentComm = Threads.parent;
+export class MesherTool extends LocationBoundTool {
+    static _chunkTool = new ChunkDataTool();
+    tasks = new TaskTool();
+    data = {
+        LOD: 1,
+    };
+    setLOD(lod) {
+        this.data.LOD = lod;
+        return this;
+    }
+    clearAll() {
+        parentComm.runTasks("clear-all", []);
+    }
+    addChukBuildToQuee() {
+        this.tasks.build.chunk.queued.add(this.location);
+    }
+    runChunkBuildQueue() {
+        this.tasks.build.chunk.queued.run(() => { });
+    }
+    buildChunk() {
+        this.tasks.build.chunk.deferred.run([this.location, 1], () => { });
+        return this;
+    }
+    buildColumn(onDone) {
+        this.tasks.build.column.deferred.run(this.location, onDone ? onDone : (data) => { });
+        return this;
+    }
+    removeColumn() {
+        WorldRegister.instance.setDimension(this.dimension);
+        const column = WorldRegister.instance.column.get(this.x, this.y, this.z);
+        if (!column)
+            return false;
+        if (column.chunks.length == 0)
+            return false;
+        parentComm.runTasks("remove-column", this.location);
+        return this;
+    }
+    fillColumn() {
+        WorldRegister.instance.setDimension(this.dimension);
+        WorldRegister.instance.column.fill(this.x, this.y, this.z);
+        return this;
+    }
+    removeColumnsOutsideRadius(radius) {
+        parentComm.runTasks("remove-column-outside-radius", [this.location, radius]);
+    }
+}