three-stdlib 2.35.6 → 2.35.8

package/shaders/BasicShader.d.cts

@@ -0,0 +1,8 @@
+/**
+ * Simple test shader
+ */
+import type { IShader } from './types.d.cts';
+export type BasicShaderUniforms = {};
+export interface IBasicShader extends IShader<BasicShaderUniforms> {
+}
+export declare const BasicShader: IBasicShader;

package/shaders/BasicShader.d.ts

@@ -1,7 +1,7 @@
 /**
  * Simple test shader
  */
-import type { IShader } from './types';
+import type { IShader } from './types.d.ts';
 export type BasicShaderUniforms = {};
 export interface IBasicShader extends IShader<BasicShaderUniforms> {
 }

package/shaders/BleachBypassShader.d.cts

@@ -0,0 +1,14 @@
+/**
+ * Bleach bypass shader [http://en.wikipedia.org/wiki/Bleach_bypass]
+ * - based on Nvidia example
+ * http://developer.download.nvidia.com/shaderlibrary/webpages/shader_library.html#post_bleach_bypass
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types.d.cts';
+export type BleachBypassShaderUniforms = {
+    opacity: IUniform<number>;
+    tDiffuse: IUniform<Texture | null>;
+};
+export interface IBleachBypassShader extends IShader<BleachBypassShaderUniforms> {
+}
+export declare const BleachBypassShader: IBleachBypassShader;

package/shaders/BleachBypassShader.d.ts

@@ -4,7 +4,7 @@
  * http://developer.download.nvidia.com/shaderlibrary/webpages/shader_library.html#post_bleach_bypass
  */
 import type { IUniform, Texture } from 'three';
-import type { IShader } from './types';
+import type { IShader } from './types.d.ts';
 export type BleachBypassShaderUniforms = {
     opacity: IUniform<number>;
     tDiffuse: IUniform<Texture | null>;

package/shaders/BlendShader.d.cts

@@ -0,0 +1,21 @@
+/**
+ * Blend two textures
+ */
+export declare const BlendShader: {
+    uniforms: {
+        tDiffuse1: {
+            value: null;
+        };
+        tDiffuse2: {
+            value: null;
+        };
+        mixRatio: {
+            value: number;
+        };
+        opacity: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/BokehShader.d.cts

@@ -0,0 +1,24 @@
+/**
+ * Depth-of-field shader with bokeh
+ * ported from GLSL shader by Martins Upitis
+ * http://artmartinsh.blogspot.com/2010/02/glsl-lens-blur-filter-with-bokeh.html
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types.d.cts';
+export type BokehShaderDefines = {
+    DEPTH_PACKING: number;
+    PERSPECTIVE_CAMERA: number;
+};
+export type BokehShaderUniforms = {
+    aperture: IUniform<number>;
+    aspect: IUniform<number>;
+    farClip: IUniform<number>;
+    focus: IUniform<number>;
+    maxblur: IUniform<number>;
+    nearClip: IUniform<number>;
+    tColor: IUniform<Texture | null>;
+    tDepth: IUniform<Texture | null>;
+};
+export interface IBokehShader extends IShader<BokehShaderUniforms, BokehShaderDefines> {
+}
+export declare const BokehShader: IBokehShader;

package/shaders/BokehShader.d.ts

@@ -4,7 +4,7 @@
  * http://artmartinsh.blogspot.com/2010/02/glsl-lens-blur-filter-with-bokeh.html
  */
 import type { IUniform, Texture } from 'three';
-import type { IShader } from './types';
+import type { IShader } from './types.d.ts';
 export type BokehShaderDefines = {
     DEPTH_PACKING: number;
     PERSPECTIVE_CAMERA: number;

package/shaders/BokehShader2.d.cts

@@ -0,0 +1,50 @@
+import type { IUniform, Texture, Vector2 } from 'three';
+export interface BokehShader2Uniforms {
+    textureWidth: IUniform<number>;
+    textureHeight: IUniform<number>;
+    focalDepth: IUniform<number>;
+    focalLength: IUniform<number>;
+    fstop: IUniform<number>;
+    tColor: IUniform<Texture | null>;
+    tDepth: IUniform<Texture | null>;
+    maxblur: IUniform<number>;
+    showFocus: IUniform<number>;
+    manualdof: IUniform<number>;
+    vignetting: IUniform<number>;
+    depthblur: IUniform<number>;
+    threshold: IUniform<number>;
+    gain: IUniform<number>;
+    bias: IUniform<number>;
+    fringe: IUniform<number>;
+    znear: IUniform<number>;
+    zfar: IUniform<number>;
+    noise: IUniform<number>;
+    dithering: IUniform<number>;
+    pentagon: IUniform<number>;
+    shaderFocus: IUniform<number>;
+    focusCoords: IUniform<Vector2>;
+}
+/**
+ * Depth-of-field shader with bokeh
+ * ported from GLSL shader by Martins Upitis
+ * http://blenderartists.org/forum/showthread.php?237488-GLSL-depth-of-field-with-bokeh-v2-4-(update)
+ *
+ * Requires #define RINGS and SAMPLES integers
+ */
+export declare const BokehShader2: {
+    uniforms: BokehShader2Uniforms;
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const BokehDepthShader: {
+    uniforms: {
+        mNear: {
+            value: number;
+        };
+        mFar: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/BokehShader2.d.ts

@@ -1,4 +1,4 @@
-import { IUniform, Texture, Vector2 } from 'three';
+import type { IUniform, Texture, Vector2 } from 'three';
 export interface BokehShader2Uniforms {
     textureWidth: IUniform<number>;
     textureHeight: IUniform<number>;

package/shaders/BrightnessContrastShader.d.cts

@@ -0,0 +1,21 @@
+/**
+ * Brightness and contrast adjustment
+ * https://github.com/evanw/glfx.js
+ * brightness: -1 to 1 (-1 is solid black, 0 is no change, and 1 is solid white)
+ * contrast: -1 to 1 (-1 is solid gray, 0 is no change, and 1 is maximum contrast)
+ */
+export declare const BrightnessContrastShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        brightness: {
+            value: number;
+        };
+        contrast: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/ColorCorrectionShader.d.cts

@@ -0,0 +1,22 @@
+import type { Vector3 } from 'three';
+/**
+ * Color correction
+ */
+export declare const ColorCorrectionShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        powRGB: {
+            value: Vector3;
+        };
+        mulRGB: {
+            value: Vector3;
+        };
+        addRGB: {
+            value: Vector3;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/ColorCorrectionShader.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from 'three';
+import type { Vector3 } from 'three';
 /**
  * Color correction
  */

package/shaders/ColorifyShader.d.cts

@@ -0,0 +1,16 @@
+import type { Color } from 'three';
+/**
+ * Colorify shader
+ */
+export declare const ColorifyShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        color: {
+            value: Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/ColorifyShader.d.ts

@@ -1,4 +1,4 @@
-import { Color } from 'three';
+import type { Color } from 'three';
 /**
  * Colorify shader
  */

package/shaders/ConvolutionShader.d.cts

@@ -0,0 +1,21 @@
+import type { Vector2 } from 'three';
+/**
+ * Convolution shader
+ * ported from o3d sample to WebGL / GLSL
+ * http://o3d.googlecode.com/svn/trunk/samples/convolution.html
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types.d.cts';
+export type ConvolutionShaderDefines = {
+    KERNEL_SIZE_FLOAT: string;
+    KERNEL_SIZE_INT: string;
+};
+export type ConvolutionShaderUniforms = {
+    cKernel: IUniform<number[]>;
+    tDiffuse: IUniform<Texture | null>;
+    uImageIncrement: IUniform<Vector2>;
+};
+export interface IConvolutionShader extends IShader<ConvolutionShaderUniforms, ConvolutionShaderDefines> {
+    buildKernel: (sigma: number) => number[];
+}
+export declare const ConvolutionShader: IConvolutionShader;

package/shaders/ConvolutionShader.d.ts

@@ -1,11 +1,11 @@
-import { Vector2 } from 'three';
+import type { Vector2 } from 'three';
 /**
  * Convolution shader
  * ported from o3d sample to WebGL / GLSL
  * http://o3d.googlecode.com/svn/trunk/samples/convolution.html
  */
 import type { IUniform, Texture } from 'three';
-import type { IShader } from './types';
+import type { IShader } from './types.d.ts';
 export type ConvolutionShaderDefines = {
     KERNEL_SIZE_FLOAT: string;
     KERNEL_SIZE_INT: string;

package/shaders/CopyShader.d.cts

@@ -0,0 +1,12 @@
+/**
+ * Full-screen textured quad shader
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types.d.cts';
+export type CopyShaderUniforms = {
+    opacity: IUniform<number>;
+    tDiffuse: IUniform<Texture | null>;
+};
+export interface ICopyShader extends IShader<CopyShaderUniforms> {
+}
+export declare const CopyShader: ICopyShader;

package/shaders/CopyShader.d.ts

@@ -2,7 +2,7 @@
  * Full-screen textured quad shader
  */
 import type { IUniform, Texture } from 'three';
-import type { IShader } from './types';
+import type { IShader } from './types.d.ts';
 export type CopyShaderUniforms = {
     opacity: IUniform<number>;
     tDiffuse: IUniform<Texture | null>;

package/shaders/DOFMipMapShader.d.cts

@@ -0,0 +1,23 @@
+/**
+ * Depth-of-field shader using mipmaps
+ * - from Matt Handley @applmak
+ * - requires power-of-2 sized render target with enabled mipmaps
+ */
+export declare const DOFMipMapShader: {
+    uniforms: {
+        tColor: {
+            value: null;
+        };
+        tDepth: {
+            value: null;
+        };
+        focus: {
+            value: number;
+        };
+        maxblur: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/DepthLimitedBlurShader.d.cts

@@ -0,0 +1,28 @@
+import type { Vector2 } from 'three';
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types.d.cts';
+export type DepthLimitedBlurShaderDefines = {
+    DEPTH_PACKING: number;
+    KERNEL_RADIUS: number;
+    PERSPECTIVE_CAMERA: number;
+};
+export type DepthLimitedBlurShaderUniforms = {
+    cameraFar: IUniform<number>;
+    cameraNear: IUniform<number>;
+    depthCutoff: IUniform<number>;
+    sampleUvOffsets: IUniform<Vector2[]>;
+    sampleWeights: IUniform<number[]>;
+    size: IUniform<Vector2>;
+    tDepth: IUniform<Texture | null>;
+    tDiffuse: IUniform<Texture | null>;
+};
+export interface IDepthLimitedBlurShader extends IShader<DepthLimitedBlurShaderUniforms, DepthLimitedBlurShaderDefines> {
+    defines: DepthLimitedBlurShaderDefines;
+    needsUpdate?: boolean;
+}
+export declare const DepthLimitedBlurShader: IDepthLimitedBlurShader;
+export declare const BlurShaderUtils: {
+    createSampleWeights: (kernelRadius: number, stdDev: number) => number[];
+    createSampleOffsets: (kernelRadius: number, uvIncrement: Vector2) => Vector2[];
+    configure: (shader: IDepthLimitedBlurShader, kernelRadius: number, stdDev: number, uvIncrement: Vector2) => void;
+};

package/shaders/DepthLimitedBlurShader.d.ts

@@ -1,6 +1,6 @@
-import { Vector2 } from 'three';
+import type { Vector2 } from 'three';
 import type { IUniform, Texture } from 'three';
-import type { IShader } from './types';
+import type { IShader } from './types.d.ts';
 export type DepthLimitedBlurShaderDefines = {
     DEPTH_PACKING: number;
     KERNEL_RADIUS: number;

package/shaders/DigitalGlitch.d.cts

@@ -0,0 +1,39 @@
+export declare const DigitalGlitch: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        tDisp: {
+            value: null;
+        };
+        byp: {
+            value: number;
+        };
+        amount: {
+            value: number;
+        };
+        angle: {
+            value: number;
+        };
+        seed: {
+            value: number;
+        };
+        seed_x: {
+            value: number;
+        };
+        seed_y: {
+            value: number;
+        };
+        distortion_x: {
+            value: number;
+        };
+        distortion_y: {
+            value: number;
+        };
+        col_s: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/DotScreenShader.d.cts

@@ -0,0 +1,27 @@
+import type { Vector2 } from 'three';
+/**
+ * Dot screen shader
+ * based on glfx.js sepia shader
+ * https://github.com/evanw/glfx.js
+ */
+export declare const DotScreenShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        tSize: {
+            value: Vector2;
+        };
+        center: {
+            value: Vector2;
+        };
+        angle: {
+            value: number;
+        };
+        scale: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/DotScreenShader.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from 'three';
+import type { Vector2 } from 'three';
 /**
  * Dot screen shader
  * based on glfx.js sepia shader

package/shaders/FXAAShader.d.cts

@@ -0,0 +1,19 @@
+import type { Vector2 } from 'three';
+/**
+ * NVIDIA FXAA by Timothy Lottes
+ * http://timothylottes.blogspot.com/2011/06/fxaa3-source-released.html
+ * - WebGL port by @supereggbert
+ * http://www.glge.org/demos/fxaa/
+ */
+export declare const FXAAShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        resolution: {
+            value: Vector2;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/FXAAShader.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from 'three';
+import type { Vector2 } from 'three';
 /**
  * NVIDIA FXAA by Timothy Lottes
  * http://timothylottes.blogspot.com/2011/06/fxaa3-source-released.html

package/shaders/FilmShader.d.cts

@@ -0,0 +1,43 @@
+/**
+ * Film grain & scanlines shader
+ *
+ * - ported from HLSL to WebGL / GLSL
+ * http://www.truevision3d.com/forums/showcase/staticnoise_colorblackwhite_scanline_shaders-t18698.0.html
+ *
+ * Screen Space Static Postprocessor
+ *
+ * Produces an analogue noise overlay similar to a film grain / TV static
+ *
+ * Original implementation and noise algorithm
+ * Pat 'Hawthorne' Shearon
+ *
+ * Optimized scanlines + noise version with intensity scaling
+ * Georg 'Leviathan' Steinrohder
+ *
+ * This version is provided under a Creative Commons Attribution 3.0 License
+ * http://creativecommons.org/licenses/by/3.0/
+ */
+export declare const FilmShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        time: {
+            value: number;
+        };
+        nIntensity: {
+            value: number;
+        };
+        sIntensity: {
+            value: number;
+        };
+        sCount: {
+            value: number;
+        };
+        grayscale: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/FocusShader.d.cts

@@ -0,0 +1,26 @@
+/**
+ * Focus shader
+ * based on PaintEffect postprocess from ro.me
+ * http://code.google.com/p/3-dreams-of-black/source/browse/deploy/js/effects/PaintEffect.js
+ */
+export declare const FocusShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        screenWidth: {
+            value: number;
+        };
+        screenHeight: {
+            value: number;
+        };
+        sampleDistance: {
+            value: number;
+        };
+        waveFactor: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/FreiChenShader.d.cts

@@ -0,0 +1,19 @@
+import type { Vector2 } from 'three';
+/**
+ * Edge Detection Shader using Frei-Chen filter
+ * Based on http://rastergrid.com/blog/2011/01/frei-chen-edge-detector
+ *
+ * aspect: vec2 of (1/width, 1/height)
+ */
+export declare const FreiChenShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        aspect: {
+            value: Vector2;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/FreiChenShader.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from 'three';
+import type { Vector2 } from 'three';
 /**
  * Edge Detection Shader using Frei-Chen filter
  * Based on http://rastergrid.com/blog/2011/01/frei-chen-edge-detector

package/shaders/FresnelShader.d.cts

@@ -0,0 +1,24 @@
+/**
+ * Based on Nvidia Cg tutorial
+ */
+export declare const FresnelShader: {
+    uniforms: {
+        mRefractionRatio: {
+            value: number;
+        };
+        mFresnelBias: {
+            value: number;
+        };
+        mFresnelPower: {
+            value: number;
+        };
+        mFresnelScale: {
+            value: number;
+        };
+        tCube: {
+            value: null;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/GammaCorrectionShader.d.cts

@@ -0,0 +1,12 @@
+/**
+ * Gamma Correction Shader
+ * http://en.wikipedia.org/wiki/gamma_correction
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types.d.cts';
+export type GammaCorrectionShaderUniforms = {
+    tDiffuse: IUniform<Texture | null>;
+};
+export interface IGammaCorrectionShader extends IShader<GammaCorrectionShaderUniforms> {
+}
+export declare const GammaCorrectionShader: IGammaCorrectionShader;

package/shaders/GammaCorrectionShader.d.ts

@@ -3,7 +3,7 @@
  * http://en.wikipedia.org/wiki/gamma_correction
  */
 import type { IUniform, Texture } from 'three';
-import type { IShader } from './types';
+import type { IShader } from './types.d.ts';
 export type GammaCorrectionShaderUniforms = {
     tDiffuse: IUniform<Texture | null>;
 };