@divinevoxel/vlox 0.0.4 → 0.0.6

package/World/WorldSpaces.d.ts

@@ -0,0 +1,55 @@
+import { Vec3Array, Vector3Like } from "@amodx/math";
+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 inBounds(x: number, y: number, z: number): boolean;
+    static getWorldWidth(): number;
+    static getWorldDepth(): number;
+    static getWorldHeightY(): number;
+    static getWorldDimensions(): {
+        width: number;
+        depth: number;
+        height: number;
+    };
+}
+declare class SectorSpace {
+    static power2Axes: Vector3Like;
+    static bounds: Vector3Like;
+    static volumne: number;
+    static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
+    static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
+}
+declare class SectionSpace {
+    static power2Axes: Vector3Like;
+    static bounds: Vector3Like;
+    static volumne: number;
+    static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
+    static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
+    static getIndex(x: number, y: number, z: number): number;
+}
+declare class VoxelSpace {
+    static bounds: Vector3Like;
+    static getPosition(x: number, y: number, z: number, refPosition?: Vector3Like): Vector3Like;
+    static getPositionVec3Array(x: number, y: number, z: number, refPosition?: Vec3Array): Vec3Array;
+    static getIndex(x: number, y: number, z: number): number;
+}
+declare class Hash {
+    static hashVec3(vector3: Vector3Like): string;
+    static hashVec3Array(vector3: Vec3Array): string;
+    static hashXYZ(x: number, y: number, z: number): string;
+}
+export declare class WorldSpaces {
+    static hash: typeof Hash;
+    static world: typeof WorldBounds;
+    static sector: typeof SectorSpace;
+    static section: typeof SectionSpace;
+    static voxel: typeof VoxelSpace;
+}
+export {};

package/World/WorldSpaces.js

@@ -0,0 +1,147 @@
+//types
+import { EngineSettings } from "../Settings/EngineSettings.js";
+import { Vector3Like } from "@amodx/math";
+import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, } from "../Math/Indexing.js";
+const tempPosition = Vector3Like.Create();
+const tempPosition2 = Vector3Like.Create();
+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 inBounds(x, y, z) {
+        if (x < this.bounds.MinX)
+            return false;
+        if (y < this.bounds.MinY)
+            return false;
+        if (z < this.bounds.MinZ)
+            return false;
+        if (x > this.bounds.MaxX)
+            return false;
+        if (y > this.bounds.MaxY)
+            return false;
+        if (z > this.bounds.MaxZ)
+            return false;
+        return true;
+    }
+    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(),
+        };
+    }
+}
+class SectorSpace {
+    static power2Axes = Vector3Like.Create();
+    static bounds = Vector3Like.Create();
+    static volumne = 0;
+    static getPosition(x, y, z, refPosition = Vector3Like.Create()) {
+        CubeHashVec3(x, y, z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, refPosition);
+        return refPosition;
+    }
+    static getPositionVec3Array(x, y, z, refPosition = [0, 0, 0]) {
+        CubeHashVec3Array(x, y, z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, refPosition);
+        return refPosition;
+    }
+}
+class SectionSpace {
+    static power2Axes = Vector3Like.Create();
+    static bounds = Vector3Like.Create();
+    static volumne = 0;
+    static getPosition(x, y, z, refPosition = Vector3Like.Create()) {
+        CubeHashVec3(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, refPosition);
+        return refPosition;
+    }
+    static getPositionVec3Array(x, y, z, refPosition = [0, 0, 0]) {
+        CubeHashVec3Array(x, y, z, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z, refPosition);
+        return refPosition;
+    }
+    static getIndex(x, y, z) {
+        SectionSpace.getPosition(x, y, z, tempPosition);
+        SectorSpace.getPosition(x, y, z, tempPosition2);
+        return (tempPosition.y - tempPosition2.y) / SectionSpace.bounds.y;
+    }
+}
+class VoxelSpace {
+    static bounds = Vector3Like.Create();
+    static getPosition(x, y, z, refPosition = Vector3Like.Create()) {
+        CubeHashVec3(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, refPosition);
+        refPosition.x = x - refPosition.x;
+        refPosition.y = y - refPosition.y;
+        refPosition.z = z - refPosition.z;
+        return refPosition;
+    }
+    static getPositionVec3Array(x, y, z, refPosition = [0, 0, 0]) {
+        CubeHashVec3Array(x, y, z, SectionSpace.power2Axes.x, SectionSpace.power2Axes.y, SectionSpace.power2Axes.z, refPosition);
+        refPosition[0] = x - refPosition[0];
+        refPosition[1] = y - refPosition[1];
+        refPosition[2] = z - refPosition[2];
+        return refPosition;
+    }
+    static getIndex(x, y, z) {
+        const position = this.getPosition(x, y, z, tempPosition);
+        return GetYXZOrderArrayIndex(position.x, position.y, position.z, SectionSpace.bounds.x, SectionSpace.bounds.y, SectionSpace.bounds.z);
+    }
+}
+class Hash {
+    static hashVec3(vector3) {
+        return `${vector3.x}-${vector3.y}-${vector3.z}`;
+    }
+    static hashVec3Array(vector3) {
+        return `${vector3[0]}-${vector3[1]}-${vector3[2]}`;
+    }
+    static hashXYZ(x, y, z) {
+        return `${x}-${y}-${z}`;
+    }
+}
+export class WorldSpaces {
+    static hash = Hash;
+    static world = WorldBounds;
+    static sector = SectorSpace;
+    static section = SectionSpace;
+    static voxel = VoxelSpace;
+}
+EngineSettings.addEventListener("synced", (event) => {
+    const { settings } = event.detail.settings;
+    WorldBounds.setWorldBounds(settings.world.minX, settings.world.maxX, settings.world.minZ, settings.world.maxZ, settings.world.minY, settings.world.maxY);
+    SectorSpace.power2Axes.x = settings.sectors.sectorXPow2;
+    SectorSpace.power2Axes.y = settings.sectors.sectorYPow2;
+    SectorSpace.power2Axes.z = settings.sectors.sectorZPow2;
+    SectorSpace.bounds.x = 1 << SectorSpace.power2Axes.x;
+    SectorSpace.bounds.y = 1 << SectorSpace.power2Axes.y;
+    SectorSpace.bounds.z = 1 << SectorSpace.power2Axes.z;
+    SectionSpace.power2Axes.x = settings.sections.sectionXPow2;
+    SectionSpace.power2Axes.y = settings.sections.sectionYPow2;
+    SectionSpace.power2Axes.z = settings.sections.sectionZPow2;
+    SectionSpace.bounds.x = 1 << SectionSpace.power2Axes.x;
+    SectionSpace.bounds.y = 1 << SectionSpace.power2Axes.y;
+    SectionSpace.bounds.z = 1 << SectionSpace.power2Axes.z;
+    SectionSpace.volumne =
+        SectionSpace.bounds.x * SectionSpace.bounds.y * SectionSpace.bounds.z;
+    SectorSpace.volumne =
+        (SectorSpace.bounds.x / SectionSpace.bounds.x) *
+            (SectorSpace.bounds.y / SectionSpace.bounds.y) *
+            (SectorSpace.bounds.z / SectionSpace.bounds.z);
+});

package/World/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Section/Section.js";
+export * from "./Sector/Sector.js";
+export * from "./Dimension/Dimension.js";
+export * from "./Cursor/WorldCursor.js";

package/World/index.js

@@ -0,0 +1,4 @@
+export * from "./Section/Section.js";
+export * from "./Sector/Sector.js";
+export * from "./Dimension/Dimension.js";
+export * from "./Cursor/WorldCursor.js";

package/index.d.ts

@@ -1 +1 @@
-export * from "./Voxels/Voxel.types";
+export * from "./Voxels/Types/Voxel.types";

package/index.js

@@ -1 +1 @@
-export * from "./Voxels/Voxel.types";
+export * from "./Voxels/Types/Voxel.types";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.04",
+  "version": "0.0.06",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,14 +20,9 @@
     "url": "https://github.com/Divine-Star-Software/DivineVoxelEngine/issues"
   },
   "dependencies": {
-    "@amodx/meshing": "latest",
-    "@amodx/core": "latest",
     "@amodx/math": "latest",
     "@amodx/binary": "latest",
-    "@amodx/threads": "latest",
-    "@amodx/indexdb": "latest",
-    "@amodx/controls": "latest",
-    "@amodx/rng": "latest"
+    "@amodx/threads": "latest"
   },
   "publishConfig": {
     "access": "public"

package/Archive/Archive.types.d.ts

@@ -1,176 +0,0 @@
-import { Vec3Array } from "@amodx/math";
-import { LocationData } from "../Math";
-/**
- * Interface for an archived column.
- */
-export interface ArchivedColumnData {
-    /** Number representing the version of the archiver used. */
-    archiverVersion: number;
-    /** Number representing the version of the column data. */
-    version: number;
-    /** The location of the column in the world. */
-    location: LocationData;
-    /** Record of the column's state, storing dynamic or user-defined data. */
-    columnState: Record<string, any>;
-    /** The palette data used within the column. */
-    palettes: ArchivedColumnPaletteData;
-    /** Placeholder for future buffer data. */
-    buffers: ArchivedColumnBuffersData;
-    /** Keys associated with chunk states and other objects. */
-    keys: ArchivedColumnKeysData;
-    /** Array of archived chunk data within the column. */
-    chunks: ArchivedChunkData[];
-}
-/**
- * Interface for the palettes of an archived column.
- */
-export interface ArchivedColumnPaletteData {
-    /** Array of strings representing the unique identifiers for the primary voxel types in the column. */
-    id: string[];
-    /** Optional array of strings for the secondary voxel types, providing additional data for complex structures. */
-    secondaryId?: string[];
-    /** Optional Uint16Array representing the state of voxels, indicating specific conditions or variations. */
-    state?: Uint16Array;
-    /** Optional Uint16Array representing the mod state of voxels, indicating specific conditions or variations. */
-    mod?: Uint16Array;
-    /** Optional Uint16Array representing light levels for each voxel in the column. */
-    light?: Uint16Array;
-    /** Optional Uint16Array representing the state of secondary voxels. */
-    secondaryState?: Uint16Array;
-}
-/**
- * Interface for the keys of an archived column.
- */
-export interface ArchivedColumnKeysData {
-    /** Array of strings that are the keys for the chunk state struct.  */
-    chunkState: string[];
-}
-/**
- * Placeholder interface for future buffer data in a column.
- */
-export interface ArchivedColumnBuffersData {
-}
-/**
- * Interface for an archived chunk.
- */
-export interface ArchivedChunkData {
-    /** Array representing the chunk's state, holding dynamic or user-defined data. */
-    state: any[];
-    /** Palette data used within the chunk. */
-    palettes: ArchivedChunkPaletteData;
-    /** Buffer data for the chunk, holding voxel type identifiers, light data, state, and secondary state. */
-    buffers: ArchivedChunkBuffers;
-}
-/**
- * Interface representing the palette data for a single chunk in the voxel engine.
- */
-export interface ArchivedChunkPaletteData {
-    /** Optional Uint16Array representing the voxel type identifiers within the chunk. */
-    id?: Uint16Array;
-    /** Optional Uint16Array for storing light data. */
-    light?: Uint16Array;
-    /** Optional Uint16Array for secondary voxel type identifiers. */
-    secondaryId?: Uint16Array;
-    /** Optional Uint16Array for storing voxel states within the chunk. */
-    state?: Uint16Array;
-    /** Optional Uint16Array for storing mod data. */
-    mod?: Uint16Array;
-    /** Optional Uint16Array for storing states of secondary voxels. */
-    secondaryState?: Uint16Array;
-}
-/**
- * Interface representing the buffer data for a chunk.
- */
-export interface ArchivedChunkBuffers {
-    /** The buffer for voxel type identifiers, which could be a Uint16Array, Uint8Array, or a single number if all voxels are the same. */
-    id: Uint16Array | Uint8Array | number;
-    /** The buffer for light data, which could be a Uint16Array, Uint8Array, or a single number if all light values are the same. */
-    light: Uint16Array | Uint8Array | number;
-    /** The buffer for voxel states, which could be a Uint16Array, Uint8Array, or a single number if all states are the same. */
-    state: Uint16Array | Uint8Array | number;
-    /** The buffer for voxel mod states, which could be a Uint16Array, Uint8Array, or a single number if all states are the same. */
-    mod: Uint16Array | Uint8Array | number;
-    /** The buffer for secondary voxel data, which could be a Uint16Array, Uint8Array, or a single number if all secondary data is the same. */
-    secondary: Uint16Array | Uint8Array | number;
-}
-/**
- * Interface for an archived area.
- */
-export interface ArchivedAreaData {
-    /** Number representing the version of the archiver used. */
-    archiverVersion: number;
-    /** Number representing the version of the area data. */
-    version: number;
-    /** String representing the dimension or world type the area belongs to. */
-    dimension: string;
-    /** The palette maps for the area, including voxel, light, and state data. */
-    maps: ArchivedAreaMapData;
-    /** Keys associated with column and chunk states and other objects. */
-    keys: ArchivedAreaKeysData;
-    /** Array of archived column data within the area. */
-    columns: ArchivedAreaColumnData[];
-}
-/**
- * Interface for an archived area maps.
- */
-export interface ArchivedAreaMapData {
-    /** Record mapping voxel IDs to string identifiers. */
-    id: Record<string, string>;
-    /** Record mapping string IDs to arrays of voxel identifiers. */
-    idPalette: Record<string, string[]>;
-    /** Record mapping string IDs to arrays of secondary voxel identifiers. */
-    secondaryIdPalette: Record<string, string[]>;
-    /** Record mapping string IDs to Uint16Arrays of light data. */
-    lightPalette: Record<string, Uint16Array>;
-    /** Record mapping string IDs to Uint16Arrays of voxel states. */
-    statePalette: Record<string, Uint16Array>;
-    /** Record mapping string IDs to Uint16Arrays of voxel mods. */
-    modPalette: Record<string, Uint16Array>;
-    /** Record mapping string IDs to Uint16Arrays of secondary voxel states. */
-    secondaryStatePalette: Record<string, Uint16Array>;
-    /** Record mapping chunk identifiers to `ArchivedChunkData`. */
-    chunk: Record<string, ArchivedChunkData>;
-    /** Record mapping column state identifiers to arrays of state data. */
-    columnState: Record<string, any[]>;
-}
-/**
- * Interface representing the keys associated with column and chunk states within an area.
- */
-export interface ArchivedAreaKeysData {
-    /** Array of strings that are the keys for the column state struct.  */
-    columnState: string[];
-    /** Array of strings that are the keys for the chunk state struct.  */
-    chunkState: string[];
-}
-/**
- * Interface representing the palette data for a column within an area.
- */
-export interface ArchivedAreaColumnPaletteData {
-    /** Array of strings representing the unique identifiers for the primary voxel types in the column. */
-    id: string[];
-    /** Optional array of strings for secondary voxel types. */
-    secondary?: string[];
-    /** Optional Uint16Array representing the state of voxels in the column. */
-    state?: Uint16Array;
-    /** Optional Uint16Array representing the mod of voxels in the column. */
-    mod?: Uint16Array;
-    /** Optional Uint16Array representing light levels for each voxel in the column. */
-    light?: Uint16Array;
-    /** Optional Uint16Array representing the state of secondary voxels. */
-    secondaryState?: Uint16Array;
-}
-/**
- * Interface representing the archived data for a column within an area.
- */
-export interface ArchivedAreaColumnData {
-    /** A Vec3Array representing the position of the column within the area. */
-    position: Vec3Array;
-    /** The state data for the column, either as an array or a reference string. */
-    columnState: any[] | string;
-    /** Buffer data for the column. */
-    buffers: ArchivedColumnBuffersData;
-    /** The palette data used within the column. */
-    palettes: ArchivedAreaColumnPaletteData;
-    /** Array of archived chunk data or references to chunk data. */
-    chunks: (ArchivedChunkData | string)[];
-}

package/Archive/Functions/ArchiveArea.d.ts

@@ -1,10 +0,0 @@
-import { ArchivedAreaColumnData, ArchivedAreaData, ArchivedColumnData } from "../Archive.types";
-type RunData = {
-    dimension: string;
-    columns: ArchivedColumnData[];
-    version?: number;
-};
-export default function CreateArchiveArea(archiveData: RunData): ArchivedAreaData;
-export declare function CreateColumnFromArea(area: ArchivedAreaData, column: ArchivedAreaColumnData): ArchivedColumnData;
-export declare function CreateColumnsFromArea(area: ArchivedAreaData): Generator<ArchivedColumnData>;
-export {};