@types/three 0.182.0 → 0.183.0

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

@@ -1,8 +1,11 @@
+import { Camera } from "../../cameras/Camera.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
 import { Vector4 } from "../../math/Vector4.js";
+import MRTNode from "../../nodes/core/MRTNode.js";
 import { DepthTexture } from "../../textures/DepthTexture.js";
 import { Texture } from "../../textures/Texture.js";
 import ClippingContext from "./ClippingContext.js";
+
 /**
  * Any render or compute command is executed in a specific context that defines
  * the state of the renderer and its backend. Typical examples for such context
@@ -12,42 +15,205 @@ import ClippingContext from "./ClippingContext.js";
  * @private
  */
 declare class RenderContext {
+    /**
+     * The context's ID.
+     *
+     * @type {number}
+     */
     id: number;
+    /**
+     * The MRT configuration.
+     *
+     * @type {?MRTNode}
+     * @default null
+     */
+    mrt: MRTNode | null;
+    /**
+     * Whether the current active framebuffer has a color attachment.
+     *
+     * @type {boolean}
+     * @default true
+     */
     color: boolean;
+    /**
+     * Whether the color attachment should be cleared or not.
+     *
+     * @type {boolean}
+     * @default true
+     */
     clearColor: boolean;
+    /**
+     * The clear color value.
+     *
+     * @type {Object}
+     * @default true
+     */
     clearColorValue: {
         r: number;
         g: number;
         b: number;
         a: number;
     };
+    /**
+     * Whether the current active framebuffer has a depth attachment.
+     *
+     * @type {boolean}
+     * @default true
+     */
     depth: boolean;
+    /**
+     * Whether the depth attachment should be cleared or not.
+     *
+     * @type {boolean}
+     * @default true
+     */
     clearDepth: boolean;
+    /**
+     * The clear depth value.
+     *
+     * @type {number}
+     * @default 1
+     */
     clearDepthValue: number;
+    /**
+     * Whether the current active framebuffer has a stencil attachment.
+     *
+     * @type {boolean}
+     * @default false
+     */
     stencil: boolean;
+    /**
+     * Whether the stencil attachment should be cleared or not.
+     *
+     * @type {boolean}
+     * @default true
+     */
     clearStencil: boolean;
+    /**
+     * The clear stencil value.
+     *
+     * @type {number}
+     * @default 1
+     */
     clearStencilValue: number;
+    /**
+     * By default the viewport encloses the entire framebuffer If a smaller
+     * viewport is manually defined, this property is to `true` by the renderer.
+     *
+     * @type {boolean}
+     * @default false
+     */
     viewport: boolean;
+    /**
+     * The viewport value. This value is in physical pixels meaning it incorporates
+     * the renderer's pixel ratio. The viewport property of render targets or
+     * the renderer is in logical pixels.
+     *
+     * @type {Vector4}
+     */
     viewportValue: Vector4;
+    /**
+     * When the scissor test is active and scissor rectangle smaller than the
+     * framebuffers dimensions, this property is to `true` by the renderer.
+     *
+     * @type {boolean}
+     * @default false
+     */
     scissor: boolean;
+    /**
+     * The scissor rectangle.
+     *
+     * @type {Vector4}
+     */
     scissorValue: Vector4;
+    /**
+     * The active render target.
+     *
+     * @type {?RenderTarget}
+     * @default null
+     */
     renderTarget: RenderTarget | null;
+    /**
+     * The textures of the active render target.
+     * `null` when no render target is set.
+     *
+     * @type {?Array<Texture>}
+     * @default null
+     */
     textures: Texture[] | null;
+    /**
+     * The depth texture of the active render target.
+     * `null` when no render target is set.
+     *
+     * @type {?DepthTexture}
+     * @default null
+     */
     depthTexture: DepthTexture | null;
+    /**
+     * The active cube face.
+     *
+     * @type {number}
+     * @default 0
+     */
     activeCubeFace: number;
+    /**
+     * The active mipmap level.
+     *
+     * @type {number}
+     * @default 0
+     */
+    activeMipmapLevel: number;
+    /**
+     * The number of MSAA samples. This value is always `1` when
+     * MSAA isn't used.
+     *
+     * @type {number}
+     * @default 1
+     */
     sampleCount: number;
+    /**
+     * The active render target's width in physical pixels.
+     *
+     * @type {number}
+     * @default 0
+     */
     width: number;
+    /**
+     * The active render target's height in physical pixels.
+     *
+     * @type {number}
+     * @default 0
+     */
     height: number;
+    /**
+     * The occlusion query count.
+     *
+     * @type {number}
+     * @default 0
+     */
     occlusionQueryCount: number;
+    /**
+     * The current clipping context.
+     *
+     * @type {?ClippingContext}
+     * @default null
+     */
     clippingContext: ClippingContext | null;
-    readonly isRenderContext: true;
-    depthClearValue?: number | undefined;
-    stencilClearValue?: number | undefined;
-    activeMipmapLevel?: number | undefined;
     /**
-     * Constructs a new render context.
+     * The current camera.
+     *
+     * @type {?Camera}
+     * @default null
+     */
+    camera: Camera | null;
+    /**
+     * This flag can be used for type testing.
+     *
+     * @type {boolean}
+     * @readonly
+     * @default true
      */
-    constructor();
+    readonly isRenderContext: boolean;
     /**
      * Returns the cache key of this render context.
      *
@@ -55,6 +221,7 @@ declare class RenderContext {
      */
     getCacheKey(): number;
 }
+
 /**
  * Computes a cache key for the given render context. This key
  * should identify the render target state so it is possible to
@@ -63,5 +230,6 @@ declare class RenderContext {
  * @param {RenderContext} renderContext - The render context.
  * @return {number} The cache key.
  */
-export declare function getCacheKey(renderContext: RenderContext): number;
+export function getCacheKey(renderContext: RenderContext): number;
+
 export default RenderContext;

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

@@ -1,52 +1,47 @@
-import { Camera } from "../../cameras/Camera.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
 import MRTNode from "../../nodes/core/MRTNode.js";
-import { Scene } from "../../scenes/Scene.js";
-import ChainMap from "./ChainMap.js";
 import RenderContext from "./RenderContext.js";
+import Renderer from "./Renderer.js";
+
 /**
  * This module manages the render contexts of the renderer.
  *
  * @private
  */
 declare class RenderContexts {
-    chainMaps: {
-        [attachmentState: string]: ChainMap<readonly [Scene, Camera], RenderContext> | undefined;
-    };
     /**
      * Constructs a new render context management component.
+     *
+     * @param {Renderer} renderer - The renderer.
      */
-    constructor();
+    constructor(renderer: Renderer);
     /**
-     * Returns a render context for the given scene, camera and render target.
+     * The renderer.
      *
-     * @param {Scene} scene - The scene.
-     * @param {Camera} camera - The camera that is used to render the scene.
-     * @param {?RenderTarget} [renderTarget=null] - The active render target.
-     * @param {?MRT} [mrt=null] - The active multiple render target.
-     * @return {RenderContext} The render context.
+     * @type {Renderer}
      */
-    get(scene: Scene, camera: Camera, renderTarget?: RenderTarget | null, mrt?: MRTNode | null): RenderContext;
+    renderer: Renderer;
     /**
-     * Returns a render context intended for clear operations.
+     * A dictionary that manages render contexts.
      *
-     * @param {?RenderTarget} [renderTarget=null] - The active render target.
-     * @return {RenderContext} The render context.
+     * @type {Object<string,RenderContext>}
      */
-    getForClear(renderTarget?: RenderTarget | null): RenderContext;
+    _renderContexts: {
+        [x: string]: RenderContext;
+    };
     /**
-     * Returns a chain map for the given attachment state.
+     * Returns a render context for the given scene, camera and render target.
      *
-     * @private
-     * @param {string} attachmentState - The attachment state.
-     * @return {ChainMap} The chain map.
+     * @param {?RenderTarget} [renderTarget=null] - The active render target.
+     * @param {?MRTNode} [mrt=null] - The MRT configuration
+     * @param {?number} [callDepth=0] - The call depth of the renderer.
+     * @return {RenderContext} The render context.
      */
-    _getChainMap(
-        attachmentState: string,
-    ): ChainMap<readonly [Scene<import("../../Three.Core.js").Object3DEventMap>, Camera], RenderContext>;
+    get(renderTarget?: RenderTarget | null, mrt?: MRTNode | null, callDepth?: number | null): RenderContext;
     /**
      * Frees internal resources.
      */
     dispose(): void;
 }
+
 export default RenderContexts;

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

@@ -3,15 +3,18 @@ import { BufferGeometry, GeometryGroup } from "../../core/BufferGeometry.js";
 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 LightsNode from "../../nodes/lighting/LightsNode.js";
+import { Scene } from "../../scenes/Scene.js";
 import BundleGroup from "./BundleGroup.js";
 import ClippingContext from "./ClippingContext.js";
 import Lighting from "./Lighting.js";
+
 export interface Bundle {
     bundleGroup: BundleGroup;
     camera: Camera;
     renderList: RenderList;
 }
+
 export interface RenderItem {
     id: number | null;
     object: Object3D | null;
@@ -23,6 +26,7 @@ export interface RenderItem {
     group: GeometryGroup | null;
     clippingContext: ClippingContext | null;
 }
+
 /**
  * When the renderer analyzes the scene at the beginning of a render call,
  * it stores 3D object for further processing in render lists. Depending on the
@@ -35,25 +39,86 @@ export interface RenderItem {
  * @augments Pipeline
  */
 declare class RenderList {
+    /**
+     * Constructs a render list.
+     *
+     * @param {Lighting} lighting - The lighting management component.
+     * @param {Scene} scene - The scene.
+     * @param {Camera} camera - The camera the scene is rendered with.
+     */
+    constructor(lighting: Lighting, scene: Scene, camera: Camera);
+    /**
+     * 3D objects are transformed into render items and stored in this array.
+     *
+     * @type {Array<Object>}
+     */
     renderItems: RenderItem[];
+    /**
+     * The current render items index.
+     *
+     * @type {number}
+     * @default 0
+     */
     renderItemsIndex: number;
+    /**
+     * A list with opaque render items.
+     *
+     * @type {Array<Object>}
+     */
     opaque: RenderItem[];
+    /**
+     * A list with transparent render items which require
+     * double pass rendering (e.g. transmissive objects).
+     *
+     * @type {Array<Object>}
+     */
     transparentDoublePass: RenderItem[];
+    /**
+     * A list with transparent render items.
+     *
+     * @type {Array<Object>}
+     */
     transparent: RenderItem[];
+    /**
+     * A list with transparent render bundle data.
+     *
+     * @type {Array<Object>}
+     */
     bundles: Bundle[];
+    /**
+     * The render list's lights node. This node is later
+     * relevant for the actual analytical light nodes which
+     * compute the scene's lighting in the shader.
+     *
+     * @type {LightsNode}
+     */
     lightsNode: LightsNode;
+    /**
+     * The scene's lights stored in an array. This array
+     * is used to setup the lights node.
+     *
+     * @type {Array<Light>}
+     */
     lightsArray: Light[];
-    scene: Object3D;
+    /**
+     * The scene.
+     *
+     * @type {Scene}
+     */
+    scene: Scene;
+    /**
+     * The camera the scene is rendered with.
+     *
+     * @type {Camera}
+     */
     camera: Camera;
-    occlusionQueryCount: number;
     /**
-     * Constructs a render list.
+     * How many objects perform occlusion query tests.
      *
-     * @param {Lighting} lighting - The lighting management component.
-     * @param {Scene} scene - The scene.
-     * @param {Camera} camera - The camera the scene is rendered with.
+     * @type {number}
+     * @default 0
      */
-    constructor(lighting: Lighting, scene: Object3D, camera: Camera);
+    occlusionQueryCount: number;
     /**
      * This method is called right at the beginning of a render call
      * before the scene is analyzed. It prepares the internal data
@@ -85,7 +150,7 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
-        clippingContext: ClippingContext | null,
+        clippingContext: ClippingContext,
     ): RenderItem;
     /**
      * Pushes the given object as a render item to the internal render lists.
@@ -106,7 +171,7 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
-        clippingContext: ClippingContext | null,
+        clippingContext: ClippingContext,
     ): void;
     /**
      * Inserts the given object as a render item at the start of the internal render lists.
@@ -127,7 +192,7 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
-        clippingContext: ClippingContext | null,
+        clippingContext: ClippingContext,
     ): void;
     /**
      * Pushes render bundle group data into the render list.
@@ -157,4 +222,5 @@ declare class RenderList {
      */
     finish(): void;
 }
+
 export default RenderList;

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

@@ -1,8 +1,9 @@
 import { Camera } from "../../cameras/Camera.js";
-import { Object3D } from "../../core/Object3D.js";
+import { Scene } from "../../scenes/Scene.js";
 import ChainMap from "./ChainMap.js";
 import Lighting from "./Lighting.js";
 import RenderList from "./RenderList.js";
+
 /**
  * This renderer module manages the render lists which are unique
  * per scene and camera combination.
@@ -10,14 +11,24 @@ import RenderList from "./RenderList.js";
  * @private
  */
 declare class RenderLists {
-    lighting: Lighting;
-    lists: ChainMap<readonly [Object3D, Camera], RenderList>;
     /**
      * Constructs a render lists management component.
      *
      * @param {Lighting} lighting - The lighting management component.
      */
     constructor(lighting: Lighting);
+    /**
+     * The lighting management component.
+     *
+     * @type {Lighting}
+     */
+    lighting: Lighting;
+    /**
+     * The internal chain map which holds the render lists.
+     *
+     * @type {ChainMap}
+     */
+    lists: ChainMap;
     /**
      * Returns a render list for the given scene and camera.
      *
@@ -25,10 +36,11 @@ declare class RenderLists {
      * @param {Camera} camera - The camera.
      * @return {RenderList} The render list.
      */
-    get(scene: Object3D, camera: Camera): RenderList;
+    get(scene: Scene, camera: Camera): RenderList;
     /**
      * Frees all internal resources.
      */
     dispose(): void;
 }
+
 export default RenderLists;