@safe-engine/pixi 8.10.2 → 8.10.4

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

@@ -1,258 +0,0 @@
-import { FilterEffect } from '../../../filters/FilterEffect';
-import type { Filter } from '../../../filters/Filter';
-import type { Rectangle } from '../../../maths/shapes/Rectangle';
-import type { MaskEffect } from '../../../rendering/mask/MaskEffectManager';
-import type { Container } from '../Container';
-import type { Effect } from '../Effect';
-/** @ignore */
-export interface EffectsMixinConstructor {
-    /**
-     * The mask to apply, which can be a Container or null.
-     *
-     * If null, it clears the existing mask.
-     * @example
-     * ```ts
-     * // Set a mask
-     * sprite.setMask({
-     *     mask: graphics,
-     *     inverse: false,
-     * });
-     */
-    mask?: Mask;
-    setMask?: (options: Partial<MaskOptionsAndMask>) => void;
-    /**
-     * Sets the filters for the displayObject.
-     * Filters are visual effects that can be applied to any display object and its children.
-     *
-     * > [!IMPORTANT] This is a WebGL/WebGPU only feature and will be ignored by the canvas renderer.
-     * @example
-     * ```ts
-     * new Container({
-     *     filters: [new BlurFilter(2), new ColorMatrixFilter()],
-     * });
-     * ```
-     * @see {@link Filter} For filter base class
-     */
-    filters?: Filter | readonly Filter[];
-}
-/**
- * The Mask type represents different ways to mask a display object.
- * - A number represents a mask ID.
- * - A Container represents a mask object, such as a Graphics or Sprite.
- * - null indicates that no mask is applied.
- * @example
- * ```ts
- * // Using a Container as a mask
- * const maskContainer: Mask = new Graphics();
- * // Using a mask ID
- * const maskId: Mask = 123;
- * // No mask applied
- * const noMask: Mask = null;
- * ```
- * @category scene
- * @standard
- */
-export type Mask = number | Container | null;
-/**
- * Options for configuring mask behavior on a display object.
- * @example
- * ```ts
- * // Basic mask inversion
- * sprite.setMask({
- *     mask: graphics,
- *     inverse: true
- * });
- * ```
- * @see {@link Container#setMask} For applying masks with options
- * @see {@link Container#mask} For basic masking
- * @category scene
- * @standard
- */
-export interface MaskOptions {
-    /**
-     * Whether the mask should be inverted.
-     * When true, the masked area becomes transparent and the unmasked area becomes visible.
-     * @default false
-     * @example
-     * ```ts
-     * // Invert the mask
-     * sprite.setMask({
-     *     mask: graphics,
-     *     inverse: true
-     * });
-     * ```
-     */
-    inverse: boolean;
-}
-/**
- * MaskOptionsAndMask combines MaskOptions with a Mask for configuring masking behavior.
- * Used when setting up complex masking effects with additional options.
- * @example
- * ```ts
- * sprite.setMask({
- *     mask: graphics,
- *     inverse: true,
- * });
- *
- * // Clear existing mask
- * sprite.setMask({
- *     mask: null,
- *     inverse: false,
- * });
- * ```
- * @category scene
- * @standard
- * @see {@link Container#setMask} For applying masks
- * @see {@link MaskOptions} For base options
- */
-export interface MaskOptionsAndMask extends MaskOptions {
-    /**
-     * The mask to apply, which can be a Container or null.
-     *
-     * If null, it clears the existing mask.
-     * @example
-     * ```ts
-     * // Set a mask
-     * sprite.setMask({
-     *     mask: graphics,
-     *     inverse: false,
-     * });
-     */
-    mask: Mask;
-}
-/**
- * The EffectsMixin interface provides methods and properties for managing effects
- * such as masks and filters on a display object.
- * It allows for adding, removing, and configuring effects, as well as setting a mask for the display object.
- * @category scene
- * @advanced
- */
-export interface EffectsMixin extends Required<EffectsMixinConstructor> {
-    /** @private */
-    _maskEffect?: MaskEffect;
-    /** @private */
-    _maskOptions?: MaskOptions;
-    /** @private */
-    _filterEffect?: FilterEffect;
-    /** @private */
-    _markStructureAsChanged(): void;
-    /**
-     * The area the filter is applied to. This is used as an optimization to define a specific region
-     * for filter effects instead of calculating the display object bounds each frame.
-     *
-     * > [!NOTE]
-     * > Setting this to a custom Rectangle allows you to define a specific area for filter effects,
-     * > which can improve performance by avoiding expensive bounds calculations.
-     * @example
-     * ```ts
-     * // Set specific filter area
-     * container.filterArea = new Rectangle(0, 0, 100, 100);
-     *
-     * // Optimize filter region
-     * const screen = app.screen;
-     * container.filterArea = new Rectangle(
-     *     screen.x,
-     *     screen.y,
-     *     screen.width,
-     *     screen.height
-     * );
-     * ```
-     * @see {@link Container#filters} For applying filters
-     * @see {@link Rectangle} For area definition
-     */
-    filterArea?: Rectangle;
-    /**
-     * todo Needs docs
-     * @advanced
-     */
-    effects?: Effect[];
-    /**
-     * todo Needs docs.
-     * @param {Effect} effect - The effect to add.
-     * @ignore
-     */
-    addEffect(effect: Effect): void;
-    /**
-     * todo Needs docs.
-     * @param {Effect} effect - The effect to remove.
-     * @ignore
-     */
-    removeEffect(effect: Effect): void;
-    /**
-     * Used to set mask and control mask options on a display object.
-     * Allows for more detailed control over masking behavior compared to the mask property.
-     * @example
-     * ```ts
-     * import { Graphics, Sprite } from 'pixi.js';
-     *
-     * // Create a circular mask
-     * const graphics = new Graphics()
-     *     .beginFill(0xFF3300)
-     *     .drawCircle(100, 100, 50)
-     *     .endFill();
-     *
-     * // Apply mask with options
-     * sprite.setMask({
-     *     mask: graphics,
-     *     inverse: true, // Create a hole effect
-     * });
-     *
-     * // Clear existing mask
-     * sprite.setMask({ mask: null });
-     * ```
-     * @param {Partial<MaskOptionsAndMask>} options - Configuration options for the mask
-     * @see {@link Container#mask} For simple masking
-     * @see {@link MaskOptionsAndMask} For full options API
-     */
-    setMask(options: Partial<MaskOptionsAndMask>): void;
-    /**
-     * Sets a mask for the displayObject. A mask is an object that limits the visibility of an
-     * object to the shape of the mask applied to it.
-     *
-     * > [!IMPORTANT] In PixiJS a regular mask must be a {@link Graphics} or a {@link Sprite} object.
-     * > This allows for much faster masking in canvas as it utilities shape clipping.
-     * > Furthermore, a mask of an object must be in the subtree of its parent.
-     * > Otherwise, `getLocalBounds` may calculate incorrect bounds, which makes the container's width and height wrong.
-     *
-     * For sprite mask both alpha and red channel are used. Black mask is the same as transparent mask.
-     * @example
-     * ```ts
-     * // Apply mask to sprite
-     * const sprite = new Sprite(texture);
-     * sprite.mask = graphics;
-     *
-     * // Remove mask
-     * sprite.mask = null;
-     * ```
-     * @see {@link Graphics} For creating mask shapes
-     * @see {@link Sprite} For texture-based masks
-     * @see {@link Container#setMask} For advanced mask options
-     */
-    mask: Mask;
-    /**
-     * Sets the filters for the displayObject.
-     * Filters are visual effects that can be applied to any display object and its children.
-     *
-     * > [!IMPORTANT] This is a WebGL/WebGPU only feature and will be ignored by the canvas renderer.
-     * @example
-     * ```ts
-     * // Add a single filter
-     * sprite.filters = new BlurFilter(2);
-     *
-     * // Apply multiple filters
-     * container.filters = [
-     *     new BlurFilter(2),
-     *     new ColorMatrixFilter(),
-     * ];
-     *
-     * // Remove filters
-     * sprite.filters = null;
-     * ```
-     * @see {@link Filter} For filter base class
-     */
-    set filters(value: Filter | Filter[] | null | undefined);
-    get filters(): readonly Filter[];
-}
-/** @internal */
-export declare const effectsMixin: Partial<Container>;
-//# sourceMappingURL=effectsMixin.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"effectsMixin.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/scene/container/container-mixins/effectsMixin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAG7D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2CAA2C,CAAC;AAC5E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,cAAc;AACd,MAAM,WAAW,uBAAuB;IAEpC;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,kBAAkB,CAAC,KAAK,IAAI,CAAC;IACzD;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;AAE7C;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,WAAW;IAExB;;;;;;;;;;;;OAYG;IACH,OAAO,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IAEnD;;;;;;;;;;;OAWG;IACH,IAAI,EAAE,IAAI,CAAC;CACd;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAa,SAAQ,QAAQ,CAAC,uBAAuB,CAAC;IAEnE,eAAe;IACf,WAAW,CAAC,EAAE,UAAU,CAAC;IACzB,eAAe;IACf,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,eAAe;IACf,aAAa,CAAC,EAAE,YAAY,CAAC;IAC7B,eAAe;IACf,uBAAuB,IAAI,IAAI,CAAC;IAEhC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,IAAI,CAAC;IACpD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,IAAI,EAAE,IAAI,CAAC;IACX;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,EAAE;IACzD,IAAI,OAAO,IAAI,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,gBAAgB;AAChB,eAAO,MAAM,YAAY,EAAE,OAAO,CAAC,SAAS,CAgJ9B,CAAC"}

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

@@ -1,100 +0,0 @@
-import { FilterEffect } from '../../../filters/FilterEffect';
-import { MaskEffectManager } from '../../../rendering/mask/MaskEffectManager';
-/** @internal */
-export const effectsMixin = {
-    _maskEffect: null,
-    _maskOptions: {
-        inverse: false,
-    },
-    _filterEffect: null,
-    effects: [],
-    _markStructureAsChanged() {
-        const renderGroup = this.renderGroup || this.parentRenderGroup;
-        if (renderGroup) {
-            renderGroup.structureDidChange = true;
-        }
-    },
-    addEffect(effect) {
-        const index = this.effects.indexOf(effect);
-        if (index !== -1)
-            return; // already exists!
-        this.effects.push(effect);
-        this.effects.sort((a, b) => a.priority - b.priority);
-        this._markStructureAsChanged();
-        // if (this.renderGroup)
-        // {
-        //     this.renderGroup.structureDidChange = true;
-        // }
-        this._updateIsSimple();
-    },
-    removeEffect(effect) {
-        const index = this.effects.indexOf(effect);
-        if (index === -1)
-            return; // already exists!
-        this.effects.splice(index, 1);
-        this._markStructureAsChanged();
-        this._updateIsSimple();
-    },
-    set mask(value) {
-        const effect = this._maskEffect;
-        if ((effect === null || effect === void 0 ? void 0 : effect.mask) === value)
-            return;
-        if (effect) {
-            this.removeEffect(effect);
-            MaskEffectManager.returnMaskEffect(effect);
-            this._maskEffect = null;
-        }
-        if (value === null || value === undefined)
-            return;
-        this._maskEffect = MaskEffectManager.getMaskEffect(value);
-        this.addEffect(this._maskEffect);
-    },
-    get mask() {
-        var _a;
-        return (_a = this._maskEffect) === null || _a === void 0 ? void 0 : _a.mask;
-    },
-    setMask(options) {
-        this._maskOptions = Object.assign(Object.assign({}, this._maskOptions), options);
-        if (options.mask) {
-            this.mask = options.mask;
-        }
-        this._markStructureAsChanged();
-    },
-    set filters(value) {
-        var _a;
-        if (!Array.isArray(value) && value)
-            value = [value];
-        const effect = this._filterEffect || (this._filterEffect = new FilterEffect());
-        // Ignore the Filter type
-        value = value;
-        const hasFilters = (value === null || value === void 0 ? void 0 : value.length) > 0;
-        const hadFilters = ((_a = effect.filters) === null || _a === void 0 ? void 0 : _a.length) > 0;
-        const didChange = hasFilters !== hadFilters;
-        // Clone the filters array so we don't freeze the user-input
-        value = Array.isArray(value) ? value.slice(0) : value;
-        // Ensure filters are immutable via filters getter
-        effect.filters = Object.freeze(value);
-        if (didChange) {
-            if (hasFilters) {
-                this.addEffect(effect);
-            }
-            else {
-                this.removeEffect(effect);
-                // sets the empty array...
-                effect.filters = value !== null && value !== void 0 ? value : null;
-            }
-        }
-    },
-    get filters() {
-        var _a;
-        return (_a = this._filterEffect) === null || _a === void 0 ? void 0 : _a.filters;
-    },
-    set filterArea(value) {
-        this._filterEffect || (this._filterEffect = new FilterEffect());
-        this._filterEffect.filterArea = value;
-    },
-    get filterArea() {
-        var _a;
-        return (_a = this._filterEffect) === null || _a === void 0 ? void 0 : _a.filterArea;
-    },
-};

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

@@ -1,78 +0,0 @@
-import type { Container } from '../Container';
-/** @ignore */
-export interface FindMixinConstructor {
-    /**
-     * The instance label of the object.
-     * @default null
-     */
-    label?: string;
-}
-/**
- * The FindMixin interface provides methods for finding children within a container by their label.
- * It allows for searching for a single child or multiple children with a specific label,
- * either directly or recursively through the container's hierarchy.
- * @category scene
- * @advanced
- */
-export interface FindMixin extends Required<FindMixinConstructor> {
-    /**
-     * The instance name of the object.
-     * @deprecated since 8.0.0
-     * @see Container#label
-     * @default null
-     */
-    name: string;
-    /**
-     * @deprecated since 8.0.0
-     * @param {string} label - Instance name.
-     * @param {boolean}[deep=false] - Whether to search recursively
-     * @returns {Container} The child with the specified name.
-     * @see Container#getChildByLabel
-     */
-    getChildByName(label: RegExp | string, deep?: boolean): Container | null;
-    /**
-     * Returns the first child in the container with the specified label.
-     * Recursive searches are done in a pre-order traversal.
-     * @example
-     * ```ts
-     * // Basic label search
-     * const child = container.getChildByLabel('player');
-     *
-     * // Search with regular expression
-     * const enemy = container.getChildByLabel(/enemy-\d+/);
-     *
-     * // Deep search through children
-     * const deepChild = container.getChildByLabel('powerup', true);
-     * ```
-     * @param {RegExp|string} label - Instance label to search for
-     * @param {boolean} deep - Whether to search recursively through children
-     * @returns The first child with the specified label, or null if none found
-     * @see {@link Container#getChildrenByLabel} For finding all matches
-     * @see {@link Container#label} For setting labels
-     */
-    getChildByLabel(label: RegExp | string, deep?: boolean): Container | null;
-    /**
-     * Returns all children in the container with the specified label.
-     * Recursive searches are done in a pre-order traversal.
-     * @example
-     * ```ts
-     * // Basic label search
-     * const enemies = container.getChildrenByLabel('enemy');
-     * // Search with regular expression
-     * const powerups = container.getChildrenByLabel(/powerup-\d+/);
-     * // Deep search with collection
-     * const buttons = [];
-     * container.getChildrenByLabel('button', true, buttons);
-     * ```
-     * @param {string|RegExp} label  - Instance label to search for
-     * @param {boolean}[deep=false] - Whether to search recursively through children
-     * @param {Container[]} [out=[]]  - Optional array to store matching children in
-     * @returns An array of children with the specified label
-     * @see {@link Container#getChildByLabel} For finding first match
-     * @see {@link Container#label} For setting labels
-     */
-    getChildrenByLabel(label: RegExp | string, deep?: boolean, out?: Container[]): Container[];
-}
-/** @internal */
-export declare const findMixin: Partial<Container>;
-//# sourceMappingURL=findMixin.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"findMixin.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/scene/container/container-mixins/findMixin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,cAAc;AACd,MAAM,WAAW,oBAAoB;IAEjC;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAU,SAAQ,QAAQ,CAAC,oBAAoB,CAAC;IAE7D;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC;IACzE;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAAC;IAC1E;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,SAAS,EAAE,GAAG,SAAS,EAAE,CAAC;CAC9F;AAED,gBAAgB;AAChB,eAAO,MAAM,SAAS,EAAE,OAAO,CAAC,SAAS,CA6E3B,CAAC"}

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

@@ -1,53 +0,0 @@
-import { deprecation, v8_0_0 } from '../../../utils/logging/deprecation';
-/** @internal */
-export const findMixin = {
-    label: null,
-    get name() {
-        // #if _DEBUG
-        deprecation(v8_0_0, 'Container.name property has been removed, use Container.label instead');
-        // #endif
-        return this.label;
-    },
-    set name(value) {
-        // #if _DEBUG
-        deprecation(v8_0_0, 'Container.name property has been removed, use Container.label instead');
-        // #endif
-        this.label = value;
-    },
-    getChildByName(name, deep = false) {
-        return this.getChildByLabel(name, deep);
-    },
-    getChildByLabel(label, deep = false) {
-        const children = this.children;
-        for (let i = 0; i < children.length; i++) {
-            const child = children[i];
-            if (child.label === label || (label instanceof RegExp && label.test(child.label)))
-                return child;
-        }
-        if (deep) {
-            for (let i = 0; i < children.length; i++) {
-                const child = children[i];
-                const found = child.getChildByLabel(label, true);
-                if (found) {
-                    return found;
-                }
-            }
-        }
-        return null;
-    },
-    getChildrenByLabel(label, deep = false, out = []) {
-        const children = this.children;
-        for (let i = 0; i < children.length; i++) {
-            const child = children[i];
-            if (child.label === label || (label instanceof RegExp && label.test(child.label))) {
-                out.push(child);
-            }
-        }
-        if (deep) {
-            for (let i = 0; i < children.length; i++) {
-                children[i].getChildrenByLabel(label, true, out);
-            }
-        }
-        return out;
-    },
-};

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

@@ -1,40 +0,0 @@
-import { type RenderLayer } from '../../layers/RenderLayer';
-import { Bounds } from '../bounds/Bounds';
-import type { Container } from '../Container';
-/**
- * Interface for the GetFastGlobalBoundsMixin, which provides methods to compute
- * an approximate global bounding box for a container and its children.
- * @category scene
- * @advanced
- */
-export interface GetFastGlobalBoundsMixin {
-    /**
-     * Computes an approximate global bounding box for the container and its children.
-     * This method is optimized for speed by using axis-aligned bounding boxes (AABBs),
-     * and uses the last render results from when it updated the transforms. This function does not update them.
-     * which may result in slightly larger bounds but never smaller than the actual bounds.
-     *
-     * for accurate (but less performant) results use `container.getGlobalBounds`
-     * @param {boolean} [factorRenderLayers] - A flag indicating whether to consider render layers in the calculation.
-     * @param {Bounds} [bounds] - The output bounds object to store the result. If not provided, a new one is created.
-     * @returns {Bounds} The computed bounds.
-     * @advanced
-     */
-    getFastGlobalBounds(factorRenderLayers?: boolean, bounds?: Bounds): Bounds;
-    /**
-     * Recursively calculates the global bounds for the container and its children.
-     * This method is used internally by getFastGlobalBounds to traverse the scene graph.
-     * @param {boolean} factorRenderLayers - A flag indicating whether to consider render layers in the calculation.
-     * @param {Bounds} bounds - The bounds object to update with the calculated values.
-     * @param {RenderLayer} currentLayer - The current render layer being processed.
-     * @internal
-     */
-    _getGlobalBoundsRecursive(factorRenderLayers: boolean, bounds: Bounds, currentLayer: RenderLayer): void;
-}
-/**
- * Mixin providing the implementation of the GetFastGlobalBoundsMixin interface.
- * It includes methods to compute and recursively calculate global bounds for containers.
- * @internal
- */
-export declare const getFastGlobalBoundsMixin: Partial<Container>;
-//# sourceMappingURL=getFastGlobalBoundsMixin.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"getFastGlobalBoundsMixin.d.ts","sourceRoot":"","sources":["../../../../../../../packages/pixijs/src/scene/container/container-mixins/getFastGlobalBoundsMixin.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG1C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAI9C;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IAErC;;;;;;;;;;;OAWG;IACH,mBAAmB,CAAC,kBAAkB,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAE3E;;;;;;;OAOG;IACH,yBAAyB,CACrB,kBAAkB,EAAE,OAAO,EAC3B,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,WAAW,GAC1B,IAAI,CAAC;CACX;AAED;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,EAAE,OAAO,CAAC,SAAS,CAuH1C,CAAC"}

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

@@ -1,85 +0,0 @@
-import { Matrix } from '../../../maths/matrix/Matrix';
-import { Bounds } from '../bounds/Bounds';
-import { boundsPool } from '../bounds/utils/matrixAndBoundsPool';
-const tempMatrix = new Matrix();
-/**
- * Mixin providing the implementation of the GetFastGlobalBoundsMixin interface.
- * It includes methods to compute and recursively calculate global bounds for containers.
- * @internal
- */
-export const getFastGlobalBoundsMixin = {
-    getFastGlobalBounds(factorRenderLayers, bounds) {
-        bounds || (bounds = new Bounds());
-        // Initialize the bounds for fresh calculations.
-        bounds.clear();
-        // Calculate bounds recursively, starting from the current container.
-        this._getGlobalBoundsRecursive(!!factorRenderLayers, bounds, this.parentRenderLayer);
-        // Validate the calculated bounds, resetting if invalid.
-        if (!bounds.isValid) {
-            bounds.set(0, 0, 0, 0);
-        }
-        // Apply the world transformation to the bounds.
-        const renderGroup = this.renderGroup || this.parentRenderGroup;
-        bounds.applyMatrix(renderGroup.worldTransform);
-        return bounds;
-    },
-    _getGlobalBoundsRecursive(factorRenderLayers, bounds, currentLayer) {
-        let localBounds = bounds;
-        // Skip if the container is not in the current render layer when factoring render layers.
-        if (factorRenderLayers && this.parentRenderLayer && this.parentRenderLayer !== currentLayer)
-            return;
-        // Skip if the container is not fully visible or not measurable.
-        if (this.localDisplayStatus !== 0b111 || (!this.measurable)) {
-            return;
-        }
-        // Determine if effects need to be managed, requiring separate bounds handling.
-        const manageEffects = !!this.effects.length;
-        // Use a temporary bounds object if the container is a render group or has effects.
-        if (this.renderGroup || manageEffects) {
-            localBounds = boundsPool.get().clear();
-        }
-        // Add the container's own bounds area to the bounds if it exists.
-        if (this.boundsArea) {
-            bounds.addRect(this.boundsArea, this.worldTransform);
-        }
-        else {
-            // If the container is renderable, add its bounds to the local bounds.
-            if (this.renderPipeId) {
-                const viewBounds = this.bounds;
-                localBounds.addFrame(viewBounds.minX, viewBounds.minY, viewBounds.maxX, viewBounds.maxY, this.groupTransform);
-            }
-            // Recursively process each child to include their bounds.
-            const children = this.children;
-            for (let i = 0; i < children.length; i++) {
-                children[i]._getGlobalBoundsRecursive(factorRenderLayers, localBounds, currentLayer);
-            }
-        }
-        // If effects are managed, apply them to the bounds.
-        if (manageEffects) {
-            let advanced = false;
-            const renderGroup = this.renderGroup || this.parentRenderGroup;
-            // Apply each effect that modifies bounds.
-            for (let i = 0; i < this.effects.length; i++) {
-                if (this.effects[i].addBounds) {
-                    if (!advanced) {
-                        advanced = true;
-                        localBounds.applyMatrix(renderGroup.worldTransform);
-                    }
-                    this.effects[i].addBounds(localBounds, true);
-                }
-            }
-            // Adjust bounds back to the local coordinate space if advanced bounds were calculated.
-            if (advanced) {
-                localBounds.applyMatrix(renderGroup.worldTransform.copyTo(tempMatrix).invert());
-            }
-            // Add the local bounds to the final bounds and return the temporary bounds object.
-            bounds.addBounds(localBounds);
-            boundsPool.return(localBounds);
-        }
-        else if (this.renderGroup) {
-            // If the container is a render group, add its local bounds to the final bounds.
-            bounds.addBounds(localBounds, this.relativeGroupTransform);
-            boundsPool.return(localBounds);
-        }
-    }
-};