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

package/src/foundry/client/pixi/placeables/wall.d.mts

@@ -0,0 +1,275 @@
+import type { LineIntersection } from "../../../common/utils/geometry.d.mts";
+import type { ConfiguredObjectClassOrDefault } from "../../config.d.mts";
+
+declare global {
+  namespace Wall {
+    type ConfiguredClass = ConfiguredObjectClassOrDefault<typeof Wall>;
+    type ConfiguredInstance = InstanceType<ConfiguredClass>;
+
+    interface RenderFlags extends PlaceableObject.RenderFlags {
+      refreshLine: boolean;
+
+      refreshEndpoints: boolean;
+
+      refreshDirection: boolean;
+
+      refreshHighlight: boolean;
+    }
+
+    interface ControlOptions extends PlaceableObject.ControlOptions {
+      /** @defaultValue `false` */
+      chain: boolean;
+    }
+
+    type DoorInteraction = "open" | "close" | "lock" | "unlock" | "test";
+  }
+
+  /**
+   * A Wall is an implementation of PlaceableObject which represents a physical or visual barrier within the Scene.
+   * Walls are used to restrict Token movement or visibility as well as to define the areas of effect for ambient lights
+   * and sounds.
+   *
+   * @see {@link WallDocument}
+   * @see {@link WallsLayer}
+   */
+  class Wall extends PlaceableObject<WallDocument.ConfiguredInstance> {
+    static override embeddedName: "Wall";
+
+    static override RENDER_FLAGS: {
+      /** @defaultValue `{ propagate: ["refresh"] }` */
+      redraw: RenderFlag<Partial<Wall.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshState", "refreshLine"], alias: true }` */
+      refresh: RenderFlag<Partial<Wall.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight"] }` */
+      refreshState: RenderFlag<Partial<Wall.RenderFlags>>;
+
+      /** @defaultValue `{ propagate: ["refreshEndpoints", "refreshHighlight", "refreshDirection"] }` */
+      refreshLine: RenderFlag<Partial<Wall.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshEndpoints: RenderFlag<Partial<Wall.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshDirection: RenderFlag<Partial<Wall.RenderFlags>>;
+
+      /** @defaultValue `{}` */
+      refreshHighlight: RenderFlag<Partial<Wall.RenderFlags>>;
+    };
+
+    /**
+     * A reference the Door Control icon associated with this Wall, if any
+     * @defaultValue `undefined`
+     */
+    protected doorControl: DoorControl | undefined | null;
+
+    /**
+     * A reference to an overhead Tile that is a roof, interior to which this wall is contained
+     * @defaultValue `undefined`
+     */
+    roof: Tile.ConfiguredInstance | undefined;
+
+    /**
+     * A Graphics object used to highlight this wall segment. Only used when the wall is controlled.
+     */
+    highlight: PIXI.Graphics | undefined;
+
+    /**
+     * A set which tracks other Wall instances that this Wall intersects with (excluding shared endpoints)
+     */
+    intersectsWith: Map<Wall.ConfiguredInstance, LineIntersection>;
+
+    /**
+     * A convenience reference to the coordinates Array for the Wall endpoints, [x0,y0,x1,y1].
+     */
+    get coords(): Wall["document"]["c"];
+
+    /**
+     * The endpoints of the wall expressed as {@link foundry.canvas.edges.PolygonVertex} instances.
+     */
+    get vertices(): { a: foundry.canvas.edges.PolygonVertex; b: foundry.canvas.edges.PolygonVertex };
+
+    /**
+     * The initial endpoint of the Wall
+     */
+    get A(): Canvas.Point;
+
+    /**
+     * The second endpoint of the Wall
+     */
+    get B(): Canvas.Point;
+
+    /**
+     * A set of vertex sort keys which identify this Wall's endpoints.
+     */
+    get wallKeys(): Set<number>;
+
+    override get bounds(): PIXI.Rectangle;
+
+    /**
+     * A boolean for whether this wall contains a door
+     */
+    get isDoor(): boolean;
+
+    /**
+     * A boolean for whether the wall contains an open door
+     */
+    get isOpen(): boolean;
+
+    /**
+     * Is this Wall interior to a non-occluded roof Tile?
+     */
+    get hasActiveRoof(): boolean;
+
+    /**
+     * Return the coordinates [x,y] at the midpoint of the wall segment
+     */
+    get midpoint(): Canvas.PointArray;
+
+    override get center(): PIXI.Point;
+
+    /**
+     * Get the direction of effect for a directional Wall
+     * @returns The angle of wall effect
+     */
+    get direction(): number | null;
+
+    /**
+     * This helper converts the wall segment to a Ray
+     * @returns The wall in Ray representation
+     */
+    toRay(): Ray;
+
+    protected override _draw(): Promise<void>;
+
+    override clear(): this;
+
+    /**
+     * Draw a control icon that is used to manipulate the door's open/closed state
+     */
+    createDoorControl(): DoorControl;
+
+    /**
+     * Clear the door control if it exists.
+     */
+    clearDoorControl(): void;
+
+    /**
+     * Determine the orientation of this wall with respect to a reference point
+     * @param point - Some reference point, relative to which orientation is determined
+     * @returns An orientation in CONST.WALL_DIRECTIONS which indicates whether the Point is left,
+     *          right, or collinear (both) with the Wall
+     */
+    orientPoint(point: Canvas.Point): number;
+
+    /**
+     * Test whether to apply a configured threshold of this wall.
+     * When the proximity threshold is met, this wall is excluded as an edge in perception calculations.
+     * @param sourceType     - Sense type for the source
+     * @param sourceOrigin   - The origin or position of the source on the canvas
+     * @param externalRadius - The external radius of the source
+     *                         (default: `0`)
+     * @returns True if the wall has a threshold greater than 0 for the source type, and the source type is within that distance.
+     */
+    applyThreshold(sourceType: string, sourceOrigin: Canvas.Point, externalRadius: number): boolean;
+
+    override control(options?: Wall.ControlOptions): boolean;
+
+    protected override _destroy(options?: PIXI.IDestroyOptions | boolean): void;
+
+    /**
+     * Test whether the Wall direction lies between two provided angles
+     * This test is used for collision and vision checks against one-directional walls
+     * @param lower - The lower-bound limiting angle in radians
+     * @param upper - The upper-bound limiting angle in radians
+     */
+    isDirectionBetweenAngles(lower: number, upper: number): boolean;
+
+    /**
+     * A simple test for whether a Ray can intersect a directional wall
+     * @param ray - The ray to test
+     * @returns Can an intersection occur?
+     */
+    canRayIntersect(ray: Ray): boolean;
+
+    /**
+     * Get an Array of Wall objects which are linked by a common coordinate
+     * @returns An object reporting ids and endpoints of the linked segments
+     */
+    getLinkedSegments(): {
+      ids: string[];
+      walls: WallsLayer["placeables"];
+      endpoints: Array<[x: number, y: number]>;
+    };
+
+    /**
+     * Determine whether this wall is beneath a roof tile, and is considered "interior", or not.
+     */
+    identifyInteriorState(): void;
+
+    /**
+     * Update any intersections with this wall.
+     */
+    updateIntersections(): void;
+
+    /**
+     * Record the intersection points between this wall and another, if any.
+     * @param other - The other wall.
+     */
+    protected _identifyIntersectionsWith(other: WallDocument.ConfiguredInstance): void;
+
+    protected override _applyRenderFlags(flags: Wall.RenderFlags): void;
+
+    /**
+     * Given the properties of the wall - decide upon a color to render the wall for display on the WallsLayer
+     */
+    protected _getWallColor(): number;
+
+    /**
+     * @privateRemarks _onCreate, _onUpdate, and _onDelete are all overridden but with no signature changes.
+     * For type simplicity they are left off. These methods historically have been the source of a large amount of computation from tsc.
+     */
+
+    /**
+     * Play a door interaction sound.
+     * This plays locally, each client independently applies this workflow.
+     * @param interaction - The door interaction: "open", "close", "lock", "unlock", or "test".
+     * @internal
+     */
+    protected _playDoorSound(interaction: Wall.DoorInteraction): void;
+
+    protected override _createInteractionManager(): NonNullable<this["mouseInteractionManager"]>;
+
+    override activateListeners(): void;
+
+    protected override _canControl(user: User.ConfiguredInstance, event?: any): boolean;
+
+    protected override _onHoverIn(event: PIXI.FederatedEvent, options?: PlaceableObject.HoverInOptions): false | void;
+
+    protected override _onHoverOut(event: PIXI.FederatedEvent): false | void;
+
+    /**
+     * Handle mouse-hover events on the line segment itself, pulling the Wall to the front of the container stack
+     * @internal
+     */
+    protected _onMouseOverLine(event: PIXI.FederatedEvent): void;
+
+    protected override _onClickLeft(event: PIXI.FederatedEvent): boolean;
+
+    protected override _onClickLeft2(event: PIXI.FederatedEvent): void;
+
+    protected override _onClickRight2(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftStart(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftMove(event: PIXI.FederatedEvent): void;
+
+    protected override _onDragLeftDrop(event: PIXI.FederatedEvent): Promise<unknown>;
+
+    /**
+     * @remarks Not used
+     */
+    controlIcon: null;
+  }
+}

package/src/foundry/client/pixi/webgl/extensions/batch-renderer.d.mts

@@ -0,0 +1,95 @@
+import type { ToMethod } from "../../../../../types/helperTypes.d.mts";
+import type { InexactPartial } from "../../../../../types/utils.d.mts";
+
+declare abstract class AnyBatchRenderer extends BatchRenderer {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace BatchRenderer {
+    type AnyConstructor = typeof AnyBatchRenderer;
+
+    type PackInterleavedGeometryFunction = ToMethod<
+      (
+        element: PIXI.IBatchableElement,
+        attributeBuffer: PIXI.ViewableBuffer,
+        indexBuffer: Uint16Array,
+        aIndex: number,
+        iIndex: number,
+      ) => void
+    >;
+
+    type PreRenderBatchFunction = ToMethod<(batchRenderer: typeof BatchRenderer) => void>;
+
+    type BatchDefaultUniformsFunction = ToMethod<(maxTextures: number) => AbstractBaseShader.Uniforms>;
+
+    type ReservedTextureUnits = 0 | 1 | 2 | 3 | 4;
+
+    interface ShaderGeneratorOptions {
+      vertex: typeof BatchRenderer.defaultVertexSrc;
+      fragment: typeof BatchRenderer.defaultFragmentTemplate;
+      uniforms: typeof BatchRenderer.defaultUniforms;
+    }
+  }
+
+  /**
+   * A batch renderer with a customizable data transfer function to packed geometries.
+   */
+  class BatchRenderer extends PIXI.BatchRenderer {
+    /**
+     * The batch shader generator class.
+     * @defaultValue `BatchShaderGenerator`
+     */
+    static shaderGeneratorClass: typeof BatchShaderGenerator;
+
+    /**
+     * The default uniform values for the batch shader.
+     * @defaultValue `{}`
+     */
+    static defaultUniforms: AbstractBaseShader.Uniforms | BatchRenderer.BatchDefaultUniformsFunction;
+
+    /**
+     * The PackInterleavedGeometry function provided by the sampler.
+     */
+    protected _packInterleavedGeometry: BatchRenderer.PackInterleavedGeometryFunction | undefined;
+
+    /**
+     * The preRender function provided by the sampler and that is called just before a flush.
+     */
+    protected _preRenderBatch: BatchRenderer.PreRenderBatchFunction | undefined;
+
+    get uniforms(): AbstractBaseShader.Uniforms | undefined;
+
+    /**
+     * The number of reserved texture units that the shader generator should not use (maximum 4).
+     */
+    protected set reservedTextureUnits(val: BatchRenderer.ReservedTextureUnits);
+
+    /**
+     * Number of reserved texture units reserved by the batch shader that cannot be used by the batch renderer.
+     */
+    get reservedTextureUnits(): BatchRenderer.ReservedTextureUnits;
+
+    override setShaderGenerator(options?: InexactPartial<BatchRenderer.ShaderGeneratorOptions>): void;
+
+    /**
+     * This override allows to allocate a given number of texture units reserved for a custom batched shader.
+     * These reserved texture units won't be used to batch textures for PIXI.Sprite or SpriteMesh.
+     * @override
+     */
+    override contextChange(): void;
+
+    override onPrerender(): void;
+
+    override start(): void;
+
+    override packInterleavedGeometry: BatchRenderer.PackInterleavedGeometryFunction;
+
+    /**
+     * Verify if a PIXI plugin exists. Check by name.
+     * @param name - The name of the pixi plugin to check.
+     * @returns True if the plugin exists, false otherwise.
+     */
+    static hasPlugin(name: string): boolean;
+  }
+}

package/src/foundry/client/pixi/webgl/extensions/batch-shader-generator.d.mts

@@ -0,0 +1,30 @@
+export {};
+
+declare abstract class AnyBatchShaderGenerator extends BatchShaderGenerator {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace BatchShaderGenerator {
+    type AnyConstructor = typeof AnyBatchShaderGenerator;
+  }
+
+  /**
+   * A batch shader generator that could handle extra uniforms during initialization.
+   * @param vertexSrc    - The vertex shader source
+   * @param fragTemplate - The fragment shader source template
+   * @param uniforms     - Additional uniforms
+   */
+  class BatchShaderGenerator extends PIXI.BatchShaderGenerator {
+    constructor(
+      vertexSrc: string,
+      fragTemplate: string,
+      /**
+       * @defaultValue `{}`
+       */
+      uniforms?: AbstractBaseShader.Uniforms | BatchRenderer.BatchDefaultUniformsFunction,
+    );
+
+    override generateShader(maxTextures: number): PIXI.Shader;
+  }
+}

package/src/foundry/client/pixi/webgl/extensions/blend-modes.d.mts

@@ -0,0 +1,53 @@
+export {};
+
+declare global {
+  const BLEND_MODES: {
+    /**
+     * A custom blend mode equation which chooses the maximum color from each channel within the stack.
+     * @defaultValue
+     * ```typescript
+     * [
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.MAX,
+     *   WebGL2RenderingContext.MAX,
+     * ]
+     * ```
+     */
+    MAX_COLOR: [GLenum, GLenum, GLenum, GLenum, GLenum, GLenum];
+
+    /**
+     * A custom blend mode equation which chooses the minimum color from each channel within the stack.
+     * @defaultValue
+     * ```typescript
+     * [
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.MIN,
+     *   WebGL2RenderingContext.MAX,
+     * ]
+     * ```
+     */
+    MIN_COLOR: [GLenum, GLenum, GLenum, GLenum, GLenum, GLenum];
+
+    /**
+     * A custom blend mode equation which chooses the minimum color for color channels and min alpha from alpha channel.
+     * @defaultValue
+     * ```typescript
+     * [
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.ONE,
+     *   WebGL2RenderingContext.MIN,
+     *   WebGL2RenderingContext.MIN,
+     * ]
+     * ```
+     */
+    MIN_ALL: [GLenum, GLenum, GLenum, GLenum, GLenum, GLenum];
+  };
+}

package/src/foundry/client/pixi/webgl/extensions/index.d.mts

@@ -0,0 +1,3 @@
+import "./batch-renderer.d.mts";
+import "./batch-shader-generator.d.mts";
+import "./blend-modes.d.mts";

package/src/foundry/client/pixi/webgl/helpers/framebugger-snapshot.d.mts

@@ -0,0 +1,30 @@
+export {};
+
+declare abstract class AnyFramebufferSnapshot extends FramebufferSnapshot {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace FramebufferSnapshot {
+    type AnyConstructor = typeof AnyFramebufferSnapshot;
+  }
+
+  /**
+   * Provide the necessary methods to get a snapshot of the framebuffer into a render texture.
+   * Class meant to be used as a singleton.
+   * Created with the precious advices of dev7355608.
+   */
+  class FramebufferSnapshot {
+    /**
+     * The RenderTexture that is the render destination for the framebuffer snapshot.
+     */
+    framebufferTexture: PIXI.RenderTexture;
+
+    /**
+     * Get the framebuffer texture snapshot.
+     * @param renderer - The renderer for this context.
+     * @returns The framebuffer snapshot.
+     */
+    getFramebufferTexture(renderer: PIXI.Renderer): PIXI.RenderTexture;
+  }
+}

package/src/foundry/client/pixi/webgl/helpers/index.d.mts

@@ -0,0 +1,3 @@
+import "./framebugger-snapshot.d.mts";
+import "./smooth-noise.d.mts";
+import "./texture-extractor.d.mts";

package/src/foundry/client/pixi/webgl/helpers/smooth-noise.d.mts

@@ -0,0 +1,65 @@
+import type { InexactPartial } from "../../../../../types/utils.d.mts";
+
+declare global {
+  namespace SmoothNoise {
+    interface ConstructorOptions {
+      /**
+       * The generated noise will be on the range [0, amplitude].
+       * @defaultValue `1`
+       */
+      amplitude: number;
+
+      /**
+       * An adjustment factor for the input x values which place them on an appropriate range.
+       * @defaultValue `1`
+       */
+      scale: number;
+
+      /**
+       * The number of pre-generated random numbers to generate.
+       * @defaultValue `256`
+       */
+      maxReferences: number;
+    }
+  }
+
+  /**
+   * A smooth noise generator for one-dimensional values.
+   */
+  class SmoothNoise {
+    /**
+     * @param options - Configuration options for the noise process.
+     */
+    constructor({ amplitude, scale, maxReferences }?: InexactPartial<SmoothNoise.ConstructorOptions>);
+
+    _maxReferences: number;
+
+    _references: number[];
+
+    /**
+     * Amplitude of the generated noise output
+     * The noise output is multiplied by this value
+     */
+    get amplitude(): number;
+
+    set amplitude(amplitude);
+
+    _amplitude: number;
+
+    /**
+     * Scale factor of the random indices
+     */
+    get scale(): number;
+
+    set scale(scale);
+
+    _scale: number;
+
+    /**
+     * Generate the noise value corresponding to a provided numeric x value.
+     * @param x - Any finite number
+     * @returns The corresponding smoothed noise value
+     */
+    generate(x: number): number;
+  }
+}

package/src/foundry/client/pixi/webgl/helpers/texture-extractor.d.mts

@@ -0,0 +1,90 @@
+import type { InexactPartial } from "../../../../../types/utils.d.mts";
+
+declare abstract class AnyTextureExtractor extends TextureExtractor {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare global {
+  namespace TextureExtractor {
+    type AnyConstructor = typeof AnyTextureExtractor;
+
+    interface ConstructorOptions {
+      /** @defaultValue `"TextureExtractor"` */
+      callerName: string;
+
+      controlHash: boolean;
+
+      /** @defaultValue `PIXI.FORMATS.RED` */
+      format: PIXI.FORMATS;
+    }
+
+    interface TextureExtractionOptions {
+      /**
+       * The texture the pixels are extracted from.
+       * Otherwise, extract from the renderer.
+       */
+      texture: PIXI.Texture | PIXI.RenderTexture | null;
+
+      /** The rectangle which the pixels are extracted from. */
+      frame: PIXI.Rectangle;
+
+      /** The compression mode to apply, or NONE */
+      compression: TextureExtractor.COMPRESSION_MODES;
+
+      /** The optional image mime type. */
+      type: string;
+
+      /** The optional image quality. */
+      quality: string;
+
+      /** The optional debug flag to use. */
+      debug: boolean;
+    }
+
+    interface COMPRESSION_MODES {
+      readonly NONE: 0;
+      readonly BASE64: 1;
+    }
+  }
+
+  /**
+   * A class or interface that provide support for WebGL async read pixel/texture data extraction.
+   */
+  class TextureExtractor {
+    constructor(
+      renderer: PIXI.Renderer,
+      { callerName, controlHash, format }?: InexactPartial<TextureExtractor.ConstructorOptions>,
+    );
+
+    /**
+     * List of compression that could be applied with extraction
+     */
+    static COMPRESSION_MODES: TextureExtractor.COMPRESSION_MODES;
+
+    /**
+     * Debug flag.
+     */
+    debug: boolean;
+
+    /**
+     * The reference to the pixel buffer.
+     */
+    pixelBuffer: Uint8ClampedArray;
+
+    /**
+     * Extract a rectangular block of pixels from the texture (without un-pre-multiplying).
+     * @param options - Options which configure extraction behavior
+     */
+    extract(options: InexactPartial<TextureExtractor.TextureExtractionOptions>): ReturnType<Semaphore["add"]>;
+
+    /**
+     * Free all the bound objects.
+     */
+    reset(): void;
+
+    /**
+     * Called by the renderer contextChange runner.
+     */
+    contextChange(): void;
+  }
+}

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

@@ -0,0 +1,3 @@
+import "./extensions/index.d.mts";
+import "./helpers/index.d.mts";
+import "./shaders/index.d.mts";