@types/three 0.126.1 → 0.128.0

three/examples/jsm/objects/LightningStorm.d.ts

@@ -28,5 +28,5 @@ export class LightningStorm {
     constructor(stormParams?: StormParams);
     update(time: number): void;
     copy(source: LightningStorm): LightningStorm;
-    clone(): LightningStorm;
+    clone(): this;
 }

three/examples/jsm/objects/ReflectorForSSRPass.d.ts

@@ -11,8 +11,8 @@ import {
 
 export interface ReflectorShader {
     defines: {
-        isDistanceAttenuation: boolean;
-        isFresnel: boolean;
+        DISTANCE_ATTENUATION: boolean;
+        FRESNEL: boolean;
     };
     uniforms: {
         [key: string]: IUniform;
@@ -31,7 +31,7 @@ export interface ReflectorOptions {
 }
 
 export class Reflector<TGeometry extends BufferGeometry = BufferGeometry> extends Mesh<TGeometry> {
-    type: 'Reflector';
+    type: 'ReflectorForSSRPass';
     options: ReflectorOptions;
 
     static ReflectorShader: ReflectorShader;
@@ -40,10 +40,10 @@ export class Reflector<TGeometry extends BufferGeometry = BufferGeometry> extend
     maxDistance: number;
     opacity: number;
 
-    get isDistanceAttenuation(): boolean;
-    set isDistanceAttenuation(val: boolean);
-    get isFresnel(): boolean;
-    set isFresnel(val: boolean);
+    get distanceAttenuation(): boolean;
+    set distanceAttenuation(val: boolean);
+    get fresnel(): boolean;
+    set fresnel(val: boolean);
 
     material: ShaderMaterial;
 

three/examples/jsm/postprocessing/SAOPass.d.ts

@@ -28,7 +28,7 @@ export interface SAOPassParams {
     saoScale: number;
     saoKernelRadius: number;
     saoMinResolution: number;
-    saoBlur: number;
+    saoBlur: boolean;
     saoBlurRadius: number;
     saoBlurStdDev: number;
     saoBlurDepthCutoff: number;

three/examples/jsm/postprocessing/SSRPass.d.ts

@@ -39,17 +39,17 @@ export class SSRPass extends Pass {
     opacity: number;
     output: number;
     maxDistance: number;
-    surfDist: number;
+    thickness: number;
     encoding: TextureEncoding;
     tempColor: Color;
 
     get selects(): Mesh[] | null;
     set selects(val: Mesh[] | null);
-    isSelective: boolean;
+    selective: boolean;
     get isBouncing(): boolean;
     set isBouncing(val: boolean);
 
-    isBlur: boolean;
+    blur: boolean;
 
     get isDistanceAttenuation(): boolean;
     set isDistanceAttenuation(val: boolean);

three/examples/jsm/postprocessing/SSRrPass.d.ts

@@ -0,0 +1,138 @@
+import {
+    AddEquation,
+    Color,
+    NormalBlending,
+    DepthTexture,
+    SrcAlphaFactor,
+    OneMinusSrcAlphaFactor,
+    MeshNormalMaterial,
+    MeshBasicMaterial,
+    NearestFilter,
+    NoBlending,
+    RGBAFormat,
+    ShaderMaterial,
+    UniformsUtils,
+    UnsignedShortType,
+    WebGLRenderTarget,
+    HalfFloatType,
+    MeshStandardMaterial,
+    WebGLRenderer,
+    Scene,
+    Camera,
+    Mesh,
+    TextureEncoding,
+    Material,
+} from '../../../src/Three';
+import { Pass } from './Pass';
+import { SSRrShader, SSRrDepthShader } from '../shaders/SSRrShader';
+import { CopyShader } from '../shaders/CopyShader';
+
+export interface SSRrPassParams {
+    renderer: WebGLRenderer;
+    scene: Scene;
+    camera: Camera;
+    width?: number;
+    height?: number;
+    selects: Mesh[] | null;
+    encoding: TextureEncoding;
+    morphTargets?: boolean;
+}
+
+export class SSRrPass extends Pass {
+    width: number;
+    height: number;
+    clear: boolean;
+
+    renderer: WebGLRenderer;
+    scene: Scene;
+    camera: Camera;
+
+    output: number;
+
+    ior: number;
+    maxDistance: number;
+    surfDist: number;
+
+    encoding: TextureEncoding;
+
+    color: Color;
+
+    seleects: Mesh[] | null;
+
+    _specular: boolean;
+    get specular(): boolean;
+    set specular(spec: boolean);
+
+    _fillHole: boolean;
+    get fillHole(): boolean;
+    set fillHole(spec: boolean);
+
+    _infiniteThick: boolean;
+    get infiniteThick(): boolean;
+    set infiniteThick(spec: boolean);
+
+    beautyRenderTarget: WebGLRenderTarget;
+    specularRenderTarget: WebGLRenderTarget;
+    normalSelectsRenderTarget: WebGLRenderTarget;
+    refractiveRenderTarget: WebGLRenderTarget;
+    ssrrRenderTarget: WebGLRenderTarget;
+
+    ssrrMaterial: ShaderMaterial;
+
+    normalMaterial: MeshNormalMaterial;
+    refractiveOnMaterial: MeshBasicMaterial;
+    refractiveOffMaterial: MeshBasicMaterial;
+    specularMaterial: MeshStandardMaterial;
+
+    depthRenderMaterial: ShaderMaterial;
+    copyMaterial: ShaderMaterial;
+
+    fsQuad: Pass.FullScreenQuad;
+
+    originalClearColor: Color;
+
+    constructor(params: SSRrPassParams);
+
+    dispose: () => void;
+
+    render: (renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget) => 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;
+
+    renderRefractive: (
+        renderer: WebGLRenderer,
+        passMaterial: Material,
+        renderTarget: WebGLRenderTarget,
+        clearColor: Color | string | number,
+        clearAlpha: Color | string | number,
+    ) => void;
+
+    setSize: (width: number, height: number) => void;
+}
+
+export namespace SSRrPass {
+    interface OUTPUT {
+        Default: 0;
+        SSRr: 1;
+        Beauty: 3;
+        Depth: 4;
+        DepthSelects: 9;
+        NormalSelects: 5;
+        Refractive: 7;
+        Specular: 8;
+    }
+}

three/examples/jsm/shaders/SSRShader.d.ts

@@ -27,8 +27,7 @@ export interface SSRShader {
         opacity: IUniform<number>;
         maxDistance: IUniform<number>;
         cameraRange: IUniform<number>;
-        surfDist: IUniform<number>;
-        thickTolerance: IUniform<number>;
+        thickness: IUniform<number>;
     };
     vertexShader: string;
     fragmentShader: string;