PIXI Web GL

src/foundry/client/pixi/core/containers/base-canvas-group.d.ts

@@ -0,0 +1,40 @@
+export {};
+
+declare class BaseCanvasMixinClass {
+  /** @defaultValue `true` */
+  sortableChildren: boolean;
+
+  /**
+   * The name of this canvas group
+   * @remarks Foundry marked as abstract
+   */
+  static groupName: string;
+
+  /**
+   * If this canvas group should teardown non-layers children.
+   */
+  static tearDownChildren: boolean;
+
+  /**
+   * A mapping of CanvasLayer classes which belong to this group.
+   * @remarks Default value defined by this.#createLayers, which pulls from CONFIG.Canvas.layers
+   */
+  layers: Record<string, CanvasLayer>;
+
+  /** Draw the canvas group and all its component layers. */
+  draw(): Promise<void>;
+
+  /** Remove and destroy all layers from the base canvas. */
+  tearDown(options: InexactPartial<Record<string, unknown>>): Promise<void>;
+}
+
+declare global {
+  /**
+   * A mixin which decorates any container with base canvas common properties.
+   * @param ContainerClass - The parent Container class being mixed.
+   * @returns A ContainerClass subclass mixed with BaseCanvasMixin features.
+   */
+  function BaseCanvasMixin<BaseClass extends typeof PIXI.Container>(
+    ContainerClass: BaseClass,
+  ): Mixin<typeof BaseCanvasMixinClass, BaseClass>;
+}

src/foundry/client/pixi/core/containers/cached-container.d.ts

@@ -1,64 +1,97 @@
+export {};
+
 /**
  * A special type of PIXI.Container which draws its contents to a cached RenderTexture.
  * This is accomplished by overriding the Container#render method to draw to our own special RenderTexture.
  */
-declare class CachedContainer extends PIXI.Container {
-  constructor();
-
-  /**
-   * The RenderTexture that is the render destination for the contents of this Container
-   */
-  readonly renderTexture: PIXI.RenderTexture;
-
-  protected _onResize: () => void;
-
-  /**
-   * An object which stores a reference to the normal renderer target and source frame.
-   * We track this so we can restore them after rendering our cached texture.
-   */
-  protected _backup: {
-    renderTexture: PIXI.RenderTexture | undefined;
-    sourceFrame: PIXI.Rectangle;
-  };
-
-  /**
-   * An RGBA array used to define the clear color of the RenderTexture
-   * @defaultValue `[0, 0, 0, 1]`
-   */
-  clearColor: [r: number, g: number, b: number, a: number];
-
-  /**
-   * Should our Container also be displayed on screen, in addition to being drawn to the cached RenderTexture?
-   * @defaultValue `false`
-   */
-  displayed: boolean;
-
-  /**
-   * A bound Sprite which uses this container's render texture
-   */
-  get sprite(): PIXI.Sprite;
-
-  /** @internal */
-  protected _sprite: PIXI.Sprite | undefined;
-
-  destroy(options?: Parameters<PIXI.Container["destroy"]>[0]): ReturnType<PIXI.Container["destroy"]>;
-
-  render(renderer: Parameters<PIXI.Container["render"]>[0]): void;
-
-  /**
-   * Bind our cached RenderTexture to the Renderer, replacing the original target.
-   * @param renderer - The active canvas renderer
-   */
-  protected _bind(renderer: PIXI.Renderer): void;
-
-  /**
-   * Remove our cached RenderTexture from the Renderer, re-binding the original target.
-   * @param renderer - The active canvas renderer
-   */
-  protected _unbind(renderer: PIXI.Renderer): void;
-
-  /**
-   * Resize the cached RenderTexture when the dimensions or resolution of the Renderer have changed.
-   */
-  protected _resize(renderer: PIXI.Renderer): void;
+declare global {
+  class CachedContainer extends PIXI.Container {
+    /**
+     * Construct a CachedContainer.
+     * @param sprite - A specific sprite to bind to this CachedContainer and its renderTexture.
+     */
+    constructor(sprite: PIXI.Sprite | SpriteMesh);
+
+    /**
+     * The texture configuration to use for this cached container
+     * @remarks Foundry marked as abstract
+     */
+    static textureConfiguration: { multisample: PIXI.MSAA_QUALITY; scaleMode: PIXI.SCALE_MODES; format: PIXI.FORMATS };
+
+    /**
+     * An map of render textures, linked to their render function and an optional RGBA clear color.
+     */
+    protected _renderPaths: Map<PIXI.RenderTexture, CachedContainer.RenderOptions>;
+
+    /**
+     * An RGBA array used to define the clear color of the RenderTexture
+     * @defaultValue `[0, 0, 0, 1]`
+     */
+    clearColor: [r: number, g: number, b: number, a: number];
+
+    /**
+     * Should our Container also be displayed on screen, in addition to being drawn to the cached RenderTexture?
+     * @defaultValue `false`
+     */
+    displayed: boolean;
+
+    /**
+     * The primary render texture bound to this cached container.
+     */
+    get renderTexture(): PIXI.RenderTexture;
+
+    /**
+     * Set the alpha mode of the cached container render texture.
+     */
+    set alphaMode(mode: PIXI.ALPHA_MODES);
+
+    /**
+     * A bound Sprite which uses this container's render texture
+     */
+    get sprite(): PIXI.Sprite | SpriteMesh;
+
+    set sprite(sprite: PIXI.Sprite | SpriteMesh);
+
+    /**
+     * Create a render texture, provide a render method and an optional clear color.
+     * @param options - Optional parameters.
+     * @returns A reference to the created render texture.
+     */
+    createRenderTexture(options?: CachedContainer.RenderOptions): PIXI.RenderTexture;
+
+    /**
+     * Remove a previously created render texture.
+     * @param renderTexture - The render texture to remove.
+     * @param destroy - Should the render texture be destroyed?
+     *                  (default: `true`)
+     */
+    removeRenderTexture(renderTexture: PIXI.RenderTexture, destroy?: boolean): void;
+
+    /**
+     * Clear the cached container, removing its current contents.
+     * @param destroy - Tell children that we should destroy texture as well.
+     * @returns A reference to the cleared container for chaining.
+     */
+    clear(destroy?: boolean): CachedContainer;
+
+    override destroy(options?: boolean | PIXI.IDestroyOptions): void;
+
+    override render(renderer: PIXI.Renderer): void;
+
+    /**
+     * Resize a render texture passed as a parameter with the renderer.
+     * @param renderer - The active canvas renderer.
+     * @param rt       - The render texture to resize.
+     */
+    static resizeRenderTexture(renderer: PIXI.Renderer, rt: PIXI.RenderTexture): void;
+  }
+
+  namespace CachedContainer {
+    type RenderOptions = {
+      /** Render function that will be called to render into the RT. */
+      renderFunction?: (renderer: PIXI.Renderer) => void;
+      /** An optional clear color to clear the RT before rendering into it. */
+      clearColor?: number[];
+    };
+  }
 }

src/foundry/client/pixi/core/containers/full-canvas-container.d.ts

@@ -1,6 +1,24 @@
-/**
- * A specialized container where bounds are not computed with children, but with canvas dimensions.
- */
-declare class FullCanvasContainer extends PIXI.Container {
-  override calculateBounds(): void;
+export {};
+
+declare class FullCanvasObject {
+  /** @remarks Overrides the mixed in class */
+  calculateBounds(): void;
+}
+
+declare global {
+  /**
+   * Augment any PIXI.DisplayObject to assume bounds that are always aligned with the full visible screen.
+   * The bounds of this container do not depend on its children but always fill the entire canvas.
+   * @param Base - Any PIXI DisplayObject subclass
+   * @returns The decorated subclass with full canvas bounds
+   */
+  function FullCanvasObjectMixin<BaseClass extends typeof PIXI.DisplayObject>(
+    Base: BaseClass,
+  ): Mixin<typeof FullCanvasObject, BaseClass>;
+
+  /**
+   * @deprecated since v11, will be removed in v13
+   * @remarks You are using the FullCanvasContainer class which has been deprecated in favor of a more flexible FullCanvasObjectMixin which can augment any PIXI.DisplayObject subclass.
+   */
+  class FullCanvasContainer extends FullCanvasObjectMixin(PIXI.Container) {}
 }

src/foundry/client/pixi/core/containers/index.d.ts

@@ -1,4 +1,8 @@
+import "./base-canvas-group";
 import "./cached-container";
-import "./quadtree";
-import "./sampler-mesh";
 import "./full-canvas-container";
+import "./point-source-mesh";
+import "./quad-mesh";
+import "./quadtree";
+import "./sprite-mesh";
+import "./unbound-container";

src/foundry/client/pixi/core/containers/point-source-mesh.d.ts

@@ -0,0 +1,55 @@
+export {};
+
+declare global {
+  /**
+   * Extension of a PIXI.Mesh, with the capabilities to provide a snapshot of the framebuffer.
+   */
+  class PointSourceMesh extends PIXI.Mesh {
+    /**
+     * To store the previous blend mode of the last renderer PointSourceMesh.
+     */
+    protected static _priorBlendMode: PIXI.BLEND_MODES;
+
+    /**
+     * The current texture used by the mesh.
+     */
+    protected static _currentTexture: PIXI.Texture;
+
+    /**
+     * The transform world ID of the bounds.
+     * @defaultValue `-1`
+     */
+    _worldID: number;
+
+    /**
+     * The geometry update ID of the bounds.
+     * @defaultValue `-1`
+     */
+    _updateID: number;
+
+    override get geometry(): PIXI.Geometry;
+
+    set geometry(value: PIXI.Geometry);
+
+    /** @throws You can't add children to a PointSourceMesh. */
+    override addChild(): never;
+
+    /** @throws You can't add children to a PointSourceMesh. */
+    override addChildAt(): never;
+
+    /**
+     * @throws You can't add children to a PointSourceMesh.
+     * @privateRemarks This method is meant to be an override, but the PIXI.Mesh class does not have an addChildren() method
+     */
+    addChildren(): never;
+
+    protected override _render(renderer: PIXI.Renderer): void;
+
+    override calculateBounds(): void;
+
+    protected override _calculateBounds(): void;
+
+    /** The local bounds need to be drawn from the underlying geometry. */
+    override getLocalBounds(rect?: PIXI.Rectangle | undefined): PIXI.Rectangle;
+  }
+}

src/foundry/client/pixi/core/containers/quad-mesh.d.ts

@@ -0,0 +1,66 @@
+export {};
+
+declare global {
+  /**
+   * A basic rectangular mesh with a shader only. Does not natively handle textures (but a bound shader can).
+   * Bounds calculations are simplified and the geometry does not need to handle texture coords.
+   */
+  class QuadMesh extends PIXI.Container {
+    /**
+     * @param shaderCls - The shader class to use.
+     */
+    constructor(shaderCls: AbstractBaseShader);
+
+    /**
+     * The shader.
+     */
+    shader: BaseSamplerShader;
+
+    /**
+     * The state.
+     */
+    state: PIXI.State;
+
+    /**
+     * Assigned geometry to this mesh.
+     * We need to handle the refCount.
+     */
+    get geometry(): PIXI.Geometry;
+
+    set geometry(value: PIXI.Geometry);
+
+    /**
+     * Assigned blend mode to this mesh.
+     */
+    get blendMode(): PIXI.BLEND_MODES;
+
+    set blendMode(value: PIXI.BLEND_MODES);
+
+    /**
+     * Initialize shader based on the shader class type.
+     * @param shaderCls - Shader class used. Must inherit from AbstractBaseShader.
+     */
+    setShaderClass(shaderCls: typeof AbstractBaseShader): void;
+
+    protected override _render(_renderer: PIXI.Renderer): void;
+
+    override get width(): number;
+    override set width(value: number);
+
+    protected _width: number;
+
+    get height(): number;
+    set height(value: number);
+
+    protected _height: number;
+
+    protected override _calculateBounds(): void;
+
+    /**
+     * Tests if a point is inside this QuadMesh.
+     */
+    containsPoint(point: PIXI.IPointData): boolean;
+
+    override destroy(options?: boolean | PIXI.IDestroyOptions | undefined): void;
+  }
+}