@divinevoxel/vlox 0.0.4 → 0.0.5

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;
-}

package/Math/Classes/MatrixArray.js

@@ -1,243 +0,0 @@
-import { MatrixConstants } from "../../Math/Constants/ConstantMartrix.js";
-export class MatrixProperty {
-    data;
-    constructor(data) {
-        this.data = data;
-    }
-    get x() {
-        return this.data.getX();
-    }
-    get y() {
-        return this.data.getY();
-    }
-    get z() {
-        return this.data.getZ();
-    }
-    get w() {
-        return this.data.getW();
-    }
-    set x(value) {
-        this.data.setX(value);
-    }
-    set y(value) {
-        this.data.setY(value);
-    }
-    set z(value) {
-        this.data.setZ(value);
-    }
-    set w(value) {
-        this.data.setW(value);
-    }
-    set(x, y, z) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-    setAll(value) {
-        this.x = value;
-        this.y = value;
-        this.z = value;
-    }
-}
-export class MatrixArray {
-    index;
-    static MATRIX_INDEXES = {
-        POSITION_X: 12,
-        POSITION_Y: 13,
-        POSITION_Z: 14,
-        SCALE_X: 0,
-        SCALE_Y: 5,
-        SCALE_Z: 10,
-        SCALE_W: 15,
-    };
-    static buildProperties(matrix) {
-        const matricies = matrix.matricies;
-        matrix.rows = [];
-        matrix.cols = [];
-        let i = 0;
-        let rows = 16;
-        while (i < rows) {
-            const row = i;
-            matrix.rows.push(new MatrixProperty({
-                getX: () => {
-                    return matricies[row + matrix.trueIndex];
-                },
-                getY: () => {
-                    return matricies[row + 1 + matrix.trueIndex];
-                },
-                getZ: () => {
-                    return matricies[row + 2 + matrix.trueIndex];
-                },
-                getW: () => {
-                    return matricies[row + 3 + matrix.trueIndex];
-                },
-                setX: (value) => {
-                    matricies[row + matrix.trueIndex] = value;
-                },
-                setY: (value) => {
-                    matricies[row + 1 + matrix.trueIndex] = value;
-                },
-                setZ: (value) => {
-                    matricies[row + 2 + matrix.trueIndex] = value;
-                },
-                setW: (value) => {
-                    matricies[row + 3 + matrix.trueIndex] = value;
-                },
-            }));
-            i += 4;
-        }
-        i = 0;
-        while (i < 4) {
-            const col = i;
-            matrix.cols.push(new MatrixProperty({
-                getX: () => {
-                    return matricies[col + matrix.trueIndex];
-                },
-                getY: () => {
-                    return matricies[col + 1 * 4 + matrix.trueIndex];
-                },
-                getZ: () => {
-                    return matricies[col + 2 * 4 + matrix.trueIndex];
-                },
-                getW: () => {
-                    return matricies[col + 3 * 4 + matrix.trueIndex];
-                },
-                setX: (value) => {
-                    matricies[i + matrix.trueIndex] = value;
-                },
-                setY: (value) => {
-                    matricies[col + 1 * 4 + matrix.trueIndex] = value;
-                },
-                setZ: (value) => {
-                    matricies[col + 2 * 4 + matrix.trueIndex] = value;
-                },
-                setW: (value) => {
-                    matricies[col + 3 * 4 + matrix.trueIndex] = value;
-                },
-            }));
-            i++;
-        }
-    }
-    trueIndex = 0;
-    matricies;
-    constructor(startData, index = 0) {
-        this.index = index;
-        this.setMatriciesIndex(index);
-        if (startData instanceof MatrixArray) {
-            this.matricies = startData.matricies;
-            MatrixArray.buildProperties(this);
-            return;
-        }
-        this.matricies = new Float32Array(startData * 16);
-        let i = 0;
-        let k = 0;
-        while (k < startData) {
-            for (const row of MatrixConstants.IDENTIY_MATRIX) {
-                for (const col of row) {
-                    this.matricies[i] = col;
-                    i++;
-                }
-            }
-            k++;
-        }
-        MatrixArray.buildProperties(this);
-    }
-    rows;
-    cols;
-    scale = new MatrixProperty({
-        getX: () => {
-            return this.matricies[MatrixArray.MATRIX_INDEXES.SCALE_X + this.trueIndex];
-        },
-        getY: () => {
-            return this.matricies[MatrixArray.MATRIX_INDEXES.SCALE_Y + this.trueIndex];
-        },
-        getZ: () => {
-            return this.matricies[MatrixArray.MATRIX_INDEXES.SCALE_Z + this.trueIndex];
-        },
-        getW: () => {
-            return this.matricies[MatrixArray.MATRIX_INDEXES.SCALE_W + this.trueIndex];
-        },
-        setX: (value) => {
-            this.matricies[MatrixArray.MATRIX_INDEXES.SCALE_X + this.trueIndex] = value;
-        },
-        setY: (value) => {
-            this.matricies[MatrixArray.MATRIX_INDEXES.SCALE_Y + this.trueIndex] = value;
-        },
-        setZ: (value) => {
-            this.matricies[MatrixArray.MATRIX_INDEXES.SCALE_Z + this.trueIndex] = value;
-        },
-        setW: (value) => {
-            this.matricies[MatrixArray.MATRIX_INDEXES.SCALE_W + this.trueIndex] = value;
-        },
-    });
-    position = new MatrixProperty({
-        getX: () => {
-            return this.matricies[MatrixArray.MATRIX_INDEXES.POSITION_X + this.trueIndex];
-        },
-        getY: () => {
-            return this.matricies[MatrixArray.MATRIX_INDEXES.POSITION_Y + this.trueIndex];
-        },
-        getZ: () => {
-            return this.matricies[MatrixArray.MATRIX_INDEXES.POSITION_Z + this.trueIndex];
-        },
-        getW: () => {
-            return 0;
-        },
-        setX: (value) => {
-            this.matricies[MatrixArray.MATRIX_INDEXES.POSITION_X + this.trueIndex] =
-                value;
-        },
-        setY: (value) => {
-            this.matricies[MatrixArray.MATRIX_INDEXES.POSITION_Y + this.trueIndex] =
-                value;
-        },
-        setZ: (value) => {
-            this.matricies[MatrixArray.MATRIX_INDEXES.POSITION_Z + this.trueIndex] =
-                value;
-        },
-        setW: (value) => { },
-    });
-    setMatriciesIndex(index) {
-        this.index = index;
-        this.trueIndex = index * 16;
-        return this;
-    }
-    copy(matrix) {
-        for (let i = 0; i < 16; i++) {
-            this.matricies[i + this.trueIndex] = matrix.matricies[i + matrix.trueIndex];
-        }
-    }
-    copyIndex() {
-        const index = [];
-        for (let i = 0; i < 16; i++) {
-            index.push(this.matricies[i + this.trueIndex]);
-        }
-        return index;
-    }
-    multiply(matirx) {
-        for (let r = 0; r < 4; r++) {
-            tempMatrix.rows[r].x =
-                this.rows[r].x * matirx.cols[0].x +
-                    this.rows[r].y * matirx.cols[0].y +
-                    this.rows[r].z * matirx.cols[0].z +
-                    this.rows[r].w * matirx.cols[0].w;
-            tempMatrix.rows[r].y =
-                this.rows[r].x * matirx.cols[1].x +
-                    this.rows[r].y * matirx.cols[1].y +
-                    this.rows[r].z * matirx.cols[1].z +
-                    this.rows[r].w * matirx.cols[1].w;
-            tempMatrix.rows[r].z =
-                this.rows[r].x * matirx.cols[2].x +
-                    this.rows[r].y * matirx.cols[2].y +
-                    this.rows[r].z * matirx.cols[2].z +
-                    this.rows[r].w * matirx.cols[2].w;
-            tempMatrix.rows[r].w =
-                this.rows[r].x * matirx.cols[3].x +
-                    this.rows[r].y * matirx.cols[3].y +
-                    this.rows[r].z * matirx.cols[3].z +
-                    this.rows[r].w * matirx.cols[3].w;
-        }
-        this.copy(tempMatrix);
-    }
-}
-const tempMatrix = new MatrixArray(1, 0);

package/Math/Classes/Plane.d.ts

@@ -1,22 +0,0 @@
-import { Vector3 } from "./Vector3.js";
-export type PlaneConstrucotrData = {
-    v1: Vector3;
-    v2: Vector3;
-    v3: Vector3;
-    v4: Vector3;
-};
-export declare class Plane {
-    v1: Vector3;
-    v2: Vector3;
-    v3: Vector3;
-    v4: Vector3;
-    minX: number;
-    maxX: number;
-    minZ: number;
-    maxZ: number;
-    minY: number;
-    maxY: number;
-    constructor(data: PlaneConstrucotrData);
-    _compareVales(v1: Vector3, v2: Vector3, axis: "x" | "y" | "z", minProperty: "minX" | "minY" | "minZ", maxProperty: "maxX" | "maxY" | "maxZ"): void;
-    _minMaxCompare(v1: Vector3, v2: Vector3): void;
-}

package/Math/Classes/Plane.js

@@ -1,53 +0,0 @@
-export class Plane {
-    v1;
-    v2;
-    v3;
-    v4;
-    minX = Infinity;
-    maxX = -Infinity;
-    minZ = Infinity;
-    maxZ = -Infinity;
-    minY = Infinity;
-    maxY = -Infinity;
-    constructor(data) {
-        this.v1 = data.v1;
-        this.v2 = data.v2;
-        this.v3 = data.v3;
-        this.v4 = data.v4;
-        this._minMaxCompare(this.v1, this.v2);
-        this._minMaxCompare(this.v1, this.v3);
-        this._minMaxCompare(this.v1, this.v4);
-        this._minMaxCompare(this.v2, this.v3);
-        this._minMaxCompare(this.v2, this.v4);
-        this._minMaxCompare(this.v3, this.v4);
-    }
-    _compareVales(v1, v2, axis, minProperty, maxProperty) {
-        const c1 = v1;
-        const c2 = v2;
-        if (c1[axis] < this[minProperty]) {
-            if (c1[axis] <= c2[axis]) {
-                this[minProperty] = c1[axis];
-            }
-        }
-        if (c2[axis] < this[minProperty]) {
-            if (c2[axis] <= c1[axis]) {
-                this[minProperty] = c2[axis];
-            }
-        }
-        if (c1[axis] > this[maxProperty]) {
-            if (c1[axis] >= c2[axis]) {
-                this[maxProperty] = c1[axis];
-            }
-        }
-        if (c2[axis] > this[maxProperty]) {
-            if (c2[axis] >= c1[axis]) {
-                this[maxProperty] = c2[axis];
-            }
-        }
-    }
-    _minMaxCompare(v1, v2) {
-        this._compareVales(v1, v2, "x", "minX", "maxX");
-        this._compareVales(v1, v2, "y", "minY", "maxY");
-        this._compareVales(v1, v2, "z", "minZ", "maxZ");
-    }
-}

package/Math/Classes/Scalar.d.ts

@@ -1,5 +0,0 @@
-export declare class Scalar {
-    value: number;
-    static Between(value: number, min: number, max: number): boolean;
-    constructor(value?: number);
-}

package/Math/Classes/Scalar.js

@@ -1,9 +0,0 @@
-export class Scalar {
-    value;
-    static Between(value, min, max) {
-        return value >= min && value <= max;
-    }
-    constructor(value = 0) {
-        this.value = value;
-    }
-}

package/Math/Classes/SimpleBoundingBox.d.ts

@@ -1,40 +0,0 @@
-import { BoundsObject, VolumeDimensions } from "Math/Math.types.js";
-import { Vector3Like } from "@amodx/math";
-import { Vector3 } from "./Vector3.js";
-export declare class SimpleBoundingBox {
-    origin: Vector3;
-    dimensions: VolumeDimensions;
-    bounds: {
-        minX: number;
-        maxX: number;
-        minZ: number;
-        maxZ: number;
-        minY: number;
-        maxY: number;
-    };
-    checkBounds: {
-        minX: number;
-        maxX: number;
-        minZ: number;
-        maxZ: number;
-        minY: number;
-        maxY: number;
-    };
-    checkOrigin: Vector3;
-    _voxelCheckMap: Record<string, boolean>;
-    _voxelCheckPoints: number[][];
-    _voxelBottomCheckPoints: number[][];
-    _voxelOriginPoints: number[][];
-    constructor(origin: Vector3, dimensions: VolumeDimensions);
-    _updateBounds(): void;
-    _updateCheckBounds(): void;
-    updateOrigin(x: number, y: number, z: number): void;
-    setOriginToCheckOrigin(): void;
-    setCheckOrigin(x: number, y: number, z: number): void;
-    getCurrentOriginPoints(): number[][];
-    getVoxelCheckPoints(): number[][];
-    getVoxelBottomCheckPoints(): number[][];
-    _getPositionKey(x: number, y: number, z: number): string;
-    isPointInsideBox(point: Vector3Like): boolean;
-    doesBoxIntersect(testBox: BoundsObject): boolean;
-}

package/Math/Classes/SimpleBoundingBox.js

@@ -1,157 +0,0 @@
-import { Vector3 } from "./Vector3.js";
-export class SimpleBoundingBox {
-    origin;
-    dimensions;
-    bounds = {
-        minX: Infinity,
-        maxX: -Infinity,
-        minZ: Infinity,
-        maxZ: -Infinity,
-        minY: Infinity,
-        maxY: -Infinity,
-    };
-    checkBounds = {
-        minX: Infinity,
-        maxX: -Infinity,
-        minZ: Infinity,
-        maxZ: -Infinity,
-        minY: Infinity,
-        maxY: -Infinity,
-    };
-    checkOrigin = new Vector3(0, 0, 0);
-    _voxelCheckMap = {};
-    _voxelCheckPoints = [];
-    _voxelBottomCheckPoints = [];
-    _voxelOriginPoints = [];
-    constructor(origin, dimensions) {
-        this.origin = origin;
-        this.dimensions = dimensions;
-        const ov = origin;
-        this.checkOrigin.set(ov.x, ov.y, ov.z);
-        this._updateBounds();
-        this._updateCheckBounds();
-    }
-    _updateBounds() {
-        const ov = this.origin;
-        this.bounds.minX = ov.x - this.dimensions.w / 2;
-        this.bounds.maxX = ov.x + this.dimensions.w / 2;
-        this.bounds.minZ = ov.z - this.dimensions.d / 2;
-        this.bounds.maxZ = ov.z + this.dimensions.d / 2;
-        this.bounds.minY = ov.y - this.dimensions.h / 2;
-        this.bounds.maxY = ov.y + this.dimensions.h / 2;
-    }
-    _updateCheckBounds() {
-        const cv = this.checkOrigin;
-        this.checkBounds.minX = cv.x - this.dimensions.w / 2;
-        this.checkBounds.maxX = cv.x + this.dimensions.w / 2;
-        this.checkBounds.minZ = cv.z - this.dimensions.d / 2;
-        this.checkBounds.maxZ = cv.z + this.dimensions.d / 2;
-        this.checkBounds.minY = cv.y - this.dimensions.h / 2;
-        this.checkBounds.maxY = cv.y + this.dimensions.h / 2;
-    }
-    updateOrigin(x, y, z) {
-        this.origin.set(x, y, z);
-        this.origin.roundVector(2);
-        this._updateBounds();
-    }
-    setOriginToCheckOrigin() {
-        const cv = this.checkOrigin;
-        this.origin.set(cv.x, cv.y, cv.z);
-        this.bounds.minX = this.checkBounds.minX;
-        this.bounds.maxX = this.checkBounds.maxX;
-        this.bounds.minZ = this.checkBounds.minZ;
-        this.bounds.maxZ = this.checkBounds.maxZ;
-        this.bounds.minY = this.checkBounds.minY;
-        this.bounds.maxY = this.checkBounds.maxY;
-    }
-    setCheckOrigin(x, y, z) {
-        this.checkOrigin.set(x, y, z);
-        this._updateCheckBounds();
-    }
-    getCurrentOriginPoints() {
-        this._voxelOriginPoints = [];
-        const mx = this.bounds.minX;
-        const my = this.bounds.minY;
-        const mz = this.bounds.minZ;
-        for (let y = my; y <= this.bounds.maxY; y++) {
-            for (let x = mx - 1; x <= this.bounds.maxX + 1; x++) {
-                for (let z = mz - 1; z <= this.bounds.maxZ + 1; z++) {
-                    const key = this._getPositionKey(x, y, z);
-                    if (!this._voxelCheckMap[key]) {
-                        this._voxelOriginPoints.push([x, y, z]);
-                        this._voxelCheckMap[key] = true;
-                    }
-                }
-            }
-        }
-        this._voxelCheckMap = {};
-        return this._voxelOriginPoints;
-    }
-    getVoxelCheckPoints() {
-        this._voxelCheckPoints = [];
-        const mx = this.checkBounds.minX;
-        const my = this.checkBounds.minY;
-        const mz = this.checkBounds.minZ;
-        for (let y = my; y <= this.checkBounds.maxY; y++) {
-            for (let x = mx; x <= this.checkBounds.maxX + 1; x++) {
-                for (let z = mz; z <= this.checkBounds.maxZ + 1; z++) {
-                    const key = this._getPositionKey(x, y, z);
-                    if (!this._voxelCheckMap[key]) {
-                        this._voxelCheckPoints.push([
-                            Math.floor(x),
-                            Math.floor(y),
-                            Math.floor(z),
-                        ]);
-                        this._voxelCheckMap[key] = true;
-                    }
-                }
-            }
-        }
-        this._voxelCheckMap = {};
-        return this._voxelCheckPoints;
-    }
-    getVoxelBottomCheckPoints() {
-        this._voxelBottomCheckPoints = [];
-        const mx = this.checkBounds.minX;
-        const my = this.checkBounds.minY;
-        const mz = this.checkBounds.minZ;
-        for (let y = my - 1; y <= my; y++) {
-            for (let x = mx; x <= this.checkBounds.maxX + 1; x++) {
-                for (let z = mz; z <= this.checkBounds.maxZ + 1; z++) {
-                    const key = this._getPositionKey(x, y, z);
-                    if (!this._voxelCheckMap[key]) {
-                        this._voxelBottomCheckPoints.push([
-                            Math.floor(x),
-                            Math.floor(y),
-                            Math.floor(z),
-                        ]);
-                        this._voxelCheckMap[key] = true;
-                    }
-                }
-            }
-        }
-        this._voxelCheckMap = {};
-        return this._voxelBottomCheckPoints;
-    }
-    _getPositionKey(x, y, z) {
-        return `${x}-${y}-${z}`;
-    }
-    isPointInsideBox(point) {
-        const box = this.bounds;
-        return (point.x >= box.minX &&
-            point.x <= box.maxX &&
-            point.y >= box.minY &&
-            point.y <= box.maxY &&
-            point.z >= box.minZ &&
-            point.z <= box.maxZ);
-    }
-    doesBoxIntersect(testBox) {
-        const box = this.bounds;
-        return (box.minX <= testBox.maxX &&
-            box.maxX >= testBox.minX &&
-            box.minY <= testBox.maxY &&
-            box.maxY >= testBox.minY &&
-            box.minZ <= testBox.maxZ &&
-            box.maxZ >= testBox.minZ);
-    }
-}