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

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

@@ -0,0 +1,75 @@
+export {};
+
+declare abstract class AnyGlowOverlayFilter extends GlowOverlayFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace GlowOverlayFilter {
+    type AnyConstructor = typeof AnyGlowOverlayFilter;
+  }
+
+  /**
+   * 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 {
+    /**
+     * @defaultValue `6`
+     */
+    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: boolean;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   distance: 10,
+     *   glowColor: [1, 1, 1, 1],
+     *   quality: 0.1,
+     *   time: 0,
+     *   knockout: true,
+     *   alpha: 1
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * Dynamically create the fragment shader used for filters of this type.
+     */
+    static createFragmentShader(quality: number, distance: number): string;
+
+    static override vertexShader: string;
+
+    static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
+      this: ThisType,
+      initialUniforms?: AbstractBaseShader.Uniforms,
+    ): InstanceType<ThisType>;
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clear: PIXI.CLEAR_MODES,
+    ): void;
+  }
+}

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

@@ -0,0 +1,13 @@
+import "./base-filter.d.mts";
+import "./base-mask-filter.d.mts";
+import "./blur.d.mts";
+import "./effects-masking.d.mts";
+import "./environment.d.mts";
+import "./glow-overlay.d.mts";
+import "./invisibility.d.mts";
+import "./outline-overlay.d.mts";
+import "./transition.d.mts";
+import "./visibility.d.mts";
+import "./vision-mask-filter.d.mts";
+import "./void.d.mts";
+import "./weather-occlusion-masks.d.mts";

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

@@ -0,0 +1,29 @@
+export {};
+
+declare abstract class AnyInvisibilityFilter extends InvisibilityFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace InvisibilityFilter {
+    type AnyConstructor = typeof AnyInvisibilityFilter;
+  }
+
+  /**
+   * Invisibility effect filter for placeables.
+   */
+  class InvisibilityFilter extends AbstractBaseFilter {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   uSampler: null,
+     *   color: [0.5, 1, 1]
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+}

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

@@ -0,0 +1,86 @@
+export {};
+
+declare abstract class AnyOutlineOverlayFilter extends OutlineOverlayFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace OutlineOverlayFilter {
+    type AnyConstructor = typeof AnyOutlineOverlayFilter;
+  }
+
+  /**
+   * A filter which implements an outline.
+   * Inspired from https://github.com/pixijs/filters/tree/main/filters/outline
+   * @remarks MIT License
+   */
+  class OutlineOverlayFilter extends AbstractBaseFilter {
+    /**
+     * @defaultValue `3`
+     */
+    override padding: number;
+
+    /**
+     * @defaultValue `false`
+     */
+    override autoFit: boolean;
+
+    /**
+     * If the filter is animated or not.
+     * @defaultValue `true`
+     */
+    animated: 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;
+
+    /**
+     * Dynamically create the fragment shader used for filters of this type.
+     */
+    static createFragmentShader(): string;
+
+    /**
+     * The thickness of the outline.
+     */
+    get thickness(): number;
+
+    set thickness(value);
+
+    static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(
+      this: ThisType,
+      initialUniforms?: AbstractBaseShader.Uniforms,
+    ): InstanceType<ThisType>;
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clear: PIXI.CLEAR_MODES,
+    ): void;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks OutlineOverlayFilter#animate is deprecated in favor of OutlineOverlayFilter#animated.
+     */
+    get animate(): boolean;
+
+    /**
+     * @deprecated since v12, until v14
+     * @remarks OutlineOverlayFilter#animate is deprecated in favor of OutlineOverlayFilter#animated.
+     */
+    set animate(v);
+  }
+}

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

@@ -0,0 +1,119 @@
+import type { InexactPartial, ValueOf } from "../../../../../../types/utils.d.mts";
+
+declare abstract class AnyTextureTransitionFilter extends TextureTransitionFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace TextureTransitionFilter {
+    type AnyConstructor = typeof AnyTextureTransitionFilter;
+
+    /**
+     * @privateRemarks types are literals and not `string` to make the `type` getter and setter typings work
+     */
+    interface TYPES {
+      FADE: "fade";
+      SWIRL: "swirl";
+      WATER_DROP: "waterDrop";
+      MORPH: "morph";
+      CROSSHATCH: "crosshatch";
+      WIND: "wind";
+      WAVES: "waves";
+      WHITE_NOISE: "whiteNoise";
+      HOLOGRAM: "hologram";
+      HOLE: "hole";
+      HOLE_SWIRL: "holeSwirl";
+      GLITCH: "glitch";
+      DOTS: "dots";
+    }
+  }
+
+  /**
+   * A filter specialized for transition effects between a source object and a target texture.
+   */
+  class TextureTransitionFilter extends AbstractBaseFilter {
+    /**
+     * Transition types for this shader.
+     */
+    static get TYPES(): TextureTransitionFilter.TYPES;
+
+    /**
+     * The transition type (see {@link TextureTransitionFilter.TYPES}).
+     * @defaultValue TYPES.FADE
+     */
+    get type(): ValueOf<TextureTransitionFilter.TYPES>;
+
+    set type(type: ValueOf<TextureTransitionFilter.TYPES>);
+
+    /**
+     * Sampler target for this filter.
+     */
+    set targetTexture(targetTexture: PIXI.Texture);
+
+    /**
+     * Animate a transition from a subject SpriteMesh/PIXI.Sprite to a given texture.
+     * @param subject - The source mesh/sprite to apply a transition.
+     * @param texture - The target texture.
+     * @param options - Animation options.
+     * @returns   A Promise which resolves to true once the animation has concluded
+     *            or false if the animation was prematurely terminated
+     */
+    static animate(
+      subject: PIXI.Sprite | SpriteMesh,
+      texture: PIXI.Texture,
+      options?: InexactPartial<{
+        /**
+         * The transition type
+         * @defaultValue `TYPES.FADE`
+         */
+        type: ValueOf<TextureTransitionFilter.TYPES>;
+
+        /**
+         * The name of the {@link CanvasAnimation}.
+         */
+        name: string | symbol;
+
+        /**
+         * The animation duration
+         * @defaultValue 1000
+         * @remarks this function does not provide a default, but CanvasAnimation.animate does
+         */
+        duration: number;
+
+        /**
+         * The easing function of the animation
+         */
+        easing: CanvasAnimation.EasingFunction;
+      }>,
+    ): Promise<boolean>;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   tintAlpha: [1, 1, 1, 1],
+     *   targetTexture: null,
+     *   progress: 0,
+     *   rotation: 0,
+     *   anchor: {x: 0.5, y: 0.5},
+     *   type: 1,
+     *   filterMatrix: new PIXI.Matrix(),
+     *   filterMatrixInverse: new PIXI.Matrix(),
+     *   targetUVMatrix: new PIXI.Matrix()
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override vertexShader: string;
+
+    static override fragmentShader: string;
+
+    override apply(
+      filterManager: PIXI.FilterSystem,
+      input: PIXI.RenderTexture,
+      output: PIXI.RenderTexture,
+      clearMode?: PIXI.CLEAR_MODES,
+    ): void;
+  }
+}

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

@@ -0,0 +1,70 @@
+import type { InexactPartial } from "../../../../../../types/utils.d.mts";
+
+declare abstract class AnyVisibilityFilter extends VisibilityFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace VisibilityFilter {
+    type AnyConstructor = typeof AnyVisibilityFilter;
+
+    interface FragmentShaderOptions {
+      persistentVision: boolean;
+    }
+  }
+
+  /**
+   * 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<ThisType extends AbstractBaseFilter.AnyConstructor>(
+      this: ThisType,
+      initiaUniforms?: AbstractBaseShader.Uniforms,
+      options?: InexactPartial<VisibilityFilter.FragmentShaderOptions>,
+    ): InstanceType<ThisType>;
+
+    static override vertexShader: string;
+
+    static override fragmentShader(options: InexactPartial<VisibilityFilter.FragmentShaderOptions>): string;
+
+    /**
+     * Set the blur strength
+     * @param value - blur strength
+     */
+    set blur(value: number);
+
+    get blur(): number;
+
+    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;
+  }
+}

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

@@ -0,0 +1,33 @@
+export {};
+
+declare abstract class AnyVisionMaskFilter extends VisionMaskFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace VisionMaskFilter {
+    type AnyConstructor = typeof AnyVisionMaskFilter;
+  }
+
+  class VisionMaskFilter extends AbstractBaseMaskFilter {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   uMaskSampler: null
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override create<ThisType extends AbstractBaseFilter.AnyConstructor>(this: ThisType): InstanceType<ThisType>;
+
+    /**
+     * @remarks This is set as a property all the way up in PIXI.Filter, however Foundry has it
+     * as a getter, with a no-op setter. It's still like this in 13.332.
+     */
+    override readonly enabled: boolean;
+  }
+}

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

@@ -0,0 +1,18 @@
+export {};
+
+declare abstract class AnyVoidFilter extends VoidFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace VoidFilter {
+    type AnyConstructor = typeof AnyVoidFilter;
+  }
+
+  /**
+   * A minimalist filter (just used for blending)
+   */
+  class VoidFilter extends AbstractBaseFilter {
+    static override fragmentShader: string;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/filters/weather-occlusion-masks.d.mts

@@ -0,0 +1,56 @@
+export {};
+
+declare abstract class AnyWeatherOcclusionMaskFilter extends WeatherOcclusionMaskFilter {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace WeatherOcclusionMaskFilter {
+    type AnyConstructor = typeof AnyWeatherOcclusionMaskFilter;
+  }
+
+  /**
+   * 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,
+     *   everseOcclusion: false,
+     *   occlusionWeights: [0, 0, 1, 0],
+     *   seTerrain: false,
+     *   terrainTexture: null,
+     *   reverseTerrain: false,
+     *   terrainWeights: [1, 0, 0, 0],
+     *   sceneDimensions: [0, 0],
+     *   sceneAnchor: [0, 0]
+     *   terrainUvMatrix: new PIXI.Matrix()
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    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/fragment-channel-mixin.d.mts

@@ -0,0 +1,54 @@
+import type { AnyObject, Mixin, ShapeWithIndexSignature } from "../../../../../types/utils.d.mts";
+
+declare abstract class AnyAdaptiveFragmentChannel extends AdaptiveFragmentChannel {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare class AdaptiveFragmentChannel {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * The fragment shader which renders this filter.
+   * A subclass of AdaptiveFragmentChannelMixin must implement the fragmentShader static field.
+   * @defaultValue `null`
+   */
+  static adaptiveFragmentShader: ((channel: AdaptiveFragmentChannel.Channel) => string) | null;
+
+  /**
+   * A factory method for creating the filter using its defined default values
+   * @param options - Options which affect filter construction
+   */
+  static create<T extends AnyObject>({
+    /**
+     * A color channel to target for masking.
+     * @defaultValue `r`
+     */
+    channel,
+    /**
+     * Initial uniforms provided to the filter
+     */
+    ...uniforms
+  }?: ShapeWithIndexSignature<
+    T,
+    AdaptiveFragmentChannel.ConcreteCreateOptions,
+    string,
+    AbstractBaseShader.UniformValue
+  >): PIXI.Shader | PIXI.Filter;
+}
+
+declare global {
+  namespace AdaptiveFragmentChannel {
+    type AnyConstructor = typeof AnyAdaptiveFragmentChannel;
+
+    type Channel = "r" | "g" | "b";
+
+    interface ConcreteCreateOptions {
+      channel?: AdaptiveFragmentChannel.Channel | undefined;
+    }
+  }
+
+  function AdaptiveFragmentChannelMixin<BaseClass extends PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor>(
+    ShaderClass: BaseClass,
+  ): Mixin<typeof AdaptiveFragmentChannel, BaseClass>;
+}

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

@@ -0,0 +1,112 @@
+import type { IntentionalPartial } from "../../../../../../types/helperTypes.d.mts";
+
+declare abstract class AnyGridShader extends GridShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace GridShader {
+    type AnyConstructor = typeof AnyGridShader;
+  }
+
+  /**
+   * The grid shader used by {@link GridMesh}.
+   */
+  class GridShader extends AbstractBaseShader {
+    /**
+     * The grid type uniform.
+     */
+    static TYPE_UNIFORM: string;
+
+    /**
+     * The grid thickness uniform.
+     */
+    static THICKNESS_UNIFORM: string;
+
+    /**
+     * The grid color uniform.
+     */
+    static COLOR_UNIFORM: string;
+
+    /**
+     * The resolution (pixels per grid space units) uniform.
+     */
+    static RESOLUTION_UNIFORM: string;
+
+    /**
+     * The antialiased step function.
+     * The edge and x values is given in grid space units.
+     */
+    static ANTIALIASED_STEP_FUNCTION: string;
+
+    /**
+     * The line converage function, which returns the alpha value at a point with the given distance (in grid space units)
+     * from an antialiased line (or point) with the given thickness (in grid space units).
+     */
+    static LINE_COVERAGE_FUNCTION: string;
+
+    /**
+     * Hexagonal functions conversion for between grid and cube space.
+     */
+    static HEXAGONAL_FUNCTIONS: string;
+
+    /**
+     * Get the nearest vertex of a grid space to the given point.
+     */
+    static NEAREST_VERTEX_FUNCTION: string;
+
+    /**
+     * This function returns the distance to the nearest edge of a grid space given a point.
+     */
+    static EDGE_DISTANCE_FUNCTION: string;
+
+    /**
+     * This function returns an vector (x, y, z), where
+     * - x is the x-offset along the nearest edge,
+     * - y is the y-offset (the distance) from the nearest edge, and
+     * - z is the length of the nearest edge.
+     */
+    static EDGE_OFFSET_FUNCTION: string;
+
+    /**
+     * A function that draws the grid given a grid point, style, thickness, and color.
+     */
+    static DRAW_GRID_FUNCTION: string;
+
+    static override vertexShader: string;
+
+    static override get fragmentShader(): string;
+
+    /**
+     * The fragment shader source. Subclasses can override it.
+     */
+    protected static _fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   canvasDimensions: [1, 1],
+     *   meshDimensions: [0, 0, 1, 1],
+     *   sceneDimensions: [0, 0, 1, 1],
+     *   screenDimensions: [1, 1],
+     *   gridSize: 1,
+     *   type: 0,
+     *   thickness: 0,
+     *   resolution: 0,
+     *   color: [0, 0, 0, 0],
+     *   alpha: 0,
+     *   style: 0
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * Configure the shader.
+     */
+    configure(options?: IntentionalPartial<{ style: AbstractBaseShader.UniformValue }>): void;
+
+    protected override _preRender: AbstractBaseShader.PreRenderFunction;
+  }
+}

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

@@ -0,0 +1 @@
+import "./grid.d.mts";

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

@@ -0,0 +1,10 @@
+import "./filters/index.d.mts";
+import "./grid/index.d.mts";
+import "./lighting/index.d.mts";
+import "./region/index.d.mts";
+import "./samplers/index.d.mts";
+import "./vision/index.d.mts";
+import "./weather/index.d.mts";
+import "./base-shader.d.mts";
+import "./base-shader-mixin.d.mts";
+import "./fragment-channel-mixin.d.mts";