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

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

@@ -0,0 +1,65 @@
+export {};
+
+declare abstract class AnyAdaptiveBackgroundShader extends AdaptiveBackgroundShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AdaptiveBackgroundShader {
+    type AnyConstructor = typeof AnyAdaptiveBackgroundShader;
+  }
+
+  /**
+   * 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;
+  }
+}

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

@@ -0,0 +1,178 @@
+export {};
+
+declare abstract class AnyAdaptiveLightingShader extends AdaptiveLightingShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AdaptiveLightingShader {
+    type AnyConstructor = typeof AnyAdaptiveLightingShader;
+
+    type TechniqueReturn = ReturnType<(typeof AdaptiveLightingShader)["getShaderTechniques"]>;
+
+    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;
+    }
+  }
+
+  /**
+   * 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(): AdaptiveLightingShader.TechniqueReturn;
+
+    /**
+     * The coloration technique illumination shader fragment
+     */
+    static get ILLUMINATION_TECHNIQUES(): AdaptiveLightingShader.TechniqueReturn;
+
+    /**
+     * The coloration technique background shader fragment
+     */
+    static get BACKGROUND_TECHNIQUES(): AdaptiveLightingShader.TechniqueReturn;
+
+    /**
+     * 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
+     */
+    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;
+  }
+}

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

@@ -0,0 +1,73 @@
+export {};
+
+declare abstract class AnyAdaptiveColorationShader extends AdaptiveColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AdaptiveColorationShader {
+    type AnyConstructor = typeof AnyAdaptiveColorationShader;
+  }
+
+  /**
+   * 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;
+  }
+}

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

@@ -0,0 +1,73 @@
+export {};
+
+declare abstract class AnyAdaptiveDarknessShader extends AdaptiveDarknessShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AdaptiveDarknessShader {
+    type AnyConstructor = typeof AnyAdaptiveDarknessShader;
+  }
+
+  /**
+   * 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;
+  }
+}

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

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

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

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

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

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

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

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

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/energy-field.d.mts

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

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/fairy-light.d.mts

@@ -0,0 +1,38 @@
+export {};
+
+declare abstract class AnyFairyLightColorationShader extends FairyLightColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyFairyLightIlluminationShader extends FairyLightIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace FairyLightColorationShader {
+    type AnyConstructor = typeof AnyFairyLightColorationShader;
+  }
+
+  namespace FairyLightIlluminationShader {
+    type AnyConstructor = typeof AnyFairyLightIlluminationShader;
+  }
+
+  /**
+   * Fairy light animation coloration shader
+   */
+  class FairyLightColorationShader extends AdaptiveColorationShader {
+    /**
+     * @defaultValue `true`
+     */
+    static override forceDefaultColor: boolean;
+
+    static override fragmentShader: string;
+  }
+
+  /**
+   * Fairy light animation illumination shader
+   */
+  class FairyLightIlluminationShader extends AdaptiveIlluminationShader {
+    static override fragmentShader: string;
+  }
+}

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

@@ -0,0 +1,55 @@
+export {};
+
+declare abstract class AnyFlameIlluminationShader extends FlameIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyFlameColorationShader extends FlameColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace FlameIlluminationShader {
+    type AnyConstructor = typeof AnyFlameIlluminationShader;
+  }
+
+  namespace FlameColorationShader {
+    type AnyConstructor = typeof AnyFlameColorationShader;
+  }
+
+  /**
+   * Alternative torch illumination shader
+   */
+  class FlameIlluminationShader extends AdaptiveIlluminationShader {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   ...super.defaultUniforms,
+     *   brightnessPulse: 1
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+
+  /**
+   * Alternative torch coloration shader
+   */
+  class FlameColorationShader extends AdaptiveColorationShader {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   ...super.defaultUniforms,
+     *   brightnessPulse: 1
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+}

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

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

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/force-grid.d.mts

@@ -0,0 +1,22 @@
+export {};
+
+declare abstract class AnyForceGridColorationShader extends ForceGridColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace ForceGridColorationShader {
+    type AnyConstructor = typeof AnyForceGridColorationShader;
+  }
+  /**
+   * A futuristic Force Grid animation.
+   */
+  class ForceGridColorationShader extends AdaptiveColorationShader {
+    /**
+     * @defaultValue `true`
+     */
+    static override forceDefaultColor: boolean;
+
+    static override fragmentShader: string;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/ghost-light.d.mts

@@ -0,0 +1,33 @@
+export {};
+
+declare abstract class AnyGhostLightIlluminationShader extends GhostLightIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyGhostLightColorationShader extends GhostLightColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace GhostLightIlluminationShader {
+    type AnyConstructor = typeof AnyGhostLightIlluminationShader;
+  }
+
+  namespace GhostLightColorationShader {
+    type AnyConstructor = typeof AnyGhostLightColorationShader;
+  }
+
+  /**
+   * Ghost light animation illumination shader
+   */
+  class GhostLightIlluminationShader extends AdaptiveIlluminationShader {
+    static override fragmentShader: string;
+  }
+
+  /**
+   * Ghost light animation coloration shader
+   */
+  class GhostLightColorationShader extends AdaptiveColorationShader {
+    static override fragmentShader: string;
+  }
+}