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

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

@@ -0,0 +1,462 @@
+import type { ConstructorOf, ValueOf } from "../../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * This class defines an interface for masked custom filters
+   */
+  class AbstractBaseMaskFilter extends AbstractBaseFilter {
+    static create(uniforms?: AbstractBaseShader.Uniforms): AbstractBaseMaskFilter;
+
+    /**
+     * 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;
+  }
+
+  /**
+   * A filter used to control channels intensity using an externally provided mask texture.
+   * The mask channel used must be provided at filter creation.
+   * Contributed by SecretFire#4843
+   */
+  class InverseOcclusionMaskFilter extends AbstractBaseMaskFilter {
+    static create<T extends InverseOcclusionMaskFilter>(
+      this: ConstructorOf<T>,
+      uniforms?: AbstractBaseShader.Uniforms,
+    ): T;
+
+    static adaptiveFragmentShader(channel: "r" | "g" | "b"): string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *  uMaskSampler: null,
+     *  alphaOcclusion: 0,
+     *  alpha: 1,
+     *  depthElevation: 0
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+
+  /**
+   * A filter used to apply a reverse mask on the target display object.
+   * The caller must choose a channel to use (alpha is a good candidate).
+   */
+  class ReverseMaskFilter extends AdaptiveFragmentChannelMixin(AbstractBaseMaskFilter) {
+    static override adaptiveFragmentShader(channel: "r" | "g" | "b"): string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * { uMaskSampler: null }
+     * ```
+     */
+    static defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+
+  /**
+   * A minimalist filter (just used for blending)
+   */
+  class VoidFilter extends AbstractBaseFilter {
+    static create<T extends VoidFilter>(this: ConstructorOf<T>, uniforms?: AbstractBaseShader.Uniforms): T;
+
+    static override fragmentShader: string;
+  }
+
+  namespace VisualEffectsMaskingFilter {
+    type PostProcessModes = Array<keyof (typeof VisualEffectsMaskingFilter)["POST_PROCESS_TECHNIQUES"]>;
+
+    type FilterMode = ValueOf<(typeof VisualEffectsMaskingFilter)["FILTER_MODES"]>;
+
+    /**
+     * @privateRemarks Implementation taken from https://stackoverflow.com/a/61434547
+     */
+    // TODO: Replace when https://github.com/microsoft/TypeScript/issues/17867 is resolved
+    type CreateOptionsIntersection = {
+      filterMode?: FilterMode;
+      postProcessModes?: PostProcessModes;
+    } & AbstractBaseShader.Uniforms;
+
+    type CreateOptions<T> = {
+      filterMode?: FilterMode;
+      postProcessModes?: PostProcessModes;
+    } & {
+      [K in keyof T]: K extends "filterMode" | "postProcessModes" ? unknown : AbstractBaseShader.UniformValue;
+    };
+  }
+
+  /**
+   * This filter handles masking and post-processing for visual effects.
+   */
+  class VisualEffectsMaskingFilter extends AbstractBaseMaskFilter {
+    constructor(
+      vertex: string,
+      fragment: string,
+      uniforms: AbstractBaseShader.Uniforms,
+      filterMode: VisualEffectsMaskingFilter.FilterMode,
+    );
+
+    /**
+     * @remarks This method has been overloaded to accurately type the object input.
+     * The input cannot be separately typed, it must be fed directly into this method
+     */
+    // TODO: Replace when https://github.com/microsoft/TypeScript/issues/17867 is resolved
+    static create<T1 extends VisualEffectsMaskingFilter, T2 extends VisualEffectsMaskingFilter.CreateOptions<T2>>(
+      this: ConstructorOf<T1>,
+      { filterMode, postProcessModes, ...uniforms }?: T2,
+    ): T1;
+    static create<T extends VisualEffectsMaskingFilter>(
+      this: ConstructorOf<T>,
+      { filterMode, postProcessModes, ...uniforms }?: VisualEffectsMaskingFilter.CreateOptionsIntersection,
+    ): T;
+
+    /**
+     * The filter mode.
+     */
+    filterMode: VisualEffectsMaskingFilter.FilterMode;
+
+    /**
+     * 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;
+
+    /**
+     * Masking modes.
+     */
+    static readonly FILTER_MODES: {
+      BACKGROUND: "background";
+      ILLUMINATION: "illumination";
+      COLORATION: "coloration";
+    };
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    replacementColor: [0, 0, 0],
+     *    tint: [1, 1, 1],
+     *    screenDimensions: [1, 1],
+     *    enableVisionMasking: true,
+     *    uVisionSampler: null,
+     *    exposure: 0,
+     *    contrast: 0,
+     *    saturation: 0
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * Filter post-process techniques.
+     */
+    static readonly POST_PROCESS_TECHNIQUES: {
+      EXPOSURE: { id: "EXPOSURE"; glsl: string };
+      CONTRAST: { id: "CONTRAST"; glsl: string };
+      SATURATION: { id: "SATURATION"; glsl: string };
+    };
+
+    /**
+     * Assign the replacement color according to the filter mode.
+     * @param filterMode - Filter mode.
+     * @returns The replacement color.
+     */
+    static replacementColor(filterMode: VisualEffectsMaskingFilter.FilterMode): string;
+
+    /**
+     * Memory allocations and headers for the VisualEffectsMaskingFilter
+     * @param filterMode - Filter mode.
+     * @returns The filter header according to the filter mode.
+     */
+    static fragmentHeader(filterMode: VisualEffectsMaskingFilter.FilterMode): 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 filterMode - (default: this.FILTER_MODES.BACKGROUND)
+     * @param postProcessModes - (default: [])
+     * @override
+     */
+    static fragmentShader(
+      filterMode?: VisualEffectsMaskingFilter.FilterMode,
+      postProcessModes?: VisualEffectsMaskingFilter.PostProcessModes,
+    ): string;
+  }
+
+  /**
+   * Apply visibility coloration according to the baseLine color.
+   * Uses very lightweight gaussian vertical and horizontal blur filter passes.
+   */
+  class VisibilityFilter extends AbstractBaseMaskFilter {
+    constructor(...args: ConstructorParameters<typeof AbstractBaseMaskFilter>);
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    exploredColor: [1, 1, 1],
+     *    unexploredColor: [0, 0, 0],
+     *    screenDimensions: [1, 1],
+     *    visionTexture: null,
+     *    primaryTexture: null,
+     *    overlayTexture: null,
+     *    overlayMatrix: new PIXI.Matrix(),
+     *    hasOverlayTexture: false
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override create(
+      uniforms?: AbstractBaseShader.Uniforms,
+      options?: Parameters<(typeof VisibilityFilter)["fragmentShader"]>,
+    ): VisibilityFilter;
+
+    static override vertexShader: string;
+
+    static override fragmentShader(options: { persistentVision: boolean }): string;
+
+    /**
+     * Set the blur strength
+     * @param value - blur strength
+     */
+    set blur(value: number);
+
+    get blur();
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clear: PIXI.CLEAR_MODES,
+    ): void;
+
+    /**
+     * Calculate the fog overlay sprite matrix.
+     */
+    calculateMatrix(filterManager: PIXI.FilterSystem): void;
+  }
+
+  /**
+   * A filter which forces all non-transparent pixels to a specific color and transparency.
+   */
+  class ForceColorFilter extends AbstractBaseFilter {
+    static create<T extends ForceColorFilter>(this: ConstructorOf<T>, uniforms?: AbstractBaseShader.Uniforms): T;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   color: [1, 1, 1],
+     *   alpha: 1.0
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override fragmentShader: string;
+  }
+
+  /**
+   * This filter turns pixels with an alpha channel &lt; alphaThreshold in transparent pixels
+   * Then, optionally, it can turn the result in the chosen color (default: pure white).
+   * The alpha [threshold,1] is re-mapped to [0,1] with an hermite interpolation slope to prevent pixelation.
+   */
+  class RoofMaskFilter extends AbstractBaseFilter {
+    static create<T extends RoofMaskFilter>(this: ConstructorOf<T>, uniforms?: AbstractBaseShader.Uniforms): T;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   alphaThreshold: 0.75,
+     *   turnToColor: false,
+     *   color: [1, 1, 1]
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override fragmentShader: string;
+  }
+
+  /**
+   * A filter which implements an inner or outer glow around the source texture.
+   * Inspired from https://github.com/pixijs/filters/tree/main/filters/glow
+   * @remarks MIT License
+   */
+  class GlowOverlayFilter extends AbstractBaseFilter {
+    override padding: number;
+
+    /**
+     * The inner strength of the glow.
+     * @defaultValue `3`
+     */
+    innerStrength: number;
+
+    /**
+     * The outer strength of the glow.
+     * @defaultValue `3`
+     */
+    outerStrength: number;
+
+    /**
+     * Should this filter auto-animate?
+     * @defaultValue `true`
+     */
+    animated: number;
+
+    /**
+     * @defaultValue
+     * ```typescript
+     * {
+     *   distance: 10,
+     *   innerStrength: 0,
+     *   glowColor: [1, 1, 1, 1],
+     *   quality: 0.1,
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms & { distance: number; quality: number };
+
+    static createFragmentShader(quality: number, distance: number): string;
+
+    static override vertexShader: string;
+
+    static override create<T extends GlowOverlayFilter>(
+      this: ConstructorOf<T>,
+      uniforms: AbstractBaseShader.Uniforms,
+    ): T;
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clear: PIXI.CLEAR_MODES,
+    ): void;
+  }
+
+  /**
+   * A filter which implements an outline.
+   * Inspired from https://github.com/pixijs/filters/tree/main/filters/outline
+   * @remarks MIT License
+   */
+  class OutlineOverlayFilter extends AbstractBaseFilter {
+    override padding: number;
+
+    override autoFit: boolean;
+
+    /**
+     * If the filter is animated or not.
+     * @defaultValue `true`
+     */
+    animate: boolean;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    outlineColor: [1, 1, 1, 1],
+     *    thickness: [1, 1],
+     *    alphaThreshold: 0.60,
+     *    knockout: true,
+     *    wave: false
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override vertexShader: string;
+
+    static createFragmentShader(): string;
+
+    /**
+     * The thickness of the outline.
+     */
+    get thickness(): number;
+
+    set thickness(value);
+
+    static override create<T extends OutlineOverlayFilter>(
+      this: ConstructorOf<T>,
+      uniforms?: AbstractBaseShader.Uniforms,
+    ): T;
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clear: PIXI.CLEAR_MODES,
+    ): void;
+  }
+
+  /**
+   * The filter used by the weather layer to mask weather above occluded roofs.
+   * @see {@link WeatherEffects}
+   */
+  class WeatherOcclusionMaskFilter extends AbstractBaseMaskFilter {
+    /**
+     * Elevation of this weather occlusion mask filter.
+     * @defaultValue `Infinity`
+     */
+    elevation: number;
+
+    static override vertexShader: string;
+
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    depthElevation: 0,
+     *    useOcclusion: true,
+     *    occlusionTexture: null,
+     *    reverseOcclusion: false,
+     *    occlusionWeights: [0, 0, 1, 0],
+     *    useTerrain: false,
+     *    terrainTexture: null,
+     *    reverseTerrain: false,
+     *    terrainWeights: [1, 0, 0, 0],
+     *    sceneDimensions: [0, 0],
+     *    sceneAnchor: [0, 0]
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clear: PIXI.CLEAR_MODES,
+    ): void;
+  }
+}

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

@@ -0,0 +1,74 @@
+import type { ConstructorOf } from "../../../../../../types/utils.d.mts";
+
+declare global {
+  /**
+   * A FXAA filter based on PIXI.FXAA and slightly improved.
+   * In brief: The FXAA filter is computing the luma of neighbour pixels and apply correction according to the
+   * difference. A high luma reduction is reducing correction while a low luma reduction is reinforcing it.
+   */
+  class AdaptiveFXAAFilter extends AbstractBaseFilter {
+    /**
+     * @param vertex   - Optional vertex shader
+     *                   (default: `AdaptiveFXAAFilter.vertexShader`)
+     * @param fragment - Optional fragment shader
+     *                   (default: `AdaptiveFXAAFilter.fragmentShader`)
+     * @param uniforms - Optional uniforms
+     *                   (default: `AdaptiveFXAAFilter.defaultUniforms`)
+     * @param options  - Additional options (token knockout, ...)
+     *                   (default: `{}`)
+     */
+    constructor(
+      vertex: string,
+      fragment: string,
+      uniforms: AbstractBaseShader.Uniforms,
+      options: AdaptiveFXAAFilterOptions,
+    );
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    lumaMinimum: 0.0078125,   // The minimum luma reduction applied
+     *    lumaReduction: 0.125,     // The luma reduction applied. High value, less blur
+     *    spanMax: 8,               // Maximum distance at which luma comparisons are made
+     *    tokenKnockout: true,      // If tokens should be excluded from the FXAA
+     *    tokenTexture: null,       // Inverse occlusion token texture (if token exclusion is activated)
+     *    screenDimensions: [1, 1]  // Necessary if token exclusion is activated
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override vertexShader: string;
+
+    static override fragmentShader: string;
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clear: PIXI.CLEAR_MODES,
+    ): void;
+
+    /**
+     * Compute the luma reduction according to the stage zoom level (worldTransform.d)
+     * The zoom level is converted to a range [0.xxx =\> max zoom out , 1 =\> max zoom in]
+     * With zoom out, the reduction tends to high value, the antialias is discrete to avoid blurring side effect.
+     * With zoom in, the reduction tends to low value, the antialias is important.
+     * FXAA checks local contrast to avoid processing non-edges (high contrast difference === edge):
+     * 0.6 and 0.02 are factors applied to the "contrast range", to apply or not a contrast blend.
+     * With small values, the contrast blend is applied more often than with high values.
+     * @returns The luma reduction
+     */
+    protected _computeLumaReduction(): number;
+
+    static create<T extends AdaptiveFXAAFilter>(
+      this: ConstructorOf<T>,
+      uniforms?: AbstractBaseShader.Uniforms,
+    ): AdaptiveFXAAFilter;
+  }
+
+  // TODO: This needs to be filled in.
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  interface AdaptiveFXAAFilterOptions {}
+}

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

@@ -0,0 +1,3 @@
+import "./blur.d.mts";
+import "./filters.d.mts";
+import "./fxaa.d.mts";

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

@@ -0,0 +1,4 @@
+import "./effects/index.d.mts";
+import "./filters/index.d.mts";
+import "./samplers/index.d.mts";
+import "./base.d.mts";

package/src/foundry/client/pixi/webgl/shaders/samplers/color-adjustment.d.mts

@@ -0,0 +1,101 @@
+export {};
+
+declare global {
+  /**
+   * A color adjustment shader.
+   */
+  class ColorAdjustmentsSamplerShader extends BaseSamplerShader {
+    /**
+     * @defaultValue `null`
+     */
+    static override classPluginName: string | null;
+
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    tintAlpha: [1, 1, 1, 1],
+     *    tint: [1, 1, 1],
+     *    contrast: 0,
+     *    saturation: 0,
+     *    exposure: 0,
+     *    sampler: null,
+     *    linkedToDarknessLevel: false,
+     *    darknessLevel: 1
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    get linkedToDarknessLevel(): AbstractBaseShader.UniformValue;
+
+    set linkedToDarknessLevel(link);
+
+    get darknessLevel(): AbstractBaseShader.UniformValue;
+
+    set darknessLevel(darknessLevel);
+
+    get contrast(): AbstractBaseShader.UniformValue;
+
+    set contrast(contrast);
+
+    get exposure(): AbstractBaseShader.UniformValue;
+
+    set exposure(exposure);
+
+    get saturation(): AbstractBaseShader.UniformValue;
+
+    set saturation(saturation);
+  }
+
+  /**
+   * A light amplification shader.
+   */
+  class AmplificationSamplerShader extends ColorAdjustmentsSamplerShader {
+    /**
+     * @defaultValue `null`
+     */
+    static override classPluginName: string | null;
+
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    tintAlpha: [1, 1, 1, 1],
+     *    tint: [0.38, 0.8, 0.38],
+     *    brightness: 0,
+     *    darknessLevel: 1,
+     *    enable: true
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * Level of natural brightness (opposed to darkness level).
+     */
+    get darknessLevel(): number;
+
+    set darknessLevel(darknessLevel);
+
+    /**
+     * Brightness controls the luminosity.
+     */
+    get brightness(): number;
+
+    set brightness(brightness);
+
+    /**
+     * Tint color applied to Light Amplification.
+     * Light Amplification tint
+     * @defaultValue `[0.48, 1.0, 0.48]`
+     */
+    get colorTint(): number[];
+
+    set colorTint(color);
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.d.mts

@@ -0,0 +1,16 @@
+export {};
+
+declare global {
+  /**
+   * A simple shader which purpose is to make the original texture red channel the alpha channel,
+   * and still keeping channel informations. Used in cunjunction with the AlphaBlurFilterPass and Fog of War.
+   */
+  class FogSamplerShader extends BaseSamplerShader {
+    /**
+     * @defaultValue `null`
+     */
+    static override classPluginName: string | null;
+
+    static override fragmentShader: string;
+  }
+}

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

@@ -0,0 +1,6 @@
+import "./color-adjustment.d.mts";
+import "./fog-of-war.d.mts";
+import "./inverse-occlusion.d.mts";
+import "./invisibility.d.mts";
+import "./monochromatic.d.mts";
+import "./occlusion.d.mts";