@types/three 0.181.0 → 0.183.0

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

@@ -3,22 +3,18 @@ import { LightShadow } from "../../lights/LightShadow.js";
 import Node from "../core/Node.js";
 import ShadowNode from "./ShadowNode.js";
 
-export const cubeToUV: (pos: Node, texelSizeY: Node) => Node;
+export const BasicPointShadowFilter: (params: {
+    depthTexture: Node;
+    bd3D: Node;
+    dp: Node;
+}) => Node;
 
-export const BasicPointShadowFilter: (
-    depthTexture: Node,
-    bd3D: Node,
-    dp: Node,
-    texelSize: Node,
-) => Node;
-
-export const PointShadowFilter: (
-    depthTexture: Node,
-    bd3D: Node,
-    dp: Node,
-    texelSize: Node,
-    shadow: Node,
-) => Node;
+export const PointShadowFilter: (params: {
+    depthTexture: Node;
+    bd3D: Node;
+    dp: Node;
+    shadow: Node;
+}) => Node;
 
 declare class PointShadowNode extends ShadowNode {
     constructor(light: Light, shadow: LightShadow | null);

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

@@ -25,3 +25,5 @@ export const VSMShadowFilter: (
 ) => Node;
 
 export const getShadowMaterial: (light: Light) => NodeMaterial;
+
+export const disposeShadowMaterial: (light: Light) => void;

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

@@ -19,10 +19,4 @@ declare class SpotLightNode extends AnalyticLightNode<SpotLight> {
     getLightCoord(builder: NodeBuilder): Node;
 }
 
-declare module "three" {
-    export interface SpotLight {
-        attenuationNode?: ((lightNode: SpotLightNode) => Node) | null | undefined;
-    }
-}
-
 export default SpotLightNode;

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

@@ -55,17 +55,17 @@ export const mx_noise_float: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => Node;
+) => Node<"float">;
 export const mx_noise_vec3: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => Node;
+) => Node<"vec3">;
 export const mx_noise_vec4: (
     texcoord?: Node,
     amplitude?: Node | number,
     pivot?: Node | number,
-) => Node;
+) => Node<"vec4">;
 
 export const mx_unifiednoise2d: (
     noiseType: Node,
@@ -97,17 +97,17 @@ export const mx_unifiednoise3d: (
 export function mx_worley_noise_float(
     texcoord?: Node,
     jitter?: Node | number,
-): Node;
+): Node<"float">;
 export function mx_worley_noise_vec2(
     texcoord?: Node,
     jitter?: Node | number,
-): Node;
+): Node<"vec2">;
 export function mx_worley_noise_vec3(
     texcoord?: Node,
     jitter?: Node | number,
-): Node;
+): Node<"vec3">;
 
-export function mx_cell_noise_float(texcoord?: Node): Node;
+export function mx_cell_noise_float(texcoord?: Node): Node<"float">;
 
 export function mx_fractal_noise_float(
     position?: Node,
@@ -115,28 +115,28 @@ export function mx_fractal_noise_float(
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): Node;
+): Node<"float">;
 export function mx_fractal_noise_vec2(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): Node;
+): Node<"vec2">;
 export function mx_fractal_noise_vec3(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): Node;
+): Node<"vec3">;
 export function mx_fractal_noise_vec4(
     position?: Node,
     octaves?: Node | number,
     lacunarity?: Node | number,
     diminish?: Node | number,
     amplitude?: Node | number,
-): Node;
+): Node<"vec4">;
 
 export { mx_hsvtorgb, mx_rgbtohsv, mx_srgb_texture_to_lin_rec709 };
 

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

@@ -0,0 +1,23 @@
+import Node from "../core/Node.js";
+import MathNode from "./MathNode.js";
+
+export type BitcountNodeMethod =
+    | typeof BitcountNode.COUNT_TRAILING_ZEROS
+    | typeof BitcountNode.COUNT_LEADING_ZEROS
+    | typeof BitcountNode.COUNT_ONE_BITS;
+
+declare class BitcountNode extends MathNode {
+    readonly isBitcountNode: true;
+
+    constructor(method: BitcountNodeMethod, aNode: Node);
+
+    static COUNT_TRAILING_ZEROS: "countTrailingZeros";
+    static COUNT_LEADING_ZEROS: "countLeadingZeros";
+    static COUNT_ONE_BITS: "countOneBits";
+}
+
+export default BitcountNode;
+
+export const countTrailingZeros: (x: Node | number) => BitcountNode;
+export const countLeadingZeros: (x: Node | number) => BitcountNode;
+export const countOneBits: (x: Node | number) => BitcountNode;

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

@@ -1,30 +1,51 @@
 import Node from "../core/Node.js";
 
-declare class ConditionalNode extends Node {
-    condNode: Node;
-    ifNode: Node;
-    elseNode: Node | null;
-
-    constructor(condNode: Node, ifNode: Node, elseNode?: Node | null);
+interface ConditionalNodeInterface<TNodeType> {
+    condNode: Node<"bool">;
+    ifNode: Node<TNodeType>;
+    elseNode: Node<TNodeType> | null;
 }
 
+declare const ConditionalNode: {
+    new<TNodeType>(
+        condNode: Node<"bool">,
+        ifNode: Node<TNodeType>,
+        elseNode?: Node<TNodeType> | null,
+    ): ConditionalNode<TNodeType>;
+};
+
+type ConditionalNode<TNodeType> = Node<TNodeType> & ConditionalNodeInterface<TNodeType>;
+
 export default ConditionalNode;
 
-export const select: (
-    condNode: Node,
-    ifNode: Node | number,
-    elseNode?: Node | number | null,
-) => Node;
-
-declare module "../Nodes.js" {
-    interface Node {
-        select: (
-            ifNode: Node | number,
-            elseNode?: Node | number | null,
-        ) => Node;
-        selectAssign: (
-            ifNode: Node | number,
-            elseNode?: Node | number | null,
-        ) => this;
+interface Select {
+    (
+        condNode: Node<"bool">,
+        ifNode: Node<"float"> | number,
+        elseNode?: Node<"float"> | number | null,
+    ): Node<"float">;
+    <TNodeType>(
+        condNode: Node<"bool">,
+        ifNode: Node<TNodeType>,
+        elseNode?: Node<TNodeType> | null,
+    ): Node<TNodeType>;
+}
+
+export const select: Select;
+
+interface SelectExtension {
+    (
+        ifNode: Node<"float"> | number,
+        elseNode?: Node<"float"> | number | null,
+    ): Node<"float">;
+    <TNodeType>(
+        ifNode: Node<TNodeType>,
+        elseNode?: Node<TNodeType> | null,
+    ): Node<TNodeType>;
+}
+
+declare module "../core/Node.js" {
+    interface NodeElements {
+        select: SelectExtension;
     }
 }

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

@@ -1,3 +1,3 @@
 import Node from "../core/Node.js";
 
-export const hash: (seed: Node) => Node;
+export const hash: (seed: Node) => Node<"float">;