@types/three 0.170.0 → 0.172.0

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

@@ -1,13 +1,31 @@
 import NodeAttribute from "../../nodes/core/NodeAttribute.js";
+/**
+ * Class for representing programmable stages which are vertex,
+ * fragment or compute shaders. Unlike fixed-function states (like blending),
+ * they represent the programmable part of a pipeline.
+ *
+ * @private
+ */
 declare class ProgrammableStage {
     id: number;
     code: string;
     stage: "compute" | "vertex" | "fragment";
+    name: string;
     attributes: NodeAttribute[] | null;
     usedTimes: number;
+    /**
+     * Constructs a new programmable stage.
+     *
+     * @param {String} code - The shader code.
+     * @param {('vertex'|'fragment'|'compute')} stage - The type of stage.
+     * @param {String} name - The name of the shader.
+     * @param {Array<Object>?} [transforms=null] - The transforms (only relevant for compute stages with WebGL 2 which uses Transform Feedback).
+     * @param {Array<Object>?} [attributes=null] - The attributes (only relevant for compute stages with WebGL 2 which uses Transform Feedback).
+     */
     constructor(
         code: string,
-        type: "compute" | "vertex" | "fragment",
+        stage: "compute" | "vertex" | "fragment",
+        name: string,
         transforms?: null,
         attributes?: NodeAttribute[] | null,
     );

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

@@ -1,9 +1,20 @@
 import { Camera } from "../../cameras/Camera.js";
-import { Object3D } from "../../core/Object3D.js";
+import BundleGroup from "./BundleGroup.js";
+/**
+ * This module is used to represent render bundles inside the renderer
+ * for further processing.
+ *
+ * @private
+ */
 declare class RenderBundle {
-    scene: Object3D;
+    bundleGroup: BundleGroup;
     camera: Camera;
-    constructor(scene: Object3D, camera: Camera);
-    clone(): RenderBundle & this;
+    /**
+     * Constructs a new bundle group.
+     *
+     * @param {BundleGroup} bundleGroup - The bundle group.
+     * @param {Camera} camera - The camera the bundle group is rendered with.
+     */
+    constructor(bundleGroup: BundleGroup, camera: Camera);
 }
 export default RenderBundle;

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

@@ -2,10 +2,28 @@ import { Camera } from "../../cameras/Camera.js";
 import BundleGroup from "./BundleGroup.js";
 import ChainMap from "./ChainMap.js";
 import RenderBundle from "./RenderBundle.js";
+/**
+ * This renderer module manages render bundles.
+ *
+ * @private
+ */
 declare class RenderBundles {
-    lists: ChainMap<readonly [BundleGroup, Camera], RenderBundle>;
+    bundles: ChainMap<readonly [BundleGroup, Camera], RenderBundle>;
+    /**
+     * Constructs a new render bundle management component.
+     */
     constructor();
-    get(scene: BundleGroup, camera: Camera): RenderBundle;
+    /**
+     * Returns a render bundle for the given bundle group and camera.
+     *
+     * @param {BundleGroup} bundleGroup - The bundle group.
+     * @param {Camera} camera - The camera the bundle group is rendered with.
+     * @return {RenderBundle} The render bundle.
+     */
+    get(bundleGroup: BundleGroup, camera: Camera): RenderBundle;
+    /**
+     * Frees all internal resources.
+     */
     dispose(): void;
 }
 export default RenderBundles;

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

@@ -3,6 +3,14 @@ import { Vector4 } from "../../math/Vector4.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
+ * data are the current clear values or data from the active framebuffer. This
+ * module is used to represent these contexts as objects.
+ *
+ * @private
+ */
 declare class RenderContext {
     id: number;
     color: boolean;
@@ -36,8 +44,22 @@ declare class RenderContext {
     renderTarget?: RenderTarget | undefined;
     activeMipmapLevel?: number | undefined;
     occlusionQueryCount?: number | undefined;
+    /**
+     * Constructs a new render context.
+     */
     constructor();
+    /**
+     * Returns the cache key of this render context.
+     *
+     * @return {Number} The cache key.
+     */
     getCacheKey(): number;
 }
+/**
+ * Computes a cache key for the given render context.
+ *
+ * @param {RenderContext} renderContext - The render context.
+ * @return {Number} The cache key.
+ */
 export declare function getCacheKey(renderContext: RenderContext): number;
 export default RenderContext;

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

@@ -3,15 +3,54 @@ import { Object3D } from "../../core/Object3D.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
 import ChainMap from "./ChainMap.js";
 import RenderContext from "./RenderContext.js";
+/**
+ * This module manages the render contexts of the renderer.
+ *
+ * @private
+ */
 declare class RenderContexts {
     chainMaps: {
-        [attachmentState: string]: ChainMap<readonly [Object3D, Camera], RenderContext> | undefined;
+        [attachmentState: string]:
+            | ChainMap<
+                | readonly [Object3D, Camera]
+                | readonly [Object3D, Camera, {
+                    id: "default";
+                }],
+                RenderContext
+            >
+            | undefined;
     };
+    /**
+     * Constructs a new render context management component.
+     */
     constructor();
-    get(scene: Object3D, camera: Camera, renderTarget?: RenderTarget | null): RenderContext;
+    /**
+     * Returns a render context for the given scene, camera and render target.
+     *
+     * @param {Scene?} [scene=null] - The scene. The parameter can become `null` e.g. when the renderer clears a render target.
+     * @param {Camera?} [camera=null] - The camera that is used to render the scene. The parameter can become `null` e.g. when the renderer clears a render target.
+     * @param {RenderTarget?} [renderTarget=null] - The active render target.
+     * @return {RenderContext} The render context.
+     */
+    get(scene?: Object3D | null, camera?: Camera | null, renderTarget?: RenderTarget | null): RenderContext;
+    /**
+     * Returns a chain map for the given attachment state.
+     *
+     * @param {String} attachmentState - The attachment state.
+     * @return {ChainMap} The chain map.
+     */
     getChainMap(
         attachmentState: string,
-    ): ChainMap<readonly [Object3D<import("../../core/Object3D.js").Object3DEventMap>, Camera], RenderContext>;
+    ): ChainMap<
+        | readonly [Object3D<import("../../core/Object3D.js").Object3DEventMap>, Camera]
+        | readonly [Object3D<import("../../core/Object3D.js").Object3DEventMap>, Camera, {
+            id: "default";
+        }],
+        RenderContext
+    >;
+    /**
+     * Frees internal resources.
+     */
     dispose(): void;
 }
 export default RenderContexts;

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,7 +21,19 @@ export interface RenderItem {
     renderOrder: number | null;
     z: number | null;
     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
+ * properties of a 3D objects (like their transformation or material state), the
+ * objects are maintained in ordered lists for the actual rendering.
+ *
+ * Render lists are unique per scene and camera combination.
+ *
+ * @private
+ * @augments Pipeline
+ */
 declare class RenderList {
     renderItems: RenderItem[];
     renderItemsIndex: number;
@@ -33,8 +46,38 @@ declare class RenderList {
     scene: Object3D;
     camera: Camera;
     occlusionQueryCount: number;
+    /**
+     * 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: Object3D, camera: Camera);
+    /**
+     * This method is called right at the beginning of a render call
+     * before the scene is analyzed. It prepares the internal data
+     * structures for the upcoming render lists generation.
+     *
+     * @return {RenderList} A reference to this render list.
+     */
     begin(): this;
+    /**
+     * Returns a render item for the giving render item state. The state is defined
+     * by a series of object-related parameters.
+     *
+     * The method avoids object creation by holding render items and reusing them in
+     * subsequent render calls (just with different property values).
+     *
+     * @param {Object3D} object - The 3D object.
+     * @param {BufferGeometry} geometry - The 3D object's geometry.
+     * @param {Material} material - The 3D object's material.
+     * @param {Number} groupOrder - The current group order.
+     * @param {Number} z - Th 3D object's depth value (z value in clip space).
+     * @param {Number?} group - {Object?} group - Only relevant for objects using multiple materials. This represents a group entry from the respective `BufferGeometry`.
+     * @param {ClippingContext} clippingContext - The current clipping context.
+     * @return {Object} The render item.
+     */
     getNextRenderItem(
         object: Object3D,
         geometry: BufferGeometry,
@@ -42,7 +85,20 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
+        clippingContext: ClippingContext | null,
     ): RenderItem;
+    /**
+     * Pushes the given object as a render item to the internal render lists.
+     * The selected lists depend on the object properties.
+     *
+     * @param {Object3D} object - The 3D object.
+     * @param {BufferGeometry} geometry - The 3D object's geometry.
+     * @param {Material} material - The 3D object's material.
+     * @param {Number} groupOrder - The current group order.
+     * @param {Number} z - Th 3D object's depth value (z value in clip space).
+     * @param {Number?} group - {Object?} group - Only relevant for objects using multiple materials. This represents a group entry from the respective `BufferGeometry`.
+     * @param {ClippingContext} clippingContext - The current clipping context.
+     */
     push(
         object: Object3D,
         geometry: BufferGeometry,
@@ -50,7 +106,20 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
+        clippingContext: ClippingContext | null,
     ): void;
+    /**
+     * Inserts the given object as a render item at the start of the internal render lists.
+     * The selected lists depend on the object properties.
+     *
+     * @param {Object3D} object - The 3D object.
+     * @param {BufferGeometry} geometry - The 3D object's geometry.
+     * @param {Material} material - The 3D object's material.
+     * @param {Number} groupOrder - The current group order.
+     * @param {Number} z - Th 3D object's depth value (z value in clip space).
+     * @param {Number?} group - {Object?} group - Only relevant for objects using multiple materials. This represents a group entry from the respective `BufferGeometry`.
+     * @param {ClippingContext} clippingContext - The current clipping context.
+     */
     unshift(
         object: Object3D,
         geometry: BufferGeometry,
@@ -58,13 +127,34 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
+        clippingContext: ClippingContext | null,
     ): void;
+    /**
+     * Pushes render bundle group data into the render list.
+     *
+     * @param {Object} group - Bundle group data.
+     */
     pushBundle(group: Bundle): void;
+    /**
+     * Pushes a light into the render list.
+     *
+     * @param {Light} light - The light.
+     */
     pushLight(light: Light): void;
+    /**
+     * Sorts the internal render lists.
+     *
+     * @param {Function} customOpaqueSort - A custom sort function for opaque objects.
+     * @param {Function} customTransparentSort -  A custom sort function for transparent objects.
+     */
     sort(
         customOpaqueSort: ((a: RenderItem, b: RenderItem) => number) | null,
         customTransparentSort: ((a: RenderItem, b: RenderItem) => number) | null,
     ): void;
+    /**
+     * This method performs finalizing tasks right after the render lists
+     * have been generated.
+     */
     finish(): void;
 }
 export default RenderList;

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

@@ -3,11 +3,32 @@ import { Object3D } from "../../core/Object3D.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.
+ *
+ * @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);
+    /**
+     * Returns a render list for the given scene and camera.
+     *
+     * @param {Scene} scene - The scene.
+     * @param {Camera} camera - The camera.
+     * @return {RenderList} The render list.
+     */
     get(scene: Object3D, camera: Camera): RenderList;
+    /**
+     * Frees all internal resources.
+     */
     dispose(): void;
 }
 export default RenderLists;

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

@@ -17,6 +17,24 @@ import Nodes from "./nodes/Nodes.js";
 import RenderContext from "./RenderContext.js";
 import Renderer from "./Renderer.js";
 import RenderPipeline from "./RenderPipeline.js";
+/**
+ * A render object is the renderer's representation of single entity that gets drawn
+ * with a draw command. There is no unique mapping of render objects to 3D objects in the
+ * scene since render objects also depend from the used material, the current render context
+ * and the current scene's lighting.
+ *
+ * In general, the basic process of the renderer is:
+ *
+ * - Analyze the 3D objects in the scene and generate render lists containing render items.
+ * - Process the render lists by calling one or more render commands for each render item.
+ * - For each render command, request a render object and perform the draw.
+ *
+ * The module provides an interface to get data required for the draw command like the actual
+ * draw parameters or vertex buffers. It also holds a series of caching related methods since
+ * creating render objects should only be done when necessary.
+ *
+ * @private
+ */
 export default class RenderObject {
     _nodes: Nodes;
     _geometries: Geometries;
@@ -44,8 +62,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;
@@ -54,6 +72,20 @@ export default class RenderObject {
     onDispose: (() => void) | null;
     readonly isRenderObject: true;
     onMaterialDispose: () => void;
+    /**
+     * Constructs a new render object.
+     *
+     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
+     * @param {Geometries} geometries - Renderer component for managing geometries.
+     * @param {Renderer} renderer - The renderer.
+     * @param {Object3D} object - The 3D object.
+     * @param {Material} material - The 3D object's material.
+     * @param {Scene} scene - The scene the 3D object belongs to.
+     * @param {Camera} camera - The camera the object should be rendered with.
+     * @param {LightsNode} lightsNode - The lights node.
+     * @param {RenderContext} renderContext - The render context.
+     * @param {ClippingContext} clippingContext - The clipping context.
+     */
     constructor(
         nodes: Nodes,
         geometries: Geometries,
@@ -64,32 +96,155 @@ export default class RenderObject {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
+        clippingContext: ClippingContext | null,
     );
-    updateClipping(parent: ClippingContext): void;
+    /**
+     * Updates the clipping context.
+     *
+     * @param {ClippingContext} context - The clipping context to set.
+     */
+    updateClipping(context: ClippingContext): void;
+    /**
+     * Whether the clipping requires an update or not.
+     *
+     * @type {Boolean}
+     * @readonly
+     */
     get clippingNeedsUpdate(): boolean;
+    /**
+     * The number of clipping planes defined in context of hardware clipping.
+     *
+     * @type {Number}
+     * @readonly
+     */
+    get hardwareClippingPlanes(): number;
+    /**
+     * Returns the node builder state of this render object.
+     *
+     * @return {NodeBuilderState} The node buider state.
+     */
     getNodeBuilderState(): NodeBuilderState;
+    /**
+     * Returns the node material observer of this render object.
+     *
+     * @return {NodeMaterialObserver} The node material observer.
+     */
     getMonitor(): NodeMaterialObserver;
+    /**
+     * Returns an array of bind groups of this render object.
+     *
+     * @return {Array<BindGroup>} The bindings.
+     */
     getBindings(): BindGroup[];
+    /**
+     * Returns the index of the render object's geometry.
+     *
+     * @return {BufferAttribute?} The index. Returns `null` for non-indexed geometries.
+     */
     getIndex(): BufferAttribute | null;
+    /**
+     * Returns the indirect buffer attribute.
+     *
+     * @return {BufferAttribute?} The indirect attribute. `null` if no indirect drawing is used.
+     */
     getIndirect(): import("./IndirectStorageBufferAttribute.js").default | null;
+    /**
+     * Returns an array that acts as a key for identifying the render object in a chain map.
+     *
+     * @return {Array<Object>} An array with object references.
+     */
     getChainArray(): readonly [
         Object3D<import("../../core/Object3D.js").Object3DEventMap>,
         Material,
         RenderContext,
         LightsNode,
     ];
-    getAttributes(): (InterleavedBufferAttribute | BufferAttribute)[];
-    getVertexBuffers(): (InterleavedBuffer | BufferAttribute)[] | null;
+    /**
+     * This method is used when the geometry of a 3D object has been exchanged and the
+     * respective render object now requires an update.
+     *
+     * @param {BufferGeometry} geometry - The geometry to set.
+     */
+    setGeometry(geometry: BufferGeometry): void;
+    /**
+     * Returns the buffer attributes of the render object. The returned array holds
+     * attribute definitions on geometry and node level.
+     *
+     * @return {Array<BufferAttribute>} An array with buffer attributes.
+     */
+    getAttributes(): (BufferAttribute | InterleavedBufferAttribute)[];
+    /**
+     * Returns the vertex buffers of the render object.
+     *
+     * @return {Array<BufferAttribute|InterleavedBuffer>} An array with buffer attribute or interleaved buffers.
+     */
+    getVertexBuffers(): (BufferAttribute | InterleavedBuffer)[] | null;
+    /**
+     * Returns the draw parameters for the render object.
+     *
+     * @return {{vertexCount: Number, firstVertex: Number, instanceCount: Number, firstInstance: Number}} The draw parameters.
+     */
     getDrawParameters(): {
         vertexCount: number;
         firstVertex: number;
         instanceCount: number;
         firstInstance: number;
     } | null;
+    /**
+     * Returns the render object's geometry cache key.
+     *
+     * The geometry cache key is part of the material cache key.
+     *
+     * @return {String} The geometry cache key.
+     */
     getGeometryCacheKey(): string;
+    /**
+     * Returns the render object's material cache key.
+     *
+     * The material cache key is part of the render object cache key.
+     *
+     * @return {String} The material cache key.
+     */
     getMaterialCacheKey(): number;
+    /**
+     * Whether the geometry requires an update or not.
+     *
+     * @type {Boolean}
+     * @readonly
+     */
+    get needsGeometryUpdate(): boolean;
+    /**
+     * Whether the render object requires an update or not.
+     *
+     * Note: There are two distinct places where render objects are checked for an update.
+     *
+     * 1. In `RenderObjects.get()` which is executed when the render object is request. This
+     * method checks the `needsUpdate` flag and recreates the render object if necessary.
+     * 2. In `Renderer._renderObjectDirect()` right after getting the render object via
+     * `RenderObjects.get()`. The render object's NodeMaterialObserver is then used to detect
+     * a need for a refresh due to material, geometry or object related value changes.
+     *
+     * TODO: Investigate if it's possible to merge boths steps so there is only a single place
+     * that performs the 'needsUpdate' check.
+     *
+     * @type {Boolean}
+     * @readonly
+     */
     get needsUpdate(): boolean;
+    /**
+     * Returns the dynamic cache key which represents a key that is computed per draw command.
+     *
+     * @return {String} The cache key.
+     */
     getDynamicCacheKey(): string;
+    /**
+     * Returns the render object's cache key.
+     *
+     * @return {String} The cache key.
+     */
     getCacheKey(): string;
+    /**
+     * Frees internal resources.
+     */
     dispose(): void;
 }

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";
@@ -12,6 +13,11 @@ import Pipelines from "./Pipelines.js";
 import RenderContext from "./RenderContext.js";
 import Renderer from "./Renderer.js";
 import RenderObject from "./RenderObject.js";
+/**
+ * This module manages the render objects of the renderer.
+ *
+ * @private
+ */
 declare class RenderObjects {
     renderer: Renderer;
     nodes: Nodes;
@@ -22,6 +28,16 @@ declare class RenderObjects {
     chainMaps: {
         [passId: string]: ChainMap<readonly [Object3D, Material, RenderContext, LightsNode], RenderObject>;
     };
+    /**
+     * Constructs a new render object management component.
+     *
+     * @param {Renderer} renderer - The renderer.
+     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
+     * @param {Geometries} geometries - Renderer component for managing geometries.
+     * @param {Pipelines} pipelines - Renderer component for managing pipelines.
+     * @param {Bindings} bindings - Renderer component for managing bindings.
+     * @param {Info} info - Renderer component for managing metrics and monitoring data.
+     */
     constructor(
         renderer: Renderer,
         nodes: Nodes,
@@ -30,6 +46,19 @@ declare class RenderObjects {
         bindings: Bindings,
         info: Info,
     );
+    /**
+     * Returns a render object for the given object and state data.
+     *
+     * @param {Object3D} object - The 3D object.
+     * @param {Material} material - The 3D object's material.
+     * @param {Scene} scene - The scene the 3D object belongs to.
+     * @param {Camera} camera - The camera the 3D object should be rendered with.
+     * @param {LightsNode} lightsNode - The lights node.
+     * @param {RenderContext} renderContext - The render context.
+     * @param {ClippingContext} clippingContext - The clipping context.
+     * @param {String?} passId - An optional ID for identifying the pass.
+     * @return {RenderObject} The render object.
+     */
     get(
         object: Object3D,
         material: Material,
@@ -37,15 +66,41 @@ declare class RenderObjects {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
+        clippingContext: ClippingContext | null,
         passId?: string | undefined,
     ): RenderObject;
+    /**
+     * Returns a chain map for the given pass ID.
+     *
+     * @param {String} [passId='default'] - The pass ID.
+     * @return {ChainMap} The chain map.
+     */
     getChainMap(
         passId?: string,
     ): ChainMap<
         readonly [Object3D<import("../../core/Object3D.js").Object3DEventMap>, Material, RenderContext, LightsNode],
         RenderObject
     >;
+    /**
+     * Frees internal resources.
+     */
     dispose(): void;
+    /**
+     * Factory method for creating render objects with the given list of parameters.
+     *
+     * @param {Nodes} nodes - Renderer component for managing nodes related logic.
+     * @param {Geometries} geometries - Renderer component for managing geometries.
+     * @param {Renderer} renderer - The renderer.
+     * @param {Object3D} object - The 3D object.
+     * @param {Material} material - The object's material.
+     * @param {Scene} scene - The scene the 3D object belongs to.
+     * @param {Camera} camera - The camera the object should be rendered with.
+     * @param {LightsNode} lightsNode - The lights node.
+     * @param {RenderContext} renderContext - The render context.
+     * @param {ClippingContext} clippingContext - The clipping context.
+     * @param {String?} passId - An optional ID for identifying the pass.
+     * @return {RenderObject} The render object.
+     */
     createRenderObject(
         nodes: Nodes,
         geometries: Geometries,
@@ -56,6 +111,7 @@ declare class RenderObjects {
         camera: Camera,
         lightsNode: LightsNode,
         renderContext: RenderContext,
+        clippingContext: ClippingContext | null,
         passId: string | undefined,
     ): RenderObject;
 }