@safe-engine/pixi 8.10.2 → 8.10.4

package/dist/packages/pixijs/src/scene/mesh-perspective/PerspectiveMesh.d.ts

@@ -1,183 +0,0 @@
-import { Texture } from '../../rendering/renderers/shared/texture/Texture';
-import { Mesh } from '../mesh/shared/Mesh';
-import { PerspectivePlaneGeometry } from './PerspectivePlaneGeometry';
-import type { MeshPlaneOptions } from '../mesh-plane/MeshPlane';
-/**
- * Constructor options used for `PerspectiveMesh` instances. Defines the geometry and appearance
- * of a 2D mesh with perspective projection.
- * @example
- * ```ts
- * // Create a perspective mesh with a texture
- * const mesh = new PerspectiveMesh({
- *     texture: Texture.from('myImage.png'),
- *     verticesX: 20,
- *     verticesY: 20,
- *     // Define corners clockwise from top-left
- *     x0: 0,   y0: 0,    // Top-left
- *     x1: 100, y1: 20,   // Top-right (raised)
- *     x2: 100, y2: 100,  // Bottom-right
- *     x3: 0,   y3: 80    // Bottom-left (raised)
- * });
- *
- * // Create a skewed perspective
- * const skewedMesh = new PerspectiveMesh({
- *     texture: Texture.from('background.jpg'),
- *     verticesX: 15,     // More vertices for smoother perspective
- *     verticesY: 15,
- *     x0: 0,   y0: 30,   // Shifted top-left
- *     x1: 128, y1: 0,    // Raised top-right
- *     x2: 128, y2: 128,  // Normal bottom-right
- *     x3: 0,   y3: 98    // Shifted bottom-left
- * });
- * ```
- * @extends MeshPlaneOptions
- * @see {@link PerspectiveMesh} For the mesh implementation
- * @see {@link PerspectivePlaneGeometry} For the underlying geometry
- * @category scene
- * @standard
- * @noInheritDoc
- */
-export interface PerspectivePlaneOptions extends MeshPlaneOptions {
-    /** The x-coordinate of the top-left corner */
-    x0?: number;
-    /** The y-coordinate of the top-left corner */
-    y0?: number;
-    /** The x-coordinate of the top-right corner */
-    x1?: number;
-    /** The y-coordinate of the top-right corner */
-    y1?: number;
-    /** The x-coordinate of the bottom-right corner */
-    x2?: number;
-    /** The y-coordinate of the bottom-right corner */
-    y2?: number;
-    /** The x-coordinate of the bottom-left corner */
-    x3?: number;
-    /** The y-coordinate of the bottom-left corner */
-    y3?: number;
-}
-/**
- * A perspective mesh that allows you to draw a 2d plane with perspective. Where ever you move the corners
- * the texture will be projected to look like it is in 3d space. Great for mapping a 2D mesh into a 3D scene.
- *
- * The calculations is done at the uv level. This means that the more vertices you have the more smooth
- * the perspective will be. If you have a low amount of vertices you may see the texture stretch. Too many vertices
- * could be slower. It is a balance between performance and quality! We leave that to you to decide.
- *
- * > [!IMPORTANT] This is not a full 3D mesh, it is a 2D mesh with a perspective projection applied to it.
- * @category scene
- * @standard
- * @see {@link PerspectiveMesh}
- * @example
- * ```ts
- * // Create a perspective mesh with a texture
- * const mesh = new PerspectiveMesh({
- *     texture: Texture.from('myImage.png'),
- *     verticesX: 20,
- *     verticesY: 20,
- *     // Define corners clockwise from top-left
- *     x0: 0,   y0: 0,    // Top-left
- *     x1: 100, y1: 20,   // Top-right (raised)
- *     x2: 100, y2: 100,  // Bottom-right
- *     x3: 0,   y3: 80    // Bottom-left (raised)
- * });
- * ```
- */
-export declare class PerspectiveMesh extends Mesh<PerspectivePlaneGeometry> {
-    /**
-     * Default options for creating a PerspectiveMesh instance.
-     *
-     * Creates a 100x100 pixel square mesh
-     * with a white texture and 10x10 vertex grid for the perspective calculations.
-     * @example
-     * ```ts
-     * // Change defaults globally
-     * PerspectiveMesh.defaultOptions = {
-     *     ...PerspectiveMesh.defaultOptions,
-     *     verticesX: 15,
-     *     verticesY: 15,
-     *     // Move top edge up for default skew
-     *     y0: -20,
-     *     y1: -20
-     * };
-     * ```
-     * @see {@link PerspectivePlaneOptions} For all available options
-     * @see {@link PerspectivePlaneGeometry} For how vertices affect perspective quality
-     */
-    static defaultOptions: PerspectivePlaneOptions;
-    /**
-     * @param options - Options to be applied to PerspectiveMesh
-     */
-    constructor(options: PerspectivePlaneOptions);
-    /** Update the geometry when the texture is updated */
-    protected textureUpdated(): void;
-    set texture(value: Texture);
-    /**
-     * The texture that the mesh uses for rendering. When changed, automatically updates
-     * the geometry to match the new texture dimensions.
-     * @example
-     * ```ts
-     * const mesh = new PerspectiveMesh({
-     *     texture: Texture.from('initial.png'),
-     * });
-     *
-     * // Update texture and maintain perspective
-     * mesh.texture = Texture.from('newImage.png');
-     * ```
-     * @see {@link Texture} For texture creation and management
-     * @see {@link PerspectiveMesh#setCorners} For adjusting the mesh perspective
-     */
-    get texture(): Texture;
-    /**
-     * Sets the corners of the mesh to create a perspective transformation. The corners should be
-     * specified in clockwise order starting from the top-left.
-     *
-     * The mesh automatically recalculates the UV coordinates to create the perspective effect.
-     * @example
-     * ```ts
-     * const mesh = new PerspectiveMesh({
-     *     texture: Texture.from('myImage.png'),
-     * });
-     *
-     * // Create a basic perspective tilt
-     * mesh.setCorners(
-     *     0, 0,      // Top-left
-     *     100, 20,   // Top-right (raised)
-     *     100, 100,  // Bottom-right
-     *     0, 80      // Bottom-left
-     * );
-     *
-     * // Create a skewed billboard effect
-     * mesh.setCorners(
-     *     0, 30,     // Top-left (shifted down)
-     *     128, 0,    // Top-right (raised)
-     *     128, 128,  // Bottom-right
-     *     0, 98      // Bottom-left (shifted up)
-     * );
-     *
-     * // Animate perspective
-     * app.ticker.add((delta) => {
-     *     const time = performance.now() / 1000;
-     *     const wave = Math.sin(time) * 20;
-     *
-     *     mesh.setCorners(
-     *         0, wave,      // Top-left
-     *         100, -wave,   // Top-right
-     *         100, 100,     // Bottom-right
-     *         0, 100        // Bottom-left
-     *     );
-     * });
-     * ```
-     * @param x0 - x-coordinate of the top-left corner
-     * @param y0 - y-coordinate of the top-left corner
-     * @param x1 - x-coordinate of the top-right corner
-     * @param y1 - y-coordinate of the top-right corner
-     * @param x2 - x-coordinate of the bottom-right corner
-     * @param y2 - y-coordinate of the bottom-right corner
-     * @param x3 - x-coordinate of the bottom-left corner
-     * @param y3 - y-coordinate of the bottom-left corner
-     * @returns The PerspectiveMesh instance for method chaining
-     * @see {@link PerspectivePlaneGeometry} For the underlying geometry calculations
-     */
-    setCorners(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
-}
-//# sourceMappingURL=PerspectiveMesh.d.ts.map

package/dist/packages/pixijs/src/scene/mesh-perspective/PerspectiveMesh.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PerspectiveMesh.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/scene/mesh-perspective/PerspectiveMesh.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kDAAkD,CAAC;AAE3E,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAC3C,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB;IAE7D,8CAA8C;IAC9C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,8CAA8C;IAC9C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,+CAA+C;IAC/C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,+CAA+C;IAC/C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,kDAAkD;IAClD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,kDAAkD;IAClD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,iDAAiD;IACjD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,iDAAiD;IACjD,EAAE,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,eAAgB,SAAQ,IAAI,CAAC,wBAAwB,CAAC;IAE/D;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAc,cAAc,EAAE,uBAAuB,CAYnD;IAEF;;OAEG;gBACS,OAAO,EAAE,uBAAuB;IAwB5C,sDAAsD;IACtD,SAAS,CAAC,cAAc,IAAI,IAAI;IAgBhC,IAAI,OAAO,CAAC,KAAK,EAAE,OAAO,EAOzB;IAED;;;;;;;;;;;;;;OAcG;IACH,IAAI,OAAO,IAAI,OAAO,CAGrB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkDG;IACI,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;CAInH"}

package/dist/packages/pixijs/src/scene/mesh-perspective/PerspectiveMesh.js

@@ -1,183 +0,0 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { Texture } from '../../rendering/renderers/shared/texture/Texture';
-import { definedProps } from '../container/utils/definedProps';
-import { Mesh } from '../mesh/shared/Mesh';
-import { PerspectivePlaneGeometry } from './PerspectivePlaneGeometry';
-/**
- * A perspective mesh that allows you to draw a 2d plane with perspective. Where ever you move the corners
- * the texture will be projected to look like it is in 3d space. Great for mapping a 2D mesh into a 3D scene.
- *
- * The calculations is done at the uv level. This means that the more vertices you have the more smooth
- * the perspective will be. If you have a low amount of vertices you may see the texture stretch. Too many vertices
- * could be slower. It is a balance between performance and quality! We leave that to you to decide.
- *
- * > [!IMPORTANT] This is not a full 3D mesh, it is a 2D mesh with a perspective projection applied to it.
- * @category scene
- * @standard
- * @see {@link PerspectiveMesh}
- * @example
- * ```ts
- * // Create a perspective mesh with a texture
- * const mesh = new PerspectiveMesh({
- *     texture: Texture.from('myImage.png'),
- *     verticesX: 20,
- *     verticesY: 20,
- *     // Define corners clockwise from top-left
- *     x0: 0,   y0: 0,    // Top-left
- *     x1: 100, y1: 20,   // Top-right (raised)
- *     x2: 100, y2: 100,  // Bottom-right
- *     x3: 0,   y3: 80    // Bottom-left (raised)
- * });
- * ```
- */
-export class PerspectiveMesh extends Mesh {
-    /**
-     * @param options - Options to be applied to PerspectiveMesh
-     */
-    constructor(options) {
-        options = Object.assign(Object.assign({}, PerspectiveMesh.defaultOptions), options);
-        const { texture, verticesX, verticesY } = options, rest = __rest(options, ["texture", "verticesX", "verticesY"]);
-        const planeGeometry = new PerspectivePlaneGeometry(definedProps({
-            width: texture.width,
-            height: texture.height,
-            verticesX,
-            verticesY,
-        }));
-        super(definedProps(Object.assign(Object.assign({}, rest), { geometry: planeGeometry })));
-        this._texture = texture;
-        this.geometry.setCorners(options.x0, options.y0, options.x1, options.y1, options.x2, options.y2, options.x3, options.y3);
-    }
-    /** Update the geometry when the texture is updated */
-    textureUpdated() {
-        const geometry = this.geometry;
-        if (!geometry)
-            return;
-        const { width, height } = this.texture;
-        if (geometry.width !== width || geometry.height !== height) {
-            geometry.width = width;
-            geometry.height = height;
-            geometry.updateProjection();
-        }
-    }
-    set texture(value) {
-        if (this._texture === value)
-            return;
-        super.texture = value;
-        this.textureUpdated();
-    }
-    /**
-     * The texture that the mesh uses for rendering. When changed, automatically updates
-     * the geometry to match the new texture dimensions.
-     * @example
-     * ```ts
-     * const mesh = new PerspectiveMesh({
-     *     texture: Texture.from('initial.png'),
-     * });
-     *
-     * // Update texture and maintain perspective
-     * mesh.texture = Texture.from('newImage.png');
-     * ```
-     * @see {@link Texture} For texture creation and management
-     * @see {@link PerspectiveMesh#setCorners} For adjusting the mesh perspective
-     */
-    get texture() {
-        return this._texture;
-    }
-    /**
-     * Sets the corners of the mesh to create a perspective transformation. The corners should be
-     * specified in clockwise order starting from the top-left.
-     *
-     * The mesh automatically recalculates the UV coordinates to create the perspective effect.
-     * @example
-     * ```ts
-     * const mesh = new PerspectiveMesh({
-     *     texture: Texture.from('myImage.png'),
-     * });
-     *
-     * // Create a basic perspective tilt
-     * mesh.setCorners(
-     *     0, 0,      // Top-left
-     *     100, 20,   // Top-right (raised)
-     *     100, 100,  // Bottom-right
-     *     0, 80      // Bottom-left
-     * );
-     *
-     * // Create a skewed billboard effect
-     * mesh.setCorners(
-     *     0, 30,     // Top-left (shifted down)
-     *     128, 0,    // Top-right (raised)
-     *     128, 128,  // Bottom-right
-     *     0, 98      // Bottom-left (shifted up)
-     * );
-     *
-     * // Animate perspective
-     * app.ticker.add((delta) => {
-     *     const time = performance.now() / 1000;
-     *     const wave = Math.sin(time) * 20;
-     *
-     *     mesh.setCorners(
-     *         0, wave,      // Top-left
-     *         100, -wave,   // Top-right
-     *         100, 100,     // Bottom-right
-     *         0, 100        // Bottom-left
-     *     );
-     * });
-     * ```
-     * @param x0 - x-coordinate of the top-left corner
-     * @param y0 - y-coordinate of the top-left corner
-     * @param x1 - x-coordinate of the top-right corner
-     * @param y1 - y-coordinate of the top-right corner
-     * @param x2 - x-coordinate of the bottom-right corner
-     * @param y2 - y-coordinate of the bottom-right corner
-     * @param x3 - x-coordinate of the bottom-left corner
-     * @param y3 - y-coordinate of the bottom-left corner
-     * @returns The PerspectiveMesh instance for method chaining
-     * @see {@link PerspectivePlaneGeometry} For the underlying geometry calculations
-     */
-    setCorners(x0, y0, x1, y1, x2, y2, x3, y3) {
-        this.geometry.setCorners(x0, y0, x1, y1, x2, y2, x3, y3);
-    }
-}
-/**
- * Default options for creating a PerspectiveMesh instance.
- *
- * Creates a 100x100 pixel square mesh
- * with a white texture and 10x10 vertex grid for the perspective calculations.
- * @example
- * ```ts
- * // Change defaults globally
- * PerspectiveMesh.defaultOptions = {
- *     ...PerspectiveMesh.defaultOptions,
- *     verticesX: 15,
- *     verticesY: 15,
- *     // Move top edge up for default skew
- *     y0: -20,
- *     y1: -20
- * };
- * ```
- * @see {@link PerspectivePlaneOptions} For all available options
- * @see {@link PerspectivePlaneGeometry} For how vertices affect perspective quality
- */
-PerspectiveMesh.defaultOptions = {
-    texture: Texture.WHITE,
-    verticesX: 10,
-    verticesY: 10,
-    x0: 0,
-    y0: 0,
-    x1: 100,
-    y1: 0,
-    x2: 100,
-    y2: 100,
-    x3: 0,
-    y3: 100
-};

package/dist/packages/pixijs/src/scene/mesh-perspective/PerspectivePlaneGeometry.d.ts

@@ -1,60 +0,0 @@
-import { PlaneGeometry } from '../mesh-plane/PlaneGeometry';
-import type { PlaneGeometryOptions } from '../mesh-plane/PlaneGeometry';
-/**
- * Constructor options used for `PerspectivePlaneGeometry` instances.
- * @category scene
- * @advanced
- */
-export interface PerspectivePlaneGeometryOptions extends PlaneGeometryOptions {
-    /** The width of the plane */
-    width: number;
-    /** The height of the plane */
-    height: number;
-}
-/**
- * A PerspectivePlaneGeometry allows you to draw a 2d plane with perspective. Where ever you move the corners
- * the texture will be projected to look like it is in 3d space. Great for mapping a 2D mesh into a 3D scene.
- *
- * IMPORTANT: This is not a full 3D mesh, it is a 2D mesh with a perspective projection applied to it :)
- *
- * ```js
- * const perspectivePlaneGeometry = new PerspectivePlaneGeometry({
- *  width: 100,
- *  height: 100,
- *  verticesX: 10,
- *  verticesY: 10,
- * });
- * ```
- * @see {@link PerspectivePlaneGeometry}
- * @category scene
- * @advanced
- */
-export declare class PerspectivePlaneGeometry extends PlaneGeometry {
-    /** The corner points of the quad you can modify these directly, if you do make sure to call `updateProjection` */
-    corners: [number, number, number, number, number, number, number, number];
-    private readonly _projectionMatrix;
-    /**
-     * @param options - Options to be applied to MeshPlane
-     * @param options.width - The width of the plane
-     * @param options.height - The height of the plane
-     * @param options.verticesX - The amount of vertices on the x axis
-     * @param options.verticesY - The amount of vertices on the y axis
-     */
-    constructor(options: PerspectivePlaneGeometryOptions);
-    /**
-     * Will set the corners of the quad to the given coordinates
-     * Calculating the perspective so it looks correct!
-     * @param x0 - x coordinate of the first corner
-     * @param y0 - y coordinate of the first corner
-     * @param x1 - x coordinate of the second corner
-     * @param y1 - y coordinate of the second corner
-     * @param x2 - x coordinate of the third corner
-     * @param y2 - y coordinate of the third corner
-     * @param x3 - x coordinate of the fourth corner
-     * @param y3 - y coordinate of the fourth corner
-     */
-    setCorners(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
-    /** Update the projection matrix based on the corners */
-    updateProjection(): void;
-}
-//# sourceMappingURL=PerspectivePlaneGeometry.d.ts.map

package/dist/packages/pixijs/src/scene/mesh-perspective/PerspectivePlaneGeometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PerspectivePlaneGeometry.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/scene/mesh-perspective/PerspectivePlaneGeometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAK5D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AAExE;;;;GAIG;AACH,MAAM,WAAW,+BAAgC,SAAQ,oBAAoB;IAEzE,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,MAAM,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,wBAAyB,SAAQ,aAAa;IAEvD,kHAAkH;IAC3G,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACjF,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAsD;IAExF;;;;;;OAMG;gBACS,OAAO,EAAE,+BAA+B;IASpD;;;;;;;;;;;OAWG;IACI,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAgBhH,wDAAwD;IACjD,gBAAgB;CAwB1B"}

package/dist/packages/pixijs/src/scene/mesh-perspective/PerspectivePlaneGeometry.js

@@ -1,75 +0,0 @@
-import { PlaneGeometry } from '../mesh-plane/PlaneGeometry';
-import { applyProjectiveTransformationToPlane } from './utils/applyProjectiveTransformationToPlane';
-import { compute2DProjection } from './utils/compute2DProjections';
-/**
- * A PerspectivePlaneGeometry allows you to draw a 2d plane with perspective. Where ever you move the corners
- * the texture will be projected to look like it is in 3d space. Great for mapping a 2D mesh into a 3D scene.
- *
- * IMPORTANT: This is not a full 3D mesh, it is a 2D mesh with a perspective projection applied to it :)
- *
- * ```js
- * const perspectivePlaneGeometry = new PerspectivePlaneGeometry({
- *  width: 100,
- *  height: 100,
- *  verticesX: 10,
- *  verticesY: 10,
- * });
- * ```
- * @see {@link PerspectivePlaneGeometry}
- * @category scene
- * @advanced
- */
-export class PerspectivePlaneGeometry extends PlaneGeometry {
-    /**
-     * @param options - Options to be applied to MeshPlane
-     * @param options.width - The width of the plane
-     * @param options.height - The height of the plane
-     * @param options.verticesX - The amount of vertices on the x axis
-     * @param options.verticesY - The amount of vertices on the y axis
-     */
-    constructor(options) {
-        super(options);
-        this._projectionMatrix = [0, 0, 0, 0, 0, 0, 0, 0, 0];
-        const { width, height } = options;
-        this.corners = [0, 0, width, 0, width, height, 0, height];
-    }
-    /**
-     * Will set the corners of the quad to the given coordinates
-     * Calculating the perspective so it looks correct!
-     * @param x0 - x coordinate of the first corner
-     * @param y0 - y coordinate of the first corner
-     * @param x1 - x coordinate of the second corner
-     * @param y1 - y coordinate of the second corner
-     * @param x2 - x coordinate of the third corner
-     * @param y2 - y coordinate of the third corner
-     * @param x3 - x coordinate of the fourth corner
-     * @param y3 - y coordinate of the fourth corner
-     */
-    setCorners(x0, y0, x1, y1, x2, y2, x3, y3) {
-        const corners = this.corners;
-        corners[0] = x0;
-        corners[1] = y0;
-        corners[2] = x1;
-        corners[3] = y1;
-        corners[4] = x2;
-        corners[5] = y2;
-        corners[6] = x3;
-        corners[7] = y3;
-        this.updateProjection();
-    }
-    /** Update the projection matrix based on the corners */
-    updateProjection() {
-        const { width, height } = this;
-        const corners = this.corners;
-        const projectionMatrix = compute2DProjection(this._projectionMatrix, 0, 0, // top-left source
-        corners[0], corners[1], // top-left dest
-        width, 0, // top-right source
-        corners[2], corners[3], // top-right dest
-        width, height, // bottom-right source
-        corners[4], corners[5], // bottom-right dest
-        0, height, // bottom-left source
-        corners[6], corners[7] // bottom-left dest
-        );
-        applyProjectiveTransformationToPlane(width, height, this, projectionMatrix);
-    }
-}

package/dist/packages/pixijs/src/scene/mesh-perspective/utils/applyProjectiveTransformationToPlane.d.ts

@@ -1,12 +0,0 @@
-import type { ArrayFixed } from '../../../utils/types';
-import type { PlaneGeometry } from '../../mesh-plane/PlaneGeometry';
-/**
- * Apply a projective transformation to a plane geometry
- * @param width - The width of the plane
- * @param height - The height of the plane
- * @param geometry - The plane geometry to apply the transformation to
- * @param transformationMatrix - The transformation matrix to apply
- * @internal
- */
-export declare function applyProjectiveTransformationToPlane(width: number, height: number, geometry: PlaneGeometry, transformationMatrix: ArrayFixed<number, 9>): void;
-//# sourceMappingURL=applyProjectiveTransformationToPlane.d.ts.map

package/dist/packages/pixijs/src/scene/mesh-perspective/utils/applyProjectiveTransformationToPlane.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"applyProjectiveTransformationToPlane.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/scene/mesh-perspective/utils/applyProjectiveTransformationToPlane.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAEpE;;;;;;;GAOG;AACH,wBAAgB,oCAAoC,CAChD,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,aAAa,EACvB,oBAAoB,EAAE,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,QA2C9C"}

package/dist/packages/pixijs/src/scene/mesh-perspective/utils/applyProjectiveTransformationToPlane.js

@@ -1,39 +0,0 @@
-/**
- * Apply a projective transformation to a plane geometry
- * @param width - The width of the plane
- * @param height - The height of the plane
- * @param geometry - The plane geometry to apply the transformation to
- * @param transformationMatrix - The transformation matrix to apply
- * @internal
- */
-export function applyProjectiveTransformationToPlane(width, height, geometry, transformationMatrix) {
-    const buffer = geometry.buffers[0];
-    // Access the vertices of the mesh
-    const vertices = buffer.data;
-    const { verticesX, verticesY } = geometry;
-    const sizeX = (width) / (verticesX - 1);
-    const sizeY = (height) / (verticesY - 1);
-    let index = 0;
-    const a00 = transformationMatrix[0];
-    const a01 = transformationMatrix[1];
-    const a02 = transformationMatrix[2];
-    const a10 = transformationMatrix[3];
-    const a11 = transformationMatrix[4];
-    const a12 = transformationMatrix[5];
-    const a20 = transformationMatrix[6];
-    const a21 = transformationMatrix[7];
-    const a22 = transformationMatrix[8];
-    // Apply the transformation to each vertex
-    for (let i = 0; i < vertices.length; i += 2) {
-        const x = (index % verticesX) * sizeX;
-        const y = ((index / verticesX) | 0) * sizeY;
-        const newX = (a00 * x) + (a01 * y) + a02;
-        const newY = (a10 * x) + (a11 * y) + a12;
-        const w = (a20 * x) + (a21 * y) + a22;
-        vertices[i] = newX / w;
-        vertices[i + 1] = newY / w;
-        index++;
-    }
-    // Update the mesh geometry to reflect the changes
-    buffer.update();
-}

package/dist/packages/pixijs/src/scene/mesh-perspective/utils/compute2DProjections.d.ts

@@ -1,27 +0,0 @@
-import type { ArrayFixed } from '../../../utils/types';
-type Matrix3x3 = ArrayFixed<number, 9>;
-/**
- * Compute a 2D projection matrix
- * @param out - The matrix to store the result in
- * @param x1s - The x coordinate of the first source point
- * @param y1s - The y coordinate of the first source point
- * @param x1d - The x coordinate of the first destination point
- * @param y1d - The y coordinate of the first destination point
- * @param x2s - The x coordinate of the second source point
- * @param y2s - The y coordinate of the second source point
- * @param x2d - The x coordinate of the second destination point
- * @param y2d - The y coordinate of the second destination point
- * @param x3s - The x coordinate of the third source point
- * @param y3s - The y coordinate of the third source point
- * @param x3d - The x coordinate of the third destination point
- * @param y3d - The y coordinate of the third destination point
- * @param x4s - The x coordinate of the fourth source point
- * @param y4s - The y coordinate of the fourth source point
- * @param x4d - The x coordinate of the fourth destination point
- * @param y4d - The y coordinate of the fourth destination point
- * @returns - The computed 2D projection matrix
- * @private
- */
-export declare function compute2DProjection(out: Matrix3x3, x1s: number, y1s: number, x1d: number, y1d: number, x2s: number, y2s: number, x2d: number, y2d: number, x3s: number, y3s: number, x3d: number, y3d: number, x4s: number, y4s: number, x4d: number, y4d: number): Matrix3x3;
-export {};
-//# sourceMappingURL=compute2DProjections.d.ts.map

package/dist/packages/pixijs/src/scene/mesh-perspective/utils/compute2DProjections.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compute2DProjections.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/scene/mesh-perspective/utils/compute2DProjections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD,KAAK,SAAS,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AAwIvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,wBAAgB,mBAAmB,CAC/B,GAAG,EAAE,SAAS,EACd,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAClD,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAClD,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAClD,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GACnD,SAAS,CAiBX"}