@league-of-foundry-developers/foundry-vtt-types 9.255.3 → 9.268.2

package/src/foundry/{foundry.js/pointSources/lightSource.d.ts → client/pixi/sources/light-source.d.ts}

@@ -1,4 +1,4 @@
-import type { ConfiguredObjectClassForName } from '../../../types/helperTypes';
+import type { ConfiguredObjectClassForName } from '../../../../types/helperTypes';
 
 declare global {
   /** @see {@link foundry.data.LightData} */
@@ -160,8 +160,7 @@ declare global {
      */
     coloration: PIXI.Mesh;
 
-    /** @override */
-    static sourceType: 'light';
+    static override sourceType: 'light';
 
     /**
      * Strength of the blur for light source edges
@@ -347,7 +346,6 @@ declare global {
     /**
      * A torch animation where the luminosity and coloration decays each frame and is revitalized by flashes
      * @param dt        - Delta time
-     *                    (unused)
      * @param speed     - The animation speed, from 1 to 10
      *                    (default: `5`)
      * @param intensity - The animation intensity, from 1 to 10
@@ -358,7 +356,6 @@ declare global {
     /**
      * A basic "pulse" animation which expands and contracts.
      * @param dt        - Delta time
-     *                    (unused)
      * @param speed     - The animation speed, from 1 to 10
      *                    (default: `5`)
      * @param intensity - The animation intensity, from 1 to 10
@@ -374,7 +371,6 @@ declare global {
     /**
      * Emanate waves of light from the source origin point
      * @param dt        - Delta time
-     *                    (unused)
      * @param speed     - The animation speed, from 1 to 10
      *                    (default: `5`)
      * @param intensity - The animation intensity, from 1 to 10

package/src/foundry/{foundry.js/pointSources/soundSource.d.ts → client/pixi/sources/sound-source.d.ts}

@@ -1,4 +1,4 @@
-import type { ConfiguredObjectClassForName } from '../../../types/helperTypes';
+import type { ConfiguredObjectClassForName } from '../../../../types/helperTypes';
 
 declare global {
   interface SoundSourceData extends PointSource.Data {
@@ -19,8 +19,7 @@ declare global {
     /** @param object - The AmbientSound object that generates this sound source */
     constructor(object: InstanceType<ConfiguredObjectClassForName<'AmbientSound'>>);
 
-    /** @override */
-    static sourceType: 'sound';
+    static override sourceType: 'sound';
 
     /**
      * The object of data which configures how the source is rendered

package/src/foundry/{foundry.js/pointSources/visionSource.d.ts → client/pixi/sources/vision-source.d.ts}

@@ -1,4 +1,4 @@
-import type { ConfiguredObjectClassForName } from '../../../types/helperTypes';
+import type { ConfiguredObjectClassForName } from '../../../../types/helperTypes';
 
 declare global {
   interface VisionSourceData extends Exclude<PointSource.Data, 'walls'> {
@@ -35,8 +35,7 @@ declare global {
      */
     illumination: PIXI.Mesh;
 
-    /** @override */
-    static sourceType: 'vision';
+    static override sourceType: 'vision';
 
     /**
      * Keys in the VisionSourceData structure which, when modified, change the appearance of the source
@@ -119,7 +118,6 @@ declare global {
      */
     protected _updateIlluminationUniforms(shader: AdaptiveIlluminationShader): void;
 
-    /** @override */
-    protected _drawRenderTextureContainer(): PIXI.Container;
+    protected override _drawRenderTextureContainer(): PIXI.Container;
   }
 }

package/src/foundry/client/pixi/webgl/filters.d.ts

@@ -0,0 +1,182 @@
+/**
+ * This class defines an interface for masked custom filters
+ */
+declare abstract class AbstractBaseMaskFilter extends PIXI.Filter {
+  /**
+   * The default vertex shader used by all instances of AbstractBaseMaskFilter
+   */
+  static vertexShader: string;
+
+  /**
+   * The fragment shader which renders this filter.
+   * A subclass of AbstractBaseMaskFilter must implement the fragmentShader(channel) static field.
+   */
+  static fragmentShader: ((channel: 'r' | 'g' | 'b') => string) | null;
+
+  /**
+   * A factory method for creating the filter using its defined default values
+   * @param defaultUniforms - Initial uniforms provided to the filter
+   *                          (default: `{}`)
+   * @param channel         - A color channel to target for masking.
+   *                          (default: `'r'`)
+   */
+  static create<T extends AbstractBaseMaskFilter>(
+    this: ConstructorOf<T>,
+    defaultUniforms?: ConstructorParameters<typeof PIXI.Filter>[2],
+    channel?: 'r' | 'g' | 'b'
+  ): T;
+
+  override apply(
+    filterManager: PIXI.systems.FilterSystem,
+    input: PIXI.RenderTexture,
+    output: PIXI.RenderTexture,
+    clear: PIXI.CLEAR_MODES,
+    currentState: any
+  ): void;
+}
+
+/**
+ * A filter used to control channels intensity using an externally provided mask texture.
+ * The mask channel used must be provided at filter creation.
+ * Contributed by SecretFire#4843
+ */
+declare class InverseOcclusionMaskFilter extends AbstractBaseMaskFilter {
+  static fragmentShader(channel: 'r' | 'g' | 'b'): string;
+
+  /**
+   * @param defaultUniforms - (default: `{}`)
+   * @param channel  - (default `'r'`)
+   */
+  static create<T extends InverseOcclusionMaskFilter>(
+    this: ConstructorOf<T>,
+    defaultUniforms?: ConstructorParameters<typeof PIXI.Filter>[2],
+    channel?: 'r' | 'g' | 'b'
+  ): T;
+}
+
+/**
+ * An abstract filter which provides a framework for reusable definition
+ */
+declare abstract class AbstractFilter extends PIXI.Filter {
+  /**
+   * The default uniforms used by the filter
+   * @defaultValue `{}`
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  /**
+   * The fragment shader which renders this filter.
+   * @defaultValue `undefined`
+   * @remarks This is a function in {@link GlowFilter}. See https://gitlab.com/foundrynet/foundryvtt/-/issues/6937
+   */
+  static fragmentShader: string | ((quality: number, distance: number) => string) | undefined;
+
+  /**
+   * The vertex shader which renders this filter.
+   * @defaultValue `undefined`
+   */
+  static vertexShader: string | undefined;
+
+  /**
+   * A factory method for creating the filter using its defined default values
+   * @param uniforms - (default: `{}`)
+   */
+  static create(uniforms: AbstractBaseShader.Uniforms): AbstractFilter;
+
+  /**
+   * Always target the resolution of the render texture or renderer
+   */
+  // @ts-expect-error this is a property on PIXI.Filter
+  get resolution(): number;
+  set resolution(value: number);
+
+  /**
+   * Always target the MSAA level of the render texture or renderer
+   */
+  get multisample(): PIXI.MSAA_QUALITY;
+  set multisample(value: PIXI.MSAA_QUALITY);
+}
+
+/**
+ * A filter which forces all non-transparent pixels to a specific color and transparency.
+ */
+declare class ForceColorFilter extends AbstractFilter {
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   color: [1, 1, 1],
+   *   alpha: 1.0
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static fragmentShader: string;
+}
+
+/**
+ * A filter which is rendering explored color according to FoW intensity.
+ */
+declare class FogColorFilter extends AbstractFilter {
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   exploredColor: [1, 1, 1]
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static fragmentShader: string;
+}
+
+/**
+ * This filter turns pixels with an alpha channel &lt; alphaThreshold in transparent pixels
+ * Then, optionally, it can turn the result in the chosen color (default: pure white).
+ * The alpha [threshold,1] is re-mapped to [0,1] with an hermite interpolation slope to prevent pixelation.
+ */
+declare class RoofMaskFilter extends AbstractFilter {
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   alphaThreshold: 0.75,
+   *   turnToColor: false,
+   *   color: [1, 1, 1]
+   * }
+   * ```
+   */
+  static defaultUniforms: AbstractBaseShader.Uniforms;
+
+  static fragmentShader: string;
+}
+
+/**
+ * A filter which implements an inner or outer glow around the source texture.
+ * Incorporated from https://github.com/pixijs/filters/tree/main/filters/glow
+ */
+declare class GlowFilter extends AbstractFilter {
+  /**
+   * @defaultValue
+   * ```typescript
+   * {
+   *   distance: 10,
+   *   innerStrength: 0,
+   *   glowColor: [1, 1, 1, 1],
+   *   quality: 0.1,
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms & { distance: number; quality: number };
+
+  /**
+   * @remarks This could change, see https://gitlab.com/foundrynet/foundryvtt/-/issues/6937
+   */
+  static override fragmentShader(quality: number, distance: number): string;
+
+  static override vertexShader: string;
+
+  static override create(uniforms: AbstractBaseShader.Uniforms): GlowFilter;
+}

package/src/foundry/client/pixi/webgl/index.d.ts

@@ -0,0 +1,5 @@
+import './base';
+import './blend_modes';
+import './filters';
+import './lighting';
+import './sampler';