@league-of-foundry-developers/foundry-vtt-types 12.331.3-beta → 13.340.0

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/sunburst.d.mts

@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnySunburstColorationShader extends SunburstColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnySunburstIlluminationShader extends SunburstIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace SunburstColorationShader {
-    type AnyConstructor = typeof AnySunburstColorationShader;
-  }
-
-  namespace SunburstIlluminationShader {
-    type AnyConstructor = typeof AnySunburstIlluminationShader;
-  }
-
   /**
    * Sunburst animation illumination shader
    */
@@ -24,10 +8,28 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace SunburstIlluminationShader {
+    interface Any extends AnySunburstIlluminationShader {}
+    type AnyConstructor = typeof AnySunburstIlluminationShader;
+  }
+
   /**
    * Sunburst animation coloration shader
    */
   class SunburstColorationShader extends AdaptiveColorationShader {
     static override fragmentShader: string;
   }
+
+  namespace SunburstColorationShader {
+    interface Any extends AnySunburstColorationShader {}
+    type AnyConstructor = typeof AnySunburstColorationShader;
+  }
+}
+
+declare abstract class AnySunburstColorationShader extends SunburstColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnySunburstIlluminationShader extends SunburstIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/swirling-rainbow.d.mts

@@ -1,14 +1,5 @@
 export {};
-
-declare abstract class AnySwirlingRainbowColorationShader extends SwirlingRainbowColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace SwirlingRainbowColorationShader {
-    type AnyConstructor = typeof AnySwirlingRainbowColorationShader;
-  }
-
   /**
    * Swirling rainbow animation coloration shader
    */
@@ -20,4 +11,13 @@ declare global {
 
     static override fragmentShader: string;
   }
+
+  namespace SwirlingRainbowColorationShader {
+    interface Any extends AnySwirlingRainbowColorationShader {}
+    type AnyConstructor = typeof AnySwirlingRainbowColorationShader;
+  }
+}
+
+declare abstract class AnySwirlingRainbowColorationShader extends SwirlingRainbowColorationShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/torch.d.mts

@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyTorchColorationShader extends TorchColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyTorchIlluminationShader extends TorchIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace TorchColorationShader {
-    type AnyConstructor = typeof AnyTorchColorationShader;
-  }
-
-  namespace TorchIlluminationShader {
-    type AnyConstructor = typeof AnyTorchIlluminationShader;
-  }
-
   /**
    * Allow coloring of illumination
    */
@@ -24,6 +8,11 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace TorchIlluminationShader {
+    interface Any extends AnyTorchIlluminationShader {}
+    type AnyConstructor = typeof AnyTorchIlluminationShader;
+  }
+
   /**
    * Torch animation coloration shader
    */
@@ -42,4 +31,17 @@ declare global {
      */
     static override defaultUniforms: AbstractBaseShader.Uniforms;
   }
+
+  namespace TorchColorationShader {
+    interface Any extends AnyTorchColorationShader {}
+    type AnyConstructor = typeof AnyTorchColorationShader;
+  }
+}
+
+declare abstract class AnyTorchColorationShader extends TorchColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyTorchIlluminationShader extends TorchIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/vortex.d.mts

@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyVortexColorationShader extends VortexColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyVortexIlluminationShader extends VortexIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace VortexColorationShader {
-    type AnyConstructor = typeof AnyVortexColorationShader;
-  }
-
-  namespace VortexIlluminationShader {
-    type AnyConstructor = typeof AnyVortexIlluminationShader;
-  }
-
   /**
    * Vortex animation coloration shader
    */
@@ -29,10 +13,28 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace VortexColorationShader {
+    interface Any extends AnyVortexColorationShader {}
+    type AnyConstructor = typeof AnyVortexColorationShader;
+  }
+
   /**
    * Vortex animation coloration shader
    */
   class VortexIlluminationShader extends AdaptiveIlluminationShader {
     static override fragmentShader: string;
   }
+
+  namespace VortexIlluminationShader {
+    interface Any extends AnyVortexIlluminationShader {}
+    type AnyConstructor = typeof AnyVortexIlluminationShader;
+  }
+}
+
+declare abstract class AnyVortexColorationShader extends VortexColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyVortexIlluminationShader extends VortexIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/lighting/effects/wave.d.mts

@@ -1,22 +1,6 @@
 export {};
 
-declare abstract class AnyWaveColorationShader extends WaveColorationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyWaveIlluminationShader extends WaveIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace WaveColorationShader {
-    type AnyConstructor = typeof AnyWaveColorationShader;
-  }
-
-  namespace WaveIlluminationShader {
-    type AnyConstructor = typeof AnyWaveIlluminationShader;
-  }
-
   /**
    * Wave animation illumination shader
    */
@@ -24,10 +8,28 @@ declare global {
     static override fragmentShader: string;
   }
 
+  namespace WaveIlluminationShader {
+    interface Any extends AnyWaveIlluminationShader {}
+    type AnyConstructor = typeof AnyWaveIlluminationShader;
+  }
+
   /**
    * Wave animation coloration shader
    */
   class WaveColorationShader extends AdaptiveColorationShader {
     static override fragmentShader: string;
   }
+
+  namespace WaveColorationShader {
+    interface Any extends AnyWaveColorationShader {}
+    type AnyConstructor = typeof AnyWaveColorationShader;
+  }
+}
+
+declare abstract class AnyWaveColorationShader extends WaveColorationShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyWaveIlluminationShader extends WaveIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,14 +1,6 @@
 export {};
 
-declare abstract class AnyAdaptiveIlluminationShader extends AdaptiveIlluminationShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AdaptiveIlluminationShader {
-    type AnyConstructor = typeof AnyAdaptiveIlluminationShader;
-  }
-
   /**
    * The default coloration shader used by standard rendering and animations
    * A fragment shader which creates a solid light source.
@@ -76,4 +68,13 @@ declare global {
      */
     get isRequired(): boolean;
   }
+
+  namespace AdaptiveIlluminationShader {
+    interface Any extends AnyAdaptiveIlluminationShader {}
+    type AnyConstructor = typeof AnyAdaptiveIlluminationShader;
+  }
+}
+
+declare abstract class AnyAdaptiveIlluminationShader extends AdaptiveIlluminationShader {
+  constructor(arg0: never, ...args: never[]);
 }

package/src/foundry/client/pixi/webgl/shaders/region/adjust-darkness-level.d.mts

@@ -1,35 +1,10 @@
 export {};
 
-declare abstract class AnyAbstractDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyAdjustDarknessLevelRegionShader extends AdjustDarknessLevelRegionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
-declare abstract class AnyIlluminationDarknessLevelRegionShader extends IlluminationDarknessLevelRegionShader {
-  constructor(arg0: never, ...args: never[]);
-}
-
 declare global {
-  namespace AbstractDarknessLevelRegionShader {
-    type AnyConstructor = typeof AnyAbstractDarknessLevelRegionShader;
-  }
-
-  namespace AdjustDarknessLevelRegionShader {
-    type AnyConstructor = typeof AnyAdjustDarknessLevelRegionShader;
-  }
-
-  namespace IlluminationDarknessLevelRegionShader {
-    type AnyConstructor = typeof AnyIlluminationDarknessLevelRegionShader;
-  }
-
   /**
    * Abstract shader used for Adjust Darkness Level region behavior.
-   * @remarks Foundry labeled as abstract
    */
-  class AbstractDarknessLevelRegionShader extends RegionShader {
+  abstract class AbstractDarknessLevelRegionShader extends RegionShader {
     /**
      * @defaultValue
      * ```js
@@ -46,9 +21,8 @@ declare global {
     /**
      * The darkness level adjustment mode.
      * @defaultValue `foundry.data.regionBehaviors.AdjustDarknessLevelRegionBehaviorType.MODES.OVERRIDE`
-     * TODO: make into typeof... when referenced class is available
      */
-    mode: number;
+    mode: foundry.data.regionBehaviors.AdjustDarknessLevelRegionBehaviorType.MODES;
 
     /**
      * The darkness level modifier.
@@ -64,10 +38,36 @@ declare global {
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
 
+  namespace AbstractDarknessLevelRegionShader {
+    interface Any extends AnyAbstractDarknessLevelRegionShader {}
+    type AnyConstructor = typeof AnyAbstractDarknessLevelRegionShader;
+  }
+
   /**
    * Render the RegionMesh with darkness level adjustments.
    */
   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;
 
     /**
@@ -84,10 +84,52 @@ declare global {
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
 
+  namespace AdjustDarknessLevelRegionShader {
+    interface Any extends AnyAdjustDarknessLevelRegionShader {}
+    type AnyConstructor = typeof AnyAdjustDarknessLevelRegionShader;
+  }
+
   /**
    * Render the RegionMesh with darkness level adjustments.
    */
   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;
   }
+
+  namespace IlluminationDarknessLevelRegionShader {
+    interface Any extends AnyIlluminationDarknessLevelRegionShader {}
+    type AnyConstructor = typeof AnyIlluminationDarknessLevelRegionShader;
+  }
+}
+
+declare abstract class AnyAbstractDarknessLevelRegionShader extends AbstractDarknessLevelRegionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyAdjustDarknessLevelRegionShader extends AdjustDarknessLevelRegionShader {
+  constructor(arg0: never, ...args: never[]);
+}
+
+declare abstract class AnyIlluminationDarknessLevelRegionShader extends IlluminationDarknessLevelRegionShader {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,20 +1,55 @@
 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 {
+    /**
+     * @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;
 
     /**
@@ -32,4 +67,13 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace RegionShader {
+    interface Any extends AnyRegionShader {}
+    type AnyConstructor = typeof AnyRegionShader;
+  }
+}
+
+declare abstract class AnyRegionShader extends RegionShader {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,20 +1,71 @@
 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 {
+    /**
+     * @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;
 
     /**
@@ -32,4 +83,13 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace HighlightRegionShader {
+    interface Any extends AnyHighlightRegionShader {}
+    type AnyConstructor = typeof AnyHighlightRegionShader;
+  }
+}
+
+declare abstract class AnyHighlightRegionShader extends HighlightRegionShader {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,8 +1,4 @@
-import type { InexactPartial, Mixin } from "../../../../../../types/utils.d.mts";
-
-declare abstract class AnyBaseSamplerShader extends BaseSamplerShader {
-  constructor(arg0: never, ...args: never[]);
-}
+import type { InexactPartial, Mixin } from "fvtt-types/utils";
 
 declare class BatchPlugin<BaseSamplerShaderClass extends BaseSamplerShader.AnyConstructor> {
   /** @privateRemarks All mixin classses should accept anything for its constructor. */
@@ -26,24 +22,6 @@ declare class BatchGeometry extends PIXI.Geometry {
 }
 
 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!)
    */
@@ -64,7 +42,7 @@ declare global {
      * The plugin name associated for this instance, if any.
      * Returns "batch" if the shader is disabled.
      */
-    get pluginName(): BaseSamplerShader.PluginName;
+    get pluginName(): (typeof BaseSamplerShader)["classPluginName"];
 
     /**
      * Activate or deactivate this sampler. If set to false, the batch rendering is redirected to "batch".
@@ -203,4 +181,25 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace BaseSamplerShader {
+    interface Any extends AnyBaseSamplerShader {}
+    type AnyConstructor = 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[];
+  }
+}
+
+declare abstract class AnyBaseSamplerShader extends BaseSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }

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

@@ -1,14 +1,6 @@
 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.
    */
@@ -35,4 +27,13 @@ declare global {
 
     protected override _preRender: AbstractBaseShader.PreRenderFunction;
   }
+
+  namespace BaselineIlluminationSamplerShader {
+    interface Any extends AnyBaselineIlluminationSamplerShader {}
+    type AnyConstructor = typeof AnyBaselineIlluminationSamplerShader;
+  }
+}
+
+declare abstract class AnyBaselineIlluminationSamplerShader extends BaselineIlluminationSamplerShader {
+  constructor(arg0: never, ...args: never[]);
 }