@types/three 0.172.0 → 0.174.0

three/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for three (https://threejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three.
 
 ### Additional Details
- * Last updated: Mon, 06 Jan 2025 09:02:31 GMT
+ * Last updated: Thu, 27 Feb 2025 18:02:49 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), [@webgpu/types](https://npmjs.com/package/@webgpu/types), [fflate](https://npmjs.com/package/fflate), [meshoptimizer](https://npmjs.com/package/meshoptimizer)
 
 # Credits

three/examples/jsm/animation/CCDIKSolver.d.ts

@@ -14,6 +14,7 @@ export interface IK {
     minAngle?: number | undefined;
     maxAngle?: number | undefined;
     target: number;
+    blendFactor?: number | undefined;
 }
 
 export class CCDIKSolver {
@@ -22,8 +23,8 @@ export class CCDIKSolver {
 
     constructor(mesh: SkinnedMesh, iks?: IK[]);
 
-    update(): this;
-    updateOne(ik: IK): this;
+    update(globalBlendFactor?: number): this;
+    updateOne(ik: IK, overrideBlend?: number): this;
     createHelper(sphereSize?: number): CCDIKHelper;
 }
 

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

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

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

@@ -1,4 +1,4 @@
-import { Camera, Group, Object3D, Object3DEventMap, Vector2, WebGLRenderer, XRTargetRaySpace } from "three";
+import { Camera, Group, Object3D, Object3DEventMap, Raycaster, Vector2, WebGLRenderer, XRTargetRaySpace } from "three";
 
 export interface InteractiveObject3DEventMap extends Object3DEventMap {
     hoveron: { data: Vector2 };
@@ -14,7 +14,15 @@ export interface InteractiveObject3DEventMap extends Object3DEventMap {
 export class InteractiveObject3D extends Object3D<InteractiveObject3DEventMap> {}
 
 export class InteractiveGroup extends Group {
+    raycaster: Raycaster;
+
     listenToPointerEvents(renderer: WebGLRenderer, camera: Camera): void;
 
+    disconnectionPointerEvents(): void;
+
     listenToXRControllerEvents(controller: XRTargetRaySpace): void;
+
+    disconnectXrControllerEvents(): void;
+
+    disconnect(): void;
 }

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

@@ -38,8 +38,8 @@ export class MTLLoader extends Loader<MTLLoader.MaterialCreator> {
 }
 
 export interface MaterialInfo {
-    ks?: number[] | undefined;
     kd?: number[] | undefined;
+    ks?: number[] | undefined;
     ke?: number[] | undefined;
     map_kd?: string | undefined;
     map_ks?: string | undefined;
@@ -47,6 +47,7 @@ export interface MaterialInfo {
     norm?: string | undefined;
     map_bump?: string | undefined;
     bump?: string | undefined;
+    disp?: string | undefined;
     map_d?: string | undefined;
     ns?: number | undefined;
     d?: number | undefined;

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

@@ -6,6 +6,9 @@
 
 import { ShaderMaterial, ShaderMaterialParameters } from "three";
 
+/**
+ * @deprecated Use THREE.MeshLambertMaterial instead.
+ */
 export class MeshGouraudMaterial extends ShaderMaterial {
     isMeshGouraudMaterial: true;
 

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

@@ -4,8 +4,8 @@
  *
  * - {@link Timer} has an {@link .update()} method that updates its internal state. That makes it possible to call
  *   {@link .getDelta()} and {@link .getElapsed()} multiple times per simulation step without getting different values.
- * - The class uses the Page Visibility API to avoid large time delta values when the app is inactive (e.g. tab switched
- *   or browser hidden).
+ * - The class can make use of the Page Visibility API to avoid large time delta values when the app is inactive (e.g.
+ *   tab switched or browser hidden).
  *
  * @example
  * const timer = new Timer();
@@ -24,6 +24,17 @@
 export class Timer {
     constructor();
 
+    /**
+     * Connects the timer to the given document. Calling this method is not mandatory to use the timer but enables the
+     * usage of the Page Visibility API to avoid large time delta values.
+     */
+    connect(document: Document): void;
+
+    /**
+     * Disconnects the timer from the DOM and also disables the usage of the Page Visibility API.
+     */
+    disconnect(): void;
+
     /**
      * Returns the time delta in seconds.
      */

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

@@ -11,6 +11,7 @@ export interface ReflectorOptions {
 
 export class Reflector extends Mesh {
     type: "Reflector";
+    forceUpdate: boolean;
     camera: PerspectiveCamera;
 
     constructor(geometry?: BufferGeometry, options?: ReflectorOptions);

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

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

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

@@ -0,0 +1,9 @@
+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> }>,
+) => void;

three/examples/jsm/webxr/XRButton.d.ts

@@ -1,5 +1,7 @@
-import { WebGLRenderer } from "three";
+export interface XRButtonRenderer {
+    xr: { setSession(session: XRSession): Promise<void> };
+}
 
 export class XRButton {
-    static createButton(renderer: WebGLRenderer, sessionInit?: XRSessionInit): HTMLElement;
+    static createButton(renderer: XRButtonRenderer, sessionInit?: XRSessionInit): HTMLElement;
 }

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.172.0",
+    "version": "0.174.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -48,6 +48,6 @@
         "meshoptimizer": "~0.18.1"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "5a0a6eed488cac2cce6e55921ed12957eedbfbfc3847d24e7762d3d686ecaeac",
+    "typesPublisherContentHash": "42b773a4ca2b467bb5f631194fbba7e91c3510c11d419d1c442487b3e4c90b2e",
     "typeScriptVersion": "5.0"
 }

three/src/Three.Core.d.ts

@@ -140,6 +140,7 @@ export * from "./renderers/WebGL3DRenderTarget.js";
 export * from "./renderers/WebGLArrayRenderTarget.js";
 export * from "./renderers/WebGLCubeRenderTarget.js";
 export * from "./renderers/WebGLRenderTarget.js";
+export * from "./renderers/webxr/WebXRController.js";
 export * from "./scenes/Fog.js";
 export * from "./scenes/FogExp2.js";
 export * from "./scenes/Scene.js";
@@ -155,5 +156,6 @@ export * from "./textures/DepthTexture.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";

three/src/Three.TSL.d.ts

@@ -43,6 +43,7 @@ export const anisotropyB: typeof TSL.anisotropyB;
 export const anisotropyT: typeof TSL.anisotropyT;
 export const any: typeof TSL.any;
 export const append: typeof TSL.append;
+export const array: typeof TSL.array;
 export const arrayBuffer: typeof TSL.arrayBuffer;
 export const asin: typeof TSL.asin;
 export const assign: typeof TSL.assign;
@@ -57,6 +58,7 @@ export const atomicOr: typeof TSL.atomicOr;
 export const atomicStore: typeof TSL.atomicStore;
 export const atomicSub: typeof TSL.atomicSub;
 export const atomicXor: typeof TSL.atomicXor;
+export const atomicLoad: typeof TSL.atomicLoad;
 export const attenuationColor: typeof TSL.attenuationColor;
 export const attenuationDistance: typeof TSL.attenuationDistance;
 export const attribute: typeof TSL.attribute;
@@ -93,6 +95,7 @@ export const bypass: typeof TSL.bypass;
 export const cache: typeof TSL.cache;
 export const call: typeof TSL.call;
 export const cameraFar: typeof TSL.cameraFar;
+export const cameraIndex: typeof TSL.cameraIndex;
 export const cameraNear: typeof TSL.cameraNear;
 export const cameraNormalMatrix: typeof TSL.cameraNormalMatrix;
 export const cameraPosition: typeof TSL.cameraPosition;
@@ -114,6 +117,7 @@ export const colorSpaceToWorking: typeof TSL.colorSpaceToWorking;
 export const colorToDirection: typeof TSL.colorToDirection;
 export const compute: typeof TSL.compute;
 export const cond: typeof TSL.cond;
+export const Const: typeof TSL.Const;
 export const context: typeof TSL.context;
 export const convert: typeof TSL.convert;
 export const convertColorSpace: typeof TSL.convertColorSpace;
@@ -219,6 +223,7 @@ export const lights: typeof TSL.lights;
 export const linearDepth: typeof TSL.linearDepth;
 export const linearToneMapping: typeof TSL.linearToneMapping;
 export const localId: typeof TSL.localId;
+export const globalId: typeof TSL.globalId;
 export const log: typeof TSL.log;
 export const log2: typeof TSL.log2;
 export const logarithmicDepthToViewZ: typeof TSL.logarithmicDepthToViewZ;
@@ -254,7 +259,7 @@ export const materialLineWidth: typeof TSL.materialLineWidth;
 export const materialMetalness: typeof TSL.materialMetalness;
 export const materialNormal: typeof TSL.materialNormal;
 export const materialOpacity: typeof TSL.materialOpacity;
-export const materialPointWidth: typeof TSL.materialPointWidth;
+export const materialPointSize: typeof TSL.materialPointSize;
 export const materialReference: typeof TSL.materialReference;
 export const materialReflectivity: typeof TSL.materialReflectivity;
 export const materialRefractionRatio: typeof TSL.materialRefractionRatio;
@@ -280,6 +285,7 @@ export const modInt: typeof TSL.modInt;
 export const modelDirection: typeof TSL.modelDirection;
 export const modelNormalMatrix: typeof TSL.modelNormalMatrix;
 export const modelPosition: typeof TSL.modelPosition;
+export const modelRadius: typeof TSL.modelRadius;
 export const modelScale: typeof TSL.modelScale;
 export const modelViewMatrix: typeof TSL.modelViewMatrix;
 export const modelViewPosition: typeof TSL.modelViewPosition;
@@ -331,6 +337,7 @@ export const numWorkgroups: typeof TSL.numWorkgroups;
 export const objectDirection: typeof TSL.objectDirection;
 export const objectGroup: typeof TSL.objectGroup;
 export const objectPosition: typeof TSL.objectPosition;
+export const objectRadius: typeof TSL.objectRadius;
 export const objectScale: typeof TSL.objectScale;
 export const objectViewPosition: typeof TSL.objectViewPosition;
 export const objectWorldMatrix: typeof TSL.objectWorldMatrix;
@@ -375,6 +382,7 @@ export const range: typeof TSL.range;
 export const rangeFog: typeof TSL.rangeFog;
 export const rangeFogFactor: typeof TSL.rangeFogFactor;
 export const reciprocal: typeof TSL.reciprocal;
+export const lightProjectionUV: typeof TSL.lightProjectionUV;
 export const reference: typeof TSL.reference;
 export const referenceBuffer: typeof TSL.referenceBuffer;
 export const reflect: typeof TSL.reflect;
@@ -411,8 +419,10 @@ export const select: typeof TSL.select;
 export const setCurrentStack: typeof TSL.setCurrentStack;
 export const shaderStages: typeof TSL.shaderStages;
 export const shadow: typeof TSL.shadow;
+export const pointShadow: typeof TSL.pointShadow;
 export const shadowPositionWorld: typeof TSL.shadowPositionWorld;
 export const sharedUniformGroup: typeof TSL.sharedUniformGroup;
+export const shapeCircle: typeof TSL.shapeCircle;
 export const sheen: typeof TSL.sheen;
 export const sheenRoughness: typeof TSL.sheenRoughness;
 export const shiftLeft: typeof TSL.shiftLeft;
@@ -438,6 +448,7 @@ export const storageBarrier: typeof TSL.storageBarrier;
 export const storageObject: typeof TSL.storageObject;
 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 subgroupIndex: typeof TSL.subgroupIndex;
 export const subgroupSize: typeof TSL.subgroupSize;
@@ -496,6 +507,7 @@ export const uv: typeof TSL.uv;
 export const uvec2: typeof TSL.uvec2;
 export const uvec3: typeof TSL.uvec3;
 export const uvec4: typeof TSL.uvec4;
+export const Var: typeof TSL.Var;
 export const varying: typeof TSL.varying;
 export const varyingProperty: typeof TSL.varyingProperty;
 export const vec2: typeof TSL.vec2;

three/src/Three.d.ts

@@ -28,7 +28,12 @@ export type { WebGLProperties } from "./renderers/webgl/WebGLProperties.js";
 export type { RenderItem, WebGLRenderList, WebGLRenderLists } from "./renderers/webgl/WebGLRenderLists.js";
 export type { WebGLShader } from "./renderers/webgl/WebGLShader.js";
 export type { WebGLShadowMap } from "./renderers/webgl/WebGLShadowMap.js";
-export type { WebGLState } from "./renderers/webgl/WebGLState.js";
+export type {
+    WebGLColorBuffer,
+    WebGLDepthBuffer,
+    WebGLState,
+    WebGLStencilBuffer,
+} from "./renderers/webgl/WebGLState.js";
 export type { WebGLTextures } from "./renderers/webgl/WebGLTextures.js";
 export type { WebGLUniforms } from "./renderers/webgl/WebGLUniforms.js";
 export * from "./renderers/webgl/WebGLUtils.js";

three/src/animation/AnimationClip.d.ts

@@ -41,7 +41,7 @@ export class AnimationClip {
     validate(): boolean;
     optimize(): AnimationClip;
     clone(): this;
-    toJSON(clip: AnimationClip): any;
+    toJSON(): AnimationClipJSON;
 
     static CreateFromMorphTargetSequence(
         name: string,

three/src/cameras/ArrayCamera.d.ts

@@ -11,12 +11,6 @@ import { PerspectiveCamera } from "./PerspectiveCamera.js";
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/cameras/ArrayCamera.js | Source}
  */
 export class ArrayCamera extends PerspectiveCamera {
-    /**
-     * An array of cameras.
-     * @param array. Default `[]`.
-     */
-    constructor(cameras?: PerspectiveCamera[]);
-
     /**
      * Read-only flag to check if a given object is of type {@link ArrayCamera}.
      * @remarks This is a _constant_ value
@@ -29,4 +23,11 @@ export class ArrayCamera extends PerspectiveCamera {
      * @defaultValue `[]`
      */
     cameras: PerspectiveCamera[];
+
+    index: number;
+
+    /**
+     * An array of cameras.
+     */
+    constructor(cameras?: PerspectiveCamera[]);
 }

three/src/cameras/Camera.d.ts

@@ -16,8 +16,8 @@ export class Camera extends Object3D {
     /**
      * @remarks
      * Note that this class is not intended to be called directly; you probably want a
-     * {@link THREE.PerspectiveCamera | PerspectiveCamera} or
-     * {@link THREE.OrthographicCamera | OrthographicCamera} instead.
+     * {@link PerspectiveCamera | PerspectiveCamera} or
+     * {@link OrthographicCamera | OrthographicCamera} instead.
      */
     constructor();
 
@@ -36,7 +36,7 @@ export class Camera extends Object3D {
 
     /**
      * @override
-     * The {@link THREE.Layers | layers} that the {@link Camera} is a member of.
+     * The {@link Layers | layers} that the {@link Camera} is a member of.
      * @remarks Objects must share at least one layer with the {@link Camera} to be n when the camera's viewpoint is rendered.
      * @defaultValue `new THREE.Layers()`
      */
@@ -45,19 +45,19 @@ export class Camera extends Object3D {
     /**
      * This is the inverse of matrixWorld.
      * @remarks MatrixWorld contains the Matrix which has the world transform of the {@link Camera} .
-     * @defaultValue {@link THREE.Matrix4 | `new THREE.Matrix4()`}
+     * @defaultValue {@link Matrix4 | `new THREE.Matrix4()`}
      */
     matrixWorldInverse: Matrix4;
 
     /**
      * This is the matrix which contains the projection.
-     * @defaultValue {@link THREE.Matrix4 | `new THREE.Matrix4()`}
+     * @defaultValue {@link Matrix4 | `new THREE.Matrix4()`}
      */
     projectionMatrix: Matrix4;
 
     /**
      * This is the inverse of projectionMatrix.
-     * @defaultValue {@link THREE.Matrix4 | `new THREE.Matrix4()`}
+     * @defaultValue {@link Matrix4 | `new THREE.Matrix4()`}
      */
     projectionMatrixInverse: Matrix4;
 
@@ -66,7 +66,7 @@ export class Camera extends Object3D {
     viewport?: Vector4;
 
     /**
-     * Returns a {@link THREE.Vector3 | Vector3} representing the world space direction in which the {@link Camera} is looking.
+     * Returns a {@link 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.
      * @param target The result will be copied into this Vector3.
      */

three/src/constants.d.ts

@@ -791,6 +791,12 @@ export const WebGLCoordinateSystem: 2000;
 export const WebGPUCoordinateSystem: 2001;
 export type CoordinateSystem = typeof WebGLCoordinateSystem | typeof WebGPUCoordinateSystem;
 
+export const TimestampQuery: {
+    COMPUTE: "compute";
+    RENDER: "render";
+};
+export type TimestampQuery = "compute" | "render";
+
 ///////////////////////////////////////////////////////////////////////////////
 // Texture - Internal Pixel Formats
 

three/src/core/BufferAttribute.d.ts

@@ -57,6 +57,11 @@ export class BufferAttribute {
      */
     constructor(array: TypedArray, itemSize: number, normalized?: boolean);
 
+    /**
+     * Unique number for this attribute instance.
+     */
+    readonly id: number;
+
     /**
      * Optional name for this attribute instance.
      * @defaultValue ''

three/src/core/Raycaster.d.ts

@@ -17,6 +17,10 @@ export interface Face {
 export interface Intersection<TIntersected extends Object3D = Object3D> {
     /** Distance between the origin of the ray and the intersection */
     distance: number;
+    /**
+     * Some objects (f.e. {@link Points}) provide the distance of the intersection to the nearest point on the ray. For
+     * other objects it will be `undefined`
+     */
     distanceToRay?: number | undefined;
     /** Point of intersection, in world coordinates */
     point: Vector3;

three/src/extras/PMREMGenerator.d.ts

@@ -1,9 +1,15 @@
+import { Vector3 } from "../math/Vector3.js";
 import { WebGLRenderer } from "../renderers/WebGLRenderer.js";
 import { WebGLRenderTarget } from "../renderers/WebGLRenderTarget.js";
 import { Scene } from "../scenes/Scene.js";
 import { CubeTexture } from "../textures/CubeTexture.js";
 import { Texture } from "../textures/Texture.js";
 
+export interface PMREMGeneratorOptions {
+    size?: number | undefined;
+    position?: Vector3 | undefined;
+}
+
 /**
  * This class generates a Prefiltered, Mipmapped Radiance Environment Map (PMREM) from a cubeMap environment texture.
  * @remarks
@@ -38,13 +44,20 @@ export class PMREMGenerator {
     /**
      * Generates a PMREM from a supplied Scene, which can be faster than using an image if networking bandwidth is low
      * @remarks
-     * Optional near and far planes ensure the scene is rendered in its entirety (the cubeCamera is placed at the origin).
+     * Optional near and far planes ensure the scene is rendered in its entirety.
      * @param scene The given scene.
      * @param sigma Specifies a blur radius in radians to be applied to the scene before PMREM generation. Default `0`.
      * @param near The near plane value. Default `0.1`.
      * @param far The far plane value. Default `100`.
+     * @param {?Object} [options={}]
      */
-    fromScene(scene: Scene, sigma?: number, near?: number, far?: number): WebGLRenderTarget;
+    fromScene(
+        scene: Scene,
+        sigma?: number,
+        near?: number,
+        far?: number,
+        options?: PMREMGeneratorOptions,
+    ): WebGLRenderTarget;
 
     /**
      * Generates a PMREM from an equirectangular texture, which can be either LDR or HDR. The ideal input image size is

three/src/geometries/TorusGeometry.d.ts

@@ -16,12 +16,11 @@ import { BufferGeometry } from "../core/BufferGeometry.js";
  */
 export class TorusGeometry extends BufferGeometry {
     /**
-     * Create a new instance of {@link TorusGeometry}
-     * @param radius Radius of the torus, from the center of the torus to the center of the tube. Expects a `Float`. Default `1`.
-     * @param tube Radius of the tube. Expects a `Float`. Default `0.4`.
-     * @param radialSegments Expects a `Integer`.Default is `12`.
-     * @param tubularSegments Expects a `Integer`. Default `48`.
-     * @param arc Central angle. Expects a `Float`. Default `Math.PI * 2`
+     * @param radius Radius of the torus, from the center of the torus to the center of the tube. Default `1`.
+     * @param tube Radius of the tube. Must be smaller than `radius`. Default is `0.4`.
+     * @param radialSegments Default is `12`.
+     * @param tubularSegments Default is `48`.
+     * @param arc Central angle. Default is Math.PI * 2.
      */
     constructor(radius?: number, tube?: number, radialSegments?: number, tubularSegments?: number, arc?: number);
 

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

@@ -60,7 +60,7 @@ declare class NodeMaterial extends Material {
 
     depthNode: Node | null;
     shadowPositionNode: Node | null;
-    receivedShadowNode: Node | null;
+    receivedShadowNode: (() => Node) | null;
     castShadowNode: Node | null;
 
     outputNode: Node | null;
@@ -89,6 +89,7 @@ declare class NodeMaterial extends Material {
     setupOutgoingLight(): Node;
     setupLightingModel(builder: NodeBuilder): LightingModel;
     setupLighting(builder: NodeBuilder): Node;
+    setupFog(builder: NodeBuilder, outputNode: Node): Node;
     setupOutput(builder: NodeBuilder, outputNode: Node): Node;
 
     setDefaultValues(material: Material): void;

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

@@ -1,7 +1,3 @@
-export {
-    default as InstancedPointsNodeMaterial,
-    InstancedPointsNodeMaterialParameters,
-} from "./InstancedPointsNodeMaterial.js";
 export { default as Line2NodeMaterial, Line2NodeMaterialParameters } from "./Line2NodeMaterial.js";
 export { default as LineBasicNodeMaterial, LineBasicNodeMaterialParameters } from "./LineBasicNodeMaterial.js";
 export { default as LineDashedNodeMaterial, LineDashedNodeMaterialParameters } from "./LineDashedNodeMaterial.js";

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

@@ -1,21 +1,14 @@
-import { Color } from "../../math/Color.js";
-import { Texture } from "../../textures/Texture.js";
-import { PointsMaterialParameters } from "../PointsMaterial.js";
-import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+import Node from "../../nodes/core/Node.js";
+import SpriteNodeMaterial, { SpriteNodeMaterialParameters } from "./SpriteNodeMaterial.js";
 
-export interface PointsNodeMaterialParameters extends NodeMaterialParameters, PointsMaterialParameters {
+export interface PointsNodeMaterialParameters extends SpriteNodeMaterialParameters {
+    sizeNode?: Node | null | undefined;
 }
 
-export default class PointsNodeMaterial extends NodeMaterial {
-    readonly isPointsNodeMaterial: true;
+export default class PointsNodeMaterial extends SpriteNodeMaterial {
+    sizeNode: Node | null;
 
-    // Properties from PointsMaterial
-    readonly isPointsMaterial: true;
-    color: Color;
-    map: Texture | null;
-    alphaMap: Texture | null;
-    size: number;
-    sizeAttenuation: boolean;
+    readonly isPointsNodeMaterial: true;
 
     constructor(parameters?: PointsNodeMaterialParameters);
 }

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

@@ -1,10 +1,22 @@
+import FunctionNode from "../../nodes/code/FunctionNode.js";
 import Node from "../../nodes/core/Node.js";
+import { ShaderNodeObject } from "../../nodes/tsl/TSLCore.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
+export interface VolumeNodeMaterialParameters extends NodeMaterialParameters {
+    steps?: number | undefined;
+
+    scatteringNode?: Node | null | undefined;
+}
+
 export default class VolumeNodeMaterial extends NodeMaterial {
-    lights: boolean;
     readonly isVolumeNodeMaterial: true;
-    testNode: Node | null;
+
+    steps: number;
+
+    scatteringNode: (params: { positionRay: ShaderNodeObject<Node> }) => Node | null;
+
+    offsetNode?: Node | undefined;
 
     constructor(parameters?: NodeMaterialParameters);
 }

three/src/materials/nodes/manager/NodeMaterialObserver.d.ts

@@ -68,6 +68,7 @@ interface AttributesData {
 interface RenderObjectData {
     material: MaterialData;
     geometry: {
+        id: number;
         attributes: AttributesData;
         indexVersion: number | null;
         drawRange: {
@@ -99,7 +100,7 @@ declare class NodeMaterialObserver {
      * Returns `true` if the given render object is verified for the first time of this observer.
      *
      * @param {RenderObject} renderObject - The render object.
-     * @return {Boolean} Whether the given render object is verified for the first time of this observer.
+     * @return {boolean} Whether the given render object is verified for the first time of this observer.
      */
     firstInitialization(renderObject: RenderObject): boolean;
     /**
@@ -122,7 +123,7 @@ declare class NodeMaterialObserver {
      * node properties.
      *
      * @param {NodeBuilder} builder - The current node builder.
-     * @return {Boolean} Whether the node builder's material uses node properties or not.
+     * @return {boolean} Whether the node builder's material uses node properties or not.
      */
     containsNode(builder: NodeBuilder): boolean;
     /**
@@ -137,7 +138,7 @@ declare class NodeMaterialObserver {
      * Returns `true` if the given render object has not changed its state.
      *
      * @param {RenderObject} renderObject - The render object.
-     * @return {Boolean} Whether the given render object has changed its state or not.
+     * @return {boolean} Whether the given render object has changed its state or not.
      */
     equals(renderObject: RenderObject): boolean;
     /**
@@ -145,7 +146,7 @@ declare class NodeMaterialObserver {
      *
      * @param {RenderObject} renderObject - The render object.
      * @param {NodeFrame} nodeFrame - The current node frame.
-     * @return {Boolean} Whether the given render object requires a refresh or not.
+     * @return {boolean} Whether the given render object requires a refresh or not.
      */
     needsRefresh(renderObject: RenderObject, nodeFrame: NodeFrame): boolean;
 }

three/src/math/Matrix4.d.ts

@@ -128,7 +128,8 @@ export class Matrix4 {
     makeRotationFromQuaternion(q: Quaternion): this;
 
     /**
-     * Constructs a rotation matrix, looking from eye towards center with defined up vector.
+     * Sets the rotation component of the transformation matrix, looking from [eye]{@link Vector3} towards
+     * [target]{@link Vector3}, and oriented by the up-direction [up]{@link Vector3}.
      */
     lookAt(eye: Vector3, target: Vector3, up: Vector3): this;