@safe-engine/pixi 8.10.0 → 8.10.2

package/dist/packages/pixijs/src/scene/container/container-mixins/getGlobalMixin.d.ts

@@ -0,0 +1,76 @@
+import { Matrix } from '../../../maths/matrix/Matrix';
+import type { Container } from '../Container';
+/**
+ * Converts a color from BGR format to RGB format.
+ * @param color - The color in BGR format (0xBBGGRR).
+ * @returns The color in RGB format (0xRRGGBB).
+ * @category utils
+ * @internal
+ */
+export declare function bgr2rgb(color: number): number;
+/**
+ * Interface for a mixin that provides methods to retrieve global properties of a container.
+ * This mixin allows you to get the global alpha, transform matrix, and tint color of a container,
+ * taking into account its parent containers and render groups.
+ * It includes methods to optimize performance by using cached values when available.
+ * @category scene
+ * @advanced
+ */
+export interface GetGlobalMixin {
+    /**
+     * Returns the global (compound) alpha of the container within the scene.
+     * @param {boolean} skipUpdate - Performance optimization flag:
+     *   - If false (default): Recalculates the entire alpha chain through parents for accuracy
+     *   - If true: Uses cached worldAlpha from the last render pass for better performance
+     * @returns The resulting alpha value (between 0 and 1)
+     * @example
+     * ```ts
+     * // Accurate but slower - recalculates entire alpha chain
+     * const preciseAlpha = container.getGlobalAlpha();
+     *
+     * // Faster but may be outdated - uses cached alpha
+     * const cachedAlpha = container.getGlobalAlpha(true);
+     * ```
+     */
+    getGlobalAlpha(skipUpdate?: boolean): number;
+    /**
+     * Returns the global transform matrix of the container within the scene.
+     * @param {Matrix} matrix - Optional matrix to store the result. If not provided, a new Matrix will be created.
+     * @param {boolean} skipUpdate - Performance optimization flag:
+     *   - If false (default): Recalculates the entire transform chain for accuracy
+     *   - If true: Uses cached worldTransform from the last render pass for better performance
+     * @returns The resulting transformation matrix (either the input matrix or a new one)
+     * @example
+     * ```ts
+     * // Accurate but slower - recalculates entire transform chain
+     * const preciseTransform = container.getGlobalTransform();
+     *
+     * // Faster but may be outdated - uses cached transform
+     * const cachedTransform = container.getGlobalTransform(undefined, true);
+     *
+     * // Reuse existing matrix
+     * const existingMatrix = new Matrix();
+     * container.getGlobalTransform(existingMatrix);
+     * ```
+     */
+    getGlobalTransform(matrix?: Matrix, skipUpdate?: boolean): Matrix;
+    /**
+     * Returns the global (compound) tint color of the container within the scene.
+     * @param {boolean} skipUpdate - Performance optimization flag:
+     *   - If false (default): Recalculates the entire tint chain through parents for accuracy
+     *   - If true: Uses cached worldColor from the last render pass for better performance
+     * @returns The resulting tint color as a 24-bit RGB number (0xRRGGBB)
+     * @example
+     * ```ts
+     * // Accurate but slower - recalculates entire tint chain
+     * const preciseTint = container.getGlobalTint();
+     *
+     * // Faster but may be outdated - uses cached tint
+     * const cachedTint = container.getGlobalTint(true);
+     * ```
+     */
+    getGlobalTint(skipUpdate?: boolean): number;
+}
+/** @internal */
+export declare const getGlobalMixin: Partial<Container>;
+//# sourceMappingURL=getGlobalMixin.d.ts.map

package/dist/packages/pixijs/src/scene/container/container-mixins/getGlobalMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getGlobalMixin.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/scene/container/container-mixins/getGlobalMixin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAKtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAE3B;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7C;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAAkB,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAClE;;;;;;;;;;;;;;OAcG;IACH,aAAa,CAAC,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CAC/C;AAED,gBAAgB;AAChB,eAAO,MAAM,cAAc,EAAE,OAAO,CAAC,SAAS,CA4EhC,CAAC"}

package/dist/packages/pixijs/src/scene/container/container-mixins/getGlobalMixin.js

@@ -0,0 +1,63 @@
+import { Matrix } from '../../../maths/matrix/Matrix';
+import { updateTransformBackwards } from '../bounds/getGlobalBounds';
+import { matrixPool } from '../bounds/utils/matrixAndBoundsPool';
+import { multiplyColors } from '../utils/multiplyColors';
+/**
+ * Converts a color from BGR format to RGB format.
+ * @param color - The color in BGR format (0xBBGGRR).
+ * @returns The color in RGB format (0xRRGGBB).
+ * @category utils
+ * @internal
+ */
+export function bgr2rgb(color) {
+    return ((color & 0xFF) << 16) + (color & 0xFF00) + ((color >> 16) & 0xFF);
+}
+/** @internal */
+export const getGlobalMixin = {
+    getGlobalAlpha(skipUpdate) {
+        if (skipUpdate) {
+            if (this.renderGroup) {
+                return this.renderGroup.worldAlpha;
+            }
+            if (this.parentRenderGroup) {
+                return this.parentRenderGroup.worldAlpha * this.alpha;
+            }
+            return this.alpha;
+        }
+        let alpha = this.alpha;
+        let current = this.parent;
+        while (current) {
+            alpha *= current.alpha;
+            current = current.parent;
+        }
+        return alpha;
+    },
+    getGlobalTransform(matrix = new Matrix(), skipUpdate) {
+        if (skipUpdate) {
+            return matrix.copyFrom(this.worldTransform);
+        }
+        this.updateLocalTransform();
+        const parentTransform = updateTransformBackwards(this, matrixPool.get().identity());
+        matrix.appendFrom(this.localTransform, parentTransform);
+        matrixPool.return(parentTransform);
+        return matrix;
+    },
+    getGlobalTint(skipUpdate) {
+        if (skipUpdate) {
+            if (this.renderGroup) {
+                return bgr2rgb(this.renderGroup.worldColor);
+            }
+            if (this.parentRenderGroup) {
+                return bgr2rgb(multiplyColors(this.localColor, this.parentRenderGroup.worldColor));
+            }
+            return this.tint;
+        }
+        let color = this.localColor;
+        let parent = this.parent;
+        while (parent) {
+            color = multiplyColors(color, parent.localColor);
+            parent = parent.parent;
+        }
+        return bgr2rgb(color);
+    }
+};

package/dist/packages/pixijs/src/scene/container/container-mixins/measureMixin.d.ts

@@ -0,0 +1,107 @@
+import { Bounds } from '../bounds/Bounds';
+import type { Size } from '../../../maths/misc/Size';
+import type { Container } from '../Container';
+/**
+ * A utility type that makes all properties of T optional except for the specified keys K.
+ * @category utils
+ * @internal
+ */
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+/** @ignore */
+export interface MeasureMixinConstructor {
+    /**
+     * The width of the display object, in pixels.
+     * @example
+     * ```ts
+     * new Container({ width: 100});
+     * ```
+     * @default 0
+     */
+    width?: number;
+    /**
+     * The height of the display object, in pixels.
+     * @example
+     * ```ts
+     * new Container({ height: 100});
+     * ```
+     * @default 0
+     */
+    height?: number;
+}
+/**
+ * The MeasureMixin interface provides methods for measuring and manipulating the size and bounds of a display object.
+ * It includes methods to get and set the size of the object, retrieve its local bounds,
+ * and calculate its global bounds.
+ * @category scene
+ * @advanced
+ */
+export interface MeasureMixin extends Required<MeasureMixinConstructor> {
+    getSize(out?: Size): Size;
+    setSize(width: number, height?: number): void;
+    setSize(value: Optional<Size, 'height'>): void;
+    /**
+     * Retrieves the local bounds of the container as a Bounds object.
+     * Uses cached values when possible for better performance.
+     * @example
+     * ```ts
+     * // Basic bounds check
+     * const bounds = container.getLocalBounds();
+     * console.log(`Width: ${bounds.width}, Height: ${bounds.height}`);
+     * // subsequent calls will reuse the cached bounds
+     * const cachedBounds = container.getLocalBounds();
+     * console.log(bounds === cachedBounds); // true
+     * ```
+     * @returns The bounding area
+     * @see {@link Container#getBounds} For world space bounds
+     * @see {@link Bounds} For bounds properties
+     */
+    getLocalBounds(): Bounds;
+    /**
+     * Calculates and returns the (world) bounds of the display object as a Rectangle.
+     * Takes into account transforms and child bounds.
+     * @example
+     * ```ts
+     * // Basic bounds calculation
+     * const bounds = sprite.getBounds();
+     * console.log(`World bounds: ${bounds.x}, ${bounds.y}, ${bounds.width}, ${bounds.height}`);
+     *
+     * // Reuse bounds object for performance
+     * const recycleBounds = new Bounds();
+     * sprite.getBounds(false, recycleBounds);
+     *
+     * // Skip update for performance
+     * const fastBounds = sprite.getBounds(true);
+     * ```
+     * @remarks
+     * - Includes transform calculations
+     * - Updates scene graph by default
+     * - Can reuse bounds objects
+     * - Common in hit testing
+     * @param {boolean} skipUpdate - Setting to `true` will stop the transforms of the scene graph from
+     *  being updated. This means the calculation returned MAY be out of date BUT will give you a
+     *  nice performance boost.
+     * @param {Bounds} bounds - Optional bounds to store the result of the bounds calculation
+     * @returns The minimum axis-aligned rectangle in world space that fits around this object
+     * @see {@link Container#getLocalBounds} For untransformed bounds
+     * @see {@link Bounds} For bounds properties
+     */
+    getBounds(skipUpdate?: boolean, bounds?: Bounds): Bounds;
+    /** @private */
+    _localBoundsCacheData: LocalBoundsCacheData;
+    /** @private */
+    _localBoundsCacheId: number;
+    /** @private */
+    _setWidth(width: number, localWidth: number): void;
+    /** @private */
+    _setHeight(height: number, localHeight: number): void;
+}
+interface LocalBoundsCacheData {
+    data: number[];
+    index: number;
+    didChange: boolean;
+    localBounds: Bounds;
+}
+/** @internal */
+export declare const measureMixin: Partial<Container>;
+export {};
+//# sourceMappingURL=measureMixin.d.ts.map

package/dist/packages/pixijs/src/scene/container/container-mixins/measureMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measureMixin.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/scene/container/container-mixins/measureMixin.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAK1C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;GAIG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAE9E,cAAc;AACd,MAAM,WAAW,uBAAuB;IAEpC;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AACD;;;;;;GAMG;AACH,MAAM,WAAW,YAAa,SAAQ,QAAQ,CAAC,uBAAuB,CAAC;IAEnE,OAAO,CAAC,GAAG,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IAC1B,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,GAAG,IAAI,CAAC;IAC/C;;;;;;;;;;;;;;;OAeG;IACH,cAAc,IAAI,MAAM,CAAC;IACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,SAAS,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACzD,eAAe;IACf,qBAAqB,EAAE,oBAAoB,CAAC;IAC5C,eAAe;IACf,mBAAmB,EAAE,MAAM,CAAC;IAC5B,eAAe;IACf,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD,eAAe;IACf,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CACzD;AAED,UAAU,oBAAoB;IAE1B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACvB;AAID,gBAAgB;AAChB,eAAO,MAAM,YAAY,EAAE,OAAO,CAAC,SAAS,CAsE9B,CAAC"}

package/dist/packages/pixijs/src/scene/container/container-mixins/measureMixin.js

@@ -0,0 +1,54 @@
+import { Matrix } from '../../../maths/matrix/Matrix';
+import { Bounds } from '../bounds/Bounds';
+import { getGlobalBounds } from '../bounds/getGlobalBounds';
+import { getLocalBounds } from '../bounds/getLocalBounds';
+import { checkChildrenDidChange } from '../utils/checkChildrenDidChange';
+const tempMatrix = new Matrix();
+/** @internal */
+export const measureMixin = {
+    _localBoundsCacheId: -1,
+    _localBoundsCacheData: null,
+    _setWidth(value, localWidth) {
+        const sign = Math.sign(this.scale.x) || 1;
+        if (localWidth !== 0) {
+            this.scale.x = (value / localWidth) * sign;
+        }
+        else {
+            this.scale.x = sign;
+        }
+    },
+    _setHeight(value, localHeight) {
+        const sign = Math.sign(this.scale.y) || 1;
+        if (localHeight !== 0) {
+            this.scale.y = (value / localHeight) * sign;
+        }
+        else {
+            this.scale.y = sign;
+        }
+    },
+    getLocalBounds() {
+        if (!this._localBoundsCacheData) {
+            this._localBoundsCacheData = {
+                data: [],
+                index: 1,
+                didChange: false,
+                localBounds: new Bounds()
+            };
+        }
+        const localBoundsCacheData = this._localBoundsCacheData;
+        localBoundsCacheData.index = 1;
+        localBoundsCacheData.didChange = false;
+        if (localBoundsCacheData.data[0] !== this._didViewChangeTick) {
+            localBoundsCacheData.didChange = true;
+            localBoundsCacheData.data[0] = this._didViewChangeTick;
+        }
+        checkChildrenDidChange(this, localBoundsCacheData);
+        if (localBoundsCacheData.didChange) {
+            getLocalBounds(this, localBoundsCacheData.localBounds, tempMatrix);
+        }
+        return localBoundsCacheData.localBounds;
+    },
+    getBounds(skipUpdate, bounds) {
+        return getGlobalBounds(this, skipUpdate, bounds || new Bounds());
+    },
+};

package/dist/packages/pixijs/src/scene/container/container-mixins/onRenderMixin.d.ts

@@ -0,0 +1,40 @@
+import type { Renderer } from '../../../rendering/renderers/types';
+import type { Container } from '../Container';
+/** @internal */
+export interface OnRenderMixinConstructor {
+    /**
+     * This callback is used when the container is rendered. It runs every frame during the render process,
+     * making it ideal for per-frame updates and animations.
+     *
+     * > [!NOTE] In v7 many users used `updateTransform` for this, however the way v8 renders objects is different
+     * > and "updateTransform" is no longer called every frame
+     * @example
+     * ```ts
+     * // Basic rotation animation
+     * const container = new Container();
+     * container.onRender = () => {
+     *     container.rotation += 0.01;
+     * };
+     *
+     * // Cleanup when done
+     * container.onRender = null; // Removes callback
+     * ```
+     * @param renderer - The renderer instance
+     * @see {@link Renderer} For renderer capabilities
+     */
+    onRender?: ((renderer: Renderer) => void) | null;
+}
+/**
+ * The OnRenderMixin interface provides a way to define a callback that is executed
+ * every time the container is rendered. This is useful for adding custom rendering logic
+ * or animations that need to be updated each frame.
+ * @category scene
+ * @advanced
+ */
+export interface OnRenderMixin extends Required<OnRenderMixinConstructor> {
+    /** @private */
+    _onRender: ((renderer: Renderer) => void) | null;
+}
+/** @internal */
+export declare const onRenderMixin: Partial<Container>;
+//# sourceMappingURL=onRenderMixin.d.ts.map

package/dist/packages/pixijs/src/scene/container/container-mixins/onRenderMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onRenderMixin.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/scene/container/container-mixins/onRenderMixin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,gBAAgB;AAChB,MAAM,WAAW,wBAAwB;IAErC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;CACpD;AAED;;;;;;GAMG;AACH,MAAM,WAAW,aAAc,SAAQ,QAAQ,CAAC,wBAAwB,CAAC;IAErE,eAAe;IACf,SAAS,EAAE,CAAC,CAAC,QAAQ,EAAE,QAAQ,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;CACpD;AAED,gBAAgB;AAChB,eAAO,MAAM,aAAa,EAAE,OAAO,CAAC,SAAS,CA+B/B,CAAC"}

package/dist/packages/pixijs/src/scene/container/container-mixins/onRenderMixin.js

@@ -0,0 +1,21 @@
+/** @internal */
+export const onRenderMixin = {
+    _onRender: null,
+    set onRender(func) {
+        const renderGroup = this.renderGroup || this.parentRenderGroup;
+        if (!func) {
+            if (this._onRender) {
+                renderGroup === null || renderGroup === void 0 ? void 0 : renderGroup.removeOnRender(this);
+            }
+            this._onRender = null;
+            return;
+        }
+        if (!this._onRender) {
+            renderGroup === null || renderGroup === void 0 ? void 0 : renderGroup.addOnRender(this);
+        }
+        this._onRender = func;
+    },
+    get onRender() {
+        return this._onRender;
+    }
+};

package/dist/packages/pixijs/src/scene/container/container-mixins/sortMixin.d.ts

@@ -0,0 +1,78 @@
+import type { Container } from '../Container';
+/** @ignore */
+export interface SortMixinConstructor {
+    /**
+     * The zIndex of the container.
+     *
+     * Controls the rendering order of children within their parent container.
+     *
+     * A higher value will mean it will be moved towards the front of the rendering order.
+     * @example
+     * ```ts
+     * // Add in any order
+     * container.addChild(character, background, foreground);
+     *
+     * // Adjust rendering order
+     * background.zIndex = 0;
+     * character.zIndex = 1;
+     * foreground.zIndex = 2;
+     * ```
+     * @see {@link Container#sortableChildren} For enabling sorting
+     * @see {@link Container#sortChildren} For manual sorting
+     * @default 0
+     */
+    zIndex?: number;
+    /**
+     * Should children be sorted by zIndex at the next render call.
+     *
+     * Will get automatically set to true if a new child is added, or if a child's zIndex changes.
+     * @default false
+     * @internal
+     */
+    sortDirty?: boolean;
+    /**
+     * If set to true, the container will sort its children by `zIndex` value
+     * when the next render is called, or manually if `sortChildren()` is called.
+     *
+     * This actually changes the order of elements in the array of children,
+     * so it will affect the rendering order.
+     *
+     * > [!NOTE] Also be aware of that this may not work nicely with the `addChildAt()` function,
+     * > as the `zIndex` sorting may cause the child to automatically sorted to another position.
+     * @example
+     * ```ts
+     * container.sortableChildren = true;
+     * ```
+     * @default false
+     */
+    sortableChildren?: boolean;
+}
+/**
+ * The SortMixin interface provides methods and properties for sorting children of a container
+ * based on their `zIndex` values. It allows for automatic sorting of children when their `zIndex`
+ * changes or when new children are added. The mixin includes properties to manage sorting state
+ * and methods to sort children explicitly.
+ * @category scene
+ * @advanced
+ */
+export interface SortMixin extends Required<SortMixinConstructor> {
+    /** @internal */
+    _zIndex: number;
+    /**
+     * Sorts children by zIndex value. Only sorts if container is marked as dirty.
+     * @example
+     * ```ts
+     * // Basic sorting
+     * particles.zIndex = 2;     // Will mark as dirty
+     * container.sortChildren();
+     * ```
+     * @see {@link Container#sortableChildren} For enabling automatic sorting
+     * @see {@link Container#zIndex} For setting child order
+     */
+    sortChildren: () => void;
+    /** @internal */
+    depthOfChildModified: () => void;
+}
+/** @internal */
+export declare const sortMixin: Partial<Container>;
+//# sourceMappingURL=sortMixin.d.ts.map

package/dist/packages/pixijs/src/scene/container/container-mixins/sortMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortMixin.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/scene/container/container-mixins/sortMixin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,cAAc;AACd,MAAM,WAAW,oBAAoB;IAEjC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,SAAU,SAAQ,QAAQ,CAAC,oBAAoB,CAAC;IAE7D,gBAAgB;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;OAUG;IACH,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,gBAAgB;IAChB,oBAAoB,EAAE,MAAM,IAAI,CAAC;CACpC;AAED,gBAAgB;AAChB,eAAO,MAAM,SAAS,EAAE,OAAO,CAAC,SAAS,CAyC3B,CAAC"}

package/dist/packages/pixijs/src/scene/container/container-mixins/sortMixin.js

@@ -0,0 +1,33 @@
+/** @internal */
+export const sortMixin = {
+    _zIndex: 0,
+    sortDirty: false,
+    sortableChildren: false,
+    get zIndex() {
+        return this._zIndex;
+    },
+    set zIndex(value) {
+        if (this._zIndex === value)
+            return;
+        this._zIndex = value;
+        this.depthOfChildModified();
+    },
+    depthOfChildModified() {
+        if (this.parent) {
+            this.parent.sortableChildren = true;
+            this.parent.sortDirty = true;
+        }
+        if (this.parentRenderGroup) {
+            this.parentRenderGroup.structureDidChange = true;
+        }
+    },
+    sortChildren() {
+        if (!this.sortDirty)
+            return;
+        this.sortDirty = false;
+        this.children.sort(sortChildren);
+    },
+};
+function sortChildren(a, b) {
+    return a._zIndex - b._zIndex;
+}

package/dist/packages/pixijs/src/scene/container/container-mixins/toLocalGlobalMixin.d.ts

@@ -0,0 +1,104 @@
+import { Point } from '../../../maths/point/Point';
+import type { PointData } from '../../../maths/point/PointData';
+import type { Container } from '../Container';
+/**
+ * Interface for a mixin that provides methods to convert between local and global coordinates.
+ * This mixin allows you to get the global position of a container,
+ * convert a point from local to global coordinates,
+ * and convert a point from global to local coordinates.
+ *
+ * It includes methods to optimize performance by using cached matrices when available.
+ * @category scene
+ * @advanced
+ */
+export interface ToLocalGlobalMixin {
+    /**
+     * Returns the global position of the container, taking into account the container hierarchy.
+     * @example
+     * ```ts
+     * // Basic position check
+     * const globalPos = sprite.getGlobalPosition();
+     * console.log(`Global: (${globalPos.x}, ${globalPos.y})`);
+     *
+     * // Reuse point object
+     * const point = new Point();
+     * sprite.getGlobalPosition(point);
+     *
+     * // Skip transform update for performance
+     * const fastPos = container.getGlobalPosition(undefined, true);
+     * ```
+     * @param {Point} point - The optional point to write the global value to
+     * @param {boolean} skipUpdate - Should we skip the update transform
+     * @returns The updated point
+     * @see {@link Container#toGlobal} For converting specific points
+     * @see {@link Container#toLocal} For converting to local space
+     */
+    getGlobalPosition(point?: Point, skipUpdate?: boolean): Point;
+    /**
+     * Calculates the global position of a point relative to this container.
+     * Takes into account the container hierarchy and transforms.
+     * @example
+     * ```ts
+     * // Basic point conversion
+     * const localPoint = { x: 10, y: 20 };
+     * const globalPoint = container.toGlobal(localPoint);
+     *
+     * // With point reuse
+     * const reusePoint = new Point();
+     * container.toGlobal(localPoint, reusePoint);
+     *
+     * // Performance optimization
+     * const fastPoint = container.toGlobal(
+     *     { x: 50, y: 50 },
+     *     undefined,
+     *     true // Skip transform update
+     * );
+     * ```
+     * @param {PointData} position - The local point to convert
+     * @param {P} point - Optional point to store the result
+     * @param {boolean} skipUpdate - Whether to skip transform updates
+     * @returns The global position
+     * @see {@link Container#toLocal} For reverse conversion
+     * @see {@link Container#getGlobalPosition} For container position
+     */
+    toGlobal<P extends PointData = Point>(position: PointData, point?: P, skipUpdate?: boolean): P;
+    /**
+     * Calculates the local position of the container relative to another point.
+     * Converts coordinates from any coordinate space to this container's local coordinate space.
+     * @example
+     * ```ts
+     * // Basic coordinate conversion
+     * const worldPoint = { x: 100, y: 100 };
+     * const localPos = container.toLocal(worldPoint);
+     *
+     * // Convert from another container
+     * const fromSprite = new Sprite(texture);
+     * fromSprite.position.set(50, 50);
+     * const pointInSprite = { x: 10, y: 10 };
+     * const localPoint = container.toLocal(pointInSprite, fromSprite);
+     *
+     * // With point reuse for performance
+     * const reusePoint = new Point();
+     * container.toLocal(worldPoint, undefined, reusePoint);
+     *
+     * // Skip transform update for static objects
+     * const fastLocal = container.toLocal(
+     *     worldPoint,
+     *     undefined,
+     *     undefined,
+     *     true
+     * );
+     * ```
+     * @param {PointData} position - The world origin to calculate from
+     * @param {Container} from - The Container to calculate the global position from
+     * @param {P} point - A Point object in which to store the value
+     * @param {boolean} skipUpdate - Should we skip the update transform
+     * @returns A point object representing the position in local space
+     * @see {@link Container#toGlobal} For reverse conversion
+     * @see {@link Container#getGlobalPosition} For container position
+     */
+    toLocal<P extends PointData = Point>(position: PointData, from?: Container, point?: P, skipUpdate?: boolean): P;
+}
+/** @internal */
+export declare const toLocalGlobalMixin: Partial<Container>;
+//# sourceMappingURL=toLocalGlobalMixin.d.ts.map

package/dist/packages/pixijs/src/scene/container/container-mixins/toLocalGlobalMixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toLocalGlobalMixin.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/scene/container/container-mixins/toLocalGlobalMixin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAGnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IAE/B;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,iBAAiB,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;IAC9D;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,QAAQ,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC;IAC/F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,SAAS,EAAE,KAAK,CAAC,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC;CACnH;AAED,gBAAgB;AAChB,eAAO,MAAM,kBAAkB,EAAE,OAAO,CAAC,SAAS,CA4CpC,CAAC"}

package/dist/packages/pixijs/src/scene/container/container-mixins/toLocalGlobalMixin.js

@@ -0,0 +1,32 @@
+import { Point } from '../../../maths/point/Point';
+import { matrixPool } from '../bounds/utils/matrixAndBoundsPool';
+/** @internal */
+export const toLocalGlobalMixin = {
+    getGlobalPosition(point = new Point(), skipUpdate = false) {
+        if (this.parent) {
+            this.parent.toGlobal(this._position, point, skipUpdate);
+        }
+        else {
+            point.x = this._position.x;
+            point.y = this._position.y;
+        }
+        return point;
+    },
+    toGlobal(position, point, skipUpdate = false) {
+        const globalMatrix = this.getGlobalTransform(matrixPool.get(), skipUpdate);
+        // simply apply the matrix..
+        point = globalMatrix.apply(position, point);
+        matrixPool.return(globalMatrix);
+        return point;
+    },
+    toLocal(position, from, point, skipUpdate) {
+        if (from) {
+            position = from.toGlobal(position, point, skipUpdate);
+        }
+        const globalMatrix = this.getGlobalTransform(matrixPool.get(), skipUpdate);
+        // simply apply the matrix..
+        point = globalMatrix.applyInverse(position, point);
+        matrixPool.return(globalMatrix);
+        return point;
+    }
+};