@types/three 0.181.0 → 0.182.0

three/src/lights/DirectionalLight.d.ts

@@ -1,8 +1,14 @@
-import { Object3D } from "../core/Object3D.js";
+import { JSONMeta, Object3D } from "../core/Object3D.js";
 import { ColorRepresentation } from "../math/Color.js";
 import { Vector3 } from "../math/Vector3.js";
 import { DirectionalLightShadow } from "./DirectionalLightShadow.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+import { LightShadowJSON } from "./LightShadow.js";
+
+export interface DirectionalLightJSON extends LightJSON {
+    shadow: LightShadowJSON;
+    target: string;
+}
 
 /**
  * A light that gets emitted in a specific direction
@@ -99,4 +105,6 @@ export class DirectionalLight extends Light<DirectionalLightShadow> {
      * Call this method whenever this instance is no longer used in your app.
      */
     dispose(): void;
+
+    toJSON(meta?: JSONMeta): DirectionalLightJSON;
 }

three/src/lights/HemisphereLight.d.ts

@@ -1,6 +1,11 @@
+import { JSONMeta } from "../core/Object3D.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
 import { Vector3 } from "../math/Vector3.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+
+export interface HemisphereLightJSON extends LightJSON {
+    groundColor: number;
+}
 
 /**
  * A light source positioned directly above the scene, with color fading from the sky color to the ground color.
@@ -58,4 +63,6 @@ export class HemisphereLight extends Light<undefined> {
      * @defaultValue `new THREE.Color()` set to white _(0xffffff)_.
      */
     groundColor: Color;
+
+    toJSON(meta?: JSONMeta): HemisphereLightJSON;
 }

three/src/lights/Light.d.ts

@@ -1,27 +1,23 @@
-import { JSONMeta, Object3D, Object3DJSON } from "../core/Object3D.js";
+import { JSONMeta, Object3D, Object3DEventMap, Object3DJSON } from "../core/Object3D.js";
 import { Color, ColorRepresentation } from "../math/Color.js";
-import { LightShadow, LightShadowJSON } from "./LightShadow.js";
+import { LightShadow } from "./LightShadow.js";
 
 export interface LightJSON extends Object3DJSON {
     color: number;
     intensity: number;
+}
 
-    groundColor?: number;
-
-    distance?: number;
-    angle?: number;
-    decay?: number;
-    penumbra?: number;
-
-    shadow?: LightShadowJSON;
-    target?: string;
+export interface LightEventMap extends Object3DEventMap {
+    dispose: {};
 }
 
 /**
  * Abstract base class for lights.
  * @remarks All other light types inherit the properties and methods described here.
  */
-export abstract class Light<TShadowSupport extends LightShadow | undefined = LightShadow | undefined> extends Object3D {
+export abstract class Light<TShadowSupport extends LightShadow | undefined = LightShadow | undefined>
+    extends Object3D<LightEventMap>
+{
     /**
      * Creates a new {@link Light}
      * @remarks

three/src/lights/LightProbe.d.ts

@@ -1,5 +1,10 @@
+import { JSONMeta } from "../core/Object3D.js";
 import { SphericalHarmonics3 } from "../math/SphericalHarmonics3.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+
+export interface LightProbeJSON extends LightJSON {
+    sh: number[];
+}
 
 /**
  * Light probes are an alternative way of adding light to a 3D scene.
@@ -42,6 +47,5 @@ export class LightProbe extends Light {
      */
     sh: SphericalHarmonics3;
 
-    /** @internal */
-    fromJSON(json: {}): LightProbe;
+    toJSON(meta?: JSONMeta): LightProbeJSON;
 }

three/src/lights/PointLight.d.ts

@@ -1,7 +1,16 @@
+import { JSONMeta } from "../core/Object3D.js";
 import { ColorRepresentation } from "../math/Color.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+import { LightShadowJSON } from "./LightShadow.js";
 import { PointLightShadow } from "./PointLightShadow.js";
 
+export interface PointLightJSON extends LightJSON {
+    distance: number;
+    decay: number;
+
+    shadow: LightShadowJSON;
+}
+
 /**
  * A light that gets emitted from a single point in all directions
  * @remarks
@@ -99,4 +108,6 @@ export class PointLight extends Light<PointLightShadow> {
      * @remarks Expects a `Float`
      */
     power: number;
+
+    toJSON(meta?: JSONMeta): PointLightJSON;
 }

three/src/lights/PointLightShadow.d.ts

@@ -1,5 +1,4 @@
 import { PerspectiveCamera } from "../cameras/PerspectiveCamera.js";
-import { Light } from "./Light.js";
 import { LightShadow } from "./LightShadow.js";
 
 /**
@@ -12,11 +11,5 @@ export class PointLightShadow extends LightShadow<PerspectiveCamera> {
      * @remarks This is a _constant_ value
      * @defaultValue `true`
      */
-    readonly isPointLightShadow = true;
-
-    /**
-     * Update the matrices for the camera and shadow, used internally by the renderer.
-     * @param light The light for which the shadow is being rendered.
-     */
-    override updateMatrices(light: Light, viewportIndex?: number): void;
+    readonly isPointLightShadow: true;
 }

three/src/lights/SpotLight.d.ts

@@ -1,10 +1,23 @@
-import { Object3D } from "../core/Object3D.js";
+import { JSONMeta, Object3D } from "../core/Object3D.js";
 import { ColorRepresentation } from "../math/Color.js";
 import { Vector3 } from "../math/Vector3.js";
 import { Texture } from "../textures/Texture.js";
-import { Light } from "./Light.js";
+import { Light, LightJSON } from "./Light.js";
+import { LightShadowJSON } from "./LightShadow.js";
 import { SpotLightShadow } from "./SpotLightShadow.js";
 
+export interface SpotLightJSON extends LightJSON {
+    distance: number;
+    angle: number;
+    decay: number;
+    penumbra: number;
+
+    target: string;
+    map?: string | undefined;
+
+    shadow: LightShadowJSON;
+}
+
 /**
  * This light gets emitted from a single point in one direction, along a cone that increases in size the further from the light it gets.
  * @example
@@ -161,4 +174,6 @@ export class SpotLight extends Light<SpotLightShadow> {
      * @remarks **Warning**: {@link SpotLight.map} is disabled if {@link SpotLight.castShadow} is `false`.
      */
     map: Texture | null;
+
+    toJSON(meta?: JSONMeta): SpotLightJSON;
 }

three/src/materials/Material.d.ts

@@ -548,6 +548,7 @@ export class Material extends EventDispatcher<{ dispose: {} }> {
      * @default 0
      */
     readonly version: number;
+    defines?: Record<string, unknown> | undefined;
     /**
      * An optional callback that is executed immediately before the material is used to render a 3D object.
      *

three/src/materials/ShaderMaterial.d.ts

@@ -26,7 +26,7 @@ export interface ShaderMaterialProperties extends MaterialProperties {
      * #define BAR true
      * ```
      */
-    defines: { [key: string]: any };
+    defines: Record<string, unknown>;
     /**
      * An object of the form:
      * ```js
@@ -85,9 +85,22 @@ export interface ShaderMaterialProperties extends MaterialProperties {
      */
     wireframeLinewidth: number;
     /**
-     * Define whether the material color is affected by global fog settings; `true`
+     * Defines whether the material color is affected by global fog settings; `true`
      * to pass fog uniforms to the shader.
      *
+     * Setting this property to `true` requires the definition of fog uniforms. It is
+     * recommended to use `UniformsUtils.merge()` to combine the custom shader uniforms
+     * with predefined fog uniforms.
+     *
+     * ```js
+     * const material = new ShaderMaterial( {
+     *     uniforms: UniformsUtils.merge( [ UniformsLib[ 'fog' ], shaderUniforms ] );
+     *     vertexShader: vertexShader,
+     *     fragmentShader: fragmentShader,
+     *     fog: true
+     * } );
+     * ```
+     *
      * @default false
      */
     fog: boolean;
@@ -248,4 +261,6 @@ export class ShaderMaterial extends Material {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface ShaderMaterial extends ShaderMaterialProperties {}
+export interface ShaderMaterial extends ShaderMaterialProperties {
+    defines: Record<string, unknown>;
+}

three/src/materials/nodes/NodeMaterial.d.ts

@@ -1,4 +1,5 @@
 import ClippingNode from "../../nodes/accessors/ClippingNode.js";
+import ContextNode from "../../nodes/core/ContextNode.js";
 import LightingModel from "../../nodes/core/LightingModel.js";
 import MRTNode from "../../nodes/core/MRTNode.js";
 import Node from "../../nodes/core/Node.js";
@@ -272,6 +273,12 @@ export interface NodeMaterialNodeProperties {
      * @default null
      */
     vertexNode: Node | null;
+    /**
+     * This node can be used as a global context management component for this material.
+     *
+     * @default null
+     */
+    contextNode: ContextNode | null;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface

three/src/nodes/TSL.d.ts

@@ -20,9 +20,12 @@ export * from "./core/VaryingNode.js";
 
 // math
 export * from "./math/BitcastNode.js";
+export * from "./math/BitcountNode.js";
 export * from "./math/Hash.js";
 export * from "./math/MathUtils.js";
+export * from "./math/PackFloatNode.js";
 export * from "./math/TriNoise3D.js";
+export * from "./math/UnpackFloatNode.js";
 
 // utils
 export * from "./utils/EquirectUV.js";
@@ -160,7 +163,7 @@ export * from "./materialx/MaterialXNodes.js";
 export { default as BRDF_GGX } from "./functions/BSDF/BRDF_GGX.js";
 export { default as BRDF_Lambert } from "./functions/BSDF/BRDF_Lambert.js";
 export { default as D_GGX } from "./functions/BSDF/D_GGX.js";
-export { default as DFGApprox } from "./functions/BSDF/DFGApprox.js";
+export { default as DFGLUT } from "./functions/BSDF/DFGLUT.js";
 export { default as F_Schlick } from "./functions/BSDF/F_Schlick.js";
 export { default as Schlick_to_F0 } from "./functions/BSDF/Schlick_to_F0.js";
 export { default as V_GGX_SmithCorrelated } from "./functions/BSDF/V_GGX_SmithCorrelated.js";

three/src/nodes/accessors/BufferAttributeNode.d.ts

@@ -3,6 +3,7 @@ import { BufferAttribute, TypedArray } from "../../core/BufferAttribute.js";
 import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
 import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
 import InputNode from "../core/InputNode.js";
+import Node from "../core/Node.js";
 import NodeBuilder from "../core/NodeBuilder.js";
 /**
  * In earlier `three.js` versions it was only possible to define attribute data
@@ -112,14 +113,14 @@ export default BufferAttributeNode;
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
  * @param {number} [stride=0] - The buffer stride.
  * @param {number} [offset=0] - The buffer offset.
- * @returns {BufferAttributeNode}
+ * @returns {BufferAttributeNode|Node}
  */
 export declare const bufferAttribute: (
-    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    array: BufferAttribute | InterleavedBuffer | TypedArray,
     type?: string | null,
     stride?: number,
     offset?: number,
-) => BufferAttributeNode;
+) => Node;
 /**
  * TSL function for creating a buffer attribute node but with dynamic draw usage.
  * Use this function if attribute data are updated per frame.
@@ -130,14 +131,14 @@ export declare const bufferAttribute: (
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
  * @param {number} [stride=0] - The buffer stride.
  * @param {number} [offset=0] - The buffer offset.
- * @returns {BufferAttributeNode}
+ * @returns {BufferAttributeNode|Node}
  */
 export declare const dynamicBufferAttribute: (
-    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    array: BufferAttribute | InterleavedBuffer | TypedArray,
     type?: string | null,
     stride?: number,
     offset?: number,
-) => BufferAttributeNode;
+) => Node;
 /**
  * TSL function for creating a buffer attribute node but with enabled instancing
  *
@@ -147,14 +148,14 @@ export declare const dynamicBufferAttribute: (
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
  * @param {number} [stride=0] - The buffer stride.
  * @param {number} [offset=0] - The buffer offset.
- * @returns {BufferAttributeNode}
+ * @returns {BufferAttributeNode|Node}
  */
 export declare const instancedBufferAttribute: (
-    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    array: BufferAttribute | InterleavedBuffer | TypedArray,
     type?: string | null,
     stride?: number,
     offset?: number,
-) => BufferAttributeNode;
+) => Node;
 /**
  * TSL function for creating a buffer attribute node but with dynamic draw usage and enabled instancing
  *
@@ -164,14 +165,14 @@ export declare const instancedBufferAttribute: (
  * @param {?string} [type=null] - The buffer type (e.g. `'vec3'`).
  * @param {number} [stride=0] - The buffer stride.
  * @param {number} [offset=0] - The buffer offset.
- * @returns {BufferAttributeNode}
+ * @returns {BufferAttributeNode|Node}
  */
 export declare const instancedDynamicBufferAttribute: (
-    array: TypedArray | InterleavedBuffer | BufferAttribute,
+    array: BufferAttribute | InterleavedBuffer | TypedArray,
     type?: string | null,
     stride?: number,
     offset?: number,
-) => BufferAttributeNode;
+) => Node;
 declare module "../Nodes.js" {
     interface BufferNode<TValue> {
         toAttribute: () => BufferAttributeNode;

three/src/nodes/accessors/InstanceNode.d.ts

@@ -1,23 +1,24 @@
 import { InstancedBufferAttribute } from "../../core/InstancedBufferAttribute.js";
+import StorageInstancedBufferAttribute from "../../renderers/common/StorageInstancedBufferAttribute.js";
 import Node from "../core/Node.js";
 
 export default class InstanceNode extends Node {
     count: number;
-    instanceMatrix: InstancedBufferAttribute;
-    instanceColor: InstancedBufferAttribute | null;
+    instanceMatrix: InstancedBufferAttribute | StorageInstancedBufferAttribute;
+    instanceColor: InstancedBufferAttribute | StorageInstancedBufferAttribute | null;
 
     instanceMatrixNode: Node | null;
     instanceColorNode: Node | null;
 
     constructor(
         count: number,
-        instanceMatrix: InstancedBufferAttribute,
-        instanceColor?: InstancedBufferAttribute | null,
+        instanceMatrix: InstancedBufferAttribute | StorageInstancedBufferAttribute,
+        instanceColor?: InstancedBufferAttribute | StorageInstancedBufferAttribute | null,
     );
 }
 
 export const instance: (
     count: number,
-    instanceMatrix: InstancedBufferAttribute,
-    instanceColor?: InstancedBufferAttribute | null,
+    instanceMatrix: InstancedBufferAttribute | StorageInstancedBufferAttribute,
+    instanceColor?: InstancedBufferAttribute | StorageInstancedBufferAttribute | null,
 ) => InstanceNode;

three/src/nodes/accessors/Texture3DNode.d.ts

@@ -15,3 +15,15 @@ export const texture3D: (
     uvNode?: Node | null,
     levelNode?: Node | number | null,
 ) => Texture3DNode;
+
+export const texture3DLoad: (
+    value: Texture,
+    uvNode?: Node | null,
+    levelNode?: Node | number | null,
+) => Texture3DNode;
+
+export const texture3DLevel: (
+    value: Texture,
+    uvNode?: Node | null,
+    levelNode?: Node | number | null,
+) => Texture3DNode;

three/src/nodes/core/ContextNode.d.ts

@@ -1,23 +1,33 @@
+import { Light } from "../../lights/Light.js";
 import Node from "./Node.js";
 import { NodeBuilderContext } from "./NodeBuilder.js";
 
 declare class ContextNode extends Node {
     readonly isContextNode: true;
 
-    node: Node;
+    node: Node | null;
     value: NodeBuilderContext;
 
-    constructor(node: Node, value?: NodeBuilderContext);
+    constructor(node?: Node | null, value?: NodeBuilderContext);
 }
 
 export default ContextNode;
 
-export const context: (node: Node, context?: NodeBuilderContext) => ContextNode;
+interface ContextFunction {
+    (value?: NodeBuilderContext): ContextNode;
+    (node: Node, value?: NodeBuilderContext): ContextNode;
+}
+
+export const context: ContextFunction;
 
 export const uniformFlow: (node: Node) => ContextNode;
 
 export const setName: (node: Node, label: string) => Node;
 
+export function builtinShadowContext(shadowNode: Node, light: Light, node?: Node | null): ContextNode;
+
+export function builtinAOContext(aoNode: Node, node?: Node | null): ContextNode;
+
 /**
  * @deprecated "label()" has been deprecated. Use "setName()" instead.
  */
@@ -42,5 +52,11 @@ declare module "../Nodes.js" {
 
         setName: (label: string) => Node;
         setNameAssign: (label: string) => this;
+
+        builtinShadowContext: (shadowNode: Node, light: Light) => ContextNode;
+        builtinShadowContextAssign: (shadowNode: Node, light: Light) => this;
+
+        builtinAOContext: (aoValue: Node) => ContextNode;
+        builtinAOContextAssign: (aoValue: Node) => this;
     }
 }

three/src/nodes/core/NodeUtils.d.ts

@@ -16,7 +16,7 @@ export function getLengthFromType(type: string): number | undefined;
 
 export function getMemoryLengthFromType(type: string): number | undefined;
 
-export function getByteBoundaryFromType(type: string): number | undefined;
+export function getAlignmentFromType(type: string): number | undefined;
 
 export function getValueType(value: unknown): string | null;
 

three/src/nodes/core/PropertyNode.d.ts

@@ -13,6 +13,7 @@ export const property: (type?: string | null, name?: string | null) => PropertyN
 export const varyingProperty: (type?: string | null, name?: string | null) => PropertyNode;
 
 export const diffuseColor: PropertyNode;
+export const diffuseContribution: PropertyNode;
 export const emissive: PropertyNode;
 export const roughness: PropertyNode;
 export const metalness: PropertyNode;
@@ -28,6 +29,7 @@ export const anisotropy: PropertyNode;
 export const anisotropyT: PropertyNode;
 export const anisotropyB: PropertyNode;
 export const specularColor: PropertyNode;
+export const specularColorBlended: PropertyNode;
 export const specularF90: PropertyNode;
 export const shininess: PropertyNode;
 export const output: PropertyNode;

three/src/nodes/display/NormalMapNode.d.ts

@@ -1,4 +1,4 @@
-import { NormalMapTypes } from "../../constants.js";
+import { NormalMapTypes, NormalPacking } from "../../constants.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
 
@@ -8,6 +8,8 @@ declare class NormalMapNode extends TempNode {
 
     normalMapType: NormalMapTypes;
 
+    unpackNormalMode: NormalPacking;
+
     constructor(node: Node, scaleNode?: Node | null);
 }
 

three/src/nodes/display/PassNode.d.ts

@@ -2,10 +2,12 @@ import { Camera } from "../../cameras/Camera.js";
 import { Layers } from "../../core/Layers.js";
 import { Object3D } from "../../core/Object3D.js";
 import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
+import { Material } from "../../materials/Material.js";
 import { Vector4 } from "../../math/Vector4.js";
 import Renderer from "../../renderers/common/Renderer.js";
 import { Texture } from "../../textures/Texture.js";
 import TextureNode from "../accessors/TextureNode.js";
+import ContextNode from "../core/ContextNode.js";
 import MRTNode from "../core/MRTNode.js";
 import Node from "../core/Node.js";
 import TempNode from "../core/TempNode.js";
@@ -32,6 +34,12 @@ declare class PassNode extends TempNode {
 
     renderTarget: RenderTarget;
 
+    overrideMaterial: Material | null;
+    transparent: boolean;
+    opaque: boolean;
+
+    contextNode: ContextNode | null;
+
     readonly isPassNode: true;
 
     constructor(scope: PassNodeScope, scene: Object3D, camera: Camera, options?: RenderTargetOptions);

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

@@ -0,0 +1,12 @@
+import Node from "../../core/Node.js";
+import OperatorNode from "../../math/OperatorNode.js";
+
+/**
+ * Precomputed DFG LUT for Image-Based Lighting
+ * Resolution: 16x16
+ * Samples: 4096 per texel
+ * Format: RG16F (2 half floats per texel: scale, bias)
+ */
+declare const DFGLUT: (args: { roughness: Node; dotNV: Node }) => OperatorNode;
+
+export default DFGLUT;

three/src/nodes/functions/PhysicalLightingModel.d.ts

@@ -16,6 +16,8 @@ export default class PhysicalLightingModel extends LightingModel {
     sheenSpecularIndirect: Node | null;
     iridescenceFresnel: Node | null;
     iridescenceF0: Node | null;
+    iridescenceF0Dielectric: Node | null;
+    iridescenceF0Metallic: Node | null;
 
     constructor(
         clearcoat?: boolean,
@@ -26,5 +28,10 @@ export default class PhysicalLightingModel extends LightingModel {
         dispersion?: boolean,
     );
 
-    computeMultiscattering(singleScatter: Node, multiScatter: Node, specularF90: Node): void;
+    computeMultiscattering(
+        singleScatter: Node,
+        multiScatter: Node,
+        specularF90: Node,
+        iridescenceF0?: Node | null,
+    ): void;
 }

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

@@ -16,6 +16,8 @@ declare class AnalyticLightNode<T extends Light> extends LightingNode {
 
     constructor(light?: T | null);
 
+    disposeShadow(): void;
+
     getLightVector(builder: NodeBuilder): Node;
 
     setupDirect(builder: NodeBuilder): DirectLightData | undefined;

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/math/BitcountNode.d.ts

@@ -0,0 +1,21 @@
+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 const countTrailingZeros: (x: Node | number) => BitcountNode;
+export const countLeadingZeros: (x: Node | number) => BitcountNode;
+export const countOneBits: (x: Node | number) => BitcountNode;

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

@@ -0,0 +1,19 @@
+import Node from "../core/Node.js";
+import TempNode from "../core/TempNode.js";
+
+export type PackFloatNodeEncoding = "snorm" | "unorm" | "float16";
+
+declare class PackFloatNode extends TempNode {
+    vectorNode: Node;
+    encoding: PackFloatNodeEncoding;
+
+    readonly isPackFloatNode: true;
+
+    constructor(encoding: PackFloatNodeEncoding, vectorNode: Node);
+}
+
+export default PackFloatNode;
+
+export const packSnorm2x16: (value: Node) => PackFloatNode;
+export const packUnorm2x16: (value: Node) => PackFloatNode;
+export const packHalf2x16: (value: Node) => PackFloatNode;