@types/three 0.170.0 → 0.171.0

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

@@ -0,0 +1,30 @@
+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 ShadowNode from "./ShadowNode.js";
+
+export const cubeToUV: (pos: NodeRepresentation, texelSizeY: NodeRepresentation) => ShaderNodeObject<Node>;
+
+export const BasicPointShadowFilter: (
+    depthTexture: NodeRepresentation,
+    bd3D: NodeRepresentation,
+    dp: NodeRepresentation,
+    texelSize: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PointShadowFilter: (
+    depthTexture: NodeRepresentation,
+    bd3D: NodeRepresentation,
+    dp: NodeRepresentation,
+    texelSize: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+declare class PointShadowNode extends ShadowNode {
+    constructor(light: Light, shadow: LightShadow | null);
+}
+
+export default PointShadowNode;
+
+export const pointShadow: (light: Light, shadow?: LightShadow | null) => ShaderNodeObject<PointShadowNode>;

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

@@ -1,12 +1,35 @@
 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 { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const BasicShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PCFShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const PCFSoftShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+    shadow: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+export const VSMShadowFilter: (
+    depthTexture: NodeRepresentation,
+    shadowCoord: NodeRepresentation,
+) => ShaderNodeObject<Node>;
 
 declare class ShadowNode extends Node {
-    constructor(light: Light, shadow: LightShadow);
+    constructor(light: Light, shadow: LightShadow | null);
 }
 
 export default ShadowNode;
 
-export const shadow: (light: Light, shadow: LightShadow) => ShaderNodeObject<ShadowNode>;
+export const shadow: (light: Light, shadow?: LightShadow) => ShaderNodeObject<ShadowNode>;
+export const shadows: ShaderNodeObject<Node>;

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

@@ -10,6 +10,7 @@ export type OperatorNodeOp =
     | ">>"
     | "<<"
     | "=="
+    | "!="
     | "&&"
     | "||"
     | "^^"
@@ -42,6 +43,7 @@ export const mul: Operator;
 export const div: Operator;
 export const modInt: Operator;
 export const equal: Operator;
+export const notEqual: Operator;
 export const lessThan: Operator;
 export const greaterThan: Operator;
 export const lessThanEqual: Operator;
@@ -65,6 +67,7 @@ declare module "../tsl/TSLCore.js" {
         div: typeof div;
         modInt: typeof modInt;
         equal: typeof equal;
+        notEqual: typeof notEqual;
         lessThan: typeof lessThan;
         greaterThan: typeof greaterThan;
         lessThanEqual: typeof lessThanEqual;

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

@@ -19,3 +19,8 @@ export * from "../math/OperatorNode.js";
 export * from "../utils/Discard.js";
 export * from "../utils/RemapNode.js";
 export * from "./TSLCore.js";
+
+/**
+ * @deprecated
+ */
+export function addNodeElement(name: string): void;

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

@@ -172,6 +172,8 @@ type ConstructedNode<T> = T extends new(...args: any[]) => infer R ? (R extends
 
 export type NodeOrType = Node | string;
 
+export const defined: (v: unknown) => unknown;
+
 export const getConstNodeType: (value: NodeOrType) => string | null;
 
 export class ShaderNode<T = {}, R extends Node = Node> {
@@ -271,3 +273,4 @@ export const arrayBuffer: (value: ArrayBuffer) => ShaderNodeObject<ConstNode<Arr
 
 export const element: (node: NodeRepresentation, indexNode: NodeRepresentation) => ShaderNodeObject<Node>;
 export const convert: (node: NodeRepresentation, types: string) => ShaderNodeObject<Node>;
+export const split: (node: NodeRepresentation, channels?: string) => ShaderNodeObject<Node>;

three/src/nodes/utils/SplitNode.d.ts

@@ -1,7 +1,6 @@
 import Node from "../core/Node.js";
 import { SwizzleOption } from "../tsl/TSLCore.js";
 
-/** swizzle node */
 export default class SplitNode extends Node {
     node: Node;
     components: string;
@@ -11,5 +10,6 @@ export default class SplitNode extends Node {
      * @param components swizzle like string, default = "x"
      */
     constructor(node: Node, components?: SwizzleOption);
+
     getVectorLength(): number;
 }

three/src/objects/BatchedMesh.d.ts

@@ -19,10 +19,10 @@ export interface BatchedMeshGeometryRange {
 }
 
 /**
- * A special version of {@link Mesh} with multi draw batch rendering support. Use {@link BatchedMesh} if you have to
- * render a large number of objects with the same material but with different world transformations. The  usage of
- * {@link BatchedMesh} will help you to reduce the number of draw calls and thus improve the overall rendering
- * performance in your application.
+ * A special version of {@link Mesh} with multi draw batch rendering support. Use BatchedMesh if you have to render a
+ * large number of objects with the same material but with different geometries or world transformations. The usage of
+ * BatchedMesh will help you to reduce the number of draw calls and thus improve the overall rendering performance in
+ * your application.
  *
  * If the {@link https://developer.mozilla.org/en-US/docs/Web/API/WEBGL_multi_draw WEBGL_multi_draw extension} is not
  * supported then a less performant fallback is used.

three/src/objects/ClippingGroup.d.ts

@@ -0,0 +1,41 @@
+import { Plane } from "../math/Plane.js";
+import { Group } from "./Group.js";
+
+/**
+ * A special version of the Group object that defines clipping planes for decendant objects. ClippingGroups can be
+ * nested, with clipping planes accumulating by type: intersection or union.
+ */
+declare class ClippingGroup extends Group {
+    /**
+     * Read-only flag to check if a given object is of type ClippingGroup.
+     */
+    readonly isClippingGroup: true;
+
+    /**
+     * User-defined clipping planes specified as THREE.Plane objects in world space. These planes apply to the objects
+     * that are children of this ClippingGroup. Points in space whose signed distance to the plane is negative are
+     * clipped (not rendered). See the webgpu_clipping example. Default is `[]`.
+     */
+    clippingPlanes: Plane[];
+
+    /**
+     * Determines if the clipping planes defined by this object are applied. Default is `true`.
+     */
+    enabled: boolean;
+
+    /**
+     * Changes the behavior of clipping planes so that only their intersection is clipped, rather than their union.
+     * Default is `false`.
+     */
+    clipIntersection: boolean;
+
+    /**
+     * Defines whether to clip shadows according to the clipping planes specified by this ClippingGroup. Default is
+     * `false`.
+     */
+    clipShadows: boolean;
+
+    constructor();
+}
+
+export { ClippingGroup };

three/src/renderers/WebGLRenderer.d.ts

@@ -444,6 +444,7 @@ export class WebGLRenderer implements Renderer {
      * @param dstTexture Specifies the destination texture.
      * @param srcRegion Specifies the bounds
      * @param dstPosition Specifies the pixel offset into the dstTexture where the copy will occur.
+     * @param srcLevel Specifies the source mipmap level of the texture.
      * @param dstLevel Specifies the destination mipmap level of the texture.
      */
     copyTextureToTexture(
@@ -451,6 +452,7 @@ export class WebGLRenderer implements Renderer {
         dstTexture: Texture,
         srcRegion?: Box2 | Box3 | null,
         dstPosition?: Vector2 | Vector3 | null,
+        srcLevel?: number,
         dstLevel?: number,
     ): void;
 

three/src/renderers/common/Animation.d.ts

@@ -1,13 +1,20 @@
 import Info from "./Info.js";
 import Nodes from "./nodes/Nodes.js";
+interface AnimationContext {
+    requestAnimationFrame(callback: FrameRequestCallback, frame?: XRFrame): number;
+    cancelAnimationFrame(handle: number): void;
+}
 declare class Animation {
     nodes: Nodes;
     info: Info;
-    animationLoop: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null;
-    requestId: number | null;
+    _context: AnimationContext;
+    _animationLoop: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null;
+    _requestId: number | null;
     constructor(nodes: Nodes, info: Info);
-    _init(): void;
-    dispose(): void;
+    start(): void;
+    stop(): void;
     setAnimationLoop(callback: ((time: DOMHighResTimeStamp, frame?: XRFrame) => void) | null): void;
+    setContext(context: AnimationContext): void;
+    dispose(): void;
 }
 export default Animation;

three/src/renderers/common/ClippingContext.d.ts

@@ -1,24 +1,26 @@
 import { Camera } from "../../cameras/Camera.js";
-import { Material } from "../../materials/Material.js";
 import { Matrix3 } from "../../math/Matrix3.js";
 import { Matrix4 } from "../../math/Matrix4.js";
 import { Plane } from "../../math/Plane.js";
 import { Vector4 } from "../../math/Vector4.js";
-import Renderer from "./Renderer.js";
+import { ClippingGroup } from "../../objects/ClippingGroup.js";
+import { Scene } from "../../scenes/Scene.js";
 declare class ClippingContext {
     version: number;
-    globalClippingCount: number;
-    localClippingCount: number;
-    localClippingEnabled: boolean | undefined;
-    localClipIntersection: boolean;
-    planes: Vector4[];
-    parentVersion: number;
+    clipIntersection: boolean | null;
+    cacheKey: string;
+    intersectionPlanes?: Plane[];
+    unionPlanes?: Plane[];
     viewNormalMatrix: Matrix3;
-    cacheKey: number;
-    viewMatrix?: Matrix4 | undefined;
-    constructor();
-    projectPlanes(source: readonly Plane[], offset: number): void;
-    updateGlobal(renderer: Renderer, camera: Camera): void;
-    update(parent: ClippingContext, material: Material): void;
+    clippingGroupContexts: WeakMap<ClippingGroup, ClippingContext>;
+    shadowPass: boolean;
+    viewMatrix?: Matrix4;
+    parentVersion: number | null;
+    constructor(parentContext?: ClippingContext | null);
+    projectPlanes(source: readonly Plane[], destination: readonly Vector4[], offset: number): void;
+    updateGlobal(scene: Scene, camera: Camera): void;
+    update(parentContext: ClippingContext, clippingGroup: ClippingGroup): void;
+    getGroupContext(clippingGroup: ClippingGroup): ClippingContext;
+    get unionClippingCount(): number;
 }
 export default ClippingContext;

three/src/renderers/common/RenderList.d.ts

@@ -5,6 +5,7 @@ import { Light } from "../../lights/Light.js";
 import { Material } from "../../materials/Material.js";
 import { LightsNode } from "../../nodes/Nodes.js";
 import BundleGroup from "./BundleGroup.js";
+import ClippingContext from "./ClippingContext.js";
 import Lighting from "./Lighting.js";
 export interface Bundle {
     bundleGroup: BundleGroup;
@@ -20,6 +21,7 @@ export interface RenderItem {
     renderOrder: number | null;
     z: number | null;
     group: GeometryGroup | null;
+    clippingContext: ClippingContext | null;
 }
 declare class RenderList {
     renderItems: RenderItem[];
@@ -42,6 +44,7 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
+        clippingContext: ClippingContext | null,
     ): RenderItem;
     push(
         object: Object3D,
@@ -50,6 +53,7 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
+        clippingContext: ClippingContext | null,
     ): void;
     unshift(
         object: Object3D,
@@ -58,6 +62,7 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
+        clippingContext: ClippingContext | null,
     ): void;
     pushBundle(group: Bundle): void;
     pushLight(light: Light): void;

three/src/renderers/common/RenderObject.d.ts

@@ -44,8 +44,8 @@ export default class RenderObject {
         firstInstance: number;
     } | null;
     bundle: BundleGroup | null;
-    clippingContext: ClippingContext;
-    clippingContextVersion: number;
+    clippingContext: ClippingContext | null;
+    clippingContextCacheKey: string;
     initialNodesCacheKey: string;
     initialCacheKey: string;
     _nodeBuilderState: NodeBuilderState | null;
@@ -64,9 +64,11 @@ export default class RenderObject {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
+        clippingContext: ClippingContext | null,
     );
     updateClipping(parent: ClippingContext): void;
     get clippingNeedsUpdate(): boolean;
+    get hardwareClippingPlanes(): number;
     getNodeBuilderState(): NodeBuilderState;
     getMonitor(): NodeMaterialObserver;
     getBindings(): BindGroup[];
@@ -78,8 +80,9 @@ export default class RenderObject {
         RenderContext,
         LightsNode,
     ];
-    getAttributes(): (InterleavedBufferAttribute | BufferAttribute)[];
-    getVertexBuffers(): (InterleavedBuffer | BufferAttribute)[] | null;
+    setGeometry(geometry: BufferGeometry): void;
+    getAttributes(): (BufferAttribute | InterleavedBufferAttribute)[];
+    getVertexBuffers(): (BufferAttribute | InterleavedBuffer)[] | null;
     getDrawParameters(): {
         vertexCount: number;
         firstVertex: number;
@@ -88,6 +91,7 @@ export default class RenderObject {
     } | null;
     getGeometryCacheKey(): string;
     getMaterialCacheKey(): number;
+    get needsGeometryUpdate(): boolean;
     get needsUpdate(): boolean;
     getDynamicCacheKey(): string;
     getCacheKey(): string;

three/src/renderers/common/RenderObjects.d.ts

@@ -5,6 +5,7 @@ import LightsNode from "../../nodes/lighting/LightsNode.js";
 import { Scene } from "../../scenes/Scene.js";
 import Bindings from "./Bindings.js";
 import ChainMap from "./ChainMap.js";
+import ClippingContext from "./ClippingContext.js";
 import Geometries from "./Geometries.js";
 import Info from "./Info.js";
 import Nodes from "./nodes/Nodes.js";
@@ -37,6 +38,7 @@ declare class RenderObjects {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
+        clippingContext: ClippingContext | null,
         passId?: string | undefined,
     ): RenderObject;
     getChainMap(
@@ -56,6 +58,7 @@ declare class RenderObjects {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
+        clippingContext: ClippingContext | null,
         passId: string | undefined,
     ): RenderObject;
 }

three/src/renderers/common/Renderer.d.ts

@@ -21,6 +21,7 @@ import Attributes from "./Attributes.js";
 import Backend from "./Backend.js";
 import Background from "./Background.js";
 import Bindings from "./Bindings.js";
+import ClippingContext from "./ClippingContext.js";
 import Color4 from "./Color4.js";
 import Geometries from "./Geometries.js";
 import Info from "./Info.js";
@@ -257,6 +258,9 @@ declare class Renderer {
     computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
     hasFeatureAsync(name: string): Promise<void>;
     hasFeature(name: string): false | void;
+    hasInitialized(): boolean;
+    initTextureAsync(texture: Texture): Promise<void>;
+    initTexture(texture: Texture): false | undefined;
     copyFramebufferToTexture(framebufferTexture: FramebufferTexture, rectangle?: Rectangle | null): void;
     copyTextureToTexture(
         srcTexture: Texture,
@@ -274,7 +278,13 @@ declare class Renderer {
         index?: number,
         faceIndex?: number,
     ): Promise<import("../../core/BufferAttribute.js").TypedArray>;
-    _projectObject(object: Object3D, camera: Camera, groupOrder: number, renderList: RenderList): void;
+    _projectObject(
+        object: Object3D,
+        camera: Camera,
+        groupOrder: number,
+        renderList: RenderList,
+        clippingContext: ClippingContext | null,
+    ): void;
     _renderBundles(bundles: Bundle[], sceneRef: Scene, lightsNode: LightsNode): void;
     _renderTransparents(
         renderList: RenderItem[],
@@ -298,6 +308,7 @@ declare class Renderer {
         material: Material,
         group: GeometryGroup,
         lightsNode: LightsNode,
+        clippingContext?: ClippingContext | null,
         passId?: string | null,
     ): void;
     _renderObjectDirect(
@@ -307,6 +318,7 @@ declare class Renderer {
         camera: Camera,
         lightsNode: LightsNode,
         group: GeometryGroup,
+        clippingContext: ClippingContext | null,
         passId?: string,
     ): void;
     _createObjectPipeline(
@@ -315,6 +327,7 @@ declare class Renderer {
         scene: Scene,
         camera: Camera,
         lightsNode: LightsNode,
+        clippingContext: ClippingContext | null,
         passId?: string,
     ): void;
     get compile(): (scene: Object3D, camera: Camera, targetScene?: Object3D | null) => Promise<void>;

three/src/renderers/common/UniformsGroup.d.ts

@@ -28,5 +28,6 @@ declare class UniformsGroup extends UniformBuffer {
     updateColor(uniform: ColorNodeUniform): boolean;
     updateMatrix3(uniform: Matrix3NodeUniform): boolean;
     updateMatrix4(uniform: Matrix4NodeUniform): boolean;
+    _getBufferForType(type: string | null): Int32Array | Uint32Array | Float32Array;
 }
 export default UniformsGroup;

three/src/renderers/common/extras/PMREMGenerator.d.ts

@@ -5,7 +5,21 @@ import Renderer from "../Renderer.js";
 declare class PMREMGenerator {
     constructor(renderer: Renderer);
 
-    fromScene(scene: Scene, sigma?: number, near?: number, far?: number): RenderTarget;
+    fromScene(
+        scene: Scene,
+        sigma?: number,
+        near?: number,
+        far?: number,
+        renderTarget?: RenderTarget | null,
+    ): RenderTarget;
+
+    fromSceneAsync(
+        scene: Scene,
+        sigma?: number,
+        near?: number,
+        far?: number,
+        renderTarget?: RenderTarget | null,
+    ): Promise<RenderTarget>;
 
     dispose(): void;
 }

three/src/renderers/common/nodes/NodeLibrary.d.ts

@@ -19,7 +19,7 @@ declare class NodeLibrary {
         (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>
     >;
     constructor();
-    fromMaterial(material: Material): Material | null;
+    fromMaterial(material: Material): Material | NodeMaterial | null;
     addToneMapping(
         toneMappingNode: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>,
         toneMapping: ToneMapping,
@@ -30,9 +30,7 @@ declare class NodeLibrary {
     getMaterialNodeClass(materialType: string): (new() => NodeMaterial) | null;
     addMaterial(materialNodeClass: {
         new(): NodeMaterial;
-    }, materialClass: {
-        new(): Material;
-    }): void;
+    }, materialClassType: string): void;
     getLightNodeClass(light: Light): (new(light: Light) => AnalyticLightNode<Light>) | null;
     addLight<TLight extends Light>(lightNodeClass: {
         new(light: TLight): AnalyticLightNode<TLight>;

three/src/renderers/common/nodes/NodeUniform.d.ts

@@ -18,36 +18,43 @@ declare class NumberNodeUniform extends NumberUniform {
     nodeUniform: NodeUniform<number>;
     constructor(nodeUniform: NodeUniform<number>);
     getValue(): number;
+    getType(): string | null;
 }
 declare class Vector2NodeUniform extends Vector2Uniform {
     nodeUniform: NodeUniform<Vector2>;
     constructor(nodeUniform: NodeUniform<Vector2>);
     getValue(): Vector2;
+    getType(): string | null;
 }
 declare class Vector3NodeUniform extends Vector3Uniform {
     nodeUniform: NodeUniform<Vector3>;
     constructor(nodeUniform: NodeUniform<Vector3>);
     getValue(): Vector3;
+    getType(): string | null;
 }
 declare class Vector4NodeUniform extends Vector4Uniform {
     nodeUniform: NodeUniform<Vector4>;
     constructor(nodeUniform: NodeUniform<Vector4>);
     getValue(): Vector4;
+    getType(): string | null;
 }
 declare class ColorNodeUniform extends ColorUniform {
     nodeUniform: NodeUniform<Color>;
     constructor(nodeUniform: NodeUniform<Color>);
     getValue(): Color;
+    getType(): string | null;
 }
 declare class Matrix3NodeUniform extends Matrix3Uniform {
     nodeUniform: NodeUniform<Matrix3>;
     constructor(nodeUniform: NodeUniform<Matrix3>);
     getValue(): Matrix3;
+    getType(): string | null;
 }
 declare class Matrix4NodeUniform extends Matrix4Uniform {
     nodeUniform: NodeUniform<Matrix4>;
     constructor(nodeUniform: NodeUniform<Matrix4>);
     getValue(): Matrix4;
+    getType(): string | null;
 }
 export {
     ColorNodeUniform,

three/src/renderers/webgl/WebGLState.d.ts

@@ -67,7 +67,7 @@ declare class WebGLState {
         blendDstAlpha?: BlendingDstFactor,
         premultiplyAlpha?: boolean,
     ): void;
-    setMaterial(material: Material, frontFaceCW: boolean): void;
+    setMaterial(material: Material, frontFaceCW: boolean, hardwareClippingPlanes: number): void;
     setFlipSided(flipSided: boolean): void;
     setCullFace(cullFace: CullFace): void;
     setLineWidth(width: number): void;

three/src/textures/Data3DTexture.d.ts

@@ -1,6 +1,6 @@
 import { MagnificationTextureFilter, MinificationTextureFilter, Wrapping } from "../constants.js";
+import { TextureImageData } from "./DataTexture.js";
 import { Texture } from "./Texture.js";
-import { Texture3DImageData } from "./types.js";
 
 /**
  * Creates a three-dimensional texture from raw data, with parameters to divide it into width, height, and depth
@@ -93,4 +93,6 @@ export class Data3DTexture extends Texture {
     unpackAlignment: number;
 }
 
-export {};
+export interface Texture3DImageData extends TextureImageData {
+    depth: number;
+}

three/src/textures/DataArrayTexture.d.ts

@@ -1,6 +1,6 @@
 import { MagnificationTextureFilter, MinificationTextureFilter } from "../constants.js";
+import { Texture3DImageData } from "./Data3DTexture.js";
 import { Texture } from "./Texture.js";
-import { Texture3DImageData } from "./types.js";
 
 /**
  * Creates an array of textures directly from raw data, width and height and depth

three/src/textures/DataTexture.d.ts

@@ -7,7 +7,6 @@ import {
     Wrapping,
 } from "../constants.js";
 import { Texture } from "./Texture.js";
-import { TextureImageData } from "./types.js";
 
 /**
  * Creates a texture directly from raw data, width and height.
@@ -110,3 +109,9 @@ export class DataTexture extends Texture {
      */
     unpackAlignment: number;
 }
+
+export interface TextureImageData {
+    data: Uint8Array | Uint8ClampedArray;
+    height: number;
+    width: number;
+}

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

@@ -1,10 +0,0 @@
-import Node from "../core/Node.js";
-import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export const burn: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
-
-export const dodge: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
-
-export const screen: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;
-
-export const overlay: (base: NodeRepresentation, blend: NodeRepresentation) => ShaderNodeObject<Node>;

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

@@ -1,18 +0,0 @@
-import { Light } from "../../lights/Light.js";
-import Node from "../core/Node.js";
-import { ShaderNodeObject } from "../tsl/TSLCore.js";
-
-export type LightNodeScope = typeof LightNode.TARGET_DIRECTION;
-
-declare class LightNode extends Node {
-    scope: LightNodeScope;
-    light: Light;
-
-    constructor(scope?: LightNodeScope, light?: Light | null);
-
-    static TARGET_DIRECTION: "targetDirection";
-}
-
-export default LightNode;
-
-export const lightTargetDirection: (light?: Light | null) => ShaderNodeObject<LightNode>;

three/src/textures/types.d.ts

@@ -1,9 +0,0 @@
-export interface TextureImageData {
-    data: Uint8Array | Uint8ClampedArray;
-    height: number;
-    width: number;
-}
-
-export interface Texture3DImageData extends TextureImageData {
-    depth: number;
-}