import './pointExtras';
import './rectangleExtras';

import type { IPointData } from '@pixi/math';
import { Point } from '@pixi/math';

/**
 * The idea of a relative epsilon comparison is to find the difference between the two numbers,
 * and see if it is less than `Math.EPSILON`.
 *
 * _Note: Only available with **@pixi/math-extras**._
 * @param {number} a - First floating number to compare.
 * @param {number} b - Second floating number to compare.
 * @returns {boolean} Returns `true` if the difference between the values is less than `Math.EPSILON`; otherwise `false`.
 */
export function floatEqual(a: number, b: number): boolean;
/**
 * The idea of a relative epsilon comparison is to find the difference between the two numbers,
 * and see if it is less than a given epsilon.
 * A good epsilon would be the N% of the largest of the two values or `Math.EPSILON`.
 *
 * _Note: Only available with **@pixi/math-extras**._
 * @memberof PIXI
 * @param {number} a - First floating number to compare.
 * @param {number} b - Second floating number to compare.
 * @param {number} epsilon - The epsilon to compare to.
 * The larger the epsilon, the easier for the numbers to be considered equals.
 * @returns {boolean} Returns `true` if the difference between the values is less than the given epsilon;
 * otherwise `false`.
 */
export function floatEqual(a: number, b: number, epsilon: number): boolean;
export function floatEqual(a: number, b: number, epsilon: number = Number.EPSILON): boolean
{
    if (a === b)
    {
        return true;
    }

    const diff = Math.abs(a - b);

    return diff < epsilon;
}

/**
 * Generic line or segment intersection.
 * A line can intersect outside the two points defining it, the segment can't.
 * @param aStart - First point of the first line.
 * @param aEnd - Second point of the first line.
 * @param bStart - First point of the second line.
 * @param bEnd - Second point of the second line.
 * @param isLine - Set to true if you want Line (unbounded) intersection.
 * @param {IPointData} [outPoint] - A Point-like object in which to store the value,
 * optional (otherwise will create a new Point).
 * @returns {IPointData} The point where the lines/segments intersect or a `NaN` Point.
 */
function genericLineIntersection<T extends IPointData>(
    aStart: IPointData,
    aEnd: IPointData,
    bStart: IPointData,
    bEnd: IPointData,
    isLine: boolean,
    outPoint?: T): T
{
    if (!outPoint)
    {
        (outPoint as any) = new Point();
    }

    const dxa = aEnd.x - aStart.x;
    const dya = aEnd.y - aStart.y;
    const dxb = bEnd.x - bStart.x;
    const dyb = bEnd.y - bStart.y;

    // In order to find the position of the intersection in respect to the line segments, we can define lines
    // in terms of first degree Bézier parameters, and find the two parameters `ua` and `ub` for the two lines to touch.
    // both `ua` and `ub` formula share the same denominator so it is only calculated once.

    const denominator = ((dyb * dxa) - (dxb * dya));

    // If lines are parallel or overlapping, the intersection can be nowhere or everywhere... NaN.
    if (floatEqual(denominator, 0))
    {
        outPoint.x = NaN;
        outPoint.y = NaN;

        return outPoint;
    }

    // ua is the factor of line a where the intersection occurs. ub is the factor of line b where the intersection occurs.
    const ua = ((dxb * (aStart.y - bStart.y)) - (dyb * (aStart.x - bStart.x))) / denominator;
    const ub = ((dxa * (aStart.y - bStart.y)) - (dya * (aStart.x - bStart.x))) / denominator;

    // Line intersection extends beyond the bounds of the segment.
    // The intersection is inside the segments if 0.0 ≤ ua ≤ 1.0 and 0.0 ≤ ub ≤ 1.0
    if (!isLine && (ua < 0 || ua > 1 || ub < 0 || ub > 1))
    {
        outPoint.x = NaN;
        outPoint.y = NaN;

        return outPoint;
    }

    outPoint.x = aStart.x + (ua * dxa);
    outPoint.y = bStart.y + (ub * dyb);

    return outPoint;
}

/**
 * Computes the point where non-coincident and non-parallel Lines intersect.
 * Coincident or parallel lines return a `NaN` point `{x: NaN, y: NaN}`.
 * The intersection point may land outside the extents of the lines.
 *
 * _Note: Only available with **@pixi/math-extras**._
 * @param aStart - First point of the first line.
 * @param aEnd - Second point of the first line.
 * @param bStart - First point of the second line.
 * @param bEnd - Second point of the second line.
 * @returns {IPointData} The point where the lines intersect.
 */
export function lineIntersection(aStart: IPointData, aEnd: IPointData, bStart: IPointData, bEnd: IPointData): Point;
/**
 * Computes the point where non-coincident and non-parallel Lines intersect.
 * Coincident or parallel lines return a `NaN` point `{x: NaN, y: NaN}`.
 * The intersection point may land outside the extents of the lines.
 *
 * _Note: Only available with **@pixi/math-extras**._
 * @memberof PIXI
 * @param aStart - First point of the first line.
 * @param aEnd - Second point of the first line.
 * @param bStart - First point of the second line.
 * @param bEnd - Second point of the second line.
 * @param {IPointData} outPoint - A Point-like object in which to store the value,
 * optional (otherwise will create a new Point).
 * @returns {IPointData} The point where the lines intersect or a `NaN` Point.
 */
export function lineIntersection
<T extends IPointData>(aStart: IPointData, aEnd: IPointData, bStart: IPointData, bEnd: IPointData, outPoint: T): T;
export function lineIntersection
<T extends IPointData>(aStart: IPointData, aEnd: IPointData, bStart: IPointData, bEnd: IPointData, outPoint?: T): T
{
    return genericLineIntersection(aStart, aEnd, bStart, bEnd, true, outPoint);
}

/**
 * Computes the point where non-coincident and non-parallel segments intersect.
 * Coincident, parallel or non-intersecting segments return a `NaN` point `{x: NaN, y: NaN}`.
 * The intersection point must land inside the extents of the segments or return a `NaN` Point.
 *
 * _Note: Only available with **@pixi/math-extras**._
 * @param aStart - Starting point of the first segment.
 * @param aEnd - Ending point of the first segment.
 * @param bStart - Starting point of the second segment.
 * @param bEnd - Ending point of the second segment.
 * @returns {IPointData} The point where the segments intersect.
 */
export function segmentIntersection(aStart: IPointData, aEnd: IPointData, bStart: IPointData, bEnd: IPointData): Point;
/**
 * Computes the point where non-coincident and non-parallel segments intersect.
 * Coincident, parallel or non-intersecting segments return a `NaN` point `{x: NaN, y: NaN}`.
 * The intersection point must land inside the extents of the segments or return a `NaN` Point.
 *
 * _Note: Only available with **@pixi/math-extras**._
 * @memberof PIXI
 * @param aStart - Starting point of the first segment.
 * @param aEnd - Ending point of the first segment.
 * @param bStart - Starting point of the second segment.
 * @param bEnd - Ending point of the second segment.
 * @param {IPointData} outPoint - A Point-like object in which to store the value,
 * optional (otherwise will create a new Point).
 * @returns {IPointData} The point where the segments intersect or a `NaN` Point.
 */
export function segmentIntersection
<T extends IPointData>(aStart: IPointData, aEnd: IPointData, bStart: IPointData, bEnd: IPointData, outPoint: T): T;
export function segmentIntersection
<T extends IPointData>(aStart: IPointData, aEnd: IPointData, bStart: IPointData, bEnd: IPointData, outPoint?: T): T
{
    return genericLineIntersection(aStart, aEnd, bStart, bEnd, false, outPoint);
}
Powered by webdoc!