three-stdlib 2.35.7 → 2.35.9

package/postprocessing/SSAOPass.d.cts

@@ -0,0 +1,70 @@
+import type {
+  Camera,
+  Color,
+  DataTexture,
+  Material,
+  MeshNormalMaterial,
+  Scene,
+  ShaderMaterial,
+  Vector3,
+  WebGLRenderer,
+  WebGLRenderTarget,
+} from 'three'
+
+import type { Pass, FullScreenQuad } from './Pass.d.cts'
+
+export enum SSAOPassOUTPUT {
+  Default,
+  SSAO,
+  Blur,
+  Beauty,
+  Depth,
+  Normal,
+}
+
+export class SSAOPass extends Pass {
+  constructor(scene: Scene, camera: Camera, width?: number, height?: number)
+  scene: Scene
+  camera: Camera
+  width: number
+  height: boolean
+  clear: boolean
+  kernelRadius: number
+  kernelSize: number
+  kernel: Vector3[]
+  noiseTexture: DataTexture
+  output: SSAOPassOUTPUT
+  minDistance: number
+  maxDistance: number
+  beautyRenderTarget: WebGLRenderTarget
+  normalRenderTarget: WebGLRenderTarget
+  ssaoRenderTarget: WebGLRenderTarget
+  blurRenderTarget: WebGLRenderTarget
+  ssaoMaterial: ShaderMaterial
+  normalMaterial: MeshNormalMaterial
+  blurMaterial: ShaderMaterial
+  depthRenderMaterial: ShaderMaterial
+  copyMaterial: ShaderMaterial
+  fsQuad: FullScreenQuad
+  originalClearColor: Color
+
+  static OUTPUT: SSAOPassOUTPUT
+
+  dipose(): void
+  generateSampleKernel(): Vector3[]
+  generateRandomKernelRotations(): void
+  renderPass(
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor?: Color | string | number,
+    clearAlpha?: number,
+  ): void
+  renderOverride(
+    renderer: WebGLRenderer,
+    overrideMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor?: Color | string | number,
+    clearAlpha?: number,
+  ): void
+}

package/postprocessing/SSAOPass.d.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   Camera,
   Color,
   DataTexture,
@@ -11,7 +11,7 @@ import {
   WebGLRenderTarget,
 } from 'three'
 
-import { Pass, FullScreenQuad } from './Pass'
+import type { Pass, FullScreenQuad } from './Pass.d.ts'
 
 export enum SSAOPassOUTPUT {
   Default,

package/postprocessing/SSRPass.d.cts

@@ -0,0 +1,123 @@
+import type {
+  Color,
+  MeshNormalMaterial,
+  MeshBasicMaterial,
+  ShaderMaterial,
+  WebGLRenderTarget,
+  Scene,
+  WebGLRenderer,
+  Camera,
+  Mesh,
+  Material,
+} from 'three'
+import type { Pass, FullScreenQuad } from '../postprocessing/Pass.d.cts'
+import type { ReflectorForSSRPass } from '../objects/ReflectorForSSRPass.d.cts'
+
+export interface SSRPassParams {
+  renderer: WebGLRenderer
+  scene: Scene
+  camera: Camera
+  width?: number | undefined
+  height?: number | undefined
+  selects: Mesh[] | null
+  isPerspectiveCamera?: boolean | undefined
+  isBouncing?: boolean | undefined
+  groundReflector: ReflectorForSSRPass | null
+}
+
+export class SSRPass extends Pass {
+  width: number
+  height: number
+  clear: boolean
+  renderer: WebGLRenderer
+  scene: Scene
+  camera: Camera
+  groundReflector: ReflectorForSSRPass | null
+  opacity: number
+  output: number
+  maxDistance: number
+  thickness: number
+  tempColor: Color
+
+  get selects(): Mesh[] | null
+  set selects(val: Mesh[] | null)
+  selective: boolean
+  get isBouncing(): boolean
+  set isBouncing(val: boolean)
+
+  blur: boolean
+
+  get isDistanceAttenuation(): boolean
+  set isDistanceAttenuation(val: boolean)
+  get isFresnel(): boolean
+  set isFresnel(val: boolean)
+  get isInfiniteThick(): boolean
+  set isInfiniteThick(val: boolean)
+
+  thickTolerance: number
+
+  beautyRenderTarget: WebGLRenderTarget
+  prevRenderTarget: WebGLRenderTarget
+  normalRenderTarget: WebGLRenderTarget
+  metalnessRenderTarget: WebGLRenderTarget
+  ssrRenderTarget: WebGLRenderTarget
+
+  blurRenderTarget: WebGLRenderTarget
+  blurRenderTarget2: WebGLRenderTarget
+
+  ssrMaterial: ShaderMaterial
+
+  normalMaterial: MeshNormalMaterial
+
+  metalnessOnMaterial: MeshBasicMaterial
+
+  metalnessOffMaterial: MeshBasicMaterial
+
+  blurMaterial: ShaderMaterial
+  blurMaterial2: ShaderMaterial
+
+  depthRenderMaterial: ShaderMaterial
+
+  copyMaterial: ShaderMaterial
+
+  fsQuad: FullScreenQuad
+
+  originalClearColor: Color
+
+  static OUTPUT: {
+    Default: 0
+    SSR: 1
+    Beauty: 3
+    Depth: 4
+    Normal: 5
+    Metalness: 7
+  }
+
+  constructor(params: SSRPassParams)
+
+  dispose: () => void
+
+  renderPass: (
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor: Color | string | number,
+    clearAlpha: Color | string | number,
+  ) => void
+
+  renderOverride: (
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor: Color | string | number,
+    clearAlpha: Color | string | number,
+  ) => void
+
+  renderMetalness: (
+    renderer: WebGLRenderer,
+    passMaterial: Material,
+    renderTarget: WebGLRenderTarget,
+    clearColor: Color | string | number,
+    clearAlpha: Color | string | number,
+  ) => void
+}

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 type declare const ACESFilmicToneMappingShader: IACESFilmicToneMappingShader;

package/shaders/ACESFilmicToneMappingShader.d.ts

@@ -6,11 +6,11 @@
  * 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>;
 };
 export interface IACESFilmicToneMappingShader extends IShader<ACESFilmicToneMappingShaderUniforms> {
 }
-export declare const ACESFilmicToneMappingShader: IACESFilmicToneMappingShader;
+export type declare const ACESFilmicToneMappingShader: IACESFilmicToneMappingShader;

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 type 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>;
@@ -12,4 +12,4 @@ export type AfterimageShaderUniforms = {
 };
 export interface IAfterimageShader extends IShader<AfterimageShaderUniforms> {
 }
-export declare const AfterimageShader: IAfterimageShader;
+export type declare const AfterimageShader: IAfterimageShader;

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 type declare const BasicShader: IBasicShader;

package/shaders/BasicShader.d.ts

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