@types/three 0.169.0 → 0.171.0

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/Discard.d.ts

@@ -1,7 +1,7 @@
 import Node from "../core/Node.js";
 import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
 
-export const Discard: (conditional: NodeRepresentation) => ShaderNodeObject<Node>;
+export const Discard: (conditional?: NodeRepresentation) => ShaderNodeObject<Node>;
 export const Return: () => ShaderNodeObject<Node>;
 
 declare module "../tsl/TSLCore.js" {

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

@@ -0,0 +1,7 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const oscSine: (timeNode?: NodeRepresentation) => ShaderNodeObject<Node>;
+export const oscSquare: (timeNode?: NodeRepresentation) => ShaderNodeObject<Node>;
+export const oscTriangle: (timeNode?: NodeRepresentation) => ShaderNodeObject<Node>;
+export const oscSawtooth: (timeNode?: NodeRepresentation) => ShaderNodeObject<Node>;

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

@@ -0,0 +1,45 @@
+import Node from "../core/Node.js";
+import { NodeRepresentation, ShaderNodeObject } from "../tsl/TSLCore.js";
+
+/**
+ * Computes a position in view space based on a fragment's screen position expressed as uv coordinates, the fragments
+ * depth value and the camera's inverse projection matrix.
+ *
+ * @param {vec2} screenPosition - The fragment's screen position expressed as uv coordinates.
+ * @param {float} depth - The fragment's depth value.
+ * @param {mat4} projectionMatrixInverse - The camera's inverse projection matrix.
+ * @return {vec3} The fragments position in view space.
+ */
+export const getViewPosition: (
+    screenPosition: NodeRepresentation,
+    depth: NodeRepresentation,
+    projectionMatrixInverse: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+/**
+ * Computes a screen position expressed as uv coordinates based on a fragment's position in view space and the camera's
+ * projection matrix
+ *
+ * @param {vec3} viewPosition - The fragments position in view space.
+ * @param {mat4} projectionMatrix - The camera's projection matrix.
+ * @return {vec2} The fragment's screen position expressed as uv coordinates.
+ */
+export const getScreenPosition: (
+    viewPosition: NodeRepresentation,
+    projectionMatrix: NodeRepresentation,
+) => ShaderNodeObject<Node>;
+
+/**
+ * Computes a normal vector based on depth data. Can be used as a fallback when no normal render target is available or
+ * if flat surface normals are required.
+ *
+ * @param {vec2} uv - The texture coordinate.
+ * @param {DepthTexture} depthTexture - The depth texture.
+ * @param {mat4} projectionMatrixInverse - The camera's inverse projection matrix.
+ * @return {vec3} The computed normal vector.
+ */
+export const getNormalFromDepth: (
+    uv: NodeRepresentation,
+    depthTexture: NodeRepresentation,
+    projectionMatrixInverse: NodeRepresentation,
+) => ShaderNodeObject<Node>;

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

@@ -2,6 +2,7 @@ import { Camera } from "../../cameras/Camera.js";
 import { Object3D } from "../../core/Object3D.js";
 import { RenderTarget } from "../../core/RenderTarget.js";
 import TextureNode from "../accessors/TextureNode.js";
+import Node from "../core/Node.js";
 import { ShaderNodeObject } from "../tsl/TSLCore.js";
 
 export interface ReflectorNodeParameters {
@@ -11,7 +12,19 @@ export interface ReflectorNodeParameters {
     bounces?: boolean | undefined;
 }
 
-export default class ReflectorNode extends TextureNode {
+declare class ReflectorNode extends TextureNode {
+    constructor(parameters?: ReflectorNodeParameters);
+
+    get reflector(): ReflectorBaseNode;
+
+    get target(): Object3D;
+
+    getDepthNode(): ShaderNodeObject<ReflectorNode>;
+}
+
+declare class ReflectorBaseNode extends Node {
+    textureNode: TextureNode;
+
     target: Object3D;
     resolution: number;
     generateMipmaps: boolean;
@@ -20,9 +33,7 @@ export default class ReflectorNode extends TextureNode {
     virtualCameras: WeakMap<Camera, Camera>;
     renderTargets: WeakMap<Camera, RenderTarget>;
 
-    constructor(parameters?: ReflectorNodeParameters);
-
-    getTextureNode(): TextureNode;
+    constructor(textureNode: TextureNode, parameters?: ReflectorNodeParameters);
 
     getVirtualCamera(camera: Camera): Camera;
 
@@ -30,3 +41,5 @@ export default class ReflectorNode extends TextureNode {
 }
 
 export const reflector: (parameters?: ReflectorNodeParameters) => ShaderNodeObject<ReflectorNode>;
+
+export default ReflectorNode;

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/nodes/utils/Timer.d.ts

@@ -0,0 +1,21 @@
+import Node from "../core/Node.js";
+import { ShaderNodeObject } from "../tsl/TSLCore.js";
+
+export const time: ShaderNodeObject<Node>;
+export const deltaTime: ShaderNodeObject<Node>;
+export const frameId: ShaderNodeObject<Node>;
+
+/**
+ * @deprecated Use "time" instead.
+ */
+export const timerLocal: (timeScale?: number) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated Use "time" instead.
+ */
+export const timerGlobal: (timeScale?: number) => ShaderNodeObject<Node>;
+
+/**
+ * @deprecated Use "deltaTime" instead.
+ */
+export const timerDelta: (timeScale?: number) => ShaderNodeObject<Node>;

three/src/objects/BatchedMesh.d.ts

@@ -7,11 +7,22 @@ import { Matrix4 } from "../math/Matrix4.js";
 import { Sphere } from "../math/Sphere.js";
 import { Mesh } from "./Mesh.js";
 
+export interface BatchedMeshGeometryRange {
+    vertexStart: number;
+    vertexCount: number;
+    reservedVertexCount: number;
+    indexStart: number;
+    indexCount: number;
+    reservedIndexCount: number;
+    start: number;
+    count: number;
+}
+
 /**
- * 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.
@@ -80,6 +91,12 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     get maxInstanceCount(): number;
 
+    get instanceCount(): number;
+
+    get unusedVertexCount(): number;
+
+    get unusedIndexCount(): number;
+
     /**
      * Read-only flag to check if a given object is of type {@link BatchedMesh}.
      */
@@ -151,8 +168,8 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     getGeometryRangeAt(
         geometryId: number,
-        target?: { start: number; count: number },
-    ): { start: number; count: number } | null;
+        target?: BatchedMeshGeometryRange,
+    ): BatchedMeshGeometryRange | null;
 
     /**
      * Get the geometryIndex of the defined instance.
@@ -208,6 +225,12 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     addInstance(geometryId: number): number;
 
+    /**
+     * @param geometryId The id of a geometry to remove from the [name] that was previously added via "addGeometry". Any
+     * instances referencing this geometry will also be removed as a side effect.
+     */
+    deleteGeometry(geometryId: number): this;
+
     /**
      * 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
@@ -223,6 +246,28 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
      */
     setGeometryAt(geometryId: number, geometry: BufferGeometry): number;
 
+    /**
+     * Repacks the sub geometries in [name] to remove any unused space remaining from previously deleted geometry,
+     * freeing up space to add new geometry.
+     */
+    optimize(): this;
+
+    /**
+     * Resizes the available space in BatchedMesh's vertex and index buffer attributes to the provided sizes. If the
+     * provided arguments shrink the geometry buffers but there is not enough unused space at the end of the geometry
+     * attributes then an error is thrown.
+     * @param maxVertexCount the max number of vertices to be used by all unique geometries to resize to.
+     * @param maxIndexCount the max number of indices to be used by all unique geometries to resize to.
+     */
+    setGeometrySize(maxVertexCount: number, maxIndexCount: number): void;
+
+    /**
+     * Resizes the necessary buffers to support the provided number of instances. If the provided arguments shrink the
+     * number of instances but there are not enough unused ids at the end of the list then an error is thrown.
+     * @param maxInstanceCount the max number of individual instances that can be added and rendered by the BatchedMesh.
+     */
+    setInstanceCount(maxInstanceCount: number): void;
+
     getBoundingBoxAt(geometryId: number, target: Box3): Box3 | null;
     getBoundingSphereAt(geometryId: number, target: Sphere): Sphere | null;
 }

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

@@ -1,5 +1,5 @@
 import { Camera } from "../cameras/Camera.js";
-import { ColorSpace, CullFace, ShadowMapType, ToneMapping, WebGLCoordinateSystem } from "../constants.js";
+import { CullFace, ShadowMapType, ToneMapping, WebGLCoordinateSystem } from "../constants.js";
 import { TypedArray } from "../core/BufferAttribute.js";
 import { BufferGeometry } from "../core/BufferGeometry.js";
 import { Object3D } from "../core/Object3D.js";
@@ -74,7 +74,7 @@ export interface WebGLRendererParameters extends WebGLCapabilitiesParameters {
     /**
      * Can be "high-performance", "low-power" or "default"
      */
-    powerPreference?: string | undefined;
+    powerPreference?: WebGLPowerPreference | undefined;
 
     /**
      * default is true.
@@ -183,8 +183,8 @@ export class WebGLRenderer implements Renderer {
      * {@link SRGBColorSpace} and {@link LinearSRGBColorSpace}.
      * @default THREE.SRGBColorSpace.
      */
-    get outputColorSpace(): ColorSpace;
-    set outputColorSpace(colorSpace: ColorSpace);
+    get outputColorSpace(): string;
+    set outputColorSpace(colorSpace: string);
 
     get coordinateSystem(): typeof WebGLCoordinateSystem;
 
@@ -431,26 +431,39 @@ export class WebGLRenderer implements Renderer {
     copyFramebufferToTexture(texture: Texture, position?: Vector2 | null, level?: number): void;
 
     /**
-     * Copies the pixels of a texture in the bounds `srcRegion` in the destination texture starting from the given
-     * position.
+     * Copies the pixels of a texture in the bounds [srcRegion]{@link Box3} in the destination texture starting from the
+     * given position. 2D Texture, 3D Textures, or a mix of the two can be used as source and destination texture
+     * arguments for copying between layers of 3d textures
+     *
+     * The `depthTexture` and `texture` property of render targets are supported as well.
+     *
+     * When using render target textures as `srcTexture` and `dstTexture`, you must make sure both render targets are
+     * initialized e.g. via {@link .initRenderTarget}().
      *
      * @param srcTexture Specifies the source texture.
      * @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 level Specifies the destination mipmap level of the texture.
+     * @param srcLevel Specifies the source mipmap level of the texture.
+     * @param dstLevel Specifies the destination mipmap level of the texture.
      */
     copyTextureToTexture(
         srcTexture: Texture,
         dstTexture: Texture,
-        srcRegion?: Box2 | null,
-        dstPosition?: Vector2 | null,
-        level?: number,
+        srcRegion?: Box2 | Box3 | null,
+        dstPosition?: Vector2 | Vector3 | null,
+        srcLevel?: number,
+        dstLevel?: number,
     ): void;
 
     /**
+     * @deprecated Use "copyTextureToTexture" instead.
+     *
      * Copies the pixels of a texture in the bounds `srcRegion` in the destination texture starting from the given
-     * position.
+     * position. The `depthTexture` and `texture` property of 3D render targets are supported as well.
+     *
+     * When using render target textures as `srcTexture` and `dstTexture`, you must make sure both render targets are
+     * intitialized e.g. via {@link .initRenderTarget}().
      *
      * @param srcTexture Specifies the source texture.
      * @param dstTexture Specifies the destination texture.

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/Constants.d.ts

@@ -1,7 +1,8 @@
 export declare const AttributeType: {
     readonly VERTEX: 1;
     readonly INDEX: 2;
-    readonly STORAGE: 4;
+    readonly STORAGE: 3;
+    readonly INDIRECT: 4;
 };
 export type AttributeType = (typeof AttributeType)[keyof typeof AttributeType];
 export declare const GPU_CHUNK_BYTES = 16;

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

@@ -26,6 +26,7 @@ declare class Geometries extends DataMap<{
     initGeometry(renderObject: RenderObject): void;
     updateAttributes(renderObject: RenderObject): void;
     updateAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
+    getIndirect(renderObject: RenderObject): import("./IndirectStorageBufferAttribute.js").default | null;
     getIndex(renderObject: RenderObject): BufferAttribute | null;
 }
 export default Geometries;

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

@@ -0,0 +1,10 @@
+import { TypedArray } from "../../core/BufferAttribute.js";
+import StorageBufferAttribute from "./StorageBufferAttribute.js";
+
+declare class IndirectStorageBufferAttribute extends StorageBufferAttribute {
+    readonly isIndirectStorageBufferAttribute: true;
+
+    constructor(array: TypedArray, itemSize: number);
+}
+
+export default IndirectStorageBufferAttribute;

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

@@ -0,0 +1,15 @@
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
+import { Light } from "../../lights/Light.js";
+import LightsNode from "../../nodes/lighting/LightsNode.js";
+import ChainMap from "./ChainMap.js";
+
+declare class Lighting extends ChainMap<[Object3D, Camera], LightsNode> {
+    constructor();
+
+    createNode(lights?: Light[]): LightsNode;
+
+    getNode(scene: Object3D, camera: Camera): LightsNode;
+}
+
+export default Lighting;

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

@@ -0,0 +1,66 @@
+import { Camera } from "../../cameras/Camera.js";
+import { ToneMapping } from "../../constants.js";
+import { BufferGeometry, GeometryGroup } from "../../core/BufferGeometry.js";
+import { Object3D } from "../../core/Object3D.js";
+import { RenderTarget } from "../../core/RenderTarget.js";
+import { Material } from "../../materials/Material.js";
+import { Color } from "../../math/Color.js";
+import MRTNode from "../../nodes/core/MRTNode.js";
+import LightsNode from "../../nodes/lighting/LightsNode.js";
+import { Scene } from "../../scenes/Scene.js";
+import { CubeTexture } from "../../textures/CubeTexture.js";
+import { Texture } from "../../textures/Texture.js";
+import Color4 from "./Color4.js";
+import Renderer from "./Renderer.js";
+
+// renderer state
+
+export interface RendererState {
+    toneMapping: ToneMapping;
+    toneMappingExposure: number;
+    outputColorSpace: string;
+    renderTarget: RenderTarget | null;
+    activeCubeFace: number;
+    activeMipmapLevel: number;
+    renderObjectFunction:
+        | ((
+            object: Object3D,
+            scene: Scene,
+            camera: Camera,
+            geometry: BufferGeometry,
+            material: Material,
+            group: GeometryGroup,
+            lightsNode: LightsNode,
+        ) => void)
+        | null;
+    pixelRatio: number;
+    mrt: MRTNode | null;
+    clearColor: Color4;
+    clearAlpha: number;
+    autoClear: boolean;
+    scissorTest: boolean;
+}
+
+export function saveRendererState(renderer: Renderer, state?: RendererState): RendererState;
+
+export function resetRendererState(renderer: Renderer, state?: RendererState): RendererState;
+
+export function restoreRendererState(renderer: Renderer, state: RendererState): void;
+
+// renderer and scene state
+
+export interface RendererAndSceneState extends RendererState {
+    background: Color | Texture | CubeTexture | null;
+    backgroundNode: Node | null | undefined;
+    overrideMaterial: Material | null;
+}
+
+export function saveRendererAndSceneState(
+    renderer: RendererState,
+    scene: Scene,
+    state?: RendererAndSceneState,
+): RendererAndSceneState;
+
+export function resetRendererAndSceneState(renderer: Renderer, state?: RendererAndSceneState): RendererAndSceneState;
+
+export function restoreRendererAndSceneState(renderer: Renderer, state: RendererAndSceneState): void;

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

@@ -5,6 +5,8 @@ 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;
     camera: Camera;
@@ -19,17 +21,21 @@ export interface RenderItem {
     renderOrder: number | null;
     z: number | null;
     group: GeometryGroup | null;
+    clippingContext: ClippingContext | null;
 }
 declare class RenderList {
     renderItems: RenderItem[];
     renderItemsIndex: number;
     opaque: RenderItem[];
+    transparentDoublePass: RenderItem[];
     transparent: RenderItem[];
     bundles: Bundle[];
     lightsNode: LightsNode;
     lightsArray: Light[];
+    scene: Object3D;
+    camera: Camera;
     occlusionQueryCount: number;
-    constructor();
+    constructor(lighting: Lighting, scene: Object3D, camera: Camera);
     begin(): this;
     getNextRenderItem(
         object: Object3D,
@@ -38,6 +44,7 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
+        clippingContext: ClippingContext | null,
     ): RenderItem;
     push(
         object: Object3D,
@@ -46,6 +53,7 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
+        clippingContext: ClippingContext | null,
     ): void;
     unshift(
         object: Object3D,
@@ -54,10 +62,10 @@ declare class RenderList {
         groupOrder: number,
         z: number,
         group: GeometryGroup | null,
+        clippingContext: ClippingContext | null,
     ): void;
     pushBundle(group: Bundle): void;
     pushLight(light: Light): void;
-    getLightsNode(): LightsNode;
     sort(
         customOpaqueSort: ((a: RenderItem, b: RenderItem) => number) | null,
         customTransparentSort: ((a: RenderItem, b: RenderItem) => number) | null,

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

@@ -1,10 +1,12 @@
 import { Camera } from "../../cameras/Camera.js";
 import { Object3D } from "../../core/Object3D.js";
 import ChainMap from "./ChainMap.js";
+import Lighting from "./Lighting.js";
 import RenderList from "./RenderList.js";
 declare class RenderLists {
+    lighting: Lighting;
     lists: ChainMap<readonly [Object3D, Camera], RenderList>;
-    constructor();
+    constructor(lighting: Lighting);
     get(scene: Object3D, camera: Camera): RenderList;
     dispose(): void;
 }