@types/three 0.168.0 → 0.169.0

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

@@ -5,6 +5,7 @@ import NodeBuilder from "./NodeBuilder.js";
 import NodeFrame from "./NodeFrame.js";
 import UniformGroupNode from "./UniformGroupNode.js";
 declare class UniformNode<TValue> extends InputNode<TValue> {
+    static get type(): string;
     readonly isUniformNode: true;
     name: string;
     groupNode: UniformGroupNode;

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

@@ -1,6 +1,6 @@
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const sRGBToLinear: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const sRGBToLinearSRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const LinearTosRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;
+export const linearSRGBTosRGB: (color: NodeRepresentation) => ShaderNodeObject<Node>;

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

@@ -1,35 +1,54 @@
 import { ColorSpace, LinearSRGBColorSpace, SRGBColorSpace } from "../../constants.js";
 import Node from "../core/Node.js";
+import NodeBuilder from "../core/NodeBuilder.js";
 import TempNode from "../core/TempNode.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
+export type WorkingOrOutputColorSpace = "WorkingColorSpace" | "OutputColorSpace";
+
 export type ColorSpaceMethod = "LinearTosRGB" | "sRGBToLinear" | "LinearToLinear" | "sRGBTosRGB";
 
-export const getColorSpaceMethod: (
+export function getColorSpaceMethod(
     source: typeof LinearSRGBColorSpace | typeof SRGBColorSpace,
     target: typeof LinearSRGBColorSpace | typeof SRGBColorSpace,
-) => ColorSpaceMethod;
+): ColorSpaceMethod;
 
 export default class ColorSpaceNode extends TempNode {
     colorNode: Node;
-    target: ColorSpace | null;
-    source: ColorSpace | null;
+    source: WorkingOrOutputColorSpace | ColorSpace;
+    target: WorkingOrOutputColorSpace | ColorSpace;
+
+    constructor(
+        colorNode: Node,
+        source: WorkingOrOutputColorSpace | ColorSpace,
+        target: WorkingOrOutputColorSpace | ColorSpace,
+    );
 
-    constructor(colorNode: Node, target?: ColorSpace | null, source?: ColorSpace | null);
+    getColorSpace(nodeBuilder: NodeBuilder, colorSpace: WorkingOrOutputColorSpace): ColorSpace;
 }
 
 export const toOutputColorSpace: (
     node: NodeRepresentation,
-    colorSpace?: ColorSpace | null,
 ) => ShaderNodeObject<ColorSpaceNode>;
 export const toWorkingColorSpace: (
     node: NodeRepresentation,
-    colorSpace?: ColorSpace | null,
+) => ShaderNodeObject<ColorSpaceNode>;
+
+export const workingToColorSpace: (
+    node: NodeRepresentation,
+    colorSpace: ColorSpace,
+) => ShaderNodeObject<ColorSpaceNode>;
+export const colorSpaceToWorking: (
+    node: NodeRepresentation,
+    colorSpace: ColorSpace,
 ) => ShaderNodeObject<ColorSpaceNode>;
 
 declare module "../tsl/TSLCore.js" {
     interface NodeElements {
         toOutputColorSpace: typeof toOutputColorSpace;
         toWorkingColorSpace: typeof toWorkingColorSpace;
+
+        workingToColorSpace: typeof workingToColorSpace;
+        colorSpaceToWorking: typeof colorSpaceToWorking;
     }
 }

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

@@ -0,0 +1,48 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export type ScreenNodeScope =
+    | typeof ScreenNode.COORDINATE
+    | typeof ScreenNode.VIEWPORT
+    | typeof ScreenNode.SIZE
+    | typeof ScreenNode.UV;
+
+declare class ScreenNode extends Node {
+    scope: ScreenNodeScope;
+
+    readonly isViewportNode: true;
+
+    constructor(scope: ScreenNodeScope);
+
+    static COORDINATE: "coordinate";
+    static VIEWPORT: "viewport";
+    static SIZE: "size";
+    static UV: "uv";
+}
+
+export default ScreenNode;
+
+// Screen
+
+export const screenUV: ShaderNodeObject<ScreenNode>;
+export const screenSize: ShaderNodeObject<ScreenNode>;
+export const screenCoordinate: ShaderNodeObject<ScreenNode>;
+
+// Viewport
+
+export const viewport: ShaderNodeObject<ScreenNode>;
+export const viewportSize: ShaderNodeObject<Node>;
+export const viewportCoordinate: ShaderNodeObject<Node>;
+export const viewportUV: ShaderNodeObject<Node>;
+
+// Deprecated
+
+/**
+ * @deprecated "viewportTopLeft" is deprecated. Use "viewportUV" instead.
+ */
+export const viewportTopLeft: ShaderNodeObject<ScreenNode>;
+
+/**
+ * @deprecated "viewportBottomLeft" is deprecated. Use "viewportUV.flipY()" instead.
+ */
+export const viewportBottomLeft: ShaderNodeObject<ScreenNode>;

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

@@ -1,14 +1,14 @@
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const LinearToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const linearToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const ReinhardToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const reinhardToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const CineonToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const cineonToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const ACESFilmicToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const acesFilmicToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const AgXToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const agxToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
 
-export const NeutralToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;
+export const neutralToneMapping: (color: NodeRepresentation, exposure: NodeRepresentation) => ShaderNodeObject<Node>;

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

@@ -0,0 +1,24 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Color } from "../../math/Color.js";
+import { Scene } from "../../scenes/Scene.js";
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+import PassNode from "./PassNode.js";
+
+declare class ToonOutlinePassNode extends PassNode {
+    colorNode: Node;
+    thicknessNode: Node;
+    alphaNode: Node;
+
+    constructor(scene: Scene, camera: Camera, colorNode: Node, thicknessNode: Node, alphaNode: Node);
+}
+
+export default ToonOutlinePassNode;
+
+export const toonOutlinePass: (
+    scene: Scene,
+    camera: Camera,
+    color?: Color,
+    thickness?: number,
+    alpha?: number,
+) => ShaderNodeObject<ToonOutlinePassNode>;

three/src/nodes/functions/material/getShIrradianceAt.d.ts

@@ -0,0 +1,6 @@
+import Node from "../../core/Node.js";
+import { ShaderNodeObject } from "../../tsl/TSLCore.js";
+
+declare const getShIrradianceAt: (normal: Node, shCoefficients: Node) => ShaderNodeObject<Node>;
+
+export default getShIrradianceAt;

three/src/objects/BatchedMesh.d.ts

@@ -141,6 +141,25 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     getVisibleAt(instanceId: number): boolean;
 
+    /**
+     * Get the range representing the subset of triangles related to the attached geometry, indicating the starting
+     * offset and count, or `null` if invalid.
+     *
+     * Return an object of the form: { start: Integer, count: Integer }
+     * @param geometryId The id of the geometry to get the range of.
+     * @param target Optional target object to copy the range in to.
+     */
+    getGeometryRangeAt(
+        geometryId: number,
+        target?: { start: number; count: number },
+    ): { start: number; count: number } | null;
+
+    /**
+     * Get the geometryIndex of the defined instance.
+     * @param instanceId The id of an instance to get the geometryIndex of.
+     */
+    getGeometryIdAt(instanceId: number): number;
+
     /**
      * Sets the given color to the defined geometry instance.
      * @param instanceId The id of the instance to set the color of.
@@ -162,6 +181,13 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     setVisibleAt(instanceId: number, visible: boolean): this;
 
+    /**
+     * Sets the geometryIndex of the instance at the given index.
+     * @param instanceId The id of the instance to set the geometryIndex of.
+     * @param geometryId The geometryIndex to be use by the instance.
+     */
+    setGeometryIdAt(instanceId: number, geometryId: number): this;
+
     /**
      * Adds the given geometry to the {@link BatchedMesh} and returns the associated index referring to it.
      * @param geometry The geometry to add into the {@link BatchedMesh}.
@@ -182,6 +208,13 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     addInstance(geometryId: number): number;
 
+    /**
+     * Removes an existing instance from the BatchedMesh using the given instanceId.
+     * @param instanceId The id of an instance to remove from the BatchedMesh that was previously added via
+     * "addInstance".
+     */
+    deleteInstance(instanceId: number): this;
+
     /**
      * Replaces the geometry at `geometryId` with the provided geometry. Throws an error if there is not enough space
      * reserved for geometry. Calling this will change all instances that are rendering that geometry.

three/src/objects/Group.d.ts

@@ -34,10 +34,4 @@ export class Group<TEventMap extends Object3DEventMap = Object3DEventMap> extend
      * @defaultValue `true`
      */
     readonly isGroup: true;
-
-    /**
-     * @override
-     * @defaultValue `Group`
-     */
-    override readonly type: string | "Group";
 }

three/src/objects/LOD.d.ts

@@ -81,6 +81,13 @@ export class LOD<TEventMap extends Object3DEventMap = Object3DEventMap> extends
      */
     addLevel(object: Object3D, distance?: number, hysteresis?: number): this;
 
+    /**
+     * Removes an existing level, based on the distance from the camera. Returns `true` when the level has been removed.
+     * Otherwise `false`.
+     * @param distance Distance of the level to delete.
+     */
+    removeLabel(distance: number): boolean;
+
     /**
      * Get the currently active {@link LOD} level
      * @remarks

three/src/renderers/WebGLRenderer.d.ts

@@ -15,7 +15,7 @@ import { Scene } from "../scenes/Scene.js";
 import { Data3DTexture } from "../textures/Data3DTexture.js";
 import { DataArrayTexture } from "../textures/DataArrayTexture.js";
 import { OffscreenCanvas, Texture } from "../textures/Texture.js";
-import { WebGLCapabilities } from "./webgl/WebGLCapabilities.js";
+import { WebGLCapabilities, WebGLCapabilitiesParameters } from "./webgl/WebGLCapabilities.js";
 import { WebGLExtensions } from "./webgl/WebGLExtensions.js";
 import { WebGLInfo } from "./webgl/WebGLInfo.js";
 import { WebGLProgram } from "./webgl/WebGLProgram.js";
@@ -33,7 +33,7 @@ export interface Renderer {
     setSize(width: number, height: number, updateStyle?: boolean): void;
 }
 
-export interface WebGLRendererParameters {
+export interface WebGLRendererParameters extends WebGLCapabilitiesParameters {
     /**
      * A Canvas where the renderer draws its output.
      */
@@ -46,11 +46,6 @@ export interface WebGLRendererParameters {
      */
     context?: WebGLRenderingContext | undefined;
 
-    /**
-     * shader precision. Can be "highp", "mediump" or "lowp".
-     */
-    precision?: string | undefined;
-
     /**
      * default is false.
      */
@@ -86,11 +81,6 @@ export interface WebGLRendererParameters {
      */
     depth?: boolean | undefined;
 
-    /**
-     * default is false.
-     */
-    logarithmicDepthBuffer?: boolean | undefined;
-
     /**
      * default is false.
      */

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

@@ -0,0 +1,10 @@
+import { Group } from "../../objects/Group.js";
+declare class BundleGroup extends Group {
+    readonly isBundleGroup: true;
+    readonly type: string;
+    static: boolean;
+    version: number;
+    constructor();
+    set needsUpdate(value: boolean);
+}
+export default BundleGroup;

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

@@ -14,7 +14,7 @@ declare class ClippingContext {
     planes: Vector4[];
     parentVersion: number;
     viewNormalMatrix: Matrix3;
-    cacheKey: string;
+    cacheKey: number;
     viewMatrix?: Matrix4 | undefined;
     constructor();
     projectPlanes(source: readonly Plane[], offset: number): void;

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

@@ -1,11 +1,11 @@
 import { Camera } from "../../cameras/Camera.js";
-import { Object3D } from "../../core/Object3D.js";
+import BundleGroup from "./BundleGroup.js";
 import ChainMap from "./ChainMap.js";
 import RenderBundle from "./RenderBundle.js";
 declare class RenderBundles {
-    lists: ChainMap<readonly [Object3D, Camera], RenderBundle>;
+    lists: ChainMap<readonly [BundleGroup, Camera], RenderBundle>;
     constructor();
-    get(scene: Object3D, camera: Camera): RenderBundle;
+    get(scene: BundleGroup, camera: Camera): RenderBundle;
     dispose(): void;
 }
 export default RenderBundles;

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

@@ -37,7 +37,7 @@ declare class RenderContext {
     activeMipmapLevel?: number | undefined;
     occlusionQueryCount?: number | undefined;
     constructor();
-    getCacheKey(): string;
+    getCacheKey(): number;
 }
-export declare function getCacheKey(renderContext: RenderContext): string;
+export declare function getCacheKey(renderContext: RenderContext): number;
 export default RenderContext;

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

@@ -4,8 +4,9 @@ import { Object3D } from "../../core/Object3D.js";
 import { Light } from "../../lights/Light.js";
 import { Material } from "../../materials/Material.js";
 import { LightsNode } from "../../nodes/Nodes.js";
+import BundleGroup from "./BundleGroup.js";
 export interface Bundle {
-    object: Object3D;
+    bundleGroup: BundleGroup;
     camera: Camera;
     renderList: RenderList;
 }

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

@@ -5,9 +5,11 @@ import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
 import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
 import { Object3D } from "../../core/Object3D.js";
 import { Material } from "../../materials/Material.js";
+import NodeMaterialObserver from "../../materials/nodes/manager/NodeMaterialObserver.js";
 import { LightsNode } from "../../nodes/Nodes.js";
 import { Scene } from "../../scenes/Scene.js";
 import BindGroup from "./BindGroup.js";
+import BundleGroup from "./BundleGroup.js";
 import ClippingContext from "./ClippingContext.js";
 import Geometries from "./Geometries.js";
 import NodeBuilderState from "./nodes/NodeBuilderState.js";
@@ -35,12 +37,20 @@ export default class RenderObject {
     attributes: Array<BufferAttribute | InterleavedBufferAttribute> | null;
     pipeline: RenderPipeline | null;
     vertexBuffers: Array<BufferAttribute | InterleavedBuffer> | null;
+    drawParams: {
+        vertexCount: number;
+        firstVertex: number;
+        instanceCount: number;
+        firstInstance: number;
+    } | null;
+    bundle: BundleGroup | null;
     clippingContext: ClippingContext;
     clippingContextVersion: number;
     initialNodesCacheKey: string;
     initialCacheKey: string;
     _nodeBuilderState: NodeBuilderState | null;
     _bindings: BindGroup[] | null;
+    _monitor: NodeMaterialObserver | null;
     onDispose: (() => void) | null;
     readonly isRenderObject: true;
     onMaterialDispose: () => void;
@@ -58,6 +68,7 @@ export default class RenderObject {
     updateClipping(parent: ClippingContext): void;
     get clippingNeedsUpdate(): boolean;
     getNodeBuilderState(): NodeBuilderState;
+    getMonitor(): NodeMaterialObserver;
     getBindings(): BindGroup[];
     getIndex(): BufferAttribute | null;
     getChainArray(): readonly [
@@ -68,7 +79,14 @@ export default class RenderObject {
     ];
     getAttributes(): (InterleavedBufferAttribute | BufferAttribute)[];
     getVertexBuffers(): (InterleavedBuffer | BufferAttribute)[] | null;
-    getMaterialCacheKey(): string;
+    getDrawParameters(): {
+        vertexCount: number;
+        firstVertex: number;
+        instanceCount: number;
+        firstInstance: number;
+    } | null;
+    getGeometryCacheKey(): string;
+    getMaterialCacheKey(): number;
     get needsUpdate(): boolean;
     getDynamicCacheKey(): string;
     getCacheKey(): string;

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

@@ -36,6 +36,12 @@ import RenderList, { Bundle, RenderItem } from "./RenderList.js";
 import RenderLists from "./RenderLists.js";
 import RenderObjects from "./RenderObjects.js";
 import Textures from "./Textures.js";
+interface Rectangle {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
 export interface RendererParameters {
     logarithmicDepthBuffer?: boolean | undefined;
     alpha?: boolean | undefined;
@@ -238,7 +244,7 @@ declare class Renderer {
     computeAsync(computeNodes: ComputeNode | ComputeNode[]): Promise<void>;
     hasFeatureAsync(name: string): Promise<void>;
     hasFeature(name: string): false | void;
-    copyFramebufferToTexture(framebufferTexture: FramebufferTexture): void;
+    copyFramebufferToTexture(framebufferTexture: FramebufferTexture, rectangle?: Rectangle | null): void;
     copyTextureToTexture(
         srcTexture: Texture,
         dstTexture: Texture,
@@ -253,6 +259,7 @@ declare class Renderer {
         width: number,
         height: number,
         index?: number,
+        faceIndex?: number,
     ): Promise<import("../../core/BufferAttribute.js").TypedArray>;
     _projectObject(object: Object3D, camera: Camera, groupOrder: number, renderList: RenderList): void;
     _renderBundles(bundles: Bundle[], sceneRef: Scene, lightsNode: LightsNode): void;

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

@@ -1,3 +1,4 @@
+import NodeMaterialObserver from "../../../materials/nodes/manager/NodeMaterialObserver.js";
 import Node from "../../../nodes/core/Node.js";
 import NodeAttribute from "../../../nodes/core/NodeAttribute.js";
 import BindGroup from "../BindGroup.js";
@@ -11,7 +12,7 @@ declare class NodeBuilderState {
     updateNodes: Node[];
     updateBeforeNodes: Node[];
     updateAfterNodes: Node[];
-    instanceBindGroups: boolean;
+    monitor: NodeMaterialObserver;
     usedTimes: number;
     constructor(
         vertexShader: string | null,
@@ -22,7 +23,7 @@ declare class NodeBuilderState {
         updateNodes: Node[],
         updateBeforeNodes: Node[],
         updateAfterNodes: Node[],
-        instanceBindGroups?: boolean,
+        monitor: NodeMaterialObserver,
         transforms?: never[],
     );
     createBindings(): BindGroup[];

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

@@ -39,6 +39,13 @@ interface SceneData {
     environment?: Texture | undefined;
     environmentNode?: Node | undefined;
 }
+declare module "../../../scenes/Scene.js" {
+    interface Scene {
+        environmentNode?: Node | null | undefined;
+        backgroundNode?: Node | null | undefined;
+        fogNode?: Node | null | undefined;
+    }
+}
 declare class Nodes extends DataMap<{
     nodeUniformsGroup: {
         key: NodeUniformsGroup;
@@ -101,6 +108,7 @@ declare class Nodes extends DataMap<{
     updateAfter(renderObject: RenderObject): void;
     updateForCompute(computeNode: ComputeNode): void;
     updateForRender(renderObject: RenderObject): void;
+    needsRefresh(renderObject: RenderObject): boolean;
     dispose(): void;
 }
 export default Nodes;

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

@@ -1,8 +1,20 @@
 import { PixelFormat, TextureDataType } from "../../constants.js";
 
 export interface WebGLCapabilitiesParameters {
+    /**
+     * shader precision. Can be "highp", "mediump" or "lowp".
+     */
     precision?: string | undefined;
+
+    /**
+     * default is false.
+     */
     logarithmicDepthBuffer?: boolean | undefined;
+
+    /**
+     * default is false.
+     */
+    reverseDepthBuffer?: boolean | undefined;
 }
 
 export class WebGLCapabilities {
@@ -18,6 +30,7 @@ export class WebGLCapabilities {
 
     precision: string;
     logarithmicDepthBuffer: boolean;
+    reverseDepthBuffer: boolean;
 
     maxTextures: number;
     maxVertexTextures: number;

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

@@ -155,6 +155,7 @@ export interface WebGLProgramParameters {
 
     sizeAttenuation: boolean;
     logarithmicDepthBuffer: boolean;
+    reverseDepthBuffer: boolean;
 
     skinning: boolean;
 

three/src/renderers/webgpu/WebGPURenderer.Nodes.d.ts

@@ -0,0 +1,12 @@
+import Renderer, { RendererParameters } from "../common/Renderer.js";
+import { WebGPUBackendParameters } from "./WebGPUBackend.js";
+
+export interface WebGPURendererParameters extends RendererParameters, WebGPUBackendParameters {
+    forceWebGL?: boolean | undefined;
+}
+
+export default class WebGPURenderer extends Renderer {
+    readonly isWebGPURenderer: true;
+
+    constructor(parameters?: WebGPURendererParameters);
+}

three/src/renderers/webgpu/WebGPURenderer.d.ts

@@ -1,10 +1,14 @@
-import StandardRenderer, { StandardRendererParameters } from "../common/StandardRenderer.js";
+import Renderer, { RendererParameters } from "../common/Renderer.js";
 import { WebGPUBackendParameters } from "./WebGPUBackend.js";
 
-export interface WebGPURendererParameters extends StandardRendererParameters, WebGPUBackendParameters {
+export interface WebGPURendererParameters extends RendererParameters, WebGPUBackendParameters {
     forceWebGL?: boolean | undefined;
 }
 
-export default class WebGPURenderer extends StandardRenderer {
+declare class WebGPURenderer extends Renderer {
+    readonly isWebGPURenderer: true;
+
     constructor(parameters?: WebGPURendererParameters);
 }
+
+export default WebGPURenderer;

three/src/renderers/webgpu/nodes/BasicNodeLibrary.d.ts

@@ -0,0 +1,5 @@
+import NodeLibrary from "../../common/nodes/NodeLibrary.js";
+declare class BasicNodeLibrary extends NodeLibrary {
+    constructor();
+}
+export default BasicNodeLibrary;

three/src/renderers/webgpu/nodes/StandardNodeLibrary.d.ts

@@ -0,0 +1,5 @@
+import NodeLibrary from "../../common/nodes/NodeLibrary.js";
+declare class StandardNodeLibrary extends NodeLibrary {
+    constructor();
+}
+export default StandardNodeLibrary;

three/examples/jsm/geometries/SDFGeometryGenerator.d.ts

@@ -1,16 +0,0 @@
-import { BufferGeometry, WebGLRenderer, WebGLRenderTarget } from "three";
-
-export class SDFGeometryGenerator {
-    constructor(renderer: WebGLRenderer);
-
-    generate(res?: number, distFunc?: string, bounds?: number): BufferGeometry;
-
-    computeSDF(
-        width: number,
-        height: number,
-        tilesX: number,
-        tilesY: number,
-        bounds: number,
-        shader: string,
-    ): WebGLRenderTarget;
-}

three/examples/jsm/loaders/TiltLoader.d.ts

@@ -1,7 +0,0 @@
-import { Group, Loader, LoadingManager } from "three";
-
-export class TiltLoader extends Loader<Group> {
-    constructor(manager?: LoadingManager);
-
-    parse(data: ArrayBuffer): Group;
-}

three/examples/jsm/utils/GPUStatsPanel.d.ts

@@ -1,12 +0,0 @@
-import Stats from "../libs/stats.module.js";
-
-export class GPUStatsPanel extends Stats.Panel {
-    context: WebGLRenderingContext | WebGL2RenderingContext;
-    extension: unknown;
-    maxTime: number;
-    activeQueries: number;
-    startQuery: () => void;
-    endQuery: () => void;
-
-    constructor(context: WebGLRenderingContext | WebGL2RenderingContext, name?: string);
-}

three/examples/jsm/utils/PackedPhongMaterial.d.ts

@@ -1,10 +0,0 @@
-/**
- * `PackedPhongMaterial` inherited from THREE.MeshPhongMaterial
- *
- * @param {Object} parameters
- */
-import { MeshPhongMaterial, MeshPhongMaterialParameters } from "three";
-
-export class PackedPhongMaterial extends MeshPhongMaterial {
-    constructor(parameters: MeshPhongMaterialParameters);
-}