@7h3laughingman/foundry-types 13.351.0

package/src/client/canvas/primary/primary-sprite-mesh.d.mts

@@ -0,0 +1,127 @@
+import { SpriteMesh } from "../containers/_module.mjs";
+import { TextureAlphaData } from "../loader.mjs";
+import { PrimaryBaseSamplerShader } from "../rendering/shaders/_module.mjs";
+import PrimaryOccludableObjectMixin from "./primary-occludable-object.mjs";
+
+export interface PrimarySpriteMeshConstructorOptions {
+    /** Texture passed to the SpriteMesh. */
+    texture?: PIXI.Texture;
+    /** The name of this sprite. */
+    name?: string | null;
+    /** Any object that owns this sprite. */
+    object?: object;
+}
+
+/**
+ * A basic PCO sprite mesh which is handling occlusion and depth.
+ * @param [options] The constructor options.
+ * @param [options.texture]     Texture passed to the SpriteMesh.
+ * @param [options.shaderClass] The shader class used to render this sprite.
+ * @param [options.name]        The name of this sprite.
+ * @param [options.object]      Any object that owns this sprite.
+ */
+export default class PrimarySpriteMesh extends PrimaryOccludableObjectMixin(SpriteMesh) {
+    constructor(options: PrimarySpriteMeshConstructorOptions, shaderClass: typeof PrimaryBaseSamplerShader);
+
+    object: object | null;
+
+    name: string | null;
+
+    /** The texture alpha data. */
+    protected _textureAlphaData: TextureAlphaData | null;
+
+    /**
+     * The texture alpha threshold used for point containment tests.
+     * If set to a value larger than 0, the texture alpha data is
+     * extracted from the texture at 25% resolution.
+     */
+    textureAlphaThreshold: number;
+
+    /* -------------------------------------------- */
+    /*  PIXI Events                                 */
+    /* -------------------------------------------- */
+
+    protected override _onTextureUpdate(): void;
+
+    /* -------------------------------------------- */
+    /*  Helper Methods                              */
+    /* -------------------------------------------- */
+
+    override setShaderClass(shaderClass: typeof PrimaryBaseSamplerShader): void;
+
+    /**
+     * An all-in-one helper method: Resizing the PCO according to desired dimensions and options.
+     * This helper computes the width and height based on the following factors:
+     *
+     * - The ratio of texture width and base width.
+     * - The ratio of texture height and base height.
+     *
+     * Additionally, It takes into account the desired fit options:
+     *
+     * - (default) "fill" computes the exact width and height ratio.
+     * - "cover" takes the maximum ratio of width and height and applies it to both.
+     * - "contain" takes the minimum ratio of width and height and applies it to both.
+     * - "width" applies the width ratio to both width and height.
+     * - "height" applies the height ratio to both width and height.
+     *
+     * You can also apply optional scaleX and scaleY options to both width and height. The scale is applied after fitting.
+     *
+     * **Important**: By using this helper, you don't need to set the height, width, and scale properties of the DisplayObject.
+     *
+     * **Note**: This is a helper method. Alternatively, you could assign properties as you would with a PIXI DisplayObject.
+     *
+     * @param baseWidth             The base width used for computations.
+     * @param baseHeight            The base height used for computations.
+     * @param [options]             The options.
+     * @param [options.fit="fill"]  The fit type.
+     * @param [options.scaleX=1]    The scale on X axis.
+     * @param [options.scaleY=1]    The scale on Y axis.
+     */
+    resize(
+        baseWidth: number,
+        baseHeight: number,
+        options?: {
+            fit?: "fill" | "cover" | "contain" | "width" | "height";
+            scaleX?: number;
+            scaleY?: number;
+        },
+    ): void;
+
+    /* -------------------------------------------- */
+    /*  Methods                                     */
+    /* -------------------------------------------- */
+
+    protected override _updateBatchData(): void;
+
+    protected override _calculateCanvasBounds(): void;
+
+    /**
+     * Is the given point in canvas space contained in this object?
+     * @param point                   The point in canvas space
+     * @param [textureAlphaThreshold] The minimum texture alpha required for containment
+     */
+    override containsCanvasPoint(point: PIXI.IPointData, textureAlphaThreshold?: number): boolean;
+
+    /**
+     * Is the given point in world space contained in this object?
+     * @param point                   The point in world space
+     * @param [textureAlphaThreshold] The minimum texture alpha required for containment
+     */
+    override containsPoint(point: PIXI.IPointData, textureAlphaThreshold?: number): boolean;
+
+    /* -------------------------------------------- */
+    /*  Rendering Methods                           */
+    /* -------------------------------------------- */
+
+    override renderDepthData(renderer: PIXI.Renderer): void;
+
+    /* -------------------------------------------- */
+
+    /**
+     * Render the sprite with ERASE blending.
+     * Note: The sprite must not have visible/renderable children.
+     * @param renderer The renderer
+     * @internal
+     */
+    _renderVoid(renderer: PIXI.Renderer): void;
+}

package/src/client/canvas/rendering/_module.d.mts

@@ -0,0 +1,5 @@
+export * as batching from "./batching/_module.mjs";
+export { BLEND_MODES } from "./blend-modes.mjs";
+export * as filters from "./filters/_module.mjs";
+export * as mixins from "./mixins/_module.mjs";
+export * as shaders from "./shaders/_module.mjs";

package/src/client/canvas/rendering/batching/_module.d.mts

@@ -0,0 +1,2 @@
+export { default as BatchRenderer } from "./batch-renderer.mjs";
+export { default as BatchShaderGenerator } from "./batch-shader-generator.mjs";

package/src/client/canvas/rendering/batching/batch-renderer.d.mts

@@ -0,0 +1,71 @@
+import BatchShaderGenerator from "./batch-shader-generator.mjs";
+
+/**
+ * A batch renderer with a customizable data transfer function to packed geometries.
+ */
+export default class BatchRenderer extends PIXI.BatchRenderer {
+    /**
+     * The batch shader generator class.
+     */
+    static shaderGeneratorClass: typeof BatchShaderGenerator;
+
+    /**
+     * The default uniform values for the batch shader.
+     * @type {object | (maxTextures: number) => object}
+     */
+    static defaultUniforms: object | ((maxTextures: number) => object);
+
+    // undocumented
+    maxTextures: number;
+
+    /**
+     * The PackInterleavedGeometry function provided by the sampler.
+     */
+    protected _packInterleavedGeometry: Function | undefined;
+
+    /**
+     * The update function provided by the sampler and that is called just before a flush.
+     */
+    protected _preRenderBatch: (batchRenderer: BatchRenderer) => void | undefined;
+
+    /**
+     * Get the uniforms bound to this abstract batch renderer.
+     */
+    get uniforms(): object | undefined;
+
+    /**
+     * Number of reserved texture units reserved by the batch shader that cannot be used by the batch renderer.
+     */
+    get reservedTextureUnits(): number;
+
+    set reservedTextureUnits(val: number);
+
+    override setShaderGenerator(options?: { vertex?: string; fragment?: string; uniforms?: string }): void;
+
+    shaderGenerator: BatchShaderGenerator;
+
+    /**
+     * 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 contextChange(): void;
+
+    override onPrerender(): void;
+
+    override start(): void;
+
+    override packInterleavedGeometry(
+        element: PIXI.IBatchableElement,
+        attributeBuffer: PIXI.ViewableBuffer,
+        indexBuffer: Uint16Array,
+        aIndex: number,
+        iIndex: number,
+    ): void;
+
+    /**
+     * 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/client/canvas/rendering/batching/batch-shader-generator.d.mts

@@ -0,0 +1,13 @@
+/**
+ * A batch shader generator that could handle extra uniforms during initialization.
+ */
+export default class BatchShaderGenerator extends PIXI.BatchShaderGenerator {
+    /**
+     * @param vertexSrc    The vertex shader source
+     * @param fragTemplate The fragment shader source template
+     * @param uniforms     Additional uniforms
+     */
+    constructor(vertexSrc: string, fragTemplate: string, uniforms?: object | ((maxTextures: number) => object));
+
+    override generateShader(maxTextures: number): PIXI.Shader;
+}

package/src/client/canvas/rendering/blend-modes.d.mts

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

package/src/client/canvas/rendering/filters/_module.d.mts

@@ -0,0 +1,13 @@
+export { default as AbstractBaseFilter } from "./base-filter.mjs";
+export { default as AbstractBaseMaskFilter } from "./base-mask-filter.mjs";
+export { default as VisualEffectsMaskingFilter } from "./effects-masking.mjs";
+export { default as PrimaryCanvasGroupAmbienceFilter } from "./environment.mjs";
+export { default as GlowOverlayFilter } from "./glow-overlay.mjs";
+export { default as InvisibilityFilter } from "./invisibility.mjs";
+export { default as OutlineOverlayFilter } from "./outline-overlay.mjs";
+export { default as SMAAFilter } from "./smaa/smaa.mjs";
+export { default as TextureTransitionFilter } from "./transition.mjs";
+export { default as VisibilityFilter } from "./visibility.mjs";
+export { default as VisionMaskFilter } from "./vision-mask-filter.mjs";
+export { default as VoidFilter } from "./void.mjs";
+export { default as WeatherOcclusionMaskFilter } from "./weather-occlusion-mask.mjs";

package/src/client/canvas/rendering/filters/base-filter.d.mts

@@ -0,0 +1,28 @@
+import BaseShaderMixin from "../mixins/base-shader-mixin.mjs";
+
+/**
+ * An abstract filter which provides a framework for reusable definition
+ */
+export default abstract class AbstractBaseFilter extends BaseShaderMixin(PIXI.Filter) {
+    /**
+     * The default uniforms used by the filter
+     */
+    static defaultUniforms: object;
+
+    /**
+     * The fragment shader which renders this filter.
+     */
+    static fragmentShader: string | (() => string);
+
+    /**
+     * The vertex shader which renders this filter.
+     */
+    static vertexShader: string;
+
+    /**
+     * A factory method for creating the filter using its defined default values.
+     * @param initialUniforms Initial uniform values which override filter defaults
+     * @returns The constructed AbstractFilter instance.
+     */
+    static create(initialUniforms?: object | undefined): AbstractBaseFilter;
+}

package/src/client/canvas/rendering/filters/base-mask-filter.d.mts

@@ -0,0 +1,14 @@
+import AbstractBaseFilter from "./base-filter.mjs";
+
+/**
+ * This class defines an interface for masked custom filters
+ */
+export default class AbstractBaseMaskFilter extends AbstractBaseFilter {
+    apply(
+        filterManager: PIXI.FilterSystem,
+        input: PIXI.RenderTexture,
+        output: PIXI.RenderTexture,
+        clearMode?: PIXI.CLEAR_MODES,
+        _currentState?: PIXI.FilterState,
+    ): void;
+}

package/src/client/canvas/rendering/filters/blur.d.mts

@@ -0,0 +1,152 @@
+/**
+ * Apply a vertical or horizontal gaussian blur going inward by using alpha as the penetrating channel.
+ */
+export class AlphaBlurFilterPass extends PIXI.Filter {
+    /**
+     * @param horizontal If the pass is horizontal (true) or vertical (false).
+     * @param strength Strength of the blur (distance of sampling).
+     * @param quality Number of passes to generate the blur. More passes = Higher quality = Lower Perf.
+     * @param resolution Resolution of the filter.
+     * @param kernelSize Number of kernels to use. More kernels = Higher quality = Lower Perf.
+     */
+    constructor(horizontal: boolean, strength?: number, quality?: number, resolution?: number, kernelSize?: number);
+
+    /**
+     * If the pass is horizontal (true) or vertical (false).
+     */
+    horizontal: boolean;
+
+    /**
+     * Strength of the blur (distance of sampling).
+     */
+    strength: number;
+
+    /**
+     * The number of passes to generate the blur.
+     */
+    passes: number;
+
+    /**
+     * The quality of the filter is defined by its number of passes.
+     */
+    get quality(): number;
+
+    set quality(value);
+
+    /**
+     * The strength of the blur filter in pixels.
+     */
+    get blur(): number;
+
+    set blur(value);
+
+    /**
+     * The kernels containing the gaussian constants.
+     */
+    static GAUSSIAN_VALUES: Record<number, number[]>;
+
+    /**
+     * The fragment template generator
+     * @param kernelSize The number of kernels to use.
+     * @returns The generated fragment shader.
+     */
+    static fragTemplate(kernelSize: number): string;
+
+    /**
+     * The vertex template generator
+     * @param kernelSize The number of kernels to use.
+     * @param horizontal If the vertex should handle horizontal or vertical pass.
+     * @returns The generated vertex shader.
+     */
+    static vertTemplate(kernelSize: number, horizontal: boolean): string;
+
+    /**
+     * Generating the dynamic part of the blur in the fragment
+     * @param kernelSize The number of kernels to use.
+     * @returns The dynamic blur part.
+     */
+    static generateBlurFragSource(kernelSize: number): string;
+
+    /**
+     * Generating the dynamic part of the blur in the vertex
+     * @param kernelSize The number of kernels to use.
+     * @param horizontal If the vertex should handle horizontal or vertical pass.
+     * @returns The dynamic blur part.
+     */
+    static generateBlurVertSource(kernelSize: number, horizontal: boolean): string;
+
+    override apply(
+        filterManager: PIXI.FilterSystem,
+        input: PIXI.RenderTexture,
+        output: PIXI.RenderTexture,
+        clearMode?: PIXI.CLEAR_MODES,
+        _currentState?: PIXI.FilterState,
+    ): void;
+}
+
+/**
+ * Apply a gaussian blur going inward by using alpha as the penetrating channel.
+ */
+export default class AlphaBlurFilter extends PIXI.Filter {
+    /**
+     * @param {number} [strength=8]     Strength of the blur (distance of sampling).
+     * @param {number} [quality=4]      Number of passes to generate the blur. More passes = Higher quality = Lower Perf.
+     * @param {number} [resolution=PIXI.Filter.defaultResolution]  Resolution of the filter.
+     * @param {number} [kernelSize=5]   Number of kernels to use. More kernels = Higher quality = Lower Perf.
+     */
+    constructor(strength?: number, quality?: number, resolution?: number, kernelSize?: number);
+
+    override apply(
+        filterManager: PIXI.FilterSystem,
+        input: PIXI.RenderTexture,
+        output: PIXI.RenderTexture,
+        clearMode?: PIXI.CLEAR_MODES,
+        _currentState?: PIXI.FilterState,
+    ): void;
+
+    /**
+     * Update the filter padding according to the blur strength value (0 if _repeatEdgePixels is active)
+     */
+    updatePadding(): void;
+
+    /**
+     * The amount of blur is forwarded to the X and Y filters.
+     */
+    get blur(): number;
+
+    set blur(value);
+
+    /**
+     * The quality of blur defines the number of passes used by subsidiary filters.
+     */
+    get quality(): number;
+
+    set quality(value);
+
+    /**
+     * Whether to repeat edge pixels, adding padding to the filter area.
+     */
+    get repeatEdgePixels(): boolean;
+
+    set repeatEdgePixels(value);
+
+    /**
+     * Provided for completeness with PIXI.BlurFilter
+     */
+    get blurX(): number;
+
+    set blurX(value);
+
+    /**
+     * Provided for completeness with PIXI.BlurFilter
+     */
+    get blurY(): number;
+
+    set blurY(value);
+    /**
+     * Provided for completeness with PIXI.BlurFilter
+     */
+    get blendMode(): number;
+
+    set blendMode(value);
+}

package/src/client/canvas/rendering/filters/effects-masking.d.mts

@@ -0,0 +1,84 @@
+/**
+ * This filter handles masking and post-processing for visual effects.
+ */
+export default class VisualEffectsMaskingFilter extends AbstractBaseMaskFilter {
+    static override create(options?: object): VisualEffectsMaskingFilter;
+
+    /**
+     * Masking modes.
+     */
+    static FILTER_MODES: Readonly<{
+        BACKGROUND: 0;
+        ILLUMINATION: 1;
+        COLORATION: 2;
+    }>;
+
+    static override defaultUniforms: {
+        tint: number[];
+        screenDimensions: number[];
+        enableVisionMasking: boolean;
+        visionTexture: null;
+        darknessLevelTexture: null;
+        exposure: number;
+        contrast: number;
+        saturation: number;
+        mode: number;
+        ambientDarkness: number[];
+        ambientDaylight: number[];
+        replacementColor: number[];
+    };
+
+    /**
+     * Filter post-process techniques.
+     */
+    static POST_PROCESS_TECHNIQUES: {
+        EXPOSURE: {
+            id: string;
+            glsl: string;
+        };
+        CONTRAST: {
+            id: string;
+            glsl: string;
+        };
+        SATURATION: {
+            id: string;
+            glsl: string;
+        };
+    };
+
+    /**
+     * Memory allocations and headers for the VisualEffectsMaskingFilter
+     * @returns The filter header according to the filter mode.
+     */
+    static fragmentHeader: string;
+
+    /**
+     * The fragment core code.
+     */
+    static fragmentCore: string;
+
+    /**
+     * Construct filter post-processing code according to provided value.
+     * @param postProcessModes  Post-process modes to construct techniques.
+     * @returns The constructed shader code for post-process techniques.
+     */
+    static fragmentPostProcess(postProcessModes?: string[]): string;
+
+    /**
+     * Specify the fragment shader to use according to mode
+     */
+    static override fragmentShader(postProcessModes?: string[]): string;
+
+    /**
+     * Update the filter shader with new post-process modes.
+     * @param postProcessModes New modes to apply.
+     * @param uniforms Uniforms value to update.
+     */
+    updatePostprocessModes(postProcessModes?: string[] | undefined, uniforms?: object | undefined): void;
+
+    /**
+     * Remove all post-processing modes and reset some key uniforms.
+     */
+    reset(): void;
+}
+import AbstractBaseMaskFilter from "./base-mask-filter.mjs";

package/src/client/canvas/rendering/filters/environment.d.mts

@@ -0,0 +1,22 @@
+import AbstractBaseMaskFilter from "./base-mask-filter.mjs";
+
+/**
+ * A filter used to apply color adjustments and other modifications to the environment.
+ */
+export default class PrimaryCanvasGroupAmbienceFilter extends AbstractBaseMaskFilter {
+    static override defaultUniforms: {
+        uSampler: null;
+        darknessLevelTexture: null;
+        cycle: boolean;
+        baseTint: number[];
+        baseIntensity: number;
+        baseLuminosity: number;
+        baseSaturation: number;
+        baseShadows: number;
+        darkTint: number[];
+        darkIntensity: number;
+        darkLuminosity: number;
+        darkSaturation: number;
+        darkShadows: number;
+    };
+}

package/src/client/canvas/rendering/filters/glow-overlay.d.mts

@@ -0,0 +1,41 @@
+import AbstractBaseFilter from "./base-filter.mjs";
+
+/**
+ * A filter which implements an inner or outer glow around the source texture.
+ * Inspired from https://github.com/pixijs/filters/tree/main/filters/glow
+ * @license MIT
+ */
+export default class GlowOverlayFilter extends AbstractBaseFilter {
+    static override defaultUniforms: {
+        distance: number;
+        glowColor: number[];
+        quality: number;
+        time: number;
+        knockout: boolean;
+        alpha: number;
+    };
+
+    /**
+     * Dynamically create the fragment shader used for filters of this type.
+     */
+    static createFragmentShader(quality: number, distance: number): string;
+
+    static override create(initialUniforms?: object): GlowOverlayFilter;
+
+    /**
+     * The inner strength of the glow.
+     */
+    innerStrength: number;
+
+    /**
+     * The outer strength of the glow.
+     */
+    outerStrength: number;
+
+    /**
+     * Should this filter auto-animate?
+     */
+    animated: boolean;
+
+    apply(filterManager: any, input: any, output: any, clear: any): void;
+}

package/src/client/canvas/rendering/filters/invisibility.d.mts

@@ -0,0 +1,11 @@
+import AbstractBaseFilter from "./base-filter.mjs";
+
+/**
+ * Invisibility effect filter for placeables.
+ */
+export default class InvisibilityFilter extends AbstractBaseFilter {
+    static override defaultUniforms: {
+        uSampler: null;
+        color: number[];
+    };
+}

package/src/client/canvas/rendering/filters/outline-overlay.d.mts

@@ -0,0 +1,43 @@
+import AbstractBaseFilter from "./base-filter.mjs";
+
+/**
+ * A filter which implements an outline.
+ * Inspired from https://github.com/pixijs/filters/tree/main/filters/outline
+ * @license MIT
+ */
+export default class OutlineOverlayFilter extends AbstractBaseFilter {
+    static override defaultUniforms: {
+        outlineColor: number[];
+        thickness: number[];
+        alphaThreshold: number;
+        knockout: boolean;
+        wave: boolean;
+    };
+
+    /**
+     * Dynamically create the fragment shader used for filters of this type.
+     */
+    static createFragmentShader(): string;
+
+    static override create(initialUniforms?: object): OutlineOverlayFilter;
+
+    /**
+     * If the filter is animated or not.
+     */
+    animated: boolean;
+
+    /**
+     * The thickness of the outline.
+     */
+    get thickness(): number;
+
+    set thickness(value);
+
+    apply(
+        filterManager: PIXI.FilterSystem,
+        input: PIXI.RenderTexture,
+        output: PIXI.RenderTexture,
+        clearMode?: PIXI.CLEAR_MODES,
+        _currentState?: PIXI.FilterState,
+    ): void;
+}

package/src/client/canvas/rendering/filters/smaa/_module.d.mts

@@ -0,0 +1,4 @@
+export { default as SMAANeighborhoodBlendingFilter } from "./blend.mjs";
+export { default as SMAAEdgeDetectionFilter } from "./edges.mjs";
+export { default as SMAAFilter } from "./smaa.mjs";
+export { default as SMAABWeightCalculationFilter } from "./weights.mjs";