@types/three 0.180.0 → 0.182.0

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.180.0",
+    "version": "0.182.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -43,12 +43,12 @@
         "@dimforge/rapier3d-compat": "~0.12.0",
         "@tweenjs/tween.js": "~23.1.3",
         "@types/stats.js": "*",
-        "@types/webxr": "*",
+        "@types/webxr": ">=0.5.17",
         "@webgpu/types": "*",
         "fflate": "~0.8.2",
         "meshoptimizer": "~0.22.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "b06ef6e25296a342a8cb4449c825b5786ae345270e744fa27908d1cb8d51f547",
+    "typesPublisherContentHash": "f3281b335e326a31ecce951778649efebdd62165c3fa47922257c4a8aebf0fa4",
     "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

@@ -7,7 +7,7 @@ export const BasicShadowFilter: typeof TSL.BasicShadowFilter;
 export const Break: typeof TSL.Break;
 export const Const: typeof TSL.Const;
 export const Continue: typeof TSL.Continue;
-export const DFGApprox: typeof TSL.DFGApprox;
+export const DFGLUT: typeof TSL.DFGLUT;
 export const D_GGX: typeof TSL.D_GGX;
 export const Discard: typeof TSL.Discard;
 export const EPSILON: typeof TSL.EPSILON;
@@ -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;
@@ -98,6 +100,8 @@ export const bufferAttribute: typeof TSL.bufferAttribute;
 export const bumpMap: typeof TSL.bumpMap;
 export const burn: typeof TSL.burn;
 export const builtin: typeof TSL.builtin;
+export const builtinAOContext: typeof TSL.builtinAOContext;
+export const builtinShadowContext: typeof TSL.builtinShadowContext;
 export const bvec2: typeof TSL.bvec2;
 export const bvec3: typeof TSL.bvec3;
 export const bvec4: typeof TSL.bvec4;
@@ -134,11 +138,13 @@ export const context: typeof TSL.context;
 export const convert: typeof TSL.convert;
 export const convertColorSpace: typeof TSL.convertColorSpace;
 export const convertToTexture: typeof TSL.convertToTexture;
+export const countLeadingZeros: typeof TSL.countLeadingZeros;
+export const countOneBits: typeof TSL.countOneBits;
+export const countTrailingZeros: typeof TSL.countTrailingZeros;
 export const cos: typeof TSL.cos;
 export const cross: typeof TSL.cross;
 export const cubeTexture: typeof TSL.cubeTexture;
 export const cubeTextureBase: typeof TSL.cubeTextureBase;
-export const cubeToUV: typeof TSL.cubeToUV;
 export const dFdx: typeof TSL.dFdx;
 export const dFdy: typeof TSL.dFdy;
 export const dashSize: typeof TSL.dashSize;
@@ -196,6 +202,8 @@ 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 vogelDiskSample: typeof TSL.vogelDiskSample;
 export const getParallaxCorrectNormal: typeof TSL.getParallaxCorrectNormal;
 export const getRoughness: typeof TSL.getRoughness;
 export const getScreenPosition: typeof TSL.getScreenPosition;
@@ -396,6 +404,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;
@@ -409,6 +419,9 @@ export const output: typeof TSL.output;
 export const outputStruct: typeof TSL.outputStruct;
 export const overlay: typeof TSL.overlay;
 export const overloadingFn: typeof TSL.overloadingFn;
+export const packHalf2x16: typeof TSL.packHalf2x16;
+export const packSnorm2x16: typeof TSL.packSnorm2x16;
+export const packUnorm2x16: typeof TSL.packUnorm2x16;
 export const parabola: typeof TSL.parabola;
 export const parallaxDirection: typeof TSL.parallaxDirection;
 export const parallaxUV: typeof TSL.parallaxUV;
@@ -456,6 +469,7 @@ export const remapClamp: typeof TSL.remapClamp;
 export const renderGroup: typeof TSL.renderGroup;
 export const renderOutput: typeof TSL.renderOutput;
 export const rendererReference: typeof TSL.rendererReference;
+export const replaceDefaultUV: typeof TSL.replaceDefaultUV;
 export const rotate: typeof TSL.rotate;
 export const rotateUV: typeof TSL.rotateUV;
 export const roughness: typeof TSL.roughness;
@@ -547,6 +561,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;
@@ -573,6 +588,9 @@ export const uniformCubeTexture: typeof TSL.uniformCubeTexture;
 export const uniformGroup: typeof TSL.uniformGroup;
 export const uniformFlow: typeof TSL.uniformFlow;
 export const uniformTexture: typeof TSL.uniformTexture;
+export const unpackHalf2x16: typeof TSL.unpackHalf2x16;
+export const unpackSnorm2x16: typeof TSL.unpackSnorm2x16;
+export const unpackUnorm2x16: typeof TSL.unpackUnorm2x16;
 export const unpremultiplyAlpha: typeof TSL.unpremultiplyAlpha;
 export const userData: typeof TSL.userData;
 export const uv: typeof TSL.uv;
@@ -612,4 +630,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

@@ -1,15 +1,36 @@
 import { AnimationBlendMode } from "../constants.js";
 import { EventDispatcher } from "../core/EventDispatcher.js";
 import { Object3D } from "../core/Object3D.js";
+import { LinearInterpolant } from "../math/interpolants/LinearInterpolant.js";
 import { AnimationAction } from "./AnimationAction.js";
 import { AnimationClip } from "./AnimationClip.js";
 import { AnimationObjectGroup } from "./AnimationObjectGroup.js";
+import { PropertyMixer } from "./PropertyMixer.js";
 
 export interface AnimationMixerEventMap {
     loop: { action: AnimationAction; loopDelta: number };
     finished: { action: AnimationAction; direction: number };
 }
 
+export interface MixerControlInterpolant extends LinearInterpolant {
+    __cacheIndex: number;
+}
+
+export interface AnimationMixerStats {
+    actions: {
+        readonly total: number;
+        readonly inUse: number;
+    };
+    bindings: {
+        readonly total: number;
+        readonly inUse: number;
+    };
+    controlInterpolants: {
+        readonly total: number;
+        readonly inUse: number;
+    };
+}
+
 /**
  * `AnimationMixer` is a player for animations on a particular object in
  * the scene. When multiple objects in the scene are animated independently,
@@ -28,6 +49,23 @@ export class AnimationMixer extends EventDispatcher<AnimationMixerEventMap> {
      * @default 0
      */
     time: number;
+    protected _root: Object3D | AnimationObjectGroup;
+    protected _actions: AnimationAction[];
+    protected _nActiveActions: number;
+    protected _bindings: PropertyMixer[];
+    protected _nActiveBindings: number;
+    protected _controlInterpolants: MixerControlInterpolant[];
+    protected _nActiveControlInterpolants: number;
+    protected _bindingsByRootAndName: {
+        [rootUuid: string]: { [trackName: string]: PropertyMixer };
+    };
+    protected _actionsByClip: {
+        [clipUuid: string]: {
+            knownActions: AnimationAction[];
+            actionByRoot: { [rootUuid: string]: AnimationAction };
+        };
+    };
+    protected _accuIndex: number;
     /**
      * A scaling factor for the global time.
      *
@@ -38,6 +76,10 @@ export class AnimationMixer extends EventDispatcher<AnimationMixerEventMap> {
      * @default 1
      */
     timeScale: number;
+    /**
+     * The AnimationMixer stats track the actions of the mixer.
+     */
+    stats: AnimationMixerStats;
     /**
      * Returns an instance of {@link AnimationAction} for the passed clip.
      *
@@ -74,7 +116,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 +126,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 +136,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/animation/AnimationUtils.d.ts

@@ -1,4 +1,5 @@
 import { TypedArray, TypedArrayConstructor } from "../core/BufferAttribute.js";
+import { isTypedArray } from "../utils.js";
 import { AnimationClip } from "./AnimationClip.js";
 
 /**
@@ -8,14 +9,7 @@ import { AnimationClip } from "./AnimationClip.js";
  * @param {TypedArray.constructor} type - The constructor of a typed array that defines the new type.
  * @return {TypedArray} The converted array.
  */
-export function convertArray(array: TypedArray | number[], type: TypedArrayConstructor): TypedArray | number[];
-/**
- * Returns `true` if the given object is a typed array.
- *
- * @param {any} object - The object to check.
- * @return {boolean} Whether the given object is a typed array.
- */
-export function isTypedArray(object: unknown): boolean;
+export function convertArray(array: TypedArray | number[], type: TypedArrayConstructor): TypedArray;
 /**
  * Returns an array by which times and values can be sorted.
  *
@@ -169,3 +163,4 @@ export class AnimationUtils {
         fps?: number,
     ): AnimationClip;
 }
+export { isTypedArray };

three/src/constants.d.ts

@@ -508,6 +508,11 @@ export const RGB_ETC2_Format: 37492;
  */
 export const RGBA_ETC2_EAC_Format: 37496;
 
+export const R11_EAC_Format: 37488;
+export const SIGNED_R11_EAC_Format: 37489;
+export const RG11_EAC_Format: 37490;
+export const SIGNED_RG11_EAC_Format: 37491;
+
 // ASTC compressed texture formats
 
 /**
@@ -598,6 +603,10 @@ export type CompressedPixelFormat =
     | typeof RGB_ETC1_Format
     | typeof RGB_ETC2_Format
     | typeof RGBA_ETC2_EAC_Format
+    | typeof R11_EAC_Format
+    | typeof SIGNED_R11_EAC_Format
+    | typeof RG11_EAC_Format
+    | typeof SIGNED_RG11_EAC_Format
     | typeof RGBA_ASTC_4x4_Format
     | typeof RGBA_ASTC_5x4_Format
     | typeof RGBA_ASTC_5x5_Format
@@ -693,6 +702,11 @@ export const LinearTransfer: "linear";
 export const SRGBTransfer: "srgb";
 export type ColorSpaceTransfer = typeof LinearTransfer | typeof SRGBTransfer;
 
+export const NoNormalPacking: "";
+export const NormalRGPacking: "rg";
+export const NormalGAPacking: "ga";
+export type NormalPacking = typeof NoNormalPacking | typeof NormalRGPacking | typeof NormalGAPacking;
+
 // Stencil Op types
 export const ZeroStencilOp: 0;
 export const KeepStencilOp: 7680;

three/src/core/BufferGeometry.d.ts

@@ -163,6 +163,8 @@ export class BufferGeometry<
 
     indirect: IndirectStorageBufferAttribute | null;
 
+    indirectOffset: number | number[];
+
     /**
      * This hashmap has as id the name of the attribute to be set and as value the {@link THREE.BufferAttribute | buffer} to set it to. Rather than accessing this property directly,
      * use {@link setAttribute | .setAttribute} and {@link getAttribute | .getAttribute} to access attributes of this geometry.
@@ -243,7 +245,7 @@ export class BufferGeometry<
      */
     setIndex(index: BufferAttribute | number[] | null): this;
 
-    setIndirect(indirect: IndirectStorageBufferAttribute | null): this;
+    setIndirect(indirect: IndirectStorageBufferAttribute | null, indirectOffset?: number | number[]): this;
 
     getIndirect(): IndirectStorageBufferAttribute | null;
 

three/src/extras/Controls.d.ts

@@ -14,7 +14,7 @@ declare abstract class Controls<TEventMap extends {}> extends EventDispatcher<TE
      * The HTML element used for event listeners. If not provided via the constructor, {@link .connect} must be called
      * after `domElement` has been set.
      */
-    domElement: HTMLElement | null;
+    domElement: HTMLElement | SVGElement | null;
 
     /**
      * When set to `false`, the controls will not respond to user input. Default is `true`.
@@ -26,13 +26,13 @@ declare abstract class Controls<TEventMap extends {}> extends EventDispatcher<TE
      * @param object The object the controls should manage (usually the camera).
      * @param domElement The HTML element used for event listeners. (optional)
      */
-    constructor(object: Object3D, domElement?: HTMLElement | null);
+    constructor(object: Object3D, domElement?: HTMLElement | SVGElement | null);
 
     /**
      * Connects the controls to the DOM. This method has so called "side effects" since it adds the module's event
      * listeners to the DOM.
      */
-    connect(element: HTMLElement): void;
+    connect(element: HTMLElement | SVGElement): void;
 
     /**
      * Disconnects the controls from the DOM.

three/src/lights/DirectionalLight.d.ts

@@ -1,8 +1,14 @@
-import { Object3D } from "../core/Object3D.js";
+import { JSONMeta, Object3D } from "../core/Object3D.js";
 import { ColorRepresentation } from "../math/Color.js";
 import { Vector3 } from "../math/Vector3.js";
 import { DirectionalLightShadow } from "./DirectionalLightShadow.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+import { LightShadowJSON } from "./LightShadow.js";
+
+export interface DirectionalLightJSON extends LightJSON {
+    shadow: LightShadowJSON;
+    target: string;
+}
 
 /**
  * A light that gets emitted in a specific direction
@@ -10,7 +16,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).
@@ -100,4 +105,6 @@ export class DirectionalLight extends Light<DirectionalLightShadow> {
      * Call this method whenever this instance is no longer used in your app.
      */
     dispose(): void;
+
+    toJSON(meta?: JSONMeta): DirectionalLightJSON;
 }

three/src/lights/HemisphereLight.d.ts

@@ -1,6 +1,11 @@
+import { JSONMeta } from "../core/Object3D.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
 import { Vector3 } from "../math/Vector3.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+
+export interface HemisphereLightJSON extends LightJSON {
+    groundColor: number;
+}
 
 /**
  * A light source positioned directly above the scene, with color fading from the sky color to the ground color.
@@ -58,4 +63,6 @@ export class HemisphereLight extends Light<undefined> {
      * @defaultValue `new THREE.Color()` set to white _(0xffffff)_.
      */
     groundColor: Color;
+
+    toJSON(meta?: JSONMeta): HemisphereLightJSON;
 }

three/src/lights/Light.d.ts

@@ -1,27 +1,23 @@
-import { JSONMeta, Object3D, Object3DJSON } from "../core/Object3D.js";
+import { JSONMeta, Object3D, Object3DEventMap, Object3DJSON } from "../core/Object3D.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
-import { LightShadow, LightShadowJSON } from "./LightShadow.js";
+import { LightShadow } from "./LightShadow.js";
 
 export interface LightJSON extends Object3DJSON {
     color: number;
     intensity: number;
+}
 
-    groundColor?: number;
-
-    distance?: number;
-    angle?: number;
-    decay?: number;
-    penumbra?: number;
-
-    shadow?: LightShadowJSON;
-    target?: string;
+export interface LightEventMap extends Object3DEventMap {
+    dispose: {};
 }
 
 /**
  * Abstract base class for lights.
  * @remarks All other light types inherit the properties and methods described here.
  */
-export abstract class Light<TShadowSupport extends LightShadow | undefined = LightShadow | undefined> extends Object3D {
+export abstract class Light<TShadowSupport extends LightShadow | undefined = LightShadow | undefined>
+    extends Object3D<LightEventMap>
+{
     /**
      * Creates a new {@link Light}
      * @remarks

three/src/lights/LightProbe.d.ts

@@ -1,5 +1,10 @@
+import { JSONMeta } from "../core/Object3D.js";
 import { SphericalHarmonics3 } from "../math/SphericalHarmonics3.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+
+export interface LightProbeJSON extends LightJSON {
+    sh: number[];
+}
 
 /**
  * Light probes are an alternative way of adding light to a 3D scene.
@@ -42,6 +47,5 @@ export class LightProbe extends Light {
      */
     sh: SphericalHarmonics3;
 
-    /** @internal */
-    fromJSON(json: {}): LightProbe;
+    toJSON(meta?: JSONMeta): LightProbeJSON;
 }

three/src/lights/PointLight.d.ts

@@ -1,7 +1,16 @@
+import { JSONMeta } from "../core/Object3D.js";
 import { ColorRepresentation } from "../math/Color.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+import { LightShadowJSON } from "./LightShadow.js";
 import { PointLightShadow } from "./PointLightShadow.js";
 
+export interface PointLightJSON extends LightJSON {
+    distance: number;
+    decay: number;
+
+    shadow: LightShadowJSON;
+}
+
 /**
  * A light that gets emitted from a single point in all directions
  * @remarks
@@ -99,4 +108,6 @@ export class PointLight extends Light<PointLightShadow> {
      * @remarks Expects a `Float`
      */
     power: number;
+
+    toJSON(meta?: JSONMeta): PointLightJSON;
 }

three/src/lights/PointLightShadow.d.ts

@@ -1,5 +1,4 @@
 import { PerspectiveCamera } from "../cameras/PerspectiveCamera.js";
-import { Light } from "./Light.js";
 import { LightShadow } from "./LightShadow.js";
 
 /**
@@ -12,11 +11,5 @@ export class PointLightShadow extends LightShadow<PerspectiveCamera> {
      * @remarks This is a _constant_ value
      * @defaultValue `true`
      */
-    readonly isPointLightShadow = true;
-
-    /**
-     * Update the matrices for the camera and shadow, used internally by the renderer.
-     * @param light The light for which the shadow is being rendered.
-     */
-    override updateMatrices(light: Light, viewportIndex?: number): void;
+    readonly isPointLightShadow: true;
 }

three/src/lights/SpotLight.d.ts

@@ -1,10 +1,23 @@
-import { Object3D } from "../core/Object3D.js";
+import { JSONMeta, Object3D } from "../core/Object3D.js";
 import { ColorRepresentation } from "../math/Color.js";
 import { Vector3 } from "../math/Vector3.js";
 import { Texture } from "../textures/Texture.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+import { LightShadowJSON } from "./LightShadow.js";
 import { SpotLightShadow } from "./SpotLightShadow.js";
 
+export interface SpotLightJSON extends LightJSON {
+    distance: number;
+    angle: number;
+    decay: number;
+    penumbra: number;
+
+    target: string;
+    map?: string | undefined;
+
+    shadow: LightShadowJSON;
+}
+
 /**
  * This light gets emitted from a single point in one direction, along a cone that increases in size the further from the light it gets.
  * @example
@@ -161,4 +174,6 @@ export class SpotLight extends Light<SpotLightShadow> {
      * @remarks **Warning**: {@link SpotLight.map} is disabled if {@link SpotLight.castShadow} is `false`.
      */
     map: Texture | null;
+
+    toJSON(meta?: JSONMeta): SpotLightJSON;
 }

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,13 +541,14 @@ 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`.
      *
      * @default 0
      */
     readonly version: number;
+    defines?: Record<string, unknown> | undefined;
     /**
      * An optional callback that is executed immediately before the material is used to render a 3D object.
      *
@@ -575,7 +576,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
      */