@types/three 0.165.0 → 0.167.0

three/src/objects/BatchedMesh.d.ts

@@ -9,26 +9,36 @@ import { Mesh } from "./Mesh.js";
 
 /**
  * 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 and geometry. The
- * usage of {@link BatchedMesh} will help you to reduce the number of draw calls and thus improve the overall rendering
+ * 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.
  *
  * 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 callback is used.
+ * supported then a less performant fallback is used.
  *
  * @example
  * const box = new THREE.BoxGeometry( 1, 1, 1 );
- * const sphere = new THREE.BoxGeometry( 1, 1, 1 );
+ * const sphere = new THREE.SphereGeometry( 1, 12, 12 );
  * const material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
  *
  * // initialize and add geometries into the batched mesh
  * const batchedMesh = new BatchedMesh( 10, 5000, 10000, material );
- * const boxId = batchedMesh.addGeometry( box );
- * const sphereId = batchedMesh.addGeometry( sphere );
+ * const boxGeometryId = batchedMesh.addGeometry( box );
+ * const sphereGeometryId = batchedMesh.addGeometry( sphere );
+ *
+ * // create instances of those geometries
+ * const boxInstancedId1 = batchedMesh.addInstance( boxGeometryId );
+ * const boxInstancedId2 = batchedMesh.addInstance( boxGeometryId );
+ *
+ * const sphereInstancedId1 = batchedMesh.addInstance( sphereGeometryId );
+ * const sphereInstancedId2 = batchedMesh.addInstance( sphereGeometryId );
  *
  * // position the geometries
- * batchedMesh.setMatrixAt( boxId, boxMatrix );
- * batchedMesh.setMatrixAt( sphereId, sphereMatrix );
+ * batchedMesh.setMatrixAt( boxInstancedId1, boxMatrix1 );
+ * batchedMesh.setMatrixAt( boxInstancedId2, boxMatrix2 );
+ *
+ * batchedMesh.setMatrixAt( sphereInstancedId1, sphereMatrix1 );
+ * batchedMesh.setMatrixAt( sphereInstancedId2, sphereMatrix2 );
  *
  * scene.add( batchedMesh );
  *
@@ -68,20 +78,20 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     /**
      * The maximum number of individual geometries that can be stored in the {@link BatchedMesh}. Read only.
      */
-    get maxGeometryCount(): number;
+    get maxInstanceCount(): number;
 
     /**
      * Read-only flag to check if a given object is of type {@link BatchedMesh}.
      */
-    isBatchedMesh: true;
+    readonly isBatchedMesh: true;
 
     /**
-     * @param maxGeometryCount the max number of individual geometries planned to be added.
+     * @param maxInstanceCount the max number of individual geometries planned to be added.
      * @param maxVertexCount the max number of vertices to be used by all geometries.
      * @param maxIndexCount the max number of indices to be used by all geometries.
-     * @param material an instance of [page:Material]. Default is a new {@link MeshBasicMaterial}.
+     * @param material an instance of {@link Material}. Default is a new {@link MeshBasicMaterial}.
      */
-    constructor(maxGeometryCount: number, maxVertexCount: number, maxIndexCount?: number, material?: Material);
+    constructor(maxInstanceCount: number, maxVertexCount: number, maxIndexCount?: number, material?: Material);
 
     /**
      * Computes the bounding box, updating {@link .boundingBox} attribute.
@@ -102,54 +112,55 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     dispose(): this;
 
     /**
-     * Takes a sort a function that is run before render. The function takes a list of items to sort and a camera. The
-     * objects in the list include a "z" field to perform a depth-ordered sort with.
+     * Takes a sort a function that is run before render. The function takes a list of instances to sort and a camera.
+     * The objects in the list include a "z" field to perform a depth-ordered sort with.
      */
     setCustomSort(
-        func: ((this: this, list: Array<{ start: number; count: number; z: number }>, camera: Camera) => void) | null,
+        sortFunction:
+            | ((this: this, list: Array<{ start: number; count: number; z: number }>, camera: Camera) => void)
+            | null,
     ): this;
 
     /**
      * Get the color of the defined geometry.
-     * @param index The index of a geometry. Values have to be in the range [0, count].
-     * @param color This color object will be set to the color of the defined geometry.
+     * @param instanceId The id of an instance to get the color of.
+     * @param target The target object to copy the color in to.
      */
-    getColorAt(index: number, color: Color): void;
+    getColorAt(instanceId: number, target: Color): void;
 
     /**
      * Get the local transformation matrix of the defined instance.
-     * @param index The index of an instance. Values have to be in the range [0, count].
-     * @param matrix This 4x4 matrix will be set to the local transformation matrix of the defined instance.
+     * @param instanceId The id of an instance to get the matrix of.
+     * @param target This 4x4 matrix will be set to the local transformation matrix of the defined instance.
      */
-    getMatrixAt(index: number, matrix: Matrix4): Matrix4;
+    getMatrixAt(instanceId: number, target: Matrix4): Matrix4;
 
     /**
      * Get whether the given instance is marked as "visible" or not.
-     * @param index The index of an instance. Values have to be in the range [0, count].
+     * @param instanceId The id of an instance to get the visibility state of.
      */
-    getVisibleAt(index: number): boolean;
+    getVisibleAt(instanceId: number): boolean;
 
     /**
-     * Sets the given color to the defined geometry.
-     * @param index The index of a geometry. Values have to be in the range [0, count].
-     * @param color The color of a single geometry.
+     * Sets the given color to the defined geometry instance.
+     * @param instanceId The id of the instance to set the color of.
+     * @param color The color to set the instance to.
      */
-    setColorAt(index: number, color: Color): void;
+    setColorAt(instanceId: number, color: Color): void;
 
     /**
-     * Sets the given local transformation matrix to the defined instance. Make sure you set {@link .instanceMatrix}
-     * {@link BufferAttribute.needsUpdate} to true after updating all the matrices.
-     * @param index The index of an instance. Values have to be in the range [0, count].
+     * Sets the given local transformation matrix to the defined instance.
+     * @param instanceId The id of an instance to set the matrix of.
      * @param matrix A 4x4 matrix representing the local transformation of a single instance.
      */
-    setMatrixAt(index: number, matrix: Matrix4): this;
+    setMatrixAt(instanceId: number, matrix: Matrix4): this;
 
     /**
-     * Sets the visibility of the object at the given index.
-     * @param index The index of an instance. Values have to be in the range [0, count].
+     * Sets the visibility of the instance at the given index.
+     * @param instanceId The id of the instance to set the visibility of.
      * @param visible A boolean value indicating the visibility state.
      */
-    setVisibleAt(index: number, visible: boolean): this;
+    setVisibleAt(instanceId: number, visible: boolean): this;
 
     /**
      * Adds the given geometry to the {@link BatchedMesh} and returns the associated index referring to it.
@@ -164,30 +175,23 @@ declare class BatchedMesh extends Mesh<BufferGeometry, Material> {
     addGeometry(geometry: BufferGeometry, reservedVertexRange?: number, reservedIndexRange?: number): number;
 
     /**
-     * Replaces the geometry at `index` with the provided geometry. Throws an error if there is not enough space
-     * reserved for geometry at the index.
-     * @param index Which geometry index to replace with this geometry.
-     * @param geometry The geometry to substitute at the given geometry index.
+     * Adds a new instance to the {@link BatchedMesh} using the geometry of the given geometryId and returns a new id
+     * referring to the new instance to be used by other functions.
+     * @param geometryId The id of a previously added geometry via "addGeometry" to add into the {@link BatchedMesh} to
+     * render.
      */
-    setGeometryAt(index: number, geometry: BufferGeometry): number;
+    addInstance(geometryId: number): number;
 
     /**
-     * Gets the instance count of the geometry at `index`. Returns `null` if instance counts are not configured.
-     * @param index The index of an instance. Values have to be in the range [0, count].
+     * 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.
+     * @param geometryId Which geometry id to replace with this geometry.
+     * @param geometry The geometry to substitute at the given geometry id.
      */
-    getInstanceCountAt(index: number): number | null;
-
-    /**
-     * Sets an instance count of the geometry at `index`.
-     * @param index Which geometry index to configure an instance count for.
-     * @param instanceCount The number of instances to render of the given geometry index.
-     */
-    setInstanceCountAt(index: number, instanceCount: number): number;
-
-    deleteGeometry(index: number): this;
+    setGeometryAt(geometryId: number, geometry: BufferGeometry): number;
 
-    getBoundingBoxAt(index: number, target: Box3): Box3 | null;
-    getBoundingSphereAt(index: number, target: Sphere): Sphere | null;
+    getBoundingBoxAt(geometryId: number, target: Box3): Box3 | null;
+    getBoundingSphereAt(geometryId: number, target: Sphere): Sphere | null;
 }
 
 export { BatchedMesh };

three/src/objects/InstancedMesh.d.ts

@@ -1,13 +1,24 @@
+import { BufferAttributeJSON } from "./../core/BufferAttribute.js";
 import { BufferGeometry } from "../core/BufferGeometry.js";
 import { InstancedBufferAttribute } from "../core/InstancedBufferAttribute.js";
-import { Object3DEventMap } from "../core/Object3D.js";
+import { JSONMeta, Object3DEventMap } from "../core/Object3D.js";
 import { Material } from "../materials/Material.js";
 import { Box3 } from "../math/Box3.js";
 import { Color } from "../math/Color.js";
 import { Matrix4 } from "../math/Matrix4.js";
 import { Sphere } from "../math/Sphere.js";
 import { DataTexture } from "../textures/DataTexture.js";
-import { Mesh } from "./Mesh.js";
+import { Mesh, MeshJSONObject } from "./Mesh.js";
+
+export interface InstancedMeshJSONObject extends MeshJSONObject {
+    count: number;
+    instanceMatrix: BufferAttributeJSON;
+    instanceColor?: BufferAttributeJSON;
+}
+
+export interface InstancedMeshJSON extends MeshJSONObject {
+    object: InstancedMeshJSONObject;
+}
 
 export interface InstancedMeshEventMap extends Object3DEventMap {
     dispose: {};
@@ -163,4 +174,6 @@ export class InstancedMesh<
      * Call this method whenever this instance is no longer used in your app.
      */
     dispose(): this;
+
+    toJSON(meta?: JSONMeta): InstancedMeshJSON;
 }

three/src/objects/LOD.d.ts

@@ -1,5 +1,19 @@
 import { Camera } from "../cameras/Camera.js";
-import { Object3D, Object3DEventMap } from "../core/Object3D.js";
+import { JSONMeta, Object3D, Object3DEventMap, Object3DJSON, Object3DJSONObject } from "../core/Object3D.js";
+
+export interface LODJSONObject extends Object3DJSONObject {
+    autoUpdate?: boolean;
+
+    levels: Array<{
+        object: string;
+        distance: number;
+        hysteresis: number;
+    }>;
+}
+
+export interface LODJSON extends Object3DJSON {
+    object: LODJSONObject;
+}
 
 /**
  * Every level is associated with an object, and rendering can be switched between them at the distances specified
@@ -85,4 +99,6 @@ export class LOD<TEventMap extends Object3DEventMap = Object3DEventMap> extends
      * @param camera
      */
     update(camera: Camera): void;
+
+    toJSON(meta?: JSONMeta): LODJSON;
 }

three/src/objects/Mesh.d.ts

@@ -1,8 +1,16 @@
 import { BufferGeometry } from "../core/BufferGeometry.js";
-import { Object3D, Object3DEventMap } from "../core/Object3D.js";
+import { JSONMeta, Object3D, Object3DEventMap, Object3DJSON, Object3DJSONObject } from "../core/Object3D.js";
 import { Material } from "../materials/Material.js";
 import { Vector3 } from "../math/Vector3.js";
 
+export interface MeshJSONObject extends Object3DJSONObject {
+    geometry: string;
+}
+
+export interface MeshJSON extends Object3DJSON {
+    object: MeshJSONObject;
+}
+
 /**
  * Class representing triangular {@link https://en.wikipedia.org/wiki/Polygon_mesh | polygon mesh} based objects.
  * @remarks
@@ -81,4 +89,6 @@ export class Mesh<
      * @param target
      */
     getVertexPosition(index: number, target: Vector3): Vector3;
+
+    toJSON(meta?: JSONMeta): MeshJSON;
 }

three/src/objects/Points.d.ts

@@ -1,7 +1,4 @@
-import { BufferAttribute } from "../core/BufferAttribute.js";
 import { BufferGeometry, NormalOrGLBufferAttributes } from "../core/BufferGeometry.js";
-import { GLBufferAttribute } from "../core/GLBufferAttribute.js";
-import { InterleavedBufferAttribute } from "../core/InterleavedBufferAttribute.js";
 import { Object3D, Object3DEventMap } from "../core/Object3D.js";
 import { Material } from "../materials/Material.js";
 

three/src/objects/Skeleton.d.ts

@@ -1,7 +1,14 @@
-import { Matrix4 } from "../math/Matrix4.js";
+import { Matrix4, Matrix4Tuple } from "../math/Matrix4.js";
 import { DataTexture } from "../textures/DataTexture.js";
 import { Bone } from "./Bone.js";
 
+export interface SkeletonJSON {
+    metadata: { version: number; type: string; generator: string };
+    bones: string[];
+    boneInverses: Matrix4Tuple[];
+    uuid: string;
+}
+
 /**
  * Use an array of {@link Bone | bones} to create a {@link Skeleton} that can be used by a {@link THREE.SkinnedMesh | SkinnedMesh}.
  * @example
@@ -107,7 +114,7 @@ export class Skeleton {
      */
     dispose(): void;
 
-    toJSON(): unknown;
+    toJSON(): SkeletonJSON;
 
-    fromJSON(json: unknown, bones: Record<string, Bone>): void;
+    fromJSON(json: SkeletonJSON, bones: Record<string, Bone>): void;
 }

three/src/objects/SkinnedMesh.d.ts

@@ -1,14 +1,24 @@
 import { BindMode } from "../constants.js";
 import { BufferGeometry } from "../core/BufferGeometry.js";
-import { Object3DEventMap } from "../core/Object3D.js";
+import { JSONMeta, Object3DEventMap } from "../core/Object3D.js";
 import { Material } from "../materials/Material.js";
 import { Box3 } from "../math/Box3.js";
-import { Matrix4 } from "../math/Matrix4.js";
+import { Matrix4, Matrix4Tuple } from "../math/Matrix4.js";
 import { Sphere } from "../math/Sphere.js";
 import { Vector3 } from "../math/Vector3.js";
-import { Mesh } from "./Mesh.js";
+import { Mesh, MeshJSON, MeshJSONObject } from "./Mesh.js";
 import { Skeleton } from "./Skeleton.js";
 
+export interface SkinnedMeshJSONObject extends MeshJSONObject {
+    bindMode: BindMode;
+    bindMatrix: Matrix4Tuple;
+    skeleton?: string;
+}
+
+export interface SkinnedMeshJSON extends MeshJSON {
+    object: SkinnedMeshJSONObject;
+}
+
 /**
  * A mesh that has a {@link THREE.Skeleton | Skeleton} with {@link Bone | bones} that can then be used to animate the vertices of the geometry.
  * @example
@@ -145,4 +155,6 @@ export class SkinnedMesh<
      * @param vector
      */
     applyBoneTransform(index: number, vector: Vector3): Vector3;
+
+    toJSON(meta?: JSONMeta): SkinnedMeshJSON;
 }

three/{examples/jsm → src}/renderers/common/Animation.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="webxr" />
 import Info from "./Info.js";
 import Nodes from "./nodes/Nodes.js";
 declare class Animation {

three/{examples/jsm → src}/renderers/common/Attributes.d.ts

@@ -1,4 +1,6 @@
-import { BufferAttribute, InterleavedBuffer, InterleavedBufferAttribute } from "three";
+import { BufferAttribute } from "../../core/BufferAttribute.js";
+import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
+import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
 import Backend from "./Backend.js";
 import { AttributeType } from "./Constants.js";
 import DataMap from "./DataMap.js";
@@ -15,6 +17,6 @@ declare class Attributes extends DataMap<{
     constructor(backend: Backend);
     delete(attribute: BufferAttribute | InterleavedBufferAttribute): Data;
     update(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
-    _getBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute): InterleavedBuffer | BufferAttribute;
+    _getBufferAttribute(attribute: BufferAttribute | InterleavedBufferAttribute): BufferAttribute | InterleavedBuffer;
 }
 export default Attributes;

three/{examples/jsm → src}/renderers/common/Backend.d.ts

@@ -1,4 +1,4 @@
-import { CoordinateSystem } from "three";
+import { CoordinateSystem } from "../../constants.js";
 import Renderer from "./Renderer.js";
 
 export interface BackendParameters {

three/{examples/jsm → src}/renderers/common/Background.d.ts

@@ -1,4 +1,5 @@
-import { Mesh, Scene } from "three";
+import { Mesh } from "../../objects/Mesh.js";
+import { Scene } from "../../scenes/Scene.js";
 import DataMap from "./DataMap.js";
 import Nodes from "./nodes/Nodes.js";
 import RenderContext from "./RenderContext.js";

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

@@ -0,0 +1,9 @@
+import Binding from "./Binding.js";
+import NodeUniformsGroup from "./nodes/NodeUniformsGroup.js";
+declare class BindGroup {
+    name: string;
+    bindings: NodeUniformsGroup[] | Binding[];
+    id: number;
+    constructor(name?: string, bindings?: NodeUniformsGroup[]);
+}
+export default BindGroup;

three/{examples/jsm → src}/renderers/common/Bindings.d.ts

@@ -1,24 +1,20 @@
 import ComputeNode from "../../nodes/gpgpu/ComputeNode.js";
 import Attributes from "./Attributes.js";
 import Backend from "./Backend.js";
-import Binding from "./Binding.js";
+import BindGroup from "./BindGroup.js";
 import DataMap from "./DataMap.js";
 import Info from "./Info.js";
 import Nodes from "./nodes/Nodes.js";
 import Pipelines from "./Pipelines.js";
 import RenderObject from "./RenderObject.js";
 import Textures from "./Textures.js";
-interface Data {
-    bindings?: Binding[] | undefined;
+interface BindGroupData {
+    bindGroup?: BindGroup | undefined;
 }
 declare class Bindings extends DataMap<{
-    renderObject: {
-        key: RenderObject;
-        value: Data;
-    };
-    computeNode: {
-        key: ComputeNode;
-        value: Data;
+    bindGroup: {
+        key: BindGroup;
+        value: BindGroupData;
     };
 }> {
     backend: Backend;
@@ -35,11 +31,12 @@ declare class Bindings extends DataMap<{
         pipelines: Pipelines,
         info: Info,
     );
-    getForRender(renderObject: RenderObject): Binding[];
-    getForCompute(computeNode: ComputeNode): Binding[];
+    getForRender(renderObject: RenderObject): BindGroup[];
+    getForCompute(computeNode: ComputeNode): BindGroup[];
     updateForCompute(computeNode: ComputeNode): void;
     updateForRender(renderObject: RenderObject): void;
-    _init(bindings: Binding[]): void;
-    _update(object: ComputeNode | RenderObject, bindings: Binding[]): void;
+    _updateBindings(object: ComputeNode | RenderObject, bindings: BindGroup[]): void;
+    _init(bindGroup: BindGroup): void;
+    _update(object: ComputeNode | RenderObject, bindGroup: BindGroup, bindings: BindGroup[]): void;
 }
 export default Bindings;

three/{examples/jsm → src}/renderers/common/ClippingContext.d.ts

@@ -1,4 +1,9 @@
-import { Camera, Material, Matrix3, Matrix4, Plane, Vector4 } from "three";
+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";
 declare class ClippingContext {
     version: number;

three/{examples/jsm → src}/renderers/common/Color4.d.ts

@@ -1,4 +1,4 @@
-import { Color, ColorRepresentation } from "three";
+import { Color, ColorRepresentation } from "../../math/Color.js";
 declare class Color4 extends Color {
     a: number;
     constructor(color?: ColorRepresentation);

three/{examples/jsm → src}/renderers/common/CubeRenderTarget.d.ts

@@ -1,4 +1,7 @@
-import { RenderTargetOptions, Texture, WebGLCubeRenderTarget, WebGLRenderer } from "three";
+import { RenderTargetOptions } from "../../core/RenderTarget.js";
+import { WebGLCubeRenderTarget } from "../../renderers/WebGLCubeRenderTarget.js";
+import { Texture } from "../../textures/Texture.js";
+import { WebGLRenderer } from "../WebGLRenderer.js";
 declare class CubeRenderTarget extends WebGLCubeRenderTarget {
     readonly isCubeRenderTarget: true;
     constructor(size?: number, options?: RenderTargetOptions);

three/{examples/jsm → src}/renderers/common/Geometries.d.ts

@@ -1,4 +1,7 @@
-import { BufferAttribute, BufferGeometry } from "three";
+import { BufferAttribute } from "../../core/BufferAttribute.js";
+import { BufferGeometry } from "../../core/BufferGeometry.js";
+import { InterleavedBuffer } from "../../core/InterleavedBuffer.js";
+import { InterleavedBufferAttribute } from "../../core/InterleavedBufferAttribute.js";
 import Attributes from "./Attributes.js";
 import { AttributeType } from "./Constants.js";
 import DataMap from "./DataMap.js";
@@ -16,13 +19,13 @@ declare class Geometries extends DataMap<{
     attributes: Attributes;
     info: Info;
     wireframes: WeakMap<BufferGeometry, BufferAttribute>;
-    attributeCall: WeakMap<BufferAttribute, number>;
+    attributeCall: WeakMap<BufferAttribute | InterleavedBufferAttribute | InterleavedBuffer, number>;
     constructor(attributes: Attributes, info: Info);
     has(renderObject: RenderObject | BufferGeometry): boolean;
     updateForRender(renderObject: RenderObject): void;
     initGeometry(renderObject: RenderObject): void;
     updateAttributes(renderObject: RenderObject): void;
-    updateAttribute(attribute: BufferAttribute, type: AttributeType): void;
+    updateAttribute(attribute: BufferAttribute | InterleavedBufferAttribute, type: AttributeType): void;
     getIndex(renderObject: RenderObject): BufferAttribute | null;
 }
 export default Geometries;

three/{examples/jsm → src}/renderers/common/Info.d.ts

@@ -1,20 +1,25 @@
-import { Object3D } from "three";
+import { Object3D } from "../../core/Object3D.js";
 declare class Info {
     autoReset: boolean;
     frame: number;
     calls: number;
     render: {
         calls: number;
+        frameCalls: number;
         drawCalls: number;
         triangles: number;
         points: number;
         lines: number;
         timestamp: number;
+        previousFrameCalls: number;
+        timestampCalls: number;
     };
     compute: {
         calls: number;
-        computeCalls: number;
+        frameCalls: number;
         timestamp: number;
+        previousFrameCalls: number;
+        timestampCalls: number;
     };
     memory: {
         geometries: number;

three/{examples/jsm → src}/renderers/common/PostProcessing.d.ts

@@ -1,13 +1,21 @@
 import { Node } from "../../nodes/Nodes.js";
 import Renderer from "./Renderer.js";
 
-export default class PostProcessing {
+declare class PostProcessing {
     renderer: Renderer;
     outputNode: Node;
 
+    outputColorTransform: boolean;
+
+    needsUpdate: boolean;
+
     constructor(renderer: Renderer, outputNode?: Node);
 
     render(): void;
 
+    update(): void;
+
     renderAsync(): Promise<void>;
 }
+
+export default PostProcessing;

three/{examples/jsm/objects → src/renderers/common}/QuadMesh.d.ts

@@ -1,5 +1,7 @@
-import { Material, Mesh, OrthographicCamera } from "three";
-import Renderer from "../renderers/common/Renderer.js";
+import { OrthographicCamera } from "../../cameras/OrthographicCamera.js";
+import { Material } from "../../materials/Material.js";
+import { Mesh } from "../../objects/Mesh.js";
+import Renderer from "./Renderer.js";
 
 export default class QuadMesh extends Mesh {
     camera: OrthographicCamera;

three/{examples/jsm → src}/renderers/common/RenderBundle.d.ts

@@ -1,4 +1,5 @@
-import { Camera, Object3D } from "three";
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
 declare class RenderBundle {
     scene: Object3D;
     camera: Camera;

three/{examples/jsm → src}/renderers/common/RenderBundles.d.ts

@@ -1,4 +1,5 @@
-import { Camera, Object3D } from "three";
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
 import ChainMap from "./ChainMap.js";
 import RenderBundle from "./RenderBundle.js";
 declare class RenderBundles {

three/{examples/jsm → src}/renderers/common/RenderContext.d.ts

@@ -1,4 +1,7 @@
-import { DepthTexture, RenderTarget, Texture, Vector4 } from "three";
+import { RenderTarget } from "../../core/RenderTarget.js";
+import { Vector4 } from "../../math/Vector4.js";
+import { DepthTexture } from "../../textures/DepthTexture.js";
+import { Texture } from "../../textures/Texture.js";
 import ClippingContext from "./ClippingContext.js";
 declare class RenderContext {
     id: number;

three/{examples/jsm → src}/renderers/common/RenderContexts.d.ts

@@ -1,4 +1,6 @@
-import { Camera, RenderTarget, Scene } from "three";
+import { Camera } from "../../cameras/Camera.js";
+import { RenderTarget } from "../../core/RenderTarget.js";
+import { Scene } from "../../scenes/Scene.js";
 import ChainMap from "./ChainMap.js";
 import RenderContext from "./RenderContext.js";
 declare class RenderContexts {

three/{examples/jsm → src}/renderers/common/RenderList.d.ts

@@ -1,4 +1,8 @@
-import { BufferGeometry, Camera, GeometryGroup, Light, Material, Object3D } from "three";
+import { Camera } from "../../cameras/Camera.js";
+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";
 export interface Bundle {
     object: Object3D;

three/{examples/jsm → src}/renderers/common/RenderLists.d.ts

@@ -1,4 +1,5 @@
-import { Camera, Object3D } from "three";
+import { Camera } from "../../cameras/Camera.js";
+import { Object3D } from "../../core/Object3D.js";
 import ChainMap from "./ChainMap.js";
 import RenderList from "./RenderList.js";
 declare class RenderLists {