@safe-engine/pixi 8.7.4 → 8.8.2

package/dist/packages/pixijs/src/rendering/renderers/shared/system/AbstractRenderer.js

@@ -0,0 +1,414 @@
+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 { Color } from '../../../../color/Color';
+import { loadEnvironmentExtensions } from '../../../../environment/autoDetectEnvironment';
+import { Container } from '../../../../scene/container/Container';
+import { unsafeEvalSupported } from '../../../../utils/browser/unsafeEvalSupported';
+import { uid } from '../../../../utils/data/uid';
+import { deprecation, v8_0_0 } from '../../../../utils/logging/deprecation';
+import { GlobalResourceRegistry } from '../../../../utils/pool/GlobalResourceRegistry';
+import { EventEmitter } from '../../../../utils/utils';
+import { CLEAR } from '../../gl/const';
+import { SystemRunner } from './SystemRunner';
+const defaultRunners = [
+    'init',
+    'destroy',
+    'contextChange',
+    'resolutionChange',
+    'resetState',
+    'renderEnd',
+    'renderStart',
+    'render',
+    'update',
+    'postrender',
+    'prerender'
+];
+/* eslint-disable max-len */
+/**
+ * The base class for a PixiJS Renderer. It contains the shared logic for all renderers.
+ *
+ * You should not use this class directly, but instead use {@link WebGLRenderer}
+ * or {@link WebGPURenderer}.
+ * Alternatively, you can also use {@link autoDetectRenderer} if you want us to
+ * determine the best renderer for you.
+ *
+ * The renderer is composed of systems that manage specific tasks. The following systems are added by default
+ * whenever you create a renderer:
+ *
+ *
+ * | Generic Systems                      | Systems that manage functionality that all renderer types share               |
+ * | ------------------------------------ | ----------------------------------------------------------------------------- |
+ * | {@link ViewSystem}              | This manages the main view of the renderer usually a Canvas              |
+ * | {@link BackgroundSystem}        | This manages the main views background color and alpha                   |
+ * | {@link EventSystem}           | This manages UI events.                                                       |
+ * | {@link AccessibilitySystem} | This manages accessibility features. Requires `import 'pixi.js/accessibility'`|
+ *
+ * | Core Systems                   | Provide an optimised, easy to use API to work with WebGL/WebGPU               |
+ * | ------------------------------------ | ----------------------------------------------------------------------------- |
+ * | {@link GlobalUniformSystem} | This manages shaders, programs that run on the GPU to calculate 'em pixels.   |
+ * | {@link TextureGCSystem}     | This will automatically remove textures from the GPU if they are not used.    |
+ *
+ * | PixiJS High-Level Systems            | Set of specific systems designed to work with PixiJS objects                  |
+ * | ------------------------------------ | ----------------------------------------------------------------------------- |
+ * | {@link HelloSystem}               | Says hello, buy printing out the pixi version into the console log (along with the renderer type)       |
+ * | {@link GenerateTextureSystem} | This adds the ability to generate textures from any Container       |
+ * | {@link FilterSystem}          | This manages the filtering pipeline for post-processing effects.             |
+ * | {@link PrepareSystem}               | This manages uploading assets to the GPU. Requires `import 'pixi.js/prepare'`|
+ * | {@link ExtractSystem}               | This extracts image data from display objects.                               |
+ *
+ * The breadth of the API surface provided by the renderer is contained within these systems.
+ * @abstract
+ * @category rendering
+ * @advanced
+ * @property {HelloSystem} hello - HelloSystem instance.
+ * @property {TextureGCSystem} textureGC - TextureGCSystem instance.
+ * @property {FilterSystem} filter - FilterSystem instance.
+ * @property {GlobalUniformSystem} globalUniforms - GlobalUniformSystem instance.
+ * @property {TextureSystem} texture - TextureSystem instance.
+ * @property {EventSystem} events - EventSystem instance.
+ * @property {ExtractSystem} extract - ExtractSystem instance. Requires `import 'pixi.js/extract'`.
+ * @property {PrepareSystem} prepare - PrepareSystem instance. Requires `import 'pixi.js/prepare'`.
+ * @property {AccessibilitySystem} accessibility - AccessibilitySystem instance. Requires `import 'pixi.js/accessibility'`.
+ */
+export class AbstractRenderer extends EventEmitter {
+    /**
+     * Set up a system with a collection of SystemClasses and runners.
+     * Systems are attached dynamically to this class when added.
+     * @param config - the config for the system manager
+     */
+    constructor(config) {
+        var _a;
+        super();
+        /** @internal */
+        this.uid = uid('renderer');
+        /** @internal */
+        this.runners = Object.create(null);
+        /** @internal */
+        this.renderPipes = Object.create(null);
+        this._initOptions = {};
+        this._systemsHash = Object.create(null);
+        this.type = config.type;
+        this.name = config.name;
+        this.config = config;
+        const combinedRunners = [...defaultRunners, ...((_a = this.config.runners) !== null && _a !== void 0 ? _a : [])];
+        this._addRunners(...combinedRunners);
+        // Validation check that this environment support `new Function`
+        this._unsafeEvalCheck();
+    }
+    /**
+     * Initialize the renderer.
+     * @param options - The options to use to create the renderer.
+     */
+    init() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            const skip = options.skipExtensionImports === true ? true : options.manageImports === false;
+            yield loadEnvironmentExtensions(skip);
+            this._addSystems(this.config.systems);
+            this._addPipes(this.config.renderPipes, this.config.renderPipeAdaptors);
+            // loop through all systems...
+            for (const systemName in this._systemsHash) {
+                const system = this._systemsHash[systemName];
+                const defaultSystemOptions = system.constructor.defaultOptions;
+                options = Object.assign(Object.assign({}, defaultSystemOptions), options);
+            }
+            options = Object.assign(Object.assign({}, AbstractRenderer.defaultOptions), options);
+            this._roundPixels = options.roundPixels ? 1 : 0;
+            // await emits..
+            for (let i = 0; i < this.runners.init.items.length; i++) {
+                yield this.runners.init.items[i].init(options);
+            }
+            // store options
+            this._initOptions = options;
+        });
+    }
+    render(args, deprecated) {
+        var _a, _b;
+        let options = args;
+        if (options instanceof Container) {
+            options = { container: options };
+            if (deprecated) {
+                // #if _DEBUG
+                deprecation(v8_0_0, 'passing a second argument is deprecated, please use render options instead');
+                // #endif
+                options.target = deprecated.renderTexture;
+            }
+        }
+        options.target || (options.target = this.view.renderTarget);
+        // TODO: we should eventually fix events so that it can handle multiple canvas elements
+        if (options.target === this.view.renderTarget) {
+            // TODO get rid of this
+            this._lastObjectRendered = options.container;
+            (_a = options.clearColor) !== null && _a !== void 0 ? _a : (options.clearColor = this.background.colorRgba);
+            (_b = options.clear) !== null && _b !== void 0 ? _b : (options.clear = this.background.clearBeforeRender);
+        }
+        if (options.clearColor) {
+            const isRGBAArray = Array.isArray(options.clearColor) && options.clearColor.length === 4;
+            options.clearColor = isRGBAArray ? options.clearColor : Color.shared.setValue(options.clearColor).toArray();
+        }
+        if (!options.transform) {
+            options.container.updateLocalTransform();
+            options.transform = options.container.localTransform;
+        }
+        // Check if the container is visible before proceeding with rendering
+        if (!options.container.visible) {
+            return;
+        }
+        // lets ensure this object is a render group so we can render it!
+        // the renderer only likes to render - render groups.
+        options.container.enableRenderGroup();
+        this.runners.prerender.emit(options);
+        this.runners.renderStart.emit(options);
+        this.runners.render.emit(options);
+        this.runners.renderEnd.emit(options);
+        this.runners.postrender.emit(options);
+    }
+    /**
+     * Resizes the WebGL view to the specified width and height.
+     * @param desiredScreenWidth - The desired width of the screen.
+     * @param desiredScreenHeight - The desired height of the screen.
+     * @param resolution - The resolution / device pixel ratio of the renderer.
+     */
+    resize(desiredScreenWidth, desiredScreenHeight, resolution) {
+        const previousResolution = this.view.resolution;
+        this.view.resize(desiredScreenWidth, desiredScreenHeight, resolution);
+        this.emit('resize', this.view.screen.width, this.view.screen.height, this.view.resolution);
+        if (resolution !== undefined && resolution !== previousResolution) {
+            this.runners.resolutionChange.emit(resolution);
+        }
+    }
+    /**
+     * Clears the render target.
+     * @param options - The options to use when clearing the render target.
+     * @param options.target - The render target to clear.
+     * @param options.clearColor - The color to clear with.
+     * @param options.clear - The clear mode to use.
+     * @advanced
+     */
+    clear(options = {}) {
+        var _a;
+        // override!
+        const renderer = this;
+        options.target || (options.target = renderer.renderTarget.renderTarget);
+        options.clearColor || (options.clearColor = this.background.colorRgba);
+        (_a = options.clear) !== null && _a !== void 0 ? _a : (options.clear = CLEAR.ALL);
+        const { clear, clearColor, target } = options;
+        Color.shared.setValue(clearColor !== null && clearColor !== void 0 ? clearColor : this.background.colorRgba);
+        renderer.renderTarget.clear(target, clear, Color.shared.toArray());
+    }
+    /** The resolution / device pixel ratio of the renderer. */
+    get resolution() {
+        return this.view.resolution;
+    }
+    set resolution(value) {
+        this.view.resolution = value;
+        this.runners.resolutionChange.emit(value);
+    }
+    /**
+     * Same as view.width, actual number of pixels in the canvas by horizontal.
+     * @type {number}
+     * @readonly
+     * @default 800
+     */
+    get width() {
+        return this.view.texture.frame.width;
+    }
+    /**
+     * Same as view.height, actual number of pixels in the canvas by vertical.
+     * @default 600
+     */
+    get height() {
+        return this.view.texture.frame.height;
+    }
+    // NOTE: this was `view` in v7
+    /**
+     * The canvas element that everything is drawn to.
+     * @type {environment.ICanvas}
+     */
+    get canvas() {
+        return this.view.canvas;
+    }
+    /**
+     * the last object rendered by the renderer. Useful for other plugins like interaction managers
+     * @readonly
+     */
+    get lastObjectRendered() {
+        return this._lastObjectRendered;
+    }
+    /**
+     * Flag if we are rendering to the screen vs renderTexture
+     * @readonly
+     * @default true
+     */
+    get renderingToScreen() {
+        const renderer = this;
+        return renderer.renderTarget.renderingToScreen;
+    }
+    /**
+     * Measurements of the screen. (0, 0, screenWidth, screenHeight).
+     *
+     * Its safe to use as filterArea or hitArea for the whole stage.
+     */
+    get screen() {
+        return this.view.screen;
+    }
+    /**
+     * Create a bunch of runners based of a collection of ids
+     * @param runnerIds - the runner ids to add
+     */
+    _addRunners(...runnerIds) {
+        runnerIds.forEach((runnerId) => {
+            this.runners[runnerId] = new SystemRunner(runnerId);
+        });
+    }
+    _addSystems(systems) {
+        let i;
+        for (i in systems) {
+            const val = systems[i];
+            this._addSystem(val.value, val.name);
+        }
+    }
+    /**
+     * Add a new system to the renderer.
+     * @param ClassRef - Class reference
+     * @param name - Property name for system, if not specified
+     *        will use a static `name` property on the class itself. This
+     *        name will be assigned as s property on the Renderer so make
+     *        sure it doesn't collide with properties on Renderer.
+     * @returns Return instance of renderer
+     */
+    _addSystem(ClassRef, name) {
+        const system = new ClassRef(this);
+        if (this[name]) {
+            throw new Error(`Whoops! The name "${name}" is already in use`);
+        }
+        this[name] = system;
+        this._systemsHash[name] = system;
+        for (const i in this.runners) {
+            this.runners[i].add(system);
+        }
+        return this;
+    }
+    _addPipes(pipes, pipeAdaptors) {
+        const adaptors = pipeAdaptors.reduce((acc, adaptor) => {
+            acc[adaptor.name] = adaptor.value;
+            return acc;
+        }, {});
+        pipes.forEach((pipe) => {
+            const PipeClass = pipe.value;
+            const name = pipe.name;
+            const Adaptor = adaptors[name];
+            // sorry typescript..
+            this.renderPipes[name] = new PipeClass(this, Adaptor ? new Adaptor() : null);
+            this.runners.destroy.add(this.renderPipes[name]);
+        });
+    }
+    destroy(options = false) {
+        this.runners.destroy.items.reverse();
+        this.runners.destroy.emit(options);
+        // destroy all runners
+        Object.values(this.runners).forEach((runner) => {
+            runner.destroy();
+        });
+        if (options === true || (typeof options === 'object' && options.releaseGlobalResources)) {
+            GlobalResourceRegistry.release();
+        }
+        this._systemsHash = null;
+        // destroy all pipes
+        this.renderPipes = null;
+    }
+    /**
+     * Generate a texture from a container.
+     * @param options - options or container target to use when generating the texture
+     * @returns a texture
+     */
+    generateTexture(options) {
+        return this.textureGenerator.generateTexture(options);
+    }
+    /**
+     * Whether the renderer will round coordinates to whole pixels when rendering.
+     * Can be overridden on a per scene item basis.
+     */
+    get roundPixels() {
+        return !!this._roundPixels;
+    }
+    /**
+     * Overridable function by `pixi.js/unsafe-eval` to silence
+     * throwing an error if platform doesn't support unsafe-evals.
+     * @private
+     * @ignore
+     */
+    _unsafeEvalCheck() {
+        if (!unsafeEvalSupported()) {
+            throw new Error('Current environment does not allow unsafe-eval, '
+                + 'please use pixi.js/unsafe-eval module to enable support.');
+        }
+    }
+    /**
+     * Resets the rendering state of the renderer.
+     * This is useful when you want to use the WebGL context directly and need to ensure PixiJS's internal state
+     * stays synchronized. When modifying the WebGL context state externally, calling this method before the next Pixi
+     * render will reset all internal caches and ensure it executes correctly.
+     *
+     * This is particularly useful when combining PixiJS with other rendering engines like Three.js:
+     * ```js
+     * // Reset Three.js state
+     * threeRenderer.resetState();
+     *
+     * // Render a Three.js scene
+     * threeRenderer.render(threeScene, threeCamera);
+     *
+     * // Reset PixiJS state since Three.js modified the WebGL context
+     * pixiRenderer.resetState();
+     *
+     * // Now render Pixi content
+     * pixiRenderer.render(pixiScene);
+     * ```
+     * @advanced
+     */
+    resetState() {
+        this.runners.resetState.emit();
+    }
+}
+/** The default options for the renderer. */
+AbstractRenderer.defaultOptions = {
+    /**
+     * Default resolution / device pixel ratio of the renderer.
+     * @default 1
+     */
+    resolution: 1,
+    /**
+     * Should the `failIfMajorPerformanceCaveat` flag be enabled as a context option used in the `isWebGLSupported`
+     * function. If set to true, a WebGL renderer can fail to be created if the browser thinks there could be
+     * performance issues when using WebGL.
+     *
+     * In PixiJS v6 this has changed from true to false by default, to allow WebGL to work in as many
+     * scenarios as possible. However, some users may have a poor experience, for example, if a user has a gpu or
+     * driver version blacklisted by the
+     * browser.
+     *
+     * If your application requires high performance rendering, you may wish to set this to false.
+     * We recommend one of two options if you decide to set this flag to false:
+     *
+     * 1: Use the Canvas renderer as a fallback in case high performance WebGL is
+     *    not supported.
+     *
+     * 2: Call `isWebGLSupported` (which if found in the utils package) in your code before attempting to create a
+     *    PixiJS renderer, and show an error message to the user if the function returns false, explaining that their
+     *    device & browser combination does not support high performance WebGL.
+     *    This is a much better strategy than trying to create a PixiJS renderer and finding it then fails.
+     * @default false
+     */
+    failIfMajorPerformanceCaveat: false,
+    /**
+     * Should round pixels be forced when rendering?
+     * @default false
+     */
+    roundPixels: false
+};

package/dist/packages/pixijs/src/rendering/renderers/shared/system/SharedSystems.d.ts

@@ -0,0 +1,74 @@
+import { CustomRenderPipe } from '../../../../scene/container/CustomRenderPipe';
+import { RenderGroupPipe } from '../../../../scene/container/RenderGroupPipe';
+import { RenderGroupSystem } from '../../../../scene/container/RenderGroupSystem';
+import { SpritePipe } from '../../../../scene/sprite/SpritePipe';
+import { RendererInitHook } from '../../../../utils/global/globalHooks';
+import { BatcherPipe } from '../../../batcher/shared/BatcherPipe';
+import { AlphaMaskPipe } from '../../../mask/alpha/AlphaMaskPipe';
+import { ColorMaskPipe } from '../../../mask/color/ColorMaskPipe';
+import { StencilMaskPipe } from '../../../mask/stencil/StencilMaskPipe';
+import { BackgroundSystem } from '../background/BackgroundSystem';
+import { BlendModePipe } from '../blendModes/BlendModePipe';
+import { ExtractSystem } from '../extract/ExtractSystem';
+import { GenerateTextureSystem } from '../extract/GenerateTextureSystem';
+import { GlobalUniformSystem } from '../renderTarget/GlobalUniformSystem';
+import { SchedulerSystem } from '../SchedulerSystem';
+import { HelloSystem } from '../startup/HelloSystem';
+import { RenderableGCSystem } from '../texture/RenderableGCSystem';
+import { TextureGCSystem } from '../texture/TextureGCSystem';
+import { ViewSystem } from '../view/ViewSystem';
+import type { ExtractRendererOptions } from './utils/typeUtils';
+/**
+ * Shared systems for the renderer.
+ * @category rendering
+ * @internal
+ */
+export declare const SharedSystems: (typeof BackgroundSystem | typeof GenerateTextureSystem | typeof GlobalUniformSystem | typeof HelloSystem | typeof ViewSystem | typeof RenderGroupSystem | typeof TextureGCSystem | typeof ExtractSystem | typeof RendererInitHook | typeof RenderableGCSystem | typeof SchedulerSystem)[];
+/**
+ * Shared render pipes for the renderer.
+ * @category rendering
+ * @internal
+ */
+export declare const SharedRenderPipes: (typeof BlendModePipe | typeof BatcherPipe | typeof SpritePipe | typeof RenderGroupPipe | typeof AlphaMaskPipe | typeof StencilMaskPipe | typeof ColorMaskPipe | typeof CustomRenderPipe)[];
+/**
+ * Options for the shared systems of a renderer.
+ * @category rendering
+ * @advanced
+ */
+export interface SharedRendererOptions extends ExtractRendererOptions<typeof SharedSystems>, PixiMixins.RendererOptions {
+    /**
+     * Whether to stop PixiJS from dynamically importing default extensions for the renderer.
+     * It is false by default, and means PixiJS will load all the default extensions, based
+     * on the environment e.g browser/webworker.
+     * If you set this to true, then you will need to manually import the systems and extensions you need.
+     *
+     * e.g.
+     * ```js
+     * import 'accessibility';
+     * import 'app';
+     * import 'events';
+     * import 'spritesheet';
+     * import 'graphics';
+     * import 'mesh';
+     * import 'text';
+     * import 'text-bitmap';
+     * import 'text-html';
+     * import { autoDetectRenderer } from 'pixi.js';
+     *
+     * const renderer = await autoDetectRenderer({
+     *   width: 800,
+     *   height: 600,
+     *   skipExtensionImports: true,
+     * });
+     * ```
+     * @default false
+     */
+    skipExtensionImports?: boolean;
+    /**
+     * @default true
+     * @deprecated since 8.1.6
+     * @see `skipExtensionImports`
+     */
+    manageImports?: boolean;
+}
+//# sourceMappingURL=SharedSystems.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/system/SharedSystems.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SharedSystems.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/rendering/renderers/shared/system/SharedSystems.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,6CAA6C,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAClF,OAAO,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,sCAAsC,CAAC;AACxE,OAAO,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,uCAAuC,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,aAAa,4RAYzB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,6LAS7B,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,qBAAsB,SAAQ,sBAAsB,CAAC,OAAO,aAAa,CAAC,EAAE,UAAU,CAAC,eAAe;IAEnH;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B"}

package/dist/packages/pixijs/src/rendering/renderers/shared/system/SharedSystems.js

@@ -0,0 +1,52 @@
+import { CustomRenderPipe } from '../../../../scene/container/CustomRenderPipe';
+import { RenderGroupPipe } from '../../../../scene/container/RenderGroupPipe';
+import { RenderGroupSystem } from '../../../../scene/container/RenderGroupSystem';
+import { SpritePipe } from '../../../../scene/sprite/SpritePipe';
+import { RendererInitHook } from '../../../../utils/global/globalHooks';
+import { BatcherPipe } from '../../../batcher/shared/BatcherPipe';
+import { AlphaMaskPipe } from '../../../mask/alpha/AlphaMaskPipe';
+import { ColorMaskPipe } from '../../../mask/color/ColorMaskPipe';
+import { StencilMaskPipe } from '../../../mask/stencil/StencilMaskPipe';
+import { BackgroundSystem } from '../background/BackgroundSystem';
+import { BlendModePipe } from '../blendModes/BlendModePipe';
+import { ExtractSystem } from '../extract/ExtractSystem';
+import { GenerateTextureSystem } from '../extract/GenerateTextureSystem';
+import { GlobalUniformSystem } from '../renderTarget/GlobalUniformSystem';
+import { SchedulerSystem } from '../SchedulerSystem';
+import { HelloSystem } from '../startup/HelloSystem';
+import { RenderableGCSystem } from '../texture/RenderableGCSystem';
+import { TextureGCSystem } from '../texture/TextureGCSystem';
+import { ViewSystem } from '../view/ViewSystem';
+/**
+ * Shared systems for the renderer.
+ * @category rendering
+ * @internal
+ */
+export const SharedSystems = [
+    BackgroundSystem,
+    GlobalUniformSystem,
+    HelloSystem,
+    ViewSystem,
+    RenderGroupSystem,
+    TextureGCSystem,
+    GenerateTextureSystem,
+    ExtractSystem,
+    RendererInitHook,
+    RenderableGCSystem,
+    SchedulerSystem,
+];
+/**
+ * Shared render pipes for the renderer.
+ * @category rendering
+ * @internal
+ */
+export const SharedRenderPipes = [
+    BlendModePipe,
+    BatcherPipe,
+    SpritePipe,
+    RenderGroupPipe,
+    AlphaMaskPipe,
+    StencilMaskPipe,
+    ColorMaskPipe,
+    CustomRenderPipe
+];

package/dist/packages/pixijs/src/rendering/renderers/shared/system/System.d.ts

@@ -0,0 +1,23 @@
+import type { Renderer } from '../../types';
+import type { RendererDestroyOptions } from './AbstractRenderer';
+/**
+ * A system is a generic interface for a renderer system.
+ * It is used to define the methods that a system should implement.
+ * @category rendering
+ * @advanced
+ */
+export interface System<INIT_OPTIONS = null, DESTROY_OPTIONS = RendererDestroyOptions> {
+    init?: (options: INIT_OPTIONS) => void;
+    /** Generic destroy methods to be overridden by the subclass */
+    destroy?: (options?: DESTROY_OPTIONS) => void;
+}
+/**
+ * The constructor for a System.
+ * It is used to create instances of systems that can be added to a renderer.
+ * @category rendering
+ * @advanced
+ */
+export interface SystemConstructor {
+    new (renderer: Renderer): System;
+}
+//# sourceMappingURL=System.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/system/System.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/rendering/renderers/shared/system/System.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAEjE;;;;;GAKG;AACH,MAAM,WAAW,MAAM,CAAC,YAAY,GAAG,IAAI,EAAE,eAAe,GAAG,sBAAsB;IAEjF,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,CAAC;IACvC,+DAA+D;IAC/D,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,eAAe,KAAK,IAAI,CAAC;CACjD;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAE9B,KAAK,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAC;CACpC"}

package/dist/packages/pixijs/src/rendering/renderers/shared/system/System.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/pixijs/src/rendering/renderers/shared/system/SystemRunner.d.ts

@@ -0,0 +1,100 @@
+/**
+ * SystemRunner is used internally by the renderers as an efficient way for systems to
+ * be notified about what the renderer is up to during the rendering phase.
+ *
+ * ```ts
+ * import { SystemRunner } from 'pixi.js';
+ *
+ * const myObject = {
+ *     loaded: new SystemRunner('loaded')
+ * }
+ *
+ * const listener = {
+ *     loaded: function(){
+ *         // thin
+ *     }
+ * }
+ *
+ * myObject.loaded.add(listener);
+ *
+ * myObject.loaded.emit();
+ * ```
+ *
+ * Or for handling calling the same function on many items
+ * ```ts
+ * import { SystemRunner } from 'pixi.js';
+ *
+ * const myGame = {
+ *     update: new SystemRunner('update')
+ * }
+ *
+ * const gameObject = {
+ *     update: function(time){
+ *         // update my gamey state
+ *     }
+ * }
+ *
+ * myGame.update.add(gameObject);
+ *
+ * myGame.update.emit(time);
+ * ```
+ * @category rendering
+ * @internal
+ */
+export declare class SystemRunner {
+    items: any[];
+    private _name;
+    /**
+     * @param name - The function name that will be executed on the listeners added to this Runner.
+     */
+    constructor(name: string);
+    /**
+     * Dispatch/Broadcast Runner to all listeners added to the queue.
+     * @param {...any} params - (optional) parameters to pass to each listener
+     */
+    emit(a0?: unknown, a1?: unknown, a2?: unknown, a3?: unknown, a4?: unknown, a5?: unknown, a6?: unknown, a7?: unknown): this;
+    /**
+     * Add a listener to the Runner
+     *
+     * Runners do not need to have scope or functions passed to them.
+     * All that is required is to pass the listening object and ensure that it has contains a function that has the same name
+     * as the name provided to the Runner when it was created.
+     *
+     * Eg A listener passed to this Runner will require a 'complete' function.
+     *
+     * ```ts
+     * import { Runner } from 'pixi.js';
+     *
+     * const complete = new Runner('complete');
+     * ```
+     *
+     * The scope used will be the object itself.
+     * @param {any} item - The object that will be listening.
+     */
+    add(item: unknown): this;
+    /**
+     * Remove a single listener from the dispatch queue.
+     * @param {any} item - The listener that you would like to remove.
+     */
+    remove(item: unknown): this;
+    /**
+     * Check to see if the listener is already in the Runner
+     * @param {any} item - The listener that you would like to check.
+     */
+    contains(item: unknown): boolean;
+    /** Remove all listeners from the Runner */
+    removeAll(): this;
+    /** Remove all references, don't use after this. */
+    destroy(): void;
+    /**
+     * `true` if there are no this Runner contains no listeners
+     * @readonly
+     */
+    get empty(): boolean;
+    /**
+     * The name of the runner.
+     * @readonly
+     */
+    get name(): string;
+}
+//# sourceMappingURL=SystemRunner.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/system/SystemRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SystemRunner.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/rendering/renderers/shared/system/SystemRunner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,qBAAa,YAAY;IAEd,KAAK,EAAE,GAAG,EAAE,CAAC;IACpB,OAAO,CAAC,KAAK,CAAS;IAEtB;;OAEG;gBACS,IAAI,EAAE,MAAM;IAOxB;;;OAGG;IAEI,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAC9D,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,EAAE,OAAO,GAAG,IAAI;IAYjE;;;;;;;;;;;;;;;;;OAiBG;IACI,GAAG,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAW/B;;;OAGG;IACI,MAAM,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAYlC;;;OAGG;IACI,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO;IAKvC,2CAA2C;IACpC,SAAS,IAAI,IAAI;IAOxB,mDAAmD;IAC5C,OAAO,IAAI,IAAI;IAOtB;;;OAGG;IACH,IAAW,KAAK,IAAI,OAAO,CAG1B;IAED;;;OAGG;IACH,IAAW,IAAI,IAAI,MAAM,CAGxB;CACJ"}