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

package/src/foundry/client/pixi/webgl/shaders/base-shader-mixin.d.mts

@@ -0,0 +1,119 @@
+import type { Mixin } from "../../../../../types/utils.d.mts";
+
+declare abstract class AnyBaseShader extends BaseShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare class BaseShader {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * Useful constant values computed at compile time
+   */
+  static CONSTANTS: string;
+
+  /**
+   * Fast approximate perceived brightness computation
+   * Using Digital ITU BT.709 : Exact luminance factors
+   */
+  static PERCEIVED_BRIGHTNESS: string;
+
+  /**
+   * Convertion functions for sRGB and Linear RGB.
+   */
+  static COLOR_SPACES: string;
+
+  /**
+   * Fractional Brownian Motion for a given number of octaves
+   * @param octaves - (default: `4`)
+   * @param amp     - (default: `1.0`)
+   */
+  static FBM(octaves: number, amp: number): string;
+
+  /**
+   * High Quality Fractional Brownian Motion
+   * @param octaves - (default: `3`)
+   */
+  static FBMHQ(octaves: number): string;
+
+  /**
+   * Angular constraint working with coordinates on the range [-1, 1]
+   * =\> coord: Coordinates
+   * =\> angle: Angle in radians
+   * =\> smoothness: Smoothness of the pie
+   * =\> l: Length of the pie.
+   */
+  static PIE: string;
+
+  /**
+   * A conventional pseudo-random number generator with the "golden" numbers, based on uv position
+   */
+  static PRNG_LEGACY: string;
+
+  /**
+   * A pseudo-random number generator based on uv position which does not use cos/sin
+   * This PRNG replaces the old PRNG_LEGACY to workaround some driver bugs
+   */
+  static PRNG: string;
+
+  /**
+   * A Vec2 pseudo-random generator, based on uv position
+   */
+  static PRNG2D: string;
+
+  /**
+   * A Vec3 pseudo-random generator, based on uv position
+   */
+  static PRNG3D: string;
+
+  /**
+   * A conventional noise generator
+   */
+  static NOISE: string;
+
+  /**
+   * Convert a Hue-Saturation-Brightness color to RGB - useful to convert polar coordinates to RGB
+   */
+  static HSB2RGB: string;
+
+  /**
+   * Declare a wave function in a shader -\> wcos (default), wsin or wtan.
+   * Wave on the [v1,v2] range with amplitude -\> a and speed -\> speed.
+   * @param func - the math function to use
+   *               (default: `"cos"`)
+   */
+  static WAVE(func?: string): string;
+
+  /**
+   * Rotation function.
+   */
+  static ROTATION: string;
+
+  /**
+   * Voronoi noise function. Needs PRNG2D and CONSTANTS.
+   * @see PRNG2D
+   * @see CONSTANTS
+   */
+  static VORONOI: string;
+
+  /**
+   * Enables GLSL 1.0 backwards compatibility in GLSL 3.00 ES vertex shaders.
+   */
+  static GLSL1_COMPATIBILITY_VERTEX: string;
+
+  /**
+   * Enables GLSL 1.0 backwards compatibility in GLSL 3.00 ES fragment shaders.
+   */
+  static GLSL1_COMPATIBILITY_FRAGMENT: string;
+}
+
+declare global {
+  namespace BaseShader {
+    type AnyConstructor = typeof AnyBaseShader;
+  }
+
+  function BaseShaderMixin<BaseClass extends PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor>(
+    ShaderClass: BaseClass,
+  ): Mixin<typeof BaseShader, BaseClass>;
+}

package/src/foundry/client/pixi/webgl/shaders/base-shader.d.mts

@@ -0,0 +1,94 @@
+import type { ToMethod } from "../../../../../types/helperTypes.d.mts";
+
+declare abstract class AnyAbstractBaseShader extends AbstractBaseShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AbstractBaseShader {
+    type AnyConstructor = typeof AnyAbstractBaseShader;
+
+    type Coordinates =
+      | { x: number; y: number }
+      | { x: number; y: number; z: number }
+      | { x: number; y: number; z: number; w: number };
+
+    type UniformValue = boolean | number | Int32List | Float32List | Coordinates | Coordinates[] | PIXI.Texture;
+
+    // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+    type Uniforms = {
+      readonly [K: string]: AbstractBaseShader.UniformValue;
+    };
+
+    type FragmentShaderFunction = ToMethod<(arg0: never) => string>;
+
+    type PreRenderFunction = ToMethod<(mesh: PIXI.DisplayObject, renderer: PIXI.Renderer) => void>;
+  }
+
+  /**
+   * This class defines an interface which all shaders utilize
+   */
+  abstract class AbstractBaseShader extends BaseShaderMixin(PIXI.Shader) {
+    constructor(program: PIXI.Program, uniforms: AbstractBaseShader.Uniforms);
+
+    /**
+     * The raw vertex shader used by this class.
+     * A subclass of AbstractBaseShader must implement the vertexShader static field.
+     * @defaultValue `""`
+     */
+    static vertexShader: string;
+
+    /**
+     * The raw fragment shader used by this class.
+     * A subclass of AbstractBaseShader must implement the fragmentShader static field.
+     * @defaultValue `""`
+     */
+    static fragmentShader: string | AbstractBaseShader.FragmentShaderFunction;
+
+    /**
+     * The default uniform values for the shader.
+     * A subclass of AbstractBaseShader must implement the defaultUniforms static field.
+     * @defaultValue `{}`
+     */
+    static defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * The initial values of the shader uniforms.
+     * @remarks Set during construction
+     */
+    initialUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * A factory method for creating the shader using its defined default values
+     */
+    static create<ThisType extends AbstractBaseShader.AnyConstructor>(
+      this: ThisType,
+      initialUniforms: AbstractBaseShader.Uniforms,
+    ): InstanceType<ThisType>;
+
+    /**
+     * Reset the shader uniforms back to their initial values.
+     */
+    protected reset(): void;
+
+    /**
+     * A one time initialization performed on creation.
+     * @remarks Does nothing without subclass implementation.
+     */
+    protected _configure(): void;
+
+    /**
+     * Perform operations which are required before binding the Shader to the Renderer.
+     * @param mesh - The mesh display object linked to this shader.
+     * @param renderer - The renderer
+     */
+    protected _preRender: AbstractBaseShader.PreRenderFunction;
+
+    /**
+     * The initial default values of shader uniforms
+     * @deprecated since v12, until v14
+     * @remarks AbstractBaseShader#_defaults is deprecated in favor of AbstractBaseShader#initialUniforms.
+     */
+    protected get _defaults(): AbstractBaseShader.Uniforms;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/filters/base-filter.d.mts

@@ -0,0 +1,47 @@
+export {};
+
+declare abstract class AnyAbstractBaseFilter extends AbstractBaseFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AbstractBaseFilter {
+    type AnyConstructor = typeof AnyAbstractBaseFilter;
+  }
+
+  /**
+   * An abstract filter which provides a framework for reusable definition
+   */
+  class AbstractBaseFilter extends BaseShaderMixin(PIXI.Filter) {
+    /**
+     * The default uniforms used by the filter
+     * @defaultValue `{}`
+     */
+    static defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * The fragment shader which renders this filter.
+     * @defaultValue `undefined`
+     */
+    static fragmentShader: AbstractBaseShader.FragmentShaderFunction | string | undefined;
+
+    /**
+     * The vertex shader which renders this filter.
+     * @defaultValue `undefined`
+     */
+    static vertexShader: string | undefined;
+
+    /**
+     * A factory method for creating the filter using its defined default values.
+     * @param initialUniforms - Initial uniform values which override filter defaults
+     * @returns The constructed AbstractFilter[sic] instance.
+     */
+    static create<ThisType extends AbstractBaseFilter.AnyConstructor>(
+      this: ThisType,
+      /**
+       * @defaultValue `{}`
+       */
+      initialUniforms?: AbstractBaseShader.Uniforms,
+    ): InstanceType<ThisType>;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/filters/base-mask-filter.d.mts

@@ -0,0 +1,29 @@
+export {};
+
+declare abstract class AnyAbstractBaseMaskFilter extends AbstractBaseMaskFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AbstractBaseMaskFilter {
+    type AnyConstructor = typeof AnyAbstractBaseMaskFilter;
+  }
+
+  /**
+   * This class defines an interface for masked custom filters
+   */
+  class AbstractBaseMaskFilter extends AbstractBaseFilter {
+    /**
+     * The default vertex shader used by all instances of AbstractBaseMaskFilter
+     */
+    static vertexShader: string;
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clear: PIXI.CLEAR_MODES,
+      currentState: PIXI.FilterState,
+    ): void;
+  }
+}

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

@@ -0,0 +1,185 @@
+export {};
+
+declare abstract class AnyAlphaBlurFilterPass extends AlphaBlurFilterPass {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyAlphaBlurFilter extends AlphaBlurFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AlphaBlurFilterPass {
+    type AnyConstructor = typeof AnyAlphaBlurFilterPass;
+  }
+
+  namespace AlphaBlurFilter {
+    type AnyConstructor = typeof AnyAlphaBlurFilter;
+  }
+
+  /**
+   * 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);
+
+    blurXFilter: typeof AlphaBlurFilterPass;
+
+    blurYFilter: typeof AlphaBlurFilterPass;
+
+    _repeatEdgePixels: boolean;
+
+    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.BlurFilter
+     */
+    get blurX(): number;
+
+    set blurX(value);
+
+    /**
+     * Provided for completeness with PIXI.BlurFilter
+     */
+    get blurY(): number;
+
+    set blurY(value);
+
+    /**
+     * Provided for completeness with PIXI.BlurFilter
+     */
+    get blendMode(): number;
+
+    set blendMode(value);
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/filters/effects-masking.d.mts

@@ -0,0 +1,121 @@
+import type { AnyObject,  ShapeWithIndexSignature } from "../../../../../../types/utils.d.mts";
+
+declare abstract class AnyVisualEffectsMaskingFilter extends VisualEffectsMaskingFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace VisualEffectsMaskingFilter {
+    type AnyConstructor = typeof AnyVisualEffectsMaskingFilter;
+
+    type PostProcessModes = Array<keyof VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES>;
+
+    interface ConcreteCreateOptions {
+      postProcessModes?: PostProcessModes | undefined;
+    }
+
+    interface FILTER_MODES {
+      readonly BACKGROUND: 0;
+      readonly ILLUMINATION: 1;
+      readonly COLORATION: 2;
+    }
+
+    interface POST_PROCESS_TECHNIQUES {
+      EXPOSURE: { id: string; glsl: string };
+      CONTRAST: { id: string; glsl: string };
+      SATURATION: { id: string; glsl: string };
+    }
+  }
+
+  /**
+   * This filter handles masking and post-processing for visual effects.
+   */
+  class VisualEffectsMaskingFilter extends AbstractBaseMaskFilter {
+    static override create<ThisType extends AbstractBaseFilter.AnyConstructor, T extends AnyObject>(
+      this: ThisType,
+      {
+        postProcessModes,
+        ...initialUniforms
+      }?: ShapeWithIndexSignature<
+        T,
+        VisualEffectsMaskingFilter.ConcreteCreateOptions,
+        string,
+        AbstractBaseShader.UniformValue
+      >,
+    ): InstanceType<ThisType>;
+
+    /**
+     * Masking modes.
+     */
+    static readonly FILTER_MODES: VisualEffectsMaskingFilter.FILTER_MODES
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    tint: [1, 1, 1],
+     *    screenDimensions: [1, 1],
+     *    enableVisionMasking: true,
+     *    visionTexture: null,
+     *    darknessLevelTexture: null,
+     *    exposure: 0,
+     *    contrast: 0,
+     *    saturation: 0,
+     *    mode: 0,
+     *    ambientDarkness: [0, 0, 0],
+     *    ambientDaylight: [1, 1, 1],
+     *    replacementColor: [0, 0, 0]
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * Update the filter shader with new post-process modes.
+     * @param postProcessModes - New modes to apply.
+     * @param uniforms         - Uniforms value to update.
+     */
+    updatePostprocessModes(
+      postProcessModes?: VisualEffectsMaskingFilter.PostProcessModes,
+      uniforms?: AbstractBaseShader.Uniforms,
+    ): void;
+
+    /**
+     * Remove all post-processing modes and reset some key uniforms.
+     */
+    reset(): void;
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clear: PIXI.CLEAR_MODES,
+      currentState: PIXI.FilterState,
+    ): void;
+
+    /**
+     * Filter post-process techniques.
+     */
+    static POST_PROCESS_TECHNIQUES: VisualEffectsMaskingFilter.POST_PROCESS_TECHNIQUES;
+
+    /**
+     * Memory allocations and headers for the VisualEffectsMaskingFilter
+     */
+    static fragmentHeader: string;
+
+    static fragmentCore: string;
+
+    /**
+     * Construct filter post-processing code according to provided value.
+     * @param postProcessModes - Post-process modes to construct techniques.
+     * @returns The constructed shader code for post-process techniques.
+     */
+    static fragmentPostProcess(postProcessModes?: VisualEffectsMaskingFilter.PostProcessModes): string;
+
+    /**
+     * Specify the fragment shader to use according to mode
+     * @param postProcessModes - (default: [])
+     */
+    static override fragmentShader(postProcessModes?: VisualEffectsMaskingFilter.PostProcessModes): string;
+  }
+}

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

@@ -0,0 +1,40 @@
+export {};
+
+declare abstract class AnyPrimaryCanvasGroupAmbienceFilter extends PrimaryCanvasGroupAmbienceFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace PrimaryCanvasGroupAmbienceFilter {
+    type AnyConstructor = typeof AnyPrimaryCanvasGroupAmbienceFilter;
+  }
+
+  /**
+   * A filter used to apply color adjustments and other modifications to the environment.
+   */
+  class PrimaryCanvasGroupAmbienceFilter extends AbstractBaseMaskFilter {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    uSampler: null,
+     *    darknessLevelTexture: null,
+     *    cycle: true,
+     *    baseTint: [1, 1, 1], // Important: The base tint uniform must be in linear RGB!
+     *    baseIntensity: 0,
+     *    baseLuminosity: 0,
+     *    baseSaturation: 0,
+     *    baseShadows: 0,
+     *    darkTint: [1, 1, 1], // Important: The dark tint uniform must be in linear RGB!
+     *    darkIntensity: 0,
+     *    darkLuminosity: 0,
+     *    darkSaturation: 0,
+     *    darkShadows: 0
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+}