three-stdlib 2.35.7 → 2.35.8

package/postprocessing/SSRPass.d.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   Color,
   MeshNormalMaterial,
   MeshBasicMaterial,
@@ -10,8 +10,8 @@ import {
   Mesh,
   Material,
 } from 'three'
-import { Pass, FullScreenQuad } from '../postprocessing/Pass'
-import { ReflectorForSSRPass } from '../objects/ReflectorForSSRPass'
+import type { Pass, FullScreenQuad } from '../postprocessing/Pass.d.ts'
+import type { ReflectorForSSRPass } from '../objects/ReflectorForSSRPass.d.ts'
 
 export interface SSRPassParams {
   renderer: WebGLRenderer

package/postprocessing/SavePass.d.cts

@@ -0,0 +1,12 @@
+import type { ShaderMaterial, WebGLRenderTarget } from 'three'
+
+import type { Pass } from './Pass.d.cts'
+
+export class SavePass extends Pass {
+  constructor(renderTarget: WebGLRenderTarget)
+  textureID: string
+  renderTarget: WebGLRenderTarget
+  uniforms: object
+  material: ShaderMaterial
+  fsQuad: object
+}

package/postprocessing/SavePass.d.ts

@@ -1,6 +1,6 @@
-import { ShaderMaterial, WebGLRenderTarget } from 'three'
+import type { ShaderMaterial, WebGLRenderTarget } from 'three'
 
-import { Pass } from './Pass'
+import type { Pass } from './Pass.d.ts'
 
 export class SavePass extends Pass {
   constructor(renderTarget: WebGLRenderTarget)

package/postprocessing/ShaderPass.d.cts

@@ -0,0 +1,13 @@
+import type { ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Pass, FullScreenQuad } from './Pass.d.cts';
+import type { Defines, IShader, Uniforms } from '../shaders/types.d.cts';
+declare class ShaderPass extends Pass {
+    textureID: string;
+    uniforms: Uniforms;
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+    constructor(shader: ShaderMaterial | IShader<Uniforms, Defines | undefined>, textureID?: string);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+    dispose(): void;
+}
+export { type ShaderPass };

package/postprocessing/ShaderPass.d.ts

@@ -1,6 +1,6 @@
-import { ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
-import { Pass, FullScreenQuad } from './Pass';
-import { Defines, IShader, Uniforms } from '../shaders/types';
+import type { ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+import type { Pass, FullScreenQuad } from './Pass.d.ts';
+import type { Defines, IShader, Uniforms } from '../shaders/types.d.ts';
 declare class ShaderPass extends Pass {
     textureID: string;
     uniforms: Uniforms;
@@ -10,4 +10,4 @@ declare class ShaderPass extends Pass {
     render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
     dispose(): void;
 }
-export { ShaderPass };
+export { type ShaderPass };

package/postprocessing/TAARenderPass.d.cts

@@ -0,0 +1,8 @@
+import type { Scene, Camera, Color } from 'three'
+
+import type { SSAARenderPass } from './SSAARenderPass.d.cts'
+
+export class TAARenderPass extends SSAARenderPass {
+  constructor(scene: Scene, camera: Camera, clearColor: Color | string | number, clearAlpha: number)
+  accumulate: boolean
+}

package/postprocessing/TAARenderPass.d.ts

@@ -1,6 +1,6 @@
-import { Scene, Camera, Color } from 'three'
+import type { Scene, Camera, Color } from 'three'
 
-import { SSAARenderPass } from './SSAARenderPass'
+import type { SSAARenderPass } from './SSAARenderPass.d.ts'
 
 export class TAARenderPass extends SSAARenderPass {
   constructor(scene: Scene, camera: Camera, clearColor: Color | string | number, clearAlpha: number)

package/postprocessing/TexturePass.d.cts

@@ -0,0 +1,12 @@
+import type { Texture, ShaderMaterial } from 'three'
+
+import type { Pass, FullScreenQuad } from './Pass.d.cts'
+
+export class TexturePass extends Pass {
+  constructor(map: Texture, opacity?: number)
+  map: Texture
+  opacity: number
+  uniforms: object
+  material: ShaderMaterial
+  fsQuad: FullScreenQuad
+}

package/postprocessing/TexturePass.d.ts

@@ -1,6 +1,6 @@
-import { Texture, ShaderMaterial } from 'three'
+import type { Texture, ShaderMaterial } from 'three'
 
-import { Pass, FullScreenQuad } from './Pass'
+import type { Pass, FullScreenQuad } from './Pass.d.ts'
 
 export class TexturePass extends Pass {
   constructor(map: Texture, opacity?: number)

package/postprocessing/UnrealBloomPass.d.cts

@@ -0,0 +1,31 @@
+import type { Color, MeshBasicMaterial, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget } from 'three'
+
+import type { Pass } from './Pass.d.cts'
+
+export class UnrealBloomPass extends Pass {
+  constructor(resolution: Vector2, strength: number, radius: number, threshold: number)
+  resolution: Vector2
+  strength: number
+  radius: number
+  threshold: number
+  clearColor: Color
+  renderTargetsHorizontal: WebGLRenderTarget[]
+  renderTargetsVertical: WebGLRenderTarget[]
+  nMips: number
+  renderTargetBright: WebGLRenderTarget
+  highPassUniforms: object
+  materialHighPassFilter: ShaderMaterial
+  separableBlurMaterials: ShaderMaterial[]
+  compositeMaterial: ShaderMaterial
+  bloomTintColors: Vector3[]
+  copyUniforms: object
+  materialCopy: ShaderMaterial
+  oldClearColor: Color
+  oldClearAlpha: number
+  basic: MeshBasicMaterial
+  fsQuad: object
+
+  dispose(): void
+  getSeperableBlurMaterial(): ShaderMaterial
+  getCompositeMaterial(): ShaderMaterial
+}

package/postprocessing/UnrealBloomPass.d.ts

@@ -1,6 +1,6 @@
-import { Color, MeshBasicMaterial, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget } from 'three'
+import type { Color, MeshBasicMaterial, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget } from 'three'
 
-import { Pass } from './Pass'
+import type { Pass } from './Pass.d.ts'
 
 export class UnrealBloomPass extends Pass {
   constructor(resolution: Vector2, strength: number, radius: number, threshold: number)

package/postprocessing/WaterPass.d.cts

@@ -0,0 +1,35 @@
+import type { WebGLRenderer, WebGLRenderTarget, ShaderMaterial, Vector2, IUniform, Texture } from 'three';
+import type { Pass, FullScreenQuad } from '../postprocessing/Pass.d.cts';
+/**
+ * Simple underwater shader
+ *
+ 
+ parameters:
+ tex: texture
+ time: this should increase with time passing
+ factor: to what degree will the shader distort the screen
+
+ explaination:
+ the shader is quite simple
+ it chooses a center and start from there make pixels around it to "swell" then "shrink" then "swell"...
+ this is of course nothing really similar to underwater scene
+ but you can combine several this shaders together to create the effect you need...
+ And yes, this shader could be used for something other than underwater effect, for example, magnifier effect :)
+
+ * @author vergil Wang
+ */
+declare class WaterPass extends Pass {
+    material: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+    factor: number;
+    time: number;
+    uniforms: {
+        tex: IUniform<Texture>;
+        time: IUniform<number>;
+        factor: IUniform<number>;
+        resolution: IUniform<Vector2>;
+    };
+    constructor();
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+}
+export { type WaterPass };

package/postprocessing/WaterPass.d.ts

@@ -1,5 +1,5 @@
-import { WebGLRenderer, WebGLRenderTarget, ShaderMaterial, Vector2, IUniform, Texture } from 'three';
-import { Pass, FullScreenQuad } from '../postprocessing/Pass';
+import type { WebGLRenderer, WebGLRenderTarget, ShaderMaterial, Vector2, IUniform, Texture } from 'three';
+import type { Pass, FullScreenQuad } from '../postprocessing/Pass.d.ts';
 /**
  * Simple underwater shader
  *
@@ -32,4 +32,4 @@ declare class WaterPass extends Pass {
     constructor();
     render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
 }
-export { WaterPass };
+export { type WaterPass };

package/renderers/CSS2DRenderer.d.cts

@@ -0,0 +1,23 @@
+import type { Object3D, Scene, Camera, Vector2 } from 'three'
+
+export class CSS2DObject extends Object3D {
+  constructor(element: HTMLElement)
+  element: HTMLElement
+  center: Vector2
+
+  onBeforeRender: (renderer: unknown, scene: Scene, camera: Camera) => void
+  onAfterRender: (renderer: unknown, scene: Scene, camera: Camera) => void
+}
+
+export type CSS2DParameters = {
+  element?: HTMLElement
+}
+
+export class CSS2DRenderer {
+  constructor(parameters?: CSS2DParameters)
+  domElement: HTMLElement
+
+  getSize(): { width: number; height: number }
+  setSize(width: number, height: number): void
+  render(scene: Scene, camera: Camera): void
+}

package/renderers/CSS2DRenderer.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Scene, Camera, Vector2 } from 'three'
+import type { Object3D, Scene, Camera, Vector2 } from 'three'
 
 export class CSS2DObject extends Object3D {
   constructor(element: HTMLElement)

package/renderers/CSS3DRenderer.d.cts

@@ -0,0 +1,26 @@
+import type { Object3D, Scene, Camera } from 'three'
+
+export class CSS3DObject extends Object3D {
+  constructor(element: HTMLElement)
+  element: HTMLElement
+
+  onBeforeRender: (renderer: unknown, scene: Scene, camera: Camera) => void
+  onAfterRender: (renderer: unknown, scene: Scene, camera: Camera) => void
+}
+
+export class CSS3DSprite extends CSS3DObject {
+  constructor(element: HTMLElement)
+}
+
+export interface CSS3DParameters {
+  element?: HTMLElement
+}
+
+export class CSS3DRenderer {
+  constructor(parameters?: CSS3DParameters)
+  domElement: HTMLElement
+
+  getSize(): { width: number; height: number }
+  setSize(width: number, height: number): void
+  render(scene: Scene, camera: Camera): void
+}

package/renderers/CSS3DRenderer.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Scene, Camera } from 'three'
+import type { Object3D, Scene, Camera } from 'three'
 
 export class CSS3DObject extends Object3D {
   constructor(element: HTMLElement)

package/renderers/Projector.d.cts

@@ -0,0 +1,60 @@
+import type { Object3D, Scene, Camera, Vector2, Vector3, Vector4, Color, Material } from 'three'
+
+export class RenderableObject {
+  id: number
+  object: Object3D
+  z: number
+  renderOrder: number
+}
+
+export class RenderableFace {
+  id: number
+  v1: RenderableVertex
+  v2: RenderableVertex
+  v3: RenderableVertex
+  normalModel: Vector3
+  vertexNormalsModel: Vector3[]
+  vertexNormalsLength: number
+  color: Color
+  material: Material
+  uvs: Vector2[]
+  z: number
+  renderOrder: number
+}
+
+export class RenderableVertex {
+  position: Vector3
+  positionWorld: Vector3
+  positionScreen: Vector4
+  visible: boolean
+
+  copy(vertex: RenderableVertex): void
+}
+
+export class RenderableLine {
+  id: number
+  v1: RenderableVertex
+  v2: RenderableVertex
+  vertexColors: Color[]
+  material: Material
+  z: number
+  renderOrder: number
+}
+
+export class RenderableSprite {
+  id: number
+  object: Object3D
+  x: number
+  y: number
+  z: number
+  rotation: number
+  scale: Vector2
+  material: Material
+  renderOrder: number
+}
+
+export class Projector {
+  constructor()
+
+  projectScene(scene: Scene, camera: Camera, sortObjects: boolean, sortElements: boolean): any
+}

package/renderers/Projector.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Scene, Camera, Vector2, Vector3, Vector4, Color, Material } from 'three'
+import type { Object3D, Scene, Camera, Vector2, Vector3, Vector4, Color, Material } from 'three'
 
 export class RenderableObject {
   id: number

package/renderers/SVGRenderer.d.cts

@@ -0,0 +1,25 @@
+import type { Object3D, Color, Scene, Camera } from 'three'
+
+export class SVGObject extends Object3D {
+  constructor(node: SVGElement)
+  node: SVGElement
+}
+
+export class SVGRenderer {
+  constructor()
+  domElement: SVGElement
+  autoClear: boolean
+  sortObjects: boolean
+  sortElements: boolean
+  overdraw: number
+  info: { render: { vertices: number; faces: number } }
+
+  getSize(): { width: number; height: number }
+  setQuality(quality: string): void
+  setClearColor(color: Color, alpha: number): void
+  setPixelRatio(): void
+  setSize(width: number, height: number): void
+  setPrecision(precision: number): void
+  clear(): void
+  render(scene: Scene, camera: Camera): void
+}

package/renderers/SVGRenderer.d.ts

@@ -1,4 +1,4 @@
-import { Object3D, Color, Scene, Camera } from 'three'
+import type { Object3D, Color, Scene, Camera } from 'three'
 
 export class SVGObject extends Object3D {
   constructor(node: SVGElement)

package/shaders/ACESFilmicToneMappingShader.d.cts

@@ -0,0 +1,16 @@
+/**
+ * ACES Filmic Tone Mapping Shader by Stephen Hill
+ * source: https://github.com/selfshadow/ltc_code/blob/master/webgl/shaders/ltc/ltc_blit.fs
+ *
+ * this implementation of ACES is modified to accommodate a brighter viewing environment.
+ * the scale factor of 1/0.6 is subjective. see discussion in #19621.
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types.d.cts';
+export type ACESFilmicToneMappingShaderUniforms = {
+    exposure: IUniform<number>;
+    tDiffuse: IUniform<Texture | null>;
+};
+export interface IACESFilmicToneMappingShader extends IShader<ACESFilmicToneMappingShaderUniforms> {
+}
+export declare const ACESFilmicToneMappingShader: IACESFilmicToneMappingShader;

package/shaders/ACESFilmicToneMappingShader.d.ts

@@ -6,7 +6,7 @@
  * the scale factor of 1/0.6 is subjective. see discussion in #19621.
  */
 import type { IUniform, Texture } from 'three';
-import type { IShader } from './types';
+import type { IShader } from './types.d.ts';
 export type ACESFilmicToneMappingShaderUniforms = {
     exposure: IUniform<number>;
     tDiffuse: IUniform<Texture | null>;

package/shaders/AfterimageShader.d.cts

@@ -0,0 +1,15 @@
+/**
+ * Afterimage shader
+ * I created this effect inspired by a demo on codepen:
+ * https://codepen.io/brunoimbrizi/pen/MoRJaN?page=1&
+ */
+import type { IUniform, Texture } from 'three';
+import type { IShader } from './types.d.cts';
+export type AfterimageShaderUniforms = {
+    damp: IUniform<number>;
+    tNew: IUniform<Texture | null>;
+    tOld: IUniform<Texture | null>;
+};
+export interface IAfterimageShader extends IShader<AfterimageShaderUniforms> {
+}
+export declare const AfterimageShader: IAfterimageShader;

package/shaders/AfterimageShader.d.ts

@@ -4,7 +4,7 @@
  * https://codepen.io/brunoimbrizi/pen/MoRJaN?page=1&
  */
 import type { IUniform, Texture } from 'three';
-import type { IShader } from './types';
+import type { IShader } from './types.d.ts';
 export type AfterimageShaderUniforms = {
     damp: IUniform<number>;
     tNew: IUniform<Texture | null>;

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;
+};