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

package/src/foundry/client/pixi/webgl/shaders/effects/vision.d.mts

@@ -0,0 +1,216 @@
+export {};
+
+declare global {
+  /**
+   * This class defines an interface which all adaptive vision shaders extend.
+   */
+  class AdaptiveVisionShader extends AdaptiveLightingShader {
+    static override EXPOSURE: string;
+
+    static override SHADOW: string;
+
+    static override FALLOFF: string;
+
+    static override FRAGMENT_BEGIN: string;
+
+    /**
+     * A mapping of available shader techniques
+     */
+    static override SHADER_TECHNIQUES: AdaptiveLightingShader.ShaderTechniques;
+  }
+
+  /**
+   * The default background shader used for vision sources
+   */
+  class BackgroundVisionShader extends AdaptiveVisionShader {
+    static override FRAGMENT_END: string;
+
+    static override FALLOFF: string;
+
+    /**
+     * Memory allocations for the Adaptive Background Shader
+     */
+    static SHADER_HEADER: string;
+
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    technique: 0,
+     *    saturation: 0,
+     *    contrast: 0,
+     *    attenuation: 0.10,
+     *    exposure: 0,
+     *    darknessLevel: 0,
+     *    colorVision: [1, 1, 1],
+     *    colorTint: [1, 1, 1],
+     *    colorBackground: [1, 1, 1],
+     *    screenDimensions: [1, 1],
+     *    time: 0,
+     *    useSampler: true,
+     *    linkedToDarknessLevel: true,
+     *    primaryTexture: null,
+     *    depthTexture: null,
+     *    depthElevation: 1
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * Flag whether the background shader is currently required.
+     * If key uniforms are at their default values, we don't need to render the background container.
+     */
+    get isRequired(): boolean;
+  }
+
+  /**
+   * The default illumination shader used for vision sources
+   */
+  class IlluminationVisionShader extends AdaptiveVisionShader {
+    static override FRAGMENT_BEGIN: string;
+
+    static override FRAGMENT_END: string;
+
+    static override FALLOFF: string;
+
+    /**
+     * Transition between bright and dim colors, if requested
+     */
+    static VISION_COLOR: string;
+
+    static get ADJUSTMENTS(): string;
+
+    /**
+     * Memory allocations for the Adaptive Illumination Shader
+     */
+    static SHADER_HEADER: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    const initial = foundry.data.LightData.cleanData();
+     *    return {
+     *      technique: initial.technique,
+     *      attenuation: 0,
+     *      exposure: 0,
+     *      saturation: 0,
+     *      darknessLevel: 0,
+     *      colorVision: [1, 1, 1],
+     *      colorTint: [1, 1, 1],
+     *      colorBackground: [1, 1, 1],
+     *      screenDimensions: [1, 1],
+     *      time: 0,
+     *      useSampler: false,
+     *      linkedToDarknessLevel: true,
+     *      primaryTexture: null,
+     *      framebufferTexture: null,
+     *      depthTexture: null,
+     *      depthElevation: 1
+     *    };
+     *  }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+
+  /**
+   * The default coloration shader used for vision sources.
+   */
+  class ColorationVisionShader extends AdaptiveVisionShader {
+    static override FRAGMENT_END: string;
+
+    static override EXPOSURE: string;
+
+    static override CONTRAST: string;
+
+    static override FALLOFF: string;
+
+    /**
+     * Memory allocations for the Adaptive Coloration Shader
+     */
+    static SHADER_HEADER: string;
+
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *      technique: 0,
+     *      saturation: 0,
+     *      attenuation: 0,
+     *      colorEffect: [0, 0, 0],
+     *      colorBackground: [0, 0, 0],
+     *      colorTint: [1, 1, 1],
+     *      time: 0,
+     *      screenDimensions: [1, 1],
+     *      useSampler: true,
+     *      primaryTexture: null,
+     *      linkedToDarknessLevel: true,
+     *      depthTexture: null,
+     *      depthElevation: 1
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * Flag whether the coloration shader is currently required.
+     * If key uniforms are at their default values, we don't need to render the coloration container.
+     */
+    get isRequired(): boolean;
+  }
+
+  /**
+   * Shader specialized in wave like senses (tremorsenses)
+   */
+  class WaveBackgroundVisionShader extends BackgroundVisionShader {
+    static override FRAGMENT_END: string;
+
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {...super.defaultUniforms, colorTint: [0.8, 0.1, 0.8]}
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    override get isRequired(): boolean;
+  }
+
+  /**
+   * The wave vision shader, used to create waves emanations (ex: tremorsense)
+   */
+  class WaveColorationVisionShader extends ColorationVisionShader {
+    static override fragmentShader: string;
+
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    override get isRequired(): boolean;
+  }
+
+  /**
+   * Shader specialized in light amplification
+   */
+  class AmplificationBackgroundVisionShader extends BackgroundVisionShader {
+    static override FRAGMENT_END: string;
+
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {...super.defaultUniforms, colorTint: [0.38, 0.8, 0.38], brightness: 0.5}
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    override get isRequired(): boolean;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/effects/weather/base.d.mts

@@ -0,0 +1,102 @@
+import type { ConstructorOf } from "../../../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * The base shader class for weather shaders.
+   */
+  class AbstractWeatherShader extends AbstractBaseShader {
+    /**
+     * Compute the weather masking value.
+     */
+    static COMPUTE_MASK: string;
+
+    /**
+     * Compute the weather masking value.
+     */
+    static FRAGMENT_HEADER: string;
+
+    /**
+     * Common uniforms for all weather shaders.
+     * @defaultValue
+     * ```js
+     * {
+     *    useOcclusion: false,
+     *    occlusionTexture: null,
+     *    reverseOcclusion: false,
+     *    occlusionWeights: [0, 0, 1, 0],
+     *    useTerrain: false,
+     *    terrainTexture: null,
+     *    reverseTerrain: false,
+     *    terrainWeights: [1, 0, 0, 0],
+     *    alpha: 1,
+     *    tint: [1, 1, 1],
+     *    screenDimensions: [1, 1],
+     *    effectDimensions: [1, 1],
+     *    depthElevation: 1,
+     *    time: 0
+     * }
+     * ```
+     */
+    static commonUniforms: AbstractWeatherShader.commonUniforms;
+
+    /**
+     * Default uniforms for a specific class
+     * @remarks No default value, marked as abstract
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override create<T extends AbstractWeatherShader>(
+      this: ConstructorOf<T>,
+      initialUniforms?: AbstractBaseShader.Uniforms,
+    ): T;
+
+    /**
+     * Create the shader program.
+     */
+    static createProgram(): PIXI.Program;
+
+    static override vertexShader: string;
+
+    /**
+     * Update the scale of this effect with new values
+     * @param scale - The desired scale
+     */
+    set scale(scale: number | { x: number; y: number });
+
+    set scaleX(x: number);
+
+    set scaleY(y: number);
+
+    /**
+     * The speed multiplier applied to animation.
+     * 0 stops animation.
+     * @defaultValue `1`
+     */
+    speed: number;
+
+    /**
+     * Perform operations which are required before binding the Shader to the Renderer.
+     * @param mesh - The mesh linked to this shader.
+     */
+    protected _preRender(mesh: QuadMesh): void;
+  }
+
+  namespace AbstractWeatherShader {
+    interface commonUniforms {
+      useOcclusion: boolean;
+      occlusionTexture: PIXI.Texture | null;
+      reverseOcclusion: boolean;
+      occlusionWeights: number[];
+      useTerrain: boolean;
+      terrainTexture: PIXI.Texture | null;
+      reverseTerrain: boolean;
+      terrainWeights: number[];
+      alpha: number;
+      tint: number[];
+      screenDimensions: [number, number];
+      effectDimensions: [number, number];
+      depthElevation: number;
+      time: number;
+    }
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/effects/weather/effect.d.mts

@@ -0,0 +1,38 @@
+import type { InexactPartial } from "../../../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * An interface for defining shader-based weather effects
+   */
+  class WeatherShaderEffect extends QuadMesh {
+    /**
+     * @param config - The config object to create the shader effect
+     */
+    constructor(config: WeatherShaderEffect.WeatherShaderEffectConfig, shaderClass: typeof AbstractBaseShader);
+
+    /**
+     * Set shader parameters.
+     */
+    configure(config?: WeatherShaderEffect.WeatherShaderEffectConfig): void;
+
+    /**
+     * Begin animation
+     */
+    play(): void;
+
+    /**
+     * Stop animation
+     */
+    stop(): void;
+
+    /**
+     * Initialize the weather effect.
+     * @param config - Config object.
+     */
+    protected _initialize(config: WeatherShaderEffect.WeatherShaderEffectConfig): void;
+  }
+
+  namespace WeatherShaderEffect {
+    type WeatherShaderEffectConfig = InexactPartial<AbstractBaseShader.Uniforms & WeatherShaderEffect["shader"]>;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/effects/weather/fog.d.mts

@@ -0,0 +1,34 @@
+export {};
+
+declare global {
+  /**
+   * Fog shader effect.
+   */
+  class FogShader extends AbstractWeatherShader {
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    intensity: 1,
+     *    rotation: 0,
+     *    slope: 0.25
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * Configure the number of octaves into the shaders.
+     */
+    static OCTAVES(mode: number): string;
+
+    /**
+     * Configure the fog complexity according to mode (performance).
+     */
+    static FOG(mode: number): string;
+
+    static override createProgram(): PIXI.Program;
+
+    static override fragmentShader(mode: number): string;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/effects/weather/index.d.mts

@@ -0,0 +1,5 @@
+import "./base.d.mts";
+import "./effect.d.mts";
+import "./fog.d.mts";
+import "./rain.d.mts";
+import "./snow.d.mts";

package/src/foundry/client/pixi/webgl/shaders/effects/weather/rain.d.mts

@@ -0,0 +1,24 @@
+export {};
+
+declare global {
+  /**
+   * Rain shader effect.
+   */
+  class RainShader extends AbstractWeatherShader {
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    opacity: 1,
+     *    intensity: 1,
+     *    strength: 1,
+     *    rotation: 0.5,
+     *    resolution: [3200, 80] // The resolution to have nice rain ropes with the voronoi cells
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override fragmentShader: string;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/effects/weather/snow.d.mts

@@ -0,0 +1,20 @@
+export {};
+
+declare global {
+  /**
+   * Snow shader effect.
+   */
+  class SnowShader extends AbstractWeatherShader {
+    /**
+     * @defaultValue
+     * ```
+     * {
+     *  direction: 1.2
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override fragmentShader: string;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/filters/blur.d.mts

@@ -0,0 +1,163 @@
+export {};
+
+declare global {
+  /**
+   * Apply a vertical or horizontal gaussian blur going inward by using alpha as the penetrating channel.
+   */
+  class AlphaBlurFilterPass extends PIXI.Filter {
+    /**
+     * @param horizontal - If the pass is horizontal (true) or vertical (false).
+     * @param strength   - Strength of the blur (distance of sampling).
+     *                     (default: `8`)
+     * @param quality    - Number of passes to generate the blur. More passes = Higher quality = Lower Perf.
+     *                     (default: `4`)
+     * @param resolution - Resolution of the filter.
+     *                     (default: PIXI.Filter.defaultResolution)
+     * @param kernelSize - Number of kernels to use. More kernels = Higher quality = Lower Perf.
+     *                     (default: `5`)
+     */
+    constructor(horizontal: boolean, strength?: number, quality?: number, resolution?: number, kernelSize?: number);
+
+    /**
+     * If the pass is horizontal (true) or vertical (false).
+     */
+    horizontal: boolean;
+
+    /**
+     * Strength of the blur (distance of sampling).
+     */
+    strength: number;
+
+    /**
+     * The number of passes to generate the blur.
+     */
+    passes: number;
+
+    /**
+     * The quality of the filter is defined by its number of passes.
+     */
+    get quality(): number;
+
+    set quality(value);
+
+    /**
+     * The strength of the blur filter in pixels.
+     */
+    get blur(): number;
+
+    set blur(value);
+
+    /**
+     * The kernels containing the gaussian constants.
+     */
+    static GAUSSIAN_VALUES: Record<number, number>;
+
+    /**
+     * The fragment template generator
+     * @param kernelSize - The number of kernels to use.
+     * @returns The generated fragment shader.
+     */
+    static fragTemplate(kernelSize: number): string;
+
+    /**
+     * The vertex template generator
+     * @param kernelSize - The number of kernels to use.
+     * @param horizontal - If the vertex should handle horizontal or vertical pass.
+     * @returns The generated vertex shader.
+     */
+    static vertTemplate(kernelSize: number, horizontal: boolean): string;
+
+    /**
+     * Generating the dynamic part of the blur in the fragment
+     * @param kernelSize - The number of kernels to use.
+     * @returns The dynamic blur part.
+     */
+    static generateBlurFragSource(kernelSize: number): string;
+
+    /**
+     * Generating the dynamic part of the blur in the vertex
+     * @param kernelSize - number of kernels to use.
+     * @param horizontal - If the vertex should handle horizontal or vertical pass.
+     * @returns The dynamic blur part.
+     */
+    static generateBlurVertSource(kernelSize: number, horizontal: boolean): string;
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clearMode?: PIXI.CLEAR_MODES,
+    ): void;
+  }
+
+  /**
+   * Apply a gaussian blur going inward by using alpha as the penetrating channel.
+   */
+  class AlphaBlurFilter extends PIXI.Filter {
+    /**
+     * @param strength   - Strength of the blur (distance of sampling).
+     *                     (default: `8`)
+     * @param quality    - Number of passes to generate the blur. More passes = Higher quality = Lower Perf.
+     *                     (default: `4`)
+     * @param resolution - Resolution of the filter.
+     *                     (default: PIXI.Filter.defaultResolution)
+     * @param kernelSize - Number of kernels to use. More kernels = Higher quality = Lower Perf.
+     *                     (default: `5`)
+     */
+    constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number);
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clearMode?: PIXI.CLEAR_MODES,
+    ): void;
+
+    /**
+     * Update the filter padding according to the blur strength value (0 if _repeatEdgePixels is active)
+     */
+    updatePadding(): void;
+
+    /**
+     * The amount of blur is forwarded to the X and Y filters.
+     */
+    get blur(): number;
+
+    set blur(value);
+
+    /**
+     * The quality of blur defines the number of passes used by subsidiary filters.
+     */
+    get quality(): number;
+
+    set quality(value);
+
+    /**
+     * Whether to repeat edge pixels, adding padding to the filter area.
+     */
+    get repeatEdgePixels(): boolean;
+
+    set repeatEdgePixels(value);
+
+    /**
+     * Provided for completeness with PIXI.filters.BlurFilter
+     */
+    get blurX(): number;
+
+    set blurX(value);
+
+    /**
+     * Provided for completeness with PIXI.filters.BlurFilter
+     */
+    get blurY(): number;
+
+    set blurY(value);
+
+    /**
+     * Provided for completeness with PIXI.filters.BlurFilter
+     */
+    get blendMode(): number;
+
+    set blendMode(value);
+  }
+}