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

package/src/foundry/client/pixi/layers/effects/coloration-effects.d.mts

@@ -0,0 +1,27 @@
+export {};
+
+declare global {
+  /**
+   * A CanvasLayer for displaying coloration visual effects
+   */
+  class CanvasColorationEffects extends CanvasLayer {
+    /**
+     * @defaultValue `true`
+     */
+    override sortableChildren: boolean;
+
+    /**
+     * The filter used to mask visual effects on this layer
+     */
+    filter: VisualEffectsMaskingFilter;
+
+    /**
+     * Clear coloration effects container
+     */
+    clear(): void;
+
+    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    protected override _tearDown(options?: Record<string, unknown>): Promise<void>;
+  }
+}

package/src/foundry/client/pixi/layers/effects/illumination-effects.d.mts

@@ -0,0 +1,74 @@
+export {};
+
+declare global {
+  /**
+   * A CanvasLayer for displaying illumination visual effects
+   */
+  class CanvasIlluminationEffects extends CanvasLayer {
+    /**
+     * A minimalist texture that holds the background color.
+     */
+    backgroundColorTexture: PIXI.Texture;
+
+    background: PIXI.LegacyGraphics;
+
+    /**
+     * @defaultValue `lights.sortableChildren = true`
+     */
+    lights: PIXI.Container;
+
+    /**
+     * Is global illumination currently applied to the canvas?
+     */
+    get globalLight(): boolean;
+
+    /**
+     * The filter used to mask visual effects on this layer
+     */
+    filter: VisualEffectsMaskingFilter;
+
+    /**
+     * Set or retrieve the illumination background color.
+     */
+    set backgroundColor(color: number);
+
+    /**
+     * Clear illumination effects container
+     */
+    clear(): void;
+
+    /**
+     * Create the background color texture used by illumination point source meshes.
+     * 1x1 single pixel texture.
+     * @returns The background color texture.
+     * @defaultValue
+     * ```js
+     * PIXI.Texture.fromBuffer(new Float32Array(3), 1, 1, {
+     *      type: PIXI.TYPES.FLOAT,
+     *      format: PIXI.FORMATS.RGB,
+     *      wrapMode: PIXI.WRAP_MODES.CLAMP,
+     *      scaleMode: PIXI.SCALE_MODES.NEAREST,
+     *      mipmap: PIXI.MIPMAP_MODES.OFF
+     * })
+     * ```
+     */
+    protected _createBackgroundColorTexture(): PIXI.Texture;
+
+    override render(renderer: PIXI.Renderer): void;
+
+    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    protected override _tearDown(options?: Record<string, unknown>): Promise<void>;
+
+    /**
+     * Draw illumination baseline
+     */
+    drawBaseline(): void;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks "CanvasIlluminationEffects#updateGlobalLight has been deprecated."
+     */
+    updateGlobalLight(): false;
+  }
+}

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

@@ -0,0 +1,6 @@
+import "./background-effects.d.mts";
+import "./coloration-effects.d.mts";
+import "./illumination-effects.d.mts";
+import "./visibility.d.mts";
+import "./weather-effects.d.mts";
+import "./weather/particles/index.d.mts";

package/src/foundry/client/pixi/layers/effects/visibility.d.mts

@@ -0,0 +1,194 @@
+import type { InexactPartial, ValueOf } from "../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The visibility Layer which implements dynamic vision, lighting, and fog of war
+   * This layer uses an event-driven workflow to perform the minimal required calculation in response to changes.
+   * @see {@link PointSource}
+   */
+  class CanvasVisibility extends CanvasLayer {
+
+    /**
+     * The currently revealed vision.
+     */
+    vision: CanvasVisionContainer;
+
+    /**
+     * The exploration container which tracks exploration progress.
+     */
+    explored: PIXI.Container;
+
+    /**
+     * The optional visibility overlay sprite that should be drawn instead of the unexplored color in the fog of war.
+     */
+    visibilityOverlay: PIXI.Sprite;
+
+    /**
+     * The active vision source data object
+     * @defaultValue
+     * ```js
+     * {
+     *    source: undefined,
+     *    activeLightingOptions: {}
+     * }
+     * ```
+     */
+    visionModeData: { source: foundry.canvas.sources.PointVisionSource.Any | null; activeLightingOptions: Record<string, unknown> };
+
+    /**
+     * Define whether each lighting layer is enabled, required, or disabled by this vision mode.
+     * The value for each lighting channel is a number in LIGHTING_VISIBILITY
+     * ```js
+     * {
+     *   background: VisionMode.LIGHTING_VISIBILITY.ENABLED,
+     *    illumination: VisionMode.LIGHTING_VISIBILITY.ENABLED,
+     *    coloration: VisionMode.LIGHTING_VISIBILITY.ENABLED,
+     *    darkness: VisionMode.LIGHTING_VISIBILITY.ENABLED,
+     *    any: true
+     * }
+     * ```
+     */
+    lightingVisibility: {
+      illumination: CanvasVisibility.LightingVisibility;
+      background: CanvasVisibility.LightingVisibility;
+      coloration: CanvasVisibility.LightingVisibility;
+      darkness: CanvasVisibility.LightingVisibility;
+      any: boolean;
+    };
+
+    /**
+     * A status flag for whether the layer initialization workflow has succeeded.
+     */
+    get initialized(): boolean;
+
+    /**
+     * Indicates whether containment filtering is required when rendering vision into a texture
+     */
+    protected get needsContainment(): boolean;
+
+    /**
+     * Does the currently viewed Scene support Token field of vision?
+     */
+    get tokenVision(): boolean;
+
+    /**
+     * The configured options used for the saved fog-of-war texture.
+     */
+    get textureConfiguration(): FogTextureConfiguration;
+
+    /**
+     * Optional overrides for exploration sprite dimensions.
+     */
+    set explorationRect(rect: FogTextureConfiguration);
+
+    /**
+     * Initialize all Token vision sources which are present on this layer
+     */
+    initializeSources(): void;
+
+    /**
+     * Initialize the vision mode.
+     */
+    initializeVisionMode(): void;
+
+    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    protected override _tearDown(options?: Record<string, unknown>): Promise<void>;
+
+    /**
+     * Update the display of the sight layer.
+     * Organize sources into rendering queues and draw lighting containers for each source
+     */
+    refresh(): void;
+
+    /**
+     * Update vision (and fog if necessary)
+     */
+    refreshVisibility(): void;
+
+    /**
+     * Reset the exploration container with the fog sprite
+     */
+    resetExploration(): void;
+
+    /**
+     * Restrict the visibility of certain canvas assets (like Tokens or DoorControls) based on the visibility polygon
+     * These assets should only be displayed if they are visible given the current player's field of view
+     */
+    restrictVisibility(): void;
+
+    /**
+     * Test whether a target point on the Canvas is visible based on the current vision and LOS polygons.
+     * @param point   - The point in space to test, an object with coordinates x and y.
+     * @param options - Additional options which modify visibility testing.
+     * @returns Whether the point is currently visible.
+     */
+    testVisibility(
+      point: Point,
+      options?: InexactPartial<{
+        /**
+         * A numeric radial offset which allows for a non-exact match.
+         * For example, if tolerance is 2 then the test will pass if the point
+         * is within 2px of a vision polygon.
+         */
+        tolerance: number;
+
+        /**
+         * An optional reference to the object whose visibility is being tested
+         */
+        object: PlaceableObject | null;
+      }>,
+    ): boolean;
+
+    /**
+     * Create the visibility test config.
+     * @param point   - The point in space to test, an object with coordinates x and y.
+     * @param options - Additional options which modify visibility testing.
+     */
+    _createVisibilityTestConfig(point: Point, options?: InexactPartial<{
+      /**
+       * A numeric radial offset which allows for a non-exact match.
+       * For example, if tolerance is 2 then the test will pass if the point
+       * is within 2px of a vision polygon
+       * @defaultValue `2`
+       */
+      tolerance: number;
+
+      /**
+       * An optional reference to the object whose visibility is being tested
+       */
+      object: PlaceableObject | null;
+    }>): CanvasVisibilityTestConfig;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks `"fogOverlay is deprecated in favor of visibilityOverlay"`
+     */
+    get fogOverlay(): this["visibilityOverlay"];
+  }
+
+  namespace CanvasVisibility {
+    type LightingVisibility = ValueOf<typeof VisionMode.LIGHTING_VISIBILITY>;
+  }
+
+  interface FogTextureConfiguration {
+    resolution: number;
+    width: number;
+    height: number;
+    mipmap: PIXI.MIPMAP_MODES;
+    multisample: PIXI.MSAA_QUALITY;
+    scaleMode: PIXI.SCALE_MODES;
+    alphaMode: PIXI.ALPHA_MODES;
+    format: PIXI.FORMATS;
+  }
+
+  interface CanvasVisibilityTest {
+    point: PIXI.Point;
+    los: Map<foundry.canvas.sources.PointVisionSource.Any, boolean>;
+  }
+
+  interface CanvasVisibilityTestConfig {
+    object: PlaceableObject | null;
+    tests: CanvasVisibilityTest[];
+  }
+}

package/src/foundry/client/pixi/layers/effects/weather/particles/effect.d.mts

@@ -0,0 +1,47 @@
+export {};
+
+declare global {
+  /**
+   * An interface for defining particle-based weather effects
+   */
+  class ParticleEffect extends FullCanvasObjectMixin(PIXI.Container) {
+    /**
+     * @param options - Options passed to the getParticleEmitters method which can be used to customize values of the emitter configuration.
+     *                  (default: `{}`)
+     */
+    constructor(options?: Record<string, unknown>);
+
+    parent: PIXI.Container;
+
+    emitters: PIXI.particles.Emitter[];
+
+    /**
+     * Create an emitter instance which automatically updates using the shared PIXI.Ticker
+     * @param config - The emitter configuration
+     * @returns The created Emitter instance
+     */
+    createEmitter(config: PIXI.particles.EmitterConfigV3): PIXI.particles.Emitter;
+
+    /**
+     * Get the particle emitters which should be active for this particle effect.
+     * @param options - Options provided to the ParticleEffect constructor which can be used to customize
+     *                  configuration values for created emitters. (default: `{}`)
+     */
+    getParticleEmitters(options?: Record<string, unknown>): PIXI.particles.Emitter[];
+
+    override destroy(options?: boolean | PIXI.IDestroyOptions): void;
+
+    /**
+     * Begin animation for the configured emitters.
+     */
+    play(): void;
+
+    /**
+     * Stop animation for the configured emitters.
+     */
+    stop(): void;
+  }
+
+  /** @deprecated since v10 */
+  class SpecialEffect extends ParticleEffect {}
+}

package/src/foundry/client/pixi/layers/effects/weather/particles/index.d.mts

@@ -0,0 +1,2 @@
+import "./effect.d.mts";
+import "./leaves.d.mts";

package/src/foundry/client/pixi/layers/effects/weather/particles/leaves.d.mts

@@ -0,0 +1,20 @@
+export {};
+
+declare global {
+  /**
+   * A full-screen weather effect which renders gently falling autumn leaves.
+   */
+  class AutumnLeavesWeatherEffect extends ParticleEffect {
+    /**
+     * @defaultValue `"WEATHER.AutumnLeaves"`
+     */
+    static label: string;
+
+    /**
+     * Configuration for the particle emitter for falling leaves
+     */
+    static LEAF_CONFIG: PIXI.particles.EmitterConfigV3;
+
+    override getParticleEmitters(): PIXI.particles.Emitter[];
+  }
+}

package/src/foundry/client/pixi/layers/effects/weather-effects.d.mts

@@ -0,0 +1,172 @@
+export {};
+
+declare global {
+  /**
+   * A CanvasLayer for displaying visual effects like weather, transitions, flashes, or more
+   */
+  class WeatherEffects extends FullCanvasObjectMixin(CanvasLayer) {
+    /**
+     * @privateRemarks This is not overridden in foundry but reflects the real behavior.
+     */
+    static get instance(): Canvas["effects"];
+
+    /**
+     * @defaultValue `true`
+     */
+    override sortableChildren: boolean;
+
+    /**
+     * @defaultValue `"none"`
+     */
+    override eventMode: PIXI.EventMode;
+
+    /**
+     * Sorting values to deal with ties.
+     * @defaultValue `1000`
+     */
+    static PRIMARY_SORT_ORDER: number;
+
+    /**
+     * @defaultValue `foundry.utils.mergeObject(super.layerOptions, { name: "effects" })`
+     */
+    static override get layerOptions(): WeatherLayer.LayerOptions;
+
+    override options: WeatherLayer.LayerOptions;
+
+    /**
+     * Array of weather effects linked to this weather container.
+     */
+    effects: Map<string, Array<ParticleEffect | WeatherShaderEffect>>;
+
+    /**
+     * A default configuration of the terrain mask that is automatically applied to any shader-based weather effects.
+     * This configuration is automatically passed to WeatherShaderEffect#configureTerrainMask upon construction.
+     */
+    terrainMaskConfig: WeatherLayer.WeatherTerrainMaskConfiguration;
+
+    /**
+     * A default configuration of the terrain mask that is automatically applied to any shader-based weather effects.
+     * This configuration is automatically passed to WeatherShaderEffect#configureTerrainMask upon construction.
+     */
+    occlusionMaskConfig: WeatherLayer.WeatherOcclusionMaskConfiguration;
+
+    /**
+     * The inverse occlusion mask filter bound to this container.
+     */
+    occlusionFilter: WeatherOcclusionMaskFilter;
+
+    /**
+     * Define an elevation property on the WeatherEffects layer.
+     * This approach is used for now until the weather elevation property is formally added to the Scene data schema.
+     */
+    get elevation(): number;
+
+    set elevation(value);
+
+    protected override _draw(options?: Record<string, unknown>): Promise<void>;
+
+    protected override _tearDown(options?: Record<string, unknown>): Promise<void>;
+
+    /**
+     * Initialize the weather container from a weather config object.
+     * @param weatherEffectsConfig - Weather config object (or null/undefined to clear the container).
+     */
+    initializeEffects(weatherEffectsConfig?: WeatherLayer.WeatherEffectsConfig | null): void;
+
+    /**
+     * Clear the weather container.
+     */
+    clearEffects(): void;
+
+    /**
+     * Set the occlusion uniforms for this weather shader.
+     * @param context - The shader context
+     * @param config  - Occlusion masking options
+     */
+    protected static configureOcclusionMask(
+      context: PIXI.Shader,
+      config: WeatherLayer.WeatherOcclusionMaskConfiguration,
+    ): void;
+
+    /**
+     * Set the terrain uniforms for this weather shader.
+     * @param context - The shader context
+     * @param config  - Terrain masking options
+     */
+    protected static configureTerrainMask(
+      context: PIXI.Shader,
+      config: WeatherLayer.WeatherTerrainMaskConfiguration,
+    ): void;
+
+    /**
+     * @deprecated since v11, will be removed in v13
+     * @remarks `"The WeatherContainer at canvas.weather.weather is deprecated and combined with the layer itself."`
+     */
+    get weather(): this;
+  }
+
+  namespace WeatherLayer {
+    interface LayerOptions extends CanvasLayer.LayerOptions {
+      name: "effects";
+    }
+
+    interface WeatherTerrainMaskConfiguration {
+      /**
+       * Enable or disable this mask.
+       * @defaultValue `false`
+       */
+      enabled: boolean;
+
+      /**
+       * An RGBA array of channel weights applied to the mask texture.
+       * @defaultValue `[1, 0, 0, 0]`
+       */
+      channelWeights: [r: number, b: number, g: number, a: number];
+
+      /**
+       * If the mask should be reversed.
+       * @defaultValue `false`
+       */
+      reverse: boolean;
+
+      /**
+       * A texture which defines the mask region.
+       */
+      texture: PIXI.Texture | PIXI.RenderTexture;
+    }
+
+    interface WeatherOcclusionMaskConfiguration {
+      /**
+       * Enable or disable this mask.
+       * @defaultValue `false`
+       */
+      enabled: boolean;
+
+      /**
+       * An RGBA array of channel weights applied to the mask texture.
+       * @defaultValue `[0, 0, 1, 0]`
+       */
+      channelWeights: [r: number, b: number, g: number, a: number];
+
+      /**
+       * If the mask should be reversed.
+       * @defaultValue `false`
+       */
+      reverse: boolean;
+
+      /**
+       * A texture which defines the mask region.
+       */
+      texture: PIXI.Texture | PIXI.RenderTexture;
+    }
+
+    /**
+     * @privateRemarks types inferred from usage
+     */
+    interface WeatherEffectsConfig {
+      effects: WeatherEffects[];
+
+      filter: PIXI.Filter;
+    }
+  }
+}

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

@@ -0,0 +1,32 @@
+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;
+
+    override destroy(...args: Parameters<PIXI.Graphics["destroy"]>): void;
+  }
+}

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

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