@divinevoxel/vlox 0.0.0

package/Data/World/Classes/Chunk.js

@@ -0,0 +1,46 @@
+import { RemoteBinaryStruct } from "@amodx/binary/";
+import { WorldSpaces } from "../../../Data/World/WorldSpaces.js";
+export class Chunk {
+    static CreateNew() {
+        const stateBuffer = new SharedArrayBuffer(Chunk.StateStruct.structSize);
+        Chunk.StateStruct.setBuffer(stateBuffer);
+        const voxelSize = WorldSpaces.chunk.getVolume();
+        const idsBuffers = new SharedArrayBuffer(voxelSize * 2);
+        const ids = new Uint16Array(idsBuffers);
+        const lightBuffers = new SharedArrayBuffer(voxelSize * 2);
+        const light = new Uint16Array(lightBuffers);
+        const stateBuffers = new SharedArrayBuffer(voxelSize * 2);
+        const state = new Uint16Array(stateBuffers);
+        const modBuffer = new SharedArrayBuffer(voxelSize * 2);
+        const mod = new Uint16Array(modBuffer);
+        const secondaryBuffers = new SharedArrayBuffer(voxelSize * 2);
+        const secondary = new Uint16Array(secondaryBuffers);
+        return {
+            stateBuffer,
+            ids,
+            light,
+            state,
+            secondary,
+            mod,
+        };
+    }
+    static toObject(data) {
+        return new Chunk(data);
+    }
+    static StateStruct = new RemoteBinaryStruct("chunk-tags");
+    chunkState;
+    constructor(data) {
+        this.chunkState = new DataView(data.stateBuffer);
+        return Object.assign(this, data);
+    }
+    serialize() {
+        return {
+            stateBuffer: this.stateBuffer,
+            ids: this.ids,
+            light: this.light,
+            secondary: this.secondary,
+            state: this.state,
+            mod: this.mod,
+        };
+    }
+}

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

@@ -0,0 +1,17 @@
+import { RemoteBinaryStruct } from "@amodx/binary/";
+import { Chunk, ChunkData } from "./Chunk.js";
+export interface ColumnData {
+    stateBuffer: ArrayBuffer;
+    chunks: ChunkData[];
+}
+export interface Column extends ColumnData {
+}
+export declare class Column {
+    static StateStruct: RemoteBinaryStruct;
+    static CreateNew(data: Partial<ColumnData>): ColumnData;
+    static toObject(data: ColumnData): Column;
+    chunks: Chunk[];
+    columnState: DataView;
+    constructor(data: ColumnData);
+    toJSON(): ColumnData;
+}

package/Data/World/Classes/Column.js

@@ -0,0 +1,31 @@
+import { RemoteBinaryStruct } from "@amodx/binary/";
+import { Chunk } from "./Chunk.js";
+export class Column {
+    static StateStruct = new RemoteBinaryStruct("column-tags");
+    static CreateNew(data) {
+        const stateBuffer = new SharedArrayBuffer(Column.StateStruct.structSize);
+        Column.StateStruct.setBuffer(stateBuffer);
+        Column.StateStruct.setProperty("#dve_is_stored", 0);
+        return {
+            stateBuffer,
+            chunks: [],
+            ...data,
+        };
+    }
+    static toObject(data) {
+        return new Column(data);
+    }
+    chunks;
+    columnState;
+    constructor(data) {
+        this.columnState = new DataView(data.stateBuffer);
+        this.stateBuffer = data.stateBuffer;
+        this.chunks = data.chunks.map((_) => _ && new Chunk(_));
+    }
+    toJSON() {
+        return {
+            stateBuffer: this.stateBuffer,
+            chunks: this.chunks.map((_) => _.serialize()),
+        };
+    }
+}

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

@@ -0,0 +1,14 @@
+import { Region } from "./Region";
+export interface DimensionData {
+    id: string;
+    regions: Map<string, Region>;
+}
+export interface Dimension extends DimensionData {
+}
+export declare class Dimension {
+    static CreateNew(id: string): Dimension;
+    constructor(data: DimensionData);
+    set(regionId: string, region: Region): void;
+    delete(regionId: string): void;
+    get(regionId: string): Region | undefined;
+}

package/Data/World/Classes/Dimension.js

@@ -0,0 +1,20 @@
+export class Dimension {
+    static CreateNew(id) {
+        return new Dimension({
+            id,
+            regions: new Map(),
+        });
+    }
+    constructor(data) {
+        return Object.assign(this, data);
+    }
+    set(regionId, region) {
+        this.regions.set(regionId, region);
+    }
+    delete(regionId) {
+        this.regions.delete(regionId);
+    }
+    get(regionId) {
+        return this.regions.get(regionId);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { RemoteBinaryStruct } from "@amodx/binary/";
+import { Column } from "./Column";
+import { Vec3Array } from "@amodx/math";
+export interface RegionData {
+    stateBuffer: ArrayBuffer;
+    columns: Record<number, Column>;
+}
+export interface Region {
+}
+export declare class Region {
+    static CreateNew(): RegionData;
+    static toObject(data: RegionData): Region;
+    static StateStruct: RemoteBinaryStruct;
+    stateBuffer: ArrayBuffer;
+    columns: Map<number, Column>;
+    regionState: DataView;
+    constructor(data: RegionData);
+    getColumns(): Generator<Column>;
+    getPosition(): Vec3Array;
+    getColumnIndex(x: number, y: number, z: number): number;
+    getColumnPosition(index: number): Vec3Array;
+    toJSON(): RegionData;
+}

package/Data/World/Classes/Region.js

@@ -0,0 +1,67 @@
+import { RemoteBinaryStruct } from "@amodx/binary/";
+import { WorldDataStructProperties } from "../../Constants/Structs/WorldDataStructProperties";
+import { WorldSpaces } from "../../../Data/World/WorldSpaces";
+export class Region {
+    static CreateNew() {
+        const stateBuffer = new SharedArrayBuffer(Region.StateStruct.structSize);
+        Region.StateStruct.setBuffer(stateBuffer);
+        return {
+            stateBuffer,
+            columns: {},
+        };
+    }
+    static toObject(data) {
+        return new Region(data);
+    }
+    static StateStruct = new RemoteBinaryStruct("region-tags");
+    stateBuffer;
+    columns = new Map();
+    regionState;
+    constructor(data) {
+        this.regionState = new DataView(data.stateBuffer);
+        this.stateBuffer = data.stateBuffer;
+        const keys = Object.keys(data.columns);
+        for (const key in keys) {
+            data.columns[Number(key)] &&
+                this.columns.set(Number(key), data.columns[Number(key)]);
+        }
+    }
+    *getColumns() {
+        for (const [key, column] of this.columns) {
+            yield column;
+        }
+    }
+    getPosition() {
+        Region.StateStruct.setBuffer(this.stateBuffer);
+        return [
+            Region.StateStruct.getProperty(WorldDataStructProperties.positionX),
+            Region.StateStruct.getProperty(WorldDataStructProperties.positionY),
+            Region.StateStruct.getProperty(WorldDataStructProperties.positionZ),
+        ];
+    }
+    getColumnIndex(x, y, z) {
+        const position = this.getPosition();
+        WorldSpaces.region.setXYZ(...position);
+        return WorldSpaces.column.getIndexXYZ(x, y, z);
+    }
+    getColumnPosition(index) {
+        const position = this.getPosition();
+        WorldSpaces.region.setXYZ(...position);
+        const columnPos = WorldSpaces.column.getPositionFromIndex(index);
+        return [
+            position[0] + columnPos.x,
+            position[1] + columnPos.y,
+            position[2] + columnPos.z,
+        ];
+    }
+    toJSON() {
+        const columns = {};
+        for (const [key, col] of this.columns) {
+            columns[key] = col;
+        }
+        return {
+            stateBuffer: this.stateBuffer,
+            columns: columns,
+        };
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from "./Chunk.js";
+export * from "./Column.js";
+export * from "./Dimension.js";
+export * from "./Region.js";

package/Data/World/Classes/index.js

@@ -0,0 +1,4 @@
+export * from "./Chunk.js";
+export * from "./Column.js";
+export * from "./Dimension.js";
+export * from "./Region.js";

package/Data/World/DimensionsRegister.d.ts

@@ -0,0 +1,14 @@
+import { DimensionData, DimensionOptions } from "../Types/DimensionData.types.js";
+export declare class DimensionsRegister {
+    static instance: DimensionsRegister;
+    _count: number;
+    dimensionRecord: Record<string, number>;
+    dimensionMap: Record<number, string>;
+    __defaultDimensionOptions: DimensionOptions;
+    _dimensions: Record<string, DimensionData>;
+    constructor();
+    registerDimension(id: string, option: DimensionOptions): void;
+    getDimension(id: string | number): DimensionData;
+    getDimensionStringId(id: string | number): string;
+    getDimensionNumericId(id: string | number): number;
+}

package/Data/World/DimensionsRegister.js

@@ -0,0 +1,53 @@
+import { DataHooks } from "../DataHooks.js";
+import { WorldRegister } from "./WorldRegister.js";
+export class DimensionsRegister {
+    static instance;
+    _count = 1;
+    dimensionRecord = {
+        main: 0,
+    };
+    dimensionMap = {
+        0: "main",
+    };
+    __defaultDimensionOptions = {
+        liquidFlowSpeed: 0.1,
+        magmaFlowSpeed: 0.1,
+        sunLight: true,
+    };
+    _dimensions = {};
+    constructor() {
+        if (DimensionsRegister.instance)
+            return DimensionsRegister.instance;
+        DimensionsRegister.instance = this;
+    }
+    registerDimension(id, option) {
+        if (!option) {
+            option = this.__defaultDimensionOptions;
+        }
+        const dimensionData = {
+            id: id,
+            options: option,
+        };
+        this._dimensions[id] = dimensionData;
+        this.dimensionRecord[id] = this._count;
+        this.dimensionMap[this._count] = id;
+        DataHooks.dimension.onRegisterDimension.pipe(dimensionData);
+        WorldRegister.instance.dimensions.add(id);
+    }
+    getDimension(id) {
+        id = this.getDimensionStringId(id);
+        return this._dimensions[id];
+    }
+    getDimensionStringId(id) {
+        if (typeof id == "number") {
+            return this.dimensionMap[id];
+        }
+        return id;
+    }
+    getDimensionNumericId(id) {
+        if (typeof id == "string") {
+            return this.dimensionRecord[id];
+        }
+        return id;
+    }
+}

package/Data/World/WorldBounds.d.ts

@@ -0,0 +1,19 @@
+export declare class WorldBounds {
+    static bounds: {
+        MinZ: number;
+        MaxZ: number;
+        MinX: number;
+        MaxX: number;
+        MinY: number;
+        MaxY: number;
+    };
+    static setWorldBounds(minX: number, maxX: number, minZ: number, maxZ: number, minY: number, maxY: number): void;
+    static getWorldWidth(): number;
+    static getWorldDepth(): number;
+    static getWorldHeightY(): number;
+    static getWorldDimensions(): {
+        width: number;
+        depth: number;
+        height: number;
+    };
+}

package/Data/World/WorldBounds.js

@@ -0,0 +1,34 @@
+export class WorldBounds {
+    static bounds = {
+        MinZ: -Number.MAX_SAFE_INTEGER,
+        MaxZ: Number.MAX_SAFE_INTEGER,
+        MinX: -Number.MAX_SAFE_INTEGER,
+        MaxX: Number.MAX_SAFE_INTEGER,
+        MinY: 0,
+        MaxY: 256,
+    };
+    static setWorldBounds(minX, maxX, minZ, maxZ, minY, maxY) {
+        this.bounds.MinX = minX;
+        this.bounds.MaxX = maxX;
+        this.bounds.MinX = minZ;
+        this.bounds.MaxZ = maxZ;
+        this.bounds.MinY = minY;
+        this.bounds.MaxY = maxY;
+    }
+    static getWorldWidth() {
+        return this.bounds.MaxX - this.bounds.MinX;
+    }
+    static getWorldDepth() {
+        return this.bounds.MaxZ - this.bounds.MinZ;
+    }
+    static getWorldHeightY() {
+        return this.bounds.MaxY - this.bounds.MinY;
+    }
+    static getWorldDimensions() {
+        return {
+            width: this.getWorldWidth(),
+            depth: this.getWorldDepth(),
+            height: this.getWorldHeightY(),
+        };
+    }
+}

package/Data/World/WorldPainter.d.ts

@@ -0,0 +1,11 @@
+import { DataTool } from "../../Tools/Data/DataTool.js";
+import { AddVoxelData } from "Data/Types/WorldData.types.js";
+export declare class WorldPainter {
+    static instance: WorldPainter;
+    constructor();
+    dataTool: DataTool;
+    data: AddVoxelData;
+    dimenion: string;
+    paintVoxel(x: number, y: number, z: number): false | undefined;
+    eraseVoxel(x: number, y: number, z: number): void;
+}

package/Data/World/WorldPainter.js

@@ -0,0 +1,71 @@
+import { WorldRegister } from "./WorldRegister.js";
+import { DataHooks } from "../DataHooks.js";
+import { DataTool } from "../../Tools/Data/DataTool.js";
+import { VoxelPalette } from "../../Data/Voxel/VoxelPalette.js";
+export class WorldPainter {
+    static instance;
+    constructor() {
+        if (WorldPainter.instance)
+            return WorldPainter.instance;
+        WorldPainter.instance = this;
+    }
+    dataTool = new DataTool();
+    data;
+    dimenion = "main";
+    paintVoxel(x, y, z) {
+        let chunk = WorldRegister.instance.chunk.get(x, y, z);
+        if (!chunk) {
+            let buffer = DataHooks.chunk.onGetSync.pipe({
+                location: [this.dimenion, x, y, z],
+                chunk: null,
+            });
+            if (!buffer.chunk)
+                return;
+            chunk = WorldRegister.instance.chunk.add(x, y, z, buffer.chunk);
+        }
+        if (!this.dataTool.setDimension(this.dimenion).setXYZ(x, y, z).loadIn())
+            return;
+        const id = VoxelPalette.ids.getNumberId(this.data.id);
+        if (id < 0)
+            return false;
+        this.dataTool.setId(id);
+        this.dataTool.setShapeState(this.data.shapeState ? this.data.shapeState : 0);
+        if (this.dataTool.getSubstnaceData().isLiquid()) {
+            this.dataTool.setLevel(7);
+        }
+        this.dataTool.setMod(this.data.mod);
+        if (this.data.secondaryVoxelId &&
+            this.data.secondaryVoxelId != "dve_air" &&
+            this.dataTool.canHaveSecondaryVoxel()) {
+            const vid = VoxelPalette.ids.getNumberId(this.data.secondaryVoxelId);
+            if (vid > 0) {
+                this.dataTool.setSecondary(true);
+                this.dataTool.setId(vid);
+                this.dataTool.setSecondary(false);
+            }
+        }
+        if (this.dataTool.isLightSource() && this.dataTool.getLightSourceValue()) {
+            this.dataTool.setLight(this.dataTool.getLightSourceValue());
+        }
+        if (this.dataTool.isRich()) {
+            DataHooks.paint.onRichVoxelPaint.notify([
+                this.dataTool.getStringId(),
+                [this.dimenion, x, y, z],
+            ]);
+        }
+        this.dataTool.commit(1);
+    }
+    eraseVoxel(x, y, z) {
+        this.dataTool.setDimension(this.dimenion);
+        if (!this.dataTool.loadInAt(x, y, z))
+            return;
+        if (!this.dataTool.isRenderable())
+            return;
+        this.dataTool.data.raw[0] = 0;
+        this.dataTool.data.raw[1] = 0;
+        this.dataTool.data.raw[2] = 0;
+        this.dataTool.data.raw[3] = 0;
+        this.dataTool.data.raw[4] = 0;
+        this.dataTool.commit(2);
+    }
+}

package/Data/World/WorldRegister.d.ts

@@ -0,0 +1,51 @@
+import { Chunk, ChunkData, Column, ColumnData, Dimension, Region, RegionData } from "./Classes/";
+import { DimensionsRegister } from "./DimensionsRegister.js";
+import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
+import { RegionDataTool } from "../../Tools/Data/WorldData/RegionDataTool.js";
+import { WorldRegisterCache } from "./WorldRegisterCache.js";
+declare class WorldRegisterDimensions {
+    private _register;
+    constructor(_register: WorldRegister);
+    add(id: number | string): Dimension;
+    get(id: number | string): Dimension | undefined;
+}
+declare class WorldRegisterRegions {
+    private _register;
+    constructor(_register: WorldRegister);
+    add(x: number, y: number, z: number, region: RegionData): Region;
+    get(x: number, y: number, z: number): false | Region;
+    remove(x: number, y: number, z: number): boolean;
+}
+declare class WorldRegisterColumns {
+    private _register;
+    constructor(_register: WorldRegister);
+    add(x: number, y: number, z: number, column: ColumnData): Column | undefined;
+    get(x: number, y: number, z: number): false | Column;
+    remove(x: number, y: number, z: number): boolean;
+    fill(x: number, y: number, z: number): void;
+}
+declare class WorldRegisterChunks {
+    private _register;
+    constructor(_register: WorldRegister);
+    add(x: number, y: number, z: number, chunk: ChunkData): Chunk | undefined;
+    get(x: number, y: number, z: number): false | Chunk | undefined;
+    remove(x: number, y: number, z: number): boolean;
+}
+export declare class WorldRegister {
+    static instance: WorldRegister;
+    columnTool: ColumnDataTool;
+    regionTool: RegionDataTool;
+    _dimensions: Map<string, Dimension>;
+    _cacheOn: boolean;
+    _dimensionRegister: DimensionsRegister;
+    constructor();
+    cache: WorldRegisterCache;
+    dimensions: WorldRegisterDimensions;
+    region: WorldRegisterRegions;
+    column: WorldRegisterColumns;
+    chunk: WorldRegisterChunks;
+    _currentDimension: string;
+    setDimension(dimension: string): void;
+    clearAll(): void;
+}
+export {};