@divinevoxel/vlox 0.0.0

package/Math/Classes/SimpleBoundingBox.js

@@ -0,0 +1,157 @@
+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);
+    }
+}

package/Math/Classes/Vector3.d.ts

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,236 @@
+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/CardinalNeighbors.d.ts

@@ -0,0 +1,3 @@
+export declare const $3dMooreNeighborhood: [number, number, number][];
+export declare const $2dMooreNeighborhood: [number, number][];
+export declare const $3dCardinalNeighbors: [number, number, number][];

package/Math/Constants/CardinalNeighbors.js

@@ -0,0 +1,25 @@
+export const $3dMooreNeighborhood = [];
+export const $2dMooreNeighborhood = [
+    [0, 0],
+    [1, 0],
+    [0, 1],
+    [1, 1],
+    [-1, 0],
+    [0, -1],
+    [-1, -1],
+    [1, -1],
+    [-1, 1],
+];
+export const $3dCardinalNeighbors = [
+    [0, 1, 0],
+    [0, -1, 0],
+    [1, 0, 0],
+    [-1, 0, 0],
+    [0, 0, -1],
+    [0, 0, 1],
+];
+for (let y = -1; y < 2; y++) {
+    for (const n of $2dMooreNeighborhood) {
+        $3dMooreNeighborhood.push([n[0], y, n[1]]);
+    }
+}

package/Math/Constants/ConstantMartrix.d.ts

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

package/Math/Constants/ConstantMartrix.js

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,5 @@
+import type { DirectionNames } from "Types/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

@@ -0,0 +1,28 @@
+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/Constants/VoxelFaces.d.ts

@@ -0,0 +1,20 @@
+import { CompassDirections, Vec3Array } from "@amodx/math";
+export type VoxelFaceNames = "up" | "down" | "north" | "south" | "east" | "west";
+export declare const VoxelFaceNameArray: VoxelFaceNames[];
+export declare const VoxelFaceNameOppoisteRecord: Record<VoxelFaceNames, VoxelFaceNames>;
+export declare const VoxelFaceNameDirectionsRecord: Record<VoxelFaceNames, Vec3Array>;
+export declare enum VoxelFaces {
+    Up = 0,
+    Down = 1,
+    North = 2,
+    South = 3,
+    East = 4,
+    West = 5
+}
+export declare const VoxelFacesArray: readonly VoxelFaces[];
+export declare const VoxelFaceDirections: Readonly<Record<VoxelFaces, Vec3Array>>;
+export declare const VoxelFaceOpositeDirectionMap: Record<VoxelFaces, VoxelFaces>;
+export declare const VoxelFaceCompassDirectionMap: Record<VoxelFaces, CompassDirections>;
+export declare const CompassDirectionVoxelFaceMap: Record<CompassDirections, VoxelFaces>;
+export declare const VoxelFaceNameRecord: Record<VoxelFaceNames, VoxelFaces>;
+export declare const VoxelFaceNameMap: Record<VoxelFaces, VoxelFaceNames>;

package/Math/Constants/VoxelFaces.js

@@ -0,0 +1,92 @@
+import { CompassDirections } from "@amodx/math";
+export const VoxelFaceNameArray = [
+    "up",
+    "down",
+    "north",
+    "south",
+    "east",
+    "west",
+];
+export const VoxelFaceNameOppoisteRecord = {
+    up: "down",
+    down: "up",
+    north: "south",
+    south: "north",
+    east: "west",
+    west: "east",
+};
+export const VoxelFaceNameDirectionsRecord = {
+    up: [0, 1, 0],
+    down: [0, -1, 0],
+    north: [0, 0, 1],
+    south: [0, 0, -1],
+    east: [1, 0, 0],
+    west: [-1, 0, 0],
+};
+export var VoxelFaces;
+(function (VoxelFaces) {
+    VoxelFaces[VoxelFaces["Up"] = 0] = "Up";
+    VoxelFaces[VoxelFaces["Down"] = 1] = "Down";
+    VoxelFaces[VoxelFaces["North"] = 2] = "North";
+    VoxelFaces[VoxelFaces["South"] = 3] = "South";
+    VoxelFaces[VoxelFaces["East"] = 4] = "East";
+    VoxelFaces[VoxelFaces["West"] = 5] = "West";
+})(VoxelFaces || (VoxelFaces = {}));
+export const VoxelFacesArray = Object.freeze([
+    VoxelFaces.Up,
+    VoxelFaces.Down,
+    VoxelFaces.North,
+    VoxelFaces.South,
+    VoxelFaces.East,
+    VoxelFaces.West,
+]);
+export const VoxelFaceDirections = Object.freeze({
+    [VoxelFaces.Up]: [0, 1, 0],
+    [VoxelFaces.Down]: [0, -1, 0],
+    [VoxelFaces.North]: [0, 0, 1],
+    [VoxelFaces.South]: [0, 0, -1],
+    [VoxelFaces.East]: [1, 0, 0],
+    [VoxelFaces.West]: [-1, 0, 0],
+});
+export const VoxelFaceOpositeDirectionMap = {
+    [VoxelFaces.Up]: VoxelFaces.Down,
+    [VoxelFaces.Down]: VoxelFaces.Up,
+    [VoxelFaces.North]: VoxelFaces.South,
+    [VoxelFaces.South]: VoxelFaces.North,
+    [VoxelFaces.East]: VoxelFaces.West,
+    [VoxelFaces.West]: VoxelFaces.East,
+};
+export const VoxelFaceCompassDirectionMap = {
+    [VoxelFaces.Up]: CompassDirections.North,
+    [VoxelFaces.Down]: CompassDirections.South,
+    [VoxelFaces.North]: CompassDirections.North,
+    [VoxelFaces.South]: CompassDirections.South,
+    [VoxelFaces.East]: CompassDirections.East,
+    [VoxelFaces.West]: CompassDirections.West,
+};
+export const CompassDirectionVoxelFaceMap = {
+    [CompassDirections.North]: VoxelFaces.North,
+    [CompassDirections.South]: VoxelFaces.South,
+    [CompassDirections.West]: VoxelFaces.West,
+    [CompassDirections.East]: VoxelFaces.East,
+    [CompassDirections.NorthEast]: VoxelFaces.Up,
+    [CompassDirections.NorthWest]: VoxelFaces.Up,
+    [CompassDirections.SouthEast]: VoxelFaces.Up,
+    [CompassDirections.SouthWest]: VoxelFaces.Up,
+};
+export const VoxelFaceNameRecord = {
+    up: VoxelFaces.Up,
+    down: VoxelFaces.Down,
+    north: VoxelFaces.North,
+    south: VoxelFaces.South,
+    east: VoxelFaces.East,
+    west: VoxelFaces.West,
+};
+export const VoxelFaceNameMap = {
+    [VoxelFaces.Up]: "up",
+    [VoxelFaces.Down]: "down",
+    [VoxelFaces.North]: "north",
+    [VoxelFaces.South]: "south",
+    [VoxelFaces.East]: "east",
+    [VoxelFaces.West]: "west",
+};

package/Math/Math.types.d.ts

@@ -0,0 +1,25 @@
+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/Math.types.js

@@ -0,0 +1 @@
+export {};

package/Math/Objects/CompassDirection.d.ts

@@ -0,0 +1,9 @@
+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;
+};