@league-of-foundry-developers/foundry-vtt-types 13.340.0 → 13.345.1-beta.20250704.94554

package/src/foundry/client/canvas/rendering/shaders/region/adjust-darkness-level.d.mts

@@ -0,0 +1,137 @@
+import type { Identity } from "#utils";
+import type { AbstractBaseShader, RegionShader } from "../_module.mjs";
+
+/**
+ * Abstract shader used for Adjust Darkness Level region behavior.
+ * @internal
+ */
+declare 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`
+   */
+  mode: foundry.data.regionBehaviors.AdjustDarknessLevelRegionBehaviorType.MODES;
+
+  /**
+   * The darkness level modifier.
+   * @defaultValue `0`
+   */
+  modifier: number;
+
+  /**
+   * Current darkness level of this mesh.
+   */
+  get darknessLevel(): number;
+
+  protected override _preRender: AbstractBaseShader.PreRenderFunction;
+}
+
+declare namespace AbstractDarknessLevelRegionShader {
+  interface Any extends AnyAbstractDarknessLevelRegionShader {}
+  interface AnyConstructor extends Identity<typeof AnyAbstractDarknessLevelRegionShader> {}
+}
+
+/**
+ * Render the RegionMesh with darkness level adjustments.
+ */
+declare class AdjustDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
+  /**
+   * @defaultValue
+   * ```
+   *  `
+   *   precision ${PIXI.settings.PRECISION_FRAGMENT} float;
+   *
+   *   uniform sampler2D depthTexture;
+   *   uniform float darknessLevel;
+   *   uniform float top;
+   *   uniform float bottom;
+   *   uniform vec4 tintAlpha;
+   *   varying vec2 vScreenCoord;
+   *
+   *   void main() {
+   *     vec2 depthColor = texture2D(depthTexture, vScreenCoord).rg;
+   *     float depth = step(depthColor.g, top) * step(bottom, (254.5 / 255.0) - depthColor.r);
+   *     gl_FragColor = vec4(darknessLevel, 0.0, 0.0, 1.0) * tintAlpha * depth;
+   *   }
+   *  `
+   * ```
+   */
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   ...super.defaultUniforms,
+   *   darknessLevel: 0
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+  protected override _preRender: AbstractBaseShader.PreRenderFunction;
+}
+
+declare namespace AdjustDarknessLevelRegionShader {
+  interface Any extends AnyAdjustDarknessLevelRegionShader {}
+  interface AnyConstructor extends Identity<typeof AnyAdjustDarknessLevelRegionShader> {}
+}
+
+/**
+ * Render the RegionMesh with darkness level adjustments.
+ */
+declare class IlluminationDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
+  /**
+   * @defaultValue
+   * ```
+   *  `
+   *   precision ${PIXI.settings.PRECISION_FRAGMENT} float;
+   *
+   *   uniform sampler2D depthTexture;
+   *   uniform float top;
+   *   uniform float bottom;
+   *   uniform vec4 tintAlpha;
+   *   varying vec2 vScreenCoord;
+   *
+   *   void main() {
+   *     vec2 depthColor = texture2D(depthTexture, vScreenCoord).rg;
+   *     float depth = step(depthColor.g, top) * step(bottom, (254.5 / 255.0) - depthColor.r);
+   *     gl_FragColor = vec4(1.0) * tintAlpha * depth;
+   *   }
+   *  `
+   * ```
+   */
+  static override fragmentShader: string;
+}
+
+declare namespace IlluminationDarknessLevelRegionShader {
+  interface Any extends AnyIlluminationDarknessLevelRegionShader {}
+  interface AnyConstructor extends Identity<typeof AnyIlluminationDarknessLevelRegionShader> {}
+}
+
+export { AbstractDarknessLevelRegionShader, AdjustDarknessLevelRegionShader, IlluminationDarknessLevelRegionShader };
+
+declare abstract class AnyAbstractDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnyAdjustDarknessLevelRegionShader extends AdjustDarknessLevelRegionShader {
+  constructor(...args: never);
+}
+
+declare abstract class AnyIlluminationDarknessLevelRegionShader extends IlluminationDarknessLevelRegionShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/region/base.d.mts

@@ -0,0 +1,80 @@
+import type { Identity } from "#utils";
+import type { AbstractBaseShader } from "../_module.mjs";
+
+/**
+ * The shader used by {@linkcode foundry.canvas.placeables.regions.RegionMesh}.
+ */
+declare class RegionShader extends AbstractBaseShader {
+  /**
+   * @defaultValue
+   * ```
+   *  `
+   *   precision ${PIXI.settings.PRECISION_VERTEX} float;
+   *
+   *   attribute vec2 aVertexPosition;
+   *
+   *   uniform mat3 translationMatrix;
+   *   uniform mat3 projectionMatrix;
+   *   uniform vec2 canvasDimensions;
+   *   uniform vec4 sceneDimensions;
+   *   uniform vec2 screenDimensions;
+   *
+   *   varying vec2 vCanvasCoord; // normalized canvas coordinates
+   *   varying vec2 vSceneCoord; // normalized scene coordinates
+   *   varying vec2 vScreenCoord; // normalized screen coordinates
+   *
+   *   void main() {
+   *     vec2 pixelCoord = aVertexPosition;
+   *     vCanvasCoord = pixelCoord / canvasDimensions;
+   *     vSceneCoord = (pixelCoord - sceneDimensions.xy) / sceneDimensions.zw;
+   *     vec3 tPos = translationMatrix * vec3(aVertexPosition, 1.0);
+   *     vScreenCoord = tPos.xy / screenDimensions;
+   *     gl_Position = vec4((projectionMatrix * tPos).xy, 0.0, 1.0);
+   *   }
+   *  `
+   * ```
+   */
+  static override vertexShader: string;
+
+  /**
+   * @defaultValue
+   * ```
+   *  `
+   *   precision ${PIXI.settings.PRECISION_FRAGMENT} float;
+   *
+   *   uniform vec4 tintAlpha;
+   *
+   *   void main() {
+   *     gl_FragColor = tintAlpha;
+   *   }
+   *  `
+   * ```
+   */
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   canvasDimensions: [1, 1],
+   *   sceneDimensions: [0, 0, 1, 1],
+   *   screenDimensions: [1, 1],
+   *   tintAlpha: [1, 1, 1, 1]
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+  protected override _preRender: AbstractBaseShader.PreRenderFunction;
+}
+
+declare namespace RegionShader {
+  interface Any extends AnyRegionShader {}
+  interface AnyConstructor extends Identity<typeof AnyRegionShader> {}
+}
+
+export default RegionShader;
+
+declare abstract class AnyRegionShader extends RegionShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/region/highlight.d.mts

@@ -0,0 +1,97 @@
+import type { Identity } from "#utils";
+import type { AbstractBaseShader, RegionShader } from "../_module.mjs";
+
+/**
+ * Shader for the Region highlight.
+ * @internal
+ */
+declare class HighlightRegionShader extends RegionShader {
+  /**
+   * @defaultValue
+   * ```
+   *  `\
+   *   precision ${PIXI.settings.PRECISION_VERTEX} float;
+   *
+   *   ${this.CONSTANTS}
+   *
+   *   attribute vec2 aVertexPosition;
+   *
+   *   uniform mat3 translationMatrix;
+   *   uniform mat3 projectionMatrix;
+   *   uniform vec2 canvasDimensions;
+   *   uniform vec4 sceneDimensions;
+   *   uniform vec2 screenDimensions;
+   *   uniform mediump float hatchThickness;
+   *
+   *   varying vec2 vCanvasCoord; // normalized canvas coordinates
+   *   varying vec2 vSceneCoord; // normalized scene coordinates
+   *   varying vec2 vScreenCoord; // normalized screen coordinates
+   *   varying float vHatchOffset;
+   *
+   *   void main() {
+   *     vec2 pixelCoord = aVertexPosition;
+   *     vCanvasCoord = pixelCoord / canvasDimensions;
+   *     vSceneCoord = (pixelCoord - sceneDimensions.xy) / sceneDimensions.zw;
+   *     vec3 tPos = translationMatrix * vec3(aVertexPosition, 1.0);
+   *     vScreenCoord = tPos.xy / screenDimensions;
+   *     gl_Position = vec4((projectionMatrix * tPos).xy, 0.0, 1.0);
+   *     vHatchOffset = (pixelCoord.x + pixelCoord.y) / (SQRT2 * 2.0 * hatchThickness);
+   *   }
+   *  `
+   * ```
+   */
+  static override vertexShader: string;
+
+  /**
+   * @defaultValue
+   * ```
+   *  `\
+   *   precision ${PIXI.settings.PRECISION_FRAGMENT} float;
+   *
+   *   varying float vHatchOffset;
+   *
+   *   uniform vec4 tintAlpha;
+   *   uniform float resolution;
+   *   uniform bool hatchEnabled;
+   *   uniform mediump float hatchThickness;
+   *
+   *   void main() {
+   *     gl_FragColor = tintAlpha;
+   *     if ( !hatchEnabled ) return;
+   *     float x = abs(vHatchOffset - floor(vHatchOffset + 0.5)) * 2.0;
+   *     float s = hatchThickness * resolution;
+   *     float y0 = clamp((x + 0.5) * s + 0.5, 0.0, 1.0);
+   *     float y1 = clamp((x - 0.5) * s + 0.5, 0.0, 1.0);
+   *     gl_FragColor *= mix(0.3333, 1.0, y0 - y1);
+   *   }
+   *  `
+   * ```
+   */
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   ...super.defaultUniforms,
+   *   resolution: 1,
+   *   hatchEnabled: false,
+   *   hatchThickness: 1
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+  protected override _preRender: AbstractBaseShader.PreRenderFunction;
+}
+
+declare namespace HighlightRegionShader {
+  interface Any extends AnyHighlightRegionShader {}
+  interface AnyConstructor extends Identity<typeof AnyHighlightRegionShader> {}
+}
+
+export default HighlightRegionShader;
+
+declare abstract class AnyHighlightRegionShader extends HighlightRegionShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/samplers/amplification.d.mts

@@ -0,0 +1,58 @@
+import type { Identity } from "#utils";
+import type { AbstractBaseShader, ColorAdjustmentsSamplerShader } from "../_module.mjs";
+
+/**
+ * A light amplification shader.
+ */
+declare class AmplificationSamplerShader extends ColorAdjustmentsSamplerShader {
+  /**
+   * @defaultValue `null`
+   */
+  static override classPluginName: string | null;
+
+  static override vertexShader: string;
+
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   tintAlpha: [1, 1, 1, 1],
+   *   tint: [0.38, 0.8, 0.38],
+   *   brightness: 0,
+   *   darknessLevelTexture: null,
+   *   screenDimensions: [1, 1],
+   *   enable: true
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+  /**
+   * Brightness controls the luminosity.
+   */
+  get brightness(): number;
+
+  set brightness(brightness);
+
+  /**
+   * Tint color applied to Light Amplification.
+   * Light Amplification tint
+   * @defaultValue `[0.48, 1.0, 0.48]`
+   */
+  get colorTint(): Color.RGBColorVector;
+
+  set colorTint(color);
+}
+
+declare namespace AmplificationSamplerShader {
+  interface Any extends AnyAmplificationSamplerShader {}
+  interface AnyConstructor extends Identity<typeof AnyAmplificationSamplerShader> {}
+}
+
+export default AmplificationSamplerShader;
+
+declare abstract class AnyAmplificationSamplerShader extends AmplificationSamplerShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/samplers/base-sampler.d.mts

@@ -0,0 +1,223 @@
+import type { Identity, InexactPartial, Mixin } from "#utils";
+import type { AbstractBaseShader } from "../_module.mjs";
+import type { BatchRenderer, BatchShaderGenerator } from "../../batching/_module.mjs";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+declare class BatchPlugin<BaseSamplerShaderClass extends BaseSamplerShader.AnyConstructor> {
+  /** @privateRemarks All mixin classes should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  geometryClass: BaseSamplerShader.ToGeometryClass<BaseSamplerShaderClass["batchGeometry"]>;
+
+  setShaderGenerator(options?: BatchRenderer.ShaderGeneratorOptions): void;
+
+  contextChange(): void;
+}
+
+interface BatchPluginStatic<BaseSamplerShaderClass extends BaseSamplerShader.AnyConstructor> {
+  shaderGeneratorClass: BaseSamplerShaderClass["batchShaderGeneratorClass"];
+  defaultVertexSrc: BaseSamplerShaderClass["batchVertexShader"];
+  defaultFragmentTemplate: BaseSamplerShaderClass["batchDefaultUniforms"];
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+declare class BatchGeometry extends PIXI.Geometry {
+  constructor(_static?: boolean);
+}
+
+/**
+ * The base sampler shader exposes a simple sprite shader and all the framework to handle:
+ * - Batched shaders and plugin subscription
+ * - Configure method (for special processing done once or punctually)
+ * - Update method (pre-binding, normally done each frame)
+ * All other sampler shaders (batched or not) should extend BaseSamplerShader
+ */
+declare class BaseSamplerShader extends AbstractBaseShader {
+  /**
+   * The named batch sampler plugin that is used by this shader, or null if no batching is used.
+   * @defaultValue `"batch"`
+   */
+  static classPluginName: string | null;
+
+  /**
+   * Is this shader pausable or not?
+   * @defaultValue `true`
+   */
+  static pausable: boolean;
+
+  /**
+   * The plugin name associated for this instance, if any.
+   * Returns "batch" if the shader is disabled.
+   */
+  get pluginName(): typeof BaseSamplerShader.classPluginName;
+
+  /**
+   * Activate or deactivate this sampler. If set to false, the batch rendering is redirected to "batch".
+   * Otherwise, the batch rendering is directed toward the instance pluginName (might be null)
+   * @defaultValue `true`
+   */
+  get enabled(): boolean;
+
+  set enabled(enabled: boolean);
+
+  /**
+   * Pause or Unpause this sampler. If set to true, the shader is disabled. Otherwise, it is enabled.
+   * Contrary to enabled, a shader might decide to refuse a pause, to continue to render animations per example.
+   * @see {@linkcode enabled}
+   */
+  get paused(): boolean;
+
+  set paused(paused: boolean);
+
+  /**
+   * Contrast adjustment
+   */
+  static CONTRAST: string;
+
+  /**
+   * Saturation adjustment
+   */
+  static SATURATION: string;
+
+  /**
+   * Exposure adjustment.
+   */
+  static EXPOSURE: string;
+
+  /**
+   * The adjustments made into fragment shaders.
+   */
+  static get ADJUSTMENTS(): string;
+
+  static override vertexShader: string;
+
+  static override fragmentShader: string;
+
+  /**
+   * Batch default vertex
+   */
+  static batchVertexShader: string;
+
+  /**
+   * Batch default fragment
+   */
+  static batchFragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   sampler: 0,
+   *   tintAlpha: [1, 1, 1, 1]
+   * };
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+  /**
+   * Batch geometry associated with this sampler.
+   * @defaultValue `PIXI.BatchGeometry`
+   */
+  static batchGeometry: BaseSamplerShader.BatchGeometry;
+
+  /**
+   * The size of a vertex with all its packed attributes.
+   * @defaultValue `6`
+   */
+  static batchVertexSize: number;
+
+  /**
+   * Pack interleaved geometry custom function.
+   */
+  protected static _packInterleavedGeometry: BatchRenderer.PackInterleavedGeometryFunction | undefined;
+
+  /**
+   * A prerender function happening just before the batch renderer is flushed.
+   */
+  protected static _preRenderBatch: BatchRenderer.PreRenderBatchFunction | undefined;
+
+  /**
+   * A function that returns default uniforms associated with the batched version of this sampler.
+   * @defaultValue `{}`
+   */
+  static batchDefaultUniforms: BatchRenderer.BatchDefaultUniformsFunction | AbstractBaseShader.Uniforms;
+
+  /**
+   * The number of reserved texture units for this shader that cannot be used by the batch renderer.
+   * @defaultValue `0`
+   */
+  static reservedTextureUnits: number;
+
+  /**
+   * Initialize the batch geometry with custom properties.
+   */
+  static initializeBatchGeometry(): void;
+
+  /**
+   * The batch renderer to use.
+   * @defaultValue `BatchRenderer`
+   */
+  static batchRendererClass: typeof BatchRenderer;
+
+  /**
+   * The batch generator to use.
+   * @defaultValue `BatchShaderGenerator`
+   */
+  static batchShaderGeneratorClass: typeof BatchShaderGenerator;
+
+  /**
+   * Create a batch plugin for this sampler class.
+   * @returns - The batch plugin class linked to this sampler class.
+   */
+  static createPlugin<ThisType extends BaseSamplerShader.AnyConstructor>(
+    this: ThisType,
+  ): BaseSamplerShader.CreatedPlugin<ThisType>;
+
+  /**
+   * Register the plugin for this sampler.
+   */
+  static registerPlugin(options?: BaseSamplerShader.RegisterPluginOptions): void;
+
+  protected override _preRender: AbstractBaseShader.PreRenderFunction;
+
+  #BaseSamplerShader: true;
+}
+
+declare namespace BaseSamplerShader {
+  interface Any extends AnyBaseSamplerShader {}
+  interface AnyConstructor extends Identity<typeof AnyBaseSamplerShader> {}
+
+  interface BatchGeometryData {
+    id: string;
+    size: number;
+    normalized: boolean;
+    type: PIXI.TYPES;
+  }
+
+  type ToGeometryClass<G extends PIXI.BatchGeometry.AnyConstructor | BaseSamplerShader.BatchGeometryData[]> =
+    G extends readonly unknown[] ? typeof BatchGeometry : G;
+
+  type BatchGeometry = typeof PIXI.BatchGeometry | BaseSamplerShader.BatchGeometryData[];
+
+  type CreatedPlugin<ShaderClass extends BaseSamplerShader.AnyConstructor> = Mixin<
+    typeof BatchPlugin<ShaderClass> & BatchPluginStatic<ShaderClass>,
+    ShaderClass["batchRendererClass"]
+  >;
+
+  /** @internal */
+  type _RegisterPluginOptions = InexactPartial<{
+    /**
+     * Override the plugin of the same name that is already registered?
+     * @defaultValue `false`
+     */
+    force: boolean;
+  }>;
+
+  interface RegisterPluginOptions extends _RegisterPluginOptions {}
+}
+
+export default BaseSamplerShader;
+
+declare abstract class AnyBaseSamplerShader extends BaseSamplerShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/samplers/baseline-illumination.d.mts

@@ -0,0 +1,40 @@
+import type { Identity } from "#utils";
+import type { AbstractBaseShader, BaseSamplerShader } from "../_module.mjs";
+
+/**
+ * Compute baseline illumination according to darkness level encoded texture.
+ */
+declare class BaselineIlluminationSamplerShader extends BaseSamplerShader {
+  /**
+   * @defaultValue `null`
+   */
+  static override classPluginName: string | null;
+
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   tintAlpha: [1, 1, 1, 1],
+   *   ambientDarkness: [0, 0, 0],
+   *   ambientDaylight: [1, 1, 1],
+   *   sampler: null
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+  protected override _preRender: AbstractBaseShader.PreRenderFunction;
+}
+
+declare namespace BaselineIlluminationSamplerShader {
+  interface Any extends AnyBaselineIlluminationSamplerShader {}
+  interface AnyConstructor extends Identity<typeof AnyBaselineIlluminationSamplerShader> {}
+}
+
+export default BaselineIlluminationSamplerShader;
+
+declare abstract class AnyBaselineIlluminationSamplerShader extends BaselineIlluminationSamplerShader {
+  constructor(...args: never);
+}

package/src/foundry/client/canvas/rendering/shaders/samplers/color-adjustments.d.mts

@@ -0,0 +1,65 @@
+import type { Identity } from "#utils";
+import type { AbstractBaseShader, BaseSamplerShader } from "../_module.mjs";
+
+/**
+ * A color adjustment shader.
+ */
+declare class ColorAdjustmentsSamplerShader extends BaseSamplerShader {
+  /**
+   * @defaultValue `null`
+   */
+  static override classPluginName: string | null;
+
+  static override vertexShader: string;
+
+  static override fragmentShader: string;
+
+  /**
+   * @defaultValue
+   * ```js
+   * {
+   *   tintAlpha: [1, 1, 1, 1],
+   *   tint: [1, 1, 1],
+   *   contrast: 0,
+   *   saturation: 0,
+   *   exposure: 0,
+   *   sampler: null,
+   *   linkedToDarknessLevel: false,
+   *   darknessLevelTexture: null,
+   *   screenDimensions: [1, 1]
+   * }
+   * ```
+   */
+  static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+  /** @privateRemarks Inferred from defaultUniforms */
+  get linkedToDarknessLevel(): boolean;
+
+  set linkedToDarknessLevel(link);
+
+  /** @privateRemarks Inferred from defaultUniforms */
+  get contrast(): number;
+
+  set contrast(contrast);
+
+  /** @privateRemarks Inferred from defaultUniforms */
+  get exposure(): number;
+
+  set exposure(exposure);
+
+  /** @privateRemarks Inferred from defaultUniforms */
+  get saturation(): number;
+
+  set saturation(saturation);
+}
+
+declare namespace ColorAdjustmentsSamplerShader {
+  interface Any extends AnyColorAdjustmentsSamplerShader {}
+  interface AnyConstructor extends Identity<typeof AnyColorAdjustmentsSamplerShader> {}
+}
+
+export default ColorAdjustmentsSamplerShader;
+
+declare abstract class AnyColorAdjustmentsSamplerShader extends ColorAdjustmentsSamplerShader {
+  constructor(...args: never);
+}