@divinevoxel/vlox 0.0.3 → 0.0.5

package/Math/Classes/Vector3.d.ts

@@ -1,54 +0,0 @@
-import { Vector3Like, Vec3Array } from "@amodx/math";
-declare class V3 {
-    _data: Vec3Array;
-    get x(): number;
-    set x(x: number);
-    get y(): number;
-    set y(y: number);
-    get z(): number;
-    set z(z: number);
-}
-export declare class Vector3 extends V3 {
-    static Zero: Vector3;
-    static Up: Vector3;
-    static Down: Vector3;
-    static East: Vector3;
-    static West: Vector3;
-    static North: Vector3;
-    static South: Vector3;
-    _tv3: V3;
-    static NaNRestore(vec3: Vector3Like): void;
-    constructor(x?: number, y?: number, z?: number);
-    updateFromArray(array: number[] | Float32Array | Float64Array, startIndex?: number): this;
-    set(x: number, y: number, z: number): this;
-    setAll(value: number): this;
-    updateFromVec3(vector: Vector3): this;
-    roundVector(deciamlPoints?: number): this;
-    translate(x: number, y: number, z: number): this;
-    getTranslated(x: number, y: number, z: number): V3;
-    scaleXYZ(scaler: number): this;
-    scale(xScale: number, yScale: number, zScale: number): this;
-    getScaledXYZ(scaler: number): V3;
-    getScaled(xScale: number, yScale: number, zScale: number): V3;
-    add(x: number, y: number, z: number): this;
-    addXYZ(add: number): this;
-    addFromVec3(vector: Vector3): this;
-    isZero(): boolean;
-    subtractXYZ(subtract: number): this;
-    subtractFromObj(vector: Vector3): this;
-    getAddXYZ(add: number): V3;
-    getSubtractXYZ(subtract: number): V3;
-    addVector(vector3: Vector3): this;
-    getAddedVector(vector3: Vector3): V3;
-    subtractVector(vector3: Vector3): this;
-    getSubtractedVector(vector3: Vector3): V3;
-    scaleVector(vector3: Vector3): this;
-    getScaledVector(vector3: Vector3): V3;
-    getLength(): number;
-    divide(scalar: number): this;
-    getDivided(scalar: number): V3;
-    normalize(): this;
-    isEqual(vector3: Vector3): boolean;
-    isNotEqual(vector3: Vector3): boolean;
-}
-export {};

package/Math/Classes/Vector3.js

@@ -1,236 +0,0 @@
-class V3 {
-    _data = [0, 0, 0];
-    get x() {
-        return this._data[0];
-    }
-    set x(x) {
-        this._data[0] = x;
-    }
-    get y() {
-        return this._data[1];
-    }
-    set y(y) {
-        this._data[1] = y;
-    }
-    get z() {
-        return this._data[2];
-    }
-    set z(z) {
-        this._data[2] = z;
-    }
-}
-export class Vector3 extends V3 {
-    static Zero = new Vector3(0, 0, 0);
-    static Up = new Vector3(0, 1, 0);
-    static Down = new Vector3(0, -1, 0);
-    static East = new Vector3(1, 0, 0);
-    static West = new Vector3(-1, 0, 0);
-    static North = new Vector3(0, 0, 1);
-    static South = new Vector3(0, 0, -1);
-    _tv3 = new V3();
-    static NaNRestore(vec3) {
-        if (Number.isNaN(vec3.x))
-            vec3.x = 0;
-        if (Number.isNaN(vec3.y))
-            vec3.y = 0;
-        if (Number.isNaN(vec3.z))
-            vec3.z = 0;
-    }
-    constructor(x = 0, y = 0, z = 0) {
-        super();
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-    updateFromArray(array, startIndex = 0) {
-        this.x = array[startIndex];
-        this.y = array[startIndex + 1];
-        this.z = array[startIndex + 2];
-        return this;
-    }
-    set(x, y, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-        return this;
-    }
-    setAll(value) {
-        this.x = value;
-        this.y = value;
-        this.z = value;
-        return this;
-    }
-    updateFromVec3(vector) {
-        this.x = vector.x;
-        this.y = vector.y;
-        this.z = vector.z;
-        return this;
-    }
-    roundVector(deciamlPoints = 2) {
-        this.x = Number(this.x.toFixed(deciamlPoints));
-        this.y = Number(this.y.toFixed(deciamlPoints));
-        this.z = Number(this.z.toFixed(deciamlPoints));
-        return this;
-    }
-    translate(x, y, z) {
-        this.x = this.x + x;
-        this.y = this.y + y;
-        this.z = this.z + z;
-        return this;
-    }
-    getTranslated(x, y, z) {
-        this._tv3.x = this.x + x;
-        this._tv3.y = this.y + y;
-        this._tv3.z = this.z + z;
-        return this._tv3;
-    }
-    scaleXYZ(scaler) {
-        this.x = this.x * scaler;
-        this.y = this.y * scaler;
-        this.z = this.z * scaler;
-        return this;
-    }
-    scale(xScale, yScale, zScale) {
-        this.x = this.x * xScale;
-        this.y = this.y * yScale;
-        this.z = this.z * zScale;
-        return this;
-    }
-    getScaledXYZ(scaler) {
-        this._tv3.x = this.x * scaler;
-        this._tv3.y = this.y * scaler;
-        this._tv3.z = this.z * scaler;
-        return this._tv3;
-    }
-    getScaled(xScale, yScale, zScale) {
-        this._tv3.x = this.x * xScale;
-        this._tv3.y = this.y * yScale;
-        this._tv3.z = this.z * zScale;
-        return this._tv3;
-    }
-    add(x, y, z) {
-        this.x += x;
-        this.y += y;
-        this.z += z;
-        return this;
-    }
-    addXYZ(add) {
-        this.x = this.x + add;
-        this.y = this.y + add;
-        this.z = this.z + add;
-        return this;
-    }
-    addFromVec3(vector) {
-        this.x += vector.x;
-        this.y += vector.y;
-        this.z += vector.z;
-        return this;
-    }
-    isZero() {
-        return !this.x && !this.y && !this.z;
-    }
-    subtractXYZ(subtract) {
-        this.x = this.x - subtract;
-        this.y = this.y - subtract;
-        this.z = this.z - subtract;
-        return this;
-    }
-    subtractFromObj(vector) {
-        this.x = this.x - vector.x;
-        this.y = this.y - vector.y;
-        this.z = this.z - vector.z;
-        return this;
-    }
-    getAddXYZ(add) {
-        this._tv3.x = this.x + add;
-        this._tv3.y = this.y + add;
-        this._tv3.z = this.z + add;
-        return this._tv3;
-    }
-    getSubtractXYZ(subtract) {
-        this._tv3.x = this.x - subtract;
-        this._tv3.y = this.y - subtract;
-        this._tv3.z = this.z - subtract;
-        return this._tv3;
-    }
-    addVector(vector3) {
-        this.x = vector3.x + this.x;
-        this.y = vector3.y + this.y;
-        this.z = vector3.z + this.z;
-        return this;
-    }
-    getAddedVector(vector3) {
-        this._tv3.x = vector3.x + this.x;
-        this._tv3.y = vector3.y + this.y;
-        this._tv3.z = vector3.z + this.z;
-        return this._tv3;
-    }
-    subtractVector(vector3) {
-        this.x = this.x - vector3.x;
-        this.y = this.y - vector3.y;
-        this.z = this.z - vector3.z;
-        return this;
-    }
-    getSubtractedVector(vector3) {
-        this._tv3.x = this.x - vector3.x;
-        this._tv3.y = this.y - vector3.y;
-        this._tv3.z = this.z - vector3.z;
-        return this._tv3;
-    }
-    scaleVector(vector3) {
-        this.x = this.x * vector3.x;
-        this.y = this.y * vector3.y;
-        this.z = this.z * vector3.z;
-        return this;
-    }
-    getScaledVector(vector3) {
-        this._tv3.x = this.x * vector3.x;
-        this._tv3.y = this.y * vector3.y;
-        this._tv3.z = this.z * vector3.z;
-        return this._tv3;
-    }
-    getLength() {
-        return Math.sqrt(this.x ** 2 + this.y ** 2 + this.z ** 2);
-    }
-    divide(scalar) {
-        this.x = this.x / scalar;
-        this.y = this.y / scalar;
-        this.z = this.z / scalar;
-        Vector3.NaNRestore(this);
-        return this;
-    }
-    getDivided(scalar) {
-        this._tv3.x = this.x / scalar;
-        this._tv3.y = this.y / scalar;
-        this._tv3.z = this.z / scalar;
-        Vector3.NaNRestore(this._tv3);
-        return this._tv3;
-    }
-    normalize() {
-        return this.divide(this.getLength());
-    }
-    isEqual(vector3) {
-        if (this.x != vector3.x) {
-            return false;
-        }
-        if (this.y != vector3.y) {
-            return false;
-        }
-        if (this.z != vector3.z) {
-            return false;
-        }
-        return true;
-    }
-    isNotEqual(vector3) {
-        if (this.x != vector3.x) {
-            return true;
-        }
-        if (this.y != vector3.y) {
-            return true;
-        }
-        if (this.z != vector3.z) {
-            return true;
-        }
-        return false;
-    }
-}

package/Math/Constants/ConstantMartrix.d.ts

@@ -1,3 +0,0 @@
-export declare const MatrixConstants: {
-    IDENTIY_MATRIX: number[][];
-};

package/Math/Constants/ConstantMartrix.js

@@ -1,8 +0,0 @@
-export const MatrixConstants = {
-    IDENTIY_MATRIX: [
-        [1, 0, 0, 0],
-        [0, 1, 0, 0],
-        [0, 0, 1, 0],
-        [0, 0, 0, 1],
-    ]
-};

package/Math/Constants/Faces.d.ts

@@ -1,5 +0,0 @@
-import type { DirectionNames } from "Util/Util.types";
-import type { CompassDirectionNames } from "Math/Math.types";
-export declare const FaceMap: DirectionNames[];
-export declare const FaceRecord: Record<DirectionNames, number>;
-export declare const FaceNormals: Record<DirectionNames | CompassDirectionNames, number[]>;

package/Math/Constants/Faces.js

@@ -1,28 +0,0 @@
-export const FaceMap = [
-    "up",
-    "down",
-    "east",
-    "west",
-    "south",
-    "north",
-];
-export const FaceRecord = {
-    up: 0,
-    down: 1,
-    east: 2,
-    west: 3,
-    south: 4,
-    north: 5,
-};
-export const FaceNormals = {
-    up: [0, 1, 0],
-    down: [0, -1, 0],
-    east: [1, 0, 0],
-    west: [-1, 0, 0],
-    north: [0, 0, 1],
-    south: [0, 0, -1],
-    "north-east": [1, 0, 1],
-    "north-west": [-1, 0, 1],
-    "south-east": [1, 0, -1],
-    "south-west": [-1, 0, -1],
-};

package/Math/Math.types.d.ts

@@ -1,25 +0,0 @@
-export type BoundsObject = {
-    minX: number;
-    maxX: number;
-    minZ: number;
-    maxZ: number;
-    minY: number;
-    maxY: number;
-};
-export type Size2D = {
-    width: number;
-    height: number;
-};
-export type Size3D = {
-    width: number;
-    height: number;
-    depth: number;
-};
-export type VolumeDimensions = {
-    w: number;
-    h: number;
-    d: number;
-};
-export type Dimension2DArray = [width: number, height: number];
-export type Dimension3DArray = [width: number, height: number, depth: number];
-export type CompassDirectionNames = "north" | "south" | "east" | "west" | "north-west" | "north-east" | "south-west" | "south-east";

package/Math/Objects/CompassDirection.d.ts

@@ -1,9 +0,0 @@
-import { CompassDirectionNames } from "Math/Math.types";
-/**# Compass Directions
- * ---
- * Converts a 2D noramlized vector into a compass direction.
- */
-export declare const CompassDirections: {
-    _map: CompassDirectionNames[];
-    getDirection(x: number, z: number): CompassDirectionNames;
-};

package/Math/Objects/CompassDirection.js

@@ -1,19 +0,0 @@
-/**# Compass Directions
- * ---
- * Converts a 2D noramlized vector into a compass direction.
- */
-export const CompassDirections = {
-    _map: [
-        "east",
-        "north-east",
-        "north",
-        "north-west",
-        "west",
-        "south-west",
-        "south",
-        "south-east",
-    ],
-    getDirection(x, z) {
-        return this._map[Math.round(Math.atan2(z, x) / ((2 * Math.PI) / 7) + 8) % 8];
-    },
-};

package/Math/Spaces/VoxelSpace.d.ts

@@ -1,32 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { Flat3DIndex } from "@amodx/math/Volumes";
-export declare abstract class VoxelSpace {
-    static index: Flat3DIndex;
-    static simpleCubeHash(space: VoxelSpace): Vector3Like;
-    static getPositionFromIndex(position: Vector3Like, bounds: Vector3Like, index: number): Vector3Like;
-    static getIndex(position: Vector3Like, bounds: Vector3Like): number;
-    static WholeVec3: Vector3Like;
-    static spatialHash(space: VoxelSpace, parentSpace: VoxelSpace, divisor?: Vector3Like): Vector3Like;
-    _position: Vector3Like;
-    _hashedPosition: Vector3Like;
-    _bounds: Vector3Like;
-    _boundsPower2: Vector3Like;
-    _boundsSet: boolean;
-    constructor();
-    log: boolean;
-    abstract getPosition(): Vector3Like;
-    abstract getIndex(): number;
-    abstract getPositionFromIndex(index: number): Vector3Like;
-    getVolume(): number;
-    getArea(): number;
-    getHeight(): number;
-    getWidth(): number;
-    getDepth(): number;
-    setXYZ(x: number, y: number, z: number): this;
-    setCubeBounds(bounds: Vector3Like): this | undefined;
-    setBounds(bounds: Vector3Like): this | undefined;
-    getPositionXYZ(x: number, y: number, z: number): Vector3Like;
-    getIndexXYZ(x: number, y: number, z: number): number;
-    getKey(): string;
-    getKeyXYZ(x: number, y: number, z: number): string;
-}

package/Math/Spaces/VoxelSpace.js

@@ -1,99 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { Flat3DIndex } from "@amodx/math/Volumes";
-const alignToPowerOf2 = (value, powerOf2) => {
-    const mask = (1 << powerOf2) - 1;
-    return value & ~mask;
-};
-//Objects
-export class VoxelSpace {
-    static index = Flat3DIndex.GetXZYOrder();
-    static simpleCubeHash(space) {
-        space._position.x = alignToPowerOf2(space._position.x, space._boundsPower2.x);
-        space._position.y = alignToPowerOf2(space._position.y, space._boundsPower2.y);
-        space._position.z = alignToPowerOf2(space._position.z, space._boundsPower2.z);
-        return space._position;
-    }
-    static getPositionFromIndex(position, bounds, index) {
-        this.index.setBounds(bounds.x, bounds.y, bounds.z);
-        const newPosition = this.index.getXYZ(index);
-        position.x = newPosition[0];
-        position.y = newPosition[1];
-        position.z = newPosition[2];
-        return position;
-    }
-    static getIndex(position, bounds) {
-        this.index.setBounds(bounds.x, bounds.y, bounds.z);
-        return this.index.getIndexVec3(position);
-    }
-    static WholeVec3 = Vector3Like.Create(1, 1, 1);
-    static spatialHash(space, parentSpace, divisor = VoxelSpace.WholeVec3) {
-        const parentPosition = parentSpace.getPositionXYZ(space._position.x, space._position.y, space._position.z);
-        space._hashedPosition.x = space._position.x - parentPosition.x / divisor.x;
-        space._hashedPosition.y = space._position.y - parentPosition.y / divisor.y;
-        space._hashedPosition.z = space._position.z - parentPosition.z / divisor.z;
-        return space._hashedPosition;
-    }
-    _position = Vector3Like.Create();
-    _hashedPosition = Vector3Like.Create();
-    _bounds = Vector3Like.Create();
-    _boundsPower2 = Vector3Like.Create();
-    _boundsSet = false;
-    constructor() { }
-    log = false;
-    getVolume() {
-        return this._bounds.x * this._bounds.y * this._bounds.z;
-    }
-    getArea() {
-        return this._bounds.x * this._bounds.z;
-    }
-    getHeight() {
-        return this._bounds.y;
-    }
-    getWidth() {
-        return this._bounds.x;
-    }
-    getDepth() {
-        return this._bounds.z;
-    }
-    setXYZ(x, y, z) {
-        this._position.x = x;
-        this._position.y = y;
-        this._position.z = z;
-        this.getPosition();
-        return this;
-    }
-    setCubeBounds(bounds) {
-        if (this._boundsSet)
-            return;
-        this._boundsPower2.x = bounds.x;
-        this._boundsPower2.y = bounds.y;
-        this._boundsPower2.z = bounds.z;
-        this._bounds.x = 2 ** this._boundsPower2.x;
-        this._bounds.y = 2 ** this._boundsPower2.y;
-        this._bounds.z = 2 ** this._boundsPower2.z;
-        this._boundsSet = true;
-        return this;
-    }
-    setBounds(bounds) {
-        if (this._boundsSet)
-            return;
-        this._bounds.x = bounds.x;
-        this._bounds.y = bounds.y;
-        this._bounds.z = bounds.z;
-        this._boundsSet = true;
-        return this;
-    }
-    getPositionXYZ(x, y, z) {
-        this.setXYZ(x, y, z);
-        return this._position;
-    }
-    getIndexXYZ(x, y, z) {
-        return this.setXYZ(x, y, z).getIndex();
-    }
-    getKey() {
-        return `${this._position.x}_${this._position.y}_${this._position.z}`;
-    }
-    getKeyXYZ(x, y, z) {
-        return this.setXYZ(x, y, z).getKey();
-    }
-}

package/Math/Spaces/VoxelSpaces.d.ts

@@ -1,50 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelSpace } from "./VoxelSpace.js";
-declare class RegionSpace extends VoxelSpace {
-    chunkBounds: Vector3Like;
-    columnBounds: Vector3Like;
-    getChunkVolume(): number;
-    getColumnVolume(): number;
-    getPosition(): Vector3Like;
-    getIndex(): number;
-    getPositionFromIndex(index: number): Vector3Like;
-}
-declare class ColumnSpace extends VoxelSpace {
-    region: RegionSpace;
-    constructor(region: RegionSpace);
-    getPosition(): Vector3Like;
-    getIndex(): number;
-    getPositionFromIndex(index: number): Vector3Like;
-}
-declare class ChunkSpace extends VoxelSpace {
-    region: RegionSpace;
-    constructor(region: RegionSpace);
-    _regionPosition: Vector3Like;
-    getRegionPositonx(): Vector3Like;
-    getRegionPositonxXYZ(x: number, y: number, z: number): Vector3Like;
-    getRegionIndex(): number;
-    getRegionIndexXYZ(x: number, y: number, z: number): number;
-    getPosition(): Vector3Like;
-    getIndex(): number;
-    getPositionFromIndex(index: number): Vector3Like;
-}
-declare class FinalVoxelSpace extends VoxelSpace {
-    chunk: ChunkSpace;
-    constructor(chunk: ChunkSpace);
-    getPosition(): Vector3Like;
-    getIndex(): number;
-    getPositionFromIndex(index: number): Vector3Like;
-}
-export declare class VoxelSpaces {
-    region: RegionSpace;
-    column: ColumnSpace;
-    chunk: ChunkSpace;
-    voxel: FinalVoxelSpace;
-    constructor();
-    setDimensions(data: {
-        regions: Vector3Like;
-        columns: Vector3Like;
-        chunks: Vector3Like;
-    }): void;
-}
-export {};

package/Math/Spaces/VoxelSpaces.js

@@ -1,117 +0,0 @@
-import { Vector3Like } from "@amodx/math";
-import { VoxelSpace } from "./VoxelSpace.js";
-class RegionSpace extends VoxelSpace {
-    chunkBounds = Vector3Like.Create();
-    columnBounds = Vector3Like.Create();
-    getChunkVolume() {
-        return this.chunkBounds.x * this.chunkBounds.y * this.chunkBounds.z;
-    }
-    getColumnVolume() {
-        return this.columnBounds.x * this.columnBounds.y * this.columnBounds.z;
-    }
-    getPosition() {
-        return VoxelSpace.simpleCubeHash(this);
-    }
-    getIndex() {
-        return -Infinity;
-    }
-    getPositionFromIndex(index) {
-        return this._position;
-    }
-}
-class ColumnSpace extends VoxelSpace {
-    region;
-    constructor(region) {
-        super();
-        this.region = region;
-    }
-    getPosition() {
-        return VoxelSpace.simpleCubeHash(this);
-    }
-    getIndex() {
-        return VoxelSpace.getIndex(Vector3Like.DivideInPlace(Vector3Like.SubtractInPlace(VoxelSpace.simpleCubeHash(this), this.region._position), this._bounds), this.region.columnBounds);
-    }
-    getPositionFromIndex(index) {
-        Vector3Like.MultiplyToRef(VoxelSpace.getPositionFromIndex(this._position, this.region.columnBounds, index), this._bounds, this._position);
-        return this._position;
-    }
-}
-class ChunkSpace extends VoxelSpace {
-    region;
-    constructor(region) {
-        super();
-        this.region = region;
-    }
-    _regionPosition = Vector3Like.Create();
-    getRegionPositonx() {
-        this.getPosition();
-        return VoxelSpace.spatialHash(this, this.region, this._bounds);
-    }
-    getRegionPositonxXYZ(x, y, z) {
-        return this.setXYZ(x, y, z).getRegionPositonx();
-    }
-    getRegionIndex() {
-        return VoxelSpace.getIndex(this._hashedPosition, this.region.chunkBounds);
-    }
-    getRegionIndexXYZ(x, y, z) {
-        this.getRegionPositonxXYZ(x, y, z);
-        return this.getRegionIndex();
-    }
-    getPosition() {
-        return VoxelSpace.simpleCubeHash(this);
-    }
-    getIndex() {
-        const ry = (this._position.y >> this.region._boundsPower2.y) <<
-            this.region._boundsPower2.y;
-        const cy = (this._position.y >> this._boundsPower2.y) << this._boundsPower2.y;
-        return (cy - ry) / this._bounds.y;
-    }
-    getPositionFromIndex(index) {
-        Vector3Like.MultiplyToRef(VoxelSpace.getPositionFromIndex(this._position, this.region.chunkBounds, index), this._bounds, this._position);
-        return this._position;
-    }
-}
-class FinalVoxelSpace extends VoxelSpace {
-    chunk;
-    constructor(chunk) {
-        super();
-        this.chunk = chunk;
-    }
-    getPosition() {
-        VoxelSpace.spatialHash(this, this.chunk);
-        this._position.x = this._hashedPosition.x;
-        this._position.y = this._hashedPosition.y;
-        this._position.z = this._hashedPosition.z;
-        return this._position;
-    }
-    getIndex() {
-        return VoxelSpace.getIndex(this._hashedPosition, this._bounds);
-    }
-    getPositionFromIndex(index) {
-        return VoxelSpace.getPositionFromIndex(this._position, this.chunk._bounds, index);
-    }
-}
-export class VoxelSpaces {
-    region;
-    column;
-    chunk;
-    voxel;
-    constructor() {
-        this.region = new RegionSpace();
-        this.column = new ColumnSpace(this.region);
-        this.chunk = new ChunkSpace(this.region);
-        this.voxel = new FinalVoxelSpace(this.chunk);
-    }
-    setDimensions(data) {
-        this.region.setCubeBounds(data.regions);
-        this.column.setCubeBounds(data.columns);
-        this.chunk.setCubeBounds(data.chunks);
-        this.voxel.setCubeBounds(data.chunks);
-        this.region.chunkBounds.x = this.region._bounds.x / this.chunk._bounds.x;
-        this.region.chunkBounds.y = this.region._bounds.y / this.chunk._bounds.y;
-        this.region.chunkBounds.z = this.region._bounds.z / this.chunk._bounds.z;
-        this.region.columnBounds.x = this.region._bounds.x / this.column._bounds.x;
-        this.region.columnBounds.y = this.region._bounds.y / this.column._bounds.y;
-        this.region.columnBounds.z = this.region._bounds.z / this.column._bounds.z;
-    }
-}