* @type {boolean} * @readonly * @default true */ this.isRenderTarget = true; /** * The width of the render target. * * @type {number} * @default 1 */ this.width = width; /** * The height of the render target. * * @type {number} * @default 1 */ this.height = height; /** * The depth of the render target. * * @type {number} * @default 1 */ this.depth = options.depth; /** * A rectangular area inside the render target's viewport. Fragments that are * outside the area will be discarded. * * @type {Vector4} * @default (0,0,width,height) */ this.scissor = new Vector4( 0, 0, width, height ); /** * Indicates whether the scissor test should be enabled when rendering into * this render target or not. * * @type {boolean} * @default false */ this.scissorTest = false; /** * A rectangular area representing the render target's viewport. * * @type {Vector4} * @default (0,0,width,height) */ this.viewport = 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}