@types/three 0.143.2 → 0.144.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Mon, 29 Aug 2022 17:32:33 GMT
+ * Last updated: Fri, 02 Sep 2022 10:02:40 GMT
  * Dependencies: [@types/webxr](https://npmjs.com/package/@types/webxr)
  * Global values: `THREE`
 

three/examples/jsm/controls/FirstPersonControls.d.ts

@@ -22,7 +22,10 @@ export class FirstPersonControls {
     mouseDragOn: boolean;
 
     handleResize(): void;
-    lookAt(x: number | Vector3, y: number, z: number): this;
+
+    lookAt(x: Vector3): this;
+    lookAt(x: number, y: number, z: number): this;
+
     update(delta: number): this;
     dispose(): void;
 }

three/examples/jsm/csm/CSM.d.ts

@@ -58,4 +58,4 @@ export class CSM {
     dispose(): void;
 }
 
-import CSMFrustrum from './CSMFrustum.js';
+import CSMFrustrum from './CSMFrustum';

three/examples/jsm/environments/RoomEnvironment.d.ts

@@ -2,4 +2,5 @@ import { Scene } from '../../../src/Three';
 
 export class RoomEnvironment extends Scene {
     constructor();
+    dispose(): void;
 }

three/examples/jsm/interactive/SelectionHelper.d.ts

@@ -1,9 +1,7 @@
 import { WebGLRenderer, Vector2 } from '../../../src/Three';
 
-import { SelectionBox } from './SelectionBox';
-
 export class SelectionHelper {
-    constructor(selectionBox: SelectionBox, renderer: WebGLRenderer, cssClassName: string);
+    constructor(renderer: WebGLRenderer, cssClassName: string);
     element: HTMLElement;
     isDown: boolean;
     pointBottomRight: Vector2;

three/examples/jsm/libs/stats.module.d.ts

@@ -4,7 +4,7 @@ interface Stats {
     addPanel(panel: Stats.Panel): Stats.Panel;
     showPanel(id: number): void;
     begin(): void;
-    end(): void;
+    end(): number;
     update(): void;
     domElement: HTMLDivElement;
     setMode(id: number): void;

three/examples/jsm/loaders/TIFFLoader.d.ts

@@ -0,0 +1,16 @@
+import { DataTextureLoader, TextureFilter, LoadingManager } from 'three';
+
+export interface TIFFResult {
+    width: number;
+    height: number;
+    data: Uint8Array;
+    flipY: true;
+    magFilter: TextureFilter;
+    minFilter: TextureFilter;
+}
+
+export class TIFFLoader extends DataTextureLoader {
+    constructor(manager?: LoadingManager);
+
+    parse(buffer: Iterable<number>): TIFFResult;
+}

three/examples/jsm/materials/MeshGouraudMaterial.d.ts

@@ -0,0 +1,17 @@
+/**
+ * MeshGouraudMaterial
+ *
+ * Lambert illumination model with Gouraud (per-vertex) shading
+ *
+ */
+
+import { ShaderMaterial, ShaderMaterialParameters } from '../../../src/Three';
+
+export class MeshGouraudMaterial extends ShaderMaterial {
+    isMeshGouraudMaterial: true;
+    type: 'MeshGouraudMaterial';
+
+    constructor(parameters?: ShaderMaterialParameters);
+
+    copy(source: MeshGouraudMaterial): this;
+}

three/examples/jsm/math/ColorConverter.d.ts

@@ -16,6 +16,4 @@ export interface CMYK {
 export namespace ColorConverter {
     function setHSV(color: Color, h: number, s: number, v: number): Color;
     function getHSV(color: Color, target: HSL): HSL;
-    function setCMYK(color: Color, c: number, m: number, y: number, k: number): Color;
-    function getCMYK(color: Color, target: CMYK): CMYK;
 }

three/examples/jsm/misc/GPUComputationRenderer.d.ts

@@ -49,4 +49,5 @@ export class GPUComputationRenderer {
     createTexture(): DataTexture;
     renderTexture(input: Texture, output: Texture): void;
     doRenderTarget(material: Material, output: WebGLRenderTarget): void;
+    dispose(): void;
 }

three/examples/jsm/misc/ProgressiveLightMap.d.ts

@@ -5,7 +5,6 @@ import {
     MeshBasicMaterial,
     MeshPhongMaterial,
     Object3D,
-    PlaneBufferGeometry,
     PlaneGeometry,
     Texture,
     Vector3,
@@ -43,7 +42,7 @@ export class ProgressiveLightMap {
 
     uv_boxes: UVBoxes[];
 
-    blurringPlane: Mesh<PlaneBufferGeometry, MeshBasicMaterial>;
+    blurringPlane: Mesh<PlaneGeometry, MeshBasicMaterial>;
 
     labelMaterial: MeshBasicMaterial;
     labelPlane: PlaneGeometry;

three/examples/jsm/misc/Volume.d.ts

@@ -1,6 +1,6 @@
 import { Matrix3 } from '../../../src/Three';
 
-import { VolumeSlice } from './VolumeSlice.js';
+import { VolumeSlice } from './VolumeSlice';
 
 export class Volume {
     constructor(xLength?: number, yLength?: number, zLength?: number, type?: string, arrayBuffer?: ArrayLike<number>);

three/examples/jsm/modifiers/CurveModifier.d.ts

@@ -1,7 +1,7 @@
 import {
     DataTexture,
     Curve,
-    Uniform,
+    IUniform,
     Material,
     InstancedMesh,
     BufferGeometry,
@@ -10,11 +10,11 @@ import {
 } from '../../../src/Three';
 
 export interface SplineUniform {
-    spineTexture: Uniform;
-    pathOffset: Uniform;
-    pathSegment: Uniform;
-    spineOffset: Uniform;
-    flow: Uniform;
+    spineTexture: IUniform;
+    pathOffset: IUniform;
+    pathSegment: IUniform;
+    spineOffset: IUniform;
+    flow: IUniform;
 }
 export function initSplineTexture(size?: number): DataTexture;
 

three/examples/jsm/nodes/Nodes.d.ts

@@ -7,7 +7,7 @@ import ConstNode from './core/ConstNode';
 import ContextNode from './core/ContextNode';
 import ExpressionNode from './core/ExpressionNode';
 import FunctionCallNode from './core/FunctionCallNode';
-import FunctionNode from './core/FunctionNode';
+import FunctionNode, { FunctionNodeArguments } from './core/FunctionNode';
 import InstanceIndexNode from './core/InstanceIndexNode';
 import Node from './core/Node';
 import NodeAttribute from './core/NodeAttribute';
@@ -118,6 +118,7 @@ export {
     ExpressionNode,
     FunctionCallNode,
     FunctionNode,
+    FunctionNodeArguments,
     InstanceIndexNode,
     Node,
     NodeAttribute,

three/examples/jsm/nodes/core/CodeNode.d.ts

@@ -3,13 +3,13 @@ import Node from './Node';
 import NodeBuilder from './NodeBuilder';
 
 export interface CodeNodeInclude {
-    build(): void;
+    build(builder: NodeBuilder): void;
 }
 
 export default class CodeNode extends Node {
     isCodeNode: true;
     code: string;
-    constructor(code: string, nodeType?: NodeTypeOption);
+    constructor(code?: string, includes?: CodeNodeInclude[]);
 
     setIncludes(includes: CodeNodeInclude[]): this;
     getIncludes(builder: NodeBuilder): CodeNodeInclude[];

three/examples/jsm/nodes/core/FunctionCallNode.d.ts

@@ -2,12 +2,12 @@ import FunctionNode from './FunctionNode';
 import TempNode from './TempNode';
 import Node from './Node';
 
-export default class FunctionCallNode extends TempNode {
-    functionNode: FunctionNode;
+export default class FunctionCallNode<P extends Node[] | { [name: string]: Node }> extends TempNode {
+    functionNode: FunctionNode<P>;
     parameters: { [name: string]: Node };
 
-    constructor(functionNode?: FunctionNode, parameters?: { [name: string]: Node });
+    constructor(functionNode?: FunctionNode<P>, parameters?: P);
 
-    setParameters(parameters: { [name: string]: Node }): this;
-    getParameters(): { [name: string]: Node };
+    setParameters(parameters: P): this;
+    getParameters(): P;
 }

three/examples/jsm/nodes/core/FunctionNode.d.ts

@@ -1,15 +1,17 @@
-import CodeNode from './CodeNode';
+import CodeNode, { CodeNodeInclude } from './CodeNode';
 import FunctionCallNode from './FunctionCallNode';
 import NodeBuilder from './NodeBuilder';
 import NodeFunction from './NodeFunction';
 import NodeFunctionInput from './NodeFunctionInput';
 import Node from './Node';
 
-export default class FunctionNode extends CodeNode {
+export type FunctionNodeArguments = Node[] | { [name: string]: Node };
+
+export default class FunctionNode<P extends Node[] | { [name: string]: Node }> extends CodeNode {
     keywords: { [key: string]: Node };
-    constructor(code?: string);
+    constructor(code?: string, includes?: CodeNodeInclude[]);
 
     getInputs(builder: NodeBuilder): NodeFunctionInput[];
     getNodeFunction(builder: NodeBuilder): NodeFunction;
-    call(parameters: { [name: string]: Node }): FunctionCallNode;
+    call(parameters: P): FunctionCallNode<P>;
 }

three/examples/jsm/nodes/core/Node.d.ts

@@ -27,4 +27,5 @@ export default abstract class Node {
     serialize(json: AnyJson): void;
     deserialize(json: AnyJson): void;
     toJSON(meta?: string | { textures: {}; images: {}; nodes: {} }): AnyJson;
+    getCacheKey(): string;
 }

three/examples/jsm/nodes/core/NodeUtils.d.ts

@@ -4,3 +4,4 @@ import Node from './Node';
 export function getNodesKeys(object: Node): string[];
 export function getValueType(value: NodeValueOption): string | null;
 export function getValueFromType(type: string, ...params: number[]): NodeValueOption | null;
+export function getCacheKey(object: Node): string;

three/examples/jsm/nodes/materials/Materials.d.ts

@@ -1,14 +1,16 @@
-import NodeMaterial from '../materials/NodeMaterial';
-import LineBasicNodeMaterial from '../materials/LineBasicNodeMaterial';
-import MeshBasicNodeMaterial from '../materials/MeshBasicNodeMaterial';
-import MeshStandardNodeMaterial from '../materials/MeshStandardNodeMaterial';
-import PointsNodeMaterial from '../materials/PointsNodeMaterial';
-import SpriteNodeMaterial from '../materials/SpriteNodeMaterial';
+import NodeMaterial from './NodeMaterial';
+import LineBasicNodeMaterial from './LineBasicNodeMaterial';
+import MeshBasicNodeMaterial from './MeshBasicNodeMaterial';
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial';
+import PointsNodeMaterial from './PointsNodeMaterial';
+import SpriteNodeMaterial from './SpriteNodeMaterial';
+import MeshPhysicalNodeMaterial from './MeshPhysicalNodeMaterial';
 
 export {
     NodeMaterial,
     LineBasicNodeMaterial,
     MeshBasicNodeMaterial,
+    MeshPhysicalNodeMaterial,
     MeshStandardNodeMaterial,
     PointsNodeMaterial,
     SpriteNodeMaterial,

three/examples/jsm/nodes/materials/MeshPhysicalNodeMaterial.d.ts

@@ -0,0 +1,22 @@
+import { ShaderMaterialParameters } from '../../../../src/Three';
+import { Swizzable, CheckerNode, Node } from '../Nodes';
+
+import MeshStandardNodeMaterial from './MeshStandardNodeMaterial';
+
+export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
+    iridescenceNode: null | Swizzable<CheckerNode>;
+    iridescenceIORNode: null | Swizzable;
+    iridescenceThicknessNode: null | Swizzable;
+
+    specularIntensityNode: Node | null;
+    specularColorNode: Node | null;
+
+    transmissionNode: Node | null;
+    thicknessNode: Node | null;
+    attenuationDistanceNode: Node | null;
+    attenuationColorNode: Node | null;
+
+    constructor(parameters: ShaderMaterialParameters);
+
+    copy(source: MeshPhysicalNodeMaterial): this;
+}

three/examples/jsm/nodes/materialx/functions/lib/mx_hsv.d.ts

@@ -0,0 +1,4 @@
+import { Fn, Node, Swizzable } from '../../../Nodes';
+
+export function mx_hsvtorgb(...params: Fn<[Node]>): Swizzable;
+export function mx_rgbtohsv(...params: Fn<[Node]>): Swizzable;

three/examples/jsm/nodes/materialx/functions/lib/mx_noise.d.ts

@@ -0,0 +1,6 @@
+import { Fn, Node, Swizzable } from '../../../Nodes';
+
+export function mx_perlin_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_cell_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_worley_noise_float(...params: Fn<[Node]>): Swizzable;
+export function mx_fractal_noise_float(...params: Fn<[Node, Node, Node, Node]>): Swizzable;

three/examples/jsm/nodes/procedural/CheckerNode.d.ts

@@ -1,6 +1,6 @@
-import Node from '../core/Node';
+import TempNode from '../core/TempNode';
 
-export default class CheckerNode extends Node {
+export default class CheckerNode extends TempNode {
     uvNode: Node;
     constructor(uvNode?: Node);
 }

three/examples/jsm/nodes/shadernode/ShaderNode.d.ts

@@ -7,17 +7,19 @@ export type Swizzable<T extends Node = Node> = T &
     };
 
 /** anything that can be passed to {@link nodeObject} and returns a proxy */
-export type NodeRepresentation = number | boolean | Node | Swizzable;
+export type NodeRepresentation<T extends Node = Node> = number | boolean | Node | Swizzable<T>;
 
 /** anything that can be passed to {@link nodeObject} */
 export type NodeObjectOption = NodeRepresentation | string;
 
-// same logic as in ShaderNodeObject
+// same logic as in ShaderNodeObject: number,boolean,node->swizzable, otherwise do nothing
 export type NodeObject<T> = T extends Node ? Swizzable<T> : T extends number | boolean ? Swizzable<ConstNode> : T;
 
-type MakeObjectOption<T> = T extends Node ? NodeRepresentation : T;
+// opposite of NodeObject: node -> node|swizzable|boolean|number, otherwise do nothing
+type Proxied<T> = T extends Node ? NodeRepresentation<T> : T;
 // https://github.com/microsoft/TypeScript/issues/42435#issuecomment-765557874
-type MakeObjectOptions<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: MakeObjectOption<T[index]> }];
+export type ProxiedTuple<T extends readonly [...unknown[]]> = [...{ [index in keyof T]: Proxied<T[index]> }];
+export type ProxiedObject<T> = { [index in keyof T]: Proxied<T[index]> };
 type RemoveTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X] ? X : [];
 type RemoveHeadAndTail<T extends readonly [...unknown[]]> = T extends [unknown, ...infer X, unknown] ? X : [];
 
@@ -121,22 +123,22 @@ export function nodeArray<T extends NodeObjectOption[]>(obj: readonly [...T]): N
 
 export function nodeProxy<T>(
     nodeClass: T,
-): (...params: MakeObjectOptions<GetConstructors<T>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<GetConstructors<T>>) => Swizzable<ConstructedNode<T>>;
 
 export function nodeProxy<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
-): (...params: MakeObjectOptions<RemoveTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
 
 export function nodeProxy<T, S extends GetPossibleScopes<T>>(
     nodeClass: T,
     scope: S,
     factor: NodeObjectOption,
-): (...params: MakeObjectOptions<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
+): (...params: ProxiedTuple<RemoveHeadAndTail<GetConstructorsByScope<T, S>>>) => Swizzable<ConstructedNode<T>>;
 
 export function nodeImmutable<T>(
     nodeClass: T,
-    ...params: MakeObjectOptions<GetConstructors<T>>
+    ...params: ProxiedTuple<GetConstructors<T>>
 ): Swizzable<ConstructedNode<T>>;
 
 export class ShaderNode<T = {}, R extends Node = Node> {

three/examples/jsm/nodes/shadernode/ShaderNodeBaseElements.d.ts

@@ -13,6 +13,8 @@ import {
     Swizzable,
     NodeRepresentation,
     NodeOrType,
+    ProxiedObject,
+    ProxiedTuple,
 } from './ShaderNode';
 import { Material, Texture } from '../../../../src/Three';
 import { NodeTypeOption, NodeUserData, NodeValueOption } from '../core/constants';
@@ -22,13 +24,14 @@ import {
     BypassNode,
     CameraNode,
     CodeNode,
+    CodeNodeInclude,
     ComputeNode,
     ContextNode,
-    ConvertNode,
     ExpressionNode,
     FrontFacingNode,
     FunctionCallNode,
     FunctionNode,
+    FunctionNodeArguments,
     InstanceIndexNode,
     MaterialNode,
     MaterialReferenceNode,
@@ -83,8 +86,6 @@ export const imat4: ConvertType;
 export const umat4: ConvertType;
 export const bmat4: ConvertType;
 
-export function func(code: string): ShaderNode<FunctionNode>;
-
 export function uniform(nodeOrType: Node | Swizzable | NodeValueOption): Swizzable;
 
 export function attribute(attributeName: string, nodeType: NodeTypeOption): Swizzable;
@@ -95,10 +96,27 @@ export function code(code: string, nodeType?: NodeTypeOption): Swizzable<CodeNod
 export function context(node: NodeRepresentation, context: NodeBuilderContext): Swizzable<ContextNode>;
 export function expression(snipped?: string, nodeType?: NodeTypeOption): Swizzable<ExpressionNode>;
 
-export function call(
-    functionNode?: NodeRepresentation,
-    parameters?: { [name: string]: Node },
-): Swizzable<FunctionCallNode>;
+// definition: const call = nodeProxy(FunctionCallNode);
+export function call<P extends FunctionNodeArguments>(
+    functionNode?: FunctionNode<P>,
+    parameters?: ProxiedObject<P>,
+): Swizzable<FunctionCallNode<P>>;
+
+export type Fn<P extends FunctionNodeArguments> = P extends readonly [...unknown[]]
+    ? ProxiedTuple<P>
+    : readonly [ProxiedObject<P>];
+
+// tslint:disable:no-unnecessary-generics
+export function func<P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+): { call: (...params: Fn<P>) => Swizzable };
+
+export function fn<P extends FunctionNodeArguments>(
+    code: string,
+    includes?: CodeNodeInclude[],
+): (...params: Fn<P>) => Swizzable;
+// tslint:enable:no-unnecessary-generics
 
 export const instanceIndex: Swizzable<InstanceIndexNode>;
 export function label(node: NodeRepresentation, name?: string): Swizzable<VarNode>;

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

@@ -21,7 +21,7 @@ export interface ReflectorShader {
     fragmentShader: string;
 }
 
-export interface ReflectorOptions {
+export interface ReflectorForSSRPassOptions {
     clipBias?: number | undefined;
     textureWidth?: number | undefined;
     textureHeight?: number | undefined;
@@ -30,9 +30,9 @@ export interface ReflectorOptions {
     shader?: ReflectorShader | undefined;
 }
 
-export class Reflector<TGeometry extends BufferGeometry = BufferGeometry> extends Mesh<TGeometry> {
+export class ReflectorForSSRPass<TGeometry extends BufferGeometry = BufferGeometry> extends Mesh<TGeometry> {
     type: 'ReflectorForSSRPass';
-    options: ReflectorOptions;
+    options: ReflectorForSSRPassOptions;
 
     static ReflectorShader: ReflectorShader;
 
@@ -49,7 +49,7 @@ export class Reflector<TGeometry extends BufferGeometry = BufferGeometry> extend
 
     renderTarget: WebGLRenderTarget;
 
-    constructor(geometry: TGeometry, options: ReflectorOptions);
+    constructor(geometry: TGeometry, options: ReflectorForSSRPassOptions);
 
     doRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera) => void;
 

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

@@ -12,7 +12,7 @@ import {
     ColorRepresentation,
 } from '../../../src/Three';
 import { Pass, FullScreenQuad } from '../postprocessing/Pass';
-import { Reflector } from '../objects/ReflectorForSSRPass';
+import { ReflectorForSSRPass } from '../objects/ReflectorForSSRPass';
 
 export interface SSRPassParams {
     renderer: WebGLRenderer;
@@ -23,7 +23,7 @@ export interface SSRPassParams {
     selects: Mesh[] | null;
     isPerspectiveCamera?: boolean | undefined;
     isBouncing?: boolean | undefined;
-    groundReflector: Reflector | null;
+    groundReflector: ReflectorForSSRPass | null;
 }
 
 export class SSRPass extends Pass {
@@ -33,7 +33,7 @@ export class SSRPass extends Pass {
     renderer: WebGLRenderer;
     scene: Scene;
     camera: Camera;
-    groundReflector: Reflector | null;
+    groundReflector: ReflectorForSSRPass | null;
     opacity: number;
     output: number;
     maxDistance: number;

three/examples/jsm/renderers/webgl/nodes/SlotNode.d.ts

@@ -1,5 +1,17 @@
-import Node from '../../../nodes/core/Node.js';
+import Node from '../../../nodes/core/Node';
 
-export default class SlotNode extends Node {
-    constructor(node: Node, name: string, NodeTypeOption: string);
+export interface SlotNodeParameters<TNode extends Node = Node> {
+    node?: TNode;
+    nodeType?: string;
+    source?: string | null;
+    target?: string | null;
+}
+
+export default class SlotNode<TNode extends Node = Node> extends Node {
+    inclusionType: 'replace';
+    node: TNode | null;
+    source: null;
+    target: null;
+
+    constructor(params: SlotNodeParameters<TNode>);
 }

three/examples/jsm/renderers/webgl/nodes/WebGLNodeBuilder.d.ts

@@ -1,8 +1,8 @@
-import NodeBuilder from '../../../nodes/core/NodeBuilder.js';
+import NodeBuilder from '../../../nodes/core/NodeBuilder';
 import { Texture, TextureEncoding, Renderer, Object3D } from '../../../../../src/Three';
-import Node from '../../../nodes/core/Node.js';
-import SlotNode from './SlotNode.js';
-import { NodeShaderStageOption } from '../../../nodes/core/constants.js';
+import Node from '../../../nodes/core/Node';
+import SlotNode from './SlotNode';
+import { NodeShaderStageOption } from '../../../nodes/core/constants';
 
 export class WebGLNodeBuilder extends NodeBuilder {
     constructor(
@@ -39,7 +39,7 @@ export class WebGLNodeBuilder extends NodeBuilder {
 
     getVarys(shaderStage: string): string;
 
-    addCodeAfterSnippet(shaderStage: string, snippet: string, code: string): string;
+    addCodeAfterCode(shaderStage: string, snippet: string, code: string): string;
     addCodeAfterInclude(shaderStage: string, snippet: string, code: string): string;
 
     replaceCode(shaderStage: string, source: string, target: string): void;

three/examples/jsm/renderers/webgl/nodes/WebGLNodes.d.ts

@@ -1,3 +1,3 @@
-import NodeFrame from '../../../nodes/core/NodeFrame.js';
+import NodeFrame from '../../../nodes/core/NodeFrame';
 
 export const nodeFrame: NodeFrame;

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

@@ -1,10 +1,10 @@
-import { Uniform } from '../../../src/Three';
+import { IUniform } from '../../../src/Three';
 
 export const AfterimageShader: {
     uniforms: {
-        damp: Uniform;
-        tOld: Uniform;
-        tNew: Uniform;
+        damp: IUniform;
+        tOld: IUniform;
+        tNew: IUniform;
     };
     vertexShader: string;
     fragmentShader: string;

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

@@ -1,9 +1,9 @@
-import { Uniform } from '../../../src/Three';
+import { IUniform } from '../../../src/Three';
 
 export const BleachBypassShader: {
     uniforms: {
-        tDiffuse: Uniform;
-        opacity: Uniform;
+        tDiffuse: IUniform;
+        opacity: IUniform;
     };
     vertexShader: string;
     fragmentShader: string;

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

@@ -1,11 +1,11 @@
-import { Uniform } from '../../../src/Three';
+import { IUniform } from '../../../src/Three';
 
 export const BlendShader: {
     uniforms: {
-        tDiffuse1: Uniform;
-        tDiffuse2: Uniform;
-        mixRatio: Uniform;
-        opacity: Uniform;
+        tDiffuse1: IUniform;
+        tDiffuse2: IUniform;
+        mixRatio: IUniform;
+        opacity: IUniform;
     };
     vertexShader: string;
     fragmentShader: string;

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

@@ -1,4 +1,4 @@
-import { Uniform } from '../../../src/Three';
+import { IUniform } from '../../../src/Three';
 
 export const BokehShader: {
     defines: {
@@ -6,14 +6,14 @@ export const BokehShader: {
         PERSPECTIVE_CAMERA: number;
     };
     uniforms: {
-        tColor: Uniform;
-        tDepth: Uniform;
-        focus: Uniform;
-        aspect: Uniform;
-        aperture: Uniform;
-        maxblur: Uniform;
-        nearClip: Uniform;
-        farClip: Uniform;
+        tColor: IUniform;
+        tDepth: IUniform;
+        focus: IUniform;
+        aspect: IUniform;
+        aperture: IUniform;
+        maxblur: IUniform;
+        nearClip: IUniform;
+        farClip: IUniform;
     };
     vertexShader: string;
     fragmentShader: string;