@types/three 0.182.0 → 0.183.1

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

@@ -1,4 +1,5 @@
 import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
+
 /**
  * A special type of render target that is used when rendering
  * with the WebXR Device API.
@@ -6,11 +7,7 @@ import { RenderTarget, RenderTargetOptions } from "../../core/RenderTarget.js";
  * @private
  * @augments RenderTarget
  */
-declare class XRRenderTarget extends RenderTarget {
-    readonly isXRRenderTarget: true;
-    _hasExternalTextures: boolean;
-    _autoAllocateDepthBuffer: boolean;
-    _isOpaqueFramebuffer: boolean;
+export class XRRenderTarget extends RenderTarget {
     /**
      * Constructs a new XR render target.
      *
@@ -19,6 +16,52 @@ declare class XRRenderTarget extends RenderTarget {
      * @param {Object} [options={}] - The configuration options.
      */
     constructor(width?: number, height?: number, options?: RenderTargetOptions);
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
+     */
+    readonly isXRRenderTarget: boolean;
+    /**
+     * Whether the attachments of the render target
+     * are defined by external textures. This flag is
+     * set to `true` when using the WebXR Layers API.
+     *
+     * @private
+     * @type {boolean}
+     * @default false
+     */
+    private _hasExternalTextures;
+    /**
+     * Whether a depth buffer should automatically be allocated
+     * for this XR render target or not.
+     *
+     * Allocating a depth buffer is the default behavior of XR render
+     * targets. However, when using the WebXR Layers API, this flag
+     * must be set to `false` when the `ignoreDepthValues` property of
+     * the projection layers evaluates to `false`.
+     *
+     * Reference: {@link https://www.w3.org/TR/webxrlayers-1/#dom-xrprojectionlayer-ignoredepthvalues}.
+     *
+     * @private
+     * @type {boolean}
+     * @default true
+     */
+    private _autoAllocateDepthBuffer;
+    /**
+     * Whether this render target is associated with a XRWebGLLayer.
+     *
+     * A XRWebGLLayer points to an opaque framebuffer. Basically,
+     * this means that you don't have access to its bound color,
+     * stencil and depth buffers. We need to handle this framebuffer
+     * differently since its textures are always bound.
+     *
+     * @private
+     * @type {boolean}
+     * @default false
+     */
+    private _isOpaqueFramebuffer;
     copy(source: XRRenderTarget): this;
 }
-export { XRRenderTarget };

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

@@ -2,6 +2,7 @@ import NodeMaterialObserver from "../../../materials/nodes/manager/NodeMaterialO
 import Node from "../../../nodes/core/Node.js";
 import NodeAttribute from "../../../nodes/core/NodeAttribute.js";
 import BindGroup from "../BindGroup.js";
+
 /**
  * This module represents the state of a node builder after it was
  * used to build the nodes for a render object. The state holds the
@@ -12,17 +13,6 @@ import BindGroup from "../BindGroup.js";
  * @private
  */
 declare class NodeBuilderState {
-    vertexShader: string | null;
-    fragmentShader: string | null;
-    computeShader: string | null;
-    transforms: never[];
-    nodeAttributes: NodeAttribute[];
-    bindings: BindGroup[];
-    updateNodes: Node[];
-    updateBeforeNodes: Node[];
-    updateAfterNodes: Node[];
-    observer: NodeMaterialObserver;
-    usedTimes: number;
     /**
      * Constructs a new node builder state.
      *
@@ -38,17 +28,86 @@ declare class NodeBuilderState {
      * @param {Array<Object>} transforms - An array with transform attribute objects. Only relevant when using compute shaders with WebGL 2.
      */
     constructor(
-        vertexShader: string | null,
-        fragmentShader: string | null,
-        computeShader: string | null,
+        vertexShader: string,
+        fragmentShader: string,
+        computeShader: string,
         nodeAttributes: NodeAttribute[],
         bindings: BindGroup[],
         updateNodes: Node[],
         updateBeforeNodes: Node[],
         updateAfterNodes: Node[],
         observer: NodeMaterialObserver,
-        transforms?: never[],
+        transforms?: unknown[],
     );
+    /**
+     * The native vertex shader code.
+     *
+     * @type {string}
+     */
+    vertexShader: string;
+    /**
+     * The native fragment shader code.
+     *
+     * @type {string}
+     */
+    fragmentShader: string;
+    /**
+     * The native compute shader code.
+     *
+     * @type {string}
+     */
+    computeShader: string;
+    /**
+     * An array with transform attribute objects.
+     * Only relevant when using compute shaders with WebGL 2.
+     *
+     * @type {Array<Object>}
+     */
+    transforms: unknown[];
+    /**
+     * An array of node attributes representing
+     * the attributes of the shaders.
+     *
+     * @type {Array<NodeAttribute>}
+     */
+    nodeAttributes: NodeAttribute[];
+    /**
+     * An array of bind groups representing the uniform or storage
+     * buffers, texture or samplers of the shader.
+     *
+     * @type {Array<BindGroup>}
+     */
+    bindings: BindGroup[];
+    /**
+     * An array of nodes that implement their `update()` method.
+     *
+     * @type {Array<Node>}
+     */
+    updateNodes: Node[];
+    /**
+     * An array of nodes that implement their `updateBefore()` method.
+     *
+     * @type {Array<Node>}
+     */
+    updateBeforeNodes: Node[];
+    /**
+     * An array of nodes that implement their `updateAfter()` method.
+     *
+     * @type {Array<Node>}
+     */
+    updateAfterNodes: Node[];
+    /**
+     * A node material observer.
+     *
+     * @type {NodeMaterialObserver}
+     */
+    observer: NodeMaterialObserver;
+    /**
+     * How often this state is used by render objects.
+     *
+     * @type {number}
+     */
+    usedTimes: number;
     /**
      * This method is used to create a array of bind groups based
      * on the existing bind groups of this state. Shared groups are
@@ -58,4 +117,5 @@ declare class NodeBuilderState {
      */
     createBindings(): BindGroup[];
 }
+
 export default NodeBuilderState;

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

@@ -4,6 +4,7 @@ import { Material } from "../../../materials/Material.js";
 import NodeMaterial from "../../../materials/nodes/NodeMaterial.js";
 import Node from "../../../nodes/core/Node.js";
 import AnalyticLightNode from "../../../nodes/lighting/AnalyticLightNode.js";
+
 /**
  * The purpose of a node library is to assign node implementations
  * to existing library features. In `WebGPURenderer` lights, materials
@@ -13,19 +14,31 @@ import AnalyticLightNode from "../../../nodes/lighting/AnalyticLightNode.js";
  * @private
  */
 declare class NodeLibrary {
+    /**
+     * A weak map that maps lights to light nodes.
+     *
+     * @type {WeakMap<Light.constructor,AnalyticLightNode.constructor>}
+     */
     lightNodes: WeakMap<{
         new(): Light;
     }, {
         new(light: Light): AnalyticLightNode<Light>;
     }>;
+    /**
+     * A map that maps materials to node materials.
+     *
+     * @type {Map<string,NodeMaterial.constructor>}
+     */
     materialNodes: Map<string, {
         new(): NodeMaterial;
     }>;
-    toneMappingNodes: Map<ToneMapping, (color: Node, exposure: Node) => Node>;
     /**
-     * Constructs a new node library.
+     * A map that maps tone mapping techniques (constants)
+     * to tone mapping node functions.
+     *
+     * @type {Map<number,Function>}
      */
-    constructor();
+    toneMappingNodes: Map<ToneMapping, (color: Node, exposure: Node) => Node>;
     /**
      * Returns a matching node material instance for the given material object.
      *
@@ -36,7 +49,7 @@ declare class NodeLibrary {
      * @param {Material} material - A material.
      * @return {NodeMaterial} The corresponding node material.
      */
-    fromMaterial(material: Material): Material | NodeMaterial | null;
+    fromMaterial(material: Material): NodeMaterial;
     /**
      * Adds a tone mapping node function for a tone mapping technique (constant).
      *
@@ -73,7 +86,13 @@ declare class NodeLibrary {
      * @param {Light.constructor} light - The light class definition.
      * @return {?AnalyticLightNode.constructor} The light node class definition. Returns `null` if no light node is found.
      */
-    getLightNodeClass(light: Light): (new(light: Light) => AnalyticLightNode<Light>) | null;
+    getLightNodeClass(light: {
+        new(): Light;
+    }):
+        | ({
+            new(light: Light): AnalyticLightNode<Light>;
+        })
+        | null;
     /**
      * Adds a light node class definition for a given light class definition.
      *
@@ -106,4 +125,5 @@ declare class NodeLibrary {
         library: WeakMap<TBaseClass, TNodeClass>,
     ): void;
 }
+
 export default NodeLibrary;

three/src/renderers/common/nodes/{Nodes.d.ts → NodeManager.d.ts}

@@ -1,17 +1,11 @@
 import { Camera } from "../../../cameras/Camera.js";
 import { Object3D } from "../../../core/Object3D.js";
 import { Material } from "../../../materials/Material.js";
-import { Color } from "../../../math/Color.js";
 import Node from "../../../nodes/core/Node.js";
-import NodeBuilder from "../../../nodes/core/NodeBuilder.js";
-import UniformGroupNode from "../../../nodes/core/UniformGroupNode.js";
+import NodeFrame from "../../../nodes/core/NodeFrame.js";
 import ComputeNode from "../../../nodes/gpgpu/ComputeNode.js";
 import LightsNode from "../../../nodes/lighting/LightsNode.js";
-import { NodeFrame } from "../../../nodes/Nodes.js";
-import { Fog } from "../../../scenes/Fog.js";
-import { FogExp2 } from "../../../scenes/FogExp2.js";
 import { Scene } from "../../../scenes/Scene.js";
-import { CubeTexture } from "../../../textures/CubeTexture.js";
 import { Texture } from "../../../textures/Texture.js";
 import Backend from "../Backend.js";
 import ChainMap from "../ChainMap.js";
@@ -20,35 +14,15 @@ import Renderer from "../Renderer.js";
 import RenderObject from "../RenderObject.js";
 import NodeBuilderState from "./NodeBuilderState.js";
 import NodeUniformsGroup from "./NodeUniformsGroup.js";
-interface NodeUniformsGroupData {
-    renderId?: number | undefined;
-    frameId?: number | undefined;
-}
-interface RenderObjectData {
-    nodeBuilderState?: NodeBuilderState | undefined;
-}
-interface ComputeNodeData {
-    nodeBuilderState?: NodeBuilderState | undefined;
-}
-interface SceneData {
-    background?: Color | Texture | CubeTexture | undefined;
-    backgroundNode?: Node | undefined;
-    fog?: Fog | FogExp2 | undefined;
-    fogNode?: Node | undefined;
-    environment?: Texture | undefined;
-    environmentNode?: Node | undefined;
-}
-interface CacheKeyData {
-    callId: number;
-    cacheKey: number;
-}
+
 declare module "../../../scenes/Scene.js" {
     interface Scene {
-        environmentNode?: Node | null | undefined;
+        environmentNode?: Node<"vec3"> | null | undefined;
         backgroundNode?: Node | null | undefined;
         fogNode?: Node | null | undefined;
     }
 }
+
 /**
  * This renderer module manages node-related objects and is the
  * primary interface between the renderer and the node system.
@@ -56,42 +30,59 @@ declare module "../../../scenes/Scene.js" {
  * @private
  * @augments DataMap
  */
-declare class Nodes extends DataMap<{
+declare class NodeManager extends DataMap {
     /**
      * Constructs a new nodes management component.
      *
      * @param {Renderer} renderer - The renderer.
      * @param {Backend} backend - The renderer's backend.
      */
-    nodeUniformsGroup: {
-        key: NodeUniformsGroup;
-        value: NodeUniformsGroupData;
-    };
-    renderObject: {
-        key: RenderObject;
-        value: RenderObjectData;
-    };
-    computeNode: {
-        key: ComputeNode;
-        value: ComputeNodeData;
-    };
-    scene: {
-        key: Scene;
-        value: SceneData;
-    };
-}> {
+    constructor(renderer: Renderer, backend: Backend);
+    /**
+     * The renderer.
+     *
+     * @type {Renderer}
+     */
     renderer: Renderer;
+    /**
+     * The renderer's backend.
+     *
+     * @type {Backend}
+     */
     backend: Backend;
+    /**
+     * The node frame.
+     *
+     * @type {Renderer}
+     */
     nodeFrame: NodeFrame;
-    nodeBuilderCache: Map<string, NodeBuilderState>;
-    callHashCache: ChainMap<readonly [Scene, LightsNode], CacheKeyData>;
-    groupsData: ChainMap<readonly [UniformGroupNode, NodeUniformsGroup], {
-        version?: number;
-    }>;
+    /**
+     * A cache for managing node builder states.
+     *
+     * @type {Map<number,NodeBuilderState>}
+     */
+    nodeBuilderCache: Map<number, NodeBuilderState>;
+    /**
+     * A cache for managing data cache key data.
+     *
+     * @type {ChainMap}
+     */
+    callHashCache: ChainMap;
+    /**
+     * A cache for managing node uniforms group data.
+     *
+     * @type {ChainMap}
+     */
+    groupsData: ChainMap;
+    /**
+     * A cache for managing node objects of
+     * scene properties like fog or environments.
+     *
+     * @type {Object<string,WeakMap>}
+     */
     cacheLib: {
-        [type: string]: WeakMap<object, Node | undefined>;
+        [x: string]: WeakMap<object, Node | undefined>;
     };
-    constructor(renderer: Renderer, backend: Backend);
     /**
      * Returns `true` if the given node uniforms group must be updated or not.
      *
@@ -119,9 +110,7 @@ declare class Nodes extends DataMap<{
      * @param {any} object - The object to delete.
      * @return {?Object} The deleted dictionary.
      */
-    delete(
-        object: NodeUniformsGroup | RenderObject | ComputeNode | Scene,
-    ): RenderObjectData | NodeUniformsGroupData | ComputeNodeData | SceneData;
+    delete(object: unknown): unknown | null;
     /**
      * Returns a node builder state for the given compute node.
      *
@@ -136,7 +125,7 @@ declare class Nodes extends DataMap<{
      * @param {NodeBuilder} nodeBuilder - The node builder.
      * @return {NodeBuilderState} The node builder state.
      */
-    _createNodeBuilderState(nodeBuilder: NodeBuilder): NodeBuilderState;
+    private _createNodeBuilderState;
     /**
      * Returns an environment node for the current configured
      * scene environment.
@@ -144,7 +133,7 @@ declare class Nodes extends DataMap<{
      * @param {Scene} scene - The scene.
      * @return {Node} A node representing the current scene environment.
      */
-    getEnvironmentNode(scene: Scene): Node | null;
+    getEnvironmentNode(scene: Scene): Node;
     /**
      * Returns a background node for the current configured
      * scene background.
@@ -152,14 +141,14 @@ declare class Nodes extends DataMap<{
      * @param {Scene} scene - The scene.
      * @return {Node} A node representing the current scene background.
      */
-    getBackgroundNode(scene: Scene): Node | null;
+    getBackgroundNode(scene: Scene): Node;
     /**
      * Returns a fog node for the current configured scene fog.
      *
      * @param {Scene} scene - The scene.
      * @return {Node} A node representing the current scene fog.
      */
-    getFogNode(scene: Scene): Node | null;
+    getFogNode(scene: Scene): Node;
     /**
      * Returns a cache key for the given scene and lights node.
      * This key is used by `RenderObject` as a part of the dynamic
@@ -195,12 +184,7 @@ declare class Nodes extends DataMap<{
      * @param {boolean} [forceUpdate=false] - Whether an update should be enforced or not.
      * @return {Node} The node representation.
      */
-    getCacheNode(
-        type: string,
-        object: object,
-        callback: () => Node | undefined,
-        forceUpdate?: boolean,
-    ): Node | undefined;
+    getCacheNode(type: string, object: object, callback: () => Node | undefined, forceUpdate?: boolean): Node;
     /**
      * If a scene fog is configured, this method makes sure to
      * represent the fog with a corresponding node-based implementation.
@@ -280,9 +264,6 @@ declare class Nodes extends DataMap<{
      * @return {boolean} Whether the given render object requires a refresh or not.
      */
     needsRefresh(renderObject: RenderObject): boolean;
-    /**
-     * Frees the internal resources.
-     */
-    dispose(): void;
 }
-export default Nodes;
+
+export default NodeManager;