@7h3laughingman/foundry-types 13.351.0

package/src/client/canvas/rendering/shaders/base-shader.d.mts

@@ -0,0 +1,58 @@
+import BaseShaderMixin from "../mixins/base-shader-mixin.mjs";
+
+/**
+ * This class defines an interface which all shaders utilize.
+ */
+export default abstract class AbstractBaseShader extends BaseShaderMixin(PIXI.Shader) {
+    /**
+     * The raw vertex shader used by this class.
+     * A subclass of AbstractBaseShader must implement the vertexShader static field.
+     * @type {string}
+     */
+    static vertexShader: string;
+    /**
+     * The raw fragment shader used by this class.
+     * A subclass of AbstractBaseShader must implement the fragmentShader static field.
+     * @type {string|(...args: any[]) => string}
+     */
+    static fragmentShader: string | ((...args: any[]) => string);
+    /**
+     * The default uniform values for the shader.
+     * A subclass of AbstractBaseShader must implement the defaultUniforms static field.
+     * @type {object}
+     */
+    static defaultUniforms: object;
+    /**
+     * A factory method for creating the shader using its defined default values
+     * @param {object} initialUniforms
+     * @returns {AbstractBaseShader}
+     */
+    static create(initialUniforms: object): AbstractBaseShader;
+    constructor(program: any, uniforms: any);
+    /**
+     * The initial values of the shader uniforms.
+     * @type {object}
+     */
+    initialUniforms: object;
+    /**
+     * Reset the shader uniforms back to their initial values.
+     */
+    reset(): void;
+    /**
+     * A one time initialization performed on creation.
+     * @protected
+     */
+    protected _configure(): void;
+    /**
+     * Perform operations which are required before binding the Shader to the Renderer.
+     * @param {PIXI.DisplayObject} mesh      The mesh display object linked to this shader.
+     * @param {PIXI.Renderer} renderer       The renderer
+     * @protected
+     */
+    protected _preRender(mesh: PIXI.DisplayObject, renderer: PIXI.Renderer): void;
+    /**
+     * @deprecated since v12
+     * @ignore
+     */
+    get _defaults(): object;
+}

package/src/client/canvas/rendering/shaders/graphics/dash-line.d.mts

@@ -0,0 +1,13 @@
+/**
+ * A modified version of the PIXI.smooth.DashLineShader that supports an offset.
+ * @internal
+ */
+export default class DashLineShader {
+    /**
+     * @param options      The options
+     * @param options.dash The length of the dash
+     * @param options.gap  The length of the gap
+     * @param options.offset The offset of the dashes
+     */
+    constructor({ dash, gap, offset }?: { dash?: number; gap?: number; offset?: number } | undefined);
+}

package/src/client/canvas/rendering/shaders/grid/grid.d.mts

@@ -0,0 +1,99 @@
+/**
+ * @import GridMesh from "./../../../../canvas/containers/elements/grid-mesh.mjs";
+ */
+/**
+ * The grid shader used by {@link GridMesh}.
+ */
+export default class GridShader extends AbstractBaseShader {
+    /**
+     * The grid type uniform.
+     * @type {string}
+     */
+    static TYPE_UNIFORM: string;
+    /**
+     * The grid thickness uniform.
+     * @type {string}
+     */
+    static THICKNESS_UNIFORM: string;
+    /**
+     * The grid color uniform.
+     * @type {string}
+     */
+    static COLOR_UNIFORM: string;
+    /**
+     * The resolution (pixels per grid space units) uniform.
+     * @type {string}
+     */
+    static RESOLUTION_UNIFORM: string;
+    /**
+     * The antialiased step function.
+     * The edge and x values is given in grid space units.
+     * @type {string}
+     */
+    static ANTIALIASED_STEP_FUNCTION: string;
+    /**
+     * The line converage function, which returns the alpha value at a point with the given distance (in grid space units)
+     * from an antialiased line (or point) with the given thickness (in grid space units).
+     * @type {string}
+     */
+    static LINE_COVERAGE_FUNCTION: string;
+    /**
+     * Hexagonal functions conversion for between grid and cube space.
+     * @type {string}
+     */
+    static HEXAGONAL_FUNCTIONS: string;
+    /**
+     * Get the nearest vertex of a grid space to the given point.
+     * @type {string}
+     */
+    static NEAREST_VERTEX_FUNCTION: string;
+    /**
+     * This function returns the distance to the nearest edge of a grid space given a point.
+     * @type {string}
+     */
+    static EDGE_DISTANCE_FUNCTION: string;
+    /**
+     * This function returns an vector (x, y, z), where
+     * - x is the x-offset along the nearest edge,
+     * - y is the y-offset (the distance) from the nearest edge, and
+     * - z is the length of the nearest edge.
+     * @type {string}
+     */
+    static EDGE_OFFSET_FUNCTION: string;
+    /**
+     * A function that draws the grid given a grid point, style, thickness, and color.
+     * @type {string}
+     */
+    static DRAW_GRID_FUNCTION: string;
+    /** @override */
+    static override get fragmentShader(): string;
+    /**
+     * The fragment shader source. Subclasses can override it.
+     * @type {string}
+     * @protected
+     */
+    protected static _fragmentShader: string;
+    /** @override */
+    static override defaultUniforms: {
+        canvasDimensions: number[];
+        meshDimensions: number[];
+        sceneDimensions: number[];
+        screenDimensions: number[];
+        gridSize: number;
+        type: number;
+        thickness: number;
+        resolution: number;
+        color: number[];
+        alpha: number;
+        style: number;
+    };
+    /**
+     * Configure the shader.
+     * @param {object} options
+     */
+    configure(options: object): void;
+    /** @override */
+    override _preRender(mesh: any, renderer: any): void;
+    #private;
+}
+import AbstractBaseShader from "../base-shader.mjs";

package/src/client/canvas/rendering/shaders/lighting/background-lighting.d.mts

@@ -0,0 +1,50 @@
+/**
+ * The default coloration shader used by standard rendering and animations.
+ * A fragment shader which creates a solid light source.
+ */
+export default class AdaptiveBackgroundShader extends AdaptiveLightingShader {
+    /**
+     * Memory allocations for the Adaptive Background Shader
+     * @type {string}
+     */
+    static SHADER_HEADER: string;
+    /** @inheritdoc */
+    static fragmentShader: string;
+    /** @override */
+    static override defaultUniforms: {
+        technique: number;
+        contrast: number;
+        shadows: number;
+        saturation: number;
+        intensity: number;
+        attenuation: number;
+        exposure: number;
+        ratio: number;
+        color: number[];
+        colorBackground: number[];
+        screenDimensions: number[];
+        time: number;
+        useSampler: boolean;
+        primaryTexture: null;
+        depthTexture: null;
+        darknessLevelTexture: null;
+        depthElevation: number;
+        ambientBrightest: number[];
+        ambientDarkness: number[];
+        ambientDaylight: number[];
+        weights: number[];
+        dimLevelCorrection: number;
+        brightLevelCorrection: number;
+        computeIllumination: boolean;
+        globalLight: boolean;
+        globalLightThresholds: number[];
+    };
+    /**
+     * Flag whether the background shader is currently required.
+     * Check vision modes requirements first, then
+     * if key uniforms are at their default values, we don't need to render the background container.
+     * @type {boolean}
+     */
+    get isRequired(): boolean;
+}
+import AdaptiveLightingShader from "./base-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/base-lighting.d.mts

@@ -0,0 +1,164 @@
+/**
+ * @typedef {Object} ShaderTechnique
+ * @property {number} id                       The numeric identifier of the technique
+ * @property {string} label                    The localization string that labels the technique
+ * @property {string} [coloration]             The coloration shader fragment when the technique is used
+ * @property {string} [illumination]           The illumination shader fragment when the technique is used
+ * @property {string} [background]             The background shader fragment when the technique is used
+ */
+/**
+ * This class defines an interface which all adaptive lighting shaders extend.
+ */
+export default class AdaptiveLightingShader extends AbstractBaseShader {
+    /**
+     * Has this lighting shader a forced default color?
+     * @type {boolean}
+     */
+    static forceDefaultColor: boolean;
+    /**
+     * Common attributes for vertex shaders.
+     * @type {string}
+     */
+    static VERTEX_ATTRIBUTES: string;
+    /**
+     * Common uniforms for vertex shaders.
+     * @type {string}
+     */
+    static VERTEX_UNIFORMS: string;
+    /**
+     * Common varyings shared by vertex and fragment shaders.
+     * @type {string}
+     */
+    static VERTEX_FRAGMENT_VARYINGS: string;
+    /**
+     * Common functions used by the vertex shaders.
+     * @type {string}
+     * @abstract
+     */
+    static VERTEX_FUNCTIONS: string;
+    /**
+     * Common uniforms shared by fragment shaders.
+     * @type {string}
+     */
+    static FRAGMENT_UNIFORMS: string;
+    /**
+     * Common functions used by the fragment shaders.
+     * @type {string}
+     * @abstract
+     */
+    static FRAGMENT_FUNCTIONS: string;
+    /** @inheritdoc */
+    static CONSTANTS: string;
+    /**
+     * Construct adaptive shader according to shader type
+     * @param {string} shaderType  shader type to construct : coloration, illumination, background, etc.
+     * @returns {string}           the constructed shader adaptive block
+     */
+    static getShaderTechniques(shaderType: string): string;
+    /**
+     * The coloration technique coloration shader fragment
+     * @type {string}
+     */
+    static get COLORATION_TECHNIQUES(): string;
+    /**
+     * The coloration technique illumination shader fragment
+     * @type {string}
+     */
+    static get ILLUMINATION_TECHNIQUES(): string;
+    /**
+     * The coloration technique background shader fragment
+     * @type {string}
+     */
+    static get BACKGROUND_TECHNIQUES(): string;
+    /**
+     * The adjustments made into fragment shaders
+     * @type {string}
+     */
+    static get ADJUSTMENTS(): string;
+    /**
+     * Contrast adjustment
+     * @type {string}
+     */
+    static CONTRAST: string;
+    /**
+     * Saturation adjustment
+     * @type {string}
+     */
+    static SATURATION: string;
+    /**
+     * Exposure adjustment
+     * @type {string}
+     */
+    static EXPOSURE: string;
+    /**
+     * Switch between an inner and outer color, by comparing distance from center to ratio
+     * Apply a strong gradient between the two areas if attenuation uniform is set to true
+     * @type {string}
+     */
+    static SWITCH_COLOR: string;
+    /**
+     * Shadow adjustment
+     * @type {string}
+     */
+    static SHADOW: string;
+    /**
+     * Transition between bright and dim colors, if requested
+     * @type {string}
+     */
+    static TRANSITION: string;
+    /**
+     * Incorporate falloff if a attenuation uniform is requested
+     * @type {string}
+     */
+    static FALLOFF: string;
+    /**
+     * Compute illumination uniforms
+     * @type {string}
+     */
+    static COMPUTE_ILLUMINATION: string;
+    /**
+     * Initialize fragment with common properties
+     * @type {string}
+     */
+    static FRAGMENT_BEGIN: string;
+    /**
+     * Shader final
+     * @type {string}
+     */
+    static FRAGMENT_END: string;
+    /**
+     * A mapping of available shader techniques
+     * @type {Record<string, ShaderTechnique>}
+     */
+    static SHADER_TECHNIQUES: Record<string, ShaderTechnique>;
+    /** Called before rendering. */
+    update(): void;
+    /**
+     * @deprecated since v12
+     * @ignore
+     */
+    getDarknessPenalty(darknessLevel: any, luminosity: any): number;
+}
+export type ShaderTechnique = {
+    /**
+     * The numeric identifier of the technique
+     */
+    id: number;
+    /**
+     * The localization string that labels the technique
+     */
+    label: string;
+    /**
+     * The coloration shader fragment when the technique is used
+     */
+    coloration?: string | undefined;
+    /**
+     * The illumination shader fragment when the technique is used
+     */
+    illumination?: string | undefined;
+    /**
+     * The background shader fragment when the technique is used
+     */
+    background?: string | undefined;
+};
+import AbstractBaseShader from "../base-shader.mjs";

package/src/client/canvas/rendering/shaders/lighting/coloration-lighting.d.mts

@@ -0,0 +1,48 @@
+/**
+ * The default coloration shader used by standard rendering and animations.
+ * A fragment shader which creates a light source.
+ */
+export default class AdaptiveColorationShader extends AdaptiveLightingShader {
+    /**
+     * Memory allocations for the Adaptive Coloration Shader
+     * @type {string}
+     */
+    static SHADER_HEADER: string;
+    /** @inheritdoc */
+    static fragmentShader: string;
+    /** @inheritdoc */
+    static defaultUniforms: {
+        technique: number;
+        shadows: number;
+        contrast: number;
+        saturation: number;
+        colorationAlpha: number;
+        intensity: number;
+        attenuation: number;
+        ratio: number;
+        color: number[];
+        time: number;
+        hasColor: boolean;
+        screenDimensions: number[];
+        useSampler: boolean;
+        primaryTexture: null;
+        depthTexture: null;
+        darknessLevelTexture: null;
+        depthElevation: number;
+        ambientBrightest: number[];
+        ambientDarkness: number[];
+        ambientDaylight: number[];
+        weights: number[];
+        dimLevelCorrection: number;
+        brightLevelCorrection: number;
+        computeIllumination: boolean;
+        globalLight: boolean;
+        globalLightThresholds: number[];
+    };
+    /**
+     * Flag whether the coloration shader is currently required.
+     * @type {boolean}
+     */
+    get isRequired(): boolean;
+}
+import AdaptiveLightingShader from "./base-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/darkness-lighting.d.mts

@@ -0,0 +1,45 @@
+/**
+ * The default coloration shader used by standard rendering and animations.
+ * A fragment shader which creates a solid light source.
+ */
+export default class AdaptiveDarknessShader extends AdaptiveLightingShader {
+    /** @override */
+    static override defaultUniforms: {
+        intensity: number;
+        color: [number, number, number];
+        screenDimensions: number[];
+        time: number;
+        primaryTexture: null;
+        depthTexture: null;
+        visionTexture: null;
+        darknessLevelTexture: null;
+        depthElevation: number;
+        ambientBrightest: number[];
+        ambientDarkness: number[];
+        ambientDaylight: number[];
+        weights: number[];
+        dimLevelCorrection: number;
+        brightLevelCorrection: number;
+        borderDistance: number;
+        darknessLevel: number;
+        computeIllumination: boolean;
+        globalLight: boolean;
+        globalLightThresholds: number[];
+        enableVisionMasking: boolean;
+    };
+    /**
+     * Memory allocations for the Adaptive Background Shader
+     * @type {string}
+     */
+    static SHADER_HEADER: string;
+    /** @inheritdoc */
+    static fragmentShader: string;
+    /**
+     * Flag whether the darkness shader is currently required.
+     * Check vision modes requirements first, then
+     * if key uniforms are at their default values, we don't need to render the background container.
+     * @type {boolean}
+     */
+    get isRequired(): boolean;
+}
+import AdaptiveLightingShader from "./base-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/bewitching-wave.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Bewitching Wave animation illumination shader
+ */
+export class BewitchingWaveIlluminationShader extends AdaptiveIlluminationShader {}
+/**
+ * Bewitching Wave animation coloration shader
+ */
+export class BewitchingWaveColorationShader extends AdaptiveColorationShader {}
+import AdaptiveColorationShader from "../coloration-lighting.mjs";
+import AdaptiveIlluminationShader from "../illumination-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/black-hole.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Black Hole animation illumination shader
+ */
+export class BlackHoleDarknessShader extends AdaptiveDarknessShader {}
+import AdaptiveDarknessShader from "../darkness-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/chroma.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Chroma animation coloration shader
+ */
+export class ChromaColorationShader extends AdaptiveColorationShader {}
+import AdaptiveColorationShader from "../coloration-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/emanation.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Emanation animation coloration shader
+ */
+export class EmanationColorationShader extends AdaptiveColorationShader {}
+import AdaptiveColorationShader from "../coloration-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/energy-field.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Energy field animation coloration shader
+ */
+export class EnergyFieldColorationShader extends AdaptiveColorationShader {}
+import AdaptiveColorationShader from "../coloration-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/fairy-light.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Fairy light animation coloration shader
+ */
+export class FairyLightColorationShader extends AdaptiveColorationShader {}
+/**
+ * Fairy light animation illumination shader
+ */
+export class FairyLightIlluminationShader extends AdaptiveIlluminationShader {}
+import AdaptiveColorationShader from "../coloration-lighting.mjs";
+import AdaptiveIlluminationShader from "../illumination-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/flame.d.mts

@@ -0,0 +1,75 @@
+/**
+ * Alternative torch illumination shader
+ */
+export class FlameIlluminationShader extends AdaptiveIlluminationShader {
+    /** @inheritdoc */
+    static defaultUniforms: {
+        brightnessPulse: number;
+        technique: number;
+        shadows: number;
+        saturation: number;
+        intensity: number;
+        attenuation: number;
+        contrast: number;
+        exposure: number;
+        ratio: number;
+        darknessLevel: number;
+        color: number[];
+        colorBackground: number[];
+        colorDim: number[];
+        colorBright: number[];
+        screenDimensions: number[];
+        time: number;
+        useSampler: boolean;
+        primaryTexture: null;
+        depthTexture: null;
+        darknessLevelTexture: null;
+        depthElevation: number;
+        ambientBrightest: number[];
+        ambientDarkness: number[];
+        ambientDaylight: number[];
+        weights: number[];
+        dimLevelCorrection: number;
+        brightLevelCorrection: number;
+        computeIllumination: boolean;
+        globalLight: boolean;
+        globalLightThresholds: number[];
+    };
+}
+/**
+ * Alternative torch coloration shader
+ */
+export class FlameColorationShader extends AdaptiveColorationShader {
+    /** @inheritdoc */
+    static defaultUniforms: {
+        brightnessPulse: number;
+        technique: number;
+        shadows: number;
+        contrast: number;
+        saturation: number;
+        colorationAlpha: number;
+        intensity: number;
+        attenuation: number;
+        ratio: number;
+        color: number[];
+        time: number;
+        hasColor: boolean;
+        screenDimensions: number[];
+        useSampler: boolean;
+        primaryTexture: null;
+        depthTexture: null;
+        darknessLevelTexture: null;
+        depthElevation: number;
+        ambientBrightest: number[];
+        ambientDarkness: number[];
+        ambientDaylight: number[];
+        weights: number[];
+        dimLevelCorrection: number;
+        brightLevelCorrection: number;
+        computeIllumination: boolean;
+        globalLight: boolean;
+        globalLightThresholds: number[];
+    };
+}
+import AdaptiveColorationShader from "../coloration-lighting.mjs";
+import AdaptiveIlluminationShader from "../illumination-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/fog.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Fog animation coloration shader
+ */
+export class FogColorationShader extends AdaptiveColorationShader {}
+import AdaptiveColorationShader from "../coloration-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/force-grid.d.mts

@@ -0,0 +1,5 @@
+/**
+ * A futuristic Force Grid animation.
+ */
+export class ForceGridColorationShader extends AdaptiveColorationShader {}
+import AdaptiveColorationShader from "../coloration-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/ghost-light.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Ghost light animation illumination shader
+ */
+export class GhostLightIlluminationShader extends AdaptiveIlluminationShader {}
+/**
+ * Ghost light animation coloration shader
+ */
+export class GhostLightColorationShader extends AdaptiveColorationShader {}
+import AdaptiveColorationShader from "../coloration-lighting.mjs";
+import AdaptiveIlluminationShader from "../illumination-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/hexa-dome.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Hexagonal dome animation coloration shader
+ */
+export class HexaDomeColorationShader extends AdaptiveColorationShader {}
+import AdaptiveColorationShader from "../coloration-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/light-dome.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Light dome animation coloration shader
+ */
+export class LightDomeColorationShader extends AdaptiveColorationShader {}
+import AdaptiveColorationShader from "../coloration-lighting.mjs";

package/src/client/canvas/rendering/shaders/lighting/effects/magical-gloom.d.mts

@@ -0,0 +1,5 @@
+/**
+ * Creates a gloomy ring of pure darkness.
+ */
+export class MagicalGloomDarknessShader extends AdaptiveDarknessShader {}
+import AdaptiveDarknessShader from "../darkness-lighting.mjs";