@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.2-beta

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

@@ -0,0 +1,83 @@
+import type { AnyObject, Mixin } from "../../../../../types/utils.d.mts";
+
+declare class CanvasGroup {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /** @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;
+
+  /**
+   * The canonical name of the canvas group is the name of the constructor that is the immediate child of the defined base class.
+   */
+  get name(): string;
+
+  /**
+   * The name used by hooks to construct their hook string.
+   * Note: You should override this getter if hookName should not return the class constructor name.
+   */
+  get hookName(): string;
+
+  /**
+   * 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>;
+
+  /**
+   * Create CanvasLayer instances which belong to the canvas group.
+   */
+  _createLayers(): Record<string, CanvasLayer>;
+
+  /** Draw the canvas group and all its component layers. */
+  draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+
+  /**
+   * Draw the canvas group and all its component layers.
+   */
+  protected _draw(options: CanvasGroupMixin.DrawOptions): Promise<void>;
+
+  /**
+   * Remove and destroy all layers from the base canvas.
+   */
+  tearDown(options: CanvasGroupMixin.TearDownOptions): Promise<void>;
+
+  /**
+   * Remove and destroy all layers from the base canvas.
+   */
+  protected _tearDown(options: CanvasGroupMixin.TearDownOptions): 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 CanvasGroupMixin<BaseClass extends CanvasGroupMixin.BaseClass>(
+    ContainerClass: BaseClass,
+  ): Mixin<typeof CanvasGroup, BaseClass>;
+
+  namespace CanvasGroupMixin {
+    type BaseClass = typeof AnyPIXIContainer;
+
+    type DrawOptions = AnyObject;
+
+    type TearDownOptions = AnyObject;
+  }
+}
+
+declare abstract class AnyPIXIContainer extends PIXI.Container<any> {
+  constructor(arg0: never, ...args: never[]);
+}

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

@@ -0,0 +1,118 @@
+import type { NullishProps } from "../../../../../types/utils.d.mts";
+
+export {};
+
+declare global {
+  /**
+   * 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.
+   */
+  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: NullishProps<{
+      multisample: PIXI.MSAA_QUALITY;
+      scaleMode: PIXI.SCALE_MODES;
+      format: PIXI.FORMATS;
+    }>;
+
+    /**
+     * A 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;
+
+    /**
+     * If true, the Container is rendered every frame.
+     * If false, the Container is rendered only if {@link CachedContainer#renderDirty} is true.
+     * @defaultValue `true`
+     */
+    autoRender: boolean;
+
+    /**
+     * Does the Container need to be rendered?
+     * Set to false after the Container is rendered.
+     * @defaultValue `true`
+     */
+    renderDirty: 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.
+     * @remarks Added possibility of void return due to child classes
+     */
+    clear(destroy?: boolean): CachedContainer | void;
+
+    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 {
+    interface 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[];
+    }
+  }
+}

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

@@ -0,0 +1,37 @@
+import type { Mixin } from "../../../../../types/utils.d.mts";
+
+declare class FullCanvasObject {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /** @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 FullCanvasObject.BaseClass>(
+    Base: BaseClass,
+  ): Mixin<typeof FullCanvasObject, BaseClass>;
+
+  namespace FullCanvasObject {
+    type AnyConstructor = typeof AnyFullCanvasObject;
+
+    type BaseClass = PIXI.DisplayObject.AnyConstructor;
+  }
+
+  /**
+   * @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) {}
+}
+
+declare abstract class AnyFullCanvasObject extends FullCanvasObject {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/foundry/client/pixi/core/containers/index.d.mts

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

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

@@ -0,0 +1,62 @@
+export {};
+
+declare global {
+  /**
+   * Extension of a PIXI.Mesh, with the capabilities to provide a snapshot of the framebuffer.
+   */
+  class PointSourceMesh extends PIXI.Mesh {
+    /**
+     * @remarks This override is not in the actual Foundry code, this is reflecting actual usage.
+     * PIXI.Mesh asks for a PIXI.MeshMaterial for its second argument, a subclass of PIXI.Shader.
+     * But foundry doesn't use those additional properties, so in actual practice it just needs PIXI.Shader.
+     */
+    constructor(geometry: PIXI.Geometry, shader: PIXI.Shader, state?: PIXI.State, drawMode?: PIXI.DRAW_MODES);
+
+    /**
+     * 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): PIXI.Rectangle;
+  }
+}

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

@@ -0,0 +1,43 @@
+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 shaderClass - The shader class to use.
+     */
+    constructor(shaderClass: typeof AbstractBaseShader);
+
+    /**
+     * The shader bound to this mesh.
+     */
+    get shader(): AbstractBaseShader;
+
+    /**
+     * 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 shaderClass - Shader class used. Must inherit from AbstractBaseShader.
+     */
+    setShaderClass(shaderClass: typeof AbstractBaseShader): void;
+
+    protected override _render(_renderer: PIXI.Renderer): void;
+
+    protected override _calculateBounds(): void;
+
+    /**
+     * Tests if a point is inside this QuadMesh.
+     */
+    containsPoint(point: PIXI.IPointData): boolean;
+
+    override destroy(options?: boolean | PIXI.IDestroyOptions): void;
+  }
+}

package/src/foundry/client/pixi/core/containers/quadtree.d.mts

@@ -0,0 +1,199 @@
+export {};
+
+declare global {
+  interface QuadtreeObject<T> {
+    r: Canvas.Rectangle;
+    t: T;
+    n: Set<Quadtree<T>>;
+  }
+
+  /**
+   * A Quadtree implementation that supports collision detection for rectangles.
+   */
+  class Quadtree<T> {
+    /**
+     * @param bounds  - The outer bounds of the region
+     * @param options - Additional options which configure the Quadtree
+     */
+    constructor(bounds: PIXI.Rectangle, options?: Quadtree.Options<T>);
+
+    /**
+     * The bounding rectangle of the region
+     */
+    bounds: PIXI.Rectangle;
+
+    /**
+     * The maximum number of objects allowed within this node before it must split
+     * @defaultValue `20`
+     */
+    maxObjects: number;
+
+    /**
+     * The maximum number of levels that the base quadtree is allowed
+     * @defaultValue `4`
+     */
+    maxDepth: number;
+
+    /**
+     * The depth of this node within the root Quadtree
+     * @defaultValue `0`
+     */
+    depth: number;
+
+    /**
+     * The objects contained at this level of the tree
+     * @defaultValue `[]`
+     */
+    objects: QuadtreeObject<T>[];
+
+    /**
+     * Children of this node
+     * @defaultValue `[]`
+     */
+    nodes: Quadtree<T>[];
+
+    /**
+     * The root Quadtree
+     */
+    root: Quadtree<T>;
+
+    /**
+     * A constant that enumerates the index order of the quadtree nodes from top-left to bottom-right.
+     */
+    static readonly INDICES: {
+      tl: 0;
+      tr: 1;
+      bl: 2;
+      br: 3;
+    };
+
+    /**
+     * Return an array of all the objects in the Quadtree (recursive)
+     */
+    get all(): QuadtreeObject<T>[];
+
+    /**
+     * Split this node into 4 sub-nodes.
+     * @returns The split Quadtree
+     */
+    split(): this;
+
+    /**
+     * Clear the quadtree of all existing contents
+     * @returns The cleared Quadtree
+     */
+    clear(): this;
+
+    /**
+     * Add a rectangle object to the tree
+     * @param obj - The object being inserted
+     * @returns The Quadtree nodes the object was added to.
+     */
+    insert(obj: QuadtreeObject<T>): Quadtree<T>[];
+
+    /**
+     * Remove an object from the quadtree
+     * @param target - The quadtree target being removed
+     * @returns The Quadtree for method chaining
+     */
+    remove(target: T): this;
+
+    /**
+     * Remove an existing object from the quadtree and re-insert it with a new position
+     * @param obj - The object being inserted
+     * @returns The Quadtree nodes the object was added to
+     */
+    update(obj: QuadtreeObject<T>): Quadtree<T>[];
+
+    /**
+     * Get all the objects which could collide with the provided rectangle
+     * @param rect - The normalized target rectangle
+     * @param options - Options affecting the collision test.
+     * @returns The objects in the Quadtree which represent potential collisions
+     */
+    getObjects(
+      rect: Canvas.Rectangle,
+      options?: {
+        /* Function to further refine objects to return
+         * after a potential collision is found. Parameters are the object and rect, and the
+         * function should return true if the object should be added to the result set.
+         */
+        collisionTest: (o: QuadtreeObject<T>, rect: Canvas.Rectangle) => boolean;
+
+        /** The existing result set, for internal use.
+         *  (default: `new Set<T>()`)
+         */
+        _s?: Set<T>;
+      },
+    ): Set<T>;
+
+    /**
+     * Obtain the leaf nodes to which a target rectangle belongs.
+     * This traverses the quadtree recursively obtaining the final nodes which have no children.
+     * @param rect - The target rectangle.x
+     * @returns The Quadtree nodes to which the target rectangle belongs
+     */
+    getLeafNodes(rect: Canvas.Rectangle): Quadtree<T>[];
+
+    /**
+     * Obtain the child nodes within the current node which a rectangle belongs to.
+     * Note that this function is not recursive, it only returns nodes at the current or child level.
+     * @param rect - The target rectangle.
+     * @returns The Quadtree nodes to which the target rectangle belongs
+     */
+    getChildNodes(rect: Canvas.Rectangle): Quadtree<T>[];
+
+    /**
+     * Identify all nodes which are adjacent to this one within the parent Quadtree.
+     */
+    getAdjacentNodes(): Quadtree<T>[];
+
+    /**
+     * Visualize the nodes and objects in the quadtree
+     * @param objects - Visualize the rectangular bounds of objects in the Quadtree. Default is false.
+     *                  (default: `false`)
+     */
+    visualize({ objects }?: { objects?: boolean }): void;
+  }
+
+  /**
+   * A subclass of Quadtree specifically intended for classifying the location of objects on the game canvas.
+   */
+  class CanvasQuadtree extends Quadtree<object> {
+    constructor(options?: Quadtree.Options<object>);
+
+    readonly bounds: PIXI.Rectangle;
+  }
+
+  namespace Quadtree {
+    /**
+     * Additional options which configure the Quadtree
+     */
+    interface Options<T> {
+      /**
+       * The maximum number of objects per node
+       * @defaultValue `20`
+       */
+      maxObjects?: number;
+
+      /**
+       * The maximum number of levels within the root Quadtree
+       * @defaultValue `4`
+       */
+      maxDepth?: number;
+
+      /**
+       * The depth level of the sub-tree. For internal use
+       * @defaultValue `0`
+       * @internal
+       */
+      _depth?: number;
+
+      /**
+       * The root of the quadtree. For internal use
+       * @internal
+       */
+      _root?: Quadtree<T>;
+    }
+  }
+}