@types/three 0.180.0 → 0.181.0

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Node, Object3D, Scene, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 export interface OutlineNodeParams {
@@ -12,21 +11,21 @@ declare class OutlineNode extends TempNode {
     scene: Scene;
     camera: Camera;
     selectedObjects: Object3D[];
-    edgeThicknessNode: ShaderNodeObject<UniformNode<number>>;
-    edgeGlowNode: ShaderNodeObject<UniformNode<number>>;
+    edgeThicknessNode: UniformNode<number>;
+    edgeGlowNode: UniformNode<number>;
     downSampleRatio: number;
 
     constructor(scene: Scene, camera: Camera, params?: OutlineNodeParams);
 
-    get visibleEdge(): ShaderNodeObject<Node>;
+    get visibleEdge(): Node;
 
-    get hiddenEdge(): ShaderNodeObject<Node>;
+    get hiddenEdge(): Node;
 
-    getTextureNode(): ShaderNodeObject<TextureNode>;
+    getTextureNode(): TextureNode;
 
     setSize(width: number, height: number): void;
 }
 
 export default OutlineNode;
 
-export const outline: (scene: Scene, camera: Camera, params?: OutlineNodeParams) => ShaderNodeObject<OutlineNode>;
+export const outline: (scene: Scene, camera: Camera, params?: OutlineNodeParams) => OutlineNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Scene } from "three/webgpu";
 import StereoCompositePassNode from "./StereoCompositePassNode.js";
 
@@ -10,4 +9,4 @@ declare class ParallaxBarrierPassNode extends StereoCompositePassNode {
 
 export default ParallaxBarrierPassNode;
 
-export const parallaxBarrierPass: (scene: Scene, camera: Camera) => ShaderNodeObject<ParallaxBarrierPassNode>;
+export const parallaxBarrierPass: (scene: Scene, camera: Camera) => ParallaxBarrierPassNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, PassNode, Scene, UniformNode } from "three/webgpu";
 
 declare class PixelationPassNode extends PassNode {
@@ -23,6 +22,6 @@ export const pixelationPass: (
     pixelSize: UniformNode<number>,
     normalEdgeStrength: UniformNode<number>,
     depthEdgeStrength: UniformNode<number>,
-) => ShaderNodeObject<PixelationPassNode>;
+) => PixelationPassNode;
 
 export default PixelationPassNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 export default class RGBShiftNode extends TempNode {
@@ -13,4 +12,4 @@ export default class RGBShiftNode extends TempNode {
     setSize(width: number, height: number): void;
 }
 
-export const rgbShift: (node: Node, amount?: number, angle?: number) => ShaderNodeObject<RGBShiftNode>;
+export const rgbShift: (node: Node, amount?: number, angle?: number) => RGBShiftNode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node, TempNode, TextureNode } from "three/webgpu";
 
 declare class SMAANode extends TempNode {
@@ -15,4 +14,4 @@ declare class SMAANode extends TempNode {
     getSearchTexture(): string;
 }
 
-export const smaa: (node: Node) => ShaderNodeObject<SMAANode>;
+export const smaa: (node: Node) => SMAANode;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Color, PassNode, RenderTarget, Scene, UniformNode } from "three/webgpu";
 
 declare class SSAAPassNode extends PassNode {
@@ -18,4 +17,4 @@ declare class SSAAPassNode extends PassNode {
 
 export default SSAAPassNode;
 
-export const ssaaPass: (scene: Scene, camera: Camera) => ShaderNodeObject<SSAAPassNode>;
+export const ssaaPass: (scene: Scene, camera: Camera) => SSAAPassNode;

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

@@ -0,0 +1,30 @@
+import { Node, PerspectiveCamera, TempNode, UniformNode } from "three/webgpu";
+
+declare class SSGINode extends TempNode {
+    beautyNode: Node;
+    depthNode: Node;
+    normalNode: Node;
+
+    sliceCount: UniformNode<number>;
+    stepCount: UniformNode<number>;
+    aoIntensity: UniformNode<number>;
+    giIntensity: UniformNode<number>;
+    radius: UniformNode<number>;
+    useScreenSpaceSampling: UniformNode<boolean>;
+    expFactor: UniformNode<number>;
+    thickness: UniformNode<number>;
+    useLinearThickness: UniformNode<boolean>;
+    backfaceLighting: UniformNode<number>;
+    useTemporalFiltering: boolean;
+
+    constructor(beautyNode: Node, depthNode: Node, normalNode: Node, camera: PerspectiveCamera);
+}
+
+export default SSGINode;
+
+export const ssgi: (
+    beautyNode: Node,
+    depthNode: Node,
+    normalNode: Node,
+    camera: PerspectiveCamera,
+) => SSGINode;

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

@@ -1,12 +1,11 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Camera, Node, TempNode, TextureNode, UniformNode } from "three/webgpu";
 
 declare class SSRNode extends TempNode {
-    colorNode: ShaderNodeObject<Node>;
-    depthNode: ShaderNodeObject<Node>;
-    normalNode: ShaderNodeObject<Node>;
-    metalnessNode: ShaderNodeObject<Node>;
-    roughnessNode: ShaderNodeObject<Node> | null;
+    colorNode: Node;
+    depthNode: Node;
+    normalNode: Node;
+    metalnessNode: Node;
+    roughnessNode: Node | null;
     camera: Camera | null;
 
     resolutionScale: number;
@@ -18,15 +17,15 @@ declare class SSRNode extends TempNode {
     blurQuality: UniformNode<number>;
 
     constructor(
-        colorNode: ShaderNodeObject<Node>,
-        depthNode: ShaderNodeObject<Node>,
-        normalNode: ShaderNodeObject<Node>,
-        metalnessNode: ShaderNodeObject<Node>,
-        roughnessNode?: ShaderNodeObject<Node> | null,
+        colorNode: Node,
+        depthNode: Node,
+        normalNode: Node,
+        metalnessNode: Node,
+        roughnessNode?: Node | null,
         camera?: Camera | null,
     );
 
-    getTextureNode(): ShaderNodeObject<TextureNode>;
+    getTextureNode(): TextureNode;
 
     setSize(width: number, height: number): void;
 }
@@ -40,4 +39,4 @@ export const ssr: (
     metalnessNode: Node,
     roughnessNode?: Node | null,
     camera?: Camera | null,
-) => ShaderNodeObject<SSRNode>;
+) => SSRNode;

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

@@ -0,0 +1,18 @@
+import { Camera, DirectionalLight, TempNode, TextureNode, UniformNode } from "three/webgpu";
+
+declare class SSSNode extends TempNode {
+    depthNode: TextureNode;
+
+    maxDistance: UniformNode<number>;
+    thickness: UniformNode<number>;
+    shadowIntensity: UniformNode<number>;
+    quality: UniformNode<number>;
+    resolutionScale: number;
+    useTemporalFiltering: boolean;
+
+    constructor(depthNode: TextureNode, camera: Camera, mainLight: DirectionalLight);
+}
+
+export default SSSNode;
+
+export const sss: (depthNode: TextureNode, camera: Camera, mainLight: DirectionalLight) => SSSNode;

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

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

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
 export interface BoxBlurOptions {
@@ -8,4 +7,4 @@ export interface BoxBlurOptions {
     premultipliedAlpha?: boolean | undefined;
 }
 
-export const boxBlur: (textureNode: Node, options?: BoxBlurOptions) => ShaderNodeObject<Node>;
+export const boxBlur: (textureNode: Node, options?: BoxBlurOptions) => Node;

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

@@ -1,4 +1,3 @@
-import { ShaderNodeObject } from "three/tsl";
 import { Node } from "three/webgpu";
 
 interface HashBlurOptions {
@@ -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.180.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": "b06ef6e25296a342a8cb4449c825b5786ae345270e744fa27908d1cb8d51f547",
+    "typesPublisherContentHash": "d4f610987bd76c1162c3a6a2221b72979499c9bc94a8d25712df1534d6b1bb87",
     "typeScriptVersion": "5.2"
 }

three/src/Three.Core.d.ts

@@ -160,4 +160,4 @@ 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;
@@ -196,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;
@@ -396,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;
@@ -547,6 +552,7 @@ 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;
@@ -612,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/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/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/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/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

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.
      *

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.

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/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
      */

three/src/materials/ShaderMaterial.d.ts

@@ -130,7 +130,7 @@ export interface ShaderMaterialProperties extends MaterialProperties {
         uv1: [number, number];
     };
     /**
-     * If set, this calls [gl.bindAttribLocation]{@link https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/bindAttribLocation}
+     * If set, this calls [gl.bindAttribLocation](https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/bindAttribLocation)
      * to bind a generic vertex index to an attribute variable.
      *
      * @default undefined
@@ -209,7 +209,7 @@ export interface ShaderMaterialJSON extends MaterialJSON {
  * - You can use the directive `#pragma unroll_loop_start` and `#pragma unroll_loop_end`
  * in order to unroll a `for` loop in GLSL by the shader preprocessor. The directive has
  * to be placed right above the loop. The loop formatting has to correspond to a defined standard.
- *   - The loop has to be [normalized]{@link https://en.wikipedia.org/wiki/Normalized_loop}.
+ *   - The loop has to be [normalized](https://en.wikipedia.org/wiki/Normalized_loop).
  *   - The loop variable has to be *i*.
  *   - The value `UNROLLED_LOOP_INDEX` will be replaced with the explicitly
  * value of *i* for the given iteration and can be used in preprocessor
@@ -217,12 +217,12 @@ export interface ShaderMaterialJSON extends MaterialJSON {
  *
  * ```js
  * const material = new THREE.ShaderMaterial( {
- * 	uniforms: {
- * 		time: { value: 1.0 },
- * 		resolution: { value: new THREE.Vector2() }
- * 	},
- * 	vertexShader: document.getElementById( 'vertexShader' ).textContent,
- * 	fragmentShader: document.getElementById( 'fragmentShader' ).textContent
+ *    uniforms: {
+ *        time: { value: 1.0 },
+ *        resolution: { value: new THREE.Vector2() }
+ *    },
+ *    vertexShader: document.getElementById( 'vertexShader' ).textContent,
+ *    fragmentShader: document.getElementById( 'fragmentShader' ).textContent
  * } );
  * ```
  */

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

@@ -40,7 +40,7 @@ declare class SSSLightingModel extends PhysicalLightingModel {
     /**
      * Extends the default implementation with a SSS term.
      *
-     * Reference: [Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look]{@link https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/}
+     * Reference: [Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look](https://colinbarrebrisebois.com/2011/03/07/gdc-2011-approximating-translucency-for-a-fast-cheap-and-convincing-subsurface-scattering-look/)
      *
      * @param {Object} input - The input data.
      * @param {NodeBuilder} builder - The current node builder.