@types/three 0.179.0 → 0.181.0

three/examples/jsm/tsl/display/SobelOperatorNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class SobelOperatorNode extends TempNode {
@@ -9,4 +8,4 @@ declare class SobelOperatorNode extends TempNode {
 
 export default SobelOperatorNode;
 
-export const sobel: (node: Node) => ShaderNodeObject<SobelOperatorNode>;
+export const sobel: (node: Node) => SobelOperatorNode;

three/examples/jsm/tsl/display/StereoPassNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, PassNode, Scene, StereoCamera } from "three/webgpu";
 
 declare class StereoPassNode extends PassNode {
@@ -11,4 +10,4 @@ declare class StereoPassNode extends PassNode {
 
 export default StereoPassNode;
 
-export const stereoPass: (scene: Scene, camera: Camera) => ShaderNodeObject<StereoPassNode>;
+export const stereoPass: (scene: Scene, camera: Camera) => StereoPassNode;

three/examples/jsm/tsl/display/TRAANode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class TRAANode extends TempNode {
@@ -19,4 +18,4 @@ export const traa: (
     depthNode: TextureNode,
     velocityNode: TextureNode,
     camera: Camera,
-) => ShaderNodeObject<TRAANode>;
+) => TRAANode;

three/examples/jsm/tsl/display/TransitionNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class TransitionNode extends TempNode {
@@ -29,4 +28,4 @@ export const transition: (
     mixRatio: UniformNode<number>,
     threshold: UniformNode<number>,
     useTexture: UniformNode<number>,
-) => ShaderNodeObject<TransitionNode>;
+) => TransitionNode;

three/examples/jsm/tsl/display/boxBlur.d.ts

@@ -0,0 +1,10 @@
+import { Node } from "three/webgpu";
+
+export interface BoxBlurOptions {
+    size?: Node | undefined;
+    separation?: Node | undefined;
+    mask?: Node | null | undefined;
+    premultipliedAlpha?: boolean | undefined;
+}
+
+export const boxBlur: (textureNode: Node, options?: BoxBlurOptions) => Node;

three/examples/jsm/tsl/display/hashBlur.d.ts

@@ -1,8 +1,7 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
 interface HashBlurOptions {
-    repeats?: Node | undefined;
+    size?: Node | undefined;
     mask?: Node | null | undefined;
     premultipliedAlpha?: boolean | undefined;
 }
@@ -11,4 +10,4 @@ export const hashBlur: (
     textureNode: Node,
     bluramount?: Node | number,
     options?: HashBlurOptions,
-) => ShaderNodeObject<Node>;
+) => Node;

three/examples/jsm/tsl/lighting/TiledLightsNode.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { LightsNode, Node } from "three/webgpu";
 
 export const circleIntersectsAABB: (
@@ -6,18 +5,18 @@ export const circleIntersectsAABB: (
     radius: Node,
     minBounds: Node,
     maxBounds: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 declare class TiledLightsNode extends LightsNode {
     constructor(maxLights?: number, tileSize?: number);
 
     updateLightsTexture(): void;
 
-    getBlock(block?: number): ShaderNodeObject<Node>;
+    getBlock(block?: number): Node;
 
     setSize(width: number, height: number): this;
 }
 
 export default TiledLightsNode;
 
-export const tiledLights: (maxLights?: number, tileSize?: number) => ShaderNodeObject<TiledLightsNode>;
+export const tiledLights: (maxLights?: number, tileSize?: number) => TiledLightsNode;

three/examples/jsm/tsl/math/Bayer.d.ts

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
-export const bayer16: (uv: Node) => ShaderNodeObject<Node>;
+export const bayer16: (uv: Node) => Node;

three/examples/jsm/tsl/utils/Raymarching.d.ts

@@ -1,9 +1,8 @@
-import { ShaderNodeObject } from "three/tsl";
 import { FunctionNode, Node } from "three/webgpu";
 
 export const RaymarchingBox: (
     steps: number | Node,
     callback:
-        | ((params: { positionRay: ShaderNodeObject<Node> }) => void)
-        | FunctionNode<{ positionRay: ShaderNodeObject<Node> }>,
+        | ((params: { positionRay: Node }) => void)
+        | FunctionNode<{ positionRay: Node }>,
 ) => void;

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.179.0",
+    "version": "0.181.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -49,6 +49,6 @@
         "meshoptimizer": "~0.22.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "184261baf6703d118d65b2d005bcc72af9877981f78da02aa9756329a95df8a8",
+    "typesPublisherContentHash": "d4f610987bd76c1162c3a6a2221b72979499c9bc94a8d25712df1534d6b1bb87",
     "typeScriptVersion": "5.2"
 }

three/src/Three.Core.d.ts

@@ -154,9 +154,10 @@ export * from "./textures/Data3DTexture.js";
 export * from "./textures/DataArrayTexture.js";
 export * from "./textures/DataTexture.js";
 export * from "./textures/DepthTexture.js";
+export * from "./textures/ExternalTexture.js";
 export * from "./textures/FramebufferTexture.js";
 export * from "./textures/Source.js";
 export * from "./textures/Texture.js";
 export * from "./textures/VideoFrameTexture.js";
 export * from "./textures/VideoTexture.js";
-export { createCanvasElement } from "./utils.js";
+export { createCanvasElement, error, getConsoleFunction, log, setConsoleFunction, warn, warnOnce } from "./utils.js";

three/src/Three.TSL.d.ts

@@ -24,6 +24,8 @@ export const PCFShadowFilter: typeof TSL.PCFShadowFilter;
 export const PCFSoftShadowFilter: typeof TSL.PCFSoftShadowFilter;
 export const PI: typeof TSL.PI;
 export const PI2: typeof TSL.PI2;
+export const TWO_PI: typeof TSL.TWO_PI;
+export const HALF_PI: typeof TSL.HALF_PI;
 export const PointShadowFilter: typeof TSL.PointShadowFilter;
 export const Return: typeof TSL.Return;
 export const Schlick_to_F0: typeof TSL.Schlick_to_F0;
@@ -97,6 +99,7 @@ export const buffer: typeof TSL.buffer;
 export const bufferAttribute: typeof TSL.bufferAttribute;
 export const bumpMap: typeof TSL.bumpMap;
 export const burn: typeof TSL.burn;
+export const builtin: typeof TSL.builtin;
 export const bvec2: typeof TSL.bvec2;
 export const bvec3: typeof TSL.bvec3;
 export const bvec4: typeof TSL.bvec4;
@@ -111,6 +114,7 @@ export const cameraPosition: typeof TSL.cameraPosition;
 export const cameraProjectionMatrix: typeof TSL.cameraProjectionMatrix;
 export const cameraProjectionMatrixInverse: typeof TSL.cameraProjectionMatrixInverse;
 export const cameraViewMatrix: typeof TSL.cameraViewMatrix;
+export const cameraViewport: typeof TSL.cameraViewport;
 export const cameraWorldMatrix: typeof TSL.cameraWorldMatrix;
 export const cbrt: typeof TSL.cbrt;
 export const cdl: typeof TSL.cdl;
@@ -177,6 +181,8 @@ export const faceDirection: typeof TSL.faceDirection;
 export const faceForward: typeof TSL.faceForward;
 export const faceforward: typeof TSL.faceforward;
 export const float: typeof TSL.float;
+export const floatBitsToInt: typeof TSL.floatBitsToInt;
+export const floatBitsToUint: typeof TSL.floatBitsToUint;
 export const floor: typeof TSL.floor;
 export const fog: typeof TSL.fog;
 export const fract: typeof TSL.fract;
@@ -192,6 +198,7 @@ export const getDirection: typeof TSL.getDirection;
 export const getDistanceAttenuation: typeof TSL.getDistanceAttenuation;
 export const getGeometryRoughness: typeof TSL.getGeometryRoughness;
 export const getNormalFromDepth: typeof TSL.getNormalFromDepth;
+export const interleavedGradientNoise: typeof TSL.interleavedGradientNoise;
 export const getParallaxCorrectNormal: typeof TSL.getParallaxCorrectNormal;
 export const getRoughness: typeof TSL.getRoughness;
 export const getScreenPosition: typeof TSL.getScreenPosition;
@@ -219,6 +226,7 @@ export const instancedBufferAttribute: typeof TSL.instancedBufferAttribute;
 export const instancedDynamicBufferAttribute: typeof TSL.instancedDynamicBufferAttribute;
 export const instancedMesh: typeof TSL.instancedMesh;
 export const int: typeof TSL.int;
+export const intBitsToFloat: typeof TSL.intBitsToFloat;
 export const inverse: typeof TSL.inverse;
 export const inverseSqrt: typeof TSL.inverseSqrt;
 export const inversesqrt: typeof TSL.inversesqrt;
@@ -391,6 +399,8 @@ export const objectRadius: typeof TSL.objectRadius;
 export const objectScale: typeof TSL.objectScale;
 export const objectViewPosition: typeof TSL.objectViewPosition;
 export const objectWorldMatrix: typeof TSL.objectWorldMatrix;
+export const OnBeforeObjectUpdate: typeof TSL.OnBeforeObjectUpdate;
+export const OnBeforeMaterialUpdate: typeof TSL.OnBeforeMaterialUpdate;
 export const OnObjectUpdate: typeof TSL.OnObjectUpdate;
 export const OnMaterialUpdate: typeof TSL.OnMaterialUpdate;
 export const oneMinus: typeof TSL.oneMinus;
@@ -465,6 +475,7 @@ export const saturate: typeof TSL.saturate;
 export const saturation: typeof TSL.saturation;
 export const screen: typeof TSL.screen;
 export const screenCoordinate: typeof TSL.screenCoordinate;
+export const screenDPR: typeof TSL.screenDPR;
 export const screenSize: typeof TSL.screenSize;
 export const screenUV: typeof TSL.screenUV;
 export const scriptable: typeof TSL.scriptable;
@@ -504,15 +515,35 @@ export const storageTexture: typeof TSL.storageTexture;
 export const string: typeof TSL.string;
 export const struct: typeof TSL.struct;
 export const sub: typeof TSL.sub;
+export const subgroupAdd: typeof TSL.subgroupAdd;
+export const subgroupAll: typeof TSL.subgroupAll;
+export const subgroupAnd: typeof TSL.subgroupAnd;
+export const subgroupAny: typeof TSL.subgroupAny;
+export const subgroupBallot: typeof TSL.subgroupBallot;
+export const subgroupBroadcast: typeof TSL.subgroupBroadcast;
+export const subgroupBroadcastFirst: typeof TSL.subgroupBroadcastFirst;
 export const subBuild: typeof TSL.subBuild;
+export const subgroupElect: typeof TSL.subgroupElect;
+export const subgroupExclusiveAdd: typeof TSL.subgroupExclusiveAdd;
+export const subgroupExclusiveMul: typeof TSL.subgroupExclusiveMul;
+export const subgroupInclusiveAdd: typeof TSL.subgroupInclusiveAdd;
+export const subgroupInclusiveMul: typeof TSL.subgroupInclusiveMul;
 export const subgroupIndex: typeof TSL.subgroupIndex;
+export const subgroupMax: typeof TSL.subgroupMax;
+export const subgroupMin: typeof TSL.subgroupMin;
+export const subgroupMul: typeof TSL.subgroupMul;
+export const subgroupOr: typeof TSL.subgroupOr;
+export const subgroupShuffle: typeof TSL.subgroupShuffle;
+export const subgroupShuffleDown: typeof TSL.subgroupShuffleDown;
+export const subgroupShuffleUp: typeof TSL.subgroupShuffleUp;
+export const subgroupShuffleXor: typeof TSL.subgroupShuffleXor;
 export const subgroupSize: typeof TSL.subgroupSize;
+export const subgroupXor: typeof TSL.subgroupXor;
 export const tan: typeof TSL.tan;
 export const tangentGeometry: typeof TSL.tangentGeometry;
 export const tangentLocal: typeof TSL.tangentLocal;
 export const tangentView: typeof TSL.tangentView;
 export const tangentWorld: typeof TSL.tangentWorld;
-export const temp: typeof TSL.temp;
 export const texture: typeof TSL.texture;
 export const texture3D: typeof TSL.texture3D;
 export const textureBarrier: typeof TSL.textureBarrier;
@@ -521,12 +552,10 @@ export const textureBicubicLevel: typeof TSL.textureBicubicLevel;
 export const textureCubeUV: typeof TSL.textureCubeUV;
 export const textureLoad: typeof TSL.textureLoad;
 export const textureSize: typeof TSL.textureSize;
+export const textureLevel: typeof TSL.textureLevel;
 export const textureStore: typeof TSL.textureStore;
 export const thickness: typeof TSL.thickness;
 export const time: typeof TSL.time;
-export const timerDelta: typeof TSL.timerDelta;
-export const timerGlobal: typeof TSL.timerGlobal;
-export const timerLocal: typeof TSL.timerLocal;
 export const toneMapping: typeof TSL.toneMapping;
 export const toneMappingExposure: typeof TSL.toneMappingExposure;
 export const toonOutlinePass: typeof TSL.toonOutlinePass;
@@ -543,10 +572,12 @@ export const triplanarTexture: typeof TSL.triplanarTexture;
 export const triplanarTextures: typeof TSL.triplanarTextures;
 export const trunc: typeof TSL.trunc;
 export const uint: typeof TSL.uint;
+export const uintBitsToFloat: typeof TSL.uintBitsToFloat;
 export const uniform: typeof TSL.uniform;
 export const uniformArray: typeof TSL.uniformArray;
 export const uniformCubeTexture: typeof TSL.uniformCubeTexture;
 export const uniformGroup: typeof TSL.uniformGroup;
+export const uniformFlow: typeof TSL.uniformFlow;
 export const uniformTexture: typeof TSL.uniformTexture;
 export const unpremultiplyAlpha: typeof TSL.unpremultiplyAlpha;
 export const userData: typeof TSL.userData;
@@ -587,4 +618,4 @@ export const workgroupId: typeof TSL.workgroupId;
 export const workingToColorSpace: typeof TSL.workingToColorSpace;
 export const xor: typeof TSL.xor;
 
-export type { ProxiedObject, ShaderNodeObject, Swizzable } from "./nodes/TSL.js";
+export type { ProxiedObject, Swizzable } from "./nodes/TSL.js";

three/src/Three.WebGPU.Nodes.d.ts

@@ -16,6 +16,8 @@ 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 { default as CanvasTarget } from "./renderers/common/CanvasTarget.js";
+export { default as InspectorBase } from "./renderers/common/InspectorBase.js";
 import * as TSL from "./nodes/TSL.js";
 export { TSL };
 export { ClippingGroup } from "./objects/ClippingGroup.js";

three/src/Three.WebGPU.d.ts

@@ -16,6 +16,8 @@ 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 { default as CanvasTarget } from "./renderers/common/CanvasTarget.js";
+export { default as InspectorBase } from "./renderers/common/InspectorBase.js";
 import * as TSL from "./nodes/TSL.js";
 export { TSL };
 export { ClippingGroup } from "./objects/ClippingGroup.js";

three/src/animation/AnimationClip.d.ts

@@ -132,6 +132,11 @@ export class AnimationClip {
      * The UUID of the animation clip.
      */
     readonly uuid: string;
+    /**
+     * An object that can be used to store custom data about the animation clip.
+     * It should not hold references to functions as these will not be cloned.
+     */
+    userData: Record<string, unknown>;
     /**
      * Sets the duration of this clip to the duration of its longest keyframe track.
      *

three/src/animation/AnimationMixer.d.ts

@@ -74,7 +74,7 @@ export class AnimationMixer extends EventDispatcher<AnimationMixerEventMap> {
     /**
      * Deactivates all previously scheduled actions on this mixer.
      *
-     * @return {AnimationMixer} A reference to thi animation mixer.
+     * @return {AnimationMixer} A reference to this animation mixer.
      */
     stopAllAction(): AnimationMixer;
     /**
@@ -84,7 +84,7 @@ export class AnimationMixer extends EventDispatcher<AnimationMixerEventMap> {
      * time from {@link Clock} or {@link Timer}.
      *
      * @param {number} deltaTime - The delta time in seconds.
-     * @return {AnimationMixer} A reference to thi animation mixer.
+     * @return {AnimationMixer} A reference to this animation mixer.
      */
     update(deltaTime: number): AnimationMixer;
     /**
@@ -94,7 +94,7 @@ export class AnimationMixer extends EventDispatcher<AnimationMixerEventMap> {
      * input parameter will be scaled by {@link AnimationMixer#timeScale}
      *
      * @param {number} time - The time to set in seconds.
-     * @return {AnimationMixer} A reference to thi animation mixer.
+     * @return {AnimationMixer} A reference to this animation mixer.
      */
     setTime(time: number): AnimationMixer;
     /**

three/src/constants.d.ts

@@ -337,6 +337,7 @@ export const UnsignedShort4444Type: 1017;
 export const UnsignedShort5551Type: 1018;
 export const UnsignedInt248Type: 1020;
 export const UnsignedInt5999Type: 35902;
+export const UnsignedInt101111Type: 35899;
 
 export type AttributeGPUType = typeof FloatType | typeof IntType;
 
@@ -358,7 +359,8 @@ export type TextureDataType =
     | typeof UnsignedShort4444Type
     | typeof UnsignedShort5551Type
     | typeof UnsignedInt248Type
-    | typeof UnsignedInt5999Type;
+    | typeof UnsignedInt5999Type
+    | typeof UnsignedInt101111Type;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Pixel formats

three/src/lights/DirectionalLight.d.ts

@@ -10,7 +10,6 @@ import { Light } from "./Light.js";
  * This light will behave as though it is infinitely far away and the rays produced from it are all parallel
  * The common use case for this is to simulate daylight; the sun is far enough away that its position can be considered to be infinite, and all light rays coming from it are parallel.
  * A common point of confusion for directional lights is that setting the rotation has no effect
- * @remarks
  * This is because three.js's {@link DirectionalLight} is the equivalent to what is often called a 'Target Direct Light' in other applications.
  * This means that its direction is calculated as pointing from the light's {@link THREE.Object3D.position | position} to the {@link THREE.DirectionalLight.target | target}'s
  * position (as opposed to a 'Free Direct Light' that just has a rotation component).

three/src/loaders/ObjectLoader.d.ts

@@ -23,9 +23,9 @@ export class ObjectLoader extends Loader<Object3D> {
     parseGeometries(json: unknown): { [key: string]: InstancedBufferGeometry | BufferGeometry };
     parseMaterials(json: unknown, textures: { [key: string]: Texture }): { [key: string]: Material };
     parseAnimations(json: unknown): { [key: string]: AnimationClip };
-    parseImages(json: unknown, onLoad?: () => void): { [key: string]: Source };
-    parseImagesAsync(json: unknown): Promise<{ [key: string]: Source }>;
-    parseTextures(json: unknown, images: { [key: string]: Source }): { [key: string]: Texture };
+    parseImages(json: unknown, onLoad?: () => void): { [key: string]: Source<unknown> };
+    parseImagesAsync(json: unknown): Promise<{ [key: string]: Source<unknown> }>;
+    parseTextures(json: unknown, images: { [key: string]: Source<unknown> }): { [key: string]: Texture };
     parseObject(
         data: unknown,
         geometries: { [key: string]: InstancedBufferGeometry | BufferGeometry },

three/src/loaders/TextureLoader.d.ts

@@ -6,13 +6,13 @@ import { LoadingManager } from "./LoadingManager.js";
  * Class for loading a texture.
  * Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object.
  */
-export class TextureLoader extends Loader<Texture> {
+export class TextureLoader extends Loader<Texture<HTMLImageElement>> {
     constructor(manager?: LoadingManager);
 
     load(
         url: string,
-        onLoad?: (data: Texture) => void,
+        onLoad?: (data: Texture<HTMLImageElement>) => void,
         onProgress?: (event: ProgressEvent) => void,
         onError?: (err: unknown) => void,
-    ): Texture;
+    ): Texture<HTMLImageElement>;
 }

three/src/materials/LineBasicMaterial.d.ts

@@ -81,6 +81,7 @@ export class LineBasicMaterial extends Material {
      * @default true
      */
     readonly isLineBasicMaterial: boolean;
+    setValues(values?: LineBasicMaterialParameters): void;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/materials/LineDashedMaterial.d.ts

@@ -49,6 +49,7 @@ export class LineDashedMaterial extends LineBasicMaterial {
      * @default true
      */
     readonly isLineDashedMaterial: boolean;
+    setValues(values?: LineDashedMaterialParameters): void;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/materials/Material.d.ts

@@ -541,7 +541,7 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      * The type property is used for detecting the object type
      * in context of serialization/deserialization.
      */
-    readonly type: string;
+    type: string;
     /**
      * This starts at `0` and counts how many times {@link Material#needsUpdate} is set to `true`.
      *
@@ -575,7 +575,7 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      *
      * This method can only be used when rendering with {@link WebGLRenderer}. The
      * recommended approach when customizing materials is to use `WebGPURenderer` with the new
-     * Node Material system and [TSL]{@link https://github.com/mrdoob/three.js/wiki/Three.js-Shading-Language}.
+     * Node Material system and [TSL](https://github.com/mrdoob/three.js/wiki/Three.js-Shading-Language).
      *
      * @param {{vertexShader:string,fragmentShader:string,uniforms:Object}} shaderobject - The object holds the uniforms and the vertex and fragment shader source.
      * @param {WebGLRenderer} renderer - A reference to the renderer.

three/src/materials/MeshBasicMaterial.d.ts

@@ -167,6 +167,7 @@ export class MeshBasicMaterial extends Material {
      * @default true
      */
     readonly isMeshBasicMaterial: boolean;
+    setValues(values?: MeshBasicMaterialParameters): void;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/materials/MeshDepthMaterial.d.ts

@@ -99,6 +99,7 @@ export class MeshDepthMaterial extends Material {
      * @default true
      */
     readonly isMeshDepthMaterial: boolean;
+    setValues(values?: MeshDepthMaterialParameters): void;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/materials/MeshDistanceMaterial.d.ts

@@ -63,7 +63,7 @@ export interface MeshDistanceMaterialParameters
  * Can also be used to customize the shadow casting of an object by assigning
  * an instance of `MeshDistanceMaterial` to {@link Object3D#customDistanceMaterial}.
  * The following examples demonstrates this approach in order to ensure
- * transparent parts of objects do no cast shadows.
+ * transparent parts of objects do not cast shadows.
  */
 export class MeshDistanceMaterial extends Material {
     /**
@@ -82,6 +82,7 @@ export class MeshDistanceMaterial extends Material {
      * @default true
      */
     readonly isMeshDistanceMaterial: boolean;
+    setValues(values?: MeshDistanceMaterialParameters): void;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/materials/MeshLambertMaterial.d.ts

@@ -241,7 +241,7 @@ export interface MeshLambertMaterialParameters
 /**
  * A material for non-shiny surfaces, without specular highlights.
  *
- * The material uses a non-physically based [Lambertian]{@link https://en.wikipedia.org/wiki/Lambertian_reflectance}
+ * The material uses a non-physically based [Lambertian](https://en.wikipedia.org/wiki/Lambertian_reflectance)
  * model for calculating reflectance. This can simulate some surfaces (such
  * as untreated wood or stone) well, but cannot simulate shiny surfaces with
  * specular highlights (such as varnished wood). `MeshLambertMaterial` uses per-fragment
@@ -269,6 +269,7 @@ export class MeshLambertMaterial extends Material {
      * @default true
      */
     readonly isMeshLambertMaterial: boolean;
+    setValues(values?: MeshLambertMaterialParameters): void;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/materials/MeshMatcapMaterial.d.ts

@@ -103,6 +103,20 @@ export interface MeshMatcapMaterialProperties extends MaterialProperties {
      * @default null
      */
     alphaMap: Texture | null;
+    /**
+     * Renders the geometry as a wireframe.
+     *
+     * @default false
+     */
+    wireframe: boolean;
+    /**
+     * Controls the thickness of the wireframe.
+     *
+     * Can only be used with {@link SVGRenderer}.
+     *
+     * @default 1
+     */
+    wireframeLinewidth: number;
     /**
      * Whether the material is rendered with flat shading or not.
      *
@@ -148,6 +162,7 @@ export class MeshMatcapMaterial extends Material {
      * @default true
      */
     readonly isMeshMatcapMaterial: boolean;
+    setValues(values?: MeshMatcapMaterialParameters): void;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/materials/MeshNormalMaterial.d.ts

@@ -117,6 +117,7 @@ export class MeshNormalMaterial extends Material {
      * @default true
      */
     readonly isMeshNormalMaterial: boolean;
+    setValues(values?: MeshNormalMaterialParameters): void;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/materials/MeshPhongMaterial.d.ts

@@ -255,7 +255,7 @@ export interface MeshPhongMaterialParameters
 /**
  * A material for shiny surfaces with specular highlights.
  *
- * The material uses a non-physically based [Blinn-Phong]{@link https://en.wikipedia.org/wiki/Blinn-Phong_shading_model}
+ * The material uses a non-physically based [Blinn-Phong](https://en.wikipedia.org/wiki/Blinn-Phong_shading_model)
  * model for calculating reflectance. Unlike the Lambertian model used in the
  * {@link MeshLambertMaterial} this can simulate shiny surfaces with specular
  * highlights (such as varnished wood). `MeshPhongMaterial` uses per-fragment shading.
@@ -281,6 +281,7 @@ export class MeshPhongMaterial extends Material {
      * @default true
      */
     readonly isMeshPhongMaterial: boolean;
+    setValues(values?: MeshPhongMaterialParameters): void;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -195,7 +195,7 @@ export interface MeshPhysicalMaterialProperties extends MeshStandardMaterialProp
     specularColorMap: Texture | null;
     set anisotropy(value: number);
     /**
-     * The anisotropy strength.
+     * The anisotropy strength, from `0.0` to `1.0`.
      *
      * @default 0
      */

three/src/materials/MeshStandardMaterial.d.ts

@@ -249,9 +249,9 @@ export interface MeshStandardMaterialParameters
  * A standard physically based material, using Metallic-Roughness workflow.
  *
  * Physically based rendering (PBR) has recently become the standard in many
- * 3D applications, such as [Unity]{@link https://blogs.unity3d.com/2014/10/29/physically-based-shading-in-unity-5-a-primer/},
- * [Unreal]{@link https://docs.unrealengine.com/latest/INT/Engine/Rendering/Materials/PhysicallyBased/} and
- * [3D Studio Max]{@link http://area.autodesk.com/blogs/the-3ds-max-blog/what039s-new-for-rendering-in-3ds-max-2017}.
+ * 3D applications, such as [Unity](https://blogs.unity3d.com/2014/10/29/physically-based-shading-in-unity-5-a-primer/),
+ * [Unreal](https://docs.unrealengine.com/latest/INT/Engine/Rendering/Materials/PhysicallyBased/) and
+ * [3D Studio Max](http://area.autodesk.com/blogs/the-3ds-max-blog/what039s-new-for-rendering-in-3ds-max-2017).
  *
  * This approach differs from older approaches in that instead of using
  * approximations for the way in which light interacts with a surface, a
@@ -267,13 +267,13 @@ export interface MeshStandardMaterialParameters
  * Note that for best results you should always specify an environment map when using this material.
  *
  * For a non-technical introduction to the concept of PBR and how to set up a
- * PBR material, check out these articles by the people at [marmoset]{@link https://www.marmoset.co}:
+ * PBR material, check out these articles by the people at [marmoset](https://www.marmoset.co):
  *
- * - [Basic Theory of Physically Based Rendering]{@link https://www.marmoset.co/posts/basic-theory-of-physically-based-rendering/}
- * - [Physically Based Rendering and You Can Too]{@link https://www.marmoset.co/posts/physically-based-rendering-and-you-can-too/}
+ * - [Basic Theory of Physically Based Rendering](https://www.marmoset.co/posts/basic-theory-of-physically-based-rendering/)
+ * - [Physically Based Rendering and You Can Too](https://www.marmoset.co/posts/physically-based-rendering-and-you-can-too/)
  *
  * Technical details of the approach used in three.js (and most other PBR systems) can be found is this
- * [paper from Disney]{@link https://media.disneyanimation.com/uploads/production/publication_asset/48/asset/s2012_pbs_disney_brdf_notes_v3.pdf}
+ * [paper from Disney](https://media.disneyanimation.com/uploads/production/publication_asset/48/asset/s2012_pbs_disney_brdf_notes_v3.pdf)
  * (pdf), by Brent Burley.
  */
 export class MeshStandardMaterial extends Material {

three/src/materials/MeshToonMaterial.d.ts

@@ -216,6 +216,7 @@ export class MeshToonMaterial extends Material {
      * @default true
      */
     readonly isMeshToonMaterial: boolean;
+    setValues(values?: MeshToonMaterialParameters): void;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/materials/PointsMaterial.d.ts

@@ -33,7 +33,7 @@ export interface PointsMaterialProperties extends MaterialProperties {
     /**
      * Defines the size of the points in pixels.
      *
-     * Might be capped if the value exceeds hardware dependent parameters like [gl.ALIASED_POINT_SIZE_RANGE]{@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getParamete}.
+     * Might be capped if the value exceeds hardware dependent parameters like [gl.ALIASED_POINT_SIZE_RANGE](https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getParamete).
      *
      * @default 1
      */
@@ -97,6 +97,7 @@ export class PointsMaterial extends Material {
      * @default true
      */
     readonly isPointsMaterial: boolean;
+    setValues(values?: PointsMaterialParameters): void;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface