@types/three 0.168.0 → 0.170.0

three/src/materials/MeshNormalMaterial.d.ts

@@ -28,11 +28,6 @@ export class MeshNormalMaterial extends Material {
      */
     readonly isMeshNormalMaterial: true;
 
-    /**
-     * @default 'MeshNormalMaterial'
-     */
-    type: string;
-
     /**
      * @default null
      */

three/src/materials/MeshPhongMaterial.d.ts

@@ -52,11 +52,6 @@ export class MeshPhongMaterial extends Material {
      */
     readonly isMeshPhongMaterial: true;
 
-    /**
-     * @default 'MeshNormalMaterial'
-     */
-    type: string;
-
     /**
      * @default new THREE.Color( 0xffffff )
      */

three/src/materials/MeshPhysicalMaterial.d.ts

@@ -62,11 +62,6 @@ export class MeshPhysicalMaterial extends MeshStandardMaterial {
      */
     defines: { [key: string]: any };
 
-    /**
-     * @default 'MeshPhysicalMaterial'
-     */
-    type: string;
-
     /**
      * @default 0
      */

three/src/materials/MeshStandardMaterial.d.ts

@@ -47,11 +47,6 @@ export class MeshStandardMaterial extends Material {
      */
     readonly isMeshStandardMaterial: true;
 
-    /**
-     * @default 'MeshStandardMaterial'
-     */
-    type: string;
-
     /**
      * @default { 'STANDARD': '' }
      */

three/src/materials/MeshToonMaterial.d.ts

@@ -43,11 +43,6 @@ export class MeshToonMaterial extends Material {
      */
     readonly isMeshToonMaterial: true;
 
-    /**
-     * @default 'MeshToonMaterial'
-     */
-    type: string;
-
     /**
      * @default { 'TOON': '' }
      */

three/src/materials/PointsMaterial.d.ts

@@ -21,11 +21,6 @@ export class PointsMaterial extends Material {
      */
     readonly isPointsMaterial: true;
 
-    /**
-     * @default 'PointsMaterial'
-     */
-    type: string;
-
     /**
      * @default new THREE.Color( 0xffffff )
      */

three/src/materials/RawShaderMaterial.d.ts

@@ -9,6 +9,4 @@ export class RawShaderMaterial extends ShaderMaterial {
      * @defaultValue `true`
      */
     readonly isRawShaderMaterial: true;
-
-    override readonly type: "RawShaderMaterial";
 }

three/src/materials/ShaderMaterial.d.ts

@@ -79,11 +79,6 @@ export class ShaderMaterial extends Material {
      */
     readonly isShaderMaterial: true;
 
-    /**
-     * @default 'ShaderMaterial'
-     */
-    type: string;
-
     /**
      * @default {}
      */

three/src/materials/ShadowMaterial.d.ts

@@ -16,11 +16,6 @@ export class ShadowMaterial extends Material {
      */
     readonly isShadowMaterial: true;
 
-    /**
-     * @default 'ShadowMaterial'
-     */
-    type: string;
-
     /**
      * @default new THREE.Color( 0x000000 )
      */

three/src/materials/SpriteMaterial.d.ts

@@ -20,11 +20,6 @@ export class SpriteMaterial extends Material {
      */
     readonly isSpriteMaterial: true;
 
-    /**
-     * @default 'SpriteMaterial'
-     */
-    type: string;
-
     /**
      * @default new THREE.Color( 0xffffff )
      */

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

@@ -4,7 +4,7 @@ import { Texture } from "../../textures/Texture.js";
 import { MeshNormalMaterialParameters } from "../MeshNormalMaterial.js";
 import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
 
-export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshNormalMaterialParameters {
+export interface MeshNormalNodeMaterialParameters extends NodeMaterialParameters, MeshNormalMaterialParameters {
 }
 
 export default class MeshNormalNodeMaterial extends NodeMaterial {
@@ -24,5 +24,5 @@ export default class MeshNormalNodeMaterial extends NodeMaterial {
     wireframeLinewidth: number;
     flatShading: boolean;
 
-    constructor(parameters?: MeshBasicNodeMaterialParameters);
+    constructor(parameters?: MeshNormalNodeMaterialParameters);
 }

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

@@ -24,6 +24,7 @@ export interface NodeMaterialParameters extends MaterialParameters {
     alphaTestNode?: Node | null | undefined;
 
     positionNode?: Node | null | undefined;
+    geometryNode?: Node | null | undefined;
 
     depthNode?: Node | null | undefined;
     shadowNode?: Node | null | undefined;
@@ -35,6 +36,8 @@ export interface NodeMaterialParameters extends MaterialParameters {
 }
 
 declare class NodeMaterial extends Material {
+    static get type(): string;
+
     readonly isNodeMaterial: true;
 
     fog: boolean;
@@ -52,6 +55,7 @@ declare class NodeMaterial extends Material {
     alphaTestNode: Node | null;
 
     positionNode: Node | null;
+    geometryNode: Node | null;
 
     depthNode: Node | null;
     shadowNode: Node | null;
@@ -85,7 +89,3 @@ declare class NodeMaterial extends Material {
 }
 
 export default NodeMaterial;
-
-export function registerNodeMaterial(type: string, nodeMaterialClass: { new(): NodeMaterial }): string;
-
-export function createNodeMaterialFromType(type: string): NodeMaterial;

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

@@ -1,18 +1,21 @@
-export { default as InstancedPointsNodeMaterial } from "./InstancedPointsNodeMaterial.js";
-export { default as Line2NodeMaterial } from "./Line2NodeMaterial.js";
-export { default as LineBasicNodeMaterial } from "./LineBasicNodeMaterial.js";
-export { default as LineDashedNodeMaterial } from "./LineDashedNodeMaterial.js";
-export { default as MeshBasicNodeMaterial } from "./MeshBasicNodeMaterial.js";
-export { default as MeshLambertNodeMaterial } from "./MeshLambertNodeMaterial.js";
-export { default as MeshMatcapNodeMaterial } from "./MeshMatcapNodeMaterial.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 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";
+export { default as MeshBasicNodeMaterial, MeshBasicNodeMaterialParameters } from "./MeshBasicNodeMaterial.js";
+export { default as MeshLambertNodeMaterial, MeshLambertNodeMaterialParameters } from "./MeshLambertNodeMaterial.js";
+export { default as MeshMatcapNodeMaterial, MeshMatcapNodeMaterialParameters } from "./MeshMatcapNodeMaterial.js";
+export { default as MeshNormalNodeMaterial, MeshNormalNodeMaterialParameters } from "./MeshNormalNodeMaterial.js";
+export { default as MeshPhongNodeMaterial, MeshPhongNodeMaterialParameters } from "./MeshPhongNodeMaterial.js";
+export { default as MeshPhysicalNodeMaterial, MeshPhysicalNodeMaterialParameters } from "./MeshPhysicalNodeMaterial.js";
 export { default as MeshSSSNodeMaterial } from "./MeshSSSNodeMaterial.js";
-export { default as MeshStandardNodeMaterial } from "./MeshStandardNodeMaterial.js";
-export { default as MeshToonNodeMaterial } from "./MeshToonNodeMaterial.js";
-export { default as NodeMaterial } from "./NodeMaterial.js";
-export { default as PointsNodeMaterial } from "./PointsNodeMaterial.js";
-export { default as ShadowNodeMaterial } from "./ShadowNodeMaterial.js";
-export { default as SpriteNodeMaterial } from "./SpriteNodeMaterial.js";
+export { default as MeshStandardNodeMaterial, MeshStandardNodeMaterialParameters } from "./MeshStandardNodeMaterial.js";
+export { default as MeshToonNodeMaterial, MeshToonNodeMaterialParameters } from "./MeshToonNodeMaterial.js";
+export { default as NodeMaterial, NodeMaterialParameters } from "./NodeMaterial.js";
+export { default as PointsNodeMaterial, PointsNodeMaterialParameters } from "./PointsNodeMaterial.js";
+export { default as ShadowNodeMaterial, ShadowNodeMaterialParameters } from "./ShadowNodeMaterial.js";
+export { default as SpriteNodeMaterial, SpriteNodeMaterialParameters } from "./SpriteNodeMaterial.js";
 export { default as VolumeNodeMaterial } from "./VolumeNodeMaterial.js";

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

@@ -0,0 +1,96 @@
+import { BufferAttribute } from "../../../core/BufferAttribute.js";
+import { Matrix4 } from "../../../math/Matrix4.js";
+import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
+import NodeFrame from "../../../nodes/core/NodeFrame.js";
+import RenderObject from "../../../renderers/common/RenderObject.js";
+import { Material } from "../../Material.js";
+declare const refreshUniforms: readonly [
+    "alphaMap",
+    "alphaTest",
+    "anisotropy",
+    "anisotropyMap",
+    "anisotropyRotation",
+    "aoMap",
+    "attenuationColor",
+    "attenuationDistance",
+    "bumpMap",
+    "clearcoat",
+    "clearcoatMap",
+    "clearcoatNormalMap",
+    "clearcoatNormalScale",
+    "clearcoatRoughness",
+    "color",
+    "dispersion",
+    "displacementMap",
+    "emissive",
+    "emissiveMap",
+    "envMap",
+    "gradientMap",
+    "ior",
+    "iridescence",
+    "iridescenceIOR",
+    "iridescenceMap",
+    "iridescenceThicknessMap",
+    "lightMap",
+    "map",
+    "matcap",
+    "metalness",
+    "metalnessMap",
+    "normalMap",
+    "normalScale",
+    "opacity",
+    "roughness",
+    "roughnessMap",
+    "sheen",
+    "sheenColor",
+    "sheenColorMap",
+    "sheenRoughnessMap",
+    "shininess",
+    "specular",
+    "specularColor",
+    "specularColorMap",
+    "specularIntensity",
+    "specularIntensityMap",
+    "specularMap",
+    "thickness",
+    "transmission",
+    "transmissionMap",
+];
+type RefreshUniform = (typeof refreshUniforms)[number];
+type MaterialData = {
+    [K in RefreshUniform]?: unknown;
+};
+interface AttributesData {
+    [name: string]: {
+        version: number;
+    };
+}
+interface RenderObjectData {
+    material: MaterialData;
+    geometry: {
+        attributes: AttributesData;
+        indexVersion: number | null;
+        drawRange: {
+            start: number;
+            count: number;
+        };
+    };
+    worldMatrix: Matrix4;
+    version?: number;
+}
+declare class NodeMaterialObserver {
+    renderObjects: WeakMap<RenderObject, RenderObjectData>;
+    hasNode: boolean;
+    hasAnimation: boolean;
+    refreshUniforms: readonly RefreshUniform[];
+    renderId: number;
+    constructor(builder: NodeBuilder);
+    firstInitialization(renderObject: RenderObject): boolean;
+    getRenderObjectData(renderObject: RenderObject): RenderObjectData;
+    getAttributesData(attributes: Record<string, BufferAttribute>): AttributesData;
+    containsNode(builder: NodeBuilder): boolean;
+    getMaterialData(material: Material): MaterialData;
+    equals(renderObject: RenderObject): boolean;
+    needsRefresh(renderObject: RenderObject, nodeFrame: NodeFrame): boolean;
+}
+export default NodeMaterialObserver;

three/src/math/Color.d.ts

@@ -1,4 +1,3 @@
-import { ColorSpace } from "../constants.js";
 import { Matrix3 } from "./Matrix3.js";
 import { Vector3 } from "./Vector3.js";
 
@@ -173,12 +172,30 @@ export interface RGB {
 }
 
 /**
- * Represents a color. See also {@link ColorUtils}.
+ * Class representing a color.
  *
- * see {@link https://github.com/mrdoob/three.js/blob/master/src/math/Color.js|src/math/Color.js}
+ * A Color instance is represented by RGB components in the linear <i>working color space</i>, which defaults to
+ * `LinearSRGBColorSpace`. Inputs conventionally using `SRGBColorSpace` (such as hexadecimals and CSS strings) are
+ * converted to the working color space automatically.
  *
- * @example
- * const color = new THREE.Color( 0xff0000 );
+ * ```
+ * // converted automatically from SRGBColorSpace to LinearSRGBColorSpace
+ * const color = new THREE.Color().setHex( 0x112233 );
+ * ```
+ *
+ * Source color spaces may be specified explicitly, to ensure correct conversions.
+ *
+ * ```
+ * // assumed already LinearSRGBColorSpace; no conversion
+ * const color = new THREE.Color().setRGB( 0.5, 0.5, 0.5 );
+ *
+ * // converted explicitly from SRGBColorSpace to LinearSRGBColorSpace
+ * const color = new THREE.Color().setRGB( 0.5, 0.5, 0.5, SRGBColorSpace );
+ * ```
+ *
+ * If THREE.ColorManagement is disabled, no conversions occur. For details, see <i>Color management</i>.
+ *
+ * Iterating through a Color instance will yield its components (r, g, b) in the corresponding order.
  */
 export class Color {
     constructor(color?: ColorRepresentation);
@@ -187,19 +204,19 @@ export class Color {
     readonly isColor: true;
 
     /**
-     * Red channel value between 0 and 1. Default is 1.
+     * Red channel value between `0.0` and `1.0`. Default is `1`.
      * @default 1
      */
     r: number;
 
     /**
-     * Green channel value between 0 and 1. Default is 1.
+     * Green channel value between `0.0` and `1.0`. Default is `1`.
      * @default 1
      */
     g: number;
 
     /**
-     * Blue channel value between 0 and 1. Default is 1.
+     * Blue channel value between `0.0` and `1.0`. Default is `1`.
      * @default 1
      */
     b: number;
@@ -213,7 +230,7 @@ export class Color {
     setFromVector3(vector: Vector3): this;
 
     setScalar(scalar: number): Color;
-    setHex(hex: number, colorSpace?: ColorSpace): Color;
+    setHex(hex: number, colorSpace?: string): Color;
 
     /**
      * Sets this color from RGB values.
@@ -221,7 +238,7 @@ export class Color {
      * @param g Green channel value between 0 and 1.
      * @param b Blue channel value between 0 and 1.
      */
-    setRGB(r: number, g: number, b: number, colorSpace?: ColorSpace): Color;
+    setRGB(r: number, g: number, b: number, colorSpace?: string): Color;
 
     /**
      * Sets this color from HSL values.
@@ -231,20 +248,20 @@ export class Color {
      * @param s Saturation value channel between 0 and 1.
      * @param l Value channel value between 0 and 1.
      */
-    setHSL(h: number, s: number, l: number, colorSpace?: ColorSpace): Color;
+    setHSL(h: number, s: number, l: number, colorSpace?: string): Color;
 
     /**
      * Sets this color from a CSS context style string.
      * @param contextStyle Color in CSS context style format.
      */
-    setStyle(style: string, colorSpace?: ColorSpace): Color;
+    setStyle(style: string, colorSpace?: string): Color;
 
     /**
      * Sets this color from a color name.
      * Faster than {@link Color#setStyle .setStyle()} method if you don't need the other CSS-style formats.
      * @param style Color name in X11 format.
      */
-    setColorName(style: string, colorSpace?: ColorSpace): Color;
+    setColorName(style: string, colorSpace?: string): Color;
 
     /**
      * Clones this color.
@@ -258,46 +275,46 @@ export class Color {
     copy(color: Color): this;
 
     /**
-     * Copies given color making conversion from sRGB to linear space.
+     * Copies given color making conversion from `SRGBColorSpace` to `LinearSRGBColorSpace`.
      * @param color Color to copy.
      */
     copySRGBToLinear(color: Color): Color;
 
     /**
-     * Copies given color making conversion from linear to sRGB space.
+     * Copies given color making conversion from `LinearSRGBColorSpace` to `SRGBColorSpace`.
      * @param color Color to copy.
      */
     copyLinearToSRGB(color: Color): Color;
 
     /**
-     * Converts this color from sRGB to linear space.
+     * Converts this color from `SRGBColorSpace` to `LinearSRGBColorSpace`.
      */
     convertSRGBToLinear(): Color;
 
     /**
-     * Converts this color from linear to sRGB space.
+     * Converts this color from `LinearSRGBColorSpace` to `SRGBColorSpace`.
      */
     convertLinearToSRGB(): Color;
 
     /**
      * Returns the hexadecimal value of this color.
      */
-    getHex(colorSpace?: ColorSpace): number;
+    getHex(colorSpace?: string): number;
 
     /**
      * Returns the string formated hexadecimal value of this color.
      */
-    getHexString(colorSpace?: ColorSpace): string;
+    getHexString(colorSpace?: string): string;
 
-    getHSL(target: HSL, colorSpace?: ColorSpace): HSL;
+    getHSL(target: HSL, colorSpace?: string): HSL;
 
-    getRGB(target: RGB, colorSpace?: ColorSpace): RGB;
+    getRGB(target: RGB, colorSpace?: string): RGB;
 
     /**
      * Returns the value of this color in CSS context style.
      * Example: rgb(r, g, b)
      */
-    getStyle(colorSpace?: ColorSpace): string;
+    getStyle(colorSpace?: string): string;
 
     offsetHSL(h: number, s: number, l: number): this;
 

three/src/math/ColorManagement.d.ts

@@ -1,45 +1,45 @@
-import {
-    ColorSpace,
-    ColorSpacePrimaries,
-    ColorSpaceTransfer,
-    DisplayP3ColorSpace,
-    LinearDisplayP3ColorSpace,
-    LinearSRGBColorSpace,
-    SRGBColorSpace,
-} from "../constants.js";
+import { ColorSpaceTransfer } from "../constants.js";
 import { Color } from "./Color.js";
+import { Matrix3 } from "./Matrix3.js";
 import { Vector3 } from "./Vector3.js";
 
-export type WorkingColorSpace = typeof LinearSRGBColorSpace | typeof LinearDisplayP3ColorSpace;
-export type DefinedColorSpace =
-    | typeof LinearSRGBColorSpace
-    | typeof SRGBColorSpace
-    | typeof LinearDisplayP3ColorSpace
-    | typeof DisplayP3ColorSpace;
+export interface ColorSpaceDefinition {
+    primaries: [number, number, number, number, number, number];
+    whitePoint: [number, number];
+    transfer: ColorSpaceTransfer;
+    toXYZ: Matrix3;
+    fromXYZ: Matrix3;
+    luminanceCoefficients: [number, number, number];
+    workingColorSpaceConfig?: { unpackColorSpace: string };
+    outputColorSpaceConfig?: { drawingBufferColorSpace: string };
+}
 
 export interface ColorManagement {
     /**
-     * @default false
+     * @default true
      */
     enabled: boolean;
 
     /**
      * @default LinearSRGBColorSpace
      */
-    get workingColorSpace(): WorkingColorSpace;
-    set workingColorSpace(colorSpace: WorkingColorSpace);
+    workingColorSpace: string;
+
+    spaces: Record<string, ColorSpaceDefinition>;
+
+    convert: (color: Color, sourceColorSpace: string, targetColorSpace: string) => Color;
 
-    convert: (color: Color, sourceColorSpace: DefinedColorSpace, targetColorSpace: DefinedColorSpace) => Color;
+    fromWorkingColorSpace: (color: Color, targetColorSpace: string) => Color;
 
-    fromWorkingColorSpace: (color: Color, targetColorSpace: DefinedColorSpace) => Color;
+    toWorkingColorSpace: (color: Color, sourceColorSpace: string) => Color;
 
-    toWorkingColorSpace: (color: Color, sourceColorSpace: DefinedColorSpace) => Color;
+    getPrimaries: (colorSpace: string) => [number, number, number, number, number, number];
 
-    getPrimaries: (colorSpace: DefinedColorSpace) => ColorSpacePrimaries;
+    getTransfer: (colorSpace: string) => ColorSpaceTransfer;
 
-    getTransfer: (colorSpace: ColorSpace) => ColorSpaceTransfer;
+    getLuminanceCoefficients: (target: Vector3, colorSpace?: string) => [number, number, number];
 
-    getLuminanceCoefficients: (target: Vector3, colorSpace?: ColorSpace) => Vector3;
+    define: (colorSpaces: Record<string, ColorSpaceDefinition>) => void;
 }
 
 export const ColorManagement: ColorManagement;

three/src/math/Quaternion.d.ts

@@ -129,7 +129,7 @@ export class Quaternion {
      * @param array the source array or array-like.
      * @param offset (optional) offset into the array. Default is 0.
      */
-    fromArray(array: QuaternionTuple, offset?: number): this;
+    fromArray(array: number[] | ArrayLike<number>, offset?: number): this;
 
     /**
      * Returns an array [x, y, z, w], or copies x, y, z and w into the provided array.
@@ -137,7 +137,8 @@ export class Quaternion {
      * @param offset (optional) optional offset into the array.
      * @return The created or provided array.
      */
-    toArray(array?: number[], offset?: number): QuaternionTuple;
+    toArray(array?: number[], offset?: number): number[];
+    toArray(array?: QuaternionTuple, offset?: 0): QuaternionTuple;
 
     /**
      * Copies x, y, z and w into the provided array-like.
@@ -145,7 +146,7 @@ export class Quaternion {
      * @param offset (optional) optional offset into the array.
      * @return The provided array-like.
      */
-    toArray(array: ArrayLike<number>, offset?: number): QuaternionTuple;
+    toArray(array: ArrayLike<number>, offset?: number): ArrayLike<number>;
 
     /**
      * This method defines the serialization result of Quaternion.

three/src/math/Triangle.d.ts

@@ -82,5 +82,29 @@ export class Triangle {
         v3: Vector4,
         target: Vector4,
     ): Vector4 | null;
+    static getInterpolatedAttribute(
+        attr: BufferAttribute,
+        i1: number,
+        i2: number,
+        i3: number,
+        barycoord: Vector3,
+        target: Vector2,
+    ): Vector2;
+    static getInterpolatedAttribute(
+        attr: BufferAttribute,
+        i1: number,
+        i2: number,
+        i3: number,
+        barycoord: Vector3,
+        target: Vector3,
+    ): Vector3;
+    static getInterpolatedAttribute(
+        attr: BufferAttribute,
+        i1: number,
+        i2: number,
+        i3: number,
+        barycoord: Vector3,
+        target: Vector4,
+    ): Vector4;
     static isFrontFacing(a: Vector3, b: Vector3, c: Vector3, direction: Vector3): boolean;
 }

three/src/math/Vector4.d.ts

@@ -119,6 +119,8 @@ export class Vector4 {
 
     applyMatrix4(m: Matrix4): this;
 
+    divide(v: Vector4Like): this;
+
     /**
      * Divides this vector by scalar s.
      * Set vector to ( 0, 0, 0 ) if s == 0.