import { Rectangle } from '@pixi/math';
import type { IPointData, Transform, Matrix } from '@pixi/math';
/**
* 'Builder' pattern for bounds rectangles.
*
* This could be called an Axis-Aligned Bounding Box.
* It is not an actual shape. It is a mutable thing; no 'EMPTY' or those kind of problems.
*
* @class
* @memberof PIXI
*/
export class Bounds
{
public minX: number;
public minY: number;
public maxX: number;
public maxY: number;
public rect: Rectangle;
public updateID: number;
constructor()
{
/**
* @member {number}
* @default 0
*/
this.minX = Infinity;
/**
* @member {number}
* @default 0
*/
this.minY = Infinity;
/**
* @member {number}
* @default 0
*/
this.maxX = -Infinity;
/**
* @member {number}
* @default 0
*/
this.maxY = -Infinity;
this.rect = null;
/**
* It is updated to _boundsID of corresponding object to keep bounds in sync with content.
* Updated from outside, thus public modifier.
*
* @member {number}
* @public
*/
this.updateID = -1;
}
/**
* Checks if bounds are empty.
*
* @return {boolean} True if empty.
*/
isEmpty(): boolean
{
return this.minX > this.maxX || this.minY > this.maxY;
}
/**
* Clears the bounds and resets.
*
*/
clear(): void
{
this.minX = Infinity;
this.minY = Infinity;
this.maxX = -Infinity;
this.maxY = -Infinity;
}
/**
* Can return Rectangle.EMPTY constant, either construct new rectangle, either use your rectangle
* It is not guaranteed that it will return tempRect
*
* @param {PIXI.Rectangle} rect - temporary object will be used if AABB is not empty
* @returns {PIXI.Rectangle} A rectangle of the bounds
*/
getRectangle(rect?: Rectangle): Rectangle
{
if (this.minX > this.maxX || this.minY > this.maxY)
{
return Rectangle.EMPTY;
}
rect = rect || new Rectangle(0, 0, 1, 1);
rect.x = this.minX;
rect.y = this.minY;
rect.width = this.maxX - this.minX;
rect.height = this.maxY - this.minY;
return rect;
}
/**
* This function should be inlined when its possible.
*
* @param {PIXI.IPointData} point - The point to add.
*/
addPoint(point: IPointData): void
{
this.minX = Math.min(this.minX, point.x);
this.maxX = Math.max(this.maxX, point.x);
this.minY = Math.min(this.minY, point.y);
this.maxY = Math.max(this.maxY, point.y);
}
/**
* Adds a point, after transformed. This should be inlined when its possible.
*
* @param matrix
* @param point
*/
addPointMatrix(matrix: Matrix, point: IPointData): void
{
const { a, b, c, d, tx, ty } = matrix;
const x = (a * point.x) + (c * point.y) + tx;
const y = (b * point.x) + (d * point.y) + ty;
this.minX = Math.min(this.minX, x);
this.maxX = Math.max(this.maxX, x);
this.minY = Math.min(this.minY, y);
this.maxY = Math.max(this.maxY, y);
}
/**
* Adds a quad, not transformed
*
* @param {Float32Array} vertices - The verts to add.
*/
addQuad(vertices: Float32Array): void
{
let minX = this.minX;
let minY = this.minY;
let maxX = this.maxX;
let maxY = this.maxY;
let x = vertices[0];
let y = vertices[1];
minX = x < minX ? x : minX;
minY = y < minY ? y : minY;
maxX = x > maxX ? x : maxX;
maxY = y > maxY ? y : maxY;
x = vertices[2];
y = vertices[3];
minX = x < minX ? x : minX;
minY = y < minY ? y : minY;
maxX = x > maxX ? x : maxX;
maxY = y > maxY ? y : maxY;
x = vertices[4];
y = vertices[5];
minX = x < minX ? x : minX;
minY = y < minY ? y : minY;
maxX = x > maxX ? x : maxX;
maxY = y > maxY ? y : maxY;
x = vertices[6];
y = vertices[7];
minX = x < minX ? x : minX;
minY = y < minY ? y : minY;
maxX = x > maxX ? x : maxX;
maxY = y > maxY ? y : maxY;
this.minX = minX;
this.minY = minY;
this.maxX = maxX;
this.maxY = maxY;
}
/**
* Adds sprite frame, transformed.
*
* @param {PIXI.Transform} transform - transform to apply
* @param {number} x0 - left X of frame
* @param {number} y0 - top Y of frame
* @param {number} x1 - right X of frame
* @param {number} y1 - bottom Y of frame
*/
addFrame(transform: Transform, x0: number, y0: number, x1: number, y1: number): void
{
this.addFrameMatrix(transform.worldTransform, x0, y0, x1, y1);
}
/**
* Adds sprite frame, multiplied by matrix
*
* @param {PIXI.Matrix} matrix - matrix to apply
* @param {number} x0 - left X of frame
* @param {number} y0 - top Y of frame
* @param {number} x1 - right X of frame
* @param {number} y1 - bottom Y of frame
*/
addFrameMatrix(matrix: Matrix, x0: number, y0: number, x1: number, y1: number): void
{
const a = matrix.a;
const b = matrix.b;
const c = matrix.c;
const d = matrix.d;
const tx = matrix.tx;
const ty = matrix.ty;
let minX = this.minX;
let minY = this.minY;
let maxX = this.maxX;
let maxY = this.maxY;
let x = (a * x0) + (c * y0) + tx;
let y = (b * x0) + (d * y0) + ty;
minX = x < minX ? x : minX;
minY = y < minY ? y : minY;
maxX = x > maxX ? x : maxX;
maxY = y > maxY ? y : maxY;
x = (a * x1) + (c * y0) + tx;
y = (b * x1) + (d * y0) + ty;
minX = x < minX ? x : minX;
minY = y < minY ? y : minY;
maxX = x > maxX ? x : maxX;
maxY = y > maxY ? y : maxY;
x = (a * x0) + (c * y1) + tx;
y = (b * x0) + (d * y1) + ty;
minX = x < minX ? x : minX;
minY = y < minY ? y : minY;
maxX = x > maxX ? x : maxX;
maxY = y > maxY ? y : maxY;
x = (a * x1) + (c * y1) + tx;
y = (b * x1) + (d * y1) + ty;
minX = x < minX ? x : minX;
minY = y < minY ? y : minY;
maxX = x > maxX ? x : maxX;
maxY = y > maxY ? y : maxY;
this.minX = minX;
this.minY = minY;
this.maxX = maxX;
this.maxY = maxY;
}
/**
* Adds screen vertices from array
*
* @param {Float32Array} vertexData - calculated vertices
* @param {number} beginOffset - begin offset
* @param {number} endOffset - end offset, excluded
*/
addVertexData(vertexData: Float32Array, beginOffset: number, endOffset: number): void
{
let minX = this.minX;
let minY = this.minY;
let maxX = this.maxX;
let maxY = this.maxY;
for (let i = beginOffset; i < endOffset; i += 2)
{
const x = vertexData[i];
const y = vertexData[i + 1];
minX = x < minX ? x : minX;
minY = y < minY ? y : minY;
maxX = x > maxX ? x : maxX;
maxY = y > maxY ? y : maxY;
}
this.minX = minX;
this.minY = minY;
this.maxX = maxX;
this.maxY = maxY;
}
/**
* Add an array of mesh vertices
*
* @param {PIXI.Transform} transform - mesh transform
* @param {Float32Array} vertices - mesh coordinates in array
* @param {number} beginOffset - begin offset
* @param {number} endOffset - end offset, excluded
*/
addVertices(transform: Transform, vertices: Float32Array, beginOffset: number, endOffset: number): void
{
this.addVerticesMatrix(transform.worldTransform, vertices, beginOffset, endOffset);
}
/**
* Add an array of mesh vertices.
*
* @param {PIXI.Matrix} matrix - mesh matrix
* @param {Float32Array} vertices - mesh coordinates in array
* @param {number} beginOffset - begin offset
* @param {number} endOffset - end offset, excluded
* @param {number} [padX=0] - x padding
* @param {number} [padY=0] - y padding
*/
addVerticesMatrix(matrix: Matrix, vertices: Float32Array, beginOffset: number,
endOffset: number, padX = 0, padY = padX): void
{
const a = matrix.a;
const b = matrix.b;
const c = matrix.c;
const d = matrix.d;
const tx = matrix.tx;
const ty = matrix.ty;
let minX = this.minX;
let minY = this.minY;
let maxX = this.maxX;
let maxY = this.maxY;
for (let i = beginOffset; i < endOffset; i += 2)
{
const rawX = vertices[i];
const rawY = vertices[i + 1];
const x = (a * rawX) + (c * rawY) + tx;
const y = (d * rawY) + (b * rawX) + ty;
minX = Math.min(minX, x - padX);
maxX = Math.max(maxX, x + padX);
minY = Math.min(minY, y - padY);
maxY = Math.max(maxY, y + padY);
}
this.minX = minX;
this.minY = minY;
this.maxX = maxX;
this.maxY = maxY;
}
/**
* Adds other Bounds.
*
* @param {PIXI.Bounds} bounds - The Bounds to be added
*/
addBounds(bounds: Bounds): void
{
const minX = this.minX;
const minY = this.minY;
const maxX = this.maxX;
const maxY = this.maxY;
this.minX = bounds.minX < minX ? bounds.minX : minX;
this.minY = bounds.minY < minY ? bounds.minY : minY;
this.maxX = bounds.maxX > maxX ? bounds.maxX : maxX;
this.maxY = bounds.maxY > maxY ? bounds.maxY : maxY;
}
/**
* Adds other Bounds, masked with Bounds.
*
* @param {PIXI.Bounds} bounds - The Bounds to be added.
* @param {PIXI.Bounds} mask - TODO
*/
addBoundsMask(bounds: Bounds, mask: Bounds): void
{
const _minX = bounds.minX > mask.minX ? bounds.minX : mask.minX;
const _minY = bounds.minY > mask.minY ? bounds.minY : mask.minY;
const _maxX = bounds.maxX < mask.maxX ? bounds.maxX : mask.maxX;
const _maxY = bounds.maxY < mask.maxY ? bounds.maxY : mask.maxY;
if (_minX <= _maxX && _minY <= _maxY)
{
const minX = this.minX;
const minY = this.minY;
const maxX = this.maxX;
const maxY = this.maxY;
this.minX = _minX < minX ? _minX : minX;
this.minY = _minY < minY ? _minY : minY;
this.maxX = _maxX > maxX ? _maxX : maxX;
this.maxY = _maxY > maxY ? _maxY : maxY;
}
}
/**
* Adds other Bounds, multiplied by matrix. Bounds shouldn't be empty.
*
* @param {PIXI.Bounds} bounds - other bounds
* @param {PIXI.Matrix} matrix - multiplicator
*/
addBoundsMatrix(bounds: Bounds, matrix: Matrix): void
{
this.addFrameMatrix(matrix, bounds.minX, bounds.minY, bounds.maxX, bounds.maxY);
}
/**
* Adds other Bounds, masked with Rectangle.
*
* @param {PIXI.Bounds} bounds - TODO
* @param {PIXI.Rectangle} area - TODO
*/
addBoundsArea(bounds: Bounds, area: Rectangle): void
{
const _minX = bounds.minX > area.x ? bounds.minX : area.x;
const _minY = bounds.minY > area.y ? bounds.minY : area.y;
const _maxX = bounds.maxX < area.x + area.width ? bounds.maxX : (area.x + area.width);
const _maxY = bounds.maxY < area.y + area.height ? bounds.maxY : (area.y + area.height);
if (_minX <= _maxX && _minY <= _maxY)
{
const minX = this.minX;
const minY = this.minY;
const maxX = this.maxX;
const maxY = this.maxY;
this.minX = _minX < minX ? _minX : minX;
this.minY = _minY < minY ? _minY : minY;
this.maxX = _maxX > maxX ? _maxX : maxX;
this.maxY = _maxY > maxY ? _maxY : maxY;
}
}
/**
* Pads bounds object, making it grow in all directions.
* If paddingY is omitted, both paddingX and paddingY will be set to paddingX.
*
* @param {number} [paddingX=0] - The horizontal padding amount.
* @param {number} [paddingY=0] - The vertical padding amount.
*/
pad(paddingX = 0, paddingY = paddingX): void
{
if (!this.isEmpty())
{
this.minX -= paddingX;
this.maxX += paddingX;
this.minY -= paddingY;
this.maxY += paddingY;
}
}
/**
* Adds padded frame. (x0, y0) should be strictly less than (x1, y1)
*
* @param {number} x0 - left X of frame
* @param {number} y0 - top Y of frame
* @param {number} x1 - right X of frame
* @param {number} y1 - bottom Y of frame
* @param {number} padX - padding X
* @param {number} padY - padding Y
*/
addFramePad(x0: number, y0: number, x1: number, y1: number, padX: number, padY: number): void
{
x0 -= padX;
y0 -= padY;
x1 += padX;
y1 += padY;
this.minX = this.minX < x0 ? this.minX : x0;
this.maxX = this.maxX > x1 ? this.maxX : x1;
this.minY = this.minY < y0 ? this.minY : y0;
this.maxY = this.maxY > y1 ? this.maxY : y1;
}
}