Favivon - Correção

node_modules/maath/dist/declarations/src/buffer.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Conventions:
+ * 1. try to avoid threejs dependencies, TBD how to solve them
+ * 2. use overload signatures to support stride 2 and 3 with ok typing
+ */
+import { Quaternion } from "three";
+import type { TypedArray, MyVector2, MyVector3 } from "./ctypes";
+import * as v2 from "./vector2";
+import * as v3 from "./vector3";
+export declare function swizzle(buffer: TypedArray, stride?: number, swizzle?: string): TypedArray;
+/**
+ * @param buffer A stride 2 points buffer
+ * @param valueGenerator A function that returns the value of the z axis at index i
+ * @returns
+ */
+export declare function addAxis(buffer: TypedArray, size: number, valueGenerator?: (j: number) => number): TypedArray;
+/**
+ * Lerps bufferA and bufferB into final
+ *
+ * @param bufferA
+ * @param bufferB
+ * @param final
+ * @param t
+ */
+export declare function lerp(bufferA: TypedArray, bufferB: TypedArray, final: TypedArray, t: number): void;
+/**
+ *
+ * Translate all points in the passed buffer by the passed translactionVector.
+ *
+ * @param buffer
+ * @param translationVector
+ * @returns
+ */
+export declare function translate(buffer: TypedArray, translationVector: MyVector2 | MyVector3): TypedArray;
+export declare function rotate(buffer: TypedArray, rotation: {
+    q: Quaternion;
+    center?: number[];
+}): TypedArray;
+export declare function map(buffer: TypedArray, stride: 2, fn: (v: v2.V2, i: number) => number[]): TypedArray;
+export declare function map(buffer: TypedArray, stride: 3, fn: (v: v3.V3, i: number) => number[]): TypedArray;
+/**
+ * Reduces passed buffer
+ */
+declare type IReduceCallback<T> = (final: T, point: v2.V2, i: number) => T;
+export declare function reduce<T>(b: TypedArray, stride: 2, callback: IReduceCallback<T>, acc: T): T;
+export declare function reduce<T>(b: TypedArray, stride: 3, callback: IReduceCallback<T>, acc: T): T;
+declare type ExpandOptions = {
+    center?: [number, number];
+    distance: number;
+};
+export declare function expand(b: TypedArray, stride: 2 | 3, opts: ExpandOptions): TypedArray;
+export declare function center(myBuffer: TypedArray, stride: 2): v2.V2;
+export declare function center(myBuffer: TypedArray, stride: 3): v3.V3;
+declare type ISortingCallback<T> = (a: T, b: T) => number;
+export declare function sort(myBuffer: TypedArray, stride: 2, callback: ISortingCallback<v2.V2>): TypedArray;
+export declare function sort(myBuffer: TypedArray, stride: 3, callback: ISortingCallback<v3.V3>): TypedArray;
+export {};

node_modules/maath/dist/declarations/src/ctypes.d.ts

@@ -0,0 +1,5 @@
+import { Vector2 } from "three";
+export declare type TypedArray = Float32Array | Float64Array;
+export declare type MyVector2 = number[];
+export declare type MyVector3 = number[];
+export declare type Triangle = [MyVector2, MyVector2, MyVector2] | Vector2[];

node_modules/maath/dist/declarations/src/easing.d.ts

@@ -0,0 +1,94 @@
+import { Vector2, Vector3, Vector4, Euler, Color, Matrix4, Quaternion, Spherical, ColorRepresentation } from "three";
+export declare const rsqw: (t: number, delta?: number, a?: number, f?: number) => number;
+export declare const exp: (t: number) => number;
+export declare const linear: (t: number) => number;
+export declare const sine: {
+    in: (x: number) => number;
+    out: (x: number) => number;
+    inOut: (x: number) => number;
+};
+export declare const cubic: {
+    in: (x: number) => number;
+    out: (x: number) => number;
+    inOut: (x: number) => number;
+};
+export declare const quint: {
+    in: (x: number) => number;
+    out: (x: number) => number;
+    inOut: (x: number) => number;
+};
+export declare const circ: {
+    in: (x: number) => number;
+    out: (x: number) => number;
+    inOut: (x: number) => number;
+};
+export declare const quart: {
+    in: (t: number) => number;
+    out: (t: number) => number;
+    inOut: (t: number) => number;
+};
+export declare const expo: {
+    in: (x: number) => number;
+    out: (x: number) => number;
+    inOut: (x: number) => number;
+};
+/**
+ * Damp, based on Game Programming Gems 4 Chapter 1.10
+ *   Return value indicates whether the animation is still running.
+ */
+export declare function damp(
+/** The object */
+current: {
+    [key: string]: any;
+}, 
+/** The key to animate */
+prop: string, 
+/** To goal value */
+target: number, 
+/** Approximate time to reach the target. A smaller value will reach the target faster. */
+smoothTime?: number, 
+/** Frame delta, for refreshrate independence */
+delta?: number, 
+/** Optionally allows you to clamp the maximum speed. If smoothTime is 0.25s and looks OK
+ *  going between two close points but not for points far apart as it'll move very rapid,
+ *  then a maxSpeed of e.g. 1 which will clamp the speed to 1 unit per second, it may now
+ *  take much longer than smoothTime to reach the target if it is far away. */
+maxSpeed?: number, 
+/** Easing function */
+easing?: (t: number) => number, 
+/** End of animation precision */
+eps?: number): boolean;
+export declare function dampLookAt(current: THREE.Object3D, target: number | [x: number, y: number, z: number] | Vector3, smoothTime?: number, delta?: number, maxSpeed?: number, easing?: (t: number) => number, eps?: number): void;
+/**
+ * DampAngle, with a shortest-path
+ */
+export declare function dampAngle(current: {
+    [key: string]: any;
+}, prop: string, target: number, smoothTime?: number, delta?: number, maxSpeed?: number, easing?: (t: number) => number, eps?: number): boolean;
+export declare function damp2(current: Vector2, target: number | [x: number, y: number] | Vector2, smoothTime?: number, delta?: number, maxSpeed?: number, easing?: (t: number) => number, eps?: number): boolean;
+export declare function damp3(current: Vector3, target: number | [x: number, y: number, z: number] | Vector3, smoothTime?: number, delta?: number, maxSpeed?: number, easing?: (t: number) => number, eps?: number): boolean;
+export declare function damp4(current: Vector4, target: number | [x: number, y: number, z: number, w: number] | Vector4, smoothTime?: number, delta?: number, maxSpeed?: number, easing?: (t: number) => number, eps?: number): boolean;
+declare type EulerOrder = "XYZ" | "YXZ" | "ZXY" | "ZYX" | "YZX" | "XZY";
+export declare function dampE(current: Euler, target: [x: number, y: number, z: number, order?: EulerOrder] | Euler, smoothTime?: number, delta?: number, maxSpeed?: number, easing?: (t: number) => number, eps?: number): boolean;
+export declare function dampC(current: Color, target: ColorRepresentation | [r: number, g: number, b: number], smoothTime?: number, delta?: number, maxSpeed?: number, easing?: (t: number) => number, eps?: number): boolean;
+export declare function dampQ(current: Quaternion, target: [x: number, y: number, z: number, w: number] | Quaternion, smoothTime?: number, delta?: number, maxSpeed?: number, easing?: (t: number) => number, eps?: number): boolean;
+export declare function dampS(current: Spherical, target: [radius: number, phi: number, theta: number] | Spherical, smoothTime?: number, delta?: number, maxSpeed?: number, easing?: (t: number) => number, eps?: number): boolean;
+export declare function dampM(current: Matrix4, target: [
+    n11: number,
+    n12: number,
+    n13: number,
+    n14: number,
+    n21: number,
+    n22: number,
+    n23: number,
+    n24: number,
+    n31: number,
+    n32: number,
+    n33: number,
+    n34: number,
+    n41: number,
+    n42: number,
+    n43: number,
+    n44: number
+] | Matrix4, smoothTime?: number, delta?: number, maxSpeed?: number, easing?: (t: number) => number, eps?: number): boolean;
+export {};

node_modules/maath/dist/declarations/src/geometry.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+export declare class RoundedPlaneGeometry extends THREE.BufferGeometry {
+    parameters: {
+        width: number;
+        height: number;
+        radius: number;
+        segments: number;
+    };
+    constructor(width?: number, height?: number, radius?: number, segments?: number);
+}
+export declare function applyCylindricalUV(bufferGeometry: THREE.BufferGeometry): THREE.BufferGeometry;
+export declare function applySphereUV(bufferGeometry: THREE.BufferGeometry): THREE.BufferGeometry;
+export declare function applyBoxUV(bufferGeometry: THREE.BufferGeometry): THREE.BufferGeometry;

node_modules/maath/dist/declarations/src/index.d.ts

@@ -0,0 +1,10 @@
+export * as buffer from "./buffer";
+export * as random from "./random";
+export * as easing from "./easing";
+export * as geometry from "./geometry";
+export * as matrix from "./matrix";
+export * as misc from "./misc";
+export * as three from "./three";
+export * as triangle from "./triangle";
+export * as vector2 from "./vector2";
+export * as vector3 from "./vector3";

node_modules/maath/dist/declarations/src/matrix.d.ts

@@ -0,0 +1,57 @@
+import { Matrix3, Matrix4 } from "three";
+/**
+ *
+ * @param terms
+ *
+ * | a b |
+ * | c d |
+ *
+ * @returns {number} determinant
+ */
+export declare function determinant2(...terms: number[]): number;
+/**
+ *
+ * @param terms
+ *
+ * | a b c |
+ * | d e f |
+ * | g h i |
+ *
+ * @returns {number} determinant
+ */
+export declare function determinant3(...terms: number[]): number;
+/**
+ *
+ * @param terms
+ *
+ * | a b c g |
+ * | h i j k |
+ * | l m n o |
+ *
+ * @returns {number} determinant
+ */
+export declare function determinant4(...terms: number[]): void;
+/**
+ *
+ * Get the determinant of matrix m without row r and col c
+ *
+ * @param {matrix} m Starter matrix
+ * @param r row to remove
+ * @param c col to remove
+ *
+ *     | a b c |
+ * m = | d e f |
+ *     | g h i |
+ *
+ * getMinor(m, 1, 1) would result in this determinant
+ *
+ * | a c |
+ * | g i |
+ *
+ * @returns {number} determinant
+ */
+export declare function getMinor(matrix: Matrix4, r: number, c: number): number;
+/**
+ *
+ */
+export declare function matrixSum3(m1: Matrix3, m2: Matrix3): Matrix3;

node_modules/maath/dist/declarations/src/misc.d.ts

@@ -0,0 +1,96 @@
+import { Matrix3, Plane, Vector2, Vector3 } from "three";
+import type { TypedArray } from "./ctypes";
+import { V3 } from "./vector3";
+import { V2 } from "./vector2";
+/**
+ * Clamps a value between a range.
+ */
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function repeat(t: number, length: number): number;
+export declare function deltaAngle(current: number, target: number): number;
+/**
+ * Converts degrees to radians.
+ */
+export declare function degToRad(degrees: number): number;
+/**
+ * Converts radians to degrees.
+ */
+export declare function radToDeg(radians: number): number;
+export declare function fibonacciOnSphere(buffer: TypedArray, { radius }: {
+    radius?: number | undefined;
+}): void;
+export declare function vectorEquals(a: any, b: any, eps?: number): boolean;
+/**
+ * Sorts vectors in lexicographic order, works with both v2 and v3
+ *
+ *  Use as:
+ *  const sorted = arrayOfVectors.sort(lexicographicOrder)
+ */
+export declare function lexicographic(a: Vector2 | Vector3, b: Vector2 | Vector3): number;
+/**
+ * Convex Hull
+ *
+ * Returns an array of 2D Vectors representing the convex hull of a set of 2D Vectors
+ */
+/**
+ * Calculate the convex hull of a set of points
+ */
+export declare function convexHull(_points: Vector2[]): Vector2[];
+export declare function remap(x: number, [low1, high1]: number[], [low2, high2]: number[]): number;
+/**
+ *
+ * https://www.desmos.com/calculator/vsnmlaljdu
+ *
+ * Ease-in-out, goes to -Infinite before 0 and Infinite after 1
+ *
+ * @param t
+ * @returns
+ */
+export declare function fade(t: number): number;
+/**
+ *
+ * Returns the result of linearly interpolating between input A and input B by input T.
+ *
+ * @param v0
+ * @param v1
+ * @param t
+ * @returns
+ */
+export declare function lerp(v0: number, v1: number, t: number): number;
+/**
+ *
+ * Returns the linear parameter that produces the interpolant specified by input T within the range of input A to input B.
+ *
+ * @param v0
+ * @param v1
+ * @param t
+ * @returns
+ */
+export declare function inverseLerp(v0: number, v1: number, t: number): number;
+/**
+ *
+ */
+export declare function normalize(x: number, y: number, z: number): number[];
+/**
+ *
+ */
+export declare function pointOnCubeToPointOnSphere(x: number, y: number, z: number): number[];
+/**
+ * Give two unit vectors a and b, returns the transformation matrix that rotates a onto b.
+ *
+ * */
+export declare function rotateVectorOnVector(a: Vector3, b: Vector3): Matrix3;
+export declare function pointToCoordinate(x: number, y: number, z: number): number[];
+export declare function coordinateToPoint(lat: number, lon: number): number[];
+/**
+ * Given a plane and a segment, return the intersection point if it exists or null it doesn't.
+ */
+export declare function planeSegmentIntersection(plane: Plane, segment: Vector3[]): null | Vector3;
+/**
+ * Given a plane and a point, return the distance.
+ */
+export declare function pointToPlaneDistance(p: Vector3, plane: Plane): number;
+export declare function getIndexFrom3D(coords: V3, sides: V3): number;
+export declare function get3DFromIndex(index: number, size: V3): V3;
+export declare function getIndexFrom2D(coords: V2, size: V2): number;
+export declare function get2DFromIndex(index: number, columns: number): V2;

node_modules/maath/dist/declarations/src/random/index.d.ts

@@ -0,0 +1,70 @@
+import type { TypedArray } from "../ctypes";
+export declare class FlashGen {
+    nextBurstTime: number;
+    nextFlashEndTime: number;
+    flashesDone: number;
+    isFlashing: boolean;
+    currentCount: number;
+    flashIntensity: number;
+    isDecaying: boolean;
+    autoBurst: boolean;
+    decaySpeed: number;
+    minInterval: number;
+    maxInterval: number;
+    minDuration: number;
+    maxDuration: number;
+    count: number;
+    constructor(props: {
+        decaySpeed?: number;
+        minInterval?: number;
+        maxInterval?: number;
+        minDuration?: number;
+        maxDuration?: number;
+        count?: number;
+    });
+    scheduleNextBurst(currentTime: number): void;
+    burst(): void;
+    update(currentTime: number, delta: number): number;
+}
+export declare class Generator {
+    seed: string | number;
+    constructor(seed: string | number);
+    init: (seed: number | string) => void;
+    value: () => number;
+}
+/***
+ * [3D] Sphere
+ */
+declare type Sphere = {
+    radius?: number;
+    center?: number[];
+};
+export declare function onSphere(buffer: TypedArray, sphere?: Sphere, rng?: Generator): TypedArray;
+export declare function inSphere(buffer: TypedArray, sphere?: Sphere, rng?: Generator): TypedArray;
+/***
+ * [2D] Circle
+ */
+declare type Circle = {
+    radius?: number;
+    center?: number[];
+};
+export declare function inCircle(buffer: TypedArray, circle?: Circle, rng?: Generator): TypedArray;
+export declare function onCircle(buffer: TypedArray, circle?: Circle, rng?: Generator): TypedArray;
+/**
+ * [2D] Plane
+ */
+declare type Rect = {
+    sides: number | number[];
+};
+export declare function inRect<T extends TypedArray>(buffer: T, rect?: Rect, rng?: Generator): T;
+export declare function onRect(buffer: TypedArray, rect?: Rect, rng?: Generator): TypedArray;
+/***
+ * [3D] Box
+ */
+export declare function inBox(buffer: TypedArray, box?: Box, rng?: Generator): TypedArray;
+declare type Box = {
+    sides?: number[] | number;
+    center?: number[];
+};
+export declare function onBox(buffer: TypedArray, box?: Box, rng?: Generator): TypedArray;
+export * as noise from "./noise";

node_modules/maath/dist/declarations/src/random/noise.d.ts

@@ -0,0 +1,5 @@
+export declare const seed: (seed: number) => void;
+export declare const simplex2: (xin: number, yin: number) => number;
+export declare const simplex3: (xin: number, yin: number, zin: number) => number;
+export declare const perlin2: (x: number, y: number) => number;
+export declare const perlin3: (x: number, y: number, z: number) => number;

node_modules/maath/dist/declarations/src/three.d.ts

@@ -0,0 +1,14 @@
+import type { TypedArray } from "./ctypes";
+import { Vector2, Vector3 } from "three";
+/**
+ * Helpers for converting buffers to and from Three.js objects
+ */
+export declare function bufferToVectors(buffer: TypedArray, stride: 3): Vector3[];
+export declare function bufferToVectors(buffer: TypedArray, stride: 2): Vector2[];
+/**
+ * Transforms a passed Vector2 or Vector3 array to a points buffer
+ *
+ * @param vectorArray
+ * @returns
+ */
+export declare function vectorsToBuffer(vectorArray: Vector2[] | Vector3[]): Float32Array;

node_modules/maath/dist/declarations/src/triangle.d.ts

@@ -0,0 +1,73 @@
+import { Vector2 } from "three";
+import type { Triangle } from "./ctypes";
+/**
+ *
+ * @param point
+ *
+ * @param triangle
+ *
+ * @returns {boolean} true if the point is in the triangle
+ *
+ * TODO: Find explainer
+ */
+export declare function isPointInTriangle(point: number[], triangle: Triangle): boolean;
+export declare function triangleDeterminant(triangle: Triangle): number;
+/**
+ * Uses triangle area determinant to check if 3 points are collinear.
+ * If they are, they can't make a triangle, so the determinant will be 0!
+ *
+ *      0     1     2
+ * ─────■─────■─────■
+ *
+ *
+ * Fun fact, you can use this same determinant to check the order of the points in the triangle
+ *
+ * NOTE: Should this use a buffer instead? NOTE: Should this use a buffer instead? [x0, y0, x1, y1, x2, y2]?
+ *
+ */
+export declare function arePointsCollinear(points: Triangle): boolean;
+export declare function isTriangleClockwise(triangle: Triangle): boolean;
+/**
+ 
+The circumcircle is a circle touching all the vertices of a triangle or polygon.
+
+             ┌───┐
+             │ B │
+             └───┘
+           .───●───.
+        ,─'   ╱ ╲   '─.
+      ,'     ╱   ╲     `.
+     ╱      ╱     ╲      ╲
+    ;      ╱       ╲      :
+    │     ╱         ╲     │
+    │    ╱           ╲    │
+    :   ╱             ╲   ;
+     ╲ ╱               ╲ ╱
+┌───┐ ●─────────────────● ┌───┐
+│ A │  `.             ,'  │ C │
+└───┘    '─.       ,─'    └───┘
+            `─────'
+ */
+/**
+ *
+ * @param triangle
+ *
+ * @returns {number} circumcircle
+ */
+export declare function getCircumcircle(triangle: Triangle): {
+    x: number;
+    y: number;
+    r: number;
+} | null;
+export declare function isPointInCircumcircle(point: number[], triangle: Triangle): boolean;
+/**
+ 
+     ╱      ╲
+    ╱        ╲
+   ▕          ▏
+                  
+ right      left
+
+ * NOTE: Should this use a buffer instead? [x0, y0, x1, y1]?
+ */
+export declare function doThreePointsMakeARight(points: Triangle | Vector2[]): boolean;

node_modules/maath/dist/declarations/src/vector2.d.ts

@@ -0,0 +1,23 @@
+/**
+ *
+ */
+export declare type V2 = [x: number, y: number];
+export declare function zero(): V2;
+export declare function one(): V2;
+export declare function add(a: V2, b: V2): V2;
+export declare function addValue(a: V2, n: number): V2;
+export declare function sub(a: V2, b: V2): V2;
+export declare function subValue(a: V2, n: number): V2;
+export declare function scale(a: V2, n: number): V2;
+export declare function dot(a: V2, b: V2): number;
+/**
+ * Calculate the squared length of a vector.
+ * Use this when comparing two vectors instead of length, as it's more efficient (no sqrt)
+ */
+export declare function lengthSqr(a: V2): number;
+/**
+ * Calculate the length of a vector.
+ * If you only need to compare lenghts, consider using the more efficient lengthSqr
+ */
+export declare function length(a: V2): number;
+export declare function distance(a: V2, b: V2): number;

node_modules/maath/dist/declarations/src/vector3.d.ts

@@ -0,0 +1,24 @@
+/**
+ *
+ */
+export declare type V3 = [x: number, y: number, z: number];
+export declare function zero(): V3;
+export declare function one(): V3;
+export declare function add(a: V3, b: V3): V3;
+export declare function addValue(a: V3, n: number): V3;
+export declare function sub(a: V3, b: V3): V3;
+export declare function subValue(a: V3, n: number): V3;
+export declare function scale(a: V3, n: number): V3;
+export declare function dot(a: V3, b: V3): number;
+export declare function cross(a: V3, b: V3): V3;
+/**
+ * Calculate the squared length of a vector.
+ * Use this when comparing two vectors instead of length, as it's more efficient (no sqrt)
+ */
+export declare function lengthSqr(a: V3): number;
+/**
+ * Calculate the length of a vector.
+ * If you only need to compare lenghts, consider using the more efficient lengthSqr
+ */
+export declare function length(a: V3): number;
+export declare function distance(a: V3, b: V3): number;