@league-of-foundry-developers/foundry-vtt-types 13.340.1 → 13.345.1

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/hexa-dome.d.mts

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

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

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

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/magical-gloom.d.mts

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

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

@@ -0,0 +1,49 @@
+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";
+
+/**
+ * Pulse animation illumination shader
+ */
+declare class PulseIlluminationShader extends AdaptiveIlluminationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace PulseIlluminationShader {
+  interface Any extends AnyPulseIlluminationShader {}
+  interface AnyConstructor extends Identity<typeof AnyPulseIlluminationShader> {}
+}
+
+/**
+ * Pulse animation coloration shader
+ */
+declare class PulseColorationShader extends AdaptiveColorationShader {
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   ...super.defaultUniforms,
+   *   pulse: 0
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+}
+
+declare namespace PulseColorationShader {
+  interface Any extends AnyPulseColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyPulseColorationShader> {}
+}
+
+export { PulseColorationShader, PulseIlluminationShader };
+
+declare abstract class AnyPulseColorationShader extends PulseColorationShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnyPulseIlluminationShader extends PulseIlluminationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/radial-rainbow.d.mts

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

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

@@ -0,0 +1,39 @@
+import type { Identity } from "#utils";
+import type AdaptiveColorationShader from "../coloration-lighting.mjs";
+import type AbstractBaseShader from "../../base-shader.mjs";
+
+/**
+ * Revolving animation coloration shader
+ */
+declare class RevolvingColorationShader extends AdaptiveColorationShader {
+  /**
+   * @defaultValue `true`
+   */
+  static override forceDefaultColor: boolean;
+
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   ...super.defaultUniforms,
+   *   angle: 0,
+   *   gradientFade: 0.15,
+   *   beamLength: 1
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+}
+
+declare namespace RevolvingColorationShader {
+  interface Any extends AnyRevolvingColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyRevolvingColorationShader> {}
+}
+
+export { RevolvingColorationShader };
+
+declare abstract class AnyRevolvingColorationShader extends RevolvingColorationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/roiling-mass.d.mts

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

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

@@ -0,0 +1,66 @@
+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";
+
+/**
+ * Siren light animation coloration shader
+ */
+declare class SirenColorationShader extends AdaptiveColorationShader {
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   ...super.defaultUniforms,
+   *   ratio: 0,
+   *   brightnessPulse: 1,
+   *   angle: 0,
+   *   gradientFade: 0.15,
+   *   beamLength: 1
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+}
+
+declare namespace SirenColorationShader {
+  interface Any extends AnySirenColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnySirenColorationShader> {}
+}
+
+/**
+ * Siren light animation illumination shader
+ */
+declare class SirenIlluminationShader extends AdaptiveIlluminationShader {
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   ...super.defaultUniforms,
+   *   angle: 0,
+   *   gradientFade: 0.45,
+   *   beamLength: 1
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+}
+
+declare namespace SirenIlluminationShader {
+  interface Any extends AnySirenIlluminationShader {}
+  interface AnyConstructor extends Identity<typeof AnySirenIlluminationShader> {}
+}
+
+export { SirenColorationShader, SirenIlluminationShader };
+
+declare abstract class AnySirenColorationShader extends SirenColorationShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnySirenIlluminationShader extends SirenIlluminationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/smoke-patch.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";
+
+/**
+ * A patch of smoke
+ */
+declare class SmokePatchColorationShader extends AdaptiveColorationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace SmokePatchColorationShader {
+  interface Any extends AnySmokePatchColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnySmokePatchColorationShader> {}
+}
+
+/**
+ * A patch of smoke
+ */
+declare class SmokePatchIlluminationShader extends AdaptiveIlluminationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace SmokePatchIlluminationShader {
+  interface Any extends AnySmokePatchIlluminationShader {}
+  interface AnyConstructor extends Identity<typeof AnySmokePatchIlluminationShader> {}
+}
+
+export { SmokePatchColorationShader, SmokePatchIlluminationShader };
+
+declare abstract class AnySmokePatchColorationShader extends SmokePatchColorationShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnySmokePatchIlluminationShader extends SmokePatchIlluminationShader {
+  constructor(...args: never);
+}

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

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

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/sunburst.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";
+
+/**
+ * Sunburst animation illumination shader
+ */
+declare class SunburstIlluminationShader extends AdaptiveIlluminationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace SunburstIlluminationShader {
+  interface Any extends AnySunburstIlluminationShader {}
+  interface AnyConstructor extends Identity<typeof AnySunburstIlluminationShader> {}
+}
+
+/**
+ * Sunburst animation coloration shader
+ */
+declare class SunburstColorationShader extends AdaptiveColorationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace SunburstColorationShader {
+  interface Any extends AnySunburstColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnySunburstColorationShader> {}
+}
+
+export { SunburstColorationShader, SunburstIlluminationShader };
+
+declare abstract class AnySunburstColorationShader extends SunburstColorationShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnySunburstIlluminationShader extends SunburstIlluminationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/swirling-rainbow.d.mts

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

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

@@ -0,0 +1,50 @@
+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";
+
+/**
+ * Allow coloring of illumination
+ */
+declare class TorchIlluminationShader extends AdaptiveIlluminationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace TorchIlluminationShader {
+  interface Any extends AnyTorchIlluminationShader {}
+  interface AnyConstructor extends Identity<typeof AnyTorchIlluminationShader> {}
+}
+
+/**
+ * Torch animation coloration shader
+ */
+declare class TorchColorationShader extends AdaptiveColorationShader {
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   ...super.defaultUniforms,
+   *   ratio: 0,
+   *   brightnessPulse: 1
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+}
+
+declare namespace TorchColorationShader {
+  interface Any extends AnyTorchColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyTorchColorationShader> {}
+}
+
+export { TorchColorationShader, TorchIlluminationShader };
+
+declare abstract class AnyTorchColorationShader extends TorchColorationShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnyTorchIlluminationShader extends TorchIlluminationShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/lighting/effects/vortex.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";
+
+/**
+ * Vortex animation coloration shader
+ */
+declare class VortexColorationShader extends AdaptiveColorationShader {
+  /**
+   * @defaultValue `true`
+   */
+  static override forceDefaultColor: boolean;
+
+  static override fragmentShader: string;
+}
+
+declare namespace VortexColorationShader {
+  interface Any extends AnyVortexColorationShader {}
+  interface AnyConstructor extends Identity<typeof AnyVortexColorationShader> {}
+}
+
+/**
+ * Vortex animation coloration shader
+ */
+declare class VortexIlluminationShader extends AdaptiveIlluminationShader {
+  static override fragmentShader: string;
+}
+
+declare namespace VortexIlluminationShader {
+  interface Any extends AnyVortexIlluminationShader {}
+  interface AnyConstructor extends Identity<typeof AnyVortexIlluminationShader> {}
+}
+
+export { VortexColorationShader, VortexIlluminationShader };
+
+declare abstract class AnyVortexColorationShader extends VortexColorationShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnyVortexIlluminationShader extends VortexIlluminationShader {
+  constructor(...args: never);
+}

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

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

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

@@ -0,0 +1,79 @@
+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 AdaptiveIlluminationShader extends AdaptiveLightingShader {
+  static override FRAGMENT_END: string;
+
+  /**
+   * The adjustments made into fragment shaders
+   */
+  static get ADJUSTMENTS(): string;
+
+  static override EXPOSURE: string;
+
+  /**
+   * Memory allocations for the Adaptive Illumination Shader
+   */
+  static SHADER_HEADER: string;
+
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   technique: 1,     // overwritten by LightData.cleanData().coloration 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
+   *   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
+   *   contrast: 0,      // overwritten by LightData.cleanData().contrast in a subsequent static init block
+   *   exposure: 0,
+   *   ratio: 0.5,
+   *   darknessLevel: 0,
+   *   color: [1, 1, 1],
+   *   colorBackground: [1, 1, 1],
+   *   colorDim: [1, 1, 1],
+   *   colorBright: [1, 1, 1],
+   *   screenDimensions: [1, 1],
+   *   time: 0,
+   *   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 illumination shader is currently required.
+   */
+  get isRequired(): boolean;
+}
+
+declare namespace AdaptiveIlluminationShader {
+  interface Any extends AnyAdaptiveIlluminationShader {}
+  interface AnyConstructor extends Identity<typeof AnyAdaptiveIlluminationShader> {}
+}
+
+export default AdaptiveIlluminationShader;
+
+declare abstract class AnyAdaptiveIlluminationShader extends AdaptiveIlluminationShader {
+  constructor(...args: never);
+}