@divinevoxel/vlox 0.0.0

package/Math/Objects/CompassDirection.js

@@ -0,0 +1,19 @@
+/**# 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

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

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

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

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

package/Math/Spaces/VoxelSpaces.types.d.ts

@@ -0,0 +1,6 @@
+export type LocationData = [
+    dimensionId: string,
+    x: number,
+    y: number,
+    z: number
+];

package/Math/Spaces/VoxelSpaces.types.js

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

package/Math/VisitAll.d.ts

@@ -0,0 +1,10 @@
+import { Vector3Like } from "@amodx/math";
+/** # Visit All
+ * ---
+ * Given a starting point and an end point it will visit all voxels that are between them.
+ * @param startPoint
+ * @param endPoint
+ * @param visitor
+ * @returns an array of numbers with a stride of 3 for positions
+ */
+export declare const VisitAll: (startPoint: Vector3Like, endPoint: Vector3Like, visitor?: (x: number, y: number, z: number) => boolean) => number[];

package/Math/VisitAll.js

@@ -0,0 +1,69 @@
+/** # Visit All
+ * ---
+ * Given a starting point and an end point it will visit all voxels that are between them.
+ * @param startPoint
+ * @param endPoint
+ * @param visitor
+ * @returns an array of numbers with a stride of 3 for positions
+ */
+export const VisitAll = (startPoint, endPoint, visitor = (x, y, z) => {
+    return true;
+}) => {
+    const gx0 = startPoint.x;
+    const gy0 = startPoint.y;
+    const gz0 = startPoint.z;
+    const gx1 = endPoint.x;
+    const gy1 = endPoint.y;
+    const gz1 = endPoint.z;
+    const positons = [];
+    const gx0idx = Math.floor(gx0);
+    const gy0idx = Math.floor(gy0);
+    const gz0idx = Math.floor(gz0);
+    const gx1idx = Math.floor(gx1);
+    const gy1idx = Math.floor(gy1);
+    const gz1idx = Math.floor(gz1);
+    const sx = gx1idx > gx0idx ? 1 : gx1idx < gx0idx ? -1 : 0;
+    const sy = gy1idx > gy0idx ? 1 : gy1idx < gy0idx ? -1 : 0;
+    const sz = gz1idx > gz0idx ? 1 : gz1idx < gz0idx ? -1 : 0;
+    let gx = gx0idx;
+    let gy = gy0idx;
+    let gz = gz0idx;
+    const gxp = gx0idx + (gx1idx > gx0idx ? 1 : 0);
+    const gyp = gy0idx + (gy1idx > gy0idx ? 1 : 0);
+    const gzp = gz0idx + (gz1idx > gz0idx ? 1 : 0);
+    const vx = gx1 === gx0 ? 1 : gx1 - gx0;
+    const vy = gy1 === gy0 ? 1 : gy1 - gy0;
+    const vz = gz1 === gz0 ? 1 : gz1 - gz0;
+    const vxvy = vx * vy;
+    const vxvz = vx * vz;
+    const vyvz = vy * vz;
+    let errx = (gxp - gx0) * vyvz;
+    let erry = (gyp - gy0) * vxvz;
+    let errz = (gzp - gz0) * vxvy;
+    const derrx = sx * vyvz;
+    const derry = sy * vxvz;
+    const derrz = sz * vxvy;
+    do {
+        if (!visitor(gx, gy, gz))
+            break;
+        positons.push(gx, gy, gz);
+        if (gx === gx1idx && gy === gy1idx && gz === gz1idx)
+            break;
+        let xr = Math.abs(errx);
+        let yr = Math.abs(erry);
+        let zr = Math.abs(errz);
+        if (sx !== 0 && (sy === 0 || xr < yr) && (sz === 0 || xr < zr)) {
+            gx += sx;
+            errx += derrx;
+        }
+        else if (sy !== 0 && (sz === 0 || yr < zr)) {
+            gy += sy;
+            erry += derry;
+        }
+        else if (sz !== 0) {
+            gz += sz;
+            errz += derrz;
+        }
+    } while (true);
+    return positons;
+};

package/Math/VoxelMath.d.ts

@@ -0,0 +1,21 @@
+import { BoundingBox, BoundingBoxData } from "./Classes/BoundingBox.js";
+import { Plane } from "./Classes/Plane.js";
+import { SimpleBoundingBox } from "./Classes/SimpleBoundingBox.js";
+import { Vector3 } from "./Classes/Vector3.js";
+import { VolumeDimensions } from "./Math.types.js";
+/**# Voxel Math
+ * ---
+ * Can be used in any thread that needs it.
+ * Has functions for collision detection, finding voxels in a direction, and path finding.
+ */
+export declare const VoxelMath: {
+    visitAll: (startPoint: import("@amodx/math").Vector3Like, endPoint: import("@amodx/math").Vector3Like, visitor?: (x: number, y: number, z: number) => boolean) => number[];
+    getVector3(x: number, y: number, z: number): Vector3;
+    getPlane(pv1: Vector3, pv2: Vector3, pv3: Vector3, pv4: Vector3): Plane;
+    getSimpleBoundingBox(origin: Vector3, dimensions: VolumeDimensions): SimpleBoundingBox;
+    getBoundingBox(data: BoundingBoxData): BoundingBox;
+    convertToOriginGridSpace(position: number[]): number[];
+    distance2D(x1: number, x2: number, y1: number, y2: number): number;
+    distance3D(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number;
+};
+export type VoxelMath = typeof VoxelMath;

package/Math/VoxelMath.js

@@ -0,0 +1,47 @@
+import { BoundingBox } from "./Classes/BoundingBox.js";
+import { Plane } from "./Classes/Plane.js";
+import { SimpleBoundingBox } from "./Classes/SimpleBoundingBox.js";
+import { Vector3 } from "./Classes/Vector3.js";
+import { VisitAll } from "./VisitAll.js";
+/**# Voxel Math
+ * ---
+ * Can be used in any thread that needs it.
+ * Has functions for collision detection, finding voxels in a direction, and path finding.
+ */
+export const VoxelMath = {
+    visitAll: VisitAll,
+    getVector3(x, y, z) {
+        return new Vector3(x, y, z);
+    },
+    getPlane(pv1, pv2, pv3, pv4) {
+        return new Plane({
+            v1: pv1,
+            v2: pv2,
+            v3: pv3,
+            v4: pv4,
+        });
+    },
+    getSimpleBoundingBox(origin, dimensions) {
+        return new SimpleBoundingBox(origin, dimensions);
+    },
+    getBoundingBox(data) {
+        return new BoundingBox(data);
+    },
+    convertToOriginGridSpace(position) {
+        position[0] = Math.round(position[0]) + 0.5;
+        position[1] = Math.round(position[1]) + 0.5;
+        position[2] = Math.round(position[2]) + 0.5;
+        return position;
+    },
+    distance2D(x1, x2, y1, y2) {
+        var dx = x2 - x1;
+        var dy = y2 - y1;
+        return Math.sqrt(dx * dx + dy * dy);
+    },
+    distance3D(x1, y1, z1, x2, y2, z2) {
+        const a = x2 - x1;
+        const b = y2 - y1;
+        const c = z2 - z1;
+        return Math.sqrt(a * a + b * b + c * c);
+    },
+};

package/Math/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./VoxelMath.js";
+export * from "./Classes/BoundingBox.js";
+export * from "./Classes/Plane.js";
+export * from "./Classes/SimpleBoundingBox.js";
+export * from "./Classes/Vector3.js";
+export * from "./Classes/Vector3.js";
+export * from "./VisitAll.js";
+export * from "./Math.types.js";
+export * from "./Constants/VoxelFaces.js";
+export * from "./Spaces/VoxelSpaces.types.js";
+export * from "./Constants/VoxelFaces.js";

package/Math/index.js

@@ -0,0 +1,11 @@
+export * from "./VoxelMath.js";
+export * from "./Classes/BoundingBox.js";
+export * from "./Classes/Plane.js";
+export * from "./Classes/SimpleBoundingBox.js";
+export * from "./Classes/Vector3.js";
+export * from "./Classes/Vector3.js";
+export * from "./VisitAll.js";
+export * from "./Math.types.js";
+export * from "./Constants/VoxelFaces.js";
+export * from "./Spaces/VoxelSpaces.types.js";
+export * from "./Constants/VoxelFaces.js";

package/Mesher/Calc/CalcConstants.d.ts

@@ -0,0 +1,16 @@
+import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+import { VoxelFaces } from "../../Math";
+import { Vec3Array, Vec4Array } from "@amodx/math";
+import { Quad } from "@amodx/meshing/Classes/Quad";
+export declare const GradientCheckSets: Record<VoxelFaces, Record<QuadVerticies, number[]>>;
+export declare const GradientCheckSetsArray: Int8Array;
+export declare const GeometryCheckSetIndexes: Record<VoxelFaces, Record<QuadVerticies, [number, number, number]>>;
+export declare const CenterDirectionIndex: number;
+export declare const DirectionIndexes: Record<VoxelFaces, number>;
+export declare function shouldCauseFlip(topRight: number, topLeft: number, bottomLeft: number, bottomRight: number): boolean;
+export declare function getVertexWeights(face: VoxelFaces, x: number, y: number, z: number): Vec4Array;
+export declare function getInterpolationValue(value: Vec4Array, weights: Vec4Array): number;
+type QuadVertexWeights = [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
+export declare const addQuadWeights: (quad: Quad, direction: VoxelFaces) => QuadVertexWeights;
+export declare function closestUnitNormal(v: Vec3Array): Vec3Array;
+export {};