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

package/src/foundry/client/canvas/rendering/shaders/lighting/base-lighting.d.mts

@@ -0,0 +1,179 @@
+import type { Identity } from "#utils";
+import type AbstractBaseShader from "../base-shader.mjs";
+
+/**
+ * This class defines an interface which all adaptive lighting shaders extend.
+ */
+declare 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;
+}
+
+declare namespace AdaptiveLightingShader {
+  interface Any extends AnyAdaptiveLightingShader {}
+  interface AnyConstructor extends Identity<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;
+
+    /** The illumination shader fragment when the technique is used */
+    illumination?: string;
+
+    /** The background shader fragment when the technique is used */
+    background?: string;
+  }
+}
+
+export default AdaptiveLightingShader;
+
+declare abstract class AnyAdaptiveLightingShader extends AdaptiveLightingShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/coloration-lighting.d.mts

@@ -0,0 +1,76 @@
+import type { Identity } from "#utils";
+import type AdaptiveLightingShader from "./base-lighting.mjs";
+import type AbstractBaseShader from "../base-shader.mjs";
+
+/**
+ * The default coloration shader used by standard rendering and animations.
+ * A fragment shader which creates a light source.
+ */
+declare 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,     // overwritten by LightData.cleanData().coloration in a subsequent static init block
+   *   contrast: 0,      // overwritten by LightData.cleanData().contrast in a subsequent static init block
+   *   shadows: 0,       // overwritten by LightData.cleanData().shadows in a subsequent static init block
+   *   saturation: 0,    // overwritten by LightData.cleanData().saturation in a subsequent static init block
+   *   colorationAlpha: 1,
+   *   intensity: 5,     // overwritten by LightData.cleanData().intensity in a subsequent static init block
+   *   attenuation: 0.5, // overwritten by LightData.cleanData().attenuation in a subsequent static init block
+   *   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;
+}
+
+declare namespace AdaptiveColorationShader {
+  interface Any extends AnyAdaptiveColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyAdaptiveColorationShader> {}
+}
+
+export default AdaptiveColorationShader;
+
+declare abstract class AnyAdaptiveColorationShader extends AdaptiveColorationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/darkness-lighting.d.mts

@@ -0,0 +1,76 @@
+import type { Identity } from "#utils";
+import type AdaptiveLightingShader from "./base-lighting.mjs";
+import type AbstractBaseShader from "../base-shader.mjs";
+
+/**
+ * The default coloration shader used by standard rendering and animations.
+ * A fragment shader which creates a solid light source.
+ */
+declare 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, // overwritten by LightData.cleanData().intensity in a subsequent static init block
+   *   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;
+}
+
+declare namespace AdaptiveDarknessShader {
+  interface Any extends AnyAdaptiveDarknessShader {}
+  interface AnyConstructor extends Identity<typeof AnyAdaptiveDarknessShader> {}
+}
+
+export default AdaptiveDarknessShader;
+
+declare abstract class AnyAdaptiveDarknessShader extends AdaptiveDarknessShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/bewitching-wave.d.mts

@@ -0,0 +1,37 @@
+import type { Identity } from "#utils";
+import type AdaptiveColorationShader from "../coloration-lighting.mjs";
+import type AdaptiveIlluminationShader from "../illumination-lighting.mjs";
+
+/**
+ * Bewitching Wave animation illumination shader
+ */
+declare class BewitchingWaveIlluminationShader extends AdaptiveIlluminationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace BewitchingWaveColorationShader {
+  interface Any extends AnyBewitchingWaveColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyBewitchingWaveColorationShader> {}
+}
+
+/**
+ * Bewitching Wave animation coloration shader
+ */
+declare class BewitchingWaveColorationShader extends AdaptiveColorationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace BewitchingWaveIlluminationShader {
+  interface Any extends AnyBewitchingWaveIlluminationShader {}
+  interface AnyConstructor extends Identity<typeof AnyBewitchingWaveIlluminationShader> {}
+}
+
+export { BewitchingWaveColorationShader, BewitchingWaveIlluminationShader };
+
+declare abstract class AnyBewitchingWaveColorationShader extends BewitchingWaveColorationShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnyBewitchingWaveIlluminationShader extends BewitchingWaveIlluminationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/black-hole.d.mts

@@ -0,0 +1,20 @@
+import type { Identity } from "#utils";
+import type AdaptiveDarknessShader from "../darkness-lighting.mjs";
+
+/**
+ * Black Hole animation illumination shader
+ */
+declare class BlackHoleDarknessShader extends AdaptiveDarknessShader {
+  static override fragmentShader: string;
+}
+
+declare namespace BlackHoleDarknessShader {
+  interface Any extends AnyBlackHoleDarknessShader {}
+  interface AnyConstructor extends Identity<typeof AnyBlackHoleDarknessShader> {}
+}
+
+export { BlackHoleDarknessShader };
+
+declare abstract class AnyBlackHoleDarknessShader extends BlackHoleDarknessShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/chroma.d.mts

@@ -0,0 +1,25 @@
+import type { Identity } from "#utils";
+import type AdaptiveColorationShader from "../coloration-lighting.mjs";
+
+/**
+ * Chroma animation coloration shader
+ */
+declare class ChromaColorationShader extends AdaptiveColorationShader {
+  /**
+   * @defaultValue `true`
+   */
+  static override forceDefaultColor: boolean;
+
+  static override fragmentShader: string;
+}
+
+declare namespace ChromaColorationShader {
+  interface Any extends AnyChromaColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyChromaColorationShader> {}
+}
+
+export { ChromaColorationShader };
+
+declare abstract class AnyChromaColorationShader extends ChromaColorationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/dense-smoke.d.mts

@@ -0,0 +1,20 @@
+import type { Identity } from "#utils";
+import type AdaptiveDarknessShader from "../darkness-lighting.mjs";
+
+/**
+ * Creates a dense smoke area
+ */
+declare class DenseSmokeDarknessShader extends AdaptiveDarknessShader {
+  static override fragmentShader: string;
+}
+
+declare namespace DenseSmokeDarknessShader {
+  interface Any extends AnyDenseSmokeDarknessShader {}
+  interface AnyConstructor extends Identity<typeof AnyDenseSmokeDarknessShader> {}
+}
+
+export { DenseSmokeDarknessShader };
+
+declare abstract class AnyDenseSmokeDarknessShader extends DenseSmokeDarknessShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/emanation.d.mts

@@ -0,0 +1,25 @@
+import type { Identity } from "#utils";
+import type AdaptiveColorationShader from "../coloration-lighting.mjs";
+
+/**
+ * Emanation animation coloration shader
+ */
+declare class EmanationColorationShader extends AdaptiveColorationShader {
+  /**
+   * @defaultValue `true`
+   */
+  static override forceDefaultColor: boolean;
+
+  static override fragmentShader: string;
+}
+
+declare namespace EmanationColorationShader {
+  interface Any extends AnyEmanationColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyEmanationColorationShader> {}
+}
+
+export { EmanationColorationShader };
+
+declare abstract class AnyEmanationColorationShader extends EmanationColorationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/energy-field.d.mts

@@ -0,0 +1,25 @@
+import type { Identity } from "#utils";
+import type AdaptiveColorationShader from "../coloration-lighting.mjs";
+
+/**
+ * Energy field animation coloration shader
+ */
+declare class EnergyFieldColorationShader extends AdaptiveColorationShader {
+  /**
+   * @defaultValue `true`
+   */
+  static override forceDefaultColor: boolean;
+
+  static override fragmentShader: string;
+}
+
+declare namespace EnergyFieldColorationShader {
+  interface Any extends AnyEnergyFieldColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyEnergyFieldColorationShader> {}
+}
+
+export { EnergyFieldColorationShader };
+
+declare abstract class AnyEnergyFieldColorationShader extends EnergyFieldColorationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/fairy-light.d.mts

@@ -0,0 +1,42 @@
+import type { Identity } from "#utils";
+import type AdaptiveColorationShader from "../coloration-lighting.mjs";
+import type AdaptiveIlluminationShader from "../illumination-lighting.mjs";
+
+/**
+ * Fairy light animation coloration shader
+ */
+declare class FairyLightColorationShader extends AdaptiveColorationShader {
+  /**
+   * @defaultValue `true`
+   */
+  static override forceDefaultColor: boolean;
+
+  static override fragmentShader: string;
+}
+
+declare namespace FairyLightColorationShader {
+  interface Any extends AnyFairyLightColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyFairyLightColorationShader> {}
+}
+
+/**
+ * Fairy light animation illumination shader
+ */
+declare class FairyLightIlluminationShader extends AdaptiveIlluminationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace FairyLightIlluminationShader {
+  interface Any extends AnyFairyLightIlluminationShader {}
+  interface AnyConstructor extends Identity<typeof AnyFairyLightIlluminationShader> {}
+}
+
+export { FairyLightColorationShader, FairyLightIlluminationShader };
+
+declare abstract class AnyFairyLightColorationShader extends FairyLightColorationShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnyFairyLightIlluminationShader extends FairyLightIlluminationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/flame.d.mts

@@ -0,0 +1,60 @@
+import type { Identity } from "#utils";
+import type AdaptiveColorationShader from "../coloration-lighting.mjs";
+import type AdaptiveIlluminationShader from "../illumination-lighting.mjs";
+import type AbstractBaseShader from "../../base-shader.mjs";
+
+/**
+ * Alternative torch illumination shader
+ */
+declare class FlameIlluminationShader extends AdaptiveIlluminationShader {
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   ...super.defaultUniforms,
+   *   brightnessPulse: 1
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+}
+
+declare namespace FlameIlluminationShader {
+  interface Any extends AnyFlameIlluminationShader {}
+  interface AnyConstructor extends Identity<typeof AnyFlameIlluminationShader> {}
+}
+
+/**
+ * Alternative torch coloration shader
+ */
+declare class FlameColorationShader extends AdaptiveColorationShader {
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   ...super.defaultUniforms,
+   *   brightnessPulse: 1
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+}
+
+declare namespace FlameColorationShader {
+  interface Any extends AnyFlameColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyFlameColorationShader> {}
+}
+
+export { FlameColorationShader, FlameIlluminationShader };
+
+declare abstract class AnyFlameIlluminationShader extends FlameIlluminationShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnyFlameColorationShader extends FlameColorationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/fog.d.mts

@@ -0,0 +1,25 @@
+import type { Identity } from "#utils";
+import type AdaptiveColorationShader from "../coloration-lighting.mjs";
+
+/**
+ * Fog animation coloration shader
+ */
+declare class FogColorationShader extends AdaptiveColorationShader {
+  /**
+   * @defaultValue `true`
+   */
+  static override forceDefaultColor: boolean;
+
+  static override fragmentShader: string;
+}
+
+declare namespace FogColorationShader {
+  interface Any extends AnyFogColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyFogColorationShader> {}
+}
+
+export { FogColorationShader };
+
+declare abstract class AnyFogColorationShader extends FogColorationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/force-grid.d.mts

@@ -0,0 +1,25 @@
+import type { Identity } from "#utils";
+import type AdaptiveColorationShader from "../coloration-lighting.mjs";
+
+/**
+ * A futuristic Force Grid animation.
+ */
+declare class ForceGridColorationShader extends AdaptiveColorationShader {
+  /**
+   * @defaultValue `true`
+   */
+  static override forceDefaultColor: boolean;
+
+  static override fragmentShader: string;
+}
+
+declare namespace ForceGridColorationShader {
+  interface Any extends AnyForceGridColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyForceGridColorationShader> {}
+}
+
+export { ForceGridColorationShader };
+
+declare abstract class AnyForceGridColorationShader extends ForceGridColorationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/ghost-light.d.mts

@@ -0,0 +1,37 @@
+import type { Identity } from "#utils";
+import type AdaptiveColorationShader from "../coloration-lighting.mjs";
+import type AdaptiveIlluminationShader from "../illumination-lighting.mjs";
+
+/**
+ * Ghost light animation illumination shader
+ */
+declare class GhostLightIlluminationShader extends AdaptiveIlluminationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace GhostLightIlluminationShader {
+  interface Any extends AnyGhostLightIlluminationShader {}
+  interface AnyConstructor extends Identity<typeof AnyGhostLightIlluminationShader> {}
+}
+
+/**
+ * Ghost light animation coloration shader
+ */
+declare class GhostLightColorationShader extends AdaptiveColorationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace GhostLightColorationShader {
+  interface Any extends AnyGhostLightColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyGhostLightColorationShader> {}
+}
+
+export { GhostLightColorationShader, GhostLightIlluminationShader };
+
+declare abstract class AnyGhostLightIlluminationShader extends GhostLightIlluminationShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnyGhostLightColorationShader extends GhostLightColorationShader {
+  constructor(...args: never);
+}