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

package/src/foundry/client-esm/canvas/sources/base-light-source.d.mts

@@ -0,0 +1,162 @@
+import type { InexactPartial } from "../../../../types/utils.d.mts";
+import type RenderedEffectSource from "./rendered-effect-source.d.mts";
+
+// TODO: Adjust after client/config.js is updated
+type LightSourceAnimationConfig = unknown;
+
+/**
+ * A specialized subclass of BaseEffectSource which deals with the rendering of light or darkness.
+ */
+declare class BaseLightSource<
+  SourceData extends BaseLightSource.LightSourceData = BaseLightSource.LightSourceData,
+  SourceShape extends PIXI.Polygon = PIXI.Polygon,
+  RenderingLayers extends Record<string, RenderedEffectSource.RenderedEffectSourceLayer> = RenderedEffectSource.Layers,
+> extends RenderedEffectSource<SourceData, SourceShape, RenderingLayers> {
+  /** @defaultValue `"light"` */
+  static override sourceType: string;
+
+  /** @defaultValue `["animation.type", "walls"]` */
+  protected static override _initializeShaderKeys: string[];
+
+  /** @defaultValue `["dim", "bright", "attenuation", "alpha", "coloration", "color", "contrast", "saturation", "shadows", "luminosity"]` */
+  protected static override _refreshUniformsKeys: string[];
+
+  /**
+   * The corresponding lighting levels for dim light.
+   */
+  protected static _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
+
+  /**
+   * The corresponding lighting levels for bright light.
+   */
+  protected static _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
+
+  /**
+   * The corresponding animation config.
+   */
+  protected static get ANIMATIONS(): LightSourceAnimationConfig;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   * ...super.defaultData,
+   * priority: 0,
+   * alpha: 0.5,
+   * bright: 0,
+   * coloration: 1,
+   * contrast: 0,
+   * dim: 0,
+   * attenuation: 0.5,
+   * luminosity: 0.5,
+   * saturation: 0,
+   * shadows: 0,
+   * vision: false
+   * }
+   * ```
+   */
+  static override defaultData: RenderedEffectSource.RenderedEffectSourceData;
+
+  /**
+   * A ratio of dim:bright as part of the source radius
+   */
+  ratio: number;
+
+  override _initialize(data: Partial<SourceData>): void;
+
+  override _updateColorationUniforms(): void;
+
+  override _updateIlluminationUniforms(): void;
+
+  override _updateBackgroundUniforms(): void;
+
+  override _updateCommonUniforms(shader: AbstractBaseShader): void;
+
+  /**
+   * An animation with flickering ratio and light intensity.
+   * @param dt      - Delta time
+   * @param options - Additional options which modify the torch animation
+   */
+  animateTorch(dt: number, options?: InexactPartial<RenderedEffectSource.AnimationOptions>): void;
+
+  /**
+   * An animation with flickering ratio and light intensity
+   * @param dt      - Delta time
+   * @param options - Additional options which modify the flame animation
+   */
+  animateFlickering(
+    dt: number,
+    options?: InexactPartial<
+      RenderedEffectSource.AnimationOptions & {
+        /**
+         * Noise amplification (\>1) or dampening (\<1)
+         * @defaultValue `1`
+         */
+        amplification: number;
+      }
+    >,
+  ): void;
+
+  /**
+   * A basic "pulse" animation which expands and contracts.
+   * @param dt      - Delta time
+   * @param options - Additional options which modify the pulse animation
+   */
+  animatePulse(dt: number, options?: InexactPartial<RenderedEffectSource.AnimationOptions>): void;
+
+  /**
+   * @deprecated since v12
+   */
+  get isDarkness(): boolean;
+}
+
+declare namespace BaseLightSource {
+  interface LightSourceData extends RenderedEffectSource.RenderedEffectSourceData {
+    /**
+     * An opacity for the emitted light, if any
+     */
+    alpha: number;
+    /**
+     * The allowed radius of bright vision or illumination
+     */
+    bright: number;
+    /**
+     * The coloration technique applied in the shader
+     */
+    coloration: number;
+    /**
+     * The amount of contrast this light applies to the background texture
+     */
+    contrast: number;
+    /**
+     * The allowed radius of dim vision or illumination
+     */
+    dim: number;
+    /**
+     * Strength of the attenuation between bright, dim, and dark
+     */
+    attenuation: number;
+    /**
+     * The luminosity applied in the shader
+     */
+    luminosity: number;
+    /**
+     * The amount of color saturation this light applies to the background texture
+     */
+    saturation: number;
+    /**
+     * The depth of shadows this light applies to the background texture
+     */
+    shadows: number;
+    /**
+     * Whether or not this source provides a source of vision
+     */
+    vision: boolean;
+    /**
+     * Strength of this source to beat or not negative/positive sources
+     */
+    priority: number;
+  }
+}
+
+export default BaseLightSource;

package/src/foundry/client-esm/canvas/sources/global-light-source.d.mts

@@ -0,0 +1,47 @@
+import type BaseLightSource from "./base-light-source.d.mts";
+
+/**
+ * A specialized subclass of the BaseLightSource which is used to render global light source linked to the scene.
+ */
+export default class GlobalLightSource extends BaseLightSource {
+  /** @defaultValue `"GlobalLight"` */
+  static override sourceType: string;
+
+  /** @defaultValue `"lightSources"` */
+  static override effectsCollection: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   * ...super.defaultData,
+   * rotation: 0,
+   * angle: 360,
+   * attenuation: 0,
+   * priority: -Infinity,
+   * vision: false,
+   * walls: false,
+   * elevation: Infinity,
+   * darkness: {min: 0, max: 0}
+   * }
+   * ```
+   */
+  static override defaultData: BaseLightSource.LightSourceData;
+
+  /**
+   * Name of this global light source.
+   * @defaultValue GlobalLightSource.sourceType
+   */
+  name: string;
+
+  /**
+   * A custom polygon placeholder.
+   */
+  customPolygon: PIXI.Polygon | number[] | null;
+
+  override _createShapes(): void;
+
+  override _initializeSoftEdges(): void;
+
+  override _updateGeometry(): void;
+}

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

@@ -0,0 +1,77 @@
+import type BaseLightSource from "./base-light-source.d.mts";
+import type PointEffectSourceMixin from "./point-effect-source.d.mts";
+import type RenderedEffectSource from "./rendered-effect-source.d.mts";
+
+// TODO: Adjust after client/config.js is updated
+type LightSourceAnimationConfig = unknown;
+
+type DarknessSourceData = BaseLightSource.LightSourceData & PointEffectSourceMixin.PointEffectSourceData;
+
+// Interface causes errors
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+type DarknessLayers = {
+  darkness: RenderedEffectSource.RenderedEffectSourceLayer;
+};
+
+/**
+ * A specialized subclass of the BaseLightSource which renders a source of darkness as a point-based effect.
+ */
+export default class PointDarknessSource<
+  SourceData extends DarknessSourceData = DarknessSourceData,
+  SourceShape extends PointSourcePolygon = PointSourcePolygon,
+> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape, DarknessLayers> {
+  /** @defaultValue `"darknessSources"` */
+  static override effectsCollection: string;
+
+  /** @defaultValue `LIGHTING_LEVELS.HALFDARK` */
+  static override _dimLightingLevel: foundry.CONST.LIGHTING_LEVELS;
+
+  /** @defaultValue `LIGHTING_LEVELS.DARKNESS` */
+  static override _brightLightingLevel: foundry.CONST.LIGHTING_LEVELS;
+
+  /** @defaultValue `CONFIG.Canvas.darknessAnimations` */
+  static get ANIMATIONS(): LightSourceAnimationConfig;
+
+  static override get _layers(): Record<string, foundry.canvas.sources.RenderedEffectSource.RenderedEffectLayerConfig>;
+
+  /**
+   * The optional geometric shape is solely utilized for visual representation regarding darkness sources.
+   * Used only when an additional radius is added for visuals.
+   */
+  protected _visualShape: SourceShape;
+
+  /**
+   * Padding applied on the darkness source shape for visual appearance only.
+   * Note: for now, padding is increased radius. It might evolve in a future release.
+   */
+  protected _padding: number;
+
+  /**
+   * The Edge instances added by this darkness source.
+   */
+  edges: foundry.canvas.edges.Edge[];
+
+  override _createShapes(): void;
+
+  override _configure(changes: Partial<SourceData>): void;
+
+  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+
+  override _drawMesh(layerId: string): PIXI.Mesh | null;
+
+  override _updateGeometry(): void;
+
+  /**
+   * Update the uniforms of the shader on the darkness layer.
+   */
+  _updateDarknessUniforms(): void;
+
+  override _destroy(): void;
+
+  /**
+   * A convenience accessor to the darkness layer mesh.
+   * @deprecated since v12, until v14
+   * @remarks `"BaseLightSource#isDarkness is now obsolete. Use DarknessSource instead."`
+   */
+  get darkness(): PointSourceMesh;
+}

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

@@ -0,0 +1,91 @@
+import type { Mixin } from "../../../../types/utils.d.mts";
+import type BaseEffectSource from "./base-effect-source.d.mts";
+
+declare class PointEffectSource {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   * ...super.defaultData,
+   * radius: 0,
+   * externalRadius: 0,
+   * rotation: 0,
+   * angle: 360,
+   * walls: true
+   * }
+   * ```
+   */
+  static defaultData: PointEffectSourceMixin.PointEffectSourceData;
+
+  /**
+   * A convenience reference to the radius of the source.
+   */
+  get radius(): number;
+
+  _initialize(data: Partial<PointEffectSourceMixin.PointEffectSourceData>): void;
+
+  _initializeSoftEdges(): void;
+
+  /**
+   * Configure the parameters of the polygon that is generated for this source.
+   */
+  protected _getPolygonConfiguration(): PointSourcePolygonConfig;
+
+  _createShapes(): void;
+
+  _drawMesh(layerId: string): PIXI.Mesh | null;
+
+  _updateGeometry(): void;
+
+  /**
+   * @deprecated since v11, until v13
+   * @remarks `"The setter PointEffectSource#radius is deprecated. The radius should not be set anywhere except in PointEffectSource#_initialize."`
+   */
+  // eslint-disable-next-line @typescript-eslint/adjacent-overload-signatures
+  set radius(radius);
+
+  /**
+   * @deprecated since v11, until v13
+   * @remarks `"PointEffectSource#los is deprecated in favor of PointEffectSource#shape."`
+   * @privateRemarks Actual definition is get/set
+   */
+  los: PointSourcePolygon;
+}
+
+/**
+ * TODO - documentation required about what a PointEffectSource is.
+ * @privateRemarks the TODO is from foundry, update this class whenever the comments are done
+ */
+declare function PointEffectSourceMixin<BaseClass extends typeof BaseEffectSource<any, any>>(
+  Base: BaseClass,
+): Mixin<typeof PointEffectSource, BaseClass>;
+
+declare namespace PointEffectSourceMixin {
+  interface PointEffectSourceData extends BaseEffectSource.BaseEffectSourceData {
+    /**
+     * The radius of the source
+     */
+    radius: number;
+    /**
+     * A secondary radius used for limited angles
+     */
+    externalRadius: number;
+    /**
+     * The angle of rotation for this point source
+     */
+    rotation: number;
+    /**
+     * The angle of emission for this point source
+     */
+    angle: number;
+    /**
+     * Whether or not the source is constrained by walls
+     */
+    walls: boolean;
+  }
+}
+
+export default PointEffectSourceMixin;

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

@@ -0,0 +1,43 @@
+import type BaseLightSource from "./base-light-source.d.mts";
+import type PointEffectSourceMixin from "./point-effect-source.d.mts";
+
+type LightSourceData = PointEffectSourceMixin.PointEffectSourceData & BaseLightSource.LightSourceData;
+
+/**
+ * A specialized subclass of the BaseLightSource which renders a source of light as a point-based effect.
+ */
+export default class PointLightSource<
+  SourceData extends LightSourceData = LightSourceData,
+  SourceShape extends PointSourcePolygon = PointSourcePolygon,
+> extends PointEffectSourceMixin(BaseLightSource)<SourceData, SourceShape> {
+  /** @defaultValue `"lightSources"` */
+  static override effectsCollection: string;
+
+  override _initialize(data: Partial<SourceData>): void;
+
+  override _createShapes(): void;
+
+  override _configure(changes: Partial<SourceData>): void;
+
+  override _getPolygonConfiguration(): PointSourcePolygonConfig;
+
+  /**
+   * Test whether this LightSource provides visibility to see a certain target object.
+   * @param config - The visibility test configuration
+   * @returns Is the target object visible to this source?
+   */
+  testVisibility(config: {
+    /** The sequence of tests to perform */
+    tests: CanvasVisibilityTest[];
+    /** The target object being tested */
+    object: PlaceableObject;
+  }): boolean;
+
+  /**
+   * Can this LightSource theoretically detect a certain object based on its properties?
+   * This check should not consider the relative positions of either object, only their state.
+   * @param target - The target object being tested
+   * @returns Can the target object theoretically be detected by this vision source?
+   */
+  _canDetectObject(target: PlaceableObject): boolean;
+}

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

@@ -0,0 +1,15 @@
+import type BaseEffectSource from "./base-effect-source.d.mts";
+import type PointEffectSourceMixin from "./point-effect-source.d.mts";
+
+type MovementSourceData = PointEffectSourceMixin.PointEffectSourceData & BaseEffectSource.BaseEffectSourceData;
+
+/**
+ * A specialized subclass of the BaseEffectSource which describes a movement-based source.
+ */
+export default class PointMovementSource<
+  SourceData extends MovementSourceData = MovementSourceData,
+  SourceShape extends PointSourcePolygon = PointSourcePolygon,
+> extends PointEffectSourceMixin(BaseEffectSource)<SourceData, SourceShape> {
+  /** @defaultValue `"move"` */
+  static override sourceType: string;
+}

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: Point,
+    options?: {
+      easing?: boolean | undefined;
+    },
+  ): number;
+}

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

@@ -0,0 +1,206 @@
+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> 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;