@types/three 0.162.0 → 0.163.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: Thu, 29 Feb 2024 18:08:09 GMT
+ * Last updated: Fri, 29 Mar 2024 19:35:33 GMT
  * Dependencies: [@tweenjs/tween.js](https://npmjs.com/package/@tweenjs/tween.js), [@types/stats.js](https://npmjs.com/package/@types/stats.js), [@types/webxr](https://npmjs.com/package/@types/webxr), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

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

@@ -14,7 +14,7 @@ export interface OrbitControlsEventMap {
  * event listeners.
  */
 export class OrbitControls extends EventDispatcher<OrbitControlsEventMap> {
-    constructor(object: Camera, domElement?: HTMLElement);
+    constructor(object: Camera, domElement: HTMLElement);
 
     /**
      * The camera being controlled.

three/examples/jsm/geometries/TextGeometry.d.ts

@@ -16,9 +16,17 @@ export interface TextGeometryParameters extends ExtrudeGeometryOptions {
      * Thickness to extrude text.
      * Expects a `Float`.
      * @defaultValue `50`
+     * @deprecated THREE.TextGeometry: .height is now depreciated. Please use .depth instead
      */
     height?: number | undefined;
 
+    /**
+     * Thickness to extrude text.
+     * Expects a `Float`.
+     * @defaultValue `50`
+     */
+    depth?: number | undefined;
+
     /**
      * @override
      * @defaultValue `12`

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

@@ -1,5 +1,17 @@
 import { Loader, LoadingManager, Shape } from "three";
 
+export interface FontData {
+    glyphs: Record<string, { ha: number; x_min: number; x_max: number; o: string }>;
+    familyName: string;
+    ascender: number;
+    descender: number;
+    underlinePosition: number;
+    underlineThickness: number;
+    boundingBox: { yMin: number; xMin: number; yMax: number; xMax: number };
+    resolution: number;
+    original_font_information: Record<string, string>;
+}
+
 export class FontLoader extends Loader<Font> {
     constructor(manager?: LoadingManager);
 
@@ -10,18 +22,20 @@ export class FontLoader extends Loader<Font> {
         onError?: (err: unknown) => void,
     ): void;
 
-    parse(json: any): Font;
+    parse(json: FontData): Font;
 }
 
 export class Font {
-    constructor(jsondata: any);
+    readonly isFont: true;
 
     /**
      * @default 'Font'
      */
     type: string;
 
-    data: string;
+    data: FontData;
+
+    constructor(data: FontData);
 
-    generateShapes(text: string, size: number): Shape[];
+    generateShapes(text: string, size?: number): Shape[];
 }

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

@@ -1,8 +1,7 @@
-import { Data3DTexture, DataTexture, FloatType, Loader, LoadingManager, UnsignedByteType } from "three";
+import { Data3DTexture, FloatType, Loader, LoadingManager, UnsignedByteType } from "three";
 
 export interface LUT3dlResult {
     size: number;
-    texture: DataTexture;
     texture3D: Data3DTexture;
 }
 

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

@@ -1,11 +1,10 @@
-import { Data3DTexture, DataTexture, FloatType, Loader, LoadingManager, UnsignedByteType, Vector3 } from "three";
+import { Data3DTexture, FloatType, Loader, LoadingManager, UnsignedByteType, Vector3 } from "three";
 
 export interface LUTCubeResult {
     title: string;
     size: number;
     domainMin: Vector3;
     domainMax: Vector3;
-    texture: DataTexture;
     texture3D: Data3DTexture;
 }
 

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

@@ -24,6 +24,11 @@ export class RGBMLoader extends DataTextureLoader {
         onError?: (event: ErrorEvent) => void,
     ): CubeTexture;
 
+    loadCubemapAsync(
+        urls: string[],
+        onProgress?: (event: ProgressEvent) => void,
+    ): Promise<CubeTexture>;
+
     parse(buffer: ArrayBuffer): RGBM;
 
     setDataType(dataType: TextureDataType): this;

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

@@ -1,8 +1,10 @@
 import { Loader, LoadingManager } from "three";
+import { FontData } from "./FontLoader.js";
 
-export class TTFLoader extends Loader<object> {
-    constructor(manager?: LoadingManager);
+export class TTFLoader extends Loader<FontData> {
     reversed: boolean;
 
-    parse(arraybuffer: ArrayBuffer): object;
+    constructor(manager?: LoadingManager);
+
+    parse(arraybuffer: ArrayBuffer): FontData;
 }

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

@@ -169,7 +169,6 @@ export { default as ReflectorNode, reflector, ReflectorNodeParameters } from "./
 export { default as RemapNode, remap, remapClamp } from "./utils/RemapNode.js";
 export { default as RotateNode, rotate } from "./utils/RotateNode.js";
 export { default as RotateUVNode, rotateUV } from "./utils/RotateUVNode.js";
-export { default as SpecularMIPLevelNode, specularMIPLevel } from "./utils/SpecularMIPLevelNode.js";
 export { default as SplitNode } from "./utils/SplitNode.js";
 export { default as SpriteSheetUVNode, spritesheetUV } from "./utils/SpriteSheetUVNode.js";
 export { default as StorageArrayElementNode } from "./utils/SpriteSheetUVNode.js";
@@ -192,6 +191,7 @@ export * from "./shadernode/ShaderNode.js";
 
 // accessors
 export { parallaxDirection, parallaxUV, TBNViewMatrix } from "./accessors/AccessorsUtils.js";
+export { batch, default as BatchNode } from "./accessors/BatchNode.js";
 export {
     bitangentGeometry,
     bitangentLocal,
@@ -275,6 +275,7 @@ export {
 } from "./accessors/PositionNode.js";
 export { default as ReferenceNode, reference, referenceBuffer } from "./accessors/ReferenceNode.js";
 export { default as ReflectVectorNode, reflectVector } from "./accessors/ReflectVectorNode.js";
+export { default as RendererReferenceNode, rendererReference } from "./accessors/RendererReferenceNode.js";
 export { default as SkinningNode, skinning } from "./accessors/SkinningNode.js";
 export { default as StorageBufferNode, storage, storageObject } from "./accessors/StorageBufferNode.js";
 export {
@@ -375,6 +376,9 @@ export { default as LightsNode, lights } from "./lighting/LightsNode.js";
 export { default as PointLightNode } from "./lighting/PointLightNode.js";
 export { default as SpotLightNode } from "./lighting/SpotLightNode.js";
 
+// pmrem
+export { default as PMREMNode, pmremTexture } from "./pmrem/PMREMNode.js";
+
 // procedural
 export { checker, default as CheckerNode } from "./procedural/CheckerNode.js";
 

three/examples/jsm/nodes/accessors/BatchNode.d.ts

@@ -0,0 +1,14 @@
+import { BatchedMesh } from "three";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class BatchNode extends Node {
+    batchMesh: BatchedMesh;
+
+    instanceColorNode: Node | null;
+    batchingIdNode: Node | null;
+
+    constructor(batchMesh: BatchedMesh);
+}
+
+export const batch: (batchMesh: BatchedMesh) => ShaderNodeObject<BatchNode>;

three/examples/jsm/nodes/accessors/InstanceNode.d.ts

@@ -4,7 +4,8 @@ import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class InstanceNode extends Node {
     instanceMesh: InstancedMesh;
-    instanceMatrixNode: Node;
+    instanceMatrixNode: Node | null;
+    instanceColorNode: Node | null;
 
     constructor(instanceMesh: InstancedMesh);
 }

three/examples/jsm/nodes/accessors/RendererReferenceNode.d.ts

@@ -0,0 +1,16 @@
+import Renderer from "../../renderers/common/Renderer.js";
+import { NodeTypeOption } from "../core/constants.js";
+import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import ReferenceNode from "./ReferenceNode.js";
+
+export default class RendererReferenceNode extends ReferenceNode<Renderer> {
+    renderer: Renderer | null;
+
+    constructor(property: string, inputType: NodeTypeOption, renderer?: Renderer | null);
+}
+
+export const rendererReference: (
+    name: string,
+    type: NodeTypeOption,
+    renderer?: Renderer | null,
+) => ShaderNodeObject<RendererReferenceNode>;

three/examples/jsm/nodes/accessors/TextureNode.d.ts

@@ -4,10 +4,17 @@ import UniformNode from "../core/UniformNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class TextureNode extends UniformNode<Texture> {
-    isTextureNode: true;
+    readonly isTextureNode: true;
 
     uvNode: ShaderNodeObject<Node> | null;
     levelNode: ShaderNodeObject<Node> | null;
+    compareNode: Node | null;
+    depthNode: Node | null;
+
+    sampler: boolean;
+    updateMatrix: boolean;
+
+    referenceNode: Node | null;
 
     constructor(value: Texture, uvNode?: ShaderNodeObject<Node>, levelNode?: ShaderNodeObject<Node> | null);
 

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

@@ -3,8 +3,6 @@ import NodeBuilder from "./NodeBuilder.js";
 import NodeFrame from "./NodeFrame.js";
 
 export default abstract class Node {
-    readonly isNode: true;
-
     nodeType: NodeTypeOption | null;
 
     updateType: NodeUpdateType;
@@ -12,17 +10,23 @@ export default abstract class Node {
 
     uuid: string;
 
+    version: number;
+
+    readonly isNode: true;
+
     readonly id: number;
 
     constructor(nodeType?: NodeTypeOption | null);
 
+    set needsUpdate(value: boolean);
+
     get type(): number;
 
     isGlobal(builder: NodeBuilder): boolean;
 
     getChildren(): Node[];
 
-    getCacheKey(): string;
+    getCacheKey(force?: boolean): string;
 
     getHash(builder: NodeBuilder): string;
 

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

@@ -7,7 +7,7 @@ export interface NodeChild {
     childNode: Node;
 }
 
-export function getCacheKey(object: Node): string;
+export function getCacheKey(object: Node, force?: boolean): string;
 export function getNodeChildren(object: Node): Generator<NodeChild, void>;
 export function getValueType(value: unknown): string | null;
 export function getValueFromType(

three/examples/jsm/nodes/display/PassNode.d.ts

@@ -25,6 +25,8 @@ export default class PassNode extends TempNode {
 
     getTextureDepthNode(): ShaderNodeObject<PassTextureNode>;
 
+    getViewZNode(): ShaderNodeObject<Node>;
+
     getDepthNode(): ShaderNodeObject<Node>;
 
     setSize(width: number, height: number): void;

three/examples/jsm/nodes/display/ToneMappingNode.d.ts

@@ -1,4 +1,5 @@
 import { ToneMapping } from "three";
+import RendererReferenceNode from "../accessors/RendererReferenceNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
@@ -19,3 +20,14 @@ export const toneMapping: (
     exposure: NodeRepresentation,
     color?: NodeRepresentation,
 ) => ShaderNodeObject<ToneMappingNode>;
+export const toneMappingExposure: ShaderNodeObject<RendererReferenceNode>;
+
+declare module "../shadernode/ShaderNode.js" {
+    interface NodeElements {
+        toneMapping: (
+            color: NodeRepresentation,
+            mapping?: NodeRepresentation,
+            exposure?: NodeRepresentation,
+        ) => ShaderNodeObject<ToneMappingNode>;
+    }
+}

three/examples/jsm/nodes/fog/FogNode.d.ts

@@ -1,16 +1,21 @@
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
 import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 
 export default class FogNode extends Node {
     isFogNode: true;
-    colorNode: Node;
-    factorNode: Node;
+    colorNode: Node | null;
+    factorNode: Node | null;
 
-    constructor(colorNode: Node, factorNode: Node);
-    mixAssign(outputNode: Node): Node;
+    constructor(colorNode: Node | null, factorNode: Node | null);
+
+    getViewZNode(builder: NodeBuilder): Node;
 }
 
-export const fog: (colorNode: NodeRepresentation, factorNode: NodeRepresentation) => ShaderNodeObject<FogNode>;
+export const fog: (
+    colorNode: NodeRepresentation | null,
+    factorNode: NodeRepresentation | null,
+) => ShaderNodeObject<FogNode>;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {

three/examples/jsm/nodes/fog/FogRangeNode.d.ts

@@ -1,16 +1,20 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import FogNode from "./FogNode.js";
 
 export default class FogRangeNode extends FogNode {
     isFogRangeNode: true;
-    nearNode: Node;
-    farNode: Node;
+    nearNode: Node | null;
+    farNode: Node | null;
 
-    constructor(colorNode: Node, nearNode: Node, farNode: Node);
+    constructor(colorNode: Node | null, nearNode: Node | null, farNode: Node | null);
 }
 
-export const rangeFog: (colorNode: Node, nearNode: Node, farNode: Node) => ShaderNodeObject<FogRangeNode>;
+export const rangeFog: (
+    colorNode: NodeRepresentation | null,
+    nearNode: NodeRepresentation | null,
+    farNode: NodeRepresentation | null,
+) => ShaderNodeObject<FogRangeNode>;
 
 declare module "../shadernode/ShaderNode.js" {
     interface NodeElements {

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

@@ -1,5 +1,6 @@
 export { default as LineBasicNodeMaterial } from "./LineBasicNodeMaterial.js";
 export { default as MeshBasicNodeMaterial } from "./MeshBasicNodeMaterial.js";
+export { default as MeshNormalNodeMaterial } from "./MeshNormalNodeMaterial.js";
 export { default as MeshPhongNodeMaterial } from "./MeshPhongNodeMaterial.js";
 export { default as MeshPhysicalNodeMaterial } from "./MeshPhysicalNodeMaterial.js";
 export { default as MeshSSSPhysicalNodeMaterial } from "./MeshSSSNodeMaterial.js";

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

@@ -0,0 +1,23 @@
+import { MeshNormalMaterialParameters, NormalMapTypes, Texture, Vector2 } from "three";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshNormalMaterialParameters {
+}
+
+export default class MeshNormalNodeMaterial extends NodeMaterial {
+    readonly isMeshNormalNodeMaterial: true;
+
+    // Properties from MeshNormalMaterial
+    readonly isMeshNormalMaterial: true;
+    bumpMap: Texture | null;
+    bumpScale: number;
+    normalMap: Texture | null;
+    normalMapType: NormalMapTypes;
+    normalScale: Vector2;
+    displacementMap: Texture | null;
+    displacementScale: number;
+    displacementBias: number;
+    flatShading: boolean;
+
+    constructor(parameters?: MeshBasicNodeMaterialParameters);
+}

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

@@ -2,6 +2,7 @@ import {
     LineBasicMaterial,
     Material,
     MeshBasicMaterial,
+    MeshNormalMaterial,
     MeshPhongMaterial,
     MeshPhysicalMaterial,
     MeshStandardMaterial,
@@ -18,6 +19,7 @@ import LightsNode from "../lighting/LightsNode.js";
 import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
 import LineBasicNodeMaterial from "./LineBasicNodeMaterial.js";
 import MeshBasicNodeMaterial from "./MeshBasicNodeMaterial.js";
+import MeshNormalNodeMaterial from "./MeshNormalNodeMaterial.js";
 import MeshPhongNodeMaterial from "./MeshPhongNodeMaterial.js";
 import MeshPhysicalNodeMaterial from "./MeshPhysicalNodeMaterial.js";
 import MeshStandardNodeMaterial from "./MeshStandardNodeMaterial.js";
@@ -97,6 +99,7 @@ export default class NodeMaterial extends ShaderMaterial {
 
     static fromMaterial(material: LineBasicMaterial): LineBasicNodeMaterial;
     static fromMaterial(material: MeshBasicMaterial): MeshBasicNodeMaterial;
+    static fromMaterial(material: MeshNormalMaterial): MeshNormalNodeMaterial;
     static fromMaterial(material: MeshPhongMaterial): MeshPhongNodeMaterial;
     static fromMaterial(material: MeshPhysicalMaterial): MeshPhysicalNodeMaterial;
     static fromMaterial(material: MeshStandardMaterial): MeshStandardNodeMaterial;

three/examples/jsm/nodes/pmrem/PMREMNode.d.ts

@@ -0,0 +1,20 @@
+import { Texture } from "three";
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+import { NodeRepresentation, ShaderNodeObject } from "../shadernode/ShaderNode.js";
+
+export default class PMREMNode extends TempNode {
+    uvNode: Node | null;
+    levelNode: Node | null;
+
+    constructor(value: Texture, uvNode?: Node | null, levelNode?: Node | null);
+
+    set value(value: Texture);
+    get value(): Texture;
+}
+
+export const pmremTexture: (
+    value: Texture,
+    uvNode?: NodeRepresentation,
+    levelNode?: NodeRepresentation,
+) => ShaderNodeObject<PMREMNode>;

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

@@ -1,15 +1,12 @@
-import { Material } from "three";
+import { Material, Mesh, OrthographicCamera } from "three";
 import Renderer from "../renderers/common/Renderer.js";
 
-export default class QuadMesh {
-    constructor(material?: Material | null);
+export default class QuadMesh extends Mesh {
+    camera: OrthographicCamera;
 
-    dispose(): void;
+    constructor(material?: Material | null);
 
     renderAsync(renderer: Renderer): Promise<void>;
 
-    get material(): Material;
-    set material(value: Material);
-
-    get render(): (renderer: Renderer) => Promise<void>;
+    render(renderer: Renderer): void;
 }

three/examples/jsm/renderers/common/Info.d.ts

@@ -6,19 +6,15 @@ export default class Info {
     frame: number;
     calls: number;
 
-    render: { calls: number; drawCalls: number; triangles: number; points: number; lines: number };
+    render: { calls: number; drawCalls: number; triangles: number; points: number; lines: number; timestamp: number };
 
-    compute: { calls: number; computeCalls: number };
+    compute: { calls: number; computeCalls: number; timestamp: number };
 
     memory: { geometries: number; textures: number };
 
-    timestamp: { compute: number; render: number };
-
     update(object: Object3D, count: number, instanceCount: number): void;
 
-    updateTimestamp(type: keyof typeof this.timestamp, time: number): void;
-
-    resetCompute(): void;
+    updateTimestamp(type: "render" | "compute", time: number): void;
 
     reset(): void;
 

three/examples/jsm/renderers/common/PostProcessing.d.ts

@@ -7,5 +7,7 @@ export default class PostProcessing {
 
     constructor(renderer: Renderer, outputNode?: Node);
 
-    render(): Promise<void>;
+    render(): void;
+
+    renderAsync(): Promise<void>;
 }

three/examples/jsm/renderers/common/Renderer.d.ts

@@ -12,6 +12,7 @@ import {
     RenderTarget,
     Scene,
     ShadowMapType,
+    Texture,
     ToneMapping,
     Vector2,
     Vector4,
@@ -90,7 +91,7 @@ export default class Renderer {
     depth: boolean;
 
     /**
-     * @default true
+     * @default false
      */
     stencil: boolean;
 
@@ -268,6 +269,8 @@ export default class Renderer {
 
     copyFramebufferToTexture(framebufferTexture: FramebufferTexture): void;
 
+    copyTextureToTexture(position: Vector2, srcTexture: Texture, dstTexture: Texture, level?: number): void;
+
     readRenderTargetPixelsAsync(
         renderTarget: RenderTarget,
         x: number,

three/examples/jsm/renderers/common/extras/PMREMGenerator.d.ts

@@ -0,0 +1,8 @@
+import { RenderTarget, Scene } from "three";
+import Renderer from "../Renderer.js";
+
+export default class PMREMGenerator {
+    constructor(renderer: Renderer);
+
+    fromScene(scene: Scene, sigma?: number, near?: number, far?: number): RenderTarget;
+}

three/examples/jsm/renderers/webgl/WebGLBackend.d.ts

@@ -1,6 +1,10 @@
 import { CoordinateSystem } from "three";
 import Backend, { BackendParameters } from "../common/Backend.js";
 
+export interface WebGLBackendParameters extends BackendParameters {
+    trackTimestamp?: boolean | undefined;
+}
+
 export default class WebGLBackend extends Backend {
     constructor(parameters?: BackendParameters);
 

three/index.d.ts

@@ -3,4 +3,4 @@
 // Periodically, the updates from the repository are pushed to DefinitelyTyped
 // and released in the @types/three npm package.
 
-export * from "./src/Three";
+export * from "./src/Three.js";

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.162.0",
+    "version": "0.163.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -42,9 +42,9 @@
         "@tweenjs/tween.js": "~23.1.1",
         "@types/stats.js": "*",
         "@types/webxr": "*",
-        "fflate": "~0.6.10",
+        "fflate": "~0.8.2",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "a113c91d5796d4919f38171319b51f9ac52586ca55d8dcbb08da2d5cfeeef84d",
-    "typeScriptVersion": "4.6"
+    "typesPublisherContentHash": "9f0e97bd23c86f0c0c2d025de530532214c74995254c55868863ffb17e00963a",
+    "typeScriptVersion": "4.7"
 }

three/src/Three.d.ts

@@ -203,7 +203,6 @@ export * from "./renderers/webgl/WebGLTextures.js";
 export * from "./renderers/webgl/WebGLUniforms.js";
 export * from "./renderers/webgl/WebGLUniformsGroups.js";
 export { WebGLUtils } from "./renderers/webgl/WebGLUtils.js";
-export * from "./renderers/WebGL1Renderer.js";
 export * from "./renderers/WebGL3DRenderTarget.js";
 export * from "./renderers/WebGLArrayRenderTarget.js";
 export * from "./renderers/WebGLCubeRenderTarget.js";

three/src/cameras/Camera.d.ts

@@ -3,6 +3,7 @@ import { Layers } from "../core/Layers.js";
 import { Object3D } from "../core/Object3D.js";
 import { Matrix4 } from "../math/Matrix4.js";
 import { Vector3 } from "../math/Vector3.js";
+import { Vector4 } from "../math/Vector4.js";
 
 /**
  * Abstract base class for cameras
@@ -62,6 +63,8 @@ export class Camera extends Object3D {
 
     coordinateSystem: CoordinateSystem;
 
+    viewport?: Vector4;
+
     /**
      * Returns a {@link THREE.Vector3 | Vector3} representing the world space direction in which the {@link Camera} is looking.
      * @remarks Note: A {@link Camera} looks down its local, negative z-axis.

three/src/constants.d.ts

@@ -336,6 +336,7 @@ export const HalfFloatType: 1016;
 export const UnsignedShort4444Type: 1017;
 export const UnsignedShort5551Type: 1018;
 export const UnsignedInt248Type: 1020;
+export const UnsignedInt5999Type: 35902;
 
 export type AttributeGPUType = typeof FloatType | typeof IntType;
 
@@ -356,7 +357,8 @@ export type TextureDataType =
     | typeof HalfFloatType
     | typeof UnsignedShort4444Type
     | typeof UnsignedShort5551Type
-    | typeof UnsignedInt248Type;
+    | typeof UnsignedInt248Type
+    | typeof UnsignedInt5999Type;
 
 ///////////////////////////////////////////////////////////////////////////////
 // Pixel formats
@@ -364,7 +366,9 @@ export type TextureDataType =
 /** {@link AlphaFormat} discards the red, green and blue components and reads just the alpha component. */
 export const AlphaFormat: 1021;
 
-/** {@link RGBAFormat} discards the green and blue components and reads just the red component. (Can only be used with a WebGL 2 rendering context). */
+export const RGBFormat: 1022;
+
+/** {@link RGBAFormat} is the default and reads the red, green, blue and alpha components. */
 export const RGBAFormat: 1023;
 
 /**
@@ -395,27 +399,23 @@ export const DepthStencilFormat: 1027;
 
 /**
  * {@link RedFormat} discards the green and blue components and reads just the red component.
- * @remarks Can only be used with a WebGL 2 rendering context.
  */
 export const RedFormat: 1028;
 
 /**
  * {@link RedIntegerFormat} discards the green and blue components and reads just the red component.
  * The texels are read as integers instead of floating point.
- * @remarks Can only be used with a WebGL 2 rendering context.
  */
 export const RedIntegerFormat: 1029;
 
 /**
  * {@link RGFormat} discards the alpha, and blue components and reads the red, and green components.
- * @remarks Can only be used with a WebGL 2 rendering context.
  */
 export const RGFormat: 1030;
 
 /**
  * {@link RGIntegerFormat} discards the alpha, and blue components and reads the red, and green components.
  * The texels are read as integers instead of floating point.
- * @remarks Can only be used with a WebGL 2 rendering context.
  */
 export const RGIntegerFormat: 1031;
 
@@ -425,35 +425,15 @@ export const RGIntegerFormat: 1031;
  */
 export const RGBAIntegerFormat: 1033;
 
-export const _SRGBAFormat: 1035; // fallback for WebGL 1
-
-/**
- * Texture Pixel Formats Modes. Compatible only with {@link WebGLRenderingContext | WebGL 1 Rendering Context}.
- * @remarks Note that the texture must have the correct {@link THREE.Texture.type} set, as described in  {@link TextureDataType}.
- * @see {@link WebGLRenderingContext.texImage2D} for details.
- * @see {@link WebGL2PixelFormat} and {@link PixelFormat}
- * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
- */
-export type WebGL1PixelFormat =
-    | typeof AlphaFormat
-    | typeof LuminanceFormat
-    | typeof LuminanceAlphaFormat
-    | typeof DepthFormat
-    | typeof DepthStencilFormat
-    | typeof RedFormat
-    | typeof RedIntegerFormat
-    | typeof RGFormat
-    | typeof _SRGBAFormat;
-
 /**
- * Texture Pixel Formats Modes. Compatible only with {@link WebGL2RenderingContext | WebGL 2 Rendering Context}.
+ * All Texture Pixel Formats Modes.
  * @remarks Note that the texture must have the correct {@link THREE.Texture.type} set, as described in  {@link TextureDataType}.
  * @see {@link WebGLRenderingContext.texImage2D} for details.
- * @see {@link WebGL2PixelFormat} and {@link PixelFormat}
  * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
  */
-export type WebGL2PixelFormat =
+export type PixelFormat =
     | typeof AlphaFormat
+    | typeof RGBFormat
     | typeof RGBAFormat
     | typeof LuminanceFormat
     | typeof LuminanceAlphaFormat
@@ -463,17 +443,7 @@ export type WebGL2PixelFormat =
     | typeof RedIntegerFormat
     | typeof RGFormat
     | typeof RGIntegerFormat
-    | typeof RGBAIntegerFormat
-    | typeof _SRGBAFormat;
-
-/**
- * All Texture Pixel Formats Modes.
- * @remarks Note that the texture must have the correct {@link THREE.Texture.type} set, as described in  {@link TextureDataType}.
- * @see {@link WebGLRenderingContext.texImage2D} for details.
- * @see {@link WebGL1PixelFormat} and {@link WebGL2PixelFormat}
- * @see {@link https://threejs.org/docs/index.html#api/en/constants/Textures | Texture Constants}
- */
-export type PixelFormat = WebGL1PixelFormat | WebGL2PixelFormat;
+    | typeof RGBAIntegerFormat;
 
 /**
  * All Texture Pixel Formats Modes for {@link THREE.DepthTexture}.

three/src/materials/Material.d.ts

@@ -1,3 +1,4 @@
+import { Camera } from "../cameras/Camera.js";
 import {
     Blending,
     BlendingDstFactor,
@@ -9,11 +10,15 @@ import {
     StencilFunc,
     StencilOp,
 } from "../constants.js";
+import { BufferGeometry } from "../core/BufferGeometry.js";
 import { EventDispatcher } from "../core/EventDispatcher.js";
+import { Object3D } from "../core/Object3D.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
 import { Plane } from "../math/Plane.js";
+import { Group } from "../objects/Group.js";
 import { WebGLProgramParametersWithUniforms } from "../renderers/webgl/WebGLPrograms.js";
 import { WebGLRenderer } from "../renderers/WebGLRenderer.js";
+import { Scene } from "../scenes/Scene.js";
 
 export interface MaterialParameters {
     alphaHash?: boolean | undefined;
@@ -84,12 +89,6 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      */
     alphaHash: boolean;
 
-    /**
-     * Sets the alpha value to be used when running an alpha test. Default is 0.
-     * @default 0
-     */
-    alphaTest: number;
-
     /**
      * Enables alpha to coverage. Can only be used with MSAA-enabled rendering contexts (meaning when the renderer was
      * created with *antialias* parameter set to `true`). Enabling this will smooth aliasing on clip plane edges and
@@ -271,13 +270,6 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      */
     name: string;
 
-    /**
-     * Specifies that the material needs to be updated, WebGL wise. Set it to true if you made changes that need to be reflected in WebGL.
-     * This property is automatically set to true when instancing a new material.
-     * @default false
-     */
-    needsUpdate: boolean;
-
     /**
      * Opacity. Default is 1.
      * @default 1
@@ -342,7 +334,8 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
 
     /**
      * Defines whether this material is tone mapped according to the renderer's
-     * {@link WebGLRenderer.toneMapping toneMapping} setting. It is ignored when rendering to a render target.
+     * {@link WebGLRenderer.toneMapping toneMapping} setting. It is ignored when rendering to a render target or using
+     * post processing.
      * @default true
      */
     toneMapped: boolean;
@@ -390,20 +383,27 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
     version: number;
 
     /**
-     * Return a new material with the same parameters as this material.
+     * Gets the alpha value to be used when running an alpha test. Default is 0.
+     * @default 0
      */
-    clone(): this;
+    get alphaTest(): number;
 
     /**
-     * Copy the parameters from the passed material into this material.
-     * @param material
+     * Sets the alpha value to be used when running an alpha test. Default is 0.
+     * @default 0
      */
-    copy(material: Material): this;
+    set alphaTest(value: number);
 
-    /**
-     * This disposes the material. Textures of a material don't get disposed. These needs to be disposed by {@link Texture}.
-     */
-    dispose(): void;
+    onBuild(object: Object3D, parameters: WebGLProgramParametersWithUniforms, renderer: WebGLRenderer): void;
+
+    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.
@@ -430,4 +430,27 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      * @param meta Object containing metadata such as textures or images for the material.
      */
     toJSON(meta?: any): any;
+
+    /**
+     * Return a new material with the same parameters as this material.
+     */
+    clone(): this;
+
+    /**
+     * Copy the parameters from the passed material into this material.
+     * @param material
+     */
+    copy(material: Material): this;
+
+    /**
+     * This disposes the material. Textures of a material don't get disposed. These needs to be disposed by {@link Texture}.
+     */
+    dispose(): void;
+
+    /**
+     * Specifies that the material needs to be updated, WebGL wise. Set it to true if you made changes that need to be reflected in WebGL.
+     * This property is automatically set to true when instancing a new material.
+     * @default false
+     */
+    set needsUpdate(value: boolean);
 }

three/src/materials/ShaderMaterial.d.ts

@@ -16,10 +16,8 @@ export interface ShaderMaterialParameters extends MaterialParameters {
     fog?: boolean | undefined;
     extensions?:
         | {
-            derivatives?: boolean | undefined;
-            fragDepth?: boolean | undefined;
-            drawBuffers?: boolean | undefined;
-            shaderTextureLOD?: boolean | undefined;
+            clipCullDistance?: boolean | undefined;
+            multiDraw?: boolean | undefined;
         }
         | undefined;
     glslVersion?: GLSLVersion | undefined;
@@ -86,26 +84,13 @@ export class ShaderMaterial extends Material {
      */
     clipping: boolean;
 
-    /**
-     * @deprecated Use {@link ShaderMaterial#extensions.derivatives extensions.derivatives} instead.
-     */
-    derivatives: any;
-
     /**
      * @default {
-     *   derivatives: false,
-     *   fragDepth: false,
-     *   drawBuffers: false,
-     *   shaderTextureLOD: false,
      *   clipCullDistance: false,
      *   multiDraw: false
      * }
      */
     extensions: {
-        derivatives: boolean;
-        fragDepth: boolean;
-        drawBuffers: boolean;
-        shaderTextureLOD: boolean;
         clipCullDistance: boolean;
         multiDraw: boolean;
     };

three/src/objects/BatchedMesh.d.ts

@@ -156,9 +156,6 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     setGeometryAt(index: number, geometry: BufferGeometry): number;
 
-    /**
-     * Marks the geometry at the given index as deleted and to not be rendered anymore.
-     */
     deleteGeometry(index: number): this;
 
     getBoundingBoxAt(index: number, target: Box3): Box3 | null;

three/src/objects/InstancedMesh.d.ts

@@ -162,5 +162,5 @@ export class InstancedMesh<
      * @remarks
      * Call this method whenever this instance is no longer used in your app.
      */
-    dispose(): void;
+    dispose(): this;
 }

three/src/objects/SkinnedMesh.d.ts

@@ -11,8 +11,6 @@ import { Skeleton } from "./Skeleton.js";
 
 /**
  * A mesh that has a {@link THREE.Skeleton | Skeleton} with {@link Bone | bones} that can then be used to animate the vertices of the geometry.
- * @remarks
- * {@link SkinnedMesh} can only be used with WebGL 2.
  * @example
  * ```typescript
  * const geometry = new THREE.CylinderGeometry(5, 5, 5, 5, 15, 5, 30);

three/src/renderers/WebGLRenderer.d.ts

@@ -65,7 +65,7 @@ export interface WebGLRendererParameters {
     antialias?: boolean | undefined;
 
     /**
-     * default is true.
+     * default is false.
      */
     stencil?: boolean | undefined;
 
@@ -177,7 +177,7 @@ export class WebGLRenderer implements Renderer {
     /**
      * @default []
      */
-    clippingPlanes: readonly Plane[];
+    clippingPlanes: Plane[];
 
     /**
      * @default false

three/src/renderers/webgl/WebGLAttributes.d.ts

@@ -1,10 +1,9 @@
 import { BufferAttribute } from "../../core/BufferAttribute.js";
 import { GLBufferAttribute } from "../../core/GLBufferAttribute.js";
 import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
 
 export class WebGLAttributes {
-    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, capabilities: WebGLCapabilities);
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext);
 
     get(attribute: BufferAttribute | InterleavedBufferAttribute | GLBufferAttribute):
         | {

three/src/renderers/webgl/WebGLBindingStates.d.ts

@@ -3,17 +3,10 @@ import { BufferGeometry } from "../../core/BufferGeometry.js";
 import { Object3D } from "../../core/Object3D.js";
 import { Material } from "../../materials/Material.js";
 import { WebGLAttributes } from "./WebGLAttributes.js";
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
-import { WebGLExtensions } from "./WebGLExtensions.js";
 import { WebGLProgram } from "./WebGLProgram.js";
 
 export class WebGLBindingStates {
-    constructor(
-        gl: WebGLRenderingContext,
-        extensions: WebGLExtensions,
-        attributes: WebGLAttributes,
-        capabilities: WebGLCapabilities,
-    );
+    constructor(gl: WebGLRenderingContext, attributes: WebGLAttributes);
 
     setup(
         object: Object3D,

three/src/renderers/webgl/WebGLBufferRenderer.d.ts

@@ -1,5 +1,3 @@
-// Renderers / WebGL /////////////////////////////////////////////////////////////////////
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
 import { WebGLExtensions } from "./WebGLExtensions.js";
 import { WebGLInfo } from "./WebGLInfo.js";
 
@@ -8,7 +6,6 @@ export class WebGLBufferRenderer {
         gl: WebGLRenderingContext,
         extensions: WebGLExtensions,
         info: WebGLInfo,
-        capabilities: WebGLCapabilities,
     );
 
     setMode: (value: any) => void;

three/src/renderers/webgl/WebGLCapabilities.d.ts

@@ -7,22 +7,24 @@ export class WebGLCapabilities {
     constructor(gl: WebGLRenderingContext, extensions: any, parameters: WebGLCapabilitiesParameters);
 
     readonly isWebGL2: boolean;
-    readonly drawBuffers: boolean;
+
+    getMaxAnisotropy: () => number;
+    getMaxPrecision: (precision: string) => string;
+
     precision: string;
     logarithmicDepthBuffer: boolean;
+
     maxTextures: number;
     maxVertexTextures: number;
     maxTextureSize: number;
     maxCubemapSize: number;
+
     maxAttributes: number;
     maxVertexUniforms: number;
     maxVaryings: number;
     maxFragmentUniforms: number;
+
     vertexTextures: boolean;
-    floatFragmentTextures: boolean;
-    floatVertexTextures: boolean;
-    maxSamples: number;
 
-    getMaxAnisotropy(): number;
-    getMaxPrecision(precision: string): string;
+    maxSamples: number;
 }

three/src/renderers/webgl/WebGLExtensions.d.ts

@@ -1,9 +1,7 @@
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
-
 export class WebGLExtensions {
     constructor(gl: WebGLRenderingContext);
 
     has(name: string): boolean;
-    init(capabilities: WebGLCapabilities): void;
+    init(): void;
     get(name: string): any;
 }

three/src/renderers/webgl/WebGLIndexedBufferRenderer.d.ts

@@ -1,5 +1,5 @@
 export class WebGLIndexedBufferRenderer {
-    constructor(gl: WebGLRenderingContext, extensions: any, info: any, capabilities: any);
+    constructor(gl: WebGLRenderingContext, extensions: any, info: any);
 
     setMode: (value: any) => void;
     setIndex: (index: any) => void;

three/src/renderers/webgl/WebGLLights.d.ts

@@ -1,4 +1,3 @@
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
 import { WebGLExtensions } from "./WebGLExtensions.js";
 
 export interface WebGLLightsState {
@@ -40,7 +39,7 @@ export interface WebGLLightsState {
 }
 
 export class WebGLLights {
-    constructor(extensions: WebGLExtensions, capabilities: WebGLCapabilities);
+    constructor(extensions: WebGLExtensions);
 
     state: WebGLLightsState;
 

three/src/renderers/webgl/WebGLPrograms.d.ts

@@ -22,8 +22,6 @@ import { WebGLLightsState } from "./WebGLLights.js";
 import { WebGLProgram } from "./WebGLProgram.js";
 
 export interface WebGLProgramParameters {
-    isWebGL2: boolean;
-
     shaderID: string;
     shaderType: string;
     shaderName: string;
@@ -200,16 +198,9 @@ export interface WebGLProgramParameters {
 
     index0AttributeName: string | undefined;
 
-    extensionDerivatives: boolean;
-    extensionFragDepth: boolean;
-    extensionDrawBuffers: boolean;
-    extensionShaderTextureLOD: boolean;
     extensionClipCullDistance: boolean;
     extensionMultiDraw: boolean;
 
-    rendererExtensionFragDepth: boolean;
-    rendererExtensionDrawBuffers: boolean;
-    rendererExtensionShaderTextureLod: boolean;
     rendererExtensionParallelShaderCompile: boolean;
 
     customProgramCacheKey: string;

three/src/renderers/webgl/WebGLState.d.ts

@@ -9,8 +9,6 @@ import {
 import { Material } from "../../materials/Material.js";
 import { Vector4 } from "../../math/Vector4.js";
 import { WebGLRenderTarget } from "../WebGLRenderTarget.js";
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
-import { WebGLExtensions } from "./WebGLExtensions.js";
 
 export class WebGLColorBuffer {
     constructor();
@@ -45,7 +43,7 @@ export class WebGLStencilBuffer {
 }
 
 export class WebGLState {
-    constructor(gl: WebGLRenderingContext, extensions: WebGLExtensions, capabilities: WebGLCapabilities);
+    constructor(gl: WebGLRenderingContext);
 
     buffers: {
         color: WebGLColorBuffer;

three/src/renderers/webgl/WebGLUtils.d.ts

@@ -1,12 +1,10 @@
 import { ColorSpace, CompressedPixelFormat, PixelFormat, TextureDataType } from "../../constants.js";
-import { WebGLCapabilities } from "./WebGLCapabilities.js";
 import { WebGLExtensions } from "./WebGLExtensions.js";
 
 export class WebGLUtils {
     constructor(
         gl: WebGLRenderingContext | WebGL2RenderingContext,
         extensions: WebGLExtensions,
-        capabilities: WebGLCapabilities,
     );
 
     convert(p: PixelFormat | CompressedPixelFormat | TextureDataType, colorSpace?: ColorSpace): number | null;

three/src/scenes/Scene.d.ts

@@ -82,6 +82,12 @@ export class Scene extends Object3D {
      */
     environment: Texture | null;
 
+    /**
+     * Attenuates the color of the environment. Only influences environment maps assigned to {@link Scene.environment}.
+     * @default 1
+     */
+    environmentIntensity: number;
+
     /**
      * The rotation of the environment map in radians. Only influences physical materials in the scene when
      * {@link .environment} is used. Default is `(0,0,0)`.

three/src/textures/Data3DTexture.d.ts

@@ -4,7 +4,6 @@ import { Texture3DImageData } from "./types.js";
 
 /**
  * Creates a three-dimensional texture from raw data, with parameters to divide it into width, height, and depth
- * @remarks Compatible only with {@link WebGL2RenderingContext | WebGL 2 Rendering Context}.
  * @example
  * ```typescript
  * This creates a[name] with repeating data, 0 to 255

three/src/textures/DataArrayTexture.d.ts

@@ -4,7 +4,6 @@ import { Texture3DImageData } from "./types.js";
 
 /**
  * Creates an array of textures directly from raw data, width and height and depth
- * @remarks Compatible only with {@link WebGL2RenderingContext | WebGL 2 Rendering Context}.
  * @example
  * ```typescript
  * This creates a[name] where each texture has a different color.

three/src/textures/DepthTexture.d.ts

@@ -11,9 +11,6 @@ import { Texture } from "./Texture.js";
 
 /**
  * This class can be used to automatically save the depth information of a rendering into a texture
- * @remarks
- * When using a **WebGL1** rendering context, {@link DepthTexture} requires support for the
- * {@link https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/ | WEBGL_depth_texture} extension.
  * @see Example: {@link https://threejs.org/examples/#webgl_depth_texture | depth / texture}
  * @see {@link https://threejs.org/docs/index.html#api/en/textures/DepthTexture | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/textures/DepthTexture.js | Source}

three/src/textures/Texture.d.ts

@@ -339,13 +339,6 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
      */
     isRenderTargetTexture: boolean;
 
-    /**
-     * Indicates whether this texture should be processed by {@link THREE.PMREMGenerator} or not.
-     * @remarks Only relevant for render target textures.
-     * @defaultValue `false`
-     */
-    needsPMREMUpdate: boolean;
-
     /**
      * An object that can be used to store custom data about the texture.
      * @remarks It should not hold references to functions as these will not be cloned.
@@ -360,11 +353,24 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
      */
     version: number;
 
+    /**
+     * Indicates whether this texture should be processed by PMREMGenerator or not (only relevant for render target
+     * textures)
+     */
+    pmremVersion: number;
+
     /**
      * Set this to `true` to trigger an update next time the texture is used. Particularly important for setting the wrap mode.
      */
     set needsUpdate(value: boolean);
 
+    /**
+     * Indicates whether this texture should be processed by {@link THREE.PMREMGenerator} or not.
+     * @remarks Only relevant for render target textures.
+     * @defaultValue `false`
+     */
+    set needsPMREMUpdate(value: boolean);
+
     /**
      * The Global default value for {@link anisotropy | .anisotropy}.
      * @defaultValue `1`.

three/examples/jsm/nodes/utils/SpecularMIPLevelNode.d.ts

@@ -1,12 +0,0 @@
-import TextureNode from "../accessors/TextureNode.js";
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../shadernode/ShaderNode.js";
-
-export default class SpecularMIPLevelNode extends Node {
-    textureNode: TextureNode;
-    roughnessNode: Node | null;
-
-    constructor(textureNode: TextureNode, roughnessNode?: Node | null);
-}
-
-export const specularMIPLevel: () => ShaderNodeObject<SpecularMIPLevelNode>;

three/src/renderers/WebGL1Renderer.d.ts

@@ -1,6 +0,0 @@
-import { WebGLRenderer, WebGLRendererParameters } from "./WebGLRenderer.js";
-
-export class WebGL1Renderer extends WebGLRenderer {
-    constructor(parameters?: WebGLRendererParameters);
-    readonly isWebGL1Renderer: true;
-}