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

package/src/foundry/client/pixi/layers/grid/highlight.d.mts

@@ -0,0 +1,33 @@
+export {};
+
+declare global {
+  /**
+   * A special Graphics class which handles Grid layer highlighting
+   */
+  class GridHighlight extends PIXI.Graphics {
+    constructor(name: string, ...args: ConstructorParameters<typeof PIXI.Graphics>);
+
+    /**
+     * Track the Grid Highlight name
+     */
+    name: string;
+
+    /**
+     * Track distinct positions which have already been highlighted
+     */
+    positions: Set<string>;
+
+    /**
+     * Record a position that is highlighted and return whether or not it should be rendered
+     * @param x - The x-coordinate to highlight
+     * @param y - The y-coordinate to highlight
+     * @returns Whether or not to draw the highlight for this location
+     */
+    highlight(x: number, y: number): boolean;
+
+    override clear(): this;
+
+    /** @privateRemarks Foundry handles this by passing `(...args)` directly to super, but it only takes the one */
+    override destroy(options?: PIXI.DisplayObject.DestroyOptions): void;
+  }
+}

package/src/foundry/client/pixi/layers/grid/index.d.mts

@@ -0,0 +1,3 @@
+import "./highlight.d.mts";
+import "./layer.d.mts";
+import "./mesh.d.mts";

package/src/foundry/client/pixi/layers/grid/layer.d.mts

@@ -0,0 +1,269 @@
+import type { InexactPartial, NullishProps } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A CanvasLayer responsible for drawing a square grid
+   */
+  class GridLayer<
+    DrawOptions extends GridLayer.DrawOptions = GridLayer.DrawOptions,
+    TearDownOptions extends CanvasLayer.TearDownOptions = CanvasLayer.TearDownOptions,
+  > extends CanvasLayer<DrawOptions, TearDownOptions> {
+    /**
+     * @remarks Due to the grid rework in v12 this points to a BaseGrid subclass rather than a GridLayer instance,
+     *          however to avoid inheritance-based issues this is left as the intended GridLayer instance
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): GridLayer;
+
+    /**
+     * The grid mesh.
+     * @defaultValue `undefined`
+     */
+    mesh: GridMesh | undefined;
+
+    /**
+     * The Grid Highlight container
+     * @defaultValue `undefined`
+     */
+    highlight: PIXI.Container | undefined;
+
+    /**
+     * Map named highlight layers
+     * @defaultValue `{}`
+     */
+    highlightLayers: Record<string, GridHighlight>;
+
+    /**
+     * @defaultValue
+     * ```js
+     * foundry.utils.mergeObject(super.layerOptions, {name: "grid"});
+     * ```
+     */
+    static override get layerOptions(): GridLayer.LayerOptions;
+
+    override options: GridLayer.LayerOptions;
+
+    /**
+     * Draw the grid
+     * @param options - Override settings used in place of those saved to the Scene data
+     */
+    _draw(options?: DrawOptions): Promise<void>;
+
+    /**
+     * Creates the grid mesh.
+     */
+    protected _drawMesh(): Promise<ReturnType<GridMesh["initialize"]>>;
+
+    /**
+     * Initialize the grid mesh appearance and configure the grid shader.
+     */
+    initializeMesh(
+      /**
+       * @remarks Can't be NullishProps because ultimately `GridMesh#_initialize` does `!== undefined` checks
+       */
+      options?: InexactPartial<{
+        /** The grid style */
+        style: string; //TODO: Update as part of #2572 to keyof CONFIG["Canvas"]["gridStyles"];
+
+        /** The grid thickness */
+        thickness: number;
+
+        /** The grid color */
+        color: string;
+
+        /** The grid alpha */
+        alpha: number;
+      }>,
+    ): void;
+
+    /**
+     * Define a new Highlight graphic
+     * @param name - The name for the referenced highlight layer
+     */
+    addHighlightLayer(name: string): GridHighlight;
+
+    /**
+     * Clear a specific Highlight graphic
+     * @param name - The name for the referenced highlight layer
+     */
+    clearHighlightLayer(name: string): void;
+
+    /**
+     * Destroy a specific Highlight graphic
+     * @param name - The name for the referenced highlight layer
+     */
+    destroyHighlightLayer(name: string): void;
+
+    /**
+     * Obtain the highlight layer graphic by name
+     * @param name - The name for the referenced highlight layer
+     */
+    getHighlightLayer(name: string): GridHighlight | undefined;
+
+    /**
+     * Add highlighting for a specific grid position to a named highlight graphic
+     * @param name    - The name for the referenced highlight layer
+     * @param options - Options for the grid position that should be highlighted
+     */
+    highlightPosition(name: string, options: GridLayer.HighlightPositionOptions): void;
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks `"GridLayer#type is deprecated. Use canvas.grid.type instead."`
+     */
+    get type(): foundry.CONST.GRID_TYPES;
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks `"GridLayer#size is deprecated. Use canvas.grid.size instead.`
+     */
+    get size(): number;
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * `"GridLayer#grid is deprecated. Use canvas.grid instead."`
+     */
+    grid: Canvas["grid"];
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks `"GridLayer#isNeighbor is deprecated. Use canvas.grid.testAdjacency instead."`
+     */
+    isNeighbor(r0: number, c0: number, r1: number, c1: number): boolean;
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks `"GridLayer#w is deprecated in favor of canvas.grid.sizeX."`
+     */
+    get w(): number;
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks `"GridLayer#h is deprecated in favor of canvas.grid.sizeY."`
+     */
+    get h(): number;
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks `"GridLayer#isHex is deprecated. Use canvas.grid.isHexagonal instead."`
+     */
+    get isHex(): boolean;
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks `"GridLayer#getTopLeft is deprecated. Use canvas.grid.getTopLeftPoint instead."`
+     */
+    getTopLeft(x: number, y: number): Canvas.PointArray;
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks `"GridLayer#getCenter is deprecated. Use canvas.grid.getCenterPoint instead."`
+     */
+    getCenter(x: number, y: number): Canvas.PointArray;
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks `"GridLayer#getSnappedPosition is deprecated. Use canvas.grid.getCenterPoint instead."`
+     */
+    getSnappedPosition(
+      x: number,
+      y: number,
+      interval?: number,
+      options?: NullishProps<{
+        /**
+         * The token
+         */
+        token: Token;
+      }>,
+    ): { x: number; y: number };
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks `"GridLayer#measureDistance is deprecated. "Use canvas.grid.measurePath instead for non-Euclidean measurements."`
+     */
+    measureDistance(
+      origin: {
+        x: number;
+        y: number;
+      },
+      target: {
+        x: number;
+        y: number;
+      },
+      options?: GridLayer.MeasureDistancesOptions,
+    ): number;
+  }
+
+  namespace GridLayer {
+    type AnyConstructor = typeof AnyGridLayer;
+
+    interface DrawOptions extends CanvasLayer.DrawOptions {}
+
+    interface TearDownOptions extends CanvasLayer.TearDownOptions {}
+
+    interface LayerOptions extends CanvasLayer.LayerOptions {
+      name: "grid";
+    }
+
+    interface HighlightPositionOptions {
+      /**
+       * The x-coordinate of the highlighted position
+       * @remarks Required if `canvas.grid !== CONST.GRID_TYPES.GRIDLESS`
+       */
+      x?: number | undefined | null;
+
+      /**
+       * The y-coordinate of the highlighted position
+       * @remarks Required if `canvas.grid !== CONST.GRID_TYPES.GRIDLESS`
+       */
+      y?: number | undefined | null;
+
+      /**
+       * The fill color of the highlight
+       * @defaultValue `0x33BBFF`
+       * @privateRemarks `null` is a problem because it's forwarded to a PIXI.Graphics#beginFill call which has a default value set
+       */
+      color?: PIXI.ColorSource | undefined;
+
+      /**
+       * The border color of the highlight
+       * @defaultValue `null`
+       */
+      border?: PIXI.ColorSource | undefined | null;
+
+      /**
+       * The opacity of the highlight
+       * @defaultValue `0.25`
+       */
+      alpha?: number | undefined;
+
+      /**
+       * A predefined shape to highlight
+       * @defaultValue `null`
+       */
+      shape?: PIXI.Polygon | undefined | null;
+    }
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks Used by {@link foundry.grid.BaseGrid#measureDistances}
+     */
+    interface Segment {
+      ray: Ray;
+      label?: Ruler["labels"]["children"][number];
+    }
+
+    /**
+     * @deprecated since v12, will be removed in v14
+     * @remarks Used by {@link foundry.grid.BaseGrid#measureDistances}
+     */
+    type MeasureDistancesOptions = NullishProps<{
+      /** Return the distance in grid increments rather than the co-ordinate distance. */
+      gridSpaces?: boolean;
+    }>;
+  }
+}
+
+declare abstract class AnyGridLayer extends GridLayer {
+  constructor(arg0: never, ...args: never[]);
+}

package/src/foundry/client/pixi/layers/grid/mesh.d.mts

@@ -0,0 +1,73 @@
+import type { InexactPartial } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The grid mesh, which uses the {@link GridShader} to render the grid.
+   */
+  class GridMesh extends QuadMesh {
+    /**
+     * The grid mesh constructor.
+     * @param shaderClass - The shader class
+     */
+    constructor(shaderClass: GridShader.AnyConstructor);
+
+    /**
+     * The data of this mesh.
+     * @defaultValue
+     * ```js
+     * {
+     *   type: CONST.GRID_TYPES.GRIDLESS,
+     *   width: 0,
+     *   height: 0,
+     *   size: 0,
+     *   thickness: 1,
+     *   color: 0,
+     *   alpha: 1
+     * }
+     * ```
+     */
+    data: GridMesh.Data;
+
+    /**
+     * Initialize and update the mesh given the (partial) data.
+     * @param data - The (partial) data
+     * @remarks InexactPartial is more correct as null has different behavior in _initialize
+     */
+    initialize(data: InexactPartial<GridMesh.Data>): this;
+
+    /**
+     * Initialize the data of this mesh given the (partial) data.
+     * @param data - The (partial) data.
+     * @remarks Can't be NullishProps because of `!== undefined` tests
+     */
+    protected _initialize(data: InexactPartial<GridMesh.Data>): void;
+  }
+
+  namespace GridMesh {
+    /**
+     * The grid mesh data.
+     */
+    interface Data {
+      /** The type of the grid (see {@link CONST.GRID_TYPES}) */
+      type: number;
+
+      /** The width of the grid in pixels */
+      width: number;
+
+      /** The height of the grid in pixels */
+      height: number;
+
+      /** The size of a grid space in pixels */
+      size: number;
+
+      /** The thickness of the grid lines in pixels */
+      thickness: number;
+
+      /** The color of the grid */
+      color: number;
+
+      /** The alpha of the grid */
+      alpha: number;
+    }
+  }
+}

package/src/foundry/client/pixi/layers/index.d.mts

@@ -0,0 +1,6 @@
+import "./base/index.d.mts";
+import "./controls/index.d.mts";
+import "./effects/index.d.mts";
+import "./grid/index.d.mts";
+import "./masks/index.d.mts";
+import "./placeables/index.d.mts";

package/src/foundry/client/pixi/layers/masks/depth.d.mts

@@ -0,0 +1,62 @@
+export {};
+
+declare global {
+  /**
+   * The depth mask which contains a mapping of elevation. Needed to know if we must render objects according to depth.
+   * Red channel: Lighting occlusion (top).
+   * Green channel: Lighting occlusion (bottom).
+   * Blue channel: Weather occlusion.
+   */
+  class CanvasDepthMask extends CachedContainer {
+    /**
+     * Container in which roofs are rendered with depth data.
+     */
+    roofs: PIXI.Container;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   scaleMode: PIXI.SCALE_MODES.NEAREST,
+     *   format: PIXI.FORMATS.RGB,
+     *   multisample: PIXI.MSAA_QUALITY.NONE
+     * }
+     * ```
+     */
+    static override textureConfiguration: {
+      scaleMode: PIXI.SCALE_MODES;
+      format: PIXI.FORMATS;
+      multisample: PIXI.MSAA_QUALITY;
+    };
+
+    /**
+     * @defaultValue `[0, 0, 0, 0]`
+     */
+    override clearColor: [r: number, g: number, b: number, a: number];
+
+    /**
+     * Update the elevation-to-depth mapping?
+     */
+    protected _elevationDirty: boolean;
+
+    /**
+     * Map an elevation to a value in the range [0, 1] with 8-bit precision.
+     * The depth-rendered object are rendered with these values into the render texture.
+     * @param elevation - The elevation in distance units
+     * @returns The value for this elevation in the range [0, 1] with 8-bit precision
+     */
+    mapElevation(elevation: number): number;
+
+    /**
+     * Update the elevation-to-depth mapping.
+     * Needs to be called after the children have been sorted
+     * and the canvas transform phase.
+     */
+    protected _update(): void;
+
+    /**
+     * Clear the depth mask.
+     */
+    clear(): void;
+  }
+}

package/src/foundry/client/pixi/layers/masks/index.d.mts

@@ -0,0 +1,3 @@
+import "./depth.d.mts";
+import "./occlusion.d.mts";
+import "./vision.d.mts";

package/src/foundry/client/pixi/layers/masks/occlusion.d.mts

@@ -0,0 +1,91 @@
+export {};
+
+declare global {
+  /**
+   * The occlusion mask which contains radial occlusion and vision occlusion from tokens.
+   * Red channel: Fade occlusion.
+   * Green channel: Radial occlusion.
+   * Blue channel: Vision occlusion.
+   */
+  class CanvasOcclusionMask extends CachedContainer {
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   scaleMode: PIXI.SCALE_MODES.NEAREST,
+     *   format: PIXI.FORMATS.RGB,
+     *   multisample: PIXI.MSAA_QUALITY.NONE
+     * }
+     * ```
+     */
+    static override textureConfiguration: {
+      scaleMode: PIXI.SCALE_MODES;
+      format: PIXI.FORMATS;
+      multisample: PIXI.MSAA_QUALITY;
+    };
+
+    /**
+     * Graphics in which token radial and vision occlusion shapes are drawn.
+     */
+    tokens: PIXI.LegacyGraphics;
+
+    /**
+     * @defaultValue `[0, 1, 1, 1]`
+     */
+    override clearColor: [r: number, g: number, b: number, a: number];
+
+    override autoRender: boolean;
+
+    /**
+     * Is vision occlusion active?
+     */
+    get vision(): boolean;
+
+    /**
+     * Clear the occlusion mask.
+     */
+    clear(): void;
+
+    /**
+     * Map an elevation to a value in the range [0, 1] with 8-bit precision.
+     * The radial and vision shapes are drawn with these values into the render texture.
+     * @param elevation - The elevation in distance units
+     * @returns The value for this elevation in the range [0, 1] with 8-bit precision
+     */
+    mapElevation(elevation: number): number;
+
+    /**
+     * Update the set of occludable Tokens, redraw the occlusion mask, and update the occluded state
+     * of all occludable objects.
+     */
+    updateOcclusion(): void;
+
+    /**
+     * Draw occlusion shapes to the occlusion mask.
+     * Fade occlusion draws to the red channel with varying intensity from [0, 1] based on elevation.
+     * Radial occlusion draws to the green channel with varying intensity from [0, 1] based on elevation.
+     * Vision occlusion draws to the blue channel with varying intensity from [0, 1] based on elevation.
+     */
+    protected _updateOcclusionMask(): void;
+
+    /**
+     * Update the current occlusion status of all Tile objects.
+     */
+    protected _updateOcclusionStates(): void;
+
+    /**
+     * Determine the set of objects which should be currently occluded by a Token.
+     * @param tokens - The set of currently controlled Token objects
+     * @returns The PCO objects which should be currently occluded
+     */
+    protected _identifyOccludedObjects(
+      tokens: Token.ConfiguredInstance[],
+    ): Set<InstanceType<ReturnType<typeof PrimaryCanvasObjectMixin>>>;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks `"CanvasOcclusionMask#_identifyOccludedTiles has been deprecated in favor of CanvasOcclusionMask#_identifyOccludedObjects."`
+     */
+    _identifyOccludedTiles(): Set<typeof PrimaryCanvasObjectMixin>;
+  }
+}

package/src/foundry/client/pixi/layers/masks/vision.d.mts

@@ -0,0 +1,116 @@
+export {};
+
+declare global {
+  /**
+   * The vision mask which contains the current line-of-sight texture.
+   */
+  class CanvasVisionMask extends CachedContainer {
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    scaleMode: PIXI.SCALE_MODES.NEAREST,
+     *    format: PIXI.FORMATS.RED,
+     *    multisample: PIXI.MSAA_QUALITY.NONE
+     * }
+     * ```
+     */
+    static override textureConfiguration: {
+      scaleMode: PIXI.SCALE_MODES;
+      format: PIXI.FORMATS;
+      multisample: PIXI.MSAA_QUALITY;
+    };
+
+    /**
+     * @defaultValue `[0, 0, 0, 0]`
+     */
+    override clearColor: [r: number, g: number, b: number, a: number];
+
+    /**
+     * @defaultValue `false`
+     */
+    override autoRender: boolean;
+
+    /**
+     * The current vision Container.
+     * @defaultValue `undefined`
+     */
+    vision: CanvasVisionMask.CanvasVisionContainer | undefined;
+
+    /**
+     * The BlurFilter which applies to the vision mask texture.
+     * This filter applies a NORMAL blend mode to the container.
+     * @defaultValue `undefined`
+     */
+    blurFilter: AlphaBlurFilter | undefined;
+
+    draw(): Promise<void>;
+
+    /**
+     * Initialize the vision mask with the los and the fov graphics objects.
+     * @param vision - The vision container to attach
+     */
+    attachVision(vision: PIXI.Container): CanvasVisionMask.CanvasVisionContainer;
+
+    /**
+     * Detach the vision mask from the cached container.
+     * @returns The detached vision container.
+     */
+    detachVision(): CanvasVisionMask.CanvasVisionContainer;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks `"CanvasVisionMask#filter has been renamed to blurFilter."`
+     */
+    get filter(): this["blurFilter"];
+
+    set filter(f: AlphaBlurFilter);
+  }
+
+  namespace CanvasVisionMask {
+    /**
+     * The sight part of {@link CanvasVisionContainer}.
+     * The blend mode is MAX_COLOR.
+     */
+    interface CanvasVisionContainerSight extends PIXI.LegacyGraphics {
+      /** FOV that should not be committed to fog exploration. */
+      preview: PIXI.LegacyGraphics;
+    }
+
+    /**
+     * The light part of {@link CanvasVisionContainer}.
+     * The blend mode is MAX_COLOR.
+     */
+    interface CanvasVisionContainerLight extends PIXI.LegacyGraphics {
+      /** FOV that should not be committed to fog exploration. */
+      preview: PIXI.LegacyGraphics;
+
+      /** The sprite with the texture of FOV of cached light sources. */
+      cached: SpriteMesh;
+
+      /** The light perception polygons of vision sources and the FOV of vision sources that provide vision. */
+      mask: PIXI.LegacyGraphics & { preview: PIXI.LegacyGraphics };
+    }
+
+    /**
+     * The sight part of {@link CanvasVisionContainer}.
+     * The blend mode is ERASE.
+     */
+    interface CanvasVisionContainerDarkness extends PIXI.LegacyGraphics {
+      /** Darkness source erasing fog of war. */
+      darkness: PIXI.LegacyGraphics;
+    }
+
+    /** The currently visible areas. */
+    interface CanvasVisionContainer extends PIXI.Container {
+      /** Areas visible because of light sources and light perception. */
+      light: CanvasVisionContainerLight;
+
+      /** Areas visible because of FOV of vision sources. */
+      sight: CanvasVisionContainerSight;
+
+      /** Areas erased by darkness sources. */
+      darkness: CanvasVisionContainerDarkness;
+    }
+  }
+}