@types/three 0.179.0 → 0.181.0

three/src/nodes/math/OperatorNode.d.ts

@@ -1,6 +1,5 @@
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export type OperatorNodeOp =
     | "%"
@@ -39,93 +38,238 @@ export const add: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 export const sub: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 export const mul: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 export const div: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
-export const mod: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const equal: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const notEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const lessThan: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const greaterThan: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const lessThanEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const greaterThanEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
+export const mod: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const equal: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const notEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const lessThan: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const greaterThan: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const lessThanEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const greaterThanEqual: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
 export const and: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
+) => OperatorNode;
 export const or: (
     a: OperatorNodeParameter,
     b: OperatorNodeParameter,
     ...params: OperatorNodeParameter[]
-) => ShaderNodeObject<OperatorNode>;
-export const not: (value: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const xor: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const bitAnd: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const bitNot: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const bitOr: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const bitXor: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const shiftLeft: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-export const shiftRight: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
-
-export const incrementBefore: (a: OperatorNodeParameter) => ShaderNodeObject<Node>;
-export const decrementBefore: (a: OperatorNodeParameter) => ShaderNodeObject<Node>;
-export const increment: (a: OperatorNodeParameter) => ShaderNodeObject<Node>;
-export const decrement: (a: OperatorNodeParameter) => ShaderNodeObject<Node>;
-
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
-        add: typeof add;
-        sub: typeof sub;
-        mul: typeof mul;
-        div: typeof div;
-        mod: typeof mod;
-        equal: typeof equal;
-        notEqual: typeof notEqual;
-        lessThan: typeof lessThan;
-        greaterThan: typeof greaterThan;
-        lessThanEqual: typeof lessThanEqual;
-        greaterThanEqual: typeof greaterThanEqual;
-        and: typeof and;
-        or: typeof or;
-        not: typeof not;
-        xor: typeof xor;
-        bitAnd: typeof bitAnd;
-        bitNot: typeof bitNot;
-        bitOr: typeof bitOr;
-        bitXor: typeof bitXor;
-        shiftLeft: typeof shiftLeft;
-        shiftRight: typeof shiftRight;
-        incrementBefore: typeof incrementBefore;
-        decrementBefore: typeof decrement;
-        increment: typeof increment;
-        decrement: typeof decrement;
+) => OperatorNode;
+export const not: (value: OperatorNodeParameter) => OperatorNode;
+export const xor: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const bitAnd: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const bitNot: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const bitOr: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const bitXor: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const shiftLeft: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+export const shiftRight: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
+
+export const incrementBefore: (a: OperatorNodeParameter) => Node;
+export const decrementBefore: (a: OperatorNodeParameter) => Node;
+export const increment: (a: OperatorNodeParameter) => Node;
+export const decrement: (a: OperatorNodeParameter) => Node;
+
+declare module "../Nodes.js" {
+    interface Node {
+        add: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        addAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        sub: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        subAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        mul: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        mulAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        div: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        divAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        mod: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        modAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        equal: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        equalAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        notEqual: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        notEqualAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        lessThan: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        lessThanAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        greaterThan: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        greaterThanAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        lessThanEqual: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        lessThanEqualAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        greaterThanEqual: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        greaterThanEqualAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        and: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        andAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        or: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => OperatorNode;
+        orAssign: (
+            b: OperatorNodeParameter,
+            ...params: OperatorNodeParameter[]
+        ) => this;
+
+        not: () => OperatorNode;
+        notAssign: () => this;
+
+        xor: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        xorAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        bitAnd: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        bitAndAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        bitNot: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        bitNotAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        bitOr: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        bitOrAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        bitXor: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        bitXorAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        shiftLeft: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        shiftLeftAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        shiftRight: (
+            b: OperatorNodeParameter,
+        ) => OperatorNode;
+        shiftRightAssign: (
+            b: OperatorNodeParameter,
+        ) => this;
+
+        incrementBefore: () => OperatorNode;
+        incrementBeforeAssign: () => this;
+
+        decrementBefore: () => OperatorNode;
+        decrementBeforeAssign: () => this;
+
+        increment: () => OperatorNode;
+        incrementAssign: () => this;
+
+        decrement: () => OperatorNode;
+        decrementAssign: () => this;
     }
 }
 
 /**
  * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
  */
-export const modInt: (a: OperatorNodeParameter, b: OperatorNodeParameter) => ShaderNodeObject<OperatorNode>;
+export const modInt: (a: OperatorNodeParameter, b: OperatorNodeParameter) => OperatorNode;
 
-declare module "../tsl/TSLCore.js" {
-    interface NodeElements {
+declare module "../Nodes.js" {
+    interface Nodes {
+        /**
+         * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
+         */
+        modInt: (b: OperatorNodeParameter) => OperatorNode;
         /**
          * @deprecated "modInt()" is deprecated. Use "mod( int( ... ) )" instead.
          */
-        modInt: typeof modInt;
+        modIntAssign: (b: OperatorNodeParameter) => this;
     }
 }

three/src/nodes/math/TriNoise3D.d.ts

@@ -1,12 +1,11 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const tri: (x: Node) => ShaderNodeObject<Node>;
+export const tri: (x: Node) => Node;
 
-export const tri3: (p: Node) => ShaderNodeObject<Node>;
+export const tri3: (p: Node) => Node;
 
 export const triNoise3D: (
     position: Node,
     speed: Node | number,
     time: Node | number,
-) => ShaderNodeObject<Node>;
+) => Node;

three/src/nodes/pmrem/PMREMNode.d.ts

@@ -1,7 +1,6 @@
 import { Texture } from "../../textures/Texture.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 declare class PMREMNode extends TempNode {
     uvNode: Node | null;
@@ -19,4 +18,4 @@ export const pmremTexture: (
     value: Texture,
     uvNode?: Node,
     levelNode?: Node,
-) => ShaderNodeObject<PMREMNode>;
+) => PMREMNode;

three/src/nodes/pmrem/PMREMUtils.d.ts

@@ -1,7 +1,6 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const getDirection: (uv_immutable: Node, face: Node) => ShaderNodeObject<Node>;
+export const getDirection: (uv_immutable: Node, face: Node) => Node;
 
 export const textureCubeUV: (
     envMap: Node,
@@ -10,7 +9,7 @@ export const textureCubeUV: (
     CUBEUV_TEXEL_WIDTH: Node,
     CUBEUV_TEXEL_HEIGHT: Node,
     CUBEUV_MAX_MIP: Node,
-) => ShaderNodeObject<Node>;
+) => Node;
 
 export const blur: (
     n: Node,
@@ -25,4 +24,4 @@ export const blur: (
     CUBEUV_TEXEL_WIDTH: Node,
     CUBEUV_TEXEL_HEIGHT: Node,
     CUBEUV_MAX_MIP: Node,
-) => ShaderNodeObject<Node>;
+) => Node;

three/src/nodes/procedural/Checker.d.ts

@@ -1,4 +1,3 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const checker: (coord?: Node) => ShaderNodeObject<Node>;
+export const checker: (coord?: Node) => Node;

three/src/nodes/shapes/Shapes.d.ts

@@ -1,4 +1,3 @@
 import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const shapeCircle: (coord?: Node) => ShaderNodeObject<Node>;
+export const shapeCircle: (coord?: Node) => Node;

three/src/nodes/tsl/TSLBase.d.ts

@@ -4,8 +4,9 @@ export * from "../code/FunctionCallNode.js";
 export * from "../core/ArrayNode.js";
 export * from "../core/AssignNode.js";
 export * from "../core/BypassNode.js";
-export * from "../core/CacheNode.js";
 export * from "../core/ContextNode.js";
+export * from "../core/InspectorNode.js";
+export * from "../core/IsolateNode.js";
 export * from "../core/PropertyNode.js";
 export * from "../core/SubBuildNode.js";
 export * from "../core/UniformNode.js";