@divinevoxel/vlox 0.0.4 → 0.0.6

package/Data/World/WorldRegister.js

@@ -1,228 +0,0 @@
-import { DataHooks } from "../../Contexts/Base/DataHooks";
-import { Chunk, Column, Dimension, Region, } from "./Classes/";
-import { DimensionsRegister } from "./DimensionsRegister.js";
-import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
-import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
-import { RegionDataTool } from "../../Tools/Data/WorldData/RegionDataTool.js";
-import { WorldRegisterCache } from "./WorldRegisterCache.js";
-class WorldRegisterDimensions {
-    _register;
-    constructor(_register) {
-        this._register = _register;
-    }
-    add(id) {
-        id = this._register._dimensionRegister.getDimensionStringId(id);
-        const dimesnion = Dimension.CreateNew(id);
-        this._register._dimensions.set(id, dimesnion);
-        return dimesnion;
-    }
-    get(id) {
-        id = this._register._dimensionRegister.getDimensionStringId(id);
-        return this._register._dimensions.get(id);
-    }
-}
-class WorldRegisterRegions {
-    _register;
-    constructor(_register) {
-        this._register = _register;
-    }
-    add(x, y, z, region) {
-        let dimension = this._register.dimensions.get(this._register._currentDimension);
-        if (!dimension) {
-            dimension = this._register.dimensions.add(this._register._currentDimension);
-        }
-        const newRegion = Region.toObject(region);
-        const regionPOS = WorldSpaces.region.getPositionXYZ(x, y, z);
-        this._register.regionTool.setRegion(newRegion);
-        this._register.regionTool.setPositionData(regionPOS.x, regionPOS.y, regionPOS.z);
-        dimension.set(WorldSpaces.region.getKeyXYZ(x, y, z), newRegion);
-        return newRegion;
-    }
-    get(x, y, z) {
-        const dimension = this._register.dimensions.get(this._register._currentDimension);
-        if (!dimension)
-            return false;
-        const region = dimension.get(WorldSpaces.region.getKeyXYZ(x, y, z));
-        if (!region)
-            return false;
-        return region;
-    }
-    remove(x, y, z) {
-        const dimension = this._register.dimensions.get(this._register._currentDimension);
-        if (!dimension)
-            return false;
-        const key = WorldSpaces.region.getKeyXYZ(x, y, z);
-        const region = dimension.get(key);
-        if (!region)
-            return false;
-        dimension.delete(key);
-        return true;
-    }
-}
-class WorldRegisterColumns {
-    _register;
-    constructor(_register) {
-        this._register = _register;
-    }
-    add(x, y, z, column) {
-        let region = this._register.region.get(x, y, z);
-        if (!region) {
-            let newRegion = DataHooks.region.onGetSync.pipe({
-                location: [this._register._currentDimension, x, y, z],
-                region: null,
-            });
-            if (!newRegion.region)
-                return;
-            region = this._register.region.add(x, y, z, newRegion.region);
-            DataHooks.region.onNew.notify([
-                this._register._currentDimension,
-                x,
-                y,
-                z,
-            ]);
-        }
-        const newColumn = Column.toObject([this._register._currentDimension, x, y, z], column);
-        region.columns.set(region.getColumnIndex(x, y, z), newColumn);
-        return newColumn;
-    }
-    get(x, y, z) {
-        const columnKey = this._register.cache.getColumnIndex(x, y, z);
-        let addColumn = false;
-        if (this._register._cacheOn) {
-            const column = this._register.cache.getColumn(columnKey);
-            if (column)
-                return column;
-            addColumn = true;
-        }
-        const region = this._register.region.get(x, y, z);
-        if (!region)
-            return false;
-        const column = region.columns.get(WorldSpaces.column.getIndexXYZ(x, y, z));
-        if (!column)
-            return false;
-        if (addColumn) {
-            this._register.cache.addColumn(columnKey, column);
-        }
-        return column;
-    }
-    remove(x, y, z) {
-        const region = this._register.region.get(x, y, z);
-        if (!region)
-            return false;
-        const index = WorldSpaces.column.getIndexXYZ(x, y, z);
-        const column = region.columns.get(index);
-        if (!column)
-            return false;
-        region.columns.delete(index);
-        return true;
-    }
-    fill(x, y, z) {
-        let column = this.get(x, y, z);
-        if (!column) {
-            column = this.add(x, y, z, Column.CreateNew({}));
-        }
-        const data = {
-            location: [this._register._currentDimension, x, y, z],
-            chunk: null,
-        };
-        const maxChunkIndex = WorldSpaces.column._bounds.y / WorldSpaces.chunk._bounds.y;
-        for (let i = 0; i < maxChunkIndex; i++) {
-            if (!column.chunks[i]) {
-                data.location[1] = y + i * WorldSpaces.chunk._bounds.y;
-                data.chunk = null;
-                const newChunk = DataHooks.chunk.onGetSync.pipe(data);
-                if (!newChunk.chunk)
-                    continue;
-                column.chunks[i] = new Chunk(column, i, newChunk.chunk);
-            }
-        }
-        DataHooks.column.onNew.notify([this._register._currentDimension, x, y, z]);
-    }
-}
-class WorldRegisterChunks {
-    _register;
-    constructor(_register) {
-        this._register = _register;
-    }
-    add(x, y, z, chunk) {
-        let column = this._register.column.get(x, y, z);
-        if (!column) {
-            let newColumn = DataHooks.column.onGetSync.pipe({
-                location: [this._register._currentDimension, x, y, z],
-                column: null,
-            });
-            if (!newColumn.column)
-                return;
-            column = this._register.column.add(x, y, z, newColumn.column);
-            DataHooks.column.onNew.notify([
-                this._register._currentDimension,
-                x,
-                y,
-                z,
-            ]);
-        }
-        if (!column)
-            return;
-        const index = WorldSpaces.chunk.getIndexXYZ(x, y, z);
-        const newChunk = Chunk.toObject(column, index, chunk);
-        column.chunks[index] = newChunk;
-        DataHooks.chunk.onNew.notify([this._register._currentDimension, x, y, z]);
-        return newChunk;
-    }
-    get(x, y, z) {
-        const chunkKey = this._register.cache.getChunkIndex(x, y, z);
-        let addChunk = false;
-        if (this._register._cacheOn) {
-            const chunk = this._register.cache.getChunk(chunkKey);
-            if (chunk)
-                return chunk;
-            addChunk = true;
-        }
-        const column = this._register.column.get(x, y, z);
-        if (!column)
-            return false;
-        const chunk = column.chunks[WorldSpaces.chunk.getIndexXYZ(x, y, z)];
-        if (!chunk)
-            return;
-        if (addChunk) {
-            this._register.cache.addChunk(chunkKey, chunk);
-        }
-        return chunk;
-    }
-    remove(x, y, z) {
-        const column = this._register.column.get(x, y, z);
-        if (!column)
-            return false;
-        const index = WorldSpaces.chunk.getIndexXYZ(x, y, z);
-        const chunk = column.chunks[index];
-        if (!chunk)
-            return false;
-        delete column.chunks[index];
-        return true;
-    }
-}
-export class WorldRegister {
-    static instance;
-    columnTool = new ColumnDataTool();
-    regionTool = new RegionDataTool();
-    _dimensions = new Map();
-    _cacheOn = false;
-    _dimensionRegister = new DimensionsRegister();
-    constructor() {
-        if (WorldRegister.instance)
-            return WorldRegister.instance;
-        WorldRegister.instance = this;
-    }
-    cache = new WorldRegisterCache();
-    dimensions = new WorldRegisterDimensions(this);
-    region = new WorldRegisterRegions(this);
-    column = new WorldRegisterColumns(this);
-    chunk = new WorldRegisterChunks(this);
-    _currentDimension = "main";
-    setDimension(dimension) {
-        this._currentDimension = dimension;
-    }
-    clearAll() {
-        this._dimensions.clear();
-    }
-}

package/Data/World/WorldRegisterCache.d.ts

@@ -1,23 +0,0 @@
-import { Chunk, Column } from "./Classes/index.js";
-import { Vector3Like } from "@amodx/math";
-export declare class WorldRegisterCache {
-    _cacheOn: boolean;
-    _chunkCache: Chunk[];
-    _columnCache: Column[];
-    worldSize: Vector3Like;
-    chunkSize: Vector3Like;
-    chunkSizePower: Vector3Like;
-    columnSize: Vector3Like;
-    columnSizePower: Vector3Like;
-    constructor();
-    symcSettings(): void;
-    enable(): void;
-    disable(): void;
-    addChunk(key: number, data: Chunk): void;
-    addColumn(key: number, data: Column): void;
-    getChunk(key: number): Chunk;
-    getColumn(key: number): Column;
-    getChunkIndex(x: number, y: number, z: number): number;
-    getColumnIndex(x: number, y: number, z: number): number;
-    clear(): void;
-}

package/Data/World/WorldRegisterCache.js

@@ -1,68 +0,0 @@
-import { WorldBounds } from "../../Data/World/WorldBounds.js";
-import { Vector3Like } from "@amodx/math";
-import { EngineSettings } from "../../Settings/EngineSettings.js";
-export class WorldRegisterCache {
-    _cacheOn = false;
-    _chunkCache = [];
-    _columnCache = [];
-    worldSize = Vector3Like.Create();
-    chunkSize = Vector3Like.Create();
-    chunkSizePower = Vector3Like.Create();
-    columnSize = Vector3Like.Create();
-    columnSizePower = Vector3Like.Create();
-    constructor() {
-        this.symcSettings();
-        EngineSettings.observers.updated.subscribe("WorldRegisterCache", () => {
-            this.symcSettings();
-        });
-    }
-    symcSettings() {
-        const size = WorldBounds.getWorldDimensions();
-        this.chunkSize.x = 2 ** EngineSettings.settings.chunks.chunkXPow2;
-        this.chunkSize.y = 2 ** EngineSettings.settings.chunks.chunkYPow2;
-        this.chunkSize.z = 2 ** EngineSettings.settings.chunks.chunkZPow2;
-        this.chunkSizePower = Vector3Like.Create(EngineSettings.settings.chunks.chunkXPow2 - 1, EngineSettings.settings.chunks.chunkYPow2 - 1, EngineSettings.settings.chunks.chunkZPow2 - 1);
-        this.columnSizePower = Vector3Like.Create(EngineSettings.settings.chunks.chunkXPow2 - 1, EngineSettings.settings.regions.regionYPow2 - 1, EngineSettings.settings.chunks.chunkZPow2 - 1);
-        this.worldSize = Vector3Like.Create(size.width, size.height, size.depth);
-        this.columnSize.x = 2 ** EngineSettings.settings.chunks.chunkXPow2;
-        this.columnSize.y = 2 ** EngineSettings.settings.regions.regionYPow2;
-        this.columnSize.z = 2 ** EngineSettings.settings.chunks.chunkZPow2;
-    }
-    enable() {
-        this._cacheOn = true;
-        this._chunkCache.length = 0;
-        this._columnCache.length = 0;
-    }
-    disable() {
-        this._cacheOn = false;
-        this._chunkCache.length = 0;
-        this._columnCache.length = 0;
-    }
-    addChunk(key, data) {
-        this._chunkCache[key] = data;
-    }
-    addColumn(key, data) {
-        this._columnCache[key] = data;
-    }
-    getChunk(key) {
-        return this._chunkCache[key];
-    }
-    getColumn(key) {
-        return this._columnCache[key];
-    }
-    getChunkIndex(x, y, z) {
-        return Vector3Like.HashXYZ(((x >> this.chunkSizePower.x) << this.chunkSizePower.x) /
-            this.chunkSize.x, ((y >> this.chunkSizePower.y) << this.chunkSizePower.y) /
-            this.chunkSize.y, ((z >> this.chunkSizePower.z) << this.chunkSizePower.z) / this.chunkSize.z);
-    }
-    getColumnIndex(x, y, z) {
-        return Vector3Like.HashXYZ(((x >> this.columnSizePower.x) << this.columnSizePower.x) /
-            this.columnSize.x, ((y >> this.columnSizePower.y) << this.columnSizePower.y) /
-            this.columnSize.y, ((z >> this.columnSizePower.z) << this.columnSizePower.z) /
-            this.columnSize.z);
-    }
-    clear() {
-        this._chunkCache.length = 0;
-        this._columnCache.length = 0;
-    }
-}

package/Data/World/WorldSpaces.d.ts

@@ -1,4 +0,0 @@
-import { VoxelSpaces } from "../../Math/Spaces/VoxelSpaces.js";
-import type { EngineSettingsData } from "../../Settings/EngineSettings.types.js";
-export declare const WorldSpaces: VoxelSpaces;
-export declare function InitWorldSpaces(settings: EngineSettingsData): void;

package/Data/World/WorldSpaces.js

@@ -1,23 +0,0 @@
-//types
-import { VoxelSpaces } from "../../Math/Spaces/VoxelSpaces.js";
-//Objects
-export const WorldSpaces = new VoxelSpaces();
-export function InitWorldSpaces(settings) {
-    WorldSpaces.setDimensions({
-        regions: {
-            x: settings.regions.regionXPow2,
-            y: settings.regions.regionYPow2,
-            z: settings.regions.regionZPow2,
-        },
-        columns: {
-            x: settings.chunks.chunkXPow2,
-            y: settings.regions.regionYPow2,
-            z: settings.chunks.chunkZPow2,
-        },
-        chunks: {
-            x: settings.chunks.chunkXPow2,
-            y: settings.chunks.chunkYPow2,
-            z: settings.chunks.chunkZPow2,
-        },
-    });
-}

package/Math/Classes/BoundingBox.d.ts

@@ -1,27 +0,0 @@
-import { Plane } from "./Plane.js";
-export type BoundingBoxData = {
-    upPlane: Plane;
-    downPlane: Plane;
-    northPlane: Plane;
-    southPlane: Plane;
-    eastPlane: Plane;
-    westPlane: Plane;
-};
-export declare class BoundingBox {
-    upPlane: Plane;
-    downPlane: Plane;
-    northPlane: Plane;
-    southPlane: Plane;
-    eastPlane: Plane;
-    westPlane: Plane;
-    bounds: {
-        minX: number;
-        maxX: number;
-        minZ: number;
-        maxZ: number;
-        minY: number;
-        maxY: number;
-    };
-    constructor(data: BoundingBoxData);
-    _doMinMaxCheck(plane: Plane): void;
-}

package/Math/Classes/BoundingBox.js

@@ -1,44 +0,0 @@
-export class BoundingBox {
-    upPlane;
-    downPlane;
-    northPlane;
-    southPlane;
-    eastPlane;
-    westPlane;
-    bounds = {
-        minX: Infinity,
-        maxX: -Infinity,
-        minZ: Infinity,
-        maxZ: -Infinity,
-        minY: Infinity,
-        maxY: -Infinity,
-    };
-    constructor(data) {
-        this.upPlane = data.upPlane;
-        this._doMinMaxCheck(this.upPlane);
-        this.downPlane = data.downPlane;
-        this._doMinMaxCheck(this.downPlane);
-        this.northPlane = data.northPlane;
-        this._doMinMaxCheck(this.northPlane);
-        this.southPlane = data.southPlane;
-        this._doMinMaxCheck(this.southPlane);
-        this.eastPlane = data.eastPlane;
-        this._doMinMaxCheck(this.eastPlane);
-        this.westPlane = data.westPlane;
-        this._doMinMaxCheck(this.westPlane);
-    }
-    _doMinMaxCheck(plane) {
-        if (plane.minX <= this.bounds.minX)
-            this.bounds.minX = plane.minX;
-        if (plane.maxX >= this.bounds.maxX)
-            this.bounds.maxX = plane.maxX;
-        if (plane.minY <= this.bounds.minY)
-            this.bounds.minY = plane.minY;
-        if (plane.maxY >= this.bounds.maxY)
-            this.bounds.maxY = plane.maxY;
-        if (plane.minZ <= this.bounds.minZ)
-            this.bounds.minZ = plane.minZ;
-        if (plane.maxZ >= this.bounds.maxZ)
-            this.bounds.maxZ = plane.maxZ;
-    }
-}

package/Math/Classes/MatrixArray.d.ts

@@ -1,66 +0,0 @@
-export declare class MatrixProperty {
-    data: {
-        getX(): number;
-        getY(): number;
-        getZ(): number;
-        getW(): number;
-        setX(value: number): void;
-        setY(value: number): void;
-        setZ(value: number): void;
-        setW(value: number): void;
-    };
-    constructor(data: {
-        getX(): number;
-        getY(): number;
-        getZ(): number;
-        getW(): number;
-        setX(value: number): void;
-        setY(value: number): void;
-        setZ(value: number): void;
-        setW(value: number): void;
-    });
-    get x(): number;
-    get y(): number;
-    get z(): number;
-    get w(): number;
-    set x(value: number);
-    set y(value: number);
-    set z(value: number);
-    set w(value: number);
-    set(x: number, y: number, z: number): void;
-    setAll(value: number): void;
-}
-export declare class MatrixArray {
-    index: number;
-    static readonly MATRIX_INDEXES: {
-        POSITION_X: number;
-        POSITION_Y: number;
-        POSITION_Z: number;
-        SCALE_X: number;
-        SCALE_Y: number;
-        SCALE_Z: number;
-        SCALE_W: number;
-    };
-    static buildProperties(matrix: MatrixArray): void;
-    trueIndex: number;
-    matricies: Float32Array;
-    constructor(startData: number | MatrixArray, index?: number);
-    rows: [
-        row1: MatrixProperty,
-        row2: MatrixProperty,
-        row3: MatrixProperty,
-        row4: MatrixProperty
-    ];
-    cols: [
-        col1: MatrixProperty,
-        col2: MatrixProperty,
-        col3: MatrixProperty,
-        col4: MatrixProperty
-    ];
-    scale: MatrixProperty;
-    position: MatrixProperty;
-    setMatriciesIndex(index: number): this;
-    copy(matrix: MatrixArray): void;
-    copyIndex(): number[];
-    multiply(matirx: MatrixArray): void;
-}