@types/three 0.176.0 → 0.178.0

three/src/nodes/functions/BSDF/Schlick_to_F0.d.ts

@@ -1,10 +1,10 @@
 import Node from "../../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 declare const Schlick_to_F0: (
-    f: NodeRepresentation,
-    f90: NodeRepresentation,
-    dotVH: NodeRepresentation,
+    f: Node,
+    f90: Node,
+    dotVH: Node,
 ) => ShaderNodeObject<Node>;
 
 export default Schlick_to_F0;

three/src/nodes/functions/material/getAlphaHashThreshold.d.ts

@@ -1,6 +1,6 @@
 import Node from "../../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-declare const getAlphaHashThreshold: (position: NodeRepresentation) => ShaderNodeObject<Node>;
+declare const getAlphaHashThreshold: (position: Node) => ShaderNodeObject<Node>;
 
 export default getAlphaHashThreshold;

three/src/nodes/functions/material/getParallaxCorrectNormal.d.ts

@@ -1,10 +1,10 @@
 import Node from "../../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
 declare const getParallaxCorrectNormal: (
-    normal: NodeRepresentation,
-    cubeSize: NodeRepresentation,
-    cubePos: NodeRepresentation,
+    normal: Node,
+    cubeSize: Node,
+    cubePos: Node,
 ) => ShaderNodeObject<Node>;
 
 export default getParallaxCorrectNormal;

three/src/nodes/geometry/RangeNode.d.ts

@@ -1,6 +1,10 @@
+import { Color } from "../../math/Color.js";
+import { Vector2 } from "../../math/Vector2.js";
+import { Vector3 } from "../../math/Vector3.js";
+import { Vector4 } from "../../math/Vector4.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class RangeNode extends Node {
     minNode: Node;
@@ -11,4 +15,7 @@ export default class RangeNode extends Node {
     getVectorLength(builder: NodeBuilder): number;
 }
 
-export const range: (minNode: NodeRepresentation, maxNode: NodeRepresentation) => ShaderNodeObject<RangeNode>;
+export const range: (
+    minNode: Node | number | Color | Vector2 | Vector3 | Vector4,
+    maxNode: Node | number | Color | Vector2 | Vector3 | Vector4,
+) => ShaderNodeObject<RangeNode>;

three/src/nodes/gpgpu/AtomicFunctionNode.d.ts

@@ -1,5 +1,5 @@
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type AtomicMethod =
     | typeof AtomicFunctionNode.ATOMIC_LOAD
@@ -33,50 +33,50 @@ declare class AtomicFunctionNode extends Node {
 
 export const atomicFunc: (
     method: AtomicMethod,
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicLoad: (
-    pointerNode: NodeRepresentation,
+    pointerNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicStore: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node | number,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicAdd: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node | number,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicSub: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node | number,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicMax: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicMin: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicAnd: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicOr: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;
 
 export const atomicXor: (
-    pointerNode: NodeRepresentation,
-    valueNode: NodeRepresentation,
+    pointerNode: Node,
+    valueNode: Node,
 ) => ShaderNodeObject<AtomicFunctionNode>;

three/src/nodes/gpgpu/ComputeNode.d.ts

@@ -1,6 +1,6 @@
 import Renderer from "../../renderers/common/Renderer.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export default class ComputeNode extends Node {
     isComputeNode: true;
@@ -22,7 +22,7 @@ export default class ComputeNode extends Node {
 }
 
 export const compute: (
-    node: NodeRepresentation,
+    node: Node,
     count: number,
     workgroupSize?: number[],
 ) => ShaderNodeObject<ComputeNode>;

three/src/nodes/lighting/PointShadowNode.d.ts

@@ -1,24 +1,24 @@
 import { Light } from "../../lights/Light.js";
 import { LightShadow } from "../../lights/LightShadow.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ShadowNode from "./ShadowNode.js";
 
-export const cubeToUV: (pos: NodeRepresentation, texelSizeY: NodeRepresentation) => ShaderNodeObject<Node>;
+export const cubeToUV: (pos: Node, texelSizeY: Node) => ShaderNodeObject<Node>;
 
 export const BasicPointShadowFilter: (
-    depthTexture: NodeRepresentation,
-    bd3D: NodeRepresentation,
-    dp: NodeRepresentation,
-    texelSize: NodeRepresentation,
+    depthTexture: Node,
+    bd3D: Node,
+    dp: Node,
+    texelSize: Node,
 ) => ShaderNodeObject<Node>;
 
 export const PointShadowFilter: (
-    depthTexture: NodeRepresentation,
-    bd3D: NodeRepresentation,
-    dp: NodeRepresentation,
-    texelSize: NodeRepresentation,
-    shadow: NodeRepresentation,
+    depthTexture: Node,
+    bd3D: Node,
+    dp: Node,
+    texelSize: Node,
+    shadow: Node,
 ) => ShaderNodeObject<Node>;
 
 declare class PointShadowNode extends ShadowNode {

three/src/nodes/lighting/ProjectorLightNode.d.ts

@@ -0,0 +1,5 @@
+import SpotLightNode from "./SpotLightNode.js";
+
+declare class ProjectorLightNode extends SpotLightNode {}
+
+export default ProjectorLightNode;

three/src/nodes/lighting/ShadowFilterNode.d.ts

@@ -1,28 +1,28 @@
 import { Light } from "../../lights/Light.js";
 import NodeMaterial from "../../materials/nodes/NodeMaterial.js";
 import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const BasicShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
+    depthTexture: Node,
+    shadowCoord: Node,
 ) => ShaderNodeObject<Node>;
 
 export const PCFShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
-    shadow: NodeRepresentation,
+    depthTexture: Node,
+    shadowCoord: Node,
+    shadow: Node,
 ) => ShaderNodeObject<Node>;
 
 export const PCFSoftShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
-    shadow: NodeRepresentation,
+    depthTexture: Node,
+    shadowCoord: Node,
+    shadow: Node,
 ) => ShaderNodeObject<Node>;
 
 export const VSMShadowFilter: (
-    depthTexture: NodeRepresentation,
-    shadowCoord: NodeRepresentation,
+    depthTexture: Node,
+    shadowCoord: Node,
 ) => ShaderNodeObject<Node>;
 
 export const getShadowMaterial: (light: Light) => NodeMaterial;

three/src/nodes/lighting/SpotLightNode.d.ts

@@ -1,8 +1,10 @@
 import { SpotLight } from "../../lights/SpotLight.js";
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
 
-export default class PointLightNode extends AnalyticLightNode<SpotLight> {
+declare class SpotLightNode extends AnalyticLightNode<SpotLight> {
     directionNode: Node;
 
     coneCosNode: Node;
@@ -11,5 +13,17 @@ export default class PointLightNode extends AnalyticLightNode<SpotLight> {
     cutoffDistanceNode: Node;
     decayExponentNode: Node;
 
+    colorNode: Node;
+
     constructor(light?: SpotLight | null);
+
+    getLightCoord(builder: NodeBuilder): ShaderNodeObject<Node>;
 }
+
+declare module "three" {
+    export interface SpotLight {
+        attenuationNode?: ((lightNode: SpotLightNode) => Node) | null | undefined;
+    }
+}
+
+export default SpotLightNode;

three/src/nodes/materialx/MaterialXNodes.d.ts

@@ -1,107 +1,107 @@
 import Node from "../core/Node.js";
 import MathNode from "../math/MathNode.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import { mx_hsvtorgb, mx_rgbtohsv } from "./lib/mx_hsv.js";
 import { mx_srgb_texture_to_lin_rec709 } from "./lib/mx_transform_color.js";
 
-export function mx_aastep(threshold: NodeRepresentation, value: NodeRepresentation): ShaderNodeObject<MathNode>;
+export function mx_aastep(threshold: Node | number, value: Node | number): ShaderNodeObject<MathNode>;
 
 export function mx_ramplr(
-    valuel: NodeRepresentation,
-    valuer: NodeRepresentation,
-    texcoord?: NodeRepresentation,
+    valuel: Node | number,
+    valuer: Node | number,
+    texcoord?: Node,
 ): ShaderNodeObject<MathNode>;
 export function mx_ramptb(
-    valuet: NodeRepresentation,
-    valueb: NodeRepresentation,
-    texcoord?: NodeRepresentation,
+    valuet: Node | number,
+    valueb: Node | number,
+    texcoord?: Node,
 ): ShaderNodeObject<MathNode>;
 
 export function mx_splitlr(
-    valuel: NodeRepresentation,
-    valuer: NodeRepresentation,
-    center: NodeRepresentation,
-    texcoord?: NodeRepresentation,
+    valuel: Node | number,
+    valuer: Node | number,
+    center: Node | number,
+    texcoord?: Node,
 ): ShaderNodeObject<MathNode>;
 export function mx_splittb(
-    valuet: NodeRepresentation,
-    valueb: NodeRepresentation,
-    center: NodeRepresentation,
-    texcoord?: NodeRepresentation,
+    valuet: Node | number,
+    valueb: Node | number,
+    center: Node | number,
+    texcoord?: Node,
 ): ShaderNodeObject<MathNode>;
 
 export function mx_transform_uv(
-    uv_scale?: NodeRepresentation,
-    uv_offset?: NodeRepresentation,
-    uv_geo?: NodeRepresentation,
+    uv_scale?: Node | number,
+    uv_offset?: Node | number,
+    uv_geo?: Node,
 ): ShaderNodeObject<Node>;
 
-export function mx_safepower(in1: NodeRepresentation, in2?: NodeRepresentation): ShaderNodeObject<Node>;
+export function mx_safepower(in1: Node | number, in2?: Node | number): ShaderNodeObject<Node>;
 
 export function mx_contrast(
-    input: NodeRepresentation,
-    amount?: NodeRepresentation,
-    pivot?: NodeRepresentation,
+    input: Node | number,
+    amount?: Node | number,
+    pivot?: Node | number,
 ): ShaderNodeObject<Node>;
 
 export function mx_noise_float(
-    texcoord?: NodeRepresentation,
-    amplitude?: NodeRepresentation,
-    pivot?: NodeRepresentation,
+    texcoord?: Node,
+    amplitude?: Node | number,
+    pivot?: Node | number,
 ): ShaderNodeObject<Node>;
 export function mx_noise_vec3(
-    texcoord?: NodeRepresentation,
-    amplitude?: NodeRepresentation,
-    pivot?: NodeRepresentation,
+    texcoord?: Node,
+    amplitude?: Node | number,
+    pivot?: Node | number,
 ): ShaderNodeObject<Node>;
 export function mx_noise_vec4(
-    texcoord?: NodeRepresentation,
-    amplitude?: NodeRepresentation,
-    pivot?: NodeRepresentation,
+    texcoord?: Node,
+    amplitude?: Node | number,
+    pivot?: Node | number,
 ): ShaderNodeObject<Node>;
 
 export function mx_worley_noise_float(
-    texcoord?: NodeRepresentation,
-    jitter?: NodeRepresentation,
+    texcoord?: Node,
+    jitter?: Node | number,
 ): ShaderNodeObject<Node>;
 export function mx_worley_noise_vec2(
-    texcoord?: NodeRepresentation,
-    jitter?: NodeRepresentation,
+    texcoord?: Node,
+    jitter?: Node | number,
 ): ShaderNodeObject<Node>;
 export function mx_worley_noise_vec3(
-    texcoord?: NodeRepresentation,
-    jitter?: NodeRepresentation,
+    texcoord?: Node,
+    jitter?: Node | number,
 ): ShaderNodeObject<Node>;
 
-export function mx_cell_noise_float(texcoord?: NodeRepresentation): ShaderNodeObject<Node>;
+export function mx_cell_noise_float(texcoord?: Node): ShaderNodeObject<Node>;
 
 export function mx_fractal_noise_float(
-    position?: NodeRepresentation,
-    octaves?: NodeRepresentation,
-    lacunarity?: NodeRepresentation,
-    diminish?: NodeRepresentation,
-    amplitude?: NodeRepresentation,
+    position?: Node,
+    octaves?: Node | number,
+    lacunarity?: Node | number,
+    diminish?: Node | number,
+    amplitude?: Node | number,
 ): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec2(
-    position?: NodeRepresentation,
-    octaves?: NodeRepresentation,
-    lacunarity?: NodeRepresentation,
-    diminish?: NodeRepresentation,
-    amplitude?: NodeRepresentation,
+    position?: Node,
+    octaves?: Node | number,
+    lacunarity?: Node | number,
+    diminish?: Node | number,
+    amplitude?: Node | number,
 ): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec3(
-    position?: NodeRepresentation,
-    octaves?: NodeRepresentation,
-    lacunarity?: NodeRepresentation,
-    diminish?: NodeRepresentation,
-    amplitude?: NodeRepresentation,
+    position?: Node,
+    octaves?: Node | number,
+    lacunarity?: Node | number,
+    diminish?: Node | number,
+    amplitude?: Node | number,
 ): ShaderNodeObject<Node>;
 export function mx_fractal_noise_vec4(
-    position?: NodeRepresentation,
-    octaves?: NodeRepresentation,
-    lacunarity?: NodeRepresentation,
-    diminish?: NodeRepresentation,
-    amplitude?: NodeRepresentation,
+    position?: Node,
+    octaves?: Node | number,
+    lacunarity?: Node | number,
+    diminish?: Node | number,
+    amplitude?: Node | number,
 ): ShaderNodeObject<Node>;
 
 export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };

three/src/nodes/materialx/lib/mx_hsv.d.ts

@@ -1,6 +1,6 @@
 import Node from "../../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../../tsl/TSLCore.js";
+import { ShaderNodeObject } from "../../tsl/TSLCore.js";
 
-export const mx_hsvtorgb: (hsv: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_hsvtorgb: (hsv: Node) => ShaderNodeObject<Node>;
 
-export const mx_rgbtohsv: (c_immutable: NodeRepresentation) => ShaderNodeObject<Node>;
+export const mx_rgbtohsv: (c_immutable: Node) => ShaderNodeObject<Node>;