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

package/src/foundry/client/pixi/webgl/shaders/samplers/token-ring.d.mts

@@ -0,0 +1,47 @@
+export {};
+
+declare global {
+  /**
+   * The shader definition which powers the TokenRing.
+   */
+  class TokenRingSamplerShader extends PrimaryBaseSamplerShader {
+    /**
+     * @defaultValue `"tokenRingBatch"`
+     */
+    static override classPluginName: string;
+
+    static override batchGeometry: typeof PIXI.BatchGeometry;
+
+    /**
+     * @defaultValue `super.batchVertexSize + 11`
+     */
+    static override batchVertexSize: number;
+
+    /**
+     * @defaultValue `super.reservedTextureUnits + 1`
+     */
+    static override reservedTextureUnits: number;
+
+    /**
+     * A null UVs array used for nulled texture position.
+     * @defaultValue `[0, 0, 0, 0, 0, 0, 0, 0]`
+     */
+    static nullUvs: Float32Array;
+
+    static override batchDefaultUniforms: BatchRenderer.BatchDefaultUniformsFunction;
+
+    protected static override _preRenderBatch: BatchRenderer.PreRenderBatchFunction;
+
+    protected static override _packInterleavedGeometry(
+      element: PIXI.IBatchableElement,
+      attributeBuffer: PIXI.ViewableBuffer,
+      indexBuffer: Uint16Array,
+      aIndex: number,
+      iIndex: number,
+    ): void;
+
+    protected static override _batchVertexShader: string;
+
+    protected static override _batchFragmentShader: string;
+  }
+}

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

@@ -0,0 +1,42 @@
+export {};
+
+declare abstract class AnyBackgroundVisionShader extends BackgroundVisionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace BackgroundVisionShader {
+    type AnyConstructor = typeof AnyBackgroundVisionShader;
+  }
+
+  /**
+   * The default background shader used for vision sources
+   */
+  class BackgroundVisionShader extends AdaptiveVisionShader {
+    static override FRAGMENT_END: string;
+
+    /**
+     * Adjust the intensity according to the difference between the pixel darkness level and the scene darkness level.
+     * Used to see the difference of intensity when computing the background shader which is completeley overlapping
+     * The surface texture.
+     */
+    static ADJUST_INTENSITY: string;
+
+    static override ADJUSTMENTS: string;
+
+    /**
+     * Memory allocations for the Adaptive Background Shader
+     */
+    static SHADER_HEADER: string;
+
+    static override fragmentShader: string;
+
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * Flag whether the background shader is currently required.
+     * 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/vision/base-vision.d.mts

@@ -0,0 +1,31 @@
+export {};
+
+declare abstract class AnyAdaptiveVisionShader extends AdaptiveVisionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AdaptiveVisionShader {
+    type AnyConstructor = typeof AnyAdaptiveVisionShader;
+  }
+
+  /**
+   * This class defines an interface which all adaptive vision shaders extend.
+   */
+  class AdaptiveVisionShader extends AdaptiveLightingShader {
+    static override FRAGMENT_FUNCTIONS: string;
+
+    static override EXPOSURE: string;
+
+    static override COMPUTE_ILLUMINATION: string;
+
+    static override SHADOW: string;
+
+    static override FRAGMENT_BEGIN: string;
+
+    /**
+     * A mapping of available shader techniques
+     */
+    static override SHADER_TECHNIQUES: Record<string, AdaptiveLightingShader.ShaderTechnique>;
+  }
+}

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

@@ -0,0 +1,41 @@
+export {};
+
+declare abstract class AnyColorationVisionShader extends ColorationVisionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace ColorationVisionShader {
+    type AnyConstructor = typeof AnyColorationVisionShader;
+  }
+
+  /**
+   * The default coloration shader used for vision sources.
+   */
+  class ColorationVisionShader extends AdaptiveVisionShader {
+    /**
+     * @defaultValue `""`
+     */
+    static override EXPOSURE: string;
+
+    /**
+     * @defaultValue `""`
+     */
+    static override CONTRAST: string;
+
+    /**
+     * Memory allocations for the Adaptive Coloration Shader
+     */
+    static SHADER_HEADER: string;
+
+    static override fragmentShader: string;
+
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    /**
+     * Flag whether the coloration shader is currently required.
+     * If key uniforms are at their default values, we don't need to render the coloration container.
+     */
+    get isRequired(): boolean;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/vision/effects/amplification.d.mts

@@ -0,0 +1,32 @@
+export {};
+
+declare abstract class AnyAmplificationBackgroundVisionShader extends AmplificationBackgroundVisionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace AmplificationBackgroundVisionShader {
+    type AnyConstructor = typeof AnyAmplificationBackgroundVisionShader;
+  }
+
+  /**
+   * Shader specialized in light amplification
+   */
+  class AmplificationBackgroundVisionShader extends BackgroundVisionShader {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   ...super.defaultUniforms,
+     *   colorTint: [0.38, 0.8, 0.38],
+     *   brightness: 0.5
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    override get isRequired(): boolean;
+  }
+}

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

@@ -0,0 +1,2 @@
+import "./amplification.d.mts";
+import "./wave.d.mts";

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

@@ -0,0 +1,59 @@
+export {};
+
+declare abstract class AnyWaveBackgroundVisionShader extends WaveBackgroundVisionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyWaveColorationVisionShader extends WaveColorationVisionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace WaveBackgroundVisionShader {
+    type AnyConstructor = typeof AnyWaveBackgroundVisionShader;
+  }
+
+  namespace WaveColorationVisionShader {
+    type AnyConstructor = typeof AnyWaveColorationVisionShader;
+  }
+
+  /**
+   * Shader specialized in wave like senses (tremorsenses)
+   */
+  class WaveBackgroundVisionShader extends BackgroundVisionShader {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   ...super.defaultUniforms,
+     *   colorTint: [0.8, 0.1, 0.8]
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    override get isRequired(): boolean;
+  }
+
+  /**
+   * The wave vision shader, used to create waves emanations (ex: tremorsense)
+   */
+  class WaveColorationVisionShader extends ColorationVisionShader {
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   ...super.defaultUniforms,
+     *   colorEffect: [0.8, 0.1, 0.8]
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    override get isRequired(): boolean;
+  }
+}

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

@@ -0,0 +1,36 @@
+export {};
+
+declare abstract class AnyIlluminationVisionShader extends IlluminationVisionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace IlluminationVisionShader {
+    type AnyConstructor = typeof AnyIlluminationVisionShader;
+  }
+
+  /**
+   * The default illumination shader used for vision sources
+   */
+  class IlluminationVisionShader extends AdaptiveVisionShader {
+    static override FRAGMENT_BEGIN: string;
+
+    static override FRAGMENT_END: string;
+
+    /**
+     * Transition between bright and dim colors, if requested
+     */
+    static VISION_COLOR: string;
+
+    static get ADJUSTMENTS(): string;
+
+    /**
+     * Memory allocations for the Adaptive Illumination Shader
+     */
+    static SHADER_HEADER: string;
+
+    static override fragmentShader: string;
+
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+  }
+}

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

@@ -0,0 +1,5 @@
+import "./effects/index.d.mts";
+import "./background-vision.d.mts";
+import "./base-vision.d.mts";
+import "./coloration-vision.d.mts";
+import "./illumination-vision.d.mts";

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

@@ -0,0 +1,106 @@
+import type { InterfaceToObject } from "../../../../../../types/helperTypes.d.mts";
+import type { AnyObject, RemoveIndexSignatures } from "../../../../../../types/utils.d.mts";
+
+declare abstract class AnyAbstractWeatherShader extends AbstractWeatherShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+type AbstractBaseShaderClass = typeof AbstractBaseShader;
+
+interface InternalAbstractWeatherShader_Interface extends AbstractBaseShaderClass {
+  new <_ComputedUniforms extends object>(
+    ...args: ConstructorParameters<typeof AbstractBaseShader>
+  ): AbstractBaseShader & _ComputedUniforms;
+}
+
+declare const InternalAbstractWeatherShader_Const: InternalAbstractWeatherShader_Interface;
+
+// @ts-expect-error - This pattern inherently requires a ts-expect-error as the base class is dynamic.
+class InternalAbstractWeatherShader<
+  DefaultUniforms extends AnyObject,
+  _ComputedUniforms extends object = RemoveIndexSignatures<Extract<DefaultUniforms, AnyObject>>,
+> extends InternalAbstractWeatherShader_Const<_ComputedUniforms> {}
+
+declare global {
+  namespace AbstractWeatherShader {
+    type AnyConstructor = typeof AnyAbstractWeatherShader;
+
+    interface CommonUniforms {
+      terrainUvMatrix: PIXI.Matrix;
+      useOcclusion: boolean;
+      occlusionTexture: PIXI.Matrix | null;
+      reverseOcclusion: boolean;
+      occlusionWeights: number[];
+      useTerrain: boolean;
+      terrainTexture: PIXI.Texture | null;
+      reverseTerrain: boolean;
+      terrainWeights: number[];
+      alpha: number;
+      tint: number[];
+      screenDimensions: [number, number];
+      effectDimensions: [number, number];
+      depthElevation: number;
+      time: number;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    interface DefaultUniforms {}
+  }
+
+  /**
+   * The base shader class for weather shaders.
+   */
+  class AbstractWeatherShader<
+    DefaultUniforms extends AnyObject = InterfaceToObject<AbstractWeatherShader.DefaultUniforms>,
+  > extends InternalAbstractWeatherShader<DefaultUniforms> {
+    constructor(...args: ConstructorParameters<typeof AbstractBaseShader>);
+
+    /**
+     * Compute the weather masking value.
+     */
+    static COMPUTE_MASK: string;
+
+    /**
+     * Compute the weather masking value.
+     */
+    static FRAGMENT_HEADER: string;
+
+    static commonUniforms: AbstractWeatherShader.CommonUniforms;
+
+    /**
+     * Default uniforms for a specific class
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override create<ThisType extends AbstractBaseShader.AnyConstructor>(
+      this: ThisType,
+      initialUniforms?: AbstractBaseShader.Uniforms,
+    ): InstanceType<ThisType>;
+
+    /**
+     * Create the shader program.
+     */
+    static createProgram(): PIXI.Program;
+
+    static override vertexShader: string;
+
+    /**
+     * Update the scale of this effect with new values
+     * @param scale - The desired scale
+     */
+    set scale(scale: number | { x: number; y?: number });
+
+    set scaleX(x: number);
+
+    set scaleY(y: number);
+
+    /**
+     * The speed multiplier applied to animation.
+     * 0 stops animation.
+     * @defaultValue `1`
+     */
+    speed: number;
+
+    protected override _preRender: AbstractBaseShader.PreRenderFunction;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/weather/effect.d.mts

@@ -0,0 +1,62 @@
+import type { InexactPartial } from "../../../../../../types/utils.d.mts";
+
+declare abstract class AnyWeatherShaderEffect extends WeatherShaderEffect<any> {
+  constructor(arg0: never, ...args: never[]);
+}
+
+type QuadMeshClass = typeof QuadMesh;
+
+interface InternalWeatherShaderEffect_Interface extends QuadMeshClass {
+  new <ShaderClassInstance extends object>(
+    ...args: ConstructorParameters<typeof QuadMesh>
+  ): QuadMesh & ShaderClassInstance;
+}
+
+declare const InternalWeatherShaderEffect_Const: InternalWeatherShaderEffect_Interface;
+
+// @ts-expect-error - This pattern inherently requires a ts-expect-error as the base class is dynamic.
+class InternalWeatherShaderEffect<
+  ShaderClass extends AbstractBaseShader.AnyConstructor,
+  _ShaderClassInstance extends object = InstanceType<ShaderClass>,
+> extends InternalWeatherShaderEffect_Const<_ShaderClassInstance> {}
+
+declare global {
+  namespace WeatherShaderEffect {
+    type AnyConstructor = typeof AnyWeatherShaderEffect;
+
+    type WeatherShaderEffectConfig = InexactPartial<AbstractBaseShader.Uniforms & WeatherShaderEffect["shader"]>;
+  }
+
+  /**
+   * An interface for defining shader-based weather effects
+   */
+  class WeatherShaderEffect<
+    ShaderClass extends AbstractWeatherShader.AnyConstructor = AbstractWeatherShader.AnyConstructor,
+  > extends InternalWeatherShaderEffect<ShaderClass> {
+    /**
+     * @param config - The config object to create the shader effect
+     */
+    constructor(config: WeatherShaderEffect.WeatherShaderEffectConfig, shaderClass: ShaderClass);
+
+    /**
+     * Set shader parameters.
+     */
+    configure(config?: WeatherShaderEffect.WeatherShaderEffectConfig): void;
+
+    /**
+     * Begin animation
+     */
+    play(): void;
+
+    /**
+     * Stop animation
+     */
+    stop(): void;
+
+    /**
+     * Initialize the weather effect.
+     * @param config - Config object.
+     */
+    protected _initialize(config: WeatherShaderEffect.WeatherShaderEffectConfig): void;
+  }
+}

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

@@ -0,0 +1,50 @@
+import type { InterfaceToObject } from "../../../../../../types/helperTypes.d.mts";
+
+declare abstract class AnyFogShader extends FogShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace FogShader {
+    type AnyConstructor = typeof AnyFogShader;
+
+    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
+      intensity: number;
+      rotation: number;
+      slope: number;
+    }
+  }
+
+  /**
+   * Fog shader effect.
+   */
+  class FogShader<
+    DefaultUniforms extends FogShader.DefaultUniforms = FogShader.DefaultUniforms,
+  > extends AbstractWeatherShader<InterfaceToObject<DefaultUniforms>> {
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    intensity: 1,
+     *    rotation: 0,
+     *    slope: 0.25
+     * }
+     * ```
+     */
+    static override defaultUniforms: FogShader.DefaultUniforms;
+
+    /**
+     * Configure the number of octaves into the shaders.
+     */
+    static OCTAVES(mode: number): string;
+
+    /**
+     * Configure the fog complexity according to mode (performance).
+     */
+    static FOG(mode: number): string;
+
+    static override createProgram(): PIXI.Program;
+
+    static override fragmentShader(mode: number): string;
+  }
+}

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

@@ -0,0 +1,5 @@
+import "./base-weather.d.mts";
+import "./effect.d.mts";
+import "./fog.d.mts";
+import "./rain.d.mts";
+import "./snow.d.mts";

package/src/foundry/client/pixi/webgl/shaders/weather/rain.d.mts

@@ -0,0 +1,42 @@
+import type { InterfaceToObject } from "../../../../../../types/helperTypes.d.mts";
+
+declare abstract class AnyRainShader extends RainShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace RainShader {
+    type AnyConstructor = typeof AnyRainShader;
+
+    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
+      opacity: number;
+      intensity: number;
+      strength: number;
+      rotation: number;
+      resolution: [number, number];
+    }
+  }
+
+  /**
+   * Rain shader effect.
+   */
+  class RainShader<
+    DefaultUniforms extends RainShader.DefaultUniforms = RainShader.DefaultUniforms,
+  > extends AbstractWeatherShader<InterfaceToObject<DefaultUniforms>> {
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *    opacity: 1,
+     *    intensity: 1,
+     *    strength: 1,
+     *    rotation: 0.5,
+     *    resolution: [3200, 80] // The resolution to have nice rain ropes with the voronoi cells
+     * }
+     * ```
+     */
+    static override defaultUniforms: RainShader.DefaultUniforms;
+
+    static override fragmentShader: string;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/weather/snow.d.mts

@@ -0,0 +1,34 @@
+import type { InterfaceToObject } from "../../../../../../types/helperTypes.d.mts";
+
+declare abstract class AnySnowShader extends SnowShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace SnowShader {
+    type AnyConstructor = typeof AnySnowShader;
+
+    interface DefaultUniforms extends AbstractBaseShader.Uniforms {
+      direction: number;
+    }
+  }
+
+  /**
+   * Snow shader effect.
+   */
+  class SnowShader<
+    DefaultUniforms extends SnowShader.DefaultUniforms = SnowShader.DefaultUniforms,
+  > extends AbstractWeatherShader<InterfaceToObject<DefaultUniforms>> {
+    /**
+     * @defaultValue
+     * ```
+     * {
+     *  direction: 1.2
+     * }
+     * ```
+     */
+    static override defaultUniforms: SnowShader.DefaultUniforms;
+
+    static override fragmentShader: string;
+  }
+}

package/src/foundry/client/pixi/workers/index.d.mts

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