@types/three 0.179.0 → 0.181.0

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

@@ -0,0 +1,99 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+
+export type SubgroupFunctionNodeMethod0 = typeof SubgroupFunctionNode.SUBGROUP_ELECT;
+
+export type SubgroupFunctionNodeMethod1 =
+    | typeof SubgroupFunctionNode.SUBGROUP_BALLOT
+    | typeof SubgroupFunctionNode.SUBGROUP_ADD
+    | typeof SubgroupFunctionNode.SUBGROUP_INCLUSIVE_ADD
+    | typeof SubgroupFunctionNode.SUBGROUP_EXCLUSIVE_AND
+    | typeof SubgroupFunctionNode.SUBGROUP_MUL
+    | typeof SubgroupFunctionNode.SUBGROUP_INCLUSIVE_MUL
+    | typeof SubgroupFunctionNode.SUBGROUP_EXCLUSIVE_MUL
+    | typeof SubgroupFunctionNode.SUBGROUP_AND
+    | typeof SubgroupFunctionNode.SUBGROUP_OR
+    | typeof SubgroupFunctionNode.SUBGROUP_XOR
+    | typeof SubgroupFunctionNode.SUBGROUP_MIN
+    | typeof SubgroupFunctionNode.SUBGROUP_MAX
+    | typeof SubgroupFunctionNode.SUBGROUP_ALL
+    | typeof SubgroupFunctionNode.SUBGROUP_ANY
+    | typeof SubgroupFunctionNode.SUBGROUP_BROADCAST_FIRST
+    | typeof SubgroupFunctionNode.QUAD_SWAP_X
+    | typeof SubgroupFunctionNode.QUAD_SWAP_Y
+    | typeof SubgroupFunctionNode.QUAD_SWAP_DIAGONAL;
+
+export type SubgroupFunctionNodeMethod2 =
+    | typeof SubgroupFunctionNode.SUBGROUP_BROADCAST
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE_XOR
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE_UP
+    | typeof SubgroupFunctionNode.SUBGROUP_SHUFFLE_DOWN
+    | typeof SubgroupFunctionNode.QUAD_BROADCAST;
+
+declare class SubgroupFunctionNode extends TempNode {
+    constructor(method: SubgroupFunctionNodeMethod0);
+    constructor(method: SubgroupFunctionNodeMethod1, aNode: Node);
+    constructor(method: SubgroupFunctionNodeMethod2, aNode: Node, bNode: Node);
+
+    // 0 inputs
+    static SUBGROUP_ELECT: "subgroupElect";
+
+    // 1 input
+    static SUBGROUP_BALLOT: "subgroupBallot";
+    static SUBGROUP_ADD: "subgroupAdd";
+    static SUBGROUP_INCLUSIVE_ADD: "subgroupInclusiveAdd";
+    static SUBGROUP_EXCLUSIVE_AND: "subgroupExclusiveAdd";
+    static SUBGROUP_MUL: "subgroupMul";
+    static SUBGROUP_INCLUSIVE_MUL: "subgroupInclusiveMul";
+    static SUBGROUP_EXCLUSIVE_MUL: "subgroupExclusiveMul";
+    static SUBGROUP_AND: "subgroupAnd";
+    static SUBGROUP_OR: "subgroupOr";
+    static SUBGROUP_XOR: "subgroupXor";
+    static SUBGROUP_MIN: "subgroupMin";
+    static SUBGROUP_MAX: "subgroupMax";
+    static SUBGROUP_ALL: "subgroupAll";
+    static SUBGROUP_ANY: "subgroupAny";
+    static SUBGROUP_BROADCAST_FIRST: "subgroupBroadcastFirst";
+    static QUAD_SWAP_X: "quadSwapX";
+    static QUAD_SWAP_Y: "quadSwapY";
+    static QUAD_SWAP_DIAGONAL: "quadSwapDiagonal";
+
+    // 2 inputs
+    static SUBGROUP_BROADCAST: "subgroupBroadcast";
+    static SUBGROUP_SHUFFLE: "subgroupShuffle";
+    static SUBGROUP_SHUFFLE_XOR: "subgroupShuffleXor";
+    static SUBGROUP_SHUFFLE_UP: "subgroupShuffleUp";
+    static SUBGROUP_SHUFFLE_DOWN: "subgroupShuffleDown";
+    static QUAD_BROADCAST: "quadBroadcast";
+}
+
+export default SubgroupFunctionNode;
+
+export const subgroupElect: () => Node;
+
+export const subgroupBallot: (pred: Node) => Node;
+export const subgroupAdd: (e: Node) => Node;
+export const subgroupInclusiveAdd: (e: Node) => Node;
+export const subgroupExclusiveAdd: (e: Node) => Node;
+export const subgroupMul: (e: Node) => Node;
+export const subgroupInclusiveMul: (e: Node) => Node;
+export const subgroupExclusiveMul: (e: Node) => Node;
+export const subgroupAnd: (e: Node) => Node;
+export const subgroupOr: (e: Node) => Node;
+export const subgroupXor: (e: Node) => Node;
+export const subgroupMin: (e: Node) => Node;
+export const subgroupMax: (e: Node) => Node;
+export const subgroupAll: () => Node;
+export const subgroupAny: () => Node;
+export const subgroupBroadcastFirst: (e: Node, id: Node) => Node;
+export const quadSwapX: (e: Node) => Node;
+export const quadSwapY: (e: Node) => Node;
+export const quadSwapDiagonal: (e: Node) => Node;
+
+export const subgroupBroadcast: (e: Node, id: Node) => Node;
+export const subgroupShuffle: (v: Node, id: Node) => Node;
+export const subgroupShuffleXor: (v: Node, mask: Node) => Node;
+export const subgroupShuffleUp: (v: Node, delta: Node) => Node;
+export const subgroupShuffleDown: (v: Node, delta: Node) => Node;
+export const quadBroadcast: (e: Node) => Node;

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

@@ -1,5 +1,4 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class WorkgroupInfoNode extends Node {
     bufferType: string;
@@ -16,4 +15,4 @@ declare class WorkgroupInfoNode extends Node {
 
 export default WorkgroupInfoNode;
 
-export const workgroupArray: (type: string, count?: number) => ShaderNodeObject<WorkgroupInfoNode>;
+export const workgroupArray: (type: string, count?: number) => WorkgroupInfoNode;

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

@@ -1,7 +1,6 @@
 import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import LightingNode from "./LightingNode.js";
 import { DirectLightData, DirectRectAreaLightData } from "./LightsNode.js";
 import ShadowNode from "./ShadowNode.js";
@@ -23,7 +22,7 @@ declare class AnalyticLightNode<T extends Light> extends LightingNode {
 
     setupDirectRectArea(builder: NodeBuilder): DirectRectAreaLightData | undefined;
 
-    setupShadowNode(): ShaderNodeObject<ShadowNode>;
+    setupShadowNode(): ShadowNode;
 
     setupShadow(builder: NodeBuilder): void;
 }

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

@@ -1,9 +1,8 @@
 import Node from "../core/Node.js";
 import ConditionalNode from "../math/ConditionalNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export const getDistanceAttenuation: (args: {
     lightDistance: Node;
     cutoffDistance: Node;
     decayExponent: Node;
-}) => ShaderNodeObject<ConditionalNode>;
+}) => ConditionalNode;

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

@@ -1,7 +1,6 @@
 import ContextNode from "../core/ContextNode.js";
 import LightingModel, { LightingModelReflectedLight } from "../core/LightingModel.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import LightsNode from "./LightsNode.js";
 
 export interface LightingContext {
@@ -32,4 +31,4 @@ export default class LightingContextNode extends ContextNode {
 export const lightingContext: (
     node: LightsNode,
     lightingModelNode?: LightingModel,
-) => ShaderNodeObject<LightingContextNode>;
+) => LightingContextNode;

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

@@ -1,7 +1,6 @@
 import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
 import { NodeBuilder } from "../Nodes.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import LightingNode from "./LightingNode.js";
 
 export interface DirectLightData {
@@ -44,4 +43,4 @@ declare class LightsNode extends Node {
 
 export default LightsNode;
 
-export const lights: (lights?: Light[]) => ShaderNodeObject<LightsNode>;
+export const lights: (lights?: Light[]) => LightsNode;

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

@@ -1,15 +1,14 @@
 import { PointLight } from "../../lights/PointLight.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import AnalyticLightNode from "./AnalyticLightNode.js";
 import { DirectLightData } from "./LightsNode.js";
 import PointShadowNode from "./PointShadowNode.js";
 
 export const directPointLight: (params: {
-    color: ShaderNodeObject<Node>;
-    lightViewPosition: ShaderNodeObject<Node>;
-    cutoffDistance: ShaderNodeObject<Node>;
-    decayExponent: ShaderNodeObject<Node>;
+    color: Node;
+    lightViewPosition: Node;
+    cutoffDistance: Node;
+    decayExponent: Node;
 }) => DirectLightData;
 
 declare class PointLightNode extends AnalyticLightNode<PointLight> {
@@ -18,7 +17,7 @@ declare class PointLightNode extends AnalyticLightNode<PointLight> {
 
     constructor(light?: PointLight | null);
 
-    setupShadowNode(): ShaderNodeObject<PointShadowNode>;
+    setupShadowNode(): PointShadowNode;
 }
 
 export default PointLightNode;

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

@@ -1,17 +1,16 @@
 import { Light } from "../../lights/Light.js";
 import { LightShadow } from "../../lights/LightShadow.js";
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import ShadowNode from "./ShadowNode.js";
 
-export const cubeToUV: (pos: Node, texelSizeY: Node) => ShaderNodeObject<Node>;
+export const cubeToUV: (pos: Node, texelSizeY: Node) => Node;
 
 export const BasicPointShadowFilter: (
     depthTexture: Node,
     bd3D: Node,
     dp: Node,
     texelSize: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const PointShadowFilter: (
     depthTexture: Node,
@@ -19,7 +18,7 @@ export const PointShadowFilter: (
     dp: Node,
     texelSize: Node,
     shadow: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 declare class PointShadowNode extends ShadowNode {
     constructor(light: Light, shadow: LightShadow | null);
@@ -27,4 +26,4 @@ declare class PointShadowNode extends ShadowNode {
 
 export default PointShadowNode;
 
-export const pointShadow: (light: Light, shadow?: LightShadow | null) => ShaderNodeObject<PointShadowNode>;
+export const pointShadow: (light: Light, shadow?: LightShadow | null) => PointShadowNode;

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

@@ -1,7 +1,6 @@
 import { Light } from "../../lights/Light.js";
 import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class ShadowBaseNode extends Node {
     light: Light;
@@ -13,6 +12,6 @@ declare class ShadowBaseNode extends Node {
     setupShadowPosition(builder: NodeBuilder): void;
 }
 
-export const shadowPositionWorld: ShaderNodeObject<Node>;
+export const shadowPositionWorld: Node;
 
 export default ShadowBaseNode;

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

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

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

@@ -8,7 +8,6 @@ import { Group } from "../../objects/Group.js";
 import ClippingContext from "../../renderers/common/ClippingContext.js";
 import Renderer from "../../renderers/common/Renderer.js";
 import { Scene } from "../../scenes/Scene.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 import LightsNode from "./LightsNode.js";
 import ShadowBaseNode from "./ShadowBaseNode.js";
 
@@ -35,4 +34,4 @@ declare class ShadowNode extends ShadowBaseNode {
 
 export default ShadowNode;
 
-export const shadow: (light: Light, shadow?: LightShadow) => ShaderNodeObject<ShadowNode>;
+export const shadow: (light: Light, shadow?: LightShadow) => ShadowNode;

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

@@ -1,7 +1,6 @@
 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";
 
 declare class SpotLightNode extends AnalyticLightNode<SpotLight> {
@@ -17,7 +16,7 @@ declare class SpotLightNode extends AnalyticLightNode<SpotLight> {
 
     constructor(light?: SpotLight | null);
 
-    getLightCoord(builder: NodeBuilder): ShaderNodeObject<Node>;
+    getLightCoord(builder: NodeBuilder): Node;
 }
 
 declare module "three" {

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

@@ -1,21 +1,20 @@
 import Node from "../core/Node.js";
 import MathNode from "../math/MathNode.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 const mx_aastep: (threshold: Node | number, value: Node | number) => ShaderNodeObject<MathNode>;
+export const mx_aastep: (threshold: Node | number, value: Node | number) => MathNode;
 
 export const mx_ramplr: (
     valuel: Node | number,
     valuer: Node | number,
     texcoord?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 export const mx_ramptb: (
     valuet: Node | number,
     valueb: Node | number,
     texcoord?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 
 export const mx_ramp4: (
     valuetl: Node | number,
@@ -23,50 +22,50 @@ export const mx_ramp4: (
     valuebl: Node | number,
     valuebr: Node | number,
     texcoord?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 
 export const mx_splitlr: (
     valuel: Node | number,
     valuer: Node | number,
     center: Node | number,
     texcoord?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 export const mx_splittb: (
     valuet: Node | number,
     valueb: Node | number,
     center: Node | number,
     texcoord?: Node,
-) => ShaderNodeObject<MathNode>;
+) => MathNode;
 
 export const mx_transform_uv: (
     uv_scale?: Node | number,
     uv_offset?: Node | number,
     uv_geo?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
-export const mx_safepower: (in1: Node | number, in2?: Node | number) => ShaderNodeObject<Node>;
+export const mx_safepower: (in1: Node | number, in2?: Node | number) => Node;
 
 export const mx_contrast: (
     input: Node | number,
     amount?: Node | number,
     pivot?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const mx_noise_float: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 export const mx_noise_vec3: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 export const mx_noise_vec4: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const mx_unifiednoise2d: (
     noiseType: Node,
@@ -80,7 +79,7 @@ export const mx_unifiednoise2d: (
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 export const mx_unifiednoise3d: (
     noiseType: Node,
     texcoord?: Node,
@@ -93,22 +92,22 @@ export const mx_unifiednoise3d: (
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export function mx_worley_noise_float(
     texcoord?: Node,
     jitter?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 export function mx_worley_noise_vec2(
     texcoord?: Node,
     jitter?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 export function mx_worley_noise_vec3(
     texcoord?: Node,
     jitter?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 
-export function mx_cell_noise_float(texcoord?: Node): ShaderNodeObject<Node>;
+export function mx_cell_noise_float(texcoord?: Node): Node;
 
 export function mx_fractal_noise_float(
     position?: Node,
@@ -116,46 +115,46 @@ export function mx_fractal_noise_float(
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 export function mx_fractal_noise_vec2(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 export function mx_fractal_noise_vec3(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 export function mx_fractal_noise_vec4(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): ShaderNodeObject<Node>;
+): Node;
 
 export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };
 
-export const mx_add: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_subtract: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_multiply: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_divide: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_modulo: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_power: (in1: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_atan2: (in1?: Node, in2?: Node) => ShaderNodeObject<Node>;
-export const mx_timer: () => ShaderNodeObject<Node>;
-export const mx_frame: () => ShaderNodeObject<Node>;
-export const mx_invert: (in1: Node, amount?: Node) => ShaderNodeObject<Node>;
-export const mx_ifgreater: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
-export const mx_ifgreatereq: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
-export const mx_ifequal: (value1: Node, value2: Node, in1: Node, in2: Node) => ShaderNodeObject<Node>;
-
-export const mx_separate: (in1: Node, channelOrOut?: string | number) => ShaderNodeObject<Node>;
+export const mx_add: (in1: Node, in2?: Node) => Node;
+export const mx_subtract: (in1: Node, in2?: Node) => Node;
+export const mx_multiply: (in1: Node, in2?: Node) => Node;
+export const mx_divide: (in1: Node, in2?: Node) => Node;
+export const mx_modulo: (in1: Node, in2?: Node) => Node;
+export const mx_power: (in1: Node, in2?: Node) => Node;
+export const mx_atan2: (in1?: Node, in2?: Node) => Node;
+export const mx_timer: () => Node;
+export const mx_frame: () => Node;
+export const mx_invert: (in1: Node, amount?: Node) => Node;
+export const mx_ifgreater: (value1: Node, value2: Node, in1: Node, in2: Node) => Node;
+export const mx_ifgreatereq: (value1: Node, value2: Node, in1: Node, in2: Node) => Node;
+export const mx_ifequal: (value1: Node, value2: Node, in1: Node, in2: Node) => Node;
+
+export const mx_separate: (in1: Node, channelOrOut?: string | number) => Node;
 
 export const mx_place2d: (
     texcoord: Node,
@@ -163,10 +162,10 @@ export const mx_place2d: (
     scale?: Node,
     rotate?: Node,
     offset?: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
-export const mx_rotate2d: (input: Node, amount: Node) => ShaderNodeObject<Node>;
+export const mx_rotate2d: (input: Node, amount: Node) => Node;
 
-export const mx_rotate3d: (input: Node, amount: Node, axis: Node) => ShaderNodeObject<Node>;
+export const mx_rotate3d: (input: Node, amount: Node, axis: Node) => Node;
 
-export const mx_heighttonormal: (input: Node, scale: Node) => ShaderNodeObject<Node>;
+export const mx_heighttonormal: (input: Node, scale: Node) => Node;

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

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