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

package/src/foundry/client-esm/canvas/sources/point-sound-source.d.mts

@@ -0,0 +1,29 @@
+import type BaseEffectSource from "./base-effect-source.d.mts";
+import type PointEffectSourceMixin from "./point-effect-source.d.mts";
+
+type SoundSourceData = PointEffectSourceMixin.PointEffectSourceData & BaseEffectSource.BaseEffectSourceData;
+
+/**
+ * A specialized subclass of the BaseEffectSource which describes a point-based source of sound.
+ */
+export default class PointSoundSource<
+  SourceData extends SoundSourceData = SoundSourceData,
+  SourceShape extends PointSourcePolygon = PointSourcePolygon,
+> extends PointEffectSourceMixin(BaseEffectSource)<SourceData, SourceShape> {
+  /** @defaultValue `"sound"` */
+  static override sourceType: string;
+
+  override get effectsCollection(): Collection<this>;
+
+  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+
+  /**
+   * Get the effective volume at which an AmbientSound source should be played for a certain listener.
+   */
+  getVolumeMultiplier(
+    listener: Canvas.Point,
+    options?: {
+      easing?: boolean | undefined;
+    },
+  ): number;
+}

package/src/foundry/client-esm/canvas/sources/point-vision-source.d.mts

@@ -0,0 +1,212 @@
+import type RenderedEffectSource from "./rendered-effect-source.d.mts";
+import type PointEffectSourceMixin from "./point-effect-source.d.mts";
+
+/**
+ * A specialized subclass of RenderedEffectSource which represents a source of point-based vision.
+ */
+declare class PointVisionSource<
+  SourceData extends PointVisionSource.VisionSourceData = PointVisionSource.VisionSourceData,
+> extends PointEffectSourceMixin(RenderedEffectSource)<SourceData> {
+  /** @defaultValue `"sight"` */
+  static override sourceType: string;
+
+  /** @defaultValue `["visionMode", "blinded"]` */
+  static override _initializeShaderKeys: string[];
+
+  /** @defaultValue `["radius", "color", "attenuation", "brightness", "contrast", "saturation", "visionMode"]` */
+  static override _refreshUniformsKeys: string[];
+
+  /**
+   * The corresponding lighting levels for dim light.
+   * @defaultValue `LIGHTING_LEVELS.DIM`
+   */
+  protected static _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
+
+  /**
+   * The corresponding lighting levels for bright light.
+   * @defaultValue `LIGHTING_LEVELS.BRIGHT`
+   */
+  protected static _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
+
+  /** @defaultValue `"visionSources"` */
+  static override effectsCollection: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   * ...super.defaultData,
+   * contrast: 0,
+   * attenuation: 0.5,
+   * saturation: 0,
+   * brightness: 0,
+   * visionMode: "basic",
+   * lightRadius: null
+   * }
+   * ```
+   */
+  static override defaultData: PointVisionSourceData;
+
+  static get _layers(): Record<string, RenderedEffectSource.RenderedEffectLayerConfig>;
+
+  /**
+   * The vision mode linked to this VisionSource
+   */
+  visionMode: VisionMode | null;
+
+  /**
+   * The vision mode activation flag for handlers
+   * @internal
+   */
+  _visionModeActivated: boolean;
+
+  /**
+   * The unconstrained LOS polygon.
+   */
+  los: PointSourcePolygon;
+
+  /**
+   * The polygon of light perception.
+   */
+  light: PointSourcePolygon;
+
+  /**
+   * An alias for the shape of the vision source.
+   */
+  get fov(): PIXI.Polygon | PointSourcePolygon;
+
+  /**
+   * If this vision source background is rendered into the lighting container.
+   */
+  get preferred(): boolean;
+
+  /**
+   * Is the rendered source animated?
+   */
+  get isAnimated(): boolean;
+
+  /**
+   * Light perception radius of this vision source, taking into account if the source is blinded.
+   */
+  get lightRadius(): number;
+
+  override get radius(): number;
+
+  /**
+   * Is this source temporarily blinded?
+   */
+  get isBlinded(): boolean;
+
+  /**
+   * Records of blinding strings with a boolean value.
+   * By default, if any of this record is true, the source is blinded.
+   */
+  blinded: Record<string, boolean>;
+
+  /**
+   * Data overrides that could happen with blindness vision mode.
+   */
+  visionModeOverrides: object;
+
+  override _initialize(data: Partial<SourceData>): void;
+
+  override _createShapes(): void;
+
+  override shape: PointSourcePolygon;
+
+  /**
+   * Responsible for assigning the Vision Mode and calling the activation and deactivation handlers.
+   */
+  protected _updateVisionMode(): void;
+
+  override _configure(changes: Partial<SourceData>): void;
+
+  override _configureLayer(layer: Record<string, unknown>, layerId: string): void;
+
+  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+
+  /**
+   * Creates the polygon that represents light perception.
+   * If the light perception radius is unconstrained, no new polygon instance is created;
+   * instead the LOS polygon of this vision source is returned.
+   * @returns The new polygon or `this.los`.
+   */
+  protected _createLightPolygon(): PointSourcePolygon;
+
+  /**
+   * Create a restricted FOV polygon by limiting the radius of the unrestricted LOS polygon.
+   * If the vision radius is unconstrained, no new polygon instance is created;
+   * instead the LOS polygon of this vision source is returned.
+   * @returns The new polygon or `this.los`.
+   */
+  protected _createRestrictedPolygon(): PointSourcePolygon;
+
+  override _configureShaders(): {
+    background: AdaptiveLightingShader;
+    coloration: AdaptiveLightingShader;
+    illumination: AdaptiveLightingShader;
+  };
+
+  override _updateColorationUniforms(): void;
+
+  override _updateIlluminationUniforms(): void;
+
+  override _updateBackgroundUniforms(): void;
+
+  override _updateCommonUniforms(shader: AbstractBaseShader): void;
+
+  /**
+   * Update layer uniforms according to vision mode uniforms, if any.
+   * @param shader     - The shader being updated.
+   * @param vmUniforms - The targeted layer.
+   */
+  protected _updateVisionModeUniforms(shader: AdaptiveVisionShader, vmUniforms: AbstractBaseShader.Uniforms): void;
+}
+
+declare namespace PointVisionSource {
+  type Any = PointVisionSource<VisionSourceData>;
+
+  interface VisionSourceData
+    extends RenderedEffectSource.RenderedEffectSourceData,
+      PointEffectSourceMixin.PointEffectSourceData {
+    /**
+     * The amount of contrast
+     */
+    contrast: number;
+
+    /**
+     * Strength of the attenuation between bright, dim, and dark
+     */
+    attenuation: number;
+
+    /**
+     * The amount of color saturation
+     */
+    saturation: number;
+
+    /**
+     * The vision brightness.
+     */
+    brightness: number;
+
+    /**
+     * The vision mode.
+     */
+    visionMode: string;
+
+    /**
+     * The range of light perception.
+     */
+    lightRadius: number;
+
+    /**
+     * Is this vision source blinded?
+     */
+    blinded: boolean;
+  }
+}
+
+type PointVisionSourceData = PointEffectSourceMixin.PointEffectSourceData &
+  RenderedEffectSource.RenderedEffectSourceData;
+
+export default PointVisionSource;

package/src/foundry/client-esm/canvas/sources/rendered-effect-source.d.mts

@@ -0,0 +1,330 @@
+import type { AnyFunction, InexactPartial } from "../../../../types/utils.d.mts";
+import type BaseEffectSource from "./base-effect-source.d.mts";
+
+// TODO: Remove after shaders are done
+type AdaptiveDarknessShader = unknown;
+
+/**
+ * An abstract class which extends the base PointSource to provide common functionality for rendering.
+ * This class is extended by both the LightSource and VisionSource subclasses.
+ */
+declare class RenderedEffectSource<
+  SourceData extends RenderedEffectSource.RenderedEffectSourceData = RenderedEffectSource.RenderedEffectSourceData,
+  SourceShape extends PIXI.Polygon = PIXI.Polygon,
+  RenderingLayers extends Record<string, RenderedEffectSource.RenderedEffectSourceLayer> = RenderedEffectSource.Layers,
+> extends BaseEffectSource<SourceData, SourceShape> {
+  /**
+   * Keys of the data object which require shaders to be re-initialized.
+   */
+  protected static _initializeShaderKeys: string[];
+
+  /**
+   * Keys of the data object which require uniforms to be refreshed.
+   */
+  protected static _refreshUniformsKeys: string[];
+
+  /**
+   * Layers handled by this rendered source.
+   * @remarks Keys should match the keys of RenderingLayers
+   */
+  protected static get _layers(): Record<string, RenderedEffectSource.RenderedEffectLayerConfig>;
+
+  /**
+   * The offset in pixels applied to create soft edges.
+   * @defaultValue `-8`
+   */
+  static EDGE_OFFSET: number;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   * ...super.defaultData,
+   * animation: {},
+   * seed: null,
+   * preview: false,
+   * color: null
+   * }
+   * ```
+   */
+  static defaultData: RenderedEffectSource.RenderedEffectSourceData;
+
+  /**
+   * The animation configuration applied to this source
+   * @defaultValue `{}`
+   */
+  animation: RenderedEffectSource.RenderedEffectSourceAnimationConfig;
+
+  /**
+   * Track the status of rendering layers
+   */
+  layers: RenderingLayers;
+
+  /**
+   * The color of the source as an RGB vector.
+   */
+  colorRGB: [number, number, number] | null;
+
+  /**
+   * PIXI Geometry generated to draw meshes.
+   */
+  protected _geometry: PIXI.Geometry | null;
+
+  /**
+   * Is the rendered source animated?
+   */
+  get isAnimated(): boolean;
+
+  /**
+   * Has the rendered source at least one active layer?
+   */
+  get hasActiveLayer(): boolean;
+
+  /**
+   * Is this RenderedEffectSource a temporary preview?
+   */
+  get isPreview(): boolean;
+
+  /**
+   * A convenience accessor to the background layer mesh.
+   */
+  get background(): PointSourceMesh;
+
+  /**
+   * A convenience accessor to the coloration layer mesh.
+   */
+  get coloration(): PointSourceMesh;
+
+  /**
+   * A convenience accessor to the illumination layer mesh.
+   */
+  get illumination(): PointSourceMesh;
+
+  _initialize(data: Partial<SourceData>): void;
+
+  /**
+   * Decide whether to render soft edges with a blur.
+   */
+  protected _initializeSoftEdges(): void;
+
+  override _configure(changes: Partial<SourceData>): void;
+
+  /**
+   * Configure which shaders are used for each rendered layer.
+   * @privateRemarks Foundry marks this as private then overrides it in `PointVisionSource`
+   */
+  protected _configureShaders(): {
+    background: AdaptiveLightingShader;
+    coloration: AdaptiveLightingShader;
+    illumination: AdaptiveLightingShader;
+  };
+
+  /**
+   * Specific configuration for a layer.
+   */
+  protected _configureLayer(layer: Record<string, unknown>, layerId: string): void;
+
+  /**
+   * Create the geometry for the source shape that is used in shaders and compute its bounds for culling purpose.
+   * Triangulate the form and create buffers.
+   * @remarks Marked as abstract
+   */
+  protected _updateGeometry(): void;
+
+  /**
+   * Render the containers used to represent this light source within the LightingLayer
+   */
+  drawMeshes(): {
+    background: PIXI.Mesh;
+    coloration: PIXI.Mesh;
+    illumination: PIXI.Mesh;
+  };
+  /**
+   * Create a Mesh for a certain rendered layer of this source.
+   * @param layerId - The layer key in layers to draw
+   * @returns The drawn mesh for this layer, or null if no mesh is required
+   */
+  protected _drawMesh(layerId: string): PIXI.Mesh | null;
+
+  /**
+   * Update shader uniforms used by every rendered layer.
+   */
+  protected _updateCommonUniforms(shader: AbstractBaseShader): void;
+
+  /**
+   * Update shader uniforms used for the background layer.
+   */
+  protected _updateBackgroundUniforms(): void;
+
+  /**
+   * Update shader uniforms used for the coloration layer.
+   */
+  protected _updateColorationUniforms(): void;
+
+  /**
+   * Update shader uniforms used for the illumination layer.
+   */
+  protected _updateIlluminationUniforms(): void;
+
+  /**
+   * Animate the PointSource, if an animation is enabled and if it currently has rendered containers.
+   * @param dt - Delta time.
+   */
+  animate(dt: number): this["animation"]["animation"] extends (...args: any) => infer Return ? Return : void;
+
+  /**
+   * Generic time-based animation used for Rendered Point Sources.
+   * @param dt      - Delta time.
+   * @param options - Options which affect the time animation
+   */
+  animateTime(dt: number, options?: InexactPartial<RenderedEffectSource.AnimationOptions>): void;
+
+  /**
+   * Get corrected level according to level and active vision mode data.
+   * @returns The corrected level.
+   */
+  static getCorrectedLevel(level: foundry.CONST.LIGHTING_LEVELS): number;
+
+  /**
+   * Get corrected color according to level, dim color, bright color and background color.
+   */
+  static getCorrectedColor(
+    level: foundry.CONST.LIGHTING_LEVELS,
+    colorDim: Color,
+    colorBright: Color,
+    colorBackground?: Color,
+  ): Color;
+
+  /**
+   * @deprecated since v11
+   */
+  set preview(preview: boolean);
+
+  /**
+   * @deprecated since v11
+   */
+  get preview(): boolean;
+}
+
+declare namespace RenderedEffectSource {
+  type Any = RenderedEffectSource<any, any, any>;
+
+  interface RenderedEffectSourceData extends BaseEffectSource.BaseEffectSourceData {
+    /**
+     * An animation configuration for the source
+     */
+    animation: object;
+    /**
+     * A color applied to the rendered effect
+     */
+    color: number | null;
+    /**
+     * An integer seed to synchronize (or de-synchronize) animations
+     */
+    seed: number | null;
+    /**
+     * Is this source a temporary preview?
+     */
+    preview: boolean;
+  }
+
+  interface AnimationOptions {
+    /**
+     * The animation speed, from 0 to 10
+     * @defaultValue `5`
+     */
+    speed?: number;
+
+    /**
+     * The animation intensity, from 1 to 10
+     * @defaultValue `5`
+     */
+    intensity?: number;
+
+    /**
+     * Reverse the animation direction
+     * @defaultValue `false`
+     */
+    reverse?: boolean;
+  }
+
+  interface RenderedEffectSourceAnimationConfig {
+    /**
+     * The human-readable (localized) label for the animation
+     */
+    label?: string | undefined;
+    /**
+     * The animation function that runs every frame
+     * @privateRemarks TODO: Figure out if there's a better way to define the function
+     */
+    animation?: AnyFunction | undefined;
+    /**
+     * A custom illumination shader used by this animation
+     */
+    illuminationShader?: AdaptiveIlluminationShader | undefined;
+    /**
+     * A custom coloration shader used by this animation
+     */
+    colorationShader?: AdaptiveColorationShader | undefined;
+    /**
+     * A custom background shader used by this animation
+     */
+    backgroundShader?: AdaptiveBackgroundShader | undefined;
+    /**
+     * A custom darkness shader used by this animation
+     */
+    darknessShader?: AdaptiveDarknessShader | undefined;
+    /**
+     * The animation seed
+     */
+    seed?: number | undefined;
+    /**
+     * The animation time
+     */
+    time?: number | undefined;
+  }
+
+  interface RenderedEffectSourceLayer {
+    /**
+     * Is this layer actively rendered?
+     */
+    active: boolean;
+    /**
+     * Do uniforms need to be reset?
+     */
+    reset: boolean;
+    /**
+     * Is this layer temporarily suppressed?
+     */
+    suppressed: boolean;
+    /**
+     * The rendered mesh for this layer
+     */
+    mesh: PointSourceMesh;
+    /**
+     * The shader instance used for the layer
+     */
+    shader: AdaptiveLightingShader;
+  }
+
+  interface RenderedEffectLayerConfig {
+    /**
+     * The default shader used by this layer
+     */
+    defaultShader: AdaptiveLightingShader;
+    /**
+     * The blend mode used by this layer
+     */
+    blendMode: PIXI.BLEND_MODES;
+  }
+
+  // Interface causes errors
+  // eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+  type Layers = {
+    background: RenderedEffectSource.RenderedEffectSourceLayer;
+    coloration: RenderedEffectSource.RenderedEffectSourceLayer;
+    illumination: RenderedEffectSource.RenderedEffectSourceLayer;
+  };
+}
+
+export default RenderedEffectSource;

package/src/foundry/client-esm/canvas/tokens/_module.d.mts

@@ -0,0 +1,9 @@
+// In Foundry itself this file contains re-exports of these other modules.
+// Therefore it has a runtime effect and uses `.mjs` instead of `.d.mts`.
+// While `.mts` could work, to avoid `import/no-unresolved` from erroring `.mjs` is used.
+/* eslint-disable import/extensions */
+/* eslint-disable import/no-unresolved */ // TODO: Remove when the files are instantiated
+
+export { default as TokenRing } from "./ring.mjs";
+export { default as TokenRingConfig } from "./ring-config.mjs";
+export { default as DynamicRingData } from "./ring-data.mjs";

package/src/foundry/client-esm/canvas/tokens/ring-config.d.mts

@@ -0,0 +1,80 @@
+
+/**
+ * Token Ring configuration Singleton Class.
+ *
+ * @example Add a new custom ring configuration. Allow only ring pulse, ring gradient and background wave effects.
+ * ```js
+ * const customConfig = new foundry.canvas.tokens.DynamicRingData({
+ *   id: "myCustomRingId",
+ *   label: "Custom Ring",
+ *   effects: {
+ *     RING_PULSE: "TOKEN.RING.EFFECTS.RING_PULSE",
+ *     RING_GRADIENT: "TOKEN.RING.EFFECTS.RING_GRADIENT",
+ *     BACKGROUND_WAVE: "TOKEN.RING.EFFECTS.BACKGROUND_WAVE"
+ *   },
+ *   spritesheet: "canvas/tokens/myCustomRings.json",
+ *   framework: {
+ *     shaderClass: MyCustomTokenRingSamplerShader,
+ *     ringClass: TokenRing
+ *   }
+ * });
+ * CONFIG.Token.ring.addConfig(customConfig.id, customConfig);
+ * ```
+ *
+ * @example Get a specific ring configuration
+ * ```js
+ * const config = CONFIG.Token.ring.getConfig("myCustomRingId");
+ * console.log(config.spritesheet); // Output: canvas/tokens/myCustomRings.json
+ * ```
+ *
+ * @example Use a specific ring configuration
+ * ```js
+ * const success = CONFIG.Token.ring.useConfig("myCustomRingId");
+ * console.log(success); // Output: true
+ * ```
+ *
+ * @example Get the labels of all configurations
+ * ```js
+ * const configLabels = CONFIG.Token.ring.configLabels;
+ * console.log(configLabels);
+ * // Output:
+ * // {
+ * //   "coreSteel": "Foundry VTT Steel Ring",
+ * //   "coreBronze": "Foundry VTT Bronze Ring",
+ * //   "myCustomRingId" : "My Super Power Ring"
+ * // }
+ * ```
+ *
+ * @example Get the IDs of all configurations
+ * ```js
+ * const configIDs = CONFIG.Token.ring.configIDs;
+ * console.log(configIDs); // Output: ["coreSteel", "coreBronze", "myCustomRingId"]
+ * ```
+ *
+ * @example Create a hook to add a custom token ring configuration. This ring configuration will appear in the settings.
+ * ```js
+ * Hooks.on("initializeDynamicTokenRingConfig", ringConfig => {
+ *   const mySuperPowerRings = new foundry.canvas.tokens.DynamicRingData({
+ *     id: "myCustomRingId",
+ *     label: "My Super Power Rings",
+ *     effects: {
+ *       RING_PULSE: "TOKEN.RING.EFFECTS.RING_PULSE",
+ *       RING_GRADIENT: "TOKEN.RING.EFFECTS.RING_GRADIENT",
+ *       BACKGROUND_WAVE: "TOKEN.RING.EFFECTS.BACKGROUND_WAVE"
+ *     },
+ *     spritesheet: "canvas/tokens/mySuperPowerRings.json"
+ *   });
+ *   ringConfig.addConfig("mySuperPowerRings", mySuperPowerRings);
+ * });
+ * ```
+ *
+ * @example Activate color bands debugging visuals to ease configuration
+ * ```js
+ * CONFIG.Token.ring.debugColorBands = true;
+ * ```
+ */
+declare class TokenRingConfig {}
+
+declare namespace TokenRingConfig {}
+
+export default TokenRingConfig;

package/src/foundry/client-esm/canvas/tokens/ring-data.d.mts

@@ -0,0 +1,7 @@
+import type DataModel from "../../../common/abstract/data.d.mts";
+
+declare class DynamicRingData extends DataModel<any> {}
+
+declare namespace DynamicRingData {}
+
+export default DynamicRingData;

package/src/foundry/client-esm/canvas/tokens/ring.d.mts

@@ -0,0 +1,5 @@
+declare class TokenRing {}
+
+declare namespace TokenRing {}
+
+export default TokenRing;