@types/three 0.167.2 → 0.168.0

three/examples/jsm/effects/ParallaxBarrierEffect.d.ts

@@ -1,8 +1,11 @@
 import { Camera, Scene, WebGLRenderer } from "three";
 
-export class ParallaxBarrierEffect {
-    constructor(renderer: WebGLRenderer);
+declare class ParallaxBarrierEffect {
+    setSize: (width: number, height: number) => void;
+    render: (scene: Scene, camera: Camera) => void;
+    dispose: () => void;
 
-    render(scene: Scene, camera: Camera): void;
-    setSize(width: number, height: number): void;
+    constructor(renderer: WebGLRenderer);
 }
+
+export { ParallaxBarrierEffect };

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

@@ -1,6 +1,6 @@
-import { Scene, WebGLRenderer } from "three";
+import { Scene } from "three";
 
 export class RoomEnvironment extends Scene {
-    constructor(renderer?: WebGLRenderer);
+    constructor();
     dispose(): void;
 }

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

@@ -43,6 +43,10 @@ export class KTX2Loader extends Loader<CompressedTexture> {
      */
     detectSupport(renderer: WebGLRenderer | WebGPURenderer): this;
 
+    init(): Promise<void>;
+
+    parse(buffer: ArrayBuffer, onLoad?: (texture: CompressedTexture) => void, onError?: (err: unknown) => void): void;
+
     /**
      * Disposes the loader object, de-allocating any Web Workers created.
      */

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

@@ -0,0 +1,17 @@
+import { ShaderNodeObject, UniformNode } from "three/tsl";
+import { BoxGeometry, Mesh, NodeMaterial, Vector3 } from "three/webgpu";
+
+declare class SkyMesh extends Mesh<BoxGeometry, NodeMaterial> {
+    turbidity: ShaderNodeObject<UniformNode<number>>;
+    rayleigh: ShaderNodeObject<UniformNode<number>>;
+    mieCoefficient: ShaderNodeObject<UniformNode<number>>;
+    mieDirectionalG: ShaderNodeObject<UniformNode<number>>;
+    sunPosition: ShaderNodeObject<UniformNode<Vector3>>;
+    upUniform: ShaderNodeObject<UniformNode<Vector3>>;
+
+    readonly isSky: true;
+
+    constructor();
+}
+
+export { SkyMesh };

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

@@ -1,6 +1,6 @@
 import { BufferGeometry, ColorRepresentation, Mesh, ShaderMaterial, Texture, Vector2 } from "three";
 
-export interface Water2Options {
+export interface WaterOptions {
     color?: ColorRepresentation | undefined;
     textureWidth?: number | undefined;
     textureHeight?: number | undefined;
@@ -17,5 +17,5 @@ export interface Water2Options {
 
 export class Water extends Mesh {
     material: ShaderMaterial;
-    constructor(geometry: BufferGeometry, options: Water2Options);
+    constructor(geometry: BufferGeometry, options: WaterOptions);
 }

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

@@ -0,0 +1,42 @@
+import { TempNode, TextureNode, UniformNode, Vector2, Vector3 } from "three/tsl";
+import { BufferGeometry, Color, ColorRepresentation, Mesh, NodeMaterial, Texture } from "three/webgpu";
+
+export interface WaterMeshOptions {
+    normalMap0: Texture;
+    normalMap1: Texture;
+    flowMap?: Texture | null | undefined;
+
+    color?: ColorRepresentation | undefined;
+    flowDirection?: Vector2 | undefined;
+    flowSpeed?: number | undefined;
+    reflectivity?: number | undefined;
+    scale?: number | undefined;
+}
+
+declare class WaterMesh extends Mesh<BufferGeometry, NodeMaterial> {
+    readonly isWater: true;
+
+    constructor(geometry: BufferGeometry, options: WaterMeshOptions);
+}
+
+declare class WaterNode extends TempNode {
+    waterBody: WaterMesh;
+
+    normalMap0: TextureNode;
+    normalMap1: TextureNode;
+    flowMap: TextureNode;
+
+    color: UniformNode<Color>;
+    flowDirection: UniformNode<Vector2>;
+    flowSpeed: UniformNode<number>;
+    reflectivity: UniformNode<number>;
+    scale: UniformNode<number>;
+    flowConfig: UniformNode<Vector3>;
+
+    constructor(options: WaterMeshOptions, waterBody: WaterMesh);
+
+    updateFlow(delta: number): void;
+}
+
+export { WaterMesh };
+export type { WaterNode };

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

@@ -0,0 +1,31 @@
+import { TextureNode, UniformNode } from "three/tsl";
+import { BufferGeometry, Color, ColorRepresentation, Mesh, NodeMaterial, Texture, Vector3 } from "three/webgpu";
+
+export interface WaterMeshOptions {
+    resolution?: number | undefined;
+    waterNormals: Texture;
+    alpha?: number | undefined;
+    size?: number | undefined;
+    sunColor?: ColorRepresentation | undefined;
+    sunDirection?: Vector3 | undefined;
+    waterColor?: ColorRepresentation | undefined;
+    distortionScale?: number | undefined;
+}
+
+declare class WaterMesh extends Mesh<BufferGeometry, NodeMaterial> {
+    readonly isWater: true;
+
+    resolution: number;
+
+    waterNormals: TextureNode;
+    alpha: UniformNode<number>;
+    size: UniformNode<number>;
+    sunColor: UniformNode<Color>;
+    sunDirection: UniformNode<Vector3>;
+    waterColor: UniformNode<Color>;
+    distortionScale: UniformNode<number>;
+
+    constructor(geometry: BufferGeometry, options: WaterMeshOptions);
+}
+
+export { WaterMesh };

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

@@ -53,7 +53,7 @@ export class OutlinePass extends Pass {
     tempPulseColor2: Color;
     textureMatrix: Matrix4;
 
-    dispose(): void;
+    updateSelectionCache(): void;
     changeVisibilityOfSelectedObjects(bVisible: boolean): void;
     changeVisibilityOfNonSelectedObjects(bVisible: boolean): void;
     updateTextureMatrix(): void;

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

@@ -3,15 +3,24 @@ import { Camera, ColorRepresentation, Scene, ShaderMaterial, WebGLRenderTarget }
 import { FullScreenQuad, Pass } from "./Pass.js";
 
 export class SSAARenderPass extends Pass {
-    constructor(scene: Scene, camera: Camera, clearColor?: ColorRepresentation, clearAlpha?: number);
     scene: Scene;
     camera: Camera;
+
     sampleLevel: number;
     unbiased: boolean;
+
+    stencilBuffer: boolean;
+
     clearColor: ColorRepresentation;
     clearAlpha: number;
+
     copyUniforms: object;
+
     copyMaterial: ShaderMaterial;
+
     fsQuad: FullScreenQuad;
-    sampleRenderTarget: undefined | WebGLRenderTarget;
+
+    sampleRenderTarget?: WebGLRenderTarget | undefined;
+
+    constructor(scene: Scene, camera: Camera, clearColor?: ColorRepresentation, clearAlpha?: number);
 }

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.167.2",
+    "version": "0.168.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -40,12 +40,13 @@
     },
     "scripts": {},
     "dependencies": {
-        "@tweenjs/tween.js": "~23.1.2",
+        "@tweenjs/tween.js": "~23.1.3",
         "@types/stats.js": "*",
         "@types/webxr": "*",
+        "@webgpu/types": "*",
         "fflate": "~0.8.2",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "b2631004bef25b94aabf001fd93006de112c6e2e3bd264b1182ce7d196d50498",
+    "typesPublisherContentHash": "246996b31ec2b1d960db45a72651460f27348c47e1babab88c4c9d74a3510060",
     "typeScriptVersion": "4.8"
 }

three/src/Three.WebGPU.d.ts

@@ -40,6 +40,7 @@ export * from "./core/Raycaster.js";
 export * from "./core/RenderTarget.js";
 export * from "./core/Uniform.js";
 export * from "./core/UniformsGroup.js";
+export * from "./extras/Controls.js";
 export * from "./extras/core/Curve.js";
 export * from "./extras/core/CurvePath.js";
 export * from "./extras/core/Path.js";
@@ -94,6 +95,7 @@ export * from "./loaders/MaterialLoader.js";
 export * from "./loaders/ObjectLoader.js";
 export * from "./loaders/TextureLoader.js";
 export * from "./materials/Materials.js";
+export * from "./materials/nodes/NodeMaterials.js";
 export * from "./math/Box2.js";
 export * from "./math/Box3.js";
 export * from "./math/Color.js";
@@ -184,7 +186,11 @@ export * from "./Three.Legacy.js";
 export { createCanvasElement } from "./utils.js";
 
 export { default as IESSpotLight } from "./lights/webgpu/IESSpotLight.js";
+export { default as NodeLoader } from "./loaders/nodes/NodeLoader.js";
+export { default as NodeMaterialLoader } from "./loaders/nodes/NodeMaterialLoader.js";
+export { default as NodeObjectLoader } from "./loaders/nodes/NodeObjectLoader.js";
 export * from "./nodes/Nodes.js";
+export * from "./nodes/TSL.js";
 export { default as PMREMGenerator } from "./renderers/common/extras/PMREMGenerator.js";
 export { default as PostProcessing } from "./renderers/common/PostProcessing.js";
 export { default as QuadMesh } from "./renderers/common/QuadMesh.js";

three/src/Three.d.ts

@@ -40,6 +40,7 @@ export * from "./core/Raycaster.js";
 export * from "./core/RenderTarget.js";
 export * from "./core/Uniform.js";
 export * from "./core/UniformsGroup.js";
+export * from "./extras/Controls.js";
 export * from "./extras/core/Curve.js";
 export * from "./extras/core/CurvePath.js";
 export * from "./extras/core/Path.js";

three/src/core/EventDispatcher.d.ts

@@ -53,7 +53,6 @@ export class EventDispatcher<TEventMap extends {} = {}> {
         type: T,
         listener: EventListener<TEventMap[T], T, this>,
     ): void;
-    addEventListener<T extends string>(type: T, listener: EventListener<{}, T, this>): void;
 
     /**
      * Checks if listener is added to an event type.
@@ -64,7 +63,6 @@ export class EventDispatcher<TEventMap extends {} = {}> {
         type: T,
         listener: EventListener<TEventMap[T], T, this>,
     ): boolean;
-    hasEventListener<T extends string>(type: T, listener: EventListener<{}, T, this>): boolean;
 
     /**
      * Removes a listener from an event type.
@@ -75,7 +73,6 @@ export class EventDispatcher<TEventMap extends {} = {}> {
         type: T,
         listener: EventListener<TEventMap[T], T, this>,
     ): void;
-    removeEventListener<T extends string>(type: T, listener: EventListener<{}, T, this>): void;
 
     /**
      * Fire an event type.

three/src/core/Object3D.d.ts

@@ -299,6 +299,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     onBeforeShadow(
         renderer: WebGLRenderer,
         scene: Scene,
+        camera: Camera,
         shadowCamera: Camera,
         geometry: BufferGeometry,
         depthMaterial: Material,
@@ -317,6 +318,7 @@ export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> ext
     onAfterShadow(
         renderer: WebGLRenderer,
         scene: Scene,
+        camera: Camera,
         shadowCamera: Camera,
         geometry: BufferGeometry,
         depthMaterial: Material,

three/src/extras/Controls.d.ts

@@ -0,0 +1,54 @@
+import { Camera } from "../cameras/Camera.js";
+import { EventDispatcher } from "../core/EventDispatcher.js";
+
+/**
+ * Abstract base class for controls.
+ */
+declare abstract class Controls<TEventMap extends {}> extends EventDispatcher<TEventMap> {
+    /**
+     * The 3D object that is managed by the controls.
+     */
+    object: Camera;
+
+    /**
+     * The HTML element used for event listeners. If not provided via the constructor, {@link .connect} must be called
+     * after `domElement` has been set.
+     */
+    domElement: HTMLElement | null;
+
+    /**
+     * When set to `false`, the controls will not respond to user input. Default is `true`.
+     */
+    enabled: boolean;
+
+    /**
+     * Creates a new instance of {@link Controls}.
+     * @param object The object the controls should manage (usually the camera).
+     * @param domElement The HTML element used for event listeners. (optional)
+     */
+    constructor(object: Camera, domElement: HTMLElement | null);
+
+    /**
+     * Connects the controls to the DOM. This method has so called "side effects" since it adds the module's event
+     * listeners to the DOM.
+     */
+    connect(): void;
+
+    /**
+     * Disconnects the controls from the DOM.
+     */
+    disconnect(): void;
+
+    /**
+     * Call this method if you no longer want use to the controls. It frees all internal resources and removes all event
+     * listeners.
+     */
+    dispose(): void;
+
+    /**
+     * Controls should implement this method if they have to update their internal state per simulation step.
+     */
+    update(delta: number): void;
+}
+
+export { Controls };

three/src/{nodes/loaders → loaders/nodes}/NodeLoader.d.ts

@@ -1,7 +1,7 @@
-import { Loader } from "../../loaders/Loader.js";
-import { LoadingManager } from "../../loaders/LoadingManager.js";
+import { Node } from "../../nodes/Nodes.js";
 import { Texture } from "../../textures/Texture.js";
-import { Node } from "../Nodes.js";
+import { Loader } from "../Loader.js";
+import { LoadingManager } from "../LoadingManager.js";
 
 export interface NodeLoaderResult {
     [hash: string]: Node;

three/src/{nodes/loaders → loaders/nodes}/NodeMaterialLoader.d.ts

@@ -1,4 +1,4 @@
-import { MaterialLoader } from "../../loaders/MaterialLoader.js";
+import { MaterialLoader } from "../MaterialLoader.js";
 import { NodeLoaderResult } from "./NodeLoader.js";
 
 export default class NodeMaterialLoader extends MaterialLoader {

three/src/{nodes/loaders → loaders/nodes}/NodeObjectLoader.d.ts

@@ -1,6 +1,6 @@
-import { ObjectLoader } from "../../loaders/ObjectLoader.js";
 import { Material } from "../../materials/Material.js";
 import { Texture } from "../../textures/Texture.js";
+import { ObjectLoader } from "../ObjectLoader.js";
 import { NodeLoaderResult } from "./NodeLoader.js";
 
 export default class NodeObjectLoader extends ObjectLoader {

three/src/materials/Material.d.ts

@@ -556,10 +556,26 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      */
     set alphaTest(value: number);
 
+    /**
+     * An optional callback that is executed immediately before the material is used to render a 3D object.
+     * Unlike properties, the callback is not supported by {@link .clone()}, {@link .copy()} and {@link .toJSON()}.
+     * This callback is only supported in `WebGLRenderer` (not `WebGPURenderer`).
+     */
+    onBeforeRender(
+        renderer: WebGLRenderer,
+        scene: Scene,
+        camera: Camera,
+        geometry: BufferGeometry,
+        object: Object3D,
+        group: Group,
+    ): void;
+
     /**
      * An optional callback that is executed immediately before the shader program is compiled.
-     * This function is called with the associated WebGL program parameters and renderer.
+     * This function is called with the shader source code as a parameter.
      * Useful for the modification of built-in materials.
+     * Unlike properties, the callback is not supported by {@link .clone()}, {@link .copy()} and {@link .toJSON()}.
+     * This callback is only supported in `WebGLRenderer` (not `WebGPURenderer`).
      * @param parameters WebGL program parameters
      * @param renderer WebGLRenderer context that is initializing the material
      */
@@ -612,16 +628,4 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      * @deprecated onBuild() has been removed.
      */
     onBuild(object: Object3D, parameters: WebGLProgramParametersWithUniforms, renderer: WebGLRenderer): void;
-
-    /**
-     * @deprecated onBeforeRender() has been removed.
-     */
-    onBeforeRender(
-        renderer: WebGLRenderer,
-        scene: Scene,
-        camera: Camera,
-        geometry: BufferGeometry,
-        object: Object3D,
-        group: Group,
-    ): void;
 }

three/src/materials/nodes/InstancedPointsNodeMaterial.d.ts

@@ -0,0 +1,33 @@
+import { Color } from "../../math/Color.js";
+import Node from "../../nodes/core/Node.js";
+import { Texture } from "../../textures/Texture.js";
+import { PointsMaterialParameters } from "../PointsMaterial.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface InstancedPointsNodeMaterialParameters extends NodeMaterialParameters, PointsMaterialParameters {
+    useAlphaToCoverage?: boolean | undefined;
+    useColor?: boolean | undefined;
+    pointWidth?: number | undefined;
+    pointColorNode?: Node | null | undefined;
+    pointWidthNode?: Node | null | undefined;
+}
+
+declare class InstancedPointsNodeMaterial extends NodeMaterial {
+    useAlphaToCoverage: boolean;
+    useColor: boolean | undefined;
+    pointWidth: number;
+    pointColorNode: Node | null;
+    pointWidthNode: Node | null;
+
+    // Properties from LineDashedMaterial
+    readonly isPointsMaterial: true;
+    color: Color;
+    map: Texture | null;
+    alphaMap: Texture | null;
+    size: number;
+    sizeAttenuation: boolean;
+
+    constructor(params?: InstancedPointsNodeMaterialParameters);
+}
+
+export default InstancedPointsNodeMaterial;

three/src/{nodes/materials → materials/nodes}/Line2NodeMaterial.d.ts

@@ -1,7 +1,7 @@
-import { LineDashedMaterialParameters } from "../../materials/LineDashedMaterial.js";
 import { Color } from "../../math/Color.js";
+import Node from "../../nodes/core/Node.js";
 import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
+import { LineDashedMaterialParameters } from "../LineDashedMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface Line2NodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {

three/src/{nodes/materials → materials/nodes}/LineBasicNodeMaterial.d.ts

@@ -1,6 +1,6 @@
-import { LineBasicMaterialParameters } from "../../materials/LineBasicMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Texture } from "../../textures/Texture.js";
+import { LineBasicMaterialParameters } from "../LineBasicMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface LineBasicNodeMaterialParameters extends NodeMaterialParameters, LineBasicMaterialParameters {

three/src/materials/nodes/LineDashedNodeMaterial.d.ts

@@ -0,0 +1,29 @@
+import Node from "../../nodes/core/Node.js";
+import { LineDashedMaterialParameters } from "../LineDashedMaterial.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface LineDashedNodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
+    offsetNode?: Node | null | undefined;
+    dashScaleNode?: Node | null | undefined;
+    dashSizeNode?: Node | null | undefined;
+    gapSizeNode?: Node | null | undefined;
+}
+
+declare class LineDashedNodeMaterial extends NodeMaterial {
+    readonly isLineDashedNodeMaterial: true;
+
+    offsetNode: Node | null;
+    dashScaleNode: Node | null;
+    dashSizeNode: Node | null;
+    gapSizeNode: Node | null;
+
+    // Properties from LineDashedMaterial
+    readonly isLineDashedMaterial: true;
+    scale: number;
+    dashSize: number;
+    gapSize: number;
+
+    constructor(parameters?: LineDashedMaterialParameters);
+}
+
+export default LineDashedNodeMaterial;

three/src/{nodes/materials → materials/nodes}/MeshBasicNodeMaterial.d.ts

@@ -1,8 +1,8 @@
 import { Combine } from "../../constants.js";
-import { MeshBasicMaterialParameters } from "../../materials/MeshBasicMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Euler } from "../../math/Euler.js";
 import { Texture } from "../../textures/Texture.js";
+import { MeshBasicMaterialParameters } from "../MeshBasicMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshBasicMaterialParameters {

three/src/materials/nodes/MeshLambertNodeMaterial.d.ts

@@ -0,0 +1,49 @@
+import { Combine, NormalMapTypes } from "../../constants.js";
+import { Color } from "../../math/Color.js";
+import { Euler } from "../../math/Euler.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Texture } from "../../textures/Texture.js";
+import { MeshLambertMaterialParameters } from "../MeshLambertMaterial.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshLambertNodeMaterialParameters extends NodeMaterialParameters, MeshLambertMaterialParameters {}
+
+declare class MeshLambertNodeMaterial extends NodeMaterial {
+    readonly isMeshLambertNodeMaterial: true;
+
+    // Properties from MeshLambertMaterial
+    readonly isMeshLambertMaterial: true;
+    color: Color;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    emissive: Color;
+    emissiveIntensity: number;
+    emissiveMap: Texture | null;
+    flatShading: boolean;
+    map: Texture | null;
+    lightMap: Texture | null;
+    lightMapIntensity: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    aoMap: Texture | null;
+    aoMapIntensity: number;
+    specularMap: Texture | null;
+    alphaMap: Texture | null;
+    envMap: Texture | null;
+    envMapRotation: Euler;
+    combine: Combine;
+    reflectivity: number;
+    refractionRatio: number;
+    wireframe: boolean;
+    wireframeLinewidth: number;
+    wireframeLinecap: string;
+    wireframeLinejoin: string;
+
+    constructor(parameters?: MeshLambertNodeMaterialParameters);
+}
+
+export default MeshLambertNodeMaterial;

three/src/{nodes/materials → materials/nodes}/MeshMatcapNodeMaterial.d.ts

@@ -1,8 +1,8 @@
 import { NormalMapTypes } from "../../constants.js";
-import { MeshMatcapMaterialParameters } from "../../materials/MeshMatcapMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Vector2 } from "../../math/Vector2.js";
 import { Texture } from "../../textures/Texture.js";
+import { MeshMatcapMaterialParameters } from "../MeshMatcapMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshMatcapNodeMaterialParameters extends NodeMaterialParameters, MeshMatcapMaterialParameters {
@@ -28,5 +28,5 @@ export default class MeshMatcapNodeMaterial extends NodeMaterial {
     flatShading: boolean;
     fog: boolean;
 
-    constructor(paramters: MeshMatcapNodeMaterialParameters);
+    constructor(parameters?: MeshMatcapNodeMaterialParameters);
 }

three/src/{nodes/materials → materials/nodes}/MeshNormalNodeMaterial.d.ts

@@ -1,7 +1,7 @@
 import { NormalMapTypes } from "../../constants.js";
-import { MeshNormalMaterialParameters } from "../../materials/MeshNormalMaterial.js";
 import { Vector2 } from "../../math/Vector2.js";
 import { Texture } from "../../textures/Texture.js";
+import { MeshNormalMaterialParameters } from "../MeshNormalMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshNormalMaterialParameters {

three/src/{nodes/materials → materials/nodes}/MeshPhongNodeMaterial.d.ts

@@ -1,10 +1,10 @@
 import { Combine, NormalMapTypes } from "../../constants.js";
-import { MeshPhongMaterialParameters } from "../../materials/MeshPhongMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Euler } from "../../math/Euler.js";
 import { Vector2 } from "../../math/Vector2.js";
+import Node from "../../nodes/core/Node.js";
 import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
+import { MeshPhongMaterialParameters } from "../MeshPhongMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshPhongNodeMaterialParameters extends NodeMaterialParameters, MeshPhongMaterialParameters {

three/src/{nodes/materials → materials/nodes}/MeshPhysicalNodeMaterial.d.ts

@@ -1,8 +1,9 @@
-import { MeshPhysicalMaterialParameters } from "../../materials/MeshPhysicalMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Vector2 } from "../../math/Vector2.js";
+import Node from "../../nodes/core/Node.js";
+import { ShaderNodeObject } from "../../nodes/tsl/TSLCore.js";
 import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
+import { MeshPhysicalMaterialParameters } from "../MeshPhysicalMaterial.js";
 import MeshStandardNodeMaterial, { MeshStandardNodeMaterialParameters } from "./MeshStandardNodeMaterial.js";
 
 export interface MeshPhysicalNodeMaterialParameters
@@ -87,4 +88,6 @@ export default class MeshPhysicalNodeMaterial extends MeshStandardNodeMaterial {
     get useAnisotropy(): boolean;
     get useTransmission(): boolean;
     get useDispersion(): boolean;
+
+    setupClearcoatNormal(): ShaderNodeObject<Node>;
 }

three/src/{nodes/materials → materials/nodes}/MeshSSSNodeMaterial.d.ts

@@ -1,5 +1,5 @@
-import ConstNode from "../core/ConstNode.js";
-import Node from "../core/Node.js";
+import ConstNode from "../../nodes/core/ConstNode.js";
+import Node from "../../nodes/core/Node.js";
 import MeshPhysicalNodeMaterial, { MeshPhysicalNodeMaterialParameters } from "./MeshPhysicalNodeMaterial.js";
 
 export default class MeshSSSNodeMaterial extends MeshPhysicalNodeMaterial {

three/src/{nodes/materials → materials/nodes}/MeshStandardNodeMaterial.d.ts

@@ -1,10 +1,10 @@
 import { NormalMapTypes } from "../../constants.js";
-import { MeshStandardMaterialParameters } from "../../materials/MeshStandardMaterial.js";
 import { Color } from "../../math/Color.js";
 import { Euler } from "../../math/Euler.js";
 import { Vector2 } from "../../math/Vector2.js";
+import Node from "../../nodes/core/Node.js";
 import { Texture } from "../../textures/Texture.js";
-import Node from "../core/Node.js";
+import { MeshStandardMaterialParameters } from "../MeshStandardMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
 export interface MeshStandardNodeMaterialParameters extends NodeMaterialParameters, MeshStandardMaterialParameters {
@@ -52,5 +52,5 @@ export default class MeshStandardNodeMaterial extends NodeMaterial {
     flatShading: boolean;
     fog: boolean;
 
-    constructor(paramters?: MeshStandardNodeMaterialParameters);
+    constructor(parameters?: MeshStandardNodeMaterialParameters);
 }