port = new Vector4( 0, 0, width, height ); /** * An array of textures. Each color attachment is represented as a separate texture. * Has at least a single entry for the default color attachment. * * @type {Array} */ this.textures = []; const image = { width: width, height: height, depth: options.depth }; const texture = new Texture( image ); const count = options.count; for ( let i = 0; i < count; i ++ ) { this.textures[ i ] = texture.clone(); this.textures[ i ].isRenderTargetTexture = true; this.textures[ i ].renderTarget = this; } this._setTextureOptions( options ); /** * Whether to allocate a depth buffer or not. * * @type {boolean} * @default true */ this.depthBuffer = options.depthBuffer; /** * Whether to allocate a stencil buffer or not. * * @type {boolean} * @default false */ this.stencilBuffer = options.stencilBuffer; /** * 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. * * @type {boolean} * @default true */ this.resolveColorBuffer = options.resolveColorBuffer; /** * 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}. * * @type {boolean} * @default true */ this.resolveDepthBuffer = options.resolveDepthBuffer; /** * Whether to resolve the stencil buffer or not. Analogous to * {@link RenderTarget#resolveDepthBuffer} but for the stencil aspect. * * @type {boolean} * @default true */ this.resolveStencilBuffer = options.resolveStencilBuffer; /** * 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. * * @type {boolean} * @default true */ this.storeMultisampledColorBuffer = options.storeMultisampledColorBuffer; /** * 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. * * @type {boolean} * @default true */ this.storeMultisampledDepthBuffer = options.storeMultisampledDepthBuffer; /** * Whether to store the multisampled stencil buffer or not. Analogous to * {@link RenderTarget#storeMultisampledDepthBuffer} but for the stencil aspect. * * @type {boolean} * @default true */ this.storeMultisampledStencilBuffer = options.storeMultisampledStencilBuffer; this._depthTexture = null; this.depthTexture = options.depthTexture; /** * The number of MSAA samples. * * A value of `0` disables MSAA. * * @type {number} * @default 0 */ this.samples = options.samples; /** * Whether to this target is used in multiview rendering. * * @type {boolean} * @default false */ this.multiview = options.multiview; /** * 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 */ this.useArrayDepthTexture = options.useArrayDepthTexture; } _setTextureOptions( options = {} ) { const values = { minFilter: LinearFilter, generateMipmaps: false, flipY: false, internalFormat: null }; if ( options.mapping !== undefined ) values.m