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

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/hexa-dome.d.mts

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

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

@@ -0,0 +1,25 @@
+import "./bewitching-wave.d.mts";
+import "./black-hole.d.mts";
+import "./chroma.d.mts";
+import "./emanation.d.mts";
+import "./energy-field.d.mts";
+import "./fairy-light.d.mts";
+import "./flame.d.mts";
+import "./fog.d.mts";
+import "./force-grid.d.mts";
+import "./ghost-light.d.mts";
+import "./hexa-dome.d.mts";
+import "./light-dome.d.mts";
+import "./magical-gloom.d.mts";
+import "./pulse.d.mts";
+import "./radial-rainbow.d.mts";
+import "./revolving-light.d.mts";
+import "./roiling-mass.d.mts";
+import "./siren-light.d.mts";
+import "./smoke-patch.d.mts";
+import "./star-light.d.mts";
+import "./sunburst.d.mts";
+import "./swirling-rainbow.d.mts";
+import "./torch.d.mts";
+import "./vortex.d.mts";
+import "./wave.d.mts";

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

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

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/magical-gloom.d.mts

@@ -0,0 +1,18 @@
+export {};
+
+declare abstract class AnyMagicalGloomDarknessShader extends MagicalGloomDarknessShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace MagicalGloomDarknessShader {
+    type AnyConstructor = typeof AnyMagicalGloomDarknessShader;
+  }
+
+  /**
+   * Creates a gloomy ring of pure darkness.
+   */
+  class MagicalGloomDarknessShader extends AdaptiveDarknessShader {
+    static override fragmentShader: string;
+  }
+}

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

@@ -0,0 +1,44 @@
+export {};
+
+declare abstract class AnyPulseColorationShader extends PulseColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyPulseIlluminationShader extends PulseIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace PulseColorationShader {
+    type AnyConstructor = typeof AnyPulseColorationShader;
+  }
+
+  namespace PulseIlluminationShader {
+    type AnyConstructor = typeof AnyPulseIlluminationShader;
+  }
+
+  /**
+   * Pulse animation illumination shader
+   */
+  class PulseIlluminationShader extends AdaptiveIlluminationShader {
+    static override fragmentShader: string;
+  }
+
+  /**
+   * Pulse animation coloration shader
+   */
+  class PulseColorationShader extends AdaptiveColorationShader {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   ...super.defaultUniforms,
+     *   pulse: 0
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/radial-rainbow.d.mts

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

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

@@ -0,0 +1,36 @@
+export {};
+
+declare abstract class AnyRevolvingColorationShader extends RevolvingColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace RevolvingColorationShader {
+    type AnyConstructor = typeof AnyRevolvingColorationShader;
+  }
+
+  /**
+   * Revolving animation coloration shader
+   */
+  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;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/roiling-mass.d.mts

@@ -0,0 +1,18 @@
+export {};
+
+declare abstract class AnyRoilingDarknessShader extends RoilingDarknessShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace RoilingDarknessShader {
+    type AnyConstructor = typeof AnyRoilingDarknessShader;
+  }
+
+  /**
+   * Roiling mass illumination shader - intended primarily for darkness
+   */
+  class RoilingDarknessShader extends AdaptiveIlluminationShader {
+    static override fragmentShader: string;
+  }
+}

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

@@ -0,0 +1,61 @@
+export {};
+
+declare abstract class AnySirenColorationShader extends SirenColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnySirenIlluminationShader extends SirenIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace SirenColorationShader {
+    type AnyConstructor = typeof AnySirenColorationShader;
+  }
+
+  namespace SirenIlluminationShader {
+    type AnyConstructor = typeof AnySirenIlluminationShader;
+  }
+
+  /**
+   * Siren light animation coloration shader
+   */
+  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;
+  }
+
+  /**
+   * Siren light animation illumination shader
+   */
+  class SirenIlluminationShader extends AdaptiveIlluminationShader {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   ...super.defaultUniforms,
+     *   angle: 0,
+     *   gradientFade: 0.45,
+     *   beamLength: 1
+     * }
+     * ```
+     */
+    static defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/smoke-patch.d.mts

@@ -0,0 +1,32 @@
+export {};
+
+declare abstract class AnySmokePatchColorationShader extends SmokePatchColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnySmokePatchIlluminationShader extends SmokePatchIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace SmokePatchColorationShader {
+    type AnyConstructor = typeof AnySmokePatchColorationShader;
+  }
+
+  namespace SmokePatchIlluminationShader {
+    type AnyConstructor = typeof AnySmokePatchIlluminationShader;
+  }
+
+  /**
+   * A patch of smoke
+   */
+  class SmokePatchColorationShader extends AdaptiveColorationShader {
+    static override fragmentShader: string;
+  }
+  /**
+   * A patch of smoke
+   */
+  class SmokePatchIlluminationShader extends AdaptiveIlluminationShader {
+    static override fragmentShader: string;
+  }
+}

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

@@ -0,0 +1,23 @@
+export {};
+
+declare abstract class AnyStarLightColorationShader extends StarLightColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace StarLightColorationShader {
+    type AnyConstructor = typeof AnyStarLightColorationShader;
+  }
+
+  /**
+   * A disco like star light.
+   */
+  class StarLightColorationShader extends AdaptiveColorationShader {
+    /**
+     * @defaultValue `true`
+     */
+    static override forceDefaultColor: boolean;
+
+    static override fragmentShader: string;
+  }
+}

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

@@ -0,0 +1,33 @@
+export {};
+
+declare abstract class AnySunburstColorationShader extends SunburstColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnySunburstIlluminationShader extends SunburstIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace SunburstColorationShader {
+    type AnyConstructor = typeof AnySunburstColorationShader;
+  }
+
+  namespace SunburstIlluminationShader {
+    type AnyConstructor = typeof AnySunburstIlluminationShader;
+  }
+
+  /**
+   * Sunburst animation illumination shader
+   */
+  class SunburstIlluminationShader extends AdaptiveIlluminationShader {
+    static override fragmentShader: string;
+  }
+
+  /**
+   * Sunburst animation coloration shader
+   */
+  class SunburstColorationShader extends AdaptiveColorationShader {
+    static override fragmentShader: string;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/swirling-rainbow.d.mts

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

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

@@ -0,0 +1,45 @@
+export {};
+
+declare abstract class AnyTorchColorationShader extends TorchColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyTorchIlluminationShader extends TorchIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace TorchColorationShader {
+    type AnyConstructor = typeof AnyTorchColorationShader;
+  }
+
+  namespace TorchIlluminationShader {
+    type AnyConstructor = typeof AnyTorchIlluminationShader;
+  }
+
+  /**
+   * Allow coloring of illumination
+   */
+  class TorchIlluminationShader extends AdaptiveIlluminationShader {
+    static override fragmentShader: string;
+  }
+
+  /**
+   * Torch animation coloration shader
+   */
+  class TorchColorationShader extends AdaptiveColorationShader {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   ...super.defaultUniforms,
+     *   ratio: 0,
+     *   brightnessPulse: 1
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+}

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

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

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

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

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

@@ -0,0 +1,79 @@
+export {};
+
+declare abstract class AnyAdaptiveIlluminationShader extends AdaptiveIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AdaptiveIlluminationShader {
+    type AnyConstructor = typeof AnyAdaptiveIlluminationShader;
+  }
+
+  /**
+   * The default coloration shader used by standard rendering and animations
+   * A fragment shader which creates a solid light source.
+   */
+  class AdaptiveIlluminationShader extends AdaptiveLightingShader {
+    static override FRAGMENT_BEGIN: string;
+
+    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,
+     *   shadows: 0,
+     *   saturation: 0,
+     *   intensity: 5,
+     *   attenuation: 0.5,
+     *   contrast: 0,
+     *   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,
+     *   framebufferTexture: 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;
+  }
+}

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

@@ -0,0 +1,6 @@
+import "./base-lighting.d.mts";
+import "./background-lighting.d.mts";
+import "./coloration-lighting.d.mts";
+import "./darkness-lighting.d.mts";
+import "./illumination-lighting.d.mts";
+import "./effects/index.d.mts";

package/src/foundry/client/pixi/webgl/shaders/region/adjust-darkness-level.d.mts

@@ -0,0 +1,93 @@
+export {};
+
+declare abstract class AnyAbstractDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyAdjustDarknessLevelRegionShader extends AdjustDarknessLevelRegionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyIlluminationDarknessLevelRegionShader extends IlluminationDarknessLevelRegionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AbstractDarknessLevelRegionShader {
+    type AnyConstructor = typeof AnyAbstractDarknessLevelRegionShader;
+  }
+
+  namespace AdjustDarknessLevelRegionShader {
+    type AnyConstructor = typeof AnyAdjustDarknessLevelRegionShader;
+  }
+
+  namespace IlluminationDarknessLevelRegionShader {
+    type AnyConstructor = typeof AnyIlluminationDarknessLevelRegionShader;
+  }
+
+  /**
+   * Abstract shader used for Adjust Darkness Level region behavior.
+   * @remarks Foundry labeled as abstract
+   */
+  class AbstractDarknessLevelRegionShader extends RegionShader {
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   ...super.defaultUniforms,
+     *   bottom: 0,
+     *   top: 0,
+     *   depthTexture: null
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * The darkness level adjustment mode.
+     * @defaultValue `foundry.data.regionBehaviors.AdjustDarknessLevelRegionBehaviorType.MODES.OVERRIDE`
+     * TODO: make into typeof... when referenced class is available
+     */
+    mode: number;
+
+    /**
+     * The darkness level modifier.
+     * @defaultValue `0`
+     */
+    modifier: number;
+
+    /**
+     * Current darkness level of this mesh.
+     */
+    get darknessLevel(): number;
+
+    protected override _preRender: AbstractBaseShader.PreRenderFunction;
+  }
+
+  /**
+   * Render the RegionMesh with darkness level adjustments.
+   */
+  class AdjustDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   ...super.defaultUniforms,
+     *   darknessLevel: 0
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    protected override _preRender: AbstractBaseShader.PreRenderFunction;
+  }
+
+  /**
+   * Render the RegionMesh with darkness level adjustments.
+   */
+  class IlluminationDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
+    static override fragmentShader: string;
+  }
+}