@safe-engine/pixi 8.7.4 → 8.8.1

package/dist/packages/pixijs/src/rendering/renderers/shared/renderTarget/GlobalUniformSystem.js

@@ -0,0 +1,127 @@
+import { ExtensionType } from '../../../../extensions/Extensions';
+import { Matrix } from '../../../../maths/matrix/Matrix';
+import { Point } from '../../../../maths/point/Point';
+import { color32BitToUniform } from '../../../../scene/graphics/gpu/colorToUniform';
+import { BindGroup } from '../../gpu/shader/BindGroup';
+import { RendererType } from '../../types';
+import { UniformGroup } from '../shader/UniformGroup';
+/**
+ * System plugin to the renderer to manage global uniforms for the renderer.
+ * @category rendering
+ * @advanced
+ */
+export class GlobalUniformSystem {
+    constructor(renderer) {
+        this._stackIndex = 0;
+        this._globalUniformDataStack = [];
+        this._uniformsPool = [];
+        this._activeUniforms = [];
+        this._bindGroupPool = [];
+        this._activeBindGroups = [];
+        this._renderer = renderer;
+    }
+    reset() {
+        this._stackIndex = 0;
+        for (let i = 0; i < this._activeUniforms.length; i++) {
+            this._uniformsPool.push(this._activeUniforms[i]);
+        }
+        for (let i = 0; i < this._activeBindGroups.length; i++) {
+            this._bindGroupPool.push(this._activeBindGroups[i]);
+        }
+        this._activeUniforms.length = 0;
+        this._activeBindGroups.length = 0;
+    }
+    start(options) {
+        this.reset();
+        this.push(options);
+    }
+    bind({ size, projectionMatrix, worldTransformMatrix, worldColor, offset, }) {
+        const renderTarget = this._renderer.renderTarget.renderTarget;
+        const currentGlobalUniformData = this._stackIndex ? this._globalUniformDataStack[this._stackIndex - 1] : {
+            projectionData: renderTarget,
+            worldTransformMatrix: new Matrix(),
+            worldColor: 0xFFFFFFFF,
+            offset: new Point(),
+        };
+        const globalUniformData = {
+            projectionMatrix: projectionMatrix || this._renderer.renderTarget.projectionMatrix,
+            resolution: size || renderTarget.size,
+            worldTransformMatrix: worldTransformMatrix || currentGlobalUniformData.worldTransformMatrix,
+            worldColor: worldColor || currentGlobalUniformData.worldColor,
+            offset: offset || currentGlobalUniformData.offset,
+            bindGroup: null,
+        };
+        const uniformGroup = this._uniformsPool.pop() || this._createUniforms();
+        this._activeUniforms.push(uniformGroup);
+        const uniforms = uniformGroup.uniforms;
+        uniforms.uProjectionMatrix = globalUniformData.projectionMatrix;
+        uniforms.uResolution = globalUniformData.resolution;
+        uniforms.uWorldTransformMatrix.copyFrom(globalUniformData.worldTransformMatrix);
+        uniforms.uWorldTransformMatrix.tx -= globalUniformData.offset.x;
+        uniforms.uWorldTransformMatrix.ty -= globalUniformData.offset.y;
+        color32BitToUniform(globalUniformData.worldColor, uniforms.uWorldColorAlpha, 0);
+        uniformGroup.update();
+        let bindGroup;
+        if (this._renderer.renderPipes.uniformBatch) {
+            bindGroup = this._renderer.renderPipes.uniformBatch.getUniformBindGroup(uniformGroup, false);
+        }
+        else {
+            bindGroup = this._bindGroupPool.pop() || new BindGroup();
+            this._activeBindGroups.push(bindGroup);
+            bindGroup.setResource(uniformGroup, 0);
+        }
+        globalUniformData.bindGroup = bindGroup;
+        this._currentGlobalUniformData = globalUniformData;
+    }
+    push(options) {
+        this.bind(options);
+        this._globalUniformDataStack[this._stackIndex++] = this._currentGlobalUniformData;
+    }
+    pop() {
+        this._currentGlobalUniformData = this._globalUniformDataStack[--this._stackIndex - 1];
+        // for webGL we need to update the uniform group here
+        // as we are not using bind groups
+        if (this._renderer.type === RendererType.WEBGL) {
+            this._currentGlobalUniformData.bindGroup.resources[0].update();
+        }
+    }
+    get bindGroup() {
+        return this._currentGlobalUniformData.bindGroup;
+    }
+    get globalUniformData() {
+        return this._currentGlobalUniformData;
+    }
+    get uniformGroup() {
+        return this._currentGlobalUniformData.bindGroup.resources[0];
+    }
+    _createUniforms() {
+        const globalUniforms = new UniformGroup({
+            uProjectionMatrix: { value: new Matrix(), type: 'mat3x3<f32>' },
+            uWorldTransformMatrix: { value: new Matrix(), type: 'mat3x3<f32>' },
+            // TODO - someone smart - set this to be a unorm8x4 rather than a vec4<f32>
+            uWorldColorAlpha: { value: new Float32Array(4), type: 'vec4<f32>' },
+            uResolution: { value: [0, 0], type: 'vec2<f32>' },
+        }, {
+            isStatic: true,
+        });
+        return globalUniforms;
+    }
+    destroy() {
+        this._renderer = null;
+        this._globalUniformDataStack.length = 0;
+        this._uniformsPool.length = 0;
+        this._activeUniforms.length = 0;
+        this._bindGroupPool.length = 0;
+        this._activeBindGroups.length = 0;
+        this._currentGlobalUniformData = null;
+    }
+}
+/** @ignore */
+GlobalUniformSystem.extension = {
+    type: [
+        ExtensionType.WebGLSystem,
+        ExtensionType.WebGPUSystem,
+        ExtensionType.CanvasSystem,
+    ],
+    name: 'globalUniforms',
+};

package/dist/packages/pixijs/src/rendering/renderers/shared/renderTarget/RenderTarget.d.ts

@@ -0,0 +1,80 @@
+import { TextureSource } from '../texture/sources/TextureSource';
+import type { BindableTexture } from '../texture/Texture';
+/**
+ * Options for creating a render target.
+ * @category rendering
+ * @advanced
+ */
+export interface RenderTargetOptions {
+    /** the width of the RenderTarget */
+    width?: number;
+    /** the height of the RenderTarget */
+    height?: number;
+    /** the resolution of the RenderTarget */
+    resolution?: number;
+    /** an array of textures, or a number indicating how many color textures there should be */
+    colorTextures?: BindableTexture[] | number;
+    /** should this render target have a stencil buffer? */
+    stencil?: boolean;
+    /** should this render target have a depth buffer? */
+    depth?: boolean;
+    /** a depth stencil texture that the depth and stencil outputs will be written to */
+    depthStencilTexture?: BindableTexture | boolean;
+    /** should this render target be antialiased? */
+    antialias?: boolean;
+    /** is this a root element, true if this is gl context owners render target */
+    isRoot?: boolean;
+}
+/**
+ * A class that describes what the renderers are rendering to.
+ * This can be as simple as a Texture, or as complex as a multi-texture, multi-sampled render target.
+ * Support for stencil and depth buffers is also included.
+ *
+ * If you need something more complex than a Texture to render to, you should use this class.
+ * Under the hood, all textures you render to have a RenderTarget created on their behalf.
+ * @category rendering
+ * @advanced
+ */
+export declare class RenderTarget {
+    /** The default options for a render target */
+    static defaultOptions: RenderTargetOptions;
+    /** unique id for this render target */
+    readonly uid: number;
+    /**
+     * An array of textures that can be written to by the GPU - mostly this has one texture in Pixi, but you could
+     * write to multiple if required! (eg deferred lighting)
+     */
+    colorTextures: TextureSource[];
+    /** the stencil and depth buffer will right to this texture in WebGPU */
+    depthStencilTexture: TextureSource;
+    /** if true, will ensure a stencil buffer is added. For WebGPU, this will automatically create a depthStencilTexture */
+    stencil: boolean;
+    /** if true, will ensure a depth buffer is added. For WebGPU, this will automatically create a depthStencilTexture */
+    depth: boolean;
+    dirtyId: number;
+    isRoot: boolean;
+    private readonly _size;
+    /** if true, then when the render target is destroyed, it will destroy all the textures that were created for it. */
+    private readonly _managedColorTextures;
+    /**
+     * @param [descriptor] - Options for creating a render target.
+     */
+    constructor(descriptor?: RenderTargetOptions);
+    get size(): [number, number];
+    get width(): number;
+    get height(): number;
+    get pixelWidth(): number;
+    get pixelHeight(): number;
+    get resolution(): number;
+    get colorTexture(): TextureSource;
+    protected onSourceResize(source: TextureSource): void;
+    /**
+     * This will ensure a depthStencil texture is created for this render target.
+     * Most likely called by the mask system to make sure we have stencil buffer added.
+     * @internal
+     */
+    ensureDepthStencilTexture(): void;
+    resize(width: number, height: number, resolution?: number, skipColorTexture?: boolean): void;
+    destroy(): void;
+}
+//# sourceMappingURL=RenderTarget.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/renderTarget/RenderTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderTarget.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/rendering/renderers/shared/renderTarget/RenderTarget.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAGjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAEhC,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yCAAyC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2FAA2F;IAC3F,aAAa,CAAC,EAAE,eAAe,EAAE,GAAG,MAAM,CAAC;IAC3C,uDAAuD;IACvD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,qDAAqD;IACrD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,oFAAoF;IACpF,mBAAmB,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC;IAChD,gDAAgD;IAChD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,qBAAa,YAAY;IAErB,8CAA8C;IAC9C,OAAc,cAAc,EAAE,mBAAmB,CAiB/C;IAEF,uCAAuC;IACvC,SAAgB,GAAG,EAAE,MAAM,CAAuB;IAElD;;;OAGG;IACI,aAAa,EAAE,aAAa,EAAE,CAAM;IAC3C,wEAAwE;IACjE,mBAAmB,EAAE,aAAa,CAAC;IAC1C,uHAAuH;IAChH,OAAO,EAAE,OAAO,CAAC;IACxB,qHAAqH;IAC9G,KAAK,EAAE,OAAO,CAAC;IAEf,OAAO,SAAK;IACZ,MAAM,UAAS;IAEtB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAuB;IAC7C,oHAAoH;IACpH,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAkB;IAExD;;OAEG;gBACS,UAAU,GAAE,mBAAwB;IAoDhD,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAQ3B;IAED,IAAI,KAAK,IAAI,MAAM,CAGlB;IAED,IAAI,MAAM,IAAI,MAAM,CAGnB;IACD,IAAI,UAAU,IAAI,MAAM,CAGvB;IAED,IAAI,WAAW,IAAI,MAAM,CAGxB;IAED,IAAI,UAAU,IAAI,MAAM,CAGvB;IAED,IAAI,YAAY,IAAI,aAAa,CAGhC;IAED,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE,aAAa;IAK9C;;;;OAIG;IACI,yBAAyB;IAiBzB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,SAAkB,EAAE,gBAAgB,UAAQ;IAiB5F,OAAO;CAkBjB"}

package/dist/packages/pixijs/src/rendering/renderers/shared/renderTarget/RenderTarget.js

@@ -0,0 +1,155 @@
+// what we are building is a platform and a framework.
+// import { Matrix } from '../../shared/maths/Matrix';
+import { uid } from '../../../../utils/data/uid';
+import { TextureSource } from '../texture/sources/TextureSource';
+import { Texture } from '../texture/Texture';
+/**
+ * A class that describes what the renderers are rendering to.
+ * This can be as simple as a Texture, or as complex as a multi-texture, multi-sampled render target.
+ * Support for stencil and depth buffers is also included.
+ *
+ * If you need something more complex than a Texture to render to, you should use this class.
+ * Under the hood, all textures you render to have a RenderTarget created on their behalf.
+ * @category rendering
+ * @advanced
+ */
+export class RenderTarget {
+    /**
+     * @param [descriptor] - Options for creating a render target.
+     */
+    constructor(descriptor = {}) {
+        /** unique id for this render target */
+        this.uid = uid('renderTarget');
+        /**
+         * An array of textures that can be written to by the GPU - mostly this has one texture in Pixi, but you could
+         * write to multiple if required! (eg deferred lighting)
+         */
+        this.colorTextures = [];
+        this.dirtyId = 0;
+        this.isRoot = false;
+        this._size = new Float32Array(2);
+        /** if true, then when the render target is destroyed, it will destroy all the textures that were created for it. */
+        this._managedColorTextures = false;
+        descriptor = Object.assign(Object.assign({}, RenderTarget.defaultOptions), descriptor);
+        this.stencil = descriptor.stencil;
+        this.depth = descriptor.depth;
+        this.isRoot = descriptor.isRoot;
+        if (typeof descriptor.colorTextures === 'number') {
+            this._managedColorTextures = true;
+            for (let i = 0; i < descriptor.colorTextures; i++) {
+                this.colorTextures.push(new TextureSource({
+                    width: descriptor.width,
+                    height: descriptor.height,
+                    resolution: descriptor.resolution,
+                    antialias: descriptor.antialias,
+                }));
+            }
+        }
+        else {
+            this.colorTextures = [...descriptor.colorTextures.map((texture) => texture.source)];
+            const colorSource = this.colorTexture.source;
+            this.resize(colorSource.width, colorSource.height, colorSource._resolution);
+        }
+        // the first color texture drives the size of all others..
+        this.colorTexture.source.on('resize', this.onSourceResize, this);
+        // TODO should listen for texture destroyed?
+        if (descriptor.depthStencilTexture || this.stencil) {
+            // TODO add a test
+            if (descriptor.depthStencilTexture instanceof Texture
+                || descriptor.depthStencilTexture instanceof TextureSource) {
+                this.depthStencilTexture = descriptor.depthStencilTexture.source;
+            }
+            else {
+                this.ensureDepthStencilTexture();
+            }
+        }
+    }
+    get size() {
+        const _size = this._size;
+        _size[0] = this.pixelWidth;
+        _size[1] = this.pixelHeight;
+        return _size;
+    }
+    get width() {
+        return this.colorTexture.source.width;
+    }
+    get height() {
+        return this.colorTexture.source.height;
+    }
+    get pixelWidth() {
+        return this.colorTexture.source.pixelWidth;
+    }
+    get pixelHeight() {
+        return this.colorTexture.source.pixelHeight;
+    }
+    get resolution() {
+        return this.colorTexture.source._resolution;
+    }
+    get colorTexture() {
+        return this.colorTextures[0];
+    }
+    onSourceResize(source) {
+        this.resize(source.width, source.height, source._resolution, true);
+    }
+    /**
+     * This will ensure a depthStencil texture is created for this render target.
+     * Most likely called by the mask system to make sure we have stencil buffer added.
+     * @internal
+     */
+    ensureDepthStencilTexture() {
+        if (!this.depthStencilTexture) {
+            this.depthStencilTexture = new TextureSource({
+                width: this.width,
+                height: this.height,
+                resolution: this.resolution,
+                format: 'depth24plus-stencil8',
+                autoGenerateMipmaps: false,
+                antialias: false,
+                mipLevelCount: 1,
+                // sampleCount: handled by the render target system..
+            });
+        }
+    }
+    resize(width, height, resolution = this.resolution, skipColorTexture = false) {
+        this.dirtyId++;
+        this.colorTextures.forEach((colorTexture, i) => {
+            if (skipColorTexture && i === 0)
+                return;
+            colorTexture.source.resize(width, height, resolution);
+        });
+        if (this.depthStencilTexture) {
+            this.depthStencilTexture.source.resize(width, height, resolution);
+        }
+    }
+    destroy() {
+        this.colorTexture.source.off('resize', this.onSourceResize, this);
+        if (this._managedColorTextures) {
+            this.colorTextures.forEach((texture) => {
+                texture.destroy();
+            });
+        }
+        if (this.depthStencilTexture) {
+            this.depthStencilTexture.destroy();
+            delete this.depthStencilTexture;
+        }
+    }
+}
+/** The default options for a render target */
+RenderTarget.defaultOptions = {
+    /** the width of the RenderTarget */
+    width: 0,
+    /** the height of the RenderTarget */
+    height: 0,
+    /** the resolution of the RenderTarget */
+    resolution: 1,
+    /** an array of textures, or a number indicating how many color textures there should be */
+    colorTextures: 1,
+    /** should this render target have a stencil buffer? */
+    stencil: false,
+    /** should this render target have a depth buffer? */
+    depth: false,
+    /** should this render target be antialiased? */
+    antialias: false, // save on perf by default!
+    /** is this a root element, true if this is gl context owners render target */
+    isRoot: false
+};

package/dist/packages/pixijs/src/rendering/renderers/shared/renderTarget/RenderTargetSystem.d.ts

@@ -0,0 +1,273 @@
+import { Matrix } from '../../../../maths/matrix/Matrix';
+import { Rectangle } from '../../../../maths/shapes/Rectangle';
+import { CLEAR } from '../../gl/const';
+import { SystemRunner } from '../system/SystemRunner';
+import { TextureSource } from '../texture/sources/TextureSource';
+import { Texture } from '../texture/Texture';
+import { RenderTarget } from './RenderTarget';
+import type { RgbaArray } from '../../../../color/Color';
+import type { ICanvas } from '../../../../environment/canvas/ICanvas';
+import type { CLEAR_OR_BOOL } from '../../gl/const';
+import type { GlRenderTarget } from '../../gl/GlRenderTarget';
+import type { GpuRenderTarget } from '../../gpu/renderTarget/GpuRenderTarget';
+import type { Renderer } from '../../types';
+import type { System } from '../system/System';
+import type { BindableTexture } from '../texture/Texture';
+/**
+ * A render surface is a texture, canvas, or render target
+ * @category rendering
+ * @see environment.ICanvas
+ * @see Texture
+ * @see RenderTarget
+ * @advanced
+ */
+export type RenderSurface = ICanvas | BindableTexture | RenderTarget;
+/**
+ * An adaptor interface for RenderTargetSystem to support WebGL and WebGPU.
+ * This is used internally by the renderer, and is not intended to be used directly.
+ * @ignore
+ */
+export interface RenderTargetAdaptor<RENDER_TARGET extends GlRenderTarget | GpuRenderTarget> {
+    init(
+    /** the renderer */
+    renderer: Renderer, 
+    /** the render target system */
+    renderTargetSystem: RenderTargetSystem<RENDER_TARGET>): void;
+    /** A function copies the contents of a render surface to a texture */
+    copyToTexture(
+    /** the render surface to copy from  */
+    sourceRenderSurfaceTexture: RenderTarget, 
+    /** the texture to copy to */
+    destinationTexture: Texture, 
+    /** the origin of the copy */
+    originSrc: {
+        x: number;
+        y: number;
+    }, 
+    /** the size of the copy */
+    size: {
+        width: number;
+        height: number;
+    }, 
+    /** the destination origin (top left to paste from!) */
+    originDest?: {
+        x: number;
+        y: number;
+    }): Texture;
+    /** starts a render pass on the render target */
+    startRenderPass(
+    /** the render target to start the render pass on */
+    renderTarget: RenderTarget, clear: CLEAR_OR_BOOL, 
+    /** the color to clear to */
+    clearColor?: RgbaArray, 
+    /** the viewport to use */
+    viewport?: Rectangle): void;
+    /** clears the current render target to the specified color */
+    clear(
+    /** the render target to clear */
+    renderTarget: RenderTarget, 
+    /** the clear mode to use. Can be true or a CLEAR number 'COLOR | DEPTH | STENCIL' 0b111 */
+    clear: CLEAR_OR_BOOL, 
+    /** the color to clear to   */
+    clearColor?: RgbaArray, 
+    /** the viewport to use */
+    viewport?: Rectangle): void;
+    /** finishes the current render pass */
+    finishRenderPass(renderTarget: RenderTarget): void;
+    /** called after the render pass is finished */
+    postrender?(renderTarget: RenderTarget): void;
+    /** called before the render main pass is started */
+    prerender?(renderTarget: RenderTarget): void;
+    /**
+     * initializes a gpu render target. Both renderers use this function to initialize a gpu render target
+     * Its different type of object depending on the renderer.
+     */
+    initGpuRenderTarget(
+    /** the render target to initialize */
+    renderTarget: RenderTarget): RENDER_TARGET;
+    /** called when a render target is resized */
+    resizeGpuRenderTarget(
+    /** the render target to resize */
+    renderTarget: RenderTarget): void;
+    /** destroys the gpu render target */
+    destroyGpuRenderTarget(
+    /** the render target to destroy */
+    gpuRenderTarget: RENDER_TARGET): void;
+}
+/**
+ * A system that manages render targets. A render target is essentially a place where the shaders can color in the pixels.
+ * The render target system is responsible for binding the render target to the renderer, and managing the viewport.
+ * Render targets can be pushed and popped.
+ *
+ * To make it easier, you can also bind textures and canvases too. This will automatically create a render target for you.
+ * The render target itself is a lot more powerful than just a texture or canvas,
+ * as it can have multiple textures attached to it.
+ * It will also give ou fine grain control over the stencil buffer / depth texture.
+ * @example
+ *
+ * ```js
+ *
+ * // create a render target
+ * const renderTarget = new RenderTarget({
+ *   colorTextures: [new TextureSource({ width: 100, height: 100 })],
+ * });
+ *
+ * // bind the render target
+ * renderer.renderTarget.bind(renderTarget);
+ *
+ * // draw something!
+ * ```
+ * @category rendering
+ * @advanced
+ */
+export declare class RenderTargetSystem<RENDER_TARGET extends GlRenderTarget | GpuRenderTarget> implements System {
+    /** When rendering of a scene begins, this is where the root render surface is stored */
+    rootRenderTarget: RenderTarget;
+    /** This is the root viewport for the render pass*/
+    rootViewPort: Rectangle;
+    /** A boolean that lets the dev know if the current render pass is rendering to the screen. Used by some plugins */
+    renderingToScreen: boolean;
+    /** the current active render target */
+    renderTarget: RenderTarget;
+    /** the current active render surface that the render target is created from */
+    renderSurface: RenderSurface;
+    /** the current viewport that the gpu is using */
+    readonly viewport: Rectangle;
+    /**
+     * a runner that lets systems know if the active render target has changed.
+     * Eg the Stencil System needs to know so it can manage the stencil buffer
+     */
+    readonly onRenderTargetChange: SystemRunner;
+    /** the projection matrix that is used by the shaders based on the active render target and the viewport */
+    readonly projectionMatrix: Matrix;
+    /** the default clear color for render targets */
+    readonly defaultClearColor: RgbaArray;
+    /** a reference to the adaptor that interfaces with WebGL / WebGP */
+    readonly adaptor: RenderTargetAdaptor<RENDER_TARGET>;
+    /**
+     * a hash that stores the render target for a given render surface. When you pass in a texture source,
+     * a render target is created for it. This map stores and makes it easy to retrieve the render target
+     */
+    private readonly _renderSurfaceToRenderTargetHash;
+    /** A hash that stores a gpu render target for a given render target. */
+    private _gpuRenderTargetHash;
+    /**
+     * A stack that stores the render target and frame that is currently being rendered to.
+     * When push is called, the current render target is stored in this stack.
+     * When pop is called, the previous render target is restored.
+     */
+    private readonly _renderTargetStack;
+    /** A reference to the renderer */
+    private readonly _renderer;
+    constructor(renderer: Renderer);
+    /** called when dev wants to finish a render pass */
+    finishRenderPass(): void;
+    /**
+     * called when the renderer starts to render a scene.
+     * @param options
+     * @param options.target - the render target to render to
+     * @param options.clear - the clear mode to use. Can be true or a CLEAR number 'COLOR | DEPTH | STENCIL' 0b111
+     * @param options.clearColor - the color to clear to
+     * @param options.frame - the frame to render to
+     */
+    renderStart({ target, clear, clearColor, frame }: {
+        target: RenderSurface;
+        clear: CLEAR_OR_BOOL;
+        clearColor: RgbaArray;
+        frame?: Rectangle;
+    }): void;
+    postrender(): void;
+    /**
+     * Binding a render surface! This is the main function of the render target system.
+     * It will take the RenderSurface (which can be a texture, canvas, or render target) and bind it to the renderer.
+     * Once bound all draw calls will be rendered to the render surface.
+     *
+     * If a frame is not provide and the render surface is a texture, the frame of the texture will be used.
+     * @param renderSurface - the render surface to bind
+     * @param clear - the clear mode to use. Can be true or a CLEAR number 'COLOR | DEPTH | STENCIL' 0b111
+     * @param clearColor - the color to clear to
+     * @param frame - the frame to render to
+     * @returns the render target that was bound
+     */
+    bind(renderSurface: RenderSurface, clear?: CLEAR_OR_BOOL, clearColor?: RgbaArray, frame?: Rectangle): RenderTarget;
+    clear(target?: RenderSurface, clear?: CLEAR_OR_BOOL, clearColor?: RgbaArray): void;
+    protected contextChange(): void;
+    /**
+     * Push a render surface to the renderer. This will bind the render surface to the renderer,
+     * @param renderSurface - the render surface to push
+     * @param clear - the clear mode to use. Can be true or a CLEAR number 'COLOR | DEPTH | STENCIL' 0b111
+     * @param clearColor - the color to clear to
+     * @param frame - the frame to use when rendering to the render surface
+     */
+    push(renderSurface: RenderSurface, clear?: CLEAR | boolean, clearColor?: RgbaArray, frame?: Rectangle): RenderTarget;
+    /** Pops the current render target from the renderer and restores the previous render target. */
+    pop(): void;
+    /**
+     * Gets the render target from the provide render surface. Eg if its a texture,
+     * it will return the render target for the texture.
+     * If its a render target, it will return the same render target.
+     * @param renderSurface - the render surface to get the render target for
+     * @returns the render target for the render surface
+     */
+    getRenderTarget(renderSurface: RenderSurface): RenderTarget;
+    /**
+     * Copies a render surface to another texture.
+     *
+     * NOTE:
+     * for sourceRenderSurfaceTexture, The render target must be something that is written too by the renderer
+     *
+     * The following is not valid:
+     * @example
+     * const canvas = document.createElement('canvas')
+     * canvas.width = 200;
+     * canvas.height = 200;
+     *
+     * const ctx = canvas2.getContext('2d')!
+     * ctx.fillStyle = 'red'
+     * ctx.fillRect(0, 0, 200, 200);
+     *
+     * const texture = RenderTexture.create({
+     *   width: 200,
+     *   height: 200,
+     * })
+     * const renderTarget = renderer.renderTarget.getRenderTarget(canvas2);
+     *
+     * renderer.renderTarget.copyToTexture(renderTarget,texture, {x:0,y:0},{width:200,height:200},{x:0,y:0});
+     *
+     * The best way to copy a canvas is to create a texture from it. Then render with that.
+     *
+     * Parsing in a RenderTarget canvas context (with a 2d context)
+     * @param sourceRenderSurfaceTexture - the render surface to copy from
+     * @param destinationTexture - the texture to copy to
+     * @param originSrc - the origin of the copy
+     * @param originSrc.x - the x origin of the copy
+     * @param originSrc.y - the y origin of the copy
+     * @param size - the size of the copy
+     * @param size.width - the width of the copy
+     * @param size.height - the height of the copy
+     * @param originDest - the destination origin (top left to paste from!)
+     * @param originDest.x - the x origin of the paste
+     * @param originDest.y - the y origin of the paste
+     */
+    copyToTexture(sourceRenderSurfaceTexture: RenderTarget, destinationTexture: Texture, originSrc: {
+        x: number;
+        y: number;
+    }, size: {
+        width: number;
+        height: number;
+    }, originDest: {
+        x: number;
+        y: number;
+    }): Texture<TextureSource<any>>;
+    /**
+     * ensures that we have a depth stencil buffer available to render to
+     * This is used by the mask system to make sure we have a stencil buffer.
+     */
+    ensureDepthStencil(): void;
+    /** nukes the render target system */
+    destroy(): void;
+    private _initRenderTarget;
+    getGpuRenderTarget(renderTarget: RenderTarget): RENDER_TARGET;
+    resetState(): void;
+}
+//# sourceMappingURL=RenderTargetSystem.d.ts.map

package/dist/packages/pixijs/src/rendering/renderers/shared/renderTarget/RenderTargetSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RenderTargetSystem.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/pixijs/src/rendering/renderers/shared/renderTarget/RenderTargetSystem.ts"],"names":[],"mappings":"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"}