@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

package/src/foundry/client/pixi/webgl/shaders/fragment-channel-mixin.d.mts

@@ -1,60 +0,0 @@
-import type { AnyObject, FixedInstanceType, Mixin, ShapeWithIndexSignature } from "fvtt-types/utils";
-
-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: AdaptiveFragmentChannelMixin.Channel) => string) | null;
-
-  /**
-   * A factory method for creating the filter using its defined default values
-   * @param options - Options which affect filter construction
-   */
-  //TODO: See if we can get this to return the mixed shader class, as it calls `super.create()`
-  static create<T extends AnyObject>({
-    /**
-     * A color channel to target for masking.
-     * @defaultValue `r`
-     */
-    channel,
-    /**
-     * Initial uniforms provided to the filter
-     */
-    ...uniforms
-  }?: ShapeWithIndexSignature<
-    T,
-    AdaptiveFragmentChannelMixin.ConcreteCreateOptions,
-    string,
-    AbstractBaseShader.UniformValue
-  >): PIXI.Shader | PIXI.Filter;
-}
-
-declare global {
-  /**
-   * A mixin wich decorates a shader or filter and construct a fragment shader according to a choosen channel.
-   * @param ShaderClass - The parent ShaderClass class being mixed.
-   * @returns A Shader/Filter subclass mixed with AdaptiveFragmentChannelMixin.
-   */
-  function AdaptiveFragmentChannelMixin<BaseClass extends AdaptiveFragmentChannelMixin.BaseClass>(
-    ShaderClass: BaseClass,
-  ): Mixin<typeof AdaptiveFragmentChannel, BaseClass>;
-
-  namespace AdaptiveFragmentChannelMixin {
-    /** @privateRemarks Can't extend `AnyMixedConstructor` if it's using the `BaseClass` union; `PIXI.Shader` is the parent of `Filter`, so it's used instead */
-    type AnyMixedConstructor = ReturnType<typeof AdaptiveFragmentChannelMixin<PIXI.Shader.AnyConstructor>>;
-    interface AnyMixed extends FixedInstanceType<AnyMixedConstructor> {}
-
-    type BaseClass = PIXI.Shader.AnyConstructor | PIXI.Filter.AnyConstructor;
-
-    type Channel = "r" | "g" | "b";
-
-    interface ConcreteCreateOptions {
-      channel?: AdaptiveFragmentChannelMixin.Channel | undefined;
-    }
-  }
-}

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

@@ -1,113 +0,0 @@
-import type { NullishProps } from "fvtt-types/utils";
-
-declare global {
-  /**
-   * 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?: NullishProps<{ style: AbstractBaseShader.UniformValue }>): void;
-
-    protected override _preRender: AbstractBaseShader.PreRenderFunction;
-  }
-
-  namespace GridShader {
-    interface Any extends AnyGridShader {}
-    type AnyConstructor = typeof AnyGridShader;
-  }
-}
-
-declare abstract class AnyGridShader extends GridShader {
-  constructor(arg0: never, ...args: never[]);
-}

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

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

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

@@ -1,10 +0,0 @@
-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";

package/src/foundry/client/pixi/webgl/shaders/lighting/background-lighting.d.mts

@@ -1,66 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * The default coloration shader used by standard rendering and animations
-   * A fragment shader which creates a solid light source.
-   */
-  class AdaptiveBackgroundShader extends AdaptiveLightingShader {
-    /**
-     * Memory allocations for the Adaptive Background Shader
-     */
-    static SHADER_HEADER: string;
-
-    static override fragmentShader: string;
-
-    /**
-     * @defaultValue
-     * ```js
-     * {
-     *   technique: 1,
-     *   contrast: 0,  shadows: 0,
-     *   saturation: 0,
-     *   intensity: 5,
-     *   attenuation: 0.5,
-     *   exposure: 0,
-     *   ratio: 0.5,
-     *   color: [1, 1, 1],
-     *   colorBackground: [1, 1, 1],
-     *   screenDimensions: [1, 1],
-     *   time: 0,
-     *   useSampler: true,
-     *   primaryTexture: null,
-     *   depthTexture: null,
-     *   darknessLevelTexture: null,
-     *   depthElevation: 1,
-     *   ambientBrightest: [1, 1, 1],
-     *   ambientDarkness: [0, 0, 0],
-     *   ambientDaylight: [1, 1, 1],
-     *   weights: [0, 0, 0, 0],
-     *   dimLevelCorrection: 1,
-     *   brightLevelCorrection: 2,
-     *   computeIllumination: false,
-     *   globalLight: false,
-     *   globalLightThresholds: [0, 0]
-     * }
-     * ```
-     */
-    static override defaultUniforms: AbstractBaseShader.Uniforms;
-
-    /**
-     * Flag whether the background shader is currently required.
-     * Check vision modes requirements first, then
-     * if key uniforms are at their default values, we don't need to render the background container.
-     */
-    get isRequired(): boolean;
-  }
-
-  namespace AdaptiveBackgroundShader {
-    interface Any extends AnyAdaptiveBackgroundShader {}
-    type AnyConstructor = typeof AnyAdaptiveBackgroundShader;
-  }
-}
-
-declare abstract class AnyAdaptiveBackgroundShader extends AdaptiveBackgroundShader {
-  constructor(arg0: never, ...args: never[]);
-}

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

@@ -1,178 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * This class defines an interface which all adaptive lighting shaders extend.
-   */
-  class AdaptiveLightingShader extends AbstractBaseShader {
-    /**
-     * Has this lighting shader a forced default color?
-     * @defaultValue `false`
-     */
-    static forceDefaultColor: boolean;
-
-    /**
-     * Called before rendering.
-     * */
-    update(): void;
-
-    /**
-     * Common attributes for vertex shaders.
-     */
-    static VERTEX_ATTRIBUTES: string;
-
-    /**
-     * Common uniforms for vertex shaders.
-     */
-    static VERTEX_UNIFORMS: string;
-
-    /**
-     * Common varyings shared by vertex and fragment shaders.
-     */
-    static VERTEX_FRAGMENT_VARYINGS: string;
-
-    /**
-     * Common functions used by the vertex shaders.
-     * @remarks Foundry labeled as abstract
-     */
-    static VERTEX_FUNCTIONS: string;
-
-    /**
-     * Common uniforms shared by fragment shaders.
-     */
-    static FRAGMENT_UNIFORMS: string;
-
-    /**
-     * Common functions used by the fragment shaders.
-     * @remarks Foundry labeled as abstract but provided a default value?
-     */
-    static FRAGMENT_FUNCTIONS: string;
-
-    static override CONSTANTS: string;
-
-    static override vertexShader: string;
-
-    /**
-     * Construct adaptive shader according to shader type
-     * @param shaderType - shader type to construct : coloration, illumination, background, etc.
-     * @returns the constructed shader adaptive block
-     */
-    static getShaderTechniques(shaderType: AdaptiveLightingShader.ShaderTypes): string;
-
-    /**
-     * The coloration technique coloration shader fragment
-     */
-    static get COLORATION_TECHNIQUES(): string;
-
-    /**
-     * The coloration technique illumination shader fragment
-     */
-    static get ILLUMINATION_TECHNIQUES(): string;
-
-    /**
-     * The coloration technique background shader fragment
-     */
-    static get BACKGROUND_TECHNIQUES(): string;
-
-    /**
-     * The adjustments made into fragment shaders
-     */
-    static get ADJUSTMENTS(): string;
-
-    /**
-     * Contrast adjustment
-     */
-    static CONTRAST: string;
-
-    /**
-     * Saturation adjustment
-     */
-    static SATURATION: string;
-
-    /**
-     * Exposure adjustment
-     */
-    static EXPOSURE: string;
-
-    /**
-     * Switch between an inner and outer color, by comparing distance from center to ratio
-     * Apply a strong gradient between the two areas if attenuation uniform is set to true
-     */
-    static SWITCH_COLOR: string;
-
-    /**
-     * Shadow adjustment
-     */
-    static SHADOW: string;
-
-    /**
-     * Transition between bright and dim colors, if requested
-     */
-    static TRANSITION: string;
-
-    /**
-     * Incorporate falloff if a attenuation uniform is requested
-     */
-    static FALLOFF: string;
-
-    /**
-     * Compute illumination uniforms
-     */
-    static COMPUTE_ILLUMINATION: string;
-
-    /**
-     * Initialize fragment with common properties
-     */
-    static FRAGMENT_BEGIN: string;
-
-    /**
-     * Shader final
-     */
-    static FRAGMENT_END: string;
-
-    /**
-     * A mapping of available coloration techniques
-     * @privateRemarks This type would have at least the `id` keys Branded if not for subclasses overriding the entries
-     */
-    static SHADER_TECHNIQUES: Record<string, AdaptiveLightingShader.ShaderTechnique>;
-
-    /**
-     * Determine the correct penalty to apply for a given darkness level and luminosity
-     * @param darknessLevel - The current darkness level on [0,1]
-     * @param luminosity    - The light source luminosity on [-1,1]
-     * @returns 0
-     * @deprecated since v12, until v14
-     * @remarks AdaptiveLightingShader#getDarknessPenalty is deprecated without replacement.
-     * The darkness penalty is no longer applied on light and vision sources.
-     */
-    getDarknessPenalty(darknessLevel: number, luminosity: number): number;
-  }
-
-  namespace AdaptiveLightingShader {
-    interface Any extends AnyAdaptiveLightingShader {}
-    type AnyConstructor = typeof AnyAdaptiveLightingShader;
-
-    type ShaderTypes = "coloration" | "illumination" | "background" | (string & {});
-
-    interface ShaderTechnique {
-      /** The numeric identifier of the technique */
-      id: number;
-
-      /** The localization string that labels the technique */
-      label: string;
-
-      /**  The coloration shader fragment when the technique is used */
-      coloration?: string | undefined;
-
-      /** The illumination shader fragment when the technique is used */
-      illumination?: string | undefined;
-
-      /** The background shader fragment when the technique is used */
-      background?: string | undefined;
-    }
-  }
-}
-
-declare abstract class AnyAdaptiveLightingShader extends AdaptiveLightingShader {
-  constructor(arg0: never, ...args: never[]);
-}

package/src/foundry/client/pixi/webgl/shaders/lighting/coloration-lighting.d.mts

@@ -1,74 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * The default coloration shader used by standard rendering and animations.
-   * A fragment shader which creates a light source.
-   */
-  class AdaptiveColorationShader extends AdaptiveLightingShader {
-    static override FRAGMENT_END: string;
-
-    /**
-     * The adjustments made into fragment shaders
-     */
-    static override get ADJUSTMENTS(): string;
-
-    static override SHADOW: string;
-
-    /**
-     * Memory allocations for the Adaptive Coloration Shader
-     */
-    static SHADER_HEADER: string;
-
-    static override fragmentShader: string;
-
-    /**
-     * @defaultValue
-     * ```js
-     * {
-     *   technique: 1,
-     *   shadows: 0,
-     *   contrast: 0,
-     *   saturation: 0,
-     *   colorationAlpha: 1,
-     *   intensity: 5,
-     *   attenuation: 0.5,
-     *   ratio: 0.5,
-     *   color: [1, 1, 1],
-     *   time: 0,
-     *   hasColor: false,
-     *   screenDimensions: [1, 1],
-     *   useSampler: false,
-     *   primaryTexture: null,
-     *   depthTexture: null,
-     *   darknessLevelTexture: null,
-     *   depthElevation: 1,
-     *   ambientBrightest: [1, 1, 1],
-     *   ambientDarkness: [0, 0, 0],
-     *   ambientDaylight: [1, 1, 1],
-     *   weights: [0, 0, 0, 0],
-     *   dimLevelCorrection: 1,
-     *   brightLevelCorrection: 2,
-     *   computeIllumination: false,
-     *   globalLight: false,
-     *   globalLightThresholds: [0, 0]
-     * }
-     * ```
-     */
-    static override defaultUniforms: AbstractBaseShader.Uniforms;
-
-    /**
-     * Flag whether the coloration shader is currently required.
-     */
-    get isRequired(): boolean;
-  }
-
-  namespace AdaptiveColorationShader {
-    interface Any extends AnyAdaptiveColorationShader {}
-    type AnyConstructor = typeof AnyAdaptiveColorationShader;
-  }
-}
-
-declare abstract class AnyAdaptiveColorationShader extends AdaptiveColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}

package/src/foundry/client/pixi/webgl/shaders/lighting/darkness-lighting.d.mts

@@ -1,74 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * The default coloration shader used by standard rendering and animations.
-   * A fragment shader which creates a solid light source.
-   */
-  class AdaptiveDarknessShader extends AdaptiveLightingShader {
-    override update(): void;
-
-    /**
-     * Flag whether the darkness shader is currently required.
-     * Check vision modes requirements first, then
-     * if key uniforms are at their default values, we don't need to render the background container.
-     */
-    get isRequired(): boolean;
-
-    /**
-     * @defaultValue
-     * ```js
-     * {
-     *   intensity: 5,
-     *   color: Color.from("#8651d5").rgb,
-     *   screenDimensions: [1, 1],
-     *   time: 0,
-     *   primaryTexture: null,
-     *   depthTexture: null,
-     *   visionTexture: null,
-     *   darknessLevelTexture: null,
-     *   depthElevation: 1,
-     *   ambientBrightest: [1, 1, 1],
-     *   ambientDarkness: [0, 0, 0],
-     *   ambientDaylight: [1, 1, 1],
-     *   weights: [0, 0, 0, 0],
-     *   dimLevelCorrection: 1,
-     *   brightLevelCorrection: 2,
-     *   borderDistance: 0,
-     *   darknessLevel: 0,
-     *   computeIllumination: false,
-     *   globalLight: false,
-     *   globalLightThresholds: [0, 0],
-     *   enableVisionMasking: false
-     * }
-     * ```
-     */
-    static override defaultUniforms: AbstractBaseShader.Uniforms;
-
-    /**
-     * Shader final
-     */
-    static FRAGMENT_END: string;
-
-    /**
-     * Initialize fragment with common properties
-     */
-    static FRAGMENT_BEGIN: string;
-
-    /**
-     * Memory allocations for the Adaptive Background Shader
-     */
-    static SHADER_HEADER: string;
-
-    static override fragmentShader: string;
-  }
-
-  namespace AdaptiveDarknessShader {
-    interface Any extends AnyAdaptiveDarknessShader {}
-    type AnyConstructor = typeof AnyAdaptiveDarknessShader;
-  }
-}
-
-declare abstract class AnyAdaptiveDarknessShader extends AdaptiveDarknessShader {
-  constructor(arg0: never, ...args: never[]);
-}

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/bewitching-wave.d.mts

@@ -1,35 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * Bewitching Wave animation illumination shader
-   */
-  class BewitchingWaveIlluminationShader extends AdaptiveIlluminationShader {
-    static override fragmentShader: string;
-  }
-
-  namespace BewitchingWaveColorationShader {
-    interface Any extends AnyBewitchingWaveColorationShader {}
-    type AnyConstructor = typeof AnyBewitchingWaveColorationShader;
-  }
-
-  /**
-   * Bewitching Wave animation coloration shader
-   */
-  class BewitchingWaveColorationShader extends AdaptiveColorationShader {
-    static override fragmentShader: string;
-  }
-
-  namespace BewitchingWaveIlluminationShader {
-    interface Any extends AnyBewitchingWaveIlluminationShader {}
-    type AnyConstructor = typeof AnyBewitchingWaveIlluminationShader;
-  }
-}
-
-declare abstract class AnyBewitchingWaveColorationShader extends BewitchingWaveColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyBewitchingWaveIlluminationShader extends BewitchingWaveIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/black-hole.d.mts

@@ -1,19 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * Black Hole animation illumination shader
-   */
-  class BlackHoleDarknessShader extends AdaptiveDarknessShader {
-    static override fragmentShader: string;
-  }
-
-  namespace BlackHoleDarknessShader {
-    interface Any extends AnyBlackHoleDarknessShader {}
-    type AnyConstructor = typeof AnyBlackHoleDarknessShader;
-  }
-}
-
-declare abstract class AnyBlackHoleDarknessShader extends BlackHoleDarknessShader {
-  constructor(arg0: never, ...args: never[]);
-}

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

@@ -1,24 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * Chroma animation coloration shader
-   */
-  class ChromaColorationShader extends AdaptiveColorationShader {
-    /**
-     * @defaultValue `true`
-     */
-    static override forceDefaultColor: boolean;
-
-    static override fragmentShader: string;
-  }
-
-  namespace ChromaColorationShader {
-    interface Any extends AnyChromaColorationShader {}
-    type AnyConstructor = typeof AnyChromaColorationShader;
-  }
-}
-
-declare abstract class AnyChromaColorationShader extends ChromaColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}

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

@@ -1,24 +0,0 @@
-export {};
-
-declare global {
-  /**
-   * Emanation animation coloration shader
-   */
-  class EmanationColorationShader extends AdaptiveColorationShader {
-    /**
-     * @defaultValue `true`
-     */
-    static override forceDefaultColor: boolean;
-
-    static override fragmentShader: string;
-  }
-
-  namespace EmanationColorationShader {
-    interface Any extends AnyEmanationColorationShader {}
-    type AnyConstructor = typeof AnyEmanationColorationShader;
-  }
-}
-
-declare abstract class AnyEmanationColorationShader extends EmanationColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}