@safe-engine/pixi 8.10.2 → 8.10.4

package/dist/packages/pixijs/src/culling/Culler.js

@@ -1,118 +0,0 @@
-import { Bounds } from '../scene/container/bounds/Bounds';
-import { getGlobalBounds } from '../scene/container/bounds/getGlobalBounds';
-const tempBounds = new Bounds();
-/**
- * The Culler class is responsible for managing and culling containers.
- * Culling optimizes rendering performance by skipping objects outside the visible area.
- *
- * > [!IMPORTANT] culling is not always a golden bullet, it can be more expensive than rendering
- * > objects that are not visible, so it is best used in scenarios where you have many objects
- * > that are not visible at the same time, such as in large scenes or games with many sprites.
- * @example
- * ```ts
- * import { Culler, Container, Rectangle } from 'pixi.js';
- *
- * // Create a culler and container
- * const culler = new Culler();
- * const stage = new Container();
- *
- * // Set up container with culling
- * stage.cullable = true;
- * stage.cullArea = new Rectangle(0, 0, 800, 600);
- *
- * // Add some sprites that will be culled
- * for (let i = 0; i < 1000; i++) {
- *     const sprite = Sprite.from('texture.png');
- *     sprite.x = Math.random() * 2000;
- *     sprite.y = Math.random() * 2000;
- *     sprite.cullable = true;
- *     stage.addChild(sprite);
- * }
- *
- * // Cull objects outside view
- * culler.cull(stage, {
- *     x: 0,
- *     y: 0,
- *     width: 800,
- *     height: 600
- * });
- *
- * // Only visible objects will be rendered
- * renderer.render(stage);
- * ```
- * @see {@link CullerPlugin} For automatic culling in applications
- * @see {@link CullingMixinConstructor} For culling properties
- * @category scene
- * @standard
- */
-export class Culler {
-    /**
-     * Culls the children of a specific container based on the given view rectangle.
-     * This determines which objects should be rendered and which can be skipped.
-     * @param container - The container to cull. Must be a Container instance.
-     * @param view - The view rectangle that defines the visible area
-     * @param skipUpdateTransform - Whether to skip updating transforms for better performance
-     * @example
-     * ```ts
-     * // Basic culling with view bounds
-     * const culler = new Culler();
-     * culler.cull(stage, {
-     *     x: 0,
-     *     y: 0,
-     *     width: 800,
-     *     height: 600
-     * });
-     *
-     * // Culling to renderer screen
-     * culler.cull(stage, renderer.screen, false);
-     * ```
-     * @remarks
-     * - Recursively processes all cullable children
-     * - Uses cullArea if defined, otherwise calculates bounds
-     * - Performance depends on scene complexity
-     * @see {@link CullingMixinConstructor.cullable} For enabling culling on objects
-     * @see {@link CullingMixinConstructor.cullArea} For custom culling boundaries
-     */
-    cull(container, view, skipUpdateTransform = true) {
-        this._cullRecursive(container, view, skipUpdateTransform);
-    }
-    _cullRecursive(container, view, skipUpdateTransform = true) {
-        var _a;
-        if (container.cullable && container.measurable && container.includeInBuild) {
-            const bounds = (_a = container.cullArea) !== null && _a !== void 0 ? _a : getGlobalBounds(container, skipUpdateTransform, tempBounds);
-            // check view intersection..
-            container.culled = bounds.x >= view.x + view.width
-                || bounds.y >= view.y + view.height
-                || bounds.x + bounds.width <= view.x
-                || bounds.y + bounds.height <= view.y;
-        }
-        else {
-            container.culled = false;
-        }
-        // dont process children if not needed
-        if (!container.cullableChildren
-            || container.culled
-            || !container.renderable
-            || !container.measurable
-            || !container.includeInBuild)
-            return;
-        for (let i = 0; i < container.children.length; i++) {
-            this._cullRecursive(container.children[i], view, skipUpdateTransform);
-        }
-    }
-}
-/**
- * A shared instance of the Culler class. Provides a global culler instance for convenience.
- * @example
- * ```ts
- * // Use the shared instance instead of creating a new one
- * Culler.shared.cull(stage, {
- *     x: 0,
- *     y: 0,
- *     width: 800,
- *     height: 600
- * });
- * ```
- * @see {@link CullerPlugin} For automatic culling using this instance
- */
-Culler.shared = new Culler();

package/dist/packages/pixijs/src/culling/CullerPlugin.d.ts

@@ -1,131 +0,0 @@
-import type { ExtensionMetadata } from '../extensions/Extensions';
-import type { Renderer } from '../rendering/renderers/types';
-import type { Container } from '../scene/container/Container';
-/**
- * Application options for the {@link CullerPlugin}.
- * These options control how your application handles culling of display objects.
- * @example
- * ```ts
- * import { Application } from 'pixi.js';
- *
- * // Create application
- * const app = new Application();
- * await app.init({
- *     culler: {
- *         updateTransform: false // Skip updating transforms for culled objects
- *     }
- * });
- * ```
- * @category app
- * @standard
- */
-export interface CullerPluginOptions {
-    /**
-     * Options for the culler behavior.
-     * @example
-     * ```ts
-     * // Basic culling options
-     * const app = new Application();
-     * await app.init({
-     *     culler: {...}
-     * });
-     * ```
-     */
-    culler?: {
-        /**
-         * Update the transform of culled objects.
-         *
-         * > [!IMPORTANT] Keeping this as `false` can improve performance by avoiding unnecessary calculations,
-         * > however, the transform used for culling may not be up-to-date if the object has moved since the last render.
-         * @default true
-         * @example
-         * ```ts
-         * const app = new Application();
-         * await app.init({
-         *     culler: {
-         *         updateTransform: false // Skip updating transforms for culled objects
-         *     }
-         * });
-         * ```
-         */
-        updateTransform?: boolean;
-    };
-}
-/**
- * An {@link Application} plugin that automatically culls (hides) display objects that are outside
- * the visible screen area. This improves performance by not rendering objects that aren't visible.
- *
- * Key Features:
- * - Automatic culling based on screen boundaries
- * - Configurable culling areas and behavior per container
- * - Can improve rendering performance
- * @example
- * ```ts
- * import { Application, CullerPlugin, Container, Rectangle } from 'pixi.js';
- *
- * // Register the plugin
- * extensions.add(CullerPlugin);
- *
- * // Create application
- * const app = new Application();
- * await app.init({...});
- *
- * // Create a container with culling enabled
- * const container = new Container();
- * container.cullable = true;         // Enable culling for this container
- * container.cullableChildren = true; // Enable culling for children (default)
- * app.stage.addChild(container);
- *
- * // Optional: Set custom cull area to avoid expensive bounds calculations
- * container.cullArea = new Rectangle(0, 0, app.screen.width, app.screen.height);
- *
- * // Add many sprites to the group
- * for (let j = 0; j < 100; j++) {
- *     const sprite = Sprite.from('texture.png');
- *     sprite.x = Math.random() * 2000;
- *     sprite.y = Math.random() * 2000;
- *
- *     sprite.cullable = true; // Enable culling for each sprite
- *
- *     // Set cullArea if needed
- *     // sprite.cullArea = new Rectangle(0, 0, 100, 100); // Optional
- *
- *     // Add to container
- *     container.addChild(sprite);
- * }
- * ```
- * @remarks
- * To enable culling, you must set the following properties on your containers:
- * - `cullable`: Set to `true` to enable culling for the container
- * - `cullableChildren`: Set to `true` to enable culling for children (default)
- * - `cullArea`: Optional custom Rectangle for culling bounds
- *
- * Performance Tips:
- * - Group objects that are spatially related
- * - Use `cullArea` for containers with many children to avoid bounds calculations
- * - Set `cullableChildren = false` for containers that are always fully visible
- * @category app
- * @standard
- * @see {@link Culler} For the underlying culling implementation
- * @see {@link CullingMixinConstructor} For culling properties documentation
- */
-export declare class CullerPlugin {
-    /** @ignore */
-    static extension: ExtensionMetadata;
-    /** @internal */
-    static renderer: Renderer;
-    /** @internal */
-    static stage: Container;
-    /** @internal */
-    static render: () => void;
-    private static _renderRef;
-    /**
-     * Initialize the plugin with scope of application instance
-     * @private
-     * @param {object} [options] - See application options
-     */
-    static init(options?: PixiMixins.ApplicationOptions): void;
-    /** @internal */
-    static destroy(): void;
-}
-//# sourceMappingURL=CullerPlugin.d.ts.map

package/dist/packages/pixijs/src/culling/CullerPlugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CullerPlugin.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/src/culling/CullerPlugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAE9D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,mBAAmB;IAEhC;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE;QACL;;;;;;;;;;;;;;;WAeG;QACH,eAAe,CAAC,EAAE,OAAO,CAAC;KAC7B,CAAC;CACL;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,qBAAa,YAAY;IAErB,cAAc;IACd,OAAc,SAAS,EAAE,iBAAiB,CAIxC;IAEF,gBAAgB;IAChB,OAAc,QAAQ,EAAE,QAAQ,CAAC;IACjC,gBAAgB;IAChB,OAAc,KAAK,EAAE,SAAS,CAAC;IAC/B,gBAAgB;IAChB,OAAc,MAAM,EAAE,MAAM,IAAI,CAAC;IACjC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAa;IAEtC;;;;OAIG;WACW,IAAI,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,kBAAkB,GAAG,IAAI;IAcjE,gBAAgB;WACF,OAAO,IAAI,IAAI;CAIhC"}

package/dist/packages/pixijs/src/culling/CullerPlugin.js

@@ -1,87 +0,0 @@
-import { ExtensionType } from '../extensions/Extensions';
-import { Culler } from './Culler';
-/**
- * An {@link Application} plugin that automatically culls (hides) display objects that are outside
- * the visible screen area. This improves performance by not rendering objects that aren't visible.
- *
- * Key Features:
- * - Automatic culling based on screen boundaries
- * - Configurable culling areas and behavior per container
- * - Can improve rendering performance
- * @example
- * ```ts
- * import { Application, CullerPlugin, Container, Rectangle } from 'pixi.js';
- *
- * // Register the plugin
- * extensions.add(CullerPlugin);
- *
- * // Create application
- * const app = new Application();
- * await app.init({...});
- *
- * // Create a container with culling enabled
- * const container = new Container();
- * container.cullable = true;         // Enable culling for this container
- * container.cullableChildren = true; // Enable culling for children (default)
- * app.stage.addChild(container);
- *
- * // Optional: Set custom cull area to avoid expensive bounds calculations
- * container.cullArea = new Rectangle(0, 0, app.screen.width, app.screen.height);
- *
- * // Add many sprites to the group
- * for (let j = 0; j < 100; j++) {
- *     const sprite = Sprite.from('texture.png');
- *     sprite.x = Math.random() * 2000;
- *     sprite.y = Math.random() * 2000;
- *
- *     sprite.cullable = true; // Enable culling for each sprite
- *
- *     // Set cullArea if needed
- *     // sprite.cullArea = new Rectangle(0, 0, 100, 100); // Optional
- *
- *     // Add to container
- *     container.addChild(sprite);
- * }
- * ```
- * @remarks
- * To enable culling, you must set the following properties on your containers:
- * - `cullable`: Set to `true` to enable culling for the container
- * - `cullableChildren`: Set to `true` to enable culling for children (default)
- * - `cullArea`: Optional custom Rectangle for culling bounds
- *
- * Performance Tips:
- * - Group objects that are spatially related
- * - Use `cullArea` for containers with many children to avoid bounds calculations
- * - Set `cullableChildren = false` for containers that are always fully visible
- * @category app
- * @standard
- * @see {@link Culler} For the underlying culling implementation
- * @see {@link CullingMixinConstructor} For culling properties documentation
- */
-export class CullerPlugin {
-    /**
-     * Initialize the plugin with scope of application instance
-     * @private
-     * @param {object} [options] - See application options
-     */
-    static init(options) {
-        this._renderRef = this.render.bind(this);
-        this.render = () => {
-            var _a;
-            // default to true for updateTransform, unless specified otherwise
-            const updateTransform = ((_a = options === null || options === void 0 ? void 0 : options.culler) === null || _a === void 0 ? void 0 : _a.updateTransform) !== true;
-            Culler.shared.cull(this.stage, this.renderer.screen, updateTransform);
-            this.renderer.render({ container: this.stage });
-        };
-    }
-    /** @internal */
-    static destroy() {
-        this.render = this._renderRef;
-    }
-}
-/** @ignore */
-CullerPlugin.extension = {
-    priority: 10,
-    type: ExtensionType.Application,
-    name: 'culler',
-};

package/dist/packages/pixijs/src/culling/__tests__/Culler.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Culler.test.d.ts.map

package/dist/packages/pixijs/src/culling/__tests__/Culler.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Culler.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/pixijs/src/culling/__tests__/Culler.test.ts"],"names":[],"mappings":""}

package/dist/packages/pixijs/src/culling/__tests__/Culler.test.js

@@ -1,212 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { Application } from '../../app/Application';
-import { Culler } from '../Culler';
-import { CullerPlugin } from '../CullerPlugin';
-import { basePath } from '@test-utils';
-import { Assets, loadTextures } from '~/assets';
-import { extensions } from '~/extensions';
-import { AlphaFilter } from '~/filters';
-import { Rectangle } from '~/maths';
-import { Container, Graphics, Sprite } from '~/scene';
-describe('Culler', () => {
-    extensions.add(loadTextures);
-    let container;
-    let texture;
-    const view = { x: 0, y: 0, width: 100, height: 100 };
-    beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
-        yield Assets.init({
-            basePath,
-        });
-        texture = yield Assets.load('textures/bunny.png');
-    }));
-    afterAll(() => {
-        Assets.reset();
-    });
-    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
-        Culler.shared = new Culler();
-        container = new Container();
-    }));
-    it('should cull from the list', () => {
-        const child = new Sprite(texture);
-        child.x = 100;
-        child.y = 100;
-        child.width = 10;
-        child.height = 10;
-        child.cullable = true;
-        container.addChild(child);
-        Culler.shared.cull(container, view, false);
-        expect(container.culled).toBe(false);
-        expect(child.culled).toBe(true);
-        child.x = 0;
-        child.y = 0;
-        Culler.shared.cull(container, view, false);
-        expect(container.culled).toBe(false);
-        expect(child.culled).toBe(false);
-    });
-    it('should set culled to false if object becomes non-cullable', () => {
-        const child = new Sprite(texture);
-        child.x = 100;
-        child.y = 100;
-        child.width = 10;
-        child.height = 10;
-        child.cullable = true;
-        container.addChild(child);
-        Culler.shared.cull(container, view, false);
-        expect(child.culled).toBe(true);
-        child.x = 0;
-        child.y = 0;
-        child.cullable = false;
-        Culler.shared.cull(container, view, false);
-        expect(child.culled).toBe(false);
-    });
-    it('noncullable container should always be rendered even if bounds do not intersect the frame', () => {
-        const graphics = container.addChild(new Graphics().rect(0, 0, 10, 10).fill());
-        container.cullable = false;
-        graphics.x = -1000;
-        graphics.y = -1000;
-        Culler.shared.cull(container, view, false);
-        expect(container.culled).toBe(false);
-        expect(graphics.culled).toBe(false);
-    });
-    it('cullable container should not be rendered if bounds do not intersect the frame', () => {
-        const container = new Container();
-        const graphics = container.addChild(new Graphics().rect(0, 0, 10, 10).fill());
-        container.cullable = true;
-        graphics.x = 0;
-        graphics.y = -10;
-        Culler.shared.cull(container, view, false);
-        expect(container.culled).toBe(true);
-        expect(graphics.culled).toBe(false);
-        graphics.x = 10;
-        graphics.y = 10;
-        Culler.shared.cull(container, view, false);
-        expect(container.culled).toBe(false);
-        expect(graphics.culled).toBe(false);
-    });
-    it('cullable container should be rendered if bounds intersects the frame', () => {
-        const container = new Container();
-        const graphics = container.addChild(new Graphics().rect(0, 0, 10, 10).fill());
-        container.cullable = true;
-        graphics.x = 0;
-        graphics.y = -9;
-        Culler.shared.cull(container, view, false);
-        expect(container.culled).toBe(false);
-        expect(graphics.culled).toBe(false);
-        graphics.x = -30;
-        graphics.y = -30;
-        Culler.shared.cull(container, view, false);
-        expect(container.culled).toBe(true);
-        expect(graphics.culled).toBe(false);
-    });
-    it('cullable container that contains a child with a padded filter'
-        + 'such that the child in out of frame but the filter padding intersects the frame '
-        + 'should render the filter padding but not the container or child', () => {
-        const container = new Container();
-        const graphics = container.addChild(new Graphics().rect(0, 0, 10, 10).fill());
-        const filter = new AlphaFilter();
-        filter.padding = 30;
-        container.cullable = true;
-        graphics.filters = [filter];
-        graphics.x = 0;
-        graphics.y = -15;
-        Culler.shared.cull(container, view, false);
-        expect(container.culled).toBe(true);
-        expect(graphics.culled).toBe(false);
-    });
-    it('cullable container with a filter should not render the container or children '
-        + 'if the bounds as well as the filter padding do no intersect the frame', () => {
-        const container = new Container();
-        const graphics = container.addChild(new Graphics().rect(0, 0, 10, 10).fill());
-        const filter = new AlphaFilter();
-        filter.padding = 5;
-        container.cullable = true;
-        container.filters = [filter];
-        graphics.x = 0;
-        graphics.y = -15;
-        Culler.shared.cull(container, view, false);
-        expect(container.culled).toBe(true);
-        expect(graphics.culled).toBe(false);
-    });
-    it('cullable container with cullArea should be rendered if the bounds intersect the frame', () => {
-        const container = new Container();
-        const graphics = container.addChild(new Graphics().rect(0, 0, 10, 10).fill());
-        container.cullable = true;
-        container.cullArea = new Rectangle(-10, -10, 11, 11);
-        container.x = container.y = 107.07;
-        container.rotation = Math.PI / 4;
-        Culler.shared.cull(container, view, false);
-        expect(container.culled).toBe(false);
-        expect(graphics.culled).toBe(false);
-    });
-    it('cullable container with cullArea should not be rendered if the bounds do not intersect the frame', () => {
-        const container = new Container();
-        const graphics = container.addChild(new Graphics().rect(0, 0, 10, 10).fill());
-        container.cullable = true;
-        container.cullArea = new Rectangle(-10, -10, 10, 10);
-        container.x = container.y = 107.08;
-        container.rotation = Math.PI / 4;
-        Culler.shared.cull(container, view, false);
-        expect(container.culled).toBe(true);
-        expect(graphics.culled).toBe(false);
-    });
-});
-describe('CullerPlugin', () => {
-    it('should use the correct default options', () => __awaiter(void 0, void 0, void 0, function* () {
-        const spyCull = jest.spyOn(Culler.shared, 'cull');
-        extensions.add(CullerPlugin);
-        const app = new Application();
-        yield app.init();
-        app.render();
-        expect(spyCull).toHaveBeenCalledWith(app.stage, app.renderer.screen, true);
-        app.destroy();
-        extensions.remove(CullerPlugin);
-    }));
-    it('should use the correct options: true', () => __awaiter(void 0, void 0, void 0, function* () {
-        const spyInit = jest.spyOn(CullerPlugin, 'init');
-        const spyCull = jest.spyOn(Culler.shared, 'cull');
-        extensions.add(CullerPlugin);
-        const app = new Application();
-        yield app.init({
-            culler: {
-                updateTransform: true,
-            },
-        });
-        expect(spyInit).toHaveBeenCalledWith({
-            culler: {
-                updateTransform: true,
-            },
-        });
-        app.render();
-        expect(spyCull).toHaveBeenCalledWith(app.stage, app.renderer.screen, false);
-        app.destroy();
-        extensions.remove(CullerPlugin);
-    }));
-    it('should use the correct options: false', () => __awaiter(void 0, void 0, void 0, function* () {
-        const spyInit = jest.spyOn(CullerPlugin, 'init');
-        const spyCull = jest.spyOn(Culler.shared, 'cull');
-        extensions.add(CullerPlugin);
-        const app = new Application();
-        yield app.init({
-            culler: {
-                updateTransform: false,
-            },
-        });
-        expect(spyInit).toHaveBeenCalledWith({
-            culler: {
-                updateTransform: false,
-            },
-        });
-        app.render();
-        expect(spyCull).toHaveBeenCalledWith(app.stage, app.renderer.screen, true);
-        app.destroy();
-        extensions.remove(CullerPlugin);
-    }));
-});

package/dist/packages/pixijs/src/culling/cullingMixin.d.ts

@@ -1,96 +0,0 @@
-import type { Rectangle } from '../maths/shapes/Rectangle';
-/**
- * The CullingMixin interface provides properties and methods for managing culling behavior
- * of a display object. Culling is the process of determining whether an object should be rendered
- * based on its visibility within the current view or frame.
- *
- * Key Features:
- * - Custom culling areas for better performance
- * - Per-object culling control
- * - Child culling management
- * @example
- * ```ts
- * // Enable culling for a container
- * const container = new Container();
- * container.cullable = true;
- *
- * // Set custom cull area for better performance
- * container.cullArea = new Rectangle(0, 0, 800, 600);
- *
- * // Disable child culling for static scenes
- * container.cullableChildren = false;
- * ```
- * @category scene
- * @standard
- */
-export interface CullingMixinConstructor {
-    /**
-     * Custom shape used for culling calculations instead of object bounds.
-     * Defined in local space coordinates relative to the object.
-     * > [!NOTE]
-     * > Setting this to a custom Rectangle allows you to define a specific area for culling,
-     * > which can improve performance by avoiding expensive bounds calculations.
-     * @example
-     * ```ts
-     * const container = new Container();
-     *
-     * // Define custom culling boundary
-     * container.cullArea = new Rectangle(0, 0, 800, 600);
-     *
-     * // Reset to use object bounds
-     * container.cullArea = null;
-     * ```
-     * @remarks
-     * - Improves performance by avoiding bounds calculations
-     * - Useful for containers with many children
-     * - Set to null to use object bounds
-     * @default null
-     */
-    cullArea: Rectangle;
-    /**
-     * Controls whether this object should be culled when out of view.
-     * When true, the object will not be rendered if its bounds are outside the visible area.
-     * @example
-     * ```ts
-     * const sprite = new Sprite(texture);
-     *
-     * // Enable culling
-     * sprite.cullable = true;
-     *
-     * // Force object to always render
-     * sprite.cullable = false;
-     * ```
-     * @remarks
-     * - Does not affect transform updates
-     * - Applies to this object only
-     * - Children follow their own cullable setting
-     * @default false
-     */
-    cullable: boolean;
-    /**
-     * Controls whether children of this container can be culled.
-     * When false, skips recursive culling checks for better performance.
-     * @example
-     * ```ts
-     * const container = new Container();
-     *
-     * // Enable container culling
-     * container.cullable = true;
-     *
-     * // Disable child culling for performance
-     * container.cullableChildren = false;
-     *
-     * // Children will always render if container is visible
-     * container.addChild(sprite1, sprite2, sprite3);
-     * ```
-     * @remarks
-     * - Improves performance for static scenes
-     * - Useful when children are always within container bounds
-     * - Parent culling still applies
-     * @default true
-     */
-    cullableChildren: boolean;
-}
-/** @internal */
-export declare const cullingMixin: CullingMixinConstructor;
-//# sourceMappingURL=cullingMixin.d.ts.map

package/dist/packages/pixijs/src/culling/cullingMixin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cullingMixin.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/src/culling/cullingMixin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,uBAAuB;IAEpC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,EAAE,SAAS,CAAC;IAEpB;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,gBAAgB,EAAE,OAAO,CAAC;CAC7B;AAED,gBAAgB;AAChB,eAAO,MAAM,YAAY,EAAE,uBAI1B,CAAC"}

package/dist/packages/pixijs/src/culling/cullingMixin.js

@@ -1,6 +0,0 @@
-/** @internal */
-export const cullingMixin = {
-    cullArea: null,
-    cullable: false,
-    cullableChildren: true,
-};

package/dist/packages/pixijs/src/culling/index.d.ts

@@ -1,4 +0,0 @@
-export * from './Culler';
-export * from './CullerPlugin';
-export * from './cullingMixin';
-//# sourceMappingURL=index.d.ts.map

package/dist/packages/pixijs/src/culling/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/pixijs/src/culling/index.ts"],"names":[],"mappings":"AACA,cAAc,UAAU,CAAC;AACzB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC"}

package/dist/packages/pixijs/src/culling/index.js

@@ -1,4 +0,0 @@
-// Auto-generated code, do not edit manually
-export * from './Culler';
-export * from './CullerPlugin';
-export * from './cullingMixin';