@types/three 0.176.0 → 0.178.0

three/src/materials/SpriteMaterial.d.ts

@@ -1,61 +1,90 @@
-import { Color, ColorRepresentation } from "../math/Color.js";
+import { Color } from "../math/Color.js";
 import { Texture } from "../textures/Texture.js";
-import { Material, MaterialParameters } from "./Material.js";
-
-export interface SpriteMaterialParameters extends MaterialParameters {
-    color?: ColorRepresentation | undefined;
-    map?: Texture | null | undefined;
-    alphaMap?: Texture | null | undefined;
-    rotation?: number | undefined;
-    sizeAttenuation?: boolean | undefined;
-    fog?: boolean | undefined;
-}
-
-export class SpriteMaterial extends Material {
-    constructor(parameters?: SpriteMaterialParameters);
-    /**
-     * Read-only flag to check if a given object is of type {@link SpriteMaterial}.
-     * @remarks This is a _constant_ value
-     * @defaultValue `true`
-     */
-    readonly isSpriteMaterial: true;
+import { MapColorPropertiesToColorRepresentations, Material, MaterialProperties } from "./Material.js";
 
+export interface SpriteMaterialProperties extends MaterialProperties {
     /**
-     * @default new THREE.Color( 0xffffff )
+     * Color of the material.
+     *
+     * @default (1,1,1)
      */
     color: Color;
-
     /**
+     * The color map. May optionally include an alpha channel, typically combined
+     * with {@link Material#transparent} or {@link Material#alphaTest}. The texture map
+     * color is modulated by the diffuse `color`.
+     *
      * @default null
      */
     map: Texture | null;
-
     /**
+     * The alpha map is a grayscale texture that controls the opacity across the
+     * surface (black: fully transparent; white: fully opaque).
+     *
+     * Only the color of the texture is used, ignoring the alpha channel if one
+     * exists. For RGB and RGBA textures, the renderer will use the green channel
+     * when sampling this texture due to the extra bit of precision provided for
+     * green in DXT-compressed and uncompressed RGB 565 formats. Luminance-only and
+     * luminance/alpha textures will also still work as expected.
+     *
      * @default null
      */
     alphaMap: Texture | null;
-
     /**
+     * The rotation of the sprite in radians.
+     *
      * @default 0
      */
     rotation: number;
-
     /**
+     * Specifies whether size of the sprite is attenuated by the camera depth (perspective camera only).
+     *
      * @default true
      */
     sizeAttenuation: boolean;
-
     /**
+     * Whether the material is affected by fog or not.
+     *
      * @default true
      */
-    transparent: boolean;
+    fog: boolean;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface SpriteMaterialParameters
+    extends Partial<MapColorPropertiesToColorRepresentations<SpriteMaterialProperties>>
+{}
 
+/**
+ * A material for rendering instances of {@link Sprite}.
+ *
+ * ```js
+ * const map = new THREE.TextureLoader().load( 'textures/sprite.png' );
+ * const material = new THREE.SpriteMaterial( { map: map, color: 0xffffff } );
+ *
+ * const sprite = new THREE.Sprite( material );
+ * sprite.scale.set(200, 200, 1)
+ * scene.add( sprite );
+ * ```
+ */
+export class SpriteMaterial extends Material {
     /**
-     * Whether the material is affected by fog. Default is true.
-     * @default fog
+     * Constructs a new sprite material.
+     *
+     * @param {Object} [parameters] - An object with one or more properties
+     * defining the material's appearance. Any property of the material
+     * (including any property from inherited materials) can be passed
+     * in here. Color values can be passed any type of value accepted
+     * by {@link Color#set}.
      */
-    fog: boolean;
-
-    setValues(parameters: SpriteMaterialParameters): void;
-    copy(source: SpriteMaterial): this;
+    constructor(parameters?: SpriteMaterialParameters);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
+    readonly isSpriteMaterial: boolean;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface SpriteMaterial extends SpriteMaterialProperties {}

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

@@ -1,54 +1,101 @@
-import { Color } from "../../math/Color.js";
 import Node from "../../nodes/core/Node.js";
-import { Texture } from "../../textures/Texture.js";
-import { LineDashedMaterialParameters } from "../LineDashedMaterial.js";
-import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+import { LineDashedMaterialParameters, LineDashedMaterialProperties } from "../LineDashedMaterial.js";
+import { MapColorPropertiesToColorRepresentations } from "../Material.js";
+import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
-export interface Line2NodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
-    worldUnits?: boolean | undefined;
-    dashed?: boolean | undefined;
-}
-
-export default class Line2NodeMaterial extends NodeMaterial {
-    lights: boolean;
-
-    // Properties from LineDashedMaterial
-    readonly isLineDashedMaterial: true;
-    scale: number;
-    dashSize: number;
-    gapSize: number;
-
-    // Properties from LineBasicMaterial
-    readonly isLineBasicMaterial: true;
-    color: Color;
-    fog: boolean;
-    linewidth: number;
-    linecap: string;
-    linejoin: string;
-    map: Texture | null;
-
-    useAlphaToCoverage: boolean;
+export interface Line2NodeMaterialNodeProperties extends NodeMaterialNodeProperties {
+    /**
+     * Whether vertex colors should be used or not.
+     *
+     * @default false
+     */
     useColor: boolean;
-    useDash: boolean;
-    useWorldUnits: boolean;
-
+    /**
+     * The dash offset.
+     *
+     * @default 0
+     */
     dashOffset: number;
+    /**
+     * The line width.
+     *
+     * @default 0
+     */
     lineWidth: number;
-
+    /**
+     * Defines the lines color.
+     *
+     * @default null
+     */
     lineColorNode: Node | null;
-
+    /**
+     * Defines the offset.
+     *
+     * @default null
+     */
     offsetNode: Node | null;
+    /**
+     * Defines the dash scale.
+     *
+     * @default null
+     */
     dashScaleNode: Node | null;
+    /**
+     * Defines the dash size.
+     *
+     * @default null
+     */
     dashSizeNode: Node | null;
+    /**
+     * Defines the gap size.
+     *
+     * @default null
+     */
     gapSizeNode: Node | null;
+    set worldUnits(value: boolean);
+    /**
+     * Whether the lines should sized in world units or not.
+     * When set to `false` the unit is pixel.
+     *
+     * @default false
+     */
+    get worldUnits(): boolean;
+    set dashed(value: boolean);
+    /**
+     * Whether the lines should be dashed or not.
+     *
+     * @default false
+     */
+    get dashed(): boolean;
+}
 
-    constructor(parameters?: Line2NodeMaterialParameters);
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface Line2NodeMaterialParameters
+    extends
+        Partial<MapColorPropertiesToColorRepresentations<Line2NodeMaterialNodeProperties>>,
+        LineDashedMaterialParameters
+{}
 
-    setupShaders(): void;
+/**
+ * This node material can be used to render lines with a size larger than one
+ * by representing them as instanced meshes.
+ */
+declare class Line2NodeMaterial extends NodeMaterial {
+    /**
+     * Constructs a new node material for wide line rendering.
+     *
+     * @param {Object} [parameters={}] - The configuration parameter.
+     */
+    constructor(parameters?: Line2NodeMaterialParameters);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
+    readonly isLine2NodeMaterial: boolean;
+}
 
-    get worldUnits(): boolean;
-    set worldUnits(value: boolean);
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface Line2NodeMaterial extends Line2NodeMaterialNodeProperties, LineDashedMaterialProperties {}
 
-    get dashed(): boolean;
-    set dashed(value: boolean);
-}
+export default Line2NodeMaterial;

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

@@ -1,22 +1,41 @@
-import { Color } from "../../math/Color.js";
-import { Texture } from "../../textures/Texture.js";
-import { LineBasicMaterialParameters } from "../LineBasicMaterial.js";
-import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+import { LineBasicMaterialParameters, LineBasicMaterialProperties } from "../LineBasicMaterial.js";
+import { MapColorPropertiesToColorRepresentations } from "../Material.js";
+import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
-export interface LineBasicNodeMaterialParameters extends NodeMaterialParameters, LineBasicMaterialParameters {
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface LineBasicNodeMaterialNodeProperties extends NodeMaterialNodeProperties {
 }
 
-export default class LineBasicNodeMaterial extends NodeMaterial {
-    readonly isLineBasicNodeMaterial: true;
-
-    // Properties from LineBasicMaterial
-    readonly isLineBasicMaterial: true;
-    color: Color;
-    fog: boolean;
-    linewidth: number;
-    linecap: string;
-    linejoin: string;
-    map: Texture | null;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface LineBasicNodeMaterialParameters
+    extends
+        Partial<MapColorPropertiesToColorRepresentations<LineBasicNodeMaterialNodeProperties>>,
+        LineBasicMaterialParameters
+{}
 
+/**
+ * Node material version of {@link LineBasicMaterial}.
+ *
+ * @augments NodeMaterial
+ */
+declare class LineBasicNodeMaterial extends NodeMaterial {
+    /**
+     * Constructs a new line basic node material.
+     *
+     * @param {Object} [parameters] - The configuration parameter.
+     */
     constructor(parameters?: LineBasicNodeMaterialParameters);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isLineBasicNodeMaterial: boolean;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface LineBasicNodeMaterial extends LineBasicNodeMaterialNodeProperties, LineBasicMaterialProperties {}
+
+export default LineBasicNodeMaterial;

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

@@ -1,32 +1,87 @@
 import Node from "../../nodes/core/Node.js";
-import { LineDashedMaterialParameters } from "../LineDashedMaterial.js";
-import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
-
-export interface LineDashedNodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
-    dashOffset?: number | undefined;
-    offsetNode?: Node | null | undefined;
-    dashScaleNode?: Node | null | undefined;
-    dashSizeNode?: Node | null | undefined;
-    gapSizeNode?: Node | null | undefined;
-}
-
-declare class LineDashedNodeMaterial extends NodeMaterial {
-    readonly isLineDashedNodeMaterial: true;
+import { LineDashedMaterialParameters, LineDashedMaterialProperties } from "../LineDashedMaterial.js";
+import { MapColorPropertiesToColorRepresentations } from "../Material.js";
+import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
+export interface LineDashedNodeMaterialNodeProperties extends NodeMaterialNodeProperties {
+    /**
+     * The dash offset.
+     *
+     * @default 0
+     */
     dashOffset: number;
-
+    /**
+     * The offset of dash materials is by default inferred from the `dashOffset`
+     * property. This node property allows to overwrite the default
+     * and define the offset with a node instead.
+     *
+     * If you don't want to overwrite the offset but modify the existing
+     * value instead, use {@link materialLineDashOffset}.
+     *
+     * @default null
+     */
     offsetNode: Node | null;
+    /**
+     * The scale of dash materials is by default inferred from the `scale`
+     * property. This node property allows to overwrite the default
+     * and define the scale with a node instead.
+     *
+     * If you don't want to overwrite the scale but modify the existing
+     * value instead, use {@link materialLineScale}.
+     *
+     * @default null
+     */
     dashScaleNode: Node | null;
+    /**
+     * The dash size of dash materials is by default inferred from the `dashSize`
+     * property. This node property allows to overwrite the default
+     * and define the dash size with a node instead.
+     *
+     * If you don't want to overwrite the dash size but modify the existing
+     * value instead, use {@link materialLineDashSize}.
+     *
+     * @default null
+     */
     dashSizeNode: Node | null;
+    /**
+     * The gap size of dash materials is by default inferred from the `gapSize`
+     * property. This node property allows to overwrite the default
+     * and define the gap size with a node instead.
+     *
+     * If you don't want to overwrite the gap size but modify the existing
+     * value instead, use {@link materialLineGapSize}.
+     *
+     * @default null
+     */
     gapSizeNode: Node | null;
+}
 
-    // Properties from LineDashedMaterial
-    readonly isLineDashedMaterial: true;
-    scale: number;
-    dashSize: number;
-    gapSize: number;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface LineDashedNodeMaterialParameters
+    extends
+        Partial<MapColorPropertiesToColorRepresentations<LineDashedNodeMaterialNodeProperties>>,
+        LineDashedMaterialParameters
+{}
 
-    constructor(parameters?: LineDashedMaterialParameters);
+/**
+ * Node material version of  {@link LineDashedMaterial}.
+ */
+declare class LineDashedNodeMaterial extends NodeMaterial {
+    /**
+     * Constructs a new line dashed node material.
+     *
+     * @param {Object} [parameters] - The configuration parameter.
+     */
+    constructor(parameters?: LineDashedNodeMaterialParameters);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @default true
+     */
+    readonly isLineDashedNodeMaterial: boolean;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface LineDashedNodeMaterial extends LineDashedNodeMaterialNodeProperties, LineDashedMaterialProperties {}
+
 export default LineDashedNodeMaterial;

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

@@ -1,36 +1,55 @@
-import { Combine } from "../../constants.js";
-import { Color } from "../../math/Color.js";
-import { Euler } from "../../math/Euler.js";
-import { Texture } from "../../textures/Texture.js";
-import { MeshBasicMaterialParameters } from "../MeshBasicMaterial.js";
-import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+import NodeBuilder from "../../nodes/core/NodeBuilder.js";
+import BasicLightingModel from "../../nodes/functions/BasicLightingModel.js";
+import BasicEnvironmentNode from "../../nodes/lighting/BasicEnvironmentNode.js";
+import { MapColorPropertiesToColorRepresentations } from "../Material.js";
+import { MeshBasicMaterialParameters, MeshBasicMaterialProperties } from "../MeshBasicMaterial.js";
+import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
-export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshBasicMaterialParameters {
+export interface MeshBasicNodeMaterialNodeProperties extends NodeMaterialNodeProperties {
 }
 
-export default class MeshBasicNodeMaterial extends NodeMaterial {
-    readonly isMeshBasicNodeMaterial: true;
-
-    // Properties from MeshBasicMaterial
-    readonly isMeshBasicMaterial: true;
-    color: Color;
-    map: Texture | null;
-    lightMap: Texture | null;
-    lightMapIntensity: number;
-    aoMap: Texture | null;
-    aoMapIntensity: number;
-    specularMap: Texture | null;
-    alphaMap: Texture | null;
-    envMap: Texture | null;
-    envMapRotation: Euler;
-    combine: Combine;
-    reflectivity: number;
-    refractionRatio: number;
-    wireframe: boolean;
-    wireframeLinewidth: number;
-    wireframeLinecap: string;
-    wireframeLinejoin: string;
-    fog: boolean;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface MeshBasicNodeMaterialParameters
+    extends
+        Partial<MapColorPropertiesToColorRepresentations<MeshBasicNodeMaterialNodeProperties>>,
+        MeshBasicMaterialParameters
+{}
 
+/**
+ * Node material version of {@link MeshBasicMaterial}.
+ */
+declare class MeshBasicNodeMaterial extends NodeMaterial {
+    /**
+     * Constructs a new mesh basic node material.
+     *
+     * @param {Object} [parameters] - The configuration parameter.
+     */
     constructor(parameters?: MeshBasicNodeMaterialParameters);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isMeshBasicNodeMaterial: boolean;
+    /**
+     * Overwritten since this type of material uses {@link BasicEnvironmentNode}
+     * to implement the default environment mapping.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {?BasicEnvironmentNode<vec3>} The environment node.
+     */
+    setupEnvironment(builder: NodeBuilder): BasicEnvironmentNode | null;
+    /**
+     * Setups the lighting model.
+     *
+     * @return {BasicLightingModel} The lighting model.
+     */
+    setupLightingModel(): BasicLightingModel;
 }
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface MeshBasicNodeMaterial extends MeshBasicNodeMaterialNodeProperties, MeshBasicMaterialProperties {}
+
+export default MeshBasicNodeMaterial;

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

@@ -1,49 +1,56 @@
-import { Combine, NormalMapTypes } from "../../constants.js";
-import { Color } from "../../math/Color.js";
-import { Euler } from "../../math/Euler.js";
-import { Vector2 } from "../../math/Vector2.js";
-import { Texture } from "../../textures/Texture.js";
-import { MeshLambertMaterialParameters } from "../MeshLambertMaterial.js";
-import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+import NodeBuilder from "../../nodes/core/NodeBuilder.js";
+import PhongLightingModel from "../../nodes/functions/PhongLightingModel.js";
+import BasicEnvironmentNode from "../../nodes/lighting/BasicEnvironmentNode.js";
+import { MapColorPropertiesToColorRepresentations } from "../Material.js";
+import { MeshLambertMaterialParameters, MeshLambertMaterialProperties } from "../MeshLambertMaterial.js";
+import NodeMaterial, { NodeMaterialNodeProperties } from "./NodeMaterial.js";
 
-export interface MeshLambertNodeMaterialParameters extends NodeMaterialParameters, MeshLambertMaterialParameters {}
-
-declare class MeshLambertNodeMaterial extends NodeMaterial {
-    readonly isMeshLambertNodeMaterial: true;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface MeshLambertNodeMaterialNodeProperties extends NodeMaterialNodeProperties {
+}
 
-    // Properties from MeshLambertMaterial
-    readonly isMeshLambertMaterial: true;
-    color: Color;
-    bumpMap: Texture | null;
-    bumpScale: number;
-    displacementMap: Texture | null;
-    displacementScale: number;
-    displacementBias: number;
-    emissive: Color;
-    emissiveIntensity: number;
-    emissiveMap: Texture | null;
-    flatShading: boolean;
-    map: Texture | null;
-    lightMap: Texture | null;
-    lightMapIntensity: number;
-    normalMap: Texture | null;
-    normalMapType: NormalMapTypes;
-    normalScale: Vector2;
-    aoMap: Texture | null;
-    aoMapIntensity: number;
-    specularMap: Texture | null;
-    alphaMap: Texture | null;
-    envMap: Texture | null;
-    envMapRotation: Euler;
-    combine: Combine;
-    reflectivity: number;
-    refractionRatio: number;
-    wireframe: boolean;
-    wireframeLinewidth: number;
-    wireframeLinecap: string;
-    wireframeLinejoin: string;
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface MeshLambertNodeMaterialParameters
+    extends
+        Partial<MapColorPropertiesToColorRepresentations<MeshLambertNodeMaterialNodeProperties>>,
+        MeshLambertMaterialParameters
+{}
 
+/**
+ * Node material version of {@link MeshLambertMaterial}.
+ */
+declare class MeshLambertNodeMaterial extends NodeMaterial {
+    /**
+     * Constructs a new mesh lambert node material.
+     *
+     * @param {Object} [parameters] - The configuration parameter.
+     */
     constructor(parameters?: MeshLambertNodeMaterialParameters);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isMeshLambertNodeMaterial: boolean;
+    /**
+     * Overwritten since this type of material uses {@link BasicEnvironmentNode}
+     * to implement the default environment mapping.
+     *
+     * @param {NodeBuilder} builder - The current node builder.
+     * @return {?BasicEnvironmentNode<vec3>} The environment node.
+     */
+    setupEnvironment(builder: NodeBuilder): BasicEnvironmentNode | null;
+    /**
+     * Setups the lighting model.
+     *
+     * @return {PhongLightingModel} The lighting model.
+     */
+    setupLightingModel(): PhongLightingModel;
 }
 
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+interface MeshLambertNodeMaterial extends MeshLambertNodeMaterialNodeProperties, MeshLambertMaterialProperties {}
+
 export default MeshLambertNodeMaterial;