three-stdlib 2.35.6 → 2.35.8

package/shaders/SSRShader.d.cts

@@ -0,0 +1,94 @@
+import type { Matrix4, Vector2 } from 'three';
+/**
+ * References:
+ * https://lettier.github.io/3d-game-shaders-for-beginners/screen-space-reflection.html
+ */
+export declare const SSRShader: {
+    defines: {
+        MAX_STEP: number;
+        isPerspectiveCamera: boolean;
+        isDistanceAttenuation: boolean;
+        isFresnel: boolean;
+        isInfiniteThick: boolean;
+        isSelective: boolean;
+    };
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        tNormal: {
+            value: null;
+        };
+        tMetalness: {
+            value: null;
+        };
+        tDepth: {
+            value: null;
+        };
+        cameraNear: {
+            value: null;
+        };
+        cameraFar: {
+            value: null;
+        };
+        resolution: {
+            value: Vector2;
+        };
+        cameraProjectionMatrix: {
+            value: Matrix4;
+        };
+        cameraInverseProjectionMatrix: {
+            value: Matrix4;
+        };
+        opacity: {
+            value: number;
+        };
+        maxDistance: {
+            value: number;
+        };
+        cameraRange: {
+            value: number;
+        };
+        surfDist: {
+            value: number;
+        };
+        thickTolerance: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const SSRDepthShader: {
+    defines: {
+        PERSPECTIVE_CAMERA: number;
+    };
+    uniforms: {
+        tDepth: {
+            value: null;
+        };
+        cameraNear: {
+            value: null;
+        };
+        cameraFar: {
+            value: null;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const SSRBlurShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        resolution: {
+            value: Vector2;
+        };
+        opacity: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/SSRShader.d.ts

@@ -1,4 +1,4 @@
-import { Matrix4, Vector2 } from 'three';
+import type { Matrix4, Vector2 } from 'three';
 /**
  * References:
  * https://lettier.github.io/3d-game-shaders-for-beginners/screen-space-reflection.html

package/shaders/SepiaShader.d.cts

@@ -0,0 +1,17 @@
+/**
+ * Sepia tone shader
+ * based on glfx.js sepia shader
+ * https://github.com/evanw/glfx.js
+ */
+export declare const SepiaShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        amount: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/SobelOperatorShader.d.cts

@@ -0,0 +1,19 @@
+import type { Vector2 } from 'three';
+/**
+ * Sobel Edge Detection (see https://youtu.be/uihBwtPIBxM)
+ *
+ * As mentioned in the video the Sobel operator expects a grayscale image as input.
+ *
+ */
+export declare const SobelOperatorShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        resolution: {
+            value: Vector2;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/SobelOperatorShader.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from 'three';
+import type { Vector2 } from 'three';
 /**
  * Sobel Edge Detection (see https://youtu.be/uihBwtPIBxM)
  *

package/shaders/SubsurfaceScatteringShader.d.cts

@@ -0,0 +1,5 @@
+export declare const SubsurfaceScatteringShader: {
+    uniforms: any;
+    vertexShader: any;
+    fragmentShader: any;
+};

package/shaders/TechnicolorShader.d.cts

@@ -0,0 +1,15 @@
+/**
+ * Technicolor Shader
+ * Simulates the look of the two-strip technicolor process popular in early 20th century films.
+ * More historical info here: http://www.widescreenmuseum.com/oldcolor/technicolor1.htm
+ * Demo here: http://charliehoey.com/technicolor_shader/shader_test.html
+ */
+export declare const TechnicolorShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/ToneMapShader.d.cts

@@ -0,0 +1,27 @@
+/**
+ * Full-screen tone-mapping shader based on http://www.cis.rit.edu/people/faculty/ferwerda/publications/sig02_paper.pdf
+ */
+export declare const ToneMapShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        averageLuminance: {
+            value: number;
+        };
+        luminanceMap: {
+            value: null;
+        };
+        maxLuminance: {
+            value: number;
+        };
+        minLuminance: {
+            value: number;
+        };
+        middleGrey: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/ToonShader.d.cts

@@ -0,0 +1,108 @@
+import type { Color, Vector3 } from 'three';
+/**
+ * Currently contains:
+ *
+ *	toon1
+ *	toon2
+ *	hatching
+ *	dotted
+ */
+export declare const ToonShader1: {
+    uniforms: {
+        uDirLightPos: {
+            value: Vector3;
+        };
+        uDirLightColor: {
+            value: Color;
+        };
+        uAmbientLightColor: {
+            value: Color;
+        };
+        uBaseColor: {
+            value: Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const ToonShader2: {
+    uniforms: {
+        uDirLightPos: {
+            value: Vector3;
+        };
+        uDirLightColor: {
+            value: Color;
+        };
+        uAmbientLightColor: {
+            value: Color;
+        };
+        uBaseColor: {
+            value: Color;
+        };
+        uLineColor1: {
+            value: Color;
+        };
+        uLineColor2: {
+            value: Color;
+        };
+        uLineColor3: {
+            value: Color;
+        };
+        uLineColor4: {
+            value: Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const ToonShaderHatching: {
+    uniforms: {
+        uDirLightPos: {
+            value: Vector3;
+        };
+        uDirLightColor: {
+            value: Color;
+        };
+        uAmbientLightColor: {
+            value: Color;
+        };
+        uBaseColor: {
+            value: Color;
+        };
+        uLineColor1: {
+            value: Color;
+        };
+        uLineColor2: {
+            value: Color;
+        };
+        uLineColor3: {
+            value: Color;
+        };
+        uLineColor4: {
+            value: Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};
+export declare const ToonShaderDotted: {
+    uniforms: {
+        uDirLightPos: {
+            value: Vector3;
+        };
+        uDirLightColor: {
+            value: Color;
+        };
+        uAmbientLightColor: {
+            value: Color;
+        };
+        uBaseColor: {
+            value: Color;
+        };
+        uLineColor1: {
+            value: Color;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/ToonShader.d.ts

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

package/shaders/TriangleBlurShader.d.cts

@@ -0,0 +1,22 @@
+import type { Vector2 } from 'three';
+/**
+ * Triangle blur shader
+ * based on glfx.js triangle blur shader
+ * https://github.com/evanw/glfx.js
+ *
+ * A basic blur filter, which convolves the image with a
+ * pyramid filter. The pyramid filter is separable and is applied as two
+ * perpendicular triangle filters.
+ */
+export declare const TriangleBlurShader: {
+    uniforms: {
+        texture: {
+            value: null;
+        };
+        delta: {
+            value: Vector2;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/TriangleBlurShader.d.ts

@@ -1,4 +1,4 @@
-import { Vector2 } from 'three';
+import type { Vector2 } from 'three';
 /**
  * Triangle blur shader
  * based on glfx.js triangle blur shader

package/shaders/UnpackDepthRGBAShader.d.cts

@@ -0,0 +1,16 @@
+/**
+ * Unpack RGBA depth shader
+ * - show RGBA encoded depth as monochrome color
+ */
+export declare const UnpackDepthRGBAShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        opacity: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/VerticalBlurShader.d.cts

@@ -0,0 +1,18 @@
+/**
+ * Two pass Gaussian blur filter (horizontal and vertical blur shaders)
+ * - described in http://www.gamerendering.com/2008/10/11/gaussian-blur-filter-shader/
+ *   and used in http://www.cake23.de/traveling-wavefronts-lit-up.html
+ *
+ * - 9 samples per pass
+ * - standard deviation 2.7
+ * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types.d.cts';
+export type VerticalBlurShaderUniforms = {
+    tDiffuse: IUniform<Texture | null>;
+    v: IUniform<number>;
+};
+export interface IVerticalBlurShader extends IShader<VerticalBlurShaderUniforms> {
+}
+export declare const VerticalBlurShader: IVerticalBlurShader;

package/shaders/VerticalBlurShader.d.ts

@@ -8,7 +8,7 @@
  * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
  */
 import type { IUniform, Texture } from 'three';
-import type { IShader } from './types';
+import type { IShader } from './types.d.ts';
 export type VerticalBlurShaderUniforms = {
     tDiffuse: IUniform<Texture | null>;
     v: IUniform<number>;

package/shaders/VerticalTiltShiftShader.d.cts

@@ -0,0 +1,23 @@
+/**
+ * Simple fake tilt-shift effect, modulating two pass Gaussian blur (see above) by vertical position
+ *
+ * - 9 samples per pass
+ * - standard deviation 2.7
+ * - "h" and "v" parameters should be set to "1 / width" and "1 / height"
+ * - "r" parameter control where "focused" horizontal line lies
+ */
+export declare const VerticalTiltShiftShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        v: {
+            value: number;
+        };
+        r: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/VignetteShader.d.cts

@@ -0,0 +1,20 @@
+/**
+ * Vignette 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 VignetteShader: {
+    uniforms: {
+        tDiffuse: {
+            value: null;
+        };
+        offset: {
+            value: number;
+        };
+        darkness: {
+            value: number;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/VolumeShader.d.cts

@@ -0,0 +1,30 @@
+import type { Vector2, Vector3 } from 'three';
+/**
+ * Shaders to render 3D volumes using raycasting.
+ * The applied techniques are based on similar implementations in the Visvis and Vispy projects.
+ * This is not the only approach, therefore it's marked 1.
+ */
+export declare const VolumeRenderShader1: {
+    uniforms: {
+        u_size: {
+            value: Vector3;
+        };
+        u_renderstyle: {
+            value: number;
+        };
+        u_renderthreshold: {
+            value: number;
+        };
+        u_clim: {
+            value: Vector2;
+        };
+        u_data: {
+            value: null;
+        };
+        u_cmdata: {
+            value: null;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/VolumeShader.d.ts

@@ -1,4 +1,4 @@
-import { Vector2, Vector3 } from 'three';
+import type { Vector2, Vector3 } from 'three';
 /**
  * Shaders to render 3D volumes using raycasting.
  * The applied techniques are based on similar implementations in the Visvis and Vispy projects.

package/shaders/WaterRefractionShader.d.cts

@@ -0,0 +1,21 @@
+export declare const WaterRefractionShader: {
+    uniforms: {
+        color: {
+            value: null;
+        };
+        time: {
+            value: number;
+        };
+        tDiffuse: {
+            value: null;
+        };
+        tDudv: {
+            value: null;
+        };
+        textureMatrix: {
+            value: null;
+        };
+    };
+    vertexShader: string;
+    fragmentShader: string;
+};

package/shaders/types.d.cts

@@ -0,0 +1,13 @@
+import type { IUniform } from 'three';
+export type Defines = {
+    [key: string]: boolean | number | string;
+};
+export type Uniforms = {
+    [key: string]: IUniform;
+};
+export interface IShader<U extends Uniforms, D extends Defines | undefined = undefined> {
+    defines?: D;
+    fragmentShader: string;
+    uniforms: U;
+    vertexShader: string;
+}

package/textures/FlakesTexture.d.cts

@@ -0,0 +1,4 @@
+declare class FlakesTexture {
+    constructor(width?: number, height?: number);
+}
+export { type FlakesTexture };

package/textures/FlakesTexture.d.ts

@@ -1,4 +1,4 @@
 declare class FlakesTexture {
     constructor(width?: number, height?: number);
 }
-export { FlakesTexture };
+export { type FlakesTexture };

package/types/helpers.d.cts

@@ -0,0 +1 @@
+export declare const getWithKey: <T, K extends keyof T>(obj: T, key: K) => T[K];

package/types/shared.d.cts

@@ -0,0 +1,9 @@
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
+export type TypedArrayConstructors = Int8Array['constructor'] | Uint8Array['constructor'] | Uint8ClampedArray['constructor'] | Int16Array['constructor'] | Uint16Array['constructor'] | Int32Array['constructor'] | Uint32Array['constructor'] | Float32Array['constructor'] | Float64Array['constructor'];
+type LinearEncoding = 3000;
+type sRGBEncoding = 3001;
+/**
+ * Stub for `TextureEncoding` type since it was removed in r162.
+ */
+export type TextureEncoding = LinearEncoding | sRGBEncoding;
+export {};

package/types/utils.d.cts

@@ -0,0 +1,3 @@
+export type Nullable<T> = {
+    [K in keyof T]: T[K] | null;
+};

package/utils/BufferGeometryUtils.d.cts

@@ -0,0 +1,63 @@
+import type { BufferAttribute, BufferGeometry, Float32BufferAttribute, InterleavedBufferAttribute, Mesh, Line, Points } from 'three';
+/**
+ * @param  {Array<BufferGeometry>} geometries
+ * @param  {Boolean} useGroups
+ * @return {BufferGeometry}
+ */
+export declare const mergeBufferGeometries: (geometries: BufferGeometry[], useGroups?: boolean) => BufferGeometry | null;
+/**
+ * @param {Array<BufferAttribute>} attributes
+ * @return {BufferAttribute}
+ */
+export declare const mergeBufferAttributes: (attributes: BufferAttribute[]) => BufferAttribute | null | undefined;
+/**
+ * @param {Array<BufferAttribute>} attributes
+ * @return {Array<InterleavedBufferAttribute>}
+ */
+export declare const interleaveAttributes: (attributes: BufferAttribute[]) => InterleavedBufferAttribute[] | null;
+/**
+ * @param {Array<BufferGeometry>} geometry
+ * @return {number}
+ */
+export declare function estimateBytesUsed(geometry: BufferGeometry): number;
+/**
+ * @param {BufferGeometry} geometry
+ * @param {number} tolerance
+ * @return {BufferGeometry>}
+ */
+export declare function mergeVertices(geometry: BufferGeometry, tolerance?: number): BufferGeometry;
+/**
+ * @param {BufferGeometry} geometry
+ * @param {number} drawMode
+ * @return {BufferGeometry}
+ */
+export declare function toTrianglesDrawMode(geometry: BufferGeometry, drawMode: number): BufferGeometry;
+/**
+ * Calculates the morphed attributes of a morphed/skinned BufferGeometry.
+ * Helpful for Raytracing or Decals.
+ * @param {Mesh | Line | Points} object An instance of Mesh, Line or Points.
+ * @return {Object} An Object with original position/normal attributes and morphed ones.
+ */
+export type ComputedMorphedAttribute = {
+    positionAttribute: BufferAttribute | InterleavedBufferAttribute;
+    normalAttribute: BufferAttribute | InterleavedBufferAttribute;
+    morphedPositionAttribute: Float32BufferAttribute;
+    morphedNormalAttribute: Float32BufferAttribute;
+};
+export declare function computeMorphedAttributes(object: Mesh | Line | Points): ComputedMorphedAttribute | null;
+/**
+ * Modifies the supplied geometry if it is non-indexed, otherwise creates a new,
+ * non-indexed geometry. Returns the geometry with smooth normals everywhere except
+ * faces that meet at an angle greater than the crease angle.
+ *
+ * Backwards compatible with code such as @react-three/drei's `<RoundedBox>`
+ * which uses this method to operate on the original geometry.
+ *
+ * As of this writing, BufferGeometry.toNonIndexed() warns if the geometry is
+ * non-indexed and returns `this`, i.e. the same geometry on which it was called:
+ * `BufferGeometry is already non-indexed.`
+ *
+ * @param geometry
+ * @param creaseAngle
+ */
+export declare function toCreasedNormals(geometry: BufferGeometry, creaseAngle?: number): BufferGeometry;

package/utils/BufferGeometryUtils.d.ts

@@ -1,4 +1,4 @@
-import { BufferAttribute, BufferGeometry, Float32BufferAttribute, InterleavedBufferAttribute, Mesh, Line, Points } from 'three';
+import type { BufferAttribute, BufferGeometry, Float32BufferAttribute, InterleavedBufferAttribute, Mesh, Line, Points } from 'three';
 /**
  * @param  {Array<BufferGeometry>} geometries
  * @param  {Boolean} useGroups

package/utils/GeometryCompressionUtils.d.cts

@@ -0,0 +1,7 @@
+import type { Mesh } from 'three'
+
+export namespace GeometryCompressionUtils {
+  function compressNormals(mesh: Mesh, encodeMethod: string): void
+  function compressPositions(mesh: Mesh): void
+  function compressUvs(mesh: Mesh): void
+}

package/utils/GeometryCompressionUtils.d.ts

@@ -1,4 +1,4 @@
-import { Mesh } from 'three'
+import type { Mesh } from 'three'
 
 export namespace GeometryCompressionUtils {
   function compressNormals(mesh: Mesh, encodeMethod: string): void

package/utils/GeometryUtils.d.cts

@@ -0,0 +1,6 @@
+import type { Vector3 } from 'three';
+export declare const GeometryUtils: {
+    hilbert3D: (center?: Vector3, size?: number, iterations?: number, v0?: number, v1?: number, v2?: number, v3?: number, v4?: number, v5?: number, v6?: number, v7?: number) => Vector3[];
+    gosper: (size?: number) => number[];
+    hilbert2D: (center?: Vector3, size?: number, iterations?: number, v0?: number, v1?: number, v2?: number, v3?: number) => Vector3[];
+};

package/utils/GeometryUtils.d.ts

@@ -1,4 +1,4 @@
-import { Vector3 } from 'three';
+import type { Vector3 } from 'three';
 export declare const GeometryUtils: {
     hilbert3D: (center?: Vector3, size?: number, iterations?: number, v0?: number, v1?: number, v2?: number, v3?: number, v4?: number, v5?: number, v6?: number, v7?: number) => Vector3[];
     gosper: (size?: number) => number[];

package/utils/LDrawUtils.d.cts

@@ -0,0 +1,5 @@
+import type { Group, Object3D } from 'three'
+
+export namespace LDrawUtils {
+  function mergeObject(object: Object3D): Group
+}

package/utils/LDrawUtils.d.ts

@@ -1,4 +1,4 @@
-import { Group, Object3D } from 'three'
+import type { Group, Object3D } from 'three'
 
 export namespace LDrawUtils {
   function mergeObject(object: Object3D): Group

package/utils/RoughnessMipmapper.d.cts

@@ -0,0 +1,8 @@
+import type { Material, WebGLRenderer } from 'three'
+
+export class RoughnessMipmapper {
+  constructor(renderer: WebGLRenderer)
+
+  generateMipmaps(material: Material): void
+  dispose(): void
+}