@matboks/utilities 0.0.1

package/dist/geometry/vec3.d.ts

@@ -0,0 +1,102 @@
+import { Vec2 } from "./vec2.js";
+export declare function vec3(vector: Vec2, z: number): Vec3;
+export declare function vec3(vector: Vec3): Vec3;
+export declare function vec3(x: number, y?: number, z?: number): Vec3;
+export declare class Vec3 {
+    x: number;
+    y: number;
+    z: number;
+    length(): number;
+    lengthSquared(): number;
+    get xx(): Vec2;
+    get yy(): Vec2;
+    get zz(): Vec2;
+    get xy(): Vec2;
+    get xz(): Vec2;
+    get yx(): Vec2;
+    get yz(): Vec2;
+    get zx(): Vec2;
+    get zy(): Vec2;
+    get xxx(): Vec3;
+    get xxy(): Vec3;
+    get xxz(): Vec3;
+    get xyx(): Vec3;
+    get xyy(): Vec3;
+    get xyz(): Vec3;
+    get xzx(): Vec3;
+    get xzy(): Vec3;
+    get xzz(): Vec3;
+    get yxx(): Vec3;
+    get yxy(): Vec3;
+    get yxz(): Vec3;
+    get yyx(): Vec3;
+    get yyy(): Vec3;
+    get yyz(): Vec3;
+    get yzx(): Vec3;
+    get yzy(): Vec3;
+    get yzz(): Vec3;
+    get zxx(): Vec3;
+    get zxy(): Vec3;
+    get zxz(): Vec3;
+    get zyx(): Vec3;
+    get zyy(): Vec3;
+    get zyz(): Vec3;
+    get zzx(): Vec3;
+    get zzy(): Vec3;
+    get zzz(): Vec3;
+    constructor(vector: Vec2, z: number);
+    constructor(vector: Vec3);
+    constructor(x: number, y?: number, z?: number);
+    static add(...vectors: Array<Vec3>): Vec3;
+    static subtract(left: Vec3, right: Vec3): Vec3;
+    static multiply(vector: Vec3, value: number | Vec3): Vec3;
+    static dot(a: Vec3, b: Vec3): number;
+    static cross(a: Vec3, b: Vec3): Vec3;
+    static interpolate(start: Vec3, end: Vec3, position: number): Vec3;
+    static midpoint(start: Vec3, end: Vec3): Vec3;
+    static absolute(vector: Vec3): Vec3;
+    static distance(a: Vec3, b: Vec3): number;
+    static angle(start: Vec3, end: Vec3): number;
+    static axisAngleRotation(vector: Vec3, axis: Vec3, rotation: number): Vec3;
+    static smoothstep(vector: Vec3, lower?: number | Vec3, upper?: number | Vec3): Vec3;
+    setX(x: number): this;
+    setY(y: number): this;
+    setZ(z: number): this;
+    setCoordinates(vector: Vec2, z: number): Vec3;
+    setCoordinates(vector: Vec3): Vec3;
+    setCoordinates(x: number, y?: number, z?: number): Vec3;
+    clone(): Vec3;
+    copy(vector: Vec3): Vec3;
+    plus(vector: Vec3): Vec3;
+    minus(vector: Vec3): Vec3;
+    times(value: number | Vec3): Vec3;
+    distance(vector: Vec3): number;
+    distanceSquared(vector: Vec3): number;
+    dot(vector: Vec3): number;
+    cross(vector: Vec3): Vec3;
+    axisAngleRotate(axis: Vec3, rotation: number): this;
+    scalarProjectOnto(target: Vec3): number;
+    projectOnto(target: Vec3): Vec3;
+    scalarRejectOnto(target: Vec3): number;
+    rejectOnto(target: Vec3): Vec3;
+    reflectByVector(vector: Vec3): Vec3;
+    reflectByPoint(point: Vec3): Vec3;
+    normalize(): Vec3;
+    absolute(): Vec3;
+    negate(): Vec3;
+    floor(): Vec3;
+    round(): Vec3;
+    fract(): Vec3;
+    smoothstep(lower?: number | Vec3, upper?: number | Vec3): Vec3;
+    min(): number;
+    max(): number;
+    mod(modulo: number | Vec3): Vec3;
+    clamp(lower?: number | Vec3, upper?: number | Vec3): Vec3;
+    signed(): Vec3;
+    pow(power: number | Vec3): Vec3;
+    reflect(vector: Vec3): Vec3;
+    splitIntoIntAndFract(): [Vec3, Vec3];
+    toArray(): number[];
+    toVec2(): Vec2;
+    toHexColor(alpha?: number): string;
+}

package/dist/geometry/vec3.js

@@ -0,0 +1,256 @@
+import { clamp, fract, mod, smoothstep } from "../math/index.js";
+import { splitIntoIntAndFract } from "../math/split-into-int-and-fract.js";
+import { Vec2, vec2 } from "./vec2.js";
+export function vec3(...args) {
+    return new Vec3(args[0], args[1], args[2]);
+}
+const { floor, round, hypot, acos, cos, sin, abs, min, max, pow } = Math;
+export class Vec3 {
+    length() { return hypot(this.x, this.y, this.z); }
+    lengthSquared() { const x = this.x, y = this.y, z = this.z; return x * x + y * y + z * z; }
+    get xx() { return vec2(this.x); }
+    get yy() { return vec2(this.y); }
+    get zz() { return vec2(this.z); }
+    get xy() { return vec2(this.x, this.y); }
+    get xz() { return vec2(this.x, this.z); }
+    get yx() { return vec2(this.y, this.x); }
+    get yz() { return vec2(this.y, this.z); }
+    get zx() { return vec2(this.z, this.x); }
+    get zy() { return vec2(this.z, this.y); }
+    get xxx() { return vec3(this.x, this.x, this.x); }
+    get xxy() { return vec3(this.x, this.x, this.y); }
+    get xxz() { return vec3(this.x, this.x, this.z); }
+    get xyx() { return vec3(this.x, this.y, this.x); }
+    get xyy() { return vec3(this.x, this.y, this.y); }
+    get xyz() { return vec3(this.x, this.y, this.z); }
+    get xzx() { return vec3(this.x, this.z, this.x); }
+    get xzy() { return vec3(this.x, this.z, this.y); }
+    get xzz() { return vec3(this.x, this.z, this.z); }
+    get yxx() { return vec3(this.y, this.x, this.x); }
+    get yxy() { return vec3(this.y, this.x, this.y); }
+    get yxz() { return vec3(this.y, this.x, this.z); }
+    get yyx() { return vec3(this.y, this.y, this.x); }
+    get yyy() { return vec3(this.y, this.y, this.y); }
+    get yyz() { return vec3(this.y, this.y, this.z); }
+    get yzx() { return vec3(this.y, this.z, this.x); }
+    get yzy() { return vec3(this.y, this.z, this.y); }
+    get yzz() { return vec3(this.y, this.z, this.z); }
+    get zxx() { return vec3(this.z, this.x, this.x); }
+    get zxy() { return vec3(this.z, this.x, this.y); }
+    get zxz() { return vec3(this.z, this.x, this.z); }
+    get zyx() { return vec3(this.z, this.y, this.x); }
+    get zyy() { return vec3(this.z, this.y, this.y); }
+    get zyz() { return vec3(this.z, this.y, this.z); }
+    get zzx() { return vec3(this.z, this.z, this.x); }
+    get zzy() { return vec3(this.z, this.z, this.y); }
+    get zzz() { return vec3(this.z, this.z, this.z); }
+    constructor(...args) {
+        this.setCoordinates(args[0], args[1], args[2]);
+    }
+    static add(...vectors) {
+        let sum = vec3(0);
+        for (let vector of vectors)
+            sum.plus(vector);
+        return sum;
+    }
+    static subtract(left, right) {
+        return left.clone().minus(right);
+    }
+    static multiply(vector, value) {
+        return vector.clone().times(value);
+    }
+    static dot(a, b) {
+        return a.dot(b);
+    }
+    static cross(a, b) {
+        return a.cross(b);
+    }
+    static interpolate(start, end, position) {
+        return start.clone().times(1 - position).plus(Vec3.multiply(end, position));
+    }
+    static midpoint(start, end) {
+        return Vec3.interpolate(start, end, 0.5);
+    }
+    static absolute(vector) {
+        return vector.clone().absolute();
+    }
+    static distance(a, b) {
+        return Vec3.subtract(b, a).length();
+    }
+    static angle(start, end) {
+        return acos(start.dot(end) / (start.length() * end.length()));
+    }
+    static axisAngleRotation(vector, axis, rotation) {
+        return vector.clone().axisAngleRotate(axis, rotation);
+    }
+    static smoothstep(vector, lower = 0, upper = 1) {
+        return vector.clone().smoothstep(lower, upper);
+    }
+    setX(x) {
+        this.x = x;
+        return this;
+    }
+    setY(y) {
+        this.y = y;
+        return this;
+    }
+    setZ(z) {
+        this.z = z;
+        return this;
+    }
+    setCoordinates(...args) {
+        const [a, b, c] = args;
+        if (a instanceof Vec3) {
+            this.x = a.x;
+            this.y = a.y;
+            this.z = a.z;
+        }
+        else if (a instanceof Vec2) {
+            this.x = a.x;
+            this.y = a.y;
+            this.z = b;
+        }
+        else if (b !== undefined && c === undefined) {
+            this.x = a;
+            this.y = b;
+            this.z = 0;
+        }
+        else {
+            this.x = a;
+            this.y = b ?? a;
+            this.z = c ?? a;
+        }
+        return this;
+    }
+    clone() {
+        return vec3(this.x, this.y, this.z);
+    }
+    copy(vector) {
+        return this.setCoordinates(vector);
+    }
+    plus(vector) {
+        return this.setCoordinates(this.x + vector.x, this.y + vector.y, this.z + vector.z);
+    }
+    minus(vector) {
+        return this.setCoordinates(this.x - vector.x, this.y - vector.y, this.z - vector.z);
+    }
+    times(value) {
+        value = ensureVec3(value);
+        return this.setCoordinates(value.x * this.x, value.y * this.y, value.z * this.z);
+    }
+    distance(vector) {
+        return hypot(vector.x - this.x, vector.y - this.y, vector.z - this.z);
+    }
+    distanceSquared(vector) {
+        let dx = vector.x - this.x;
+        let dy = vector.y - this.y;
+        let dz = vector.z - this.z;
+        return dx * dx + dy * dy + dz * dz;
+    }
+    dot(vector) {
+        return this.x * vector.x + this.y * vector.y + this.z * vector.z;
+    }
+    cross(vector) {
+        let { x: x0, y: y0, z: z0 } = this;
+        let { x: x1, y: y1, z: z1 } = vector;
+        return vec3(y0 * z1 - z0 * y1, z0 * x1 - x0 * z1, x0 * y1 - y0 * x1);
+    }
+    axisAngleRotate(axis, rotation) {
+        const c = cos(rotation);
+        const s = sin(rotation);
+        // Rodrigues rotation formula
+        this.setCoordinates(Vec3.add(Vec3.multiply(this, c), Vec3.multiply(axis.cross(this), s), Vec3.multiply(axis, (1 - c) * axis.dot(this))));
+        return this;
+    }
+    scalarProjectOnto(target) {
+        return this.dot(target) / target.lengthSquared();
+    }
+    projectOnto(target) {
+        return target.clone().times(this.scalarProjectOnto(target));
+    }
+    scalarRejectOnto(target) {
+        return this.rejectOnto(target).length();
+    }
+    rejectOnto(target) {
+        return Vec3.subtract(this, this.projectOnto(target));
+    }
+    reflectByVector(vector) {
+        const rejection = this.rejectOnto(vector);
+        return this.clone().minus(rejection.times(2));
+    }
+    reflectByPoint(point) {
+        const translation = Vec3.subtract(point, this).times(2);
+        return this.clone().minus(translation);
+    }
+    normalize() {
+        return this.times(1 / this.length());
+    }
+    absolute() {
+        return this.setCoordinates(abs(this.x), abs(this.y), abs(this.z));
+    }
+    negate() {
+        return this.times(-1);
+    }
+    floor() {
+        return this.setCoordinates(floor(this.x), floor(this.y), floor(this.z));
+    }
+    round() {
+        return this.setCoordinates(round(this.x), round(this.y), round(this.z));
+    }
+    fract() {
+        return this.setCoordinates(fract(this.x), fract(this.y), fract(this.z));
+    }
+    smoothstep(lower = 0, upper = 1) {
+        lower = ensureVec3(lower);
+        upper = ensureVec3(upper);
+        return this.setCoordinates(smoothstep(this.x, lower.x, upper.x), smoothstep(this.y, lower.y, upper.y), smoothstep(this.z, lower.z, upper.z));
+    }
+    min() {
+        return min(this.x, this.y, this.z);
+    }
+    max() {
+        return max(this.x, this.y, this.z);
+    }
+    mod(modulo) {
+        modulo = ensureVec3(modulo);
+        return this.setCoordinates(mod(this.x, modulo.x), mod(this.y, modulo.y), mod(this.z, modulo.z));
+    }
+    clamp(lower = 0, upper = 1) {
+        lower = ensureVec3(lower);
+        upper = ensureVec3(upper);
+        return this.setCoordinates(clamp(this.x, lower.x, upper.x), clamp(this.y, lower.y, upper.y), clamp(this.z, lower.z, upper.z));
+    }
+    signed() {
+        return this.times(2).plus(vec3(-1));
+    }
+    pow(power) {
+        power = ensureVec3(power);
+        return this.setCoordinates(pow(this.x, power.x), pow(this.y, power.y), pow(this.z, power.z));
+    }
+    reflect(vector) {
+        const normalizedVector = vector.clone().normalize();
+        const reflectedVector = Vec3.subtract(this, Vec3.multiply(normalizedVector, 2 * this.dot(normalizedVector)));
+        return this.setCoordinates(reflectedVector);
+    }
+    splitIntoIntAndFract() {
+        const [xi, xf] = splitIntoIntAndFract(this.x);
+        const [yi, yf] = splitIntoIntAndFract(this.y);
+        const [zi, zf] = splitIntoIntAndFract(this.z);
+        return [vec3(xi, yi, zi), vec3(xf, yf, zf)];
+    }
+    toArray() {
+        return [this.x, this.y, this.z];
+    }
+    toVec2() {
+        return vec2(this.x, this.y);
+    }
+    toHexColor(alpha) {
+        const values = this.toArray();
+        if (alpha !== undefined)
+            values.push(alpha);
+        return "#" + values.map((v) => Math.floor(255 * v).toString(16).padStart(2, "0")).join("");
+    }
+}
+function ensureVec3(value) {
+    return value = typeof value === "number" ? vec3(value) : value;
+}

package/dist/geometry/vec4.d.ts

@@ -0,0 +1,71 @@
+import { Vec2 } from "./vec2.js";
+import { Vec3 } from "./vec3.js";
+export declare function vec4(vector: Vec4): Vec4;
+export declare function vec4(vector: Vec3, w: number): Vec4;
+export declare function vec4(vector: Vec2, z: number, w: number): Vec4;
+export declare function vec4(x: number, y?: number, z?: number, w?: number): Vec4;
+export declare class Vec4 {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+    length(): number;
+    lengthSquared(): number;
+    constructor(vector: Vec4);
+    constructor(vector: Vec3, w: number);
+    constructor(vector: Vec2, z: number, w: number);
+    constructor(x: number, y?: number, z?: number, w?: number);
+    static add(...vectors: Array<Vec4>): Vec4;
+    static subtract(left: Vec4, right: Vec4): Vec4;
+    static multiply(vector: Vec4, value: number | Vec4): Vec4;
+    static dot(a: Vec4, b: Vec4): number;
+    static cross(a: Vec4, b: Vec4): Vec4;
+    static interpolate(start: Vec4, end: Vec4, position: number): Vec4;
+    static midpoint(start: Vec4, end: Vec4): Vec4;
+    static absolute(vector: Vec4): Vec4;
+    static distance(a: Vec4, b: Vec4): number;
+    static angle(start: Vec4, end: Vec4): number;
+    static axisAngleRotation(vector: Vec4, axis: Vec4, rotation: number): Vec4;
+    static smoothstep(vector: Vec4, lower?: number | Vec4, upper?: number | Vec4): Vec4;
+    setX(x: number): this;
+    setY(y: number): this;
+    setZ(z: number): this;
+    setW(w: number): this;
+    setCoordinates(vector: Vec4): Vec4;
+    setCoordinates(vector: Vec3, w: number): Vec4;
+    setCoordinates(vector: Vec2, z: number, w: number): Vec4;
+    setCoordinates(x: number, y?: number, z?: number, w?: number): Vec4;
+    clone(): Vec4;
+    copy(vector: Vec4): Vec4;
+    plus(vector: Vec4): Vec4;
+    minus(vector: Vec4): Vec4;
+    times(value: number | Vec4): Vec4;
+    distance(vector: Vec4): number;
+    distanceSquared(vector: Vec4): number;
+    dot(vector: Vec4): number;
+    cross(_vector: Vec4): Vec4;
+    axisAngleRotate(axis: Vec4, rotation: number): this;
+    scalarProjectOnto(target: Vec4): number;
+    projectOnto(target: Vec4): Vec4;
+    scalarRejectOnto(target: Vec4): number;
+    rejectOnto(target: Vec4): Vec4;
+    reflectByVector(vector: Vec4): Vec4;
+    reflectByPoint(point: Vec4): Vec4;
+    normalize(): Vec4;
+    absolute(): Vec4;
+    negate(): Vec4;
+    floor(): Vec4;
+    round(): Vec4;
+    fract(): Vec4;
+    smoothstep(lower?: number | Vec4, upper?: number | Vec4): Vec4;
+    min(): number;
+    max(): number;
+    mod(modulo: number | Vec4): Vec4;
+    clamp(lower?: number | Vec4, upper?: number | Vec4): Vec4;
+    signed(): Vec4;
+    pow(power: number | Vec4): Vec4;
+    reflect(vector: Vec4): Vec4;
+    splitIntoIntAndFract(): [Vec4, Vec4];
+    toArray(): number[];
+    toHexColor(): string;
+}

package/dist/geometry/vec4.js

@@ -0,0 +1,238 @@
+import { clamp, fract, mod, smoothstep } from "../math/index.js";
+import { splitIntoIntAndFract } from "../math/split-into-int-and-fract.js";
+import { Vec2 } from "./vec2.js";
+import { Vec3 } from "./vec3.js";
+export function vec4(...args) {
+    return new Vec4(args[0], args[1], args[2], args[3]);
+}
+const { floor, round, hypot, acos, cos, sin, abs, min, max, pow } = Math;
+export class Vec4 {
+    length() { return hypot(this.x, this.y, this.z, this.w); }
+    lengthSquared() { const { x, y, z, w } = this; return x * x + y * y + z * z + w * w; }
+    constructor(...args) {
+        this.setCoordinates(args[0], args[1], args[2], args[3]);
+        ;
+    }
+    static add(...vectors) {
+        let sum = vec4(0);
+        for (let vector of vectors)
+            sum.plus(vector);
+        return sum;
+    }
+    static subtract(left, right) {
+        return left.clone().minus(right);
+    }
+    static multiply(vector, value) {
+        return vector.clone().times(value);
+    }
+    static dot(a, b) {
+        return a.dot(b);
+    }
+    static cross(a, b) {
+        return a.cross(b);
+    }
+    static interpolate(start, end, position) {
+        return start.clone().times(1 - position).plus(Vec4.multiply(end, position));
+    }
+    static midpoint(start, end) {
+        return Vec4.interpolate(start, end, 0.5);
+    }
+    static absolute(vector) {
+        return vector.clone().absolute();
+    }
+    static distance(a, b) {
+        return Vec4.subtract(b, a).length();
+    }
+    static angle(start, end) {
+        return acos(start.dot(end) / (start.length() * end.length()));
+    }
+    static axisAngleRotation(vector, axis, rotation) {
+        return vector.clone().axisAngleRotate(axis, rotation);
+    }
+    static smoothstep(vector, lower = 0, upper = 1) {
+        return vector.clone().smoothstep(lower, upper);
+    }
+    setX(x) {
+        this.x = x;
+        return this;
+    }
+    setY(y) {
+        this.y = y;
+        return this;
+    }
+    setZ(z) {
+        this.z = z;
+        return this;
+    }
+    setW(w) {
+        this.w = w;
+        return this;
+    }
+    setCoordinates(...args) {
+        const [a, b, c, d] = args;
+        if (a instanceof Vec4) {
+            this.x = a.x;
+            this.y = a.y;
+            this.z = a.z;
+            this.w = a.w;
+        }
+        else if (a instanceof Vec3) {
+            this.x = a.x;
+            this.y = a.y;
+            this.z = a.z;
+            this.w = b;
+        }
+        else if (a instanceof Vec2) {
+            this.x = a.x;
+            this.y = a.y;
+            this.z = b;
+            this.w = c;
+        }
+        else if (b !== undefined && c !== undefined && d === undefined) {
+            this.x = a;
+            this.y = b;
+            this.z = c;
+            this.w = 1;
+        }
+        else {
+            this.x = a;
+            this.y = b ?? a;
+            this.z = c ?? a;
+            this.w = d ?? 1;
+        }
+        return this;
+    }
+    clone() {
+        return vec4(this.x, this.y, this.z, this.w);
+    }
+    copy(vector) {
+        return this.setCoordinates(vector);
+    }
+    plus(vector) {
+        return this.setCoordinates(this.x + vector.x, this.y + vector.y, this.z + vector.z, this.w + vector.w);
+    }
+    minus(vector) {
+        return this.setCoordinates(this.x - vector.x, this.y - vector.y, this.z - vector.z, this.w - vector.w);
+    }
+    times(value) {
+        value = ensureVec4(value);
+        return this.setCoordinates(value.x * this.x, value.y * this.y, value.z * this.z, value.w * this.w);
+    }
+    distance(vector) {
+        return hypot(vector.x - this.x, vector.y - this.y, vector.z - this.z, vector.w - this.w);
+    }
+    distanceSquared(vector) {
+        let dx = vector.x - this.x;
+        let dy = vector.y - this.y;
+        let dz = vector.z - this.z;
+        let dw = vector.w - this.w;
+        return dx * dx + dy * dy + dz * dz + dw * dw;
+    }
+    dot(vector) {
+        return this.x * vector.x + this.y * vector.y + this.z * vector.z + this.w * vector.w;
+    }
+    cross(_vector) {
+        throw new Error("Not yet implemented");
+        // let { x: x0, y: y0, z: z0 } = this;
+        // let { x: x1, y: y1, z: z1 } = vector;
+        // return Vec4(
+        //   y0 * z1 - z0 * y1,
+        //   z0 * x1 - x0 * z1,
+        //   x0 * y1 - y0 * x1
+        // );
+    }
+    axisAngleRotate(axis, rotation) {
+        const c = cos(rotation);
+        const s = sin(rotation);
+        // Rodrigues rotation formula
+        this.setCoordinates(Vec4.add(Vec4.multiply(this, c), Vec4.multiply(axis.cross(this), s), Vec4.multiply(axis, (1 - c) * axis.dot(this))));
+        return this;
+    }
+    scalarProjectOnto(target) {
+        return this.dot(target) / target.lengthSquared();
+    }
+    projectOnto(target) {
+        return target.clone().times(this.scalarProjectOnto(target));
+    }
+    scalarRejectOnto(target) {
+        return this.rejectOnto(target).length();
+    }
+    rejectOnto(target) {
+        return Vec4.subtract(this, this.projectOnto(target));
+    }
+    reflectByVector(vector) {
+        const rejection = this.rejectOnto(vector);
+        return this.clone().minus(rejection.times(2));
+    }
+    reflectByPoint(point) {
+        const translation = Vec4.subtract(point, this).times(2);
+        return this.clone().minus(translation);
+    }
+    normalize() {
+        return this.times(1 / this.length());
+    }
+    absolute() {
+        return this.setCoordinates(abs(this.x), abs(this.y), abs(this.z), abs(this.w));
+    }
+    negate() {
+        return this.times(-1);
+    }
+    floor() {
+        return this.setCoordinates(floor(this.x), floor(this.y), floor(this.z), floor(this.w));
+    }
+    round() {
+        return this.setCoordinates(round(this.x), round(this.y), round(this.z), round(this.w));
+    }
+    fract() {
+        return this.setCoordinates(fract(this.x), fract(this.y), fract(this.z), fract(this.w));
+    }
+    smoothstep(lower = 0, upper = 1) {
+        lower = ensureVec4(lower);
+        upper = ensureVec4(upper);
+        return this.setCoordinates(smoothstep(this.x, lower.x, upper.x), smoothstep(this.y, lower.y, upper.y), smoothstep(this.z, lower.z, upper.z), smoothstep(this.w, lower.w, upper.w));
+    }
+    min() {
+        return min(this.x, this.y, this.z, this.w);
+    }
+    max() {
+        return max(this.x, this.y, this.z, this.w);
+    }
+    mod(modulo) {
+        modulo = ensureVec4(modulo);
+        return this.setCoordinates(mod(this.x, modulo.x), mod(this.y, modulo.y), mod(this.z, modulo.z), mod(this.w, modulo.w));
+    }
+    clamp(lower = 0, upper = 1) {
+        lower = ensureVec4(lower);
+        upper = ensureVec4(upper);
+        return this.setCoordinates(clamp(this.x, lower.x, upper.x), clamp(this.y, lower.y, upper.y), clamp(this.z, lower.z, upper.z), clamp(this.w, lower.w, upper.w));
+    }
+    signed() {
+        return this.times(2).plus(vec4(-1));
+    }
+    pow(power) {
+        power = ensureVec4(power);
+        return this.setCoordinates(pow(this.x, power.x), pow(this.y, power.y), pow(this.z, power.z), pow(this.w, power.w));
+    }
+    reflect(vector) {
+        const normalizedVector = vector.clone().normalize();
+        const reflectedVector = Vec4.subtract(this, Vec4.multiply(normalizedVector, 2 * this.dot(normalizedVector)));
+        return this.setCoordinates(reflectedVector);
+    }
+    splitIntoIntAndFract() {
+        const [xi, xf] = splitIntoIntAndFract(this.x);
+        const [yi, yf] = splitIntoIntAndFract(this.y);
+        const [zi, zf] = splitIntoIntAndFract(this.z);
+        const [wi, wf] = splitIntoIntAndFract(this.w);
+        return [vec4(xi, yi, zi, wi), vec4(xf, yf, zf, wf)];
+    }
+    toArray() {
+        return [this.x, this.y, this.z, this.w];
+    }
+    toHexColor() {
+        const values = this.toArray();
+        return "#" + values.map((v) => Math.floor(255 * v).toString(16).padStart(2, "0")).join("");
+    }
+}
+function ensureVec4(value) {
+    return value = typeof value === "number" ? vec4(value) : value;
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./geometry/index.js";
+export * from "./math/index.js";
+export * from "./utilities/index.js";
+export * from "./noise/index.js";
+export * from "./constants.js";
+export * from "./tilings/index.js";
+export * from "./transforms/index.js";
+export * from "./types.js";
+export * from "./shader-renderer/index.js";
+export * from "./shader-modules/index.js";
+export * from "./constants.js";

package/dist/index.js

@@ -0,0 +1,11 @@
+export * from "./geometry/index.js";
+export * from "./math/index.js";
+export * from "./utilities/index.js";
+export * from "./noise/index.js";
+export * from "./constants.js";
+export * from "./tilings/index.js";
+export * from "./transforms/index.js";
+export * from "./types.js";
+export * from "./shader-renderer/index.js";
+export * from "./shader-modules/index.js";
+export * from "./constants.js";

package/dist/math/clamp.d.ts

@@ -0,0 +1 @@
+export declare function clamp(value: number, lower?: number, upper?: number): number;

package/dist/math/clamp.js

@@ -0,0 +1,5 @@
+export function clamp(value, lower = 0, upper = 1) {
+    return value < lower ? lower :
+        value > upper ? upper :
+            value;
+}