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

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

@@ -0,0 +1,35 @@
+export {};
+
+declare abstract class AnyRegionShader extends RegionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace RegionShader {
+    type AnyConstructor = typeof AnyRegionShader;
+  }
+
+  /**
+   * The shader used by {@link RegionMesh}.
+   */
+  class RegionShader extends AbstractBaseShader {
+    static override vertexShader: string;
+
+    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;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/region/highlight.d.mts

@@ -0,0 +1,35 @@
+export {};
+
+declare abstract class AnyHighlightRegionShader extends HighlightRegionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace HighlightRegionShader {
+    type AnyConstructor = typeof AnyHighlightRegionShader;
+  }
+
+  /**
+   * Shader for the Region highlight.
+   */
+  class HighlightRegionShader extends RegionShader {
+    static override vertexShader: string;
+
+    static override fragmentShader: string;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   ...super.defaultUniforms,
+     *   resolution: 1,
+     *   hatchEnabled: false,
+     *   hatchThickness: 1
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    protected override _preRender: AbstractBaseShader.PreRenderFunction;
+  }
+}

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

@@ -0,0 +1,3 @@
+import "./base.d.mts";
+import "./adjust-darkness-level.d.mts";
+import "./highlight.d.mts";

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

@@ -0,0 +1,206 @@
+import type { InexactPartial, Mixin } from "../../../../../../types/utils.d.mts";
+
+declare abstract class AnyBaseSamplerShader extends BaseSamplerShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare class BatchPlugin<BaseSamplerShaderClass extends BaseSamplerShader.AnyConstructor> {
+  /** @privateRemarks All mixin classses should accept anything for its constructor. */
+  constructor(...args: any[]);
+
+  geometryClass: BaseSamplerShader.ToGeometryClass<BaseSamplerShaderClass["batchGeometry"]>;
+
+  setShaderGenerator(options?: InexactPartial<BatchRenderer.ShaderGeneratorOptions>): void;
+
+  contextChange(): void;
+}
+
+interface BatchPluginStatic<BaseSamplerShaderClass extends BaseSamplerShader.AnyConstructor> {
+  shaderGeneratorClass: BaseSamplerShaderClass["batchShaderGeneratorClass"];
+  defaultVertexSrc: BaseSamplerShaderClass["batchVertexShader"];
+  defaultFragmentTemplate: BaseSamplerShaderClass["batchDefaultUniforms"];
+}
+
+declare class BatchGeometry extends PIXI.Geometry {
+  constructor(_static?: boolean);
+}
+
+declare global {
+  namespace BaseSamplerShader {
+    type AnyConstructor = typeof AnyBaseSamplerShader;
+
+    type PluginName = (typeof BaseSamplerShader)["classPluginName"];
+
+    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[];
+  }
+
+  /**
+   * A simple shader to emulate a PIXI.Sprite with a PIXI.Mesh (but faster!)
+   */
+  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(): BaseSamplerShader.PluginName;
+
+    /**
+     * 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 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 vertice 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,
+    ): Mixin<typeof BatchPlugin<ThisType> & BatchPluginStatic<ThisType>, ThisType["batchRendererClass"]>;
+
+    /**
+     * Register the plugin for this sampler.
+     */
+    static registerPlugin(
+      options?: InexactPartial<{
+        /**
+         * Override the plugin of the same name that is already registered?
+         * @defaultValue `false`
+         */
+        force: boolean;
+      }>,
+    ): void;
+
+    protected override _preRender: AbstractBaseShader.PreRenderFunction;
+  }
+}

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

@@ -0,0 +1,38 @@
+export {};
+
+declare abstract class AnyBaselineIlluminationSamplerShader extends BaselineIlluminationSamplerShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace BaselineIlluminationSamplerShader {
+    type AnyConstructor = typeof AnyBaselineIlluminationSamplerShader;
+  }
+
+  /**
+   * Compute baseline illumination according to darkness level encoded texture.
+   */
+  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;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/samplers/color-adjustment.d.mts

@@ -0,0 +1,109 @@
+export {};
+
+declare abstract class AnyColorAdjustmentsSamplerShader extends ColorAdjustmentsSamplerShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyAmplificationSamplerShader extends AmplificationSamplerShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace ColorAdjustmentsSamplerShader {
+    type AnyConstructor = typeof AnyColorAdjustmentsSamplerShader;
+  }
+
+  namespace AmplificationSamplerShader {
+    type AnyConstructor = typeof AnyAmplificationSamplerShader;
+  }
+
+  /**
+   * A color adjustment shader.
+   */
+  class ColorAdjustmentsSamplerShader extends BaseSamplerShader {
+    /**
+     * @defaultValue `null`
+     */
+    static override classPluginName: string | null;
+
+    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;
+
+    get linkedToDarknessLevel(): AbstractBaseShader.UniformValue;
+
+    set linkedToDarknessLevel(link: AbstractBaseShader.UniformValue);
+
+    get contrast(): AbstractBaseShader.UniformValue;
+
+    set contrast(contrast: AbstractBaseShader.UniformValue);
+
+    get exposure(): AbstractBaseShader.UniformValue;
+
+    set exposure(exposure: AbstractBaseShader.UniformValue);
+
+    get saturation(): AbstractBaseShader.UniformValue;
+
+    set saturation(saturation: AbstractBaseShader.UniformValue);
+  }
+
+  /**
+   * A light amplification shader.
+   */
+  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: AbstractBaseShader.UniformValue);
+
+    /**
+     * Tint color applied to Light Amplification.
+     * Light Amplification tint
+     * @defaultValue `[0.48, 1.0, 0.48]`
+     */
+    get colorTint(): number[];
+
+    set colorTint(color: AbstractBaseShader.UniformValue);
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/samplers/depth.d.mts

@@ -0,0 +1,103 @@
+export {};
+
+declare abstract class AnyDepthSamplerShader extends DepthSamplerShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace DepthSamplerShader {
+    type AnyConstructor = typeof AnyDepthSamplerShader;
+
+    interface DepthBatchData extends PIXI.IBatchableElement {
+      elevation: number;
+      textureAlphaThreshold: number;
+      fadeOcclusion: number;
+      radialOcclusion: number;
+      visionOcclusion: number;
+    }
+  }
+
+  /**
+   * The depth sampler shader.
+   */
+  class DepthSamplerShader extends BaseSamplerShader {
+    /**
+     * @defaultValue `"batchDepth"`
+     */
+    static override classPluginName: string | null;
+
+    static override batchGeometry: BaseSamplerShader.BatchGeometry;
+
+    /**
+     * @defaultValue `6`
+     */
+    static override batchVertexSize: number;
+
+    /**
+     * @defaultValue `1`
+     */
+    static override reservedTextureUnits: number;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   screenDimensions: [1, 1],
+     *   sampler: null,
+     *   occlusionTexture: null,
+     *   textureAlphaThreshold: 0,
+     *   depthElevation: 0,
+     *   occlusionElevation: 0,
+     *   fadeOcclusion: 0,
+     *   radialOcclusion: 0,
+     *   visionOcclusion: 0,
+     *   restrictsLight: false,
+     *   restrictsWeather: false
+     * }
+     * ```
+     */
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    static override batchDefaultUniforms: BatchRenderer.BatchDefaultUniformsFunction;
+
+    static override _preRenderBatch: BatchRenderer.PreRenderBatchFunction;
+
+    protected static override _packInterleavedGeometry(
+      element: DepthSamplerShader.DepthBatchData,
+      attributeBuffer: PIXI.ViewableBuffer,
+      indexBuffer: Uint16Array,
+      aIndex: number,
+      iIndex: number,
+    ): void;
+
+    static override get batchVertexShader(): string;
+
+    /**
+     * The batch vertex shader source. Subclasses can override it.
+     */
+    protected static _batchVertexShader: string;
+
+    static override get batchFragmentShader(): string;
+
+    /**
+     * The batch fragment shader source. Subclasses can override it.
+     */
+    protected static _batchFragmentShader: string;
+
+    static override get vertexShader(): string;
+
+    /**
+     * The vertex shader source. Subclasses can override it.
+     */
+    protected static _vertexShader: string;
+
+    static override get fragmentShader(): string;
+
+    /**
+     * The fragment shader source. Subclasses can override it.
+     */
+    protected static _fragmentShader: string;
+
+    protected override _preRender: AbstractBaseShader.PreRenderFunction;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/samplers/fog-of-war.d.mts

@@ -0,0 +1,24 @@
+export {};
+
+declare abstract class AnyFogSamplerShader extends FogSamplerShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace FogSamplerShader {
+    type AnyConstructor = typeof AnyFogSamplerShader;
+  }
+
+  /**
+   * A simple shader which purpose is to make the original texture red channel the alpha channel,
+   * and still keeping channel informations. Used in cunjunction with the AlphaBlurFilterPass and Fog of War.
+   */
+  class FogSamplerShader extends BaseSamplerShader {
+    /**
+     * @defaultValue `null`
+     */
+    static override classPluginName: string | null;
+
+    static override fragmentShader: string;
+  }
+}

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

@@ -0,0 +1,8 @@
+import "./base-sampler.d.mts";
+import "./baseline-illumination.d.mts";
+import "./color-adjustment.d.mts";
+import "./depth.d.mts";
+import "./fog-of-war.d.mts";
+import "./occlusion.d.mts";
+import "./primary.d.mts";
+import "./token-ring.d.mts";

package/src/foundry/client/pixi/webgl/shaders/samplers/occlusion.d.mts

@@ -0,0 +1,104 @@
+export {};
+
+declare abstract class AnyOccludableSamplerShader extends OccludableSamplerShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace OccludableSamplerShader {
+    type AnyConstructor = typeof AnyOccludableSamplerShader;
+
+    interface OccludableBatchData extends PIXI.IBatchableElement {
+      elevation: number;
+      unoccludedAlpha: number;
+      occludedAlpha: number;
+      fadeOcclusion: number;
+      radialOcclusion: number;
+      visionOcclusion: number;
+    }
+  }
+
+  /**
+   * An occlusion shader to reveal certain area with elevation comparisons.
+   * This shader is also working as a batched plugin.
+   */
+  class OccludableSamplerShader extends BaseSamplerShader {
+    /**
+     * @defaultValue `"batchOcclusion"`
+     */
+    static override classPluginName: string;
+
+    static override batchGeometry: BaseSamplerShader.BatchGeometry;
+
+    /**
+     * @defaultValue `7`
+     */
+    static override batchVertexSize: number;
+
+    /**
+     * @defaultValue `1`
+     */
+    static reservedTextureUnits: number;
+
+    /**
+     * @defaultValue
+     * ```js
+     * {
+     *   screenDimensions: [1, 1],
+     *   sampler: null,
+     *   tintAlpha: [1, 1, 1, 1],
+     *   occlusionTexture: null,
+     *   unoccludedAlpha: 1,
+     *   occludedAlpha: 0,
+     *   occlusionElevation: 0,
+     *   fadeOcclusion: 0,
+     *   radialOcclusion: 0,
+     *   visionOcclusion: 0
+     * }
+     * ```
+     */
+    static override batchDefaultUniforms: BatchRenderer.BatchDefaultUniformsFunction;
+
+    protected static override _preRenderBatch: BatchRenderer.PreRenderBatchFunction;
+
+    protected static override _packInterleavedGeometry(
+      element: OccludableSamplerShader.OccludableBatchData,
+      attributeBuffer: PIXI.ViewableBuffer,
+      indexBuffer: Uint16Array,
+      aIndex: number,
+      iIndex: number,
+    ): void;
+
+    static override get batchVertexShader(): string;
+
+    /**
+     * The batch vertex shader source. Subclasses can override it.
+     */
+    protected static _batchVertexShader: string;
+
+    static override get batchFragmentShader(): string;
+
+    /**
+     * The batch fragment shader source. Subclasses can override it.
+     */
+    protected static _batchFragmentShader: string;
+
+    static override get vertexShader(): string;
+
+    /**
+     * The vertex shader source. Subclasses can override it.
+     */
+    protected static _vertexShader: string;
+
+    static override get fragmentShader(): string;
+
+    /**
+     * The fragment shader source. Subclasses can override it.
+     */
+    protected static _fragmentShader: string;
+
+    static override defaultUniforms: AbstractBaseShader.Uniforms;
+
+    protected override _preRender: AbstractBaseShader.PreRenderFunction;
+  }
+}

package/src/foundry/client/pixi/webgl/shaders/samplers/primary.d.mts

@@ -0,0 +1,26 @@
+export {};
+
+declare global {
+  /**
+   * The base shader class of {@link PrimarySpriteMesh}.
+   */
+  class PrimaryBaseSamplerShader extends OccludableSamplerShader {
+    /**
+     * The depth shader class associated with this shader.
+     * @defaultValue `DepthSampleShader`
+     */
+    static depthShaderClass: typeof DepthSamplerShader;
+
+    /**
+     * The depth shader associated with this shader.
+     * The depth shader is lazily constructed.
+     */
+    get depthShader(): DepthSamplerShader;
+
+    /**
+     * One-time configuration that is called when the depth shader is created.
+     * @param depthShader - The depth shader
+     */
+    protected _configureDepthShader(depthShader: DepthSamplerShader): void;
+  }
+}