sdfsdfs

node_modules/pixi.js/lib/rendering/renderers/gl/renderTarget/GlRenderTargetAdaptor.d.ts

@@ -0,0 +1,42 @@
+import { Rectangle } from '../../../../maths/shapes/Rectangle';
+import { GlRenderTarget } from '../GlRenderTarget';
+import type { RgbaArray } from '../../../../color/Color';
+import type { RenderTarget } from '../../shared/renderTarget/RenderTarget';
+import type { RenderTargetAdaptor, RenderTargetSystem } from '../../shared/renderTarget/RenderTargetSystem';
+import type { Texture } from '../../shared/texture/Texture';
+import type { CLEAR_OR_BOOL } from '../const';
+import type { WebGLRenderer } from '../WebGLRenderer';
+/**
+ * The WebGL adaptor for the render target system. Allows the Render Target System to be used with the WebGL renderer
+ * @memberof rendering
+ * @ignore
+ */
+export declare class GlRenderTargetAdaptor implements RenderTargetAdaptor<GlRenderTarget> {
+    private _renderTargetSystem;
+    private _renderer;
+    private _clearColorCache;
+    private _viewPortCache;
+    init(renderer: WebGLRenderer, renderTargetSystem: RenderTargetSystem<GlRenderTarget>): void;
+    contextChange(): void;
+    copyToTexture(sourceRenderSurfaceTexture: RenderTarget, destinationTexture: Texture, originSrc: {
+        x: number;
+        y: number;
+    }, size: {
+        width: number;
+        height: number;
+    }, originDest: {
+        x: number;
+        y: number;
+    }): Texture<import("../../..").TextureSource<any>>;
+    startRenderPass(renderTarget: RenderTarget, clear?: CLEAR_OR_BOOL, clearColor?: RgbaArray, viewport?: Rectangle): void;
+    finishRenderPass(renderTarget?: RenderTarget): void;
+    initGpuRenderTarget(renderTarget: RenderTarget): GlRenderTarget;
+    destroyGpuRenderTarget(gpuRenderTarget: GlRenderTarget): void;
+    clear(_renderTarget: RenderTarget, clear: CLEAR_OR_BOOL, clearColor?: RgbaArray): void;
+    resizeGpuRenderTarget(renderTarget: RenderTarget): void;
+    private _initColor;
+    private _resizeColor;
+    private _initStencil;
+    private _resizeStencil;
+    postrender(renderTarget: RenderTarget): void;
+}

node_modules/pixi.js/lib/rendering/renderers/gl/renderTarget/GlRenderTargetAdaptor.js

@@ -0,0 +1,301 @@
+'use strict';
+
+var Rectangle = require('../../../../maths/shapes/Rectangle.js');
+var warn = require('../../../../utils/logging/warn.js');
+var CanvasSource = require('../../shared/texture/sources/CanvasSource.js');
+var _const = require('../const.js');
+var GlRenderTarget = require('../GlRenderTarget.js');
+
+"use strict";
+class GlRenderTargetAdaptor {
+  constructor() {
+    this._clearColorCache = [0, 0, 0, 0];
+    this._viewPortCache = new Rectangle.Rectangle();
+  }
+  init(renderer, renderTargetSystem) {
+    this._renderer = renderer;
+    this._renderTargetSystem = renderTargetSystem;
+    renderer.runners.contextChange.add(this);
+  }
+  contextChange() {
+    this._clearColorCache = [0, 0, 0, 0];
+    this._viewPortCache = new Rectangle.Rectangle();
+  }
+  copyToTexture(sourceRenderSurfaceTexture, destinationTexture, originSrc, size, originDest) {
+    const renderTargetSystem = this._renderTargetSystem;
+    const renderer = this._renderer;
+    const glRenderTarget = renderTargetSystem.getGpuRenderTarget(sourceRenderSurfaceTexture);
+    const gl = renderer.gl;
+    this.finishRenderPass(sourceRenderSurfaceTexture);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, glRenderTarget.resolveTargetFramebuffer);
+    renderer.texture.bind(destinationTexture, 0);
+    gl.copyTexSubImage2D(
+      gl.TEXTURE_2D,
+      0,
+      originDest.x,
+      originDest.y,
+      originSrc.x,
+      originSrc.y,
+      size.width,
+      size.height
+    );
+    return destinationTexture;
+  }
+  startRenderPass(renderTarget, clear = true, clearColor, viewport) {
+    const renderTargetSystem = this._renderTargetSystem;
+    const source = renderTarget.colorTexture;
+    const gpuRenderTarget = renderTargetSystem.getGpuRenderTarget(renderTarget);
+    let viewPortY = viewport.y;
+    if (renderTarget.isRoot) {
+      viewPortY = source.pixelHeight - viewport.height;
+    }
+    renderTarget.colorTextures.forEach((texture) => {
+      this._renderer.texture.unbind(texture);
+    });
+    const gl = this._renderer.gl;
+    gl.bindFramebuffer(gl.FRAMEBUFFER, gpuRenderTarget.framebuffer);
+    const viewPortCache = this._viewPortCache;
+    if (viewPortCache.x !== viewport.x || viewPortCache.y !== viewPortY || viewPortCache.width !== viewport.width || viewPortCache.height !== viewport.height) {
+      viewPortCache.x = viewport.x;
+      viewPortCache.y = viewPortY;
+      viewPortCache.width = viewport.width;
+      viewPortCache.height = viewport.height;
+      gl.viewport(
+        viewport.x,
+        viewPortY,
+        viewport.width,
+        viewport.height
+      );
+    }
+    if (!gpuRenderTarget.depthStencilRenderBuffer && (renderTarget.stencil || renderTarget.depth)) {
+      this._initStencil(gpuRenderTarget);
+    }
+    this.clear(renderTarget, clear, clearColor);
+  }
+  finishRenderPass(renderTarget) {
+    const renderTargetSystem = this._renderTargetSystem;
+    const glRenderTarget = renderTargetSystem.getGpuRenderTarget(renderTarget);
+    if (!glRenderTarget.msaa)
+      return;
+    const gl = this._renderer.gl;
+    gl.bindFramebuffer(gl.FRAMEBUFFER, glRenderTarget.resolveTargetFramebuffer);
+    gl.bindFramebuffer(gl.READ_FRAMEBUFFER, glRenderTarget.framebuffer);
+    gl.blitFramebuffer(
+      0,
+      0,
+      glRenderTarget.width,
+      glRenderTarget.height,
+      0,
+      0,
+      glRenderTarget.width,
+      glRenderTarget.height,
+      gl.COLOR_BUFFER_BIT,
+      gl.NEAREST
+    );
+    gl.bindFramebuffer(gl.FRAMEBUFFER, glRenderTarget.framebuffer);
+  }
+  initGpuRenderTarget(renderTarget) {
+    const renderer = this._renderer;
+    const gl = renderer.gl;
+    const glRenderTarget = new GlRenderTarget.GlRenderTarget();
+    const colorTexture = renderTarget.colorTexture;
+    if (CanvasSource.CanvasSource.test(colorTexture.resource)) {
+      this._renderer.context.ensureCanvasSize(renderTarget.colorTexture.resource);
+      glRenderTarget.framebuffer = null;
+      return glRenderTarget;
+    }
+    this._initColor(renderTarget, glRenderTarget);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    return glRenderTarget;
+  }
+  destroyGpuRenderTarget(gpuRenderTarget) {
+    const gl = this._renderer.gl;
+    if (gpuRenderTarget.framebuffer) {
+      gl.deleteFramebuffer(gpuRenderTarget.framebuffer);
+      gpuRenderTarget.framebuffer = null;
+    }
+    if (gpuRenderTarget.resolveTargetFramebuffer) {
+      gl.deleteFramebuffer(gpuRenderTarget.resolveTargetFramebuffer);
+      gpuRenderTarget.resolveTargetFramebuffer = null;
+    }
+    if (gpuRenderTarget.depthStencilRenderBuffer) {
+      gl.deleteRenderbuffer(gpuRenderTarget.depthStencilRenderBuffer);
+      gpuRenderTarget.depthStencilRenderBuffer = null;
+    }
+    gpuRenderTarget.msaaRenderBuffer.forEach((renderBuffer) => {
+      gl.deleteRenderbuffer(renderBuffer);
+    });
+    gpuRenderTarget.msaaRenderBuffer = null;
+  }
+  clear(_renderTarget, clear, clearColor) {
+    if (!clear)
+      return;
+    const renderTargetSystem = this._renderTargetSystem;
+    if (typeof clear === "boolean") {
+      clear = clear ? _const.CLEAR.ALL : _const.CLEAR.NONE;
+    }
+    const gl = this._renderer.gl;
+    if (clear & _const.CLEAR.COLOR) {
+      clearColor ?? (clearColor = renderTargetSystem.defaultClearColor);
+      const clearColorCache = this._clearColorCache;
+      const clearColorArray = clearColor;
+      if (clearColorCache[0] !== clearColorArray[0] || clearColorCache[1] !== clearColorArray[1] || clearColorCache[2] !== clearColorArray[2] || clearColorCache[3] !== clearColorArray[3]) {
+        clearColorCache[0] = clearColorArray[0];
+        clearColorCache[1] = clearColorArray[1];
+        clearColorCache[2] = clearColorArray[2];
+        clearColorCache[3] = clearColorArray[3];
+        gl.clearColor(clearColorArray[0], clearColorArray[1], clearColorArray[2], clearColorArray[3]);
+      }
+    }
+    gl.clear(clear);
+  }
+  resizeGpuRenderTarget(renderTarget) {
+    if (renderTarget.isRoot)
+      return;
+    const renderTargetSystem = this._renderTargetSystem;
+    const glRenderTarget = renderTargetSystem.getGpuRenderTarget(renderTarget);
+    this._resizeColor(renderTarget, glRenderTarget);
+    if (renderTarget.stencil || renderTarget.depth) {
+      this._resizeStencil(glRenderTarget);
+    }
+  }
+  _initColor(renderTarget, glRenderTarget) {
+    const renderer = this._renderer;
+    const gl = renderer.gl;
+    const resolveTargetFramebuffer = gl.createFramebuffer();
+    glRenderTarget.resolveTargetFramebuffer = resolveTargetFramebuffer;
+    gl.bindFramebuffer(gl.FRAMEBUFFER, resolveTargetFramebuffer);
+    glRenderTarget.width = renderTarget.colorTexture.source.pixelWidth;
+    glRenderTarget.height = renderTarget.colorTexture.source.pixelHeight;
+    renderTarget.colorTextures.forEach((colorTexture, i) => {
+      const source = colorTexture.source;
+      if (source.antialias) {
+        if (renderer.context.supports.msaa) {
+          glRenderTarget.msaa = true;
+        } else {
+          warn.warn("[RenderTexture] Antialiasing on textures is not supported in WebGL1");
+        }
+      }
+      renderer.texture.bindSource(source, 0);
+      const glSource = renderer.texture.getGlSource(source);
+      const glTexture = glSource.texture;
+      gl.framebufferTexture2D(
+        gl.FRAMEBUFFER,
+        gl.COLOR_ATTACHMENT0 + i,
+        3553,
+        // texture.target,
+        glTexture,
+        0
+      );
+    });
+    if (glRenderTarget.msaa) {
+      const viewFramebuffer = gl.createFramebuffer();
+      glRenderTarget.framebuffer = viewFramebuffer;
+      gl.bindFramebuffer(gl.FRAMEBUFFER, viewFramebuffer);
+      renderTarget.colorTextures.forEach((_, i) => {
+        const msaaRenderBuffer = gl.createRenderbuffer();
+        glRenderTarget.msaaRenderBuffer[i] = msaaRenderBuffer;
+      });
+    } else {
+      glRenderTarget.framebuffer = resolveTargetFramebuffer;
+    }
+    this._resizeColor(renderTarget, glRenderTarget);
+  }
+  _resizeColor(renderTarget, glRenderTarget) {
+    const source = renderTarget.colorTexture.source;
+    glRenderTarget.width = source.pixelWidth;
+    glRenderTarget.height = source.pixelHeight;
+    renderTarget.colorTextures.forEach((colorTexture, i) => {
+      if (i === 0)
+        return;
+      colorTexture.source.resize(source.width, source.height, source._resolution);
+    });
+    if (glRenderTarget.msaa) {
+      const renderer = this._renderer;
+      const gl = renderer.gl;
+      const viewFramebuffer = glRenderTarget.framebuffer;
+      gl.bindFramebuffer(gl.FRAMEBUFFER, viewFramebuffer);
+      renderTarget.colorTextures.forEach((colorTexture, i) => {
+        const source2 = colorTexture.source;
+        renderer.texture.bindSource(source2, 0);
+        const glSource = renderer.texture.getGlSource(source2);
+        const glInternalFormat = glSource.internalFormat;
+        const msaaRenderBuffer = glRenderTarget.msaaRenderBuffer[i];
+        gl.bindRenderbuffer(
+          gl.RENDERBUFFER,
+          msaaRenderBuffer
+        );
+        gl.renderbufferStorageMultisample(
+          gl.RENDERBUFFER,
+          4,
+          glInternalFormat,
+          source2.pixelWidth,
+          source2.pixelHeight
+        );
+        gl.framebufferRenderbuffer(
+          gl.FRAMEBUFFER,
+          gl.COLOR_ATTACHMENT0 + i,
+          gl.RENDERBUFFER,
+          msaaRenderBuffer
+        );
+      });
+    }
+  }
+  _initStencil(glRenderTarget) {
+    if (glRenderTarget.framebuffer === null)
+      return;
+    const gl = this._renderer.gl;
+    const depthStencilRenderBuffer = gl.createRenderbuffer();
+    glRenderTarget.depthStencilRenderBuffer = depthStencilRenderBuffer;
+    gl.bindRenderbuffer(
+      gl.RENDERBUFFER,
+      depthStencilRenderBuffer
+    );
+    gl.framebufferRenderbuffer(
+      gl.FRAMEBUFFER,
+      gl.DEPTH_STENCIL_ATTACHMENT,
+      gl.RENDERBUFFER,
+      depthStencilRenderBuffer
+    );
+    this._resizeStencil(glRenderTarget);
+  }
+  _resizeStencil(glRenderTarget) {
+    const gl = this._renderer.gl;
+    gl.bindRenderbuffer(
+      gl.RENDERBUFFER,
+      glRenderTarget.depthStencilRenderBuffer
+    );
+    if (glRenderTarget.msaa) {
+      gl.renderbufferStorageMultisample(
+        gl.RENDERBUFFER,
+        4,
+        gl.DEPTH24_STENCIL8,
+        glRenderTarget.width,
+        glRenderTarget.height
+      );
+    } else {
+      gl.renderbufferStorage(
+        gl.RENDERBUFFER,
+        this._renderer.context.webGLVersion === 2 ? gl.DEPTH24_STENCIL8 : gl.DEPTH_STENCIL,
+        glRenderTarget.width,
+        glRenderTarget.height
+      );
+    }
+  }
+  postrender(renderTarget) {
+    if (!this._renderer.context.multiView)
+      return;
+    if (CanvasSource.CanvasSource.test(renderTarget.colorTexture.resource)) {
+      const contextCanvas = this._renderer.context.canvas;
+      const canvasSource = renderTarget.colorTexture;
+      canvasSource.context2D.drawImage(
+        contextCanvas,
+        0,
+        canvasSource.pixelHeight - contextCanvas.height
+      );
+    }
+  }
+}
+
+exports.GlRenderTargetAdaptor = GlRenderTargetAdaptor;
+//# sourceMappingURL=GlRenderTargetAdaptor.js.map

node_modules/pixi.js/lib/rendering/renderers/gl/renderTarget/GlRenderTargetAdaptor.mjs

@@ -0,0 +1,299 @@
+import { Rectangle } from '../../../../maths/shapes/Rectangle.mjs';
+import { warn } from '../../../../utils/logging/warn.mjs';
+import { CanvasSource } from '../../shared/texture/sources/CanvasSource.mjs';
+import { CLEAR } from '../const.mjs';
+import { GlRenderTarget } from '../GlRenderTarget.mjs';
+
+"use strict";
+class GlRenderTargetAdaptor {
+  constructor() {
+    this._clearColorCache = [0, 0, 0, 0];
+    this._viewPortCache = new Rectangle();
+  }
+  init(renderer, renderTargetSystem) {
+    this._renderer = renderer;
+    this._renderTargetSystem = renderTargetSystem;
+    renderer.runners.contextChange.add(this);
+  }
+  contextChange() {
+    this._clearColorCache = [0, 0, 0, 0];
+    this._viewPortCache = new Rectangle();
+  }
+  copyToTexture(sourceRenderSurfaceTexture, destinationTexture, originSrc, size, originDest) {
+    const renderTargetSystem = this._renderTargetSystem;
+    const renderer = this._renderer;
+    const glRenderTarget = renderTargetSystem.getGpuRenderTarget(sourceRenderSurfaceTexture);
+    const gl = renderer.gl;
+    this.finishRenderPass(sourceRenderSurfaceTexture);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, glRenderTarget.resolveTargetFramebuffer);
+    renderer.texture.bind(destinationTexture, 0);
+    gl.copyTexSubImage2D(
+      gl.TEXTURE_2D,
+      0,
+      originDest.x,
+      originDest.y,
+      originSrc.x,
+      originSrc.y,
+      size.width,
+      size.height
+    );
+    return destinationTexture;
+  }
+  startRenderPass(renderTarget, clear = true, clearColor, viewport) {
+    const renderTargetSystem = this._renderTargetSystem;
+    const source = renderTarget.colorTexture;
+    const gpuRenderTarget = renderTargetSystem.getGpuRenderTarget(renderTarget);
+    let viewPortY = viewport.y;
+    if (renderTarget.isRoot) {
+      viewPortY = source.pixelHeight - viewport.height;
+    }
+    renderTarget.colorTextures.forEach((texture) => {
+      this._renderer.texture.unbind(texture);
+    });
+    const gl = this._renderer.gl;
+    gl.bindFramebuffer(gl.FRAMEBUFFER, gpuRenderTarget.framebuffer);
+    const viewPortCache = this._viewPortCache;
+    if (viewPortCache.x !== viewport.x || viewPortCache.y !== viewPortY || viewPortCache.width !== viewport.width || viewPortCache.height !== viewport.height) {
+      viewPortCache.x = viewport.x;
+      viewPortCache.y = viewPortY;
+      viewPortCache.width = viewport.width;
+      viewPortCache.height = viewport.height;
+      gl.viewport(
+        viewport.x,
+        viewPortY,
+        viewport.width,
+        viewport.height
+      );
+    }
+    if (!gpuRenderTarget.depthStencilRenderBuffer && (renderTarget.stencil || renderTarget.depth)) {
+      this._initStencil(gpuRenderTarget);
+    }
+    this.clear(renderTarget, clear, clearColor);
+  }
+  finishRenderPass(renderTarget) {
+    const renderTargetSystem = this._renderTargetSystem;
+    const glRenderTarget = renderTargetSystem.getGpuRenderTarget(renderTarget);
+    if (!glRenderTarget.msaa)
+      return;
+    const gl = this._renderer.gl;
+    gl.bindFramebuffer(gl.FRAMEBUFFER, glRenderTarget.resolveTargetFramebuffer);
+    gl.bindFramebuffer(gl.READ_FRAMEBUFFER, glRenderTarget.framebuffer);
+    gl.blitFramebuffer(
+      0,
+      0,
+      glRenderTarget.width,
+      glRenderTarget.height,
+      0,
+      0,
+      glRenderTarget.width,
+      glRenderTarget.height,
+      gl.COLOR_BUFFER_BIT,
+      gl.NEAREST
+    );
+    gl.bindFramebuffer(gl.FRAMEBUFFER, glRenderTarget.framebuffer);
+  }
+  initGpuRenderTarget(renderTarget) {
+    const renderer = this._renderer;
+    const gl = renderer.gl;
+    const glRenderTarget = new GlRenderTarget();
+    const colorTexture = renderTarget.colorTexture;
+    if (CanvasSource.test(colorTexture.resource)) {
+      this._renderer.context.ensureCanvasSize(renderTarget.colorTexture.resource);
+      glRenderTarget.framebuffer = null;
+      return glRenderTarget;
+    }
+    this._initColor(renderTarget, glRenderTarget);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+    return glRenderTarget;
+  }
+  destroyGpuRenderTarget(gpuRenderTarget) {
+    const gl = this._renderer.gl;
+    if (gpuRenderTarget.framebuffer) {
+      gl.deleteFramebuffer(gpuRenderTarget.framebuffer);
+      gpuRenderTarget.framebuffer = null;
+    }
+    if (gpuRenderTarget.resolveTargetFramebuffer) {
+      gl.deleteFramebuffer(gpuRenderTarget.resolveTargetFramebuffer);
+      gpuRenderTarget.resolveTargetFramebuffer = null;
+    }
+    if (gpuRenderTarget.depthStencilRenderBuffer) {
+      gl.deleteRenderbuffer(gpuRenderTarget.depthStencilRenderBuffer);
+      gpuRenderTarget.depthStencilRenderBuffer = null;
+    }
+    gpuRenderTarget.msaaRenderBuffer.forEach((renderBuffer) => {
+      gl.deleteRenderbuffer(renderBuffer);
+    });
+    gpuRenderTarget.msaaRenderBuffer = null;
+  }
+  clear(_renderTarget, clear, clearColor) {
+    if (!clear)
+      return;
+    const renderTargetSystem = this._renderTargetSystem;
+    if (typeof clear === "boolean") {
+      clear = clear ? CLEAR.ALL : CLEAR.NONE;
+    }
+    const gl = this._renderer.gl;
+    if (clear & CLEAR.COLOR) {
+      clearColor ?? (clearColor = renderTargetSystem.defaultClearColor);
+      const clearColorCache = this._clearColorCache;
+      const clearColorArray = clearColor;
+      if (clearColorCache[0] !== clearColorArray[0] || clearColorCache[1] !== clearColorArray[1] || clearColorCache[2] !== clearColorArray[2] || clearColorCache[3] !== clearColorArray[3]) {
+        clearColorCache[0] = clearColorArray[0];
+        clearColorCache[1] = clearColorArray[1];
+        clearColorCache[2] = clearColorArray[2];
+        clearColorCache[3] = clearColorArray[3];
+        gl.clearColor(clearColorArray[0], clearColorArray[1], clearColorArray[2], clearColorArray[3]);
+      }
+    }
+    gl.clear(clear);
+  }
+  resizeGpuRenderTarget(renderTarget) {
+    if (renderTarget.isRoot)
+      return;
+    const renderTargetSystem = this._renderTargetSystem;
+    const glRenderTarget = renderTargetSystem.getGpuRenderTarget(renderTarget);
+    this._resizeColor(renderTarget, glRenderTarget);
+    if (renderTarget.stencil || renderTarget.depth) {
+      this._resizeStencil(glRenderTarget);
+    }
+  }
+  _initColor(renderTarget, glRenderTarget) {
+    const renderer = this._renderer;
+    const gl = renderer.gl;
+    const resolveTargetFramebuffer = gl.createFramebuffer();
+    glRenderTarget.resolveTargetFramebuffer = resolveTargetFramebuffer;
+    gl.bindFramebuffer(gl.FRAMEBUFFER, resolveTargetFramebuffer);
+    glRenderTarget.width = renderTarget.colorTexture.source.pixelWidth;
+    glRenderTarget.height = renderTarget.colorTexture.source.pixelHeight;
+    renderTarget.colorTextures.forEach((colorTexture, i) => {
+      const source = colorTexture.source;
+      if (source.antialias) {
+        if (renderer.context.supports.msaa) {
+          glRenderTarget.msaa = true;
+        } else {
+          warn("[RenderTexture] Antialiasing on textures is not supported in WebGL1");
+        }
+      }
+      renderer.texture.bindSource(source, 0);
+      const glSource = renderer.texture.getGlSource(source);
+      const glTexture = glSource.texture;
+      gl.framebufferTexture2D(
+        gl.FRAMEBUFFER,
+        gl.COLOR_ATTACHMENT0 + i,
+        3553,
+        // texture.target,
+        glTexture,
+        0
+      );
+    });
+    if (glRenderTarget.msaa) {
+      const viewFramebuffer = gl.createFramebuffer();
+      glRenderTarget.framebuffer = viewFramebuffer;
+      gl.bindFramebuffer(gl.FRAMEBUFFER, viewFramebuffer);
+      renderTarget.colorTextures.forEach((_, i) => {
+        const msaaRenderBuffer = gl.createRenderbuffer();
+        glRenderTarget.msaaRenderBuffer[i] = msaaRenderBuffer;
+      });
+    } else {
+      glRenderTarget.framebuffer = resolveTargetFramebuffer;
+    }
+    this._resizeColor(renderTarget, glRenderTarget);
+  }
+  _resizeColor(renderTarget, glRenderTarget) {
+    const source = renderTarget.colorTexture.source;
+    glRenderTarget.width = source.pixelWidth;
+    glRenderTarget.height = source.pixelHeight;
+    renderTarget.colorTextures.forEach((colorTexture, i) => {
+      if (i === 0)
+        return;
+      colorTexture.source.resize(source.width, source.height, source._resolution);
+    });
+    if (glRenderTarget.msaa) {
+      const renderer = this._renderer;
+      const gl = renderer.gl;
+      const viewFramebuffer = glRenderTarget.framebuffer;
+      gl.bindFramebuffer(gl.FRAMEBUFFER, viewFramebuffer);
+      renderTarget.colorTextures.forEach((colorTexture, i) => {
+        const source2 = colorTexture.source;
+        renderer.texture.bindSource(source2, 0);
+        const glSource = renderer.texture.getGlSource(source2);
+        const glInternalFormat = glSource.internalFormat;
+        const msaaRenderBuffer = glRenderTarget.msaaRenderBuffer[i];
+        gl.bindRenderbuffer(
+          gl.RENDERBUFFER,
+          msaaRenderBuffer
+        );
+        gl.renderbufferStorageMultisample(
+          gl.RENDERBUFFER,
+          4,
+          glInternalFormat,
+          source2.pixelWidth,
+          source2.pixelHeight
+        );
+        gl.framebufferRenderbuffer(
+          gl.FRAMEBUFFER,
+          gl.COLOR_ATTACHMENT0 + i,
+          gl.RENDERBUFFER,
+          msaaRenderBuffer
+        );
+      });
+    }
+  }
+  _initStencil(glRenderTarget) {
+    if (glRenderTarget.framebuffer === null)
+      return;
+    const gl = this._renderer.gl;
+    const depthStencilRenderBuffer = gl.createRenderbuffer();
+    glRenderTarget.depthStencilRenderBuffer = depthStencilRenderBuffer;
+    gl.bindRenderbuffer(
+      gl.RENDERBUFFER,
+      depthStencilRenderBuffer
+    );
+    gl.framebufferRenderbuffer(
+      gl.FRAMEBUFFER,
+      gl.DEPTH_STENCIL_ATTACHMENT,
+      gl.RENDERBUFFER,
+      depthStencilRenderBuffer
+    );
+    this._resizeStencil(glRenderTarget);
+  }
+  _resizeStencil(glRenderTarget) {
+    const gl = this._renderer.gl;
+    gl.bindRenderbuffer(
+      gl.RENDERBUFFER,
+      glRenderTarget.depthStencilRenderBuffer
+    );
+    if (glRenderTarget.msaa) {
+      gl.renderbufferStorageMultisample(
+        gl.RENDERBUFFER,
+        4,
+        gl.DEPTH24_STENCIL8,
+        glRenderTarget.width,
+        glRenderTarget.height
+      );
+    } else {
+      gl.renderbufferStorage(
+        gl.RENDERBUFFER,
+        this._renderer.context.webGLVersion === 2 ? gl.DEPTH24_STENCIL8 : gl.DEPTH_STENCIL,
+        glRenderTarget.width,
+        glRenderTarget.height
+      );
+    }
+  }
+  postrender(renderTarget) {
+    if (!this._renderer.context.multiView)
+      return;
+    if (CanvasSource.test(renderTarget.colorTexture.resource)) {
+      const contextCanvas = this._renderer.context.canvas;
+      const canvasSource = renderTarget.colorTexture;
+      canvasSource.context2D.drawImage(
+        contextCanvas,
+        0,
+        canvasSource.pixelHeight - contextCanvas.height
+      );
+    }
+  }
+}
+
+export { GlRenderTargetAdaptor };
+//# sourceMappingURL=GlRenderTargetAdaptor.mjs.map

node_modules/pixi.js/lib/rendering/renderers/gl/renderTarget/GlRenderTargetSystem.d.ts

@@ -0,0 +1,18 @@
+import { ExtensionType } from '../../../../extensions/Extensions';
+import { RenderTargetSystem } from '../../shared/renderTarget/RenderTargetSystem';
+import { GlRenderTargetAdaptor } from './GlRenderTargetAdaptor';
+import type { GlRenderTarget } from '../GlRenderTarget';
+import type { WebGLRenderer } from '../WebGLRenderer';
+/**
+ * The WebGL adaptor for the render target system. Allows the Render Target System to be used with the WebGl renderer
+ * @memberof rendering
+ */
+export declare class GlRenderTargetSystem extends RenderTargetSystem<GlRenderTarget> {
+    /** @ignore */
+    static extension: {
+        readonly type: readonly [ExtensionType.WebGLSystem];
+        readonly name: "renderTarget";
+    };
+    adaptor: GlRenderTargetAdaptor;
+    constructor(renderer: WebGLRenderer);
+}

node_modules/pixi.js/lib/rendering/renderers/gl/renderTarget/GlRenderTargetSystem.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var Extensions = require('../../../../extensions/Extensions.js');
+var RenderTargetSystem = require('../../shared/renderTarget/RenderTargetSystem.js');
+var GlRenderTargetAdaptor = require('./GlRenderTargetAdaptor.js');
+
+"use strict";
+class GlRenderTargetSystem extends RenderTargetSystem.RenderTargetSystem {
+  constructor(renderer) {
+    super(renderer);
+    this.adaptor = new GlRenderTargetAdaptor.GlRenderTargetAdaptor();
+    this.adaptor.init(renderer, this);
+  }
+}
+/** @ignore */
+GlRenderTargetSystem.extension = {
+  type: [Extensions.ExtensionType.WebGLSystem],
+  name: "renderTarget"
+};
+
+exports.GlRenderTargetSystem = GlRenderTargetSystem;
+//# sourceMappingURL=GlRenderTargetSystem.js.map

node_modules/pixi.js/lib/rendering/renderers/gl/renderTarget/GlRenderTargetSystem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlRenderTargetSystem.js","sources":["../../../../../src/rendering/renderers/gl/renderTarget/GlRenderTargetSystem.ts"],"sourcesContent":["import { ExtensionType } from '../../../../extensions/Extensions';\nimport { RenderTargetSystem } from '../../shared/renderTarget/RenderTargetSystem';\nimport { GlRenderTargetAdaptor } from './GlRenderTargetAdaptor';\n\nimport type { GlRenderTarget } from '../GlRenderTarget';\nimport type { WebGLRenderer } from '../WebGLRenderer';\n\n/**\n * The WebGL adaptor for the render target system. Allows the Render Target System to be used with the WebGl renderer\n * @memberof rendering\n */\nexport class GlRenderTargetSystem extends RenderTargetSystem<GlRenderTarget>\n{\n    /** @ignore */\n    public static extension = {\n        type: [ExtensionType.WebGLSystem],\n        name: 'renderTarget',\n    } as const;\n\n    public adaptor = new GlRenderTargetAdaptor();\n\n    constructor(renderer: WebGLRenderer)\n    {\n        super(renderer);\n\n        this.adaptor.init(renderer, this);\n    }\n}\n"],"names":["RenderTargetSystem","GlRenderTargetAdaptor","ExtensionType"],"mappings":";;;;;;;AAWO,MAAM,6BAA6BA,qCAC1C,CAAA;AAAA,EASI,YAAY,QACZ,EAAA;AACI,IAAA,KAAA,CAAM,QAAQ,CAAA,CAAA;AAJlB,IAAO,IAAA,CAAA,OAAA,GAAU,IAAIC,2CAAsB,EAAA,CAAA;AAMvC,IAAK,IAAA,CAAA,OAAA,CAAQ,IAAK,CAAA,QAAA,EAAU,IAAI,CAAA,CAAA;AAAA,GACpC;AACJ,CAAA;AAAA;AAhBa,oBAAA,CAGK,SAAY,GAAA;AAAA,EACtB,IAAA,EAAM,CAACC,wBAAA,CAAc,WAAW,CAAA;AAAA,EAChC,IAAM,EAAA,cAAA;AACV,CAAA;;;;"}

node_modules/pixi.js/lib/rendering/renderers/gl/renderTarget/GlRenderTargetSystem.mjs

@@ -0,0 +1,20 @@
+import { ExtensionType } from '../../../../extensions/Extensions.mjs';
+import { RenderTargetSystem } from '../../shared/renderTarget/RenderTargetSystem.mjs';
+import { GlRenderTargetAdaptor } from './GlRenderTargetAdaptor.mjs';
+
+"use strict";
+class GlRenderTargetSystem extends RenderTargetSystem {
+  constructor(renderer) {
+    super(renderer);
+    this.adaptor = new GlRenderTargetAdaptor();
+    this.adaptor.init(renderer, this);
+  }
+}
+/** @ignore */
+GlRenderTargetSystem.extension = {
+  type: [ExtensionType.WebGLSystem],
+  name: "renderTarget"
+};
+
+export { GlRenderTargetSystem };
+//# sourceMappingURL=GlRenderTargetSystem.mjs.map

node_modules/pixi.js/lib/rendering/renderers/gl/renderTarget/GlRenderTargetSystem.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlRenderTargetSystem.mjs","sources":["../../../../../src/rendering/renderers/gl/renderTarget/GlRenderTargetSystem.ts"],"sourcesContent":["import { ExtensionType } from '../../../../extensions/Extensions';\nimport { RenderTargetSystem } from '../../shared/renderTarget/RenderTargetSystem';\nimport { GlRenderTargetAdaptor } from './GlRenderTargetAdaptor';\n\nimport type { GlRenderTarget } from '../GlRenderTarget';\nimport type { WebGLRenderer } from '../WebGLRenderer';\n\n/**\n * The WebGL adaptor for the render target system. Allows the Render Target System to be used with the WebGl renderer\n * @memberof rendering\n */\nexport class GlRenderTargetSystem extends RenderTargetSystem<GlRenderTarget>\n{\n    /** @ignore */\n    public static extension = {\n        type: [ExtensionType.WebGLSystem],\n        name: 'renderTarget',\n    } as const;\n\n    public adaptor = new GlRenderTargetAdaptor();\n\n    constructor(renderer: WebGLRenderer)\n    {\n        super(renderer);\n\n        this.adaptor.init(renderer, this);\n    }\n}\n"],"names":[],"mappings":";;;;;AAWO,MAAM,6BAA6B,kBAC1C,CAAA;AAAA,EASI,YAAY,QACZ,EAAA;AACI,IAAA,KAAA,CAAM,QAAQ,CAAA,CAAA;AAJlB,IAAO,IAAA,CAAA,OAAA,GAAU,IAAI,qBAAsB,EAAA,CAAA;AAMvC,IAAK,IAAA,CAAA,OAAA,CAAQ,IAAK,CAAA,QAAA,EAAU,IAAI,CAAA,CAAA;AAAA,GACpC;AACJ,CAAA;AAAA;AAhBa,oBAAA,CAGK,SAAY,GAAA;AAAA,EACtB,IAAA,EAAM,CAAC,aAAA,CAAc,WAAW,CAAA;AAAA,EAChC,IAAM,EAAA,cAAA;AACV,CAAA;;;;"}