@unikia/upe-renderer 0.0.0-stage → 0.187.11

package/src/core/Raycaster.d.ts

@@ -0,0 +1,212 @@
+import { Camera } from "../cameras/Camera.js";
+import { Ray } from "../math/Ray.js";
+import { Vector2 } from "../math/Vector2.js";
+import { Vector3 } from "../math/Vector3.js";
+import { XRTargetRaySpace } from "../renderers/webxr/WebXRController.js";
+import { Layers } from "./Layers.js";
+import { Object3D } from "./Object3D.js";
+
+export interface Face {
+    a: number;
+    b: number;
+    c: number;
+    normal: Vector3;
+    materialIndex: number;
+}
+
+export interface Intersection<TIntersected extends Object3D = Object3D> {
+    /** Distance between the origin of the ray and the intersection */
+    distance: number;
+    /**
+     * Some objects (f.e. {@link Points}) provide the distance of the intersection to the nearest point on the ray. For
+     * other objects it will be `undefined`
+     */
+    distanceToRay?: number | undefined;
+    /** Point of intersection, in world coordinates */
+    point: Vector3;
+    index?: number | undefined;
+    /** Intersected face */
+    face?: Face | null | undefined;
+    /** Index of the intersected face */
+    faceIndex?: number | null | undefined;
+    barycoord?: Vector3 | null;
+    /** The intersected object */
+    object: TIntersected;
+    uv?: Vector2 | undefined;
+    uv1?: Vector2 | undefined;
+    normal?: Vector3;
+    /** The index number of the instance where the ray intersects the {@link THREE.InstancedMesh | InstancedMesh } */
+    instanceId?: number | undefined;
+    pointOnLine?: Vector3;
+    batchId?: number;
+}
+
+export interface RaycasterParameters {
+    Mesh: any;
+    Line: { threshold: number };
+    Line2?: { threshold: number };
+    LOD: any;
+    Points: { threshold: number };
+    Sprite: any;
+}
+
+/**
+ * This class is designed to assist with {@link https://en.wikipedia.org/wiki/Ray_casting | raycasting}
+ * @remarks
+ * Raycasting is used for mouse picking (working out what objects in the 3d space the mouse is over) amongst other things.
+ * @example
+ * ```typescript
+ * const raycaster = new THREE.Raycaster();
+ * const pointer = new THREE.Vector2();
+ *
+ * function onPointerMove(event) {
+ *     // calculate pointer position in normalized device coordinates (-1 to +1) for both components
+ *     pointer.x = (event.clientX / window.innerWidth) * 2 - 1;
+ *     pointer.y = -(event.clientY / window.innerHeight) * 2 + 1;
+ * }
+ *
+ * function render() {
+ *     // update the picking ray with the camera and pointer position
+ *     raycaster.setFromCamera(pointer, camera);
+ *     // calculate objects intersecting the picking ray
+ *     const intersects = raycaster.intersectObjects(scene.children);
+ *     for (let i = 0; i & lt; intersects.length; i++) {
+ *         intersects[i].object.material.color.set(0xff0000);
+ *     }
+ *     renderer.render(scene, camera);
+ * }
+ * window.addEventListener('pointermove', onPointerMove);
+ * window.requestAnimationFrame(render);
+ * ```
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_cubes | Raycasting to a Mesh}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_cubes_ortho | Raycasting to a Mesh in using an OrthographicCamera}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_buffergeometry | Raycasting to a Mesh with BufferGeometry}
+ * @see Example: {@link https://threejs.org/examples/#webgl_instancing_raycast | Raycasting to a InstancedMesh}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_lines | Raycasting to a Line}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_raycasting_points | Raycasting to Points}
+ * @see Example: {@link https://threejs.org/examples/#webgl_geometry_terrain_raycast | Terrain raycasting}
+ * @see Example: {@link https://threejs.org/examples/#webgl_interactive_voxelpainter | Raycasting to paint voxels}
+ * @see Example: {@link https://threejs.org/examples/#webgl_raycaster_texture | Raycast to a Texture}
+ * @see {@link https://threejs.org/docs/index.html#api/en/core/Raycaster | Official Documentation}
+ * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Raycaster.js | Source}
+ */
+export class Raycaster {
+    /**
+     * This creates a new {@link Raycaster} object.
+     * @param origin The origin vector where the ray casts from. Default `new Vector3()`
+     * @param direction The direction vector that gives direction to the ray. Should be normalized. Default `new Vector3(0, 0, -1)`
+     * @param near All results returned are further away than near. Near can't be negative. Expects a `Float`. Default `0`
+     * @param far All results returned are closer than far. Far can't be lower than near. Expects a `Float`. Default `Infinity`
+     */
+    constructor(origin?: Vector3, direction?: Vector3, near?: number, far?: number);
+
+    /**
+     * The {@link THREE.RaycasterRay | Ray} used for the raycasting.
+     */
+    ray: Ray;
+
+    /**
+     * The near factor of the raycaster. This value indicates which objects can be discarded based on the distance.
+     * This value shouldn't be negative and should be smaller than the far property.
+     * @remarks Expects a `Float`
+     * @defaultValue `0`
+     */
+    near: number;
+
+    /**
+     * The far factor of the raycaster. This value indicates which objects can be discarded based on the distance.
+     * This value shouldn't be negative and should be larger than the near property.
+     * @remarks Expects a `Float`
+     * @defaultValue `Infinity`
+     */
+    far: number;
+
+    /**
+     * The camera to use when raycasting against view-dependent objects such as billboarded objects like {@link THREE.Sprites | Sprites}.
+     * This field can be set manually or is set when calling  {@link setFromCamera}.
+     * @defaultValue `null`
+     */
+    camera: Camera;
+
+    /**
+     * Used by {@link Raycaster} to selectively ignore 3D objects when performing intersection tests.
+     * The following code example ensures that only 3D objects on layer `1` will be honored by the instance of Raycaster.
+     * ```
+     * raycaster.layers.set( 1 );
+     * object.layers.enable( 1 );
+     * ```
+     * @defaultValue `new THREE.Layers()` - See {@link THREE.Layers | Layers}.
+     */
+    layers: Layers;
+
+    /**
+     * An data object where threshold is the precision of the {@link Raycaster} when intersecting objects, in world units.
+     * @defaultValue `{ Mesh: {}, Line: { threshold: 1 }, LOD: {}, Points: { threshold: 1 }, Sprite: {} }`
+     */
+    params: RaycasterParameters;
+
+    /**
+     * Updates the ray with a new origin and direction
+     * @remarks
+     * Please note that this method only copies the values from the arguments.
+     * @param origin The origin vector where the ray casts from.
+     * @param direction The normalized direction vector that gives direction to the ray.
+     */
+    set(origin: Vector3, direction: Vector3): void;
+
+    /**
+     * Updates the ray with a new origin and direction.
+     * @param coords 2D coordinates of the mouse, in normalized device coordinates (NDC)---X and Y components should be between -1 and 1.
+     * @param camera camera from which the ray should originate
+     */
+    setFromCamera(coords: Vector2, camera: Camera): void;
+
+    /**
+     * Updates the ray with a new origin and direction.
+     * @param controller The controller to copy the position and direction from.
+     */
+    setFromXRController(controller: XRTargetRaySpace): this;
+
+    /**
+     * Checks all intersection between the ray and the object with or without the descendants
+     * @remarks Intersections are returned sorted by distance, closest first
+     * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
+     * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
+     * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
+     * intersections of the ray passing through the back of a face will not be detected
+     * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
+     * @see {@link intersectObjects | .intersectObjects()}.
+     * @param object The object to check for intersection with the ray.
+     * @param recursive If true, it also checks all descendants. Otherwise it only checks intersection with the object. Default `true`
+     * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
+     * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
+     * @returns An array of intersections is returned.
+     */
+    intersectObject<TIntersected extends Object3D>(
+        object: Object3D,
+        recursive?: boolean,
+        optionalTarget?: Array<Intersection<TIntersected>>,
+    ): Array<Intersection<TIntersected>>;
+
+    /**
+     * Checks all intersection between the ray and the objects with or without the descendants
+     * @remarks Intersections are returned sorted by distance, closest first
+     * @remarks Intersections are of the same form as those returned by {@link intersectObject | .intersectObject()}.
+     * @remarks {@link Raycaster} delegates to the {@link Object3D.raycast | raycast} method of the passed object, when evaluating whether the ray intersects the object or not
+     * This allows {@link THREE.Mesh | meshes} to respond differently to ray casting than {@link THREE.Line | lines} and {@link THREE.Points | pointclouds}.
+     * **Note** that for meshes, faces must be pointed towards the origin of the {@link Raycaster.ray | ray} in order to be detected;
+     * intersections of the ray passing through the back of a face will not be detected
+     * To raycast against both faces of an object, you'll want to set the {@link Mesh.material | material}'s {@link Material.side | side} property to `THREE.DoubleSide`.
+     * @see {@link intersectObject | .intersectObject()}.
+     * @param objects The objects to check for intersection with the ray.
+     * @param recursive If true, it also checks all descendants of the objects. Otherwise it only checks intersection with the objects. Default `true`
+     * @param optionalTarget Target to set the result. Otherwise a new {@link Array | Array} is instantiated.
+     * If set, you must clear this array prior to each call (i.e., array.length = 0;). Default `[]`
+     * @returns An array of intersections is returned.
+     */
+    intersectObjects<TIntersected extends Object3D>(
+        objects: Object3D[],
+        recursive?: boolean,
+        optionalTarget?: Array<Intersection<TIntersected>>,
+    ): Array<Intersection<TIntersected>>;
+}

package/src/core/Raycaster.js

@@ -0,0 +1,268 @@
+import { Matrix4 } from '../math/Matrix4.js';
+import { Ray } from '../math/Ray.js';
+import { Layers } from './Layers.js';
+import { error } from '../utils.js';
+
+const _matrix = /*@__PURE__*/ new Matrix4();
+
+/**
+ * This class is designed to assist with raycasting. Raycasting is used for
+ * mouse picking (working out what objects in the 3d space the mouse is over)
+ * amongst other things.
+ */
+class Raycaster {
+
+	/**
+	 * Constructs a new raycaster.
+	 *
+	 * @param {Vector3} origin - The origin vector where the ray casts from.
+	 * @param {Vector3} direction - The (normalized) direction vector that gives direction to the ray.
+	 * @param {number} [near=0] - All results returned are further away than near. Near can't be negative.
+	 * @param {number} [far=Infinity] - All results returned are closer than far. Far can't be lower than near.
+	 */
+	constructor( origin, direction, near = 0, far = Infinity ) {
+
+		/**
+		 * The ray used for raycasting.
+		 *
+		 * @type {Ray}
+		 */
+		this.ray = new Ray( origin, direction );
+
+		/**
+		 * All results returned are further away than near. Near can't be negative.
+		 *
+		 * @type {number}
+		 * @default 0
+		 */
+		this.near = near;
+
+		/**
+		 * All results returned are closer than far. Far can't be lower than near.
+		 *
+		 * @type {number}
+		 * @default Infinity
+		 */
+		this.far = far;
+
+		/**
+		 * The camera to use when raycasting against view-dependent objects such as
+		 * billboarded objects like sprites. This field can be set manually or
+		 * is set when calling `setFromCamera()`.
+		 *
+		 * @type {?Camera}
+		 * @default null
+		 */
+		this.camera = null;
+
+		/**
+		 * Allows to selectively ignore 3D objects when performing intersection tests.
+		 * The following code example ensures that only 3D objects on layer `1` will be
+		 * honored by raycaster.
+		 * ```js
+		 * raycaster.layers.set( 1 );
+		 * object.layers.enable( 1 );
+		 * ```
+		 *
+		 * @type {Layers}
+		 */
+		this.layers = new Layers();
+
+
+		/**
+		 * A parameter object that configures the raycasting. It has the structure:
+		 *
+		 * ```
+		 * {
+		 * 	Mesh: {},
+		 * 	Line: { threshold: 1 },
+		 * 	LOD: {},
+		 * 	Points: { threshold: 1 },
+		 * 	Sprite: {}
+		 * }
+		 * ```
+		 * Where `threshold` is the precision of the raycaster when intersecting objects, in world units.
+		 *
+		 * @type {Object}
+		 */
+		this.params = {
+			Mesh: {},
+			Line: { threshold: 1 },
+			LOD: {},
+			Points: { threshold: 1 },
+			Sprite: {}
+		};
+
+	}
+
+	/**
+	 * Updates the ray with a new origin and direction by copying the values from the arguments.
+	 *
+	 * @param {Vector3} origin - The origin vector where the ray casts from.
+	 * @param {Vector3} direction - The (normalized) direction vector that gives direction to the ray.
+	 */
+	set( origin, direction ) {
+
+		// direction is assumed to be normalized (for accurate distance calculations)
+
+		this.ray.set( origin, direction );
+
+	}
+
+	/**
+	 * Uses the given coordinates and camera to compute a new origin and direction for the internal ray.
+	 *
+	 * @param {Vector2} coords - 2D coordinates of the mouse, in normalized device coordinates (NDC).
+	 * X and Y components should be between `-1` and `1`.
+	 * @param {Camera} camera - The camera from which the ray should originate.
+	 */
+	setFromCamera( coords, camera ) {
+
+		if ( camera.isPerspectiveCamera ) {
+
+			this.ray.origin.setFromMatrixPosition( camera.matrixWorld );
+			this.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize();
+			this.camera = camera;
+
+		} else if ( camera.isOrthographicCamera ) {
+
+			this.ray.origin.set( coords.x, coords.y, camera.projectionMatrix.elements[ 14 ] ).unproject( camera ); // set origin in plane of camera
+			this.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld );
+			this.camera = camera;
+
+		} else {
+
+			error( 'Raycaster: Unsupported camera type: ' + camera.type );
+
+		}
+
+	}
+
+	/**
+	 * Uses the given WebXR controller to compute a new origin and direction for the internal ray.
+	 *
+	 * @param {WebXRController} controller - The controller to copy the position and direction from.
+	 * @return {Raycaster} A reference to this raycaster.
+	 */
+	setFromXRController( controller ) {
+
+		_matrix.identity().extractRotation( controller.matrixWorld );
+
+		this.ray.origin.setFromMatrixPosition( controller.matrixWorld );
+		this.ray.direction.set( 0, 0, - 1 ).applyMatrix4( _matrix );
+
+		return this;
+
+	}
+
+	/**
+	 * The intersection point of a raycaster intersection test.
+	 * @typedef {Object} Raycaster~Intersection
+	 * @property {number} distance - The distance from the ray's origin to the intersection point.
+	 * @property {number} distanceToRay -  Some 3D objects e.g. {@link Points} provide the distance of the
+	 * intersection to the nearest point on the ray. For other objects it will be `undefined`.
+	 * @property {Vector3} point - The intersection point, in world coordinates.
+	 * @property {Object} face - The face that has been intersected.
+	 * @property {number} faceIndex - The face index.
+	 * @property {Object3D} object - The 3D object that has been intersected.
+	 * @property {Vector2} uv - U,V coordinates at point of intersection.
+	 * @property {Vector2} uv1 - Second set of U,V coordinates at point of intersection.
+	 * @property {Vector3} normal - Interpolated normal vector at point of intersection.
+	 * @property {number} instanceId - The index number of the instance where the ray
+	 * intersects the {@link InstancedMesh}.
+	 * @property {number} batchId - The index number of the instance where the ray
+	 * intersects the {@link BatchedMesh}.
+	 */
+
+	/**
+	 * Checks all intersection between the ray and the object with or without the
+	 * descendants. Intersections are returned sorted by distance, closest first.
+	 *
+	 * `Raycaster` delegates to the `raycast()` method of the passed 3D object, when
+	 * evaluating whether the ray intersects the object or not. This allows meshes to respond
+	 * differently to ray casting than lines or points.
+	 *
+	 * Note that for meshes, faces must be pointed towards the origin of the ray in order
+	 * to be detected; intersections of the ray passing through the back of a face will not
+	 * be detected. To raycast against both faces of an object, you'll want to set  {@link Material#side}
+	 * to `THREE.DoubleSide`.
+	 *
+	 * Note that a ray hitting a triangle mesh exactly along an edge shared by two faces may be
+	 * reported by both faces, resulting in two coincident intersections (identical point and
+	 * distance) in the returned array.
+	 *
+	 * @param {Object3D} object - The 3D object to check for intersection with the ray.
+	 * @param {boolean} [recursive=true] - If set to `true`, it also checks all descendants.
+	 * Otherwise it only checks intersection with the object.
+	 * @param {Array<Raycaster~Intersection>} [intersects=[]] The target array that holds the result of the method.
+	 * @return {Array<Raycaster~Intersection>} An array holding the intersection points.
+	 */
+	intersectObject( object, recursive = true, intersects = [] ) {
+
+		intersect( object, this, intersects, recursive );
+
+		intersects.sort( ascSort );
+
+		return intersects;
+
+	}
+
+	/**
+	 * Checks all intersection between the ray and the objects with or without
+	 * the descendants. Intersections are returned sorted by distance, closest first.
+	 *
+	 * @param {Array<Object3D>} objects - The 3D objects to check for intersection with the ray.
+	 * @param {boolean} [recursive=true] - If set to `true`, it also checks all descendants.
+	 * Otherwise it only checks intersection with the object.
+	 * @param {Array<Raycaster~Intersection>} [intersects=[]] The target array that holds the result of the method.
+	 * @return {Array<Raycaster~Intersection>} An array holding the intersection points.
+	 */
+	intersectObjects( objects, recursive = true, intersects = [] ) {
+
+		for ( let i = 0, l = objects.length; i < l; i ++ ) {
+
+			intersect( objects[ i ], this, intersects, recursive );
+
+		}
+
+		intersects.sort( ascSort );
+
+		return intersects;
+
+	}
+
+}
+
+function ascSort( a, b ) {
+
+	return a.distance - b.distance;
+
+}
+
+function intersect( object, raycaster, intersects, recursive ) {
+
+	let propagate = true;
+
+	if ( object.layers.test( raycaster.layers ) ) {
+
+		const result = object.raycast( raycaster, intersects );
+
+		if ( result === false ) propagate = false;
+
+	}
+
+	if ( propagate === true && recursive === true ) {
+
+		const children = object.children;
+
+		for ( let i = 0, l = children.length; i < l; i ++ ) {
+
+			intersect( children[ i ], raycaster, intersects, true );
+
+		}
+
+	}
+
+}
+
+export { Raycaster };

package/src/core/RenderTarget.d.ts

@@ -0,0 +1,153 @@
+import { Vector4 } from "../math/Vector4.js";
+import { DepthTexture } from "../textures/DepthTexture.js";
+import { Texture, TextureParameters } from "../textures/Texture.js";
+import { EventDispatcher } from "./EventDispatcher.js";
+
+export interface RenderTargetOptions extends TextureParameters {
+    depthBuffer?: boolean | undefined; // true
+    stencilBuffer?: boolean | undefined; // false
+    resolveColorBuffer?: boolean | undefined; // true
+    resolveDepthBuffer?: boolean | undefined; // true
+    resolveStencilBuffer?: boolean | undefined; // true
+    storeMultisampledColorBuffer?: boolean | undefined; // true
+    storeMultisampledDepthBuffer?: boolean | undefined; // true
+    storeMultisampledStencilBuffer?: boolean | undefined; // true
+    depthTexture?: DepthTexture | null | undefined; // null
+    /**
+     * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
+     * @default 0
+     */
+    samples?: number | undefined;
+    count?: number | undefined;
+    depth?: number | undefined;
+    multiview?: boolean | undefined;
+    useArrayDepthTexture?: boolean | undefined;
+}
+
+export interface RenderTargetEventMap {
+    dispose: {};
+}
+
+export class RenderTarget<
+    TTexture extends Texture | Texture[] = Texture,
+    TEventMap extends RenderTargetEventMap = RenderTargetEventMap,
+> extends EventDispatcher<TEventMap> {
+    readonly isRenderTarget: true;
+
+    width: number;
+    height: number;
+    depth: number;
+
+    scissor: Vector4;
+    /**
+     * @default false
+     */
+    scissorTest: boolean;
+    viewport: Vector4;
+    textures: TTexture[];
+
+    /**
+     * @default true
+     */
+    depthBuffer: boolean;
+
+    /**
+     * @default false
+     */
+    stencilBuffer: boolean;
+
+    /**
+     * Whether to resolve the color buffer or not. When set to `false`, the color attachments do not receive the
+     * resolved (single-sampled) output of a render pass and the render target's textures are left untouched. The
+     * rendered content is then only accessible within the render pass itself.
+     *
+     * Only relevant for multisampled render targets.
+     * @default true
+     */
+    resolveColorBuffer: boolean;
+
+    /**
+     * Whether to resolve the depth buffer or not. When set to `false`, the depth texture does not receive the resolved
+     * depth output of a render pass which saves memory bandwidth. Use this setting when the depth data of a render pass
+     * are not required afterwards.
+     *
+     * Only relevant for multisampled render targets in WebGL. WebGPU does not support depth resolves; sampling the
+     * depth texture of a multisampled render target accesses the multisampled data directly, see
+     * {@link RenderTarget#storeMultisampledDepthBuffer}.
+     * @default true
+     */
+    resolveDepthBuffer: boolean;
+
+    /**
+     * Whether to resolve the stencil buffer or not. Analogous to {@link RenderTarget#resolveDepthBuffer} but for the
+     * stencil aspect.
+     * @default true
+     */
+    resolveStencilBuffer: boolean;
+
+    /**
+     * Whether to store the multisampled color buffer or not. When set to `false`, the multisampled data are discarded
+     * at the end of a render pass, right after they have been resolved. This saves memory bandwidth, especially on
+     * tile-based GPUs, and is the recommended setting for render targets that are fully redrawn each frame and whose
+     * output is only accessed via the resolved textures (e.g. scene passes in post-processing chains).
+     *
+     * Must be kept `true` when the multisampled data are needed after the render pass ends, e.g. when rendering into
+     * the target without clearing or when the scene contains transmissive objects which require a mid-pass framebuffer
+     * copy.
+     * @default true
+     */
+    storeMultisampledColorBuffer: boolean;
+
+    /**
+     * Whether to store the multisampled depth buffer or not. When set to `false`, the multisampled depth data are
+     * discarded at the end of a render pass which saves memory bandwidth.
+     *
+     * Must be kept `true` in WebGPU when the depth texture of a multisampled render target is sampled (e.g. by
+     * depth-based post-processing effects) since depth is read directly from the multisampled data.
+     * @default true
+     */
+    storeMultisampledDepthBuffer: boolean;
+
+    /**
+     * Whether to store the multisampled stencil buffer or not. Analogous to
+     * {@link RenderTarget#storeMultisampledDepthBuffer} but for the stencil aspect.
+     * @default true
+     */
+    storeMultisampledStencilBuffer: boolean;
+
+    /**
+     * Defines the count of MSAA samples. Can only be used with WebGL 2. Default is **0**.
+     * @default 0
+     */
+    samples: number;
+
+    /**
+     * Whether to this target is used in multiview rendering.
+     *
+     * @default false
+     */
+    multiview: boolean;
+
+    /**
+     * Whether to create the depth texture as an array texture for per-layer depth testing.
+     * This is separate from multiview so layered render targets can use array depth without
+     * the multiview extension.
+     *
+     * @type {boolean}
+     * @default false
+     */
+    useArrayDepthTexture: boolean;
+
+    constructor(width?: number, height?: number, options?: RenderTargetOptions);
+
+    get texture(): TTexture;
+    set texture(value: TTexture);
+
+    set depthTexture(current: DepthTexture | null);
+    get depthTexture(): DepthTexture | null;
+
+    setSize(width: number, height: number, depth?: number): void;
+    clone(): this;
+    copy(source: RenderTarget): this;
+    dispose(): void;
+}