@needle-tools/three 0.169.12 → 0.169.14

package/types/src/materials/MeshToonMaterial.d.ts

@@ -0,0 +1,178 @@
+import { NormalMapTypes } from "../constants.js";
+import { Color, ColorRepresentation } from "../math/Color.js";
+import { Vector2 } from "../math/Vector2.js";
+import { Texture } from "../textures/Texture.js";
+import { Material, MaterialParameters } from "./Material.js";
+
+export interface MeshToonMaterialParameters extends MaterialParameters {
+    /** geometry color in hexadecimal. Default is 0xffffff. */
+    color?: ColorRepresentation | undefined;
+    opacity?: number | undefined;
+    gradientMap?: Texture | null | undefined;
+    map?: Texture | null | undefined;
+    lightMap?: Texture | null | undefined;
+    lightMapIntensity?: number | undefined;
+    aoMap?: Texture | null | undefined;
+    aoMapIntensity?: number | undefined;
+    emissive?: ColorRepresentation | undefined;
+    emissiveIntensity?: number | undefined;
+    emissiveMap?: Texture | null | undefined;
+    bumpMap?: Texture | null | undefined;
+    bumpScale?: number | undefined;
+    normalMap?: Texture | null | undefined;
+    normalMapType?: NormalMapTypes | undefined;
+    normalScale?: Vector2 | undefined;
+    displacementMap?: Texture | null | undefined;
+    displacementScale?: number | undefined;
+    displacementBias?: number | undefined;
+    alphaMap?: Texture | null | undefined;
+    wireframe?: boolean | undefined;
+    wireframeLinewidth?: number | undefined;
+    wireframeLinecap?: string | undefined;
+    wireframeLinejoin?: string | undefined;
+    fog?: boolean | undefined;
+}
+
+export class MeshToonMaterial extends Material {
+    constructor(parameters?: MeshToonMaterialParameters);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link MeshToonMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isMeshToonMaterial: true;
+
+    /**
+     * @default 'MeshToonMaterial'
+     */
+    type: string;
+
+    /**
+     * @default { 'TOON': '' }
+     */
+    defines: { [key: string]: any };
+
+    /**
+     * @default new THREE.Color( 0xffffff )
+     */
+    color: Color;
+
+    /**
+     * @default null
+     */
+    gradientMap: Texture | null;
+
+    /**
+     * @default null
+     */
+    map: Texture | null;
+
+    /**
+     * @default null
+     */
+    lightMap: Texture | null;
+
+    /**
+     * @default 1
+     */
+    lightMapIntensity: number;
+
+    /**
+     * @default null
+     */
+    aoMap: Texture | null;
+
+    /**
+     * @default 1
+     */
+    aoMapIntensity: number;
+
+    /**
+     * @default new THREE.Color( 0x000000 )
+     */
+    emissive: Color;
+
+    /**
+     * @default 1
+     */
+    emissiveIntensity: number;
+
+    /**
+     * @default null
+     */
+    emissiveMap: Texture | null;
+
+    /**
+     * @default null
+     */
+    bumpMap: Texture | null;
+
+    /**
+     * @default 1
+     */
+    bumpScale: number;
+
+    /**
+     * @default null
+     */
+    normalMap: Texture | null;
+
+    /**
+     * @default THREE.TangentSpaceNormalMap
+     */
+    normalMapType: NormalMapTypes;
+
+    /**
+     * @default new THREE.Vector2( 1, 1 )
+     */
+    normalScale: Vector2;
+
+    /**
+     * @default null
+     */
+    displacementMap: Texture | null;
+
+    /**
+     * @default 1
+     */
+    displacementScale: number;
+
+    /**
+     * @default 0
+     */
+    displacementBias: number;
+
+    /**
+     * @default null
+     */
+    alphaMap: Texture | null;
+
+    /**
+     * @default false
+     */
+    wireframe: boolean;
+
+    /**
+     * @default 1
+     */
+    wireframeLinewidth: number;
+
+    /**
+     * @default 'round'
+     */
+    wireframeLinecap: string;
+
+    /**
+     * @default 'round'
+     */
+    wireframeLinejoin: string;
+
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+
+    setValues(parameters: MeshToonMaterialParameters): void;
+}

package/types/src/materials/PointsMaterial.d.ts

@@ -0,0 +1,61 @@
+import { Color, ColorRepresentation } from "../math/Color.js";
+import { Texture } from "../textures/Texture.js";
+import { Material, MaterialParameters } from "./Material.js";
+
+export interface PointsMaterialParameters extends MaterialParameters {
+    color?: ColorRepresentation | undefined;
+    map?: Texture | null | undefined;
+    alphaMap?: Texture | null | undefined;
+    size?: number | undefined;
+    sizeAttenuation?: boolean | undefined;
+    fog?: boolean | undefined;
+}
+
+export class PointsMaterial extends Material {
+    constructor(parameters?: PointsMaterialParameters);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link PointsMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isPointsMaterial: true;
+
+    /**
+     * @default 'PointsMaterial'
+     */
+    type: string;
+
+    /**
+     * @default new THREE.Color( 0xffffff )
+     */
+    color: Color;
+
+    /**
+     * @default null
+     */
+    map: Texture | null;
+
+    /**
+     * @default null
+     */
+    alphaMap: Texture | null;
+
+    /**
+     * @default 1
+     */
+    size: number;
+
+    /**
+     * @default true
+     */
+    sizeAttenuation: boolean;
+
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+
+    setValues(parameters: PointsMaterialParameters): void;
+}

package/types/src/materials/RawShaderMaterial.d.ts

@@ -0,0 +1,14 @@
+import { ShaderMaterial, ShaderMaterialParameters } from "./ShaderMaterial.js";
+
+export class RawShaderMaterial extends ShaderMaterial {
+    constructor(parameters?: ShaderMaterialParameters);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link RawShaderMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isRawShaderMaterial: true;
+
+    override readonly type: "RawShaderMaterial";
+}

package/types/src/materials/ShaderMaterial.d.ts

@@ -0,0 +1,167 @@
+import { GLSLVersion } from "../constants.js";
+import { JSONMeta } from "../core/Object3D.js";
+import { UniformsGroup } from "../core/UniformsGroup.js";
+import { Matrix3, Matrix3Tuple } from "../math/Matrix3.js";
+import { Matrix4, Matrix4Tuple } from "../math/Matrix4.js";
+import { Vector2Tuple } from "../math/Vector2.js";
+import { Vector3Tuple } from "../math/Vector3.js";
+import { Vector4Tuple } from "../math/Vector4.js";
+import { IUniform } from "../renderers/shaders/UniformsLib.js";
+import { Material, MaterialJSON, MaterialParameters } from "./Material.js";
+
+export interface ShaderMaterialParameters extends MaterialParameters {
+    uniforms?: { [uniform: string]: IUniform } | undefined;
+    uniformsGroups?: UniformsGroup[] | undefined;
+    vertexShader?: string | undefined;
+    fragmentShader?: string | undefined;
+    linewidth?: number | undefined;
+    wireframe?: boolean | undefined;
+    wireframeLinewidth?: number | undefined;
+    lights?: boolean | undefined;
+    clipping?: boolean | undefined;
+    fog?: boolean | undefined;
+    extensions?:
+        | {
+            clipCullDistance?: boolean | undefined;
+            multiDraw?: boolean | undefined;
+        }
+        | undefined;
+    glslVersion?: GLSLVersion | undefined;
+}
+
+export type ShaderMaterialUniformJSON = {
+    type: "t";
+    value: string;
+} | {
+    type: "c";
+    value: number;
+} | {
+    type: "v2";
+    value: Vector2Tuple;
+} | {
+    type: "v3";
+    value: Vector3Tuple;
+} | {
+    type: "v4";
+    value: Vector4Tuple;
+} | {
+    type: "m3";
+    value: Matrix3Tuple;
+} | {
+    type: "m4";
+    value: Matrix4Tuple;
+} | {
+    value: unknown;
+};
+
+export interface ShaderMaterialJSON extends MaterialJSON {
+    glslVersion: number | null;
+    uniforms: Record<string, ShaderMaterialUniformJSON>;
+
+    defines?: Record<string, unknown>;
+
+    vertexShader: string;
+    ragmentShader: string;
+
+    lights: boolean;
+    clipping: boolean;
+
+    extensions?: Record<string, boolean>;
+}
+
+export class ShaderMaterial extends Material {
+    constructor(parameters?: ShaderMaterialParameters);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link ShaderMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isShaderMaterial: true;
+
+    /**
+     * @default 'ShaderMaterial'
+     */
+    type: string;
+
+    /**
+     * @default {}
+     */
+    defines: { [key: string]: any };
+
+    /**
+     * @default {}
+     */
+    uniforms: { [uniform: string]: IUniform };
+
+    uniformsGroups: UniformsGroup[];
+
+    vertexShader: string;
+
+    fragmentShader: string;
+
+    /**
+     * @default 1
+     */
+    linewidth: number;
+
+    /**
+     * @default false
+     */
+    wireframe: boolean;
+
+    /**
+     * @default 1
+     */
+    wireframeLinewidth: number;
+
+    /**
+     * @default false
+     */
+    fog: boolean;
+
+    /**
+     * @default false
+     */
+    lights: boolean;
+
+    /**
+     * @default false
+     */
+    clipping: boolean;
+
+    /**
+     * @default {
+     *   clipCullDistance: false,
+     *   multiDraw: false
+     * }
+     */
+    extensions: {
+        clipCullDistance: boolean;
+        multiDraw: boolean;
+    };
+
+    /**
+     * @default { 'color': [ 1, 1, 1 ], 'uv': [ 0, 0 ], 'uv1': [ 0, 0 ] }
+     */
+    defaultAttributeValues: any;
+
+    /**
+     * @default undefined
+     */
+    index0AttributeName: string | undefined;
+
+    /**
+     * @default false
+     */
+    uniformsNeedUpdate: boolean;
+
+    /**
+     * @default null
+     */
+    glslVersion: GLSLVersion | null;
+
+    setValues(parameters: ShaderMaterialParameters): void;
+
+    toJSON(meta?: JSONMeta): ShaderMaterialJSON;
+}

package/types/src/materials/ShadowMaterial.d.ts

@@ -0,0 +1,39 @@
+import { Color, ColorRepresentation } from "../math/Color.js";
+import { Material, MaterialParameters } from "./Material.js";
+
+export interface ShadowMaterialParameters extends MaterialParameters {
+    color?: ColorRepresentation | undefined;
+    fog?: boolean | undefined;
+}
+
+export class ShadowMaterial extends Material {
+    constructor(parameters?: ShadowMaterialParameters);
+
+    /**
+     * Read-only flag to check if a given object is of type {@link ShadowMaterial}.
+     * @remarks This is a _constant_ value
+     * @defaultValue `true`
+     */
+    readonly isShadowMaterial: true;
+
+    /**
+     * @default 'ShadowMaterial'
+     */
+    type: string;
+
+    /**
+     * @default new THREE.Color( 0x000000 )
+     */
+    color: Color;
+
+    /**
+     * @default true
+     */
+    transparent: boolean;
+
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+}

package/types/src/materials/SpriteMaterial.d.ts

@@ -0,0 +1,66 @@
+import { Color, ColorRepresentation } 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;
+
+    /**
+     * @default 'SpriteMaterial'
+     */
+    type: string;
+
+    /**
+     * @default new THREE.Color( 0xffffff )
+     */
+    color: Color;
+
+    /**
+     * @default null
+     */
+    map: Texture | null;
+
+    /**
+     * @default null
+     */
+    alphaMap: Texture | null;
+
+    /**
+     * @default 0
+     */
+    rotation: number;
+
+    /**
+     * @default true
+     */
+    sizeAttenuation: boolean;
+
+    /**
+     * @default true
+     */
+    transparent: boolean;
+
+    /**
+     * Whether the material is affected by fog. Default is true.
+     * @default fog
+     */
+    fog: boolean;
+
+    setValues(parameters: SpriteMaterialParameters): void;
+    copy(source: SpriteMaterial): this;
+}

package/types/src/materials/nodes/InstancedPointsNodeMaterial.d.ts

@@ -0,0 +1,33 @@
+import { Color } from "../../math/Color.js";
+import Node from "../../nodes/core/Node.js";
+import { Texture } from "../../textures/Texture.js";
+import { PointsMaterialParameters } from "../PointsMaterial.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface InstancedPointsNodeMaterialParameters extends NodeMaterialParameters, PointsMaterialParameters {
+    useAlphaToCoverage?: boolean | undefined;
+    useColor?: boolean | undefined;
+    pointWidth?: number | undefined;
+    pointColorNode?: Node | null | undefined;
+    pointWidthNode?: Node | null | undefined;
+}
+
+declare class InstancedPointsNodeMaterial extends NodeMaterial {
+    useAlphaToCoverage: boolean;
+    useColor: boolean | undefined;
+    pointWidth: number;
+    pointColorNode: Node | null;
+    pointWidthNode: Node | null;
+
+    // Properties from LineDashedMaterial
+    readonly isPointsMaterial: true;
+    color: Color;
+    map: Texture | null;
+    alphaMap: Texture | null;
+    size: number;
+    sizeAttenuation: boolean;
+
+    constructor(params?: InstancedPointsNodeMaterialParameters);
+}
+
+export default InstancedPointsNodeMaterial;

package/types/src/materials/nodes/Line2NodeMaterial.d.ts

@@ -0,0 +1,53 @@
+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";
+
+export interface Line2NodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
+    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;
+    useColor: boolean;
+    useDash: boolean;
+    useWorldUnits: boolean;
+
+    dashOffset: number;
+    lineWidth: number;
+
+    lineColorNode: Node | null;
+
+    offsetNode: Node | null;
+    dashScaleNode: Node | null;
+    dashSizeNode: Node | null;
+    gapSizeNode: Node | null;
+
+    constructor(parameters?: Line2NodeMaterialParameters);
+
+    setupShaders(): void;
+
+    get worldUnits(): boolean;
+    set worldUnits(value: boolean);
+
+    get dashed(): boolean;
+    set dashed(value: boolean);
+}

package/types/src/materials/nodes/LineBasicNodeMaterial.d.ts

@@ -0,0 +1,22 @@
+import { Color } from "../../math/Color.js";
+import { Texture } from "../../textures/Texture.js";
+import { LineBasicMaterialParameters } from "../LineBasicMaterial.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface LineBasicNodeMaterialParameters extends NodeMaterialParameters, LineBasicMaterialParameters {
+}
+
+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;
+
+    constructor(parameters?: LineBasicNodeMaterialParameters);
+}

package/types/src/materials/nodes/LineDashedNodeMaterial.d.ts

@@ -0,0 +1,29 @@
+import Node from "../../nodes/core/Node.js";
+import { LineDashedMaterialParameters } from "../LineDashedMaterial.js";
+import NodeMaterial, { NodeMaterialParameters } from "./NodeMaterial.js";
+
+export interface LineDashedNodeMaterialParameters extends NodeMaterialParameters, LineDashedMaterialParameters {
+    offsetNode?: Node | null | undefined;
+    dashScaleNode?: Node | null | undefined;
+    dashSizeNode?: Node | null | undefined;
+    gapSizeNode?: Node | null | undefined;
+}
+
+declare class LineDashedNodeMaterial extends NodeMaterial {
+    readonly isLineDashedNodeMaterial: true;
+
+    offsetNode: Node | null;
+    dashScaleNode: Node | null;
+    dashSizeNode: Node | null;
+    gapSizeNode: Node | null;
+
+    // Properties from LineDashedMaterial
+    readonly isLineDashedMaterial: true;
+    scale: number;
+    dashSize: number;
+    gapSize: number;
+
+    constructor(parameters?: LineDashedMaterialParameters);
+}
+
+export default LineDashedNodeMaterial;

package/types/src/materials/nodes/MeshBasicNodeMaterial.d.ts

@@ -0,0 +1,36 @@
+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";
+
+export interface MeshBasicNodeMaterialParameters extends NodeMaterialParameters, MeshBasicMaterialParameters {
+}
+
+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;
+
+    constructor(parameters?: MeshBasicNodeMaterialParameters);
+}