@babylonjs/core 7.35.1 → 7.36.0

package/FrameGraph/frameGraphTextureManager.js

@@ -1,7 +1,9 @@
-import { getDimensionsFromTextureSize } from "../Materials/Textures/textureCreationOptions.js";
+import { getDimensionsFromTextureSize, textureSizeIsObject } from "../Materials/Textures/textureCreationOptions.js";
 import { Texture } from "../Materials/Textures/texture.js";
 import { backbufferColorTextureHandle, backbufferDepthStencilTextureHandle } from "./frameGraphTypes.js";
 
+import { GetTypeForDepthTexture, IsDepthTexture, HasStencilAspect } from "../Materials/Textures/internalTexture.js";
+import { FrameGraphRenderTarget } from "./frameGraphRenderTarget.js";
 var FrameGraphTextureNamespace;
 (function (FrameGraphTextureNamespace) {
     FrameGraphTextureNamespace[FrameGraphTextureNamespace["Task"] = 0] = "Task";
@@ -9,18 +11,33 @@ var FrameGraphTextureNamespace;
     FrameGraphTextureNamespace[FrameGraphTextureNamespace["External"] = 2] = "External";
 })(FrameGraphTextureNamespace || (FrameGraphTextureNamespace = {}));
 /**
+ * Manages the textures used by a frame graph
  * @experimental
- * @internal
  */
 export class FrameGraphTextureManager {
-    constructor(_engine, _debugTextures = false, _scene) {
-        this._engine = _engine;
+    /**
+     * Constructs a new instance of the texture manager
+     * @param engine The engine to use
+     * @param _debugTextures If true, debug textures will be created so that they are visible in the inspector
+     * @param _scene The scene the manager belongs to
+     */
+    constructor(engine, _debugTextures = false, _scene) {
+        this.engine = engine;
         this._debugTextures = _debugTextures;
         this._scene = _scene;
+        /** @internal */
         this._textures = new Map();
+        /** @internal */
         this._historyTextures = new Map();
+        /** @internal */
+        this._isRecordingTask = false;
         this._addSystemTextures();
     }
+    /**
+     * Checks if a handle is a backbuffer handle (color or depth/stencil)
+     * @param handle The handle to check
+     * @returns True if the handle is a backbuffer handle
+     */
     isBackbuffer(handle) {
         if (handle === backbufferColorTextureHandle || handle === backbufferDepthStencilTextureHandle) {
             return true;
@@ -31,6 +48,11 @@ export class FrameGraphTextureManager {
         }
         return textureEntry.refHandle === backbufferColorTextureHandle || textureEntry.refHandle === backbufferDepthStencilTextureHandle;
     }
+    /**
+     * Checks if a handle is a backbuffer color handle
+     * @param handle The handle to check
+     * @returns True if the handle is a backbuffer color handle
+     */
     isBackbufferColor(handle) {
         if (handle === backbufferColorTextureHandle) {
             return true;
@@ -41,6 +63,11 @@ export class FrameGraphTextureManager {
         }
         return textureEntry.refHandle === backbufferColorTextureHandle;
     }
+    /**
+     * Checks if a handle is a backbuffer depth/stencil handle
+     * @param handle The handle to check
+     * @returns True if the handle is a backbuffer depth/stencil handle
+     */
     isBackbufferDepthStencil(handle) {
         if (handle === backbufferDepthStencilTextureHandle) {
             return true;
@@ -51,80 +78,217 @@ export class FrameGraphTextureManager {
         }
         return textureEntry.refHandle === backbufferDepthStencilTextureHandle;
     }
+    /**
+     * Checks if a handle is a history texture (or points to a history texture, for a dangling handle)
+     * @param handle The handle to check
+     * @returns True if the handle is a history texture, otherwise false
+     */
+    isHistoryTexture(handle) {
+        const entry = this._textures.get(handle);
+        if (!entry) {
+            return false;
+        }
+        handle = entry.refHandle ?? handle;
+        return this._historyTextures.has(handle);
+    }
+    /**
+     * Gets the creation options of a texture
+     * @param handle Handle of the texture
+     * @returns The creation options of the texture
+     */
     getTextureCreationOptions(handle) {
-        return this._textures.get(handle).creationOptions;
+        const entry = this._textures.get(handle);
+        const creationOptions = entry.creationOptions;
+        return {
+            size: textureSizeIsObject(creationOptions.size) ? { ...creationOptions.size } : creationOptions.size,
+            sizeIsPercentage: creationOptions.sizeIsPercentage,
+            options: this._cloneTextureOptions(creationOptions.options, entry.textureIndex),
+            isHistoryTexture: creationOptions.isHistoryTexture,
+        };
     }
+    /**
+     * Gets the description of a texture
+     * @param handle Handle of the texture
+     * @returns The description of the texture
+     */
+    getTextureDescription(handle) {
+        const creationOptions = this.getTextureCreationOptions(handle);
+        const size = !creationOptions.sizeIsPercentage
+            ? textureSizeIsObject(creationOptions.size)
+                ? creationOptions.size
+                : { width: creationOptions.size, height: creationOptions.size }
+            : this.getAbsoluteDimensions(creationOptions.size);
+        return {
+            size,
+            options: creationOptions.options,
+        };
+    }
+    /**
+     * Gets a texture handle or creates a new texture if the handle is not provided.
+     * If handle is not provided, newTextureName and creationOptions must be provided.
+     * @param handle If provided, will simply return the handle
+     * @param newTextureName Name of the new texture to create
+     * @param creationOptions Options to use when creating the new texture
+     * @returns The handle to the texture.
+     */
+    getTextureHandleOrCreateTexture(handle, newTextureName, creationOptions) {
+        if (handle === undefined) {
+            if (newTextureName === undefined || creationOptions === undefined) {
+                throw new Error("getTextureHandleOrCreateTexture: Either handle or newTextureName and creationOptions must be provided.");
+            }
+            return this.createRenderTargetTexture(newTextureName, creationOptions);
+        }
+        return handle;
+    }
+    /**
+     * Gets a texture from a handle.
+     * Note that if the texture is a history texture, the read texture for the current frame will be returned.
+     * @param handle The handle of the texture
+     * @returns The texture or null if not found
+     */
     getTextureFromHandle(handle) {
         const historyEntry = this._historyTextures.get(handle);
         if (historyEntry) {
-            return historyEntry.textures[historyEntry.index ^ 1]; // get the read texture
+            return historyEntry.textures[historyEntry.index ^ 1]; // gets the read texture
         }
         return this._textures.get(handle).texture;
     }
+    /**
+     * Imports a texture into the texture manager
+     * @param name Name of the texture
+     * @param texture Texture to import
+     * @param handle Existing handle to use for the texture. If not provided (default), a new handle will be created.
+     * @returns The handle to the texture
+     */
     importTexture(name, texture, handle) {
-        const internalTexture = texture.texture;
-        if (!internalTexture) {
-            throw new Error("importTexture: Texture must have an internal texture to be imported");
-        }
         if (handle !== undefined) {
             this._freeEntry(handle);
         }
         const creationOptions = {
             size: { width: texture.width, height: texture.height },
+            sizeIsPercentage: false,
+            isHistoryTexture: false,
             options: {
-                generateMipMaps: internalTexture.generateMipMaps,
-                generateDepthBuffer: texture._generateDepthBuffer,
-                generateStencilBuffer: texture._generateStencilBuffer,
-                samples: internalTexture.samples,
-                label: internalTexture.label,
-                types: [internalTexture.type],
-                samplingModes: [internalTexture.samplingMode],
-                formats: [internalTexture.format],
-                targetTypes: [
-                    internalTexture.isCube
-                        ? 34067
-                        : internalTexture.is3D
-                            ? 32879
-                            : internalTexture.is2DArray
-                                ? 35866
-                                : 3553,
-                ],
-                useSRGBBuffers: [internalTexture._useSRGBBuffer],
-                labels: internalTexture.label ? [internalTexture.label] : undefined,
+                createMipMaps: texture.generateMipMaps,
+                samples: texture.samples,
+                types: [texture.type],
+                formats: [texture.format],
+                useSRGBBuffers: [texture._useSRGBBuffer],
+                creationFlags: [texture._creationFlags],
+                labels: texture.label ? [texture.label] : ["imported"],
             },
-            sizeIsPercentage: false,
         };
-        return this._createHandleForTexture(name, texture, creationOptions, FrameGraphTextureNamespace.External, false, handle);
+        return this._createHandleForTexture(name, texture, creationOptions, FrameGraphTextureNamespace.External, handle);
+    }
+    /**
+     * Creates a new render target texture
+     * If multiple textures are described in FrameGraphTextureCreationOptions, the handle of the first texture is returned, handle+1 is the handle of the second texture, etc.
+     * @param name Name of the texture
+     * @param creationOptions Options to use when creating the texture
+     * @param handle Existing handle to use for the texture. If not provided (default), a new handle will be created.
+     * @returns The handle to the texture
+     */
+    createRenderTargetTexture(name, creationOptions, handle) {
+        return this._createHandleForTexture(name, null, {
+            size: textureSizeIsObject(creationOptions.size) ? { ...creationOptions.size } : creationOptions.size,
+            sizeIsPercentage: creationOptions.sizeIsPercentage,
+            isHistoryTexture: creationOptions.isHistoryTexture,
+            options: this._cloneTextureOptions(creationOptions.options),
+        }, this._isRecordingTask ? FrameGraphTextureNamespace.Task : FrameGraphTextureNamespace.Graph, handle);
     }
-    createRenderTargetTexture(name, taskNamespace, creationOptions, multiTargetMode = false, handle) {
-        return this._createHandleForTexture(name, null, creationOptions, taskNamespace ? FrameGraphTextureNamespace.Task : FrameGraphTextureNamespace.Graph, multiTargetMode, handle);
+    /**
+     * Creates a (frame graph) render target wrapper
+     * Note that renderTargets or renderTargetDepth can be undefined, but not both at the same time!
+     * @param name Name of the render target wrapper
+     * @param renderTargets Render target handles (textures) to use
+     * @param renderTargetDepth Render target depth handle (texture) to use
+     * @returns The created render target wrapper
+     */
+    createRenderTarget(name, renderTargets, renderTargetDepth) {
+        const renderTarget = new FrameGraphRenderTarget(name, this, renderTargets, renderTargetDepth);
+        const rtw = renderTarget.renderTargetWrapper;
+        if (rtw !== undefined && renderTargets) {
+            const handles = Array.isArray(renderTargets) ? renderTargets : [renderTargets];
+            for (let i = 0; i < handles.length; i++) {
+                let handle = handles[i];
+                handle = this._textures.get(handle)?.refHandle ?? handle;
+                const historyEntry = this._historyTextures.get(handle);
+                if (historyEntry) {
+                    historyEntry.references.push({ renderTargetWrapper: rtw, textureIndex: i });
+                    rtw.setTexture(historyEntry.textures[historyEntry.index], i, false);
+                }
+            }
+        }
+        return renderTarget;
+    }
+    /**
+     * Creates a handle which is not associated with any texture.
+     * Call resolveDanglingHandle to associate the handle with a valid texture handle.
+     * @returns The dangling handle
+     */
+    createDanglingHandle() {
+        return FrameGraphTextureManager._Counter++;
+    }
+    /**
+     * Associates a texture with a dangling handle
+     * @param danglingHandle The dangling handle
+     * @param handle The handle to associate with the dangling handle (if not provided, a new texture handle will be created, using the newTextureName and creationOptions parameters)
+     * @param newTextureName The name of the new texture to create (if handle is not provided)
+     * @param creationOptions The options to use when creating the new texture (if handle is not provided)
+     */
+    resolveDanglingHandle(danglingHandle, handle, newTextureName, creationOptions) {
+        if (handle === undefined) {
+            if (newTextureName === undefined || creationOptions === undefined) {
+                throw new Error("resolveDanglingHandle: Either handle or newTextureName and creationOptions must be provided.");
+            }
+            this.createRenderTargetTexture(newTextureName, creationOptions, danglingHandle);
+            return;
+        }
+        const textureEntry = this._textures.get(handle);
+        if (textureEntry === undefined) {
+            throw new Error(`resolveDanglingHandle: Handle ${handle} does not exist!`);
+        }
+        this._textures.set(danglingHandle, {
+            texture: textureEntry.texture,
+            refHandle: handle,
+            name: textureEntry.name,
+            creationOptions: {
+                size: { ...textureEntry.creationOptions.size },
+                options: this._cloneTextureOptions(textureEntry.creationOptions.options),
+                sizeIsPercentage: textureEntry.creationOptions.sizeIsPercentage,
+                isHistoryTexture: false,
+            },
+            namespace: textureEntry.namespace,
+            textureIndex: textureEntry.textureIndex,
+        });
     }
-    getAbsoluteDimensions(size, screenWidth = this._engine.getRenderWidth(true), screenHeight = this._engine.getRenderHeight(true)) {
+    /**
+     * Gets the absolute dimensions of a texture.
+     * @param size The size of the texture. Width and height must be expressed as a percentage of the screen size (100=100%)!
+     * @param screenWidth The width of the screen (default: the width of the rendering canvas)
+     * @param screenHeight The height of the screen (default: the height of the rendering canvas)
+     * @returns The absolute dimensions of the texture
+     */
+    getAbsoluteDimensions(size, screenWidth = this.engine.getRenderWidth(true), screenHeight = this.engine.getRenderHeight(true)) {
         const { width, height } = getDimensionsFromTextureSize(size);
         return {
             width: Math.floor((width * screenWidth) / 100),
             height: Math.floor((height * screenHeight) / 100),
         };
     }
-    updateHistoryTextures() {
-        this._historyTextures.forEach((entry) => {
-            entry.index = entry.index ^ 1;
-            for (const refHandle of entry.refHandles) {
-                const textureEntry = this._textures.get(refHandle);
-                textureEntry.texture = entry.textures[entry.index];
-            }
-        });
+    /** @internal */
+    _dispose() {
+        this._releaseTextures();
     }
-    dispose() {
-        this.releaseTextures();
-    }
-    allocateTextures() {
+    /** @internal */
+    _allocateTextures() {
         this._textures.forEach((entry) => {
             if (!entry.texture) {
                 if (entry.refHandle !== undefined) {
+                    // entry is a dangling handle which has been resolved to point to refHandle
+                    // We simply update the texture to point to the refHandle texture
                     const refEntry = this._textures.get(entry.refHandle);
                     entry.texture = refEntry.texture;
-                    entry.texture?.texture?.incrementReferences();
                     if (refEntry.refHandle === backbufferColorTextureHandle) {
                         entry.refHandle = backbufferColorTextureHandle;
                     }
@@ -133,31 +297,32 @@ export class FrameGraphTextureManager {
                     }
                 }
                 else if (entry.namespace !== FrameGraphTextureNamespace.External) {
-                    if (entry.parentHandle !== undefined) {
-                        const creationOptions = entry.creationOptions;
-                        const size = creationOptions.sizeIsPercentage ? this.getAbsoluteDimensions(creationOptions.size) : creationOptions.size;
-                        const parentEntry = this._textures.get(entry.parentHandle);
-                        const parentInternalTexture = parentEntry.texture.textures[entry.parentTextureIndex];
-                        const creationOptionsForTexture = {
-                            createMipMaps: creationOptions.options.createMipMaps,
-                            generateMipMaps: creationOptions.options.generateMipMaps,
-                            generateDepthBuffer: creationOptions.options.generateDepthBuffer,
-                            generateStencilBuffer: creationOptions.options.generateStencilBuffer,
-                            samples: creationOptions.options.samples,
-                            type: creationOptions.options.types[0],
-                            format: creationOptions.options.formats[0],
-                            useSRGBBuffer: creationOptions.options.useSRGBBuffers[0],
-                            colorAttachment: parentInternalTexture,
-                            label: creationOptions.options.label,
-                        };
-                        entry.texture = this._engine.createRenderTargetTexture(size, creationOptionsForTexture);
-                        parentInternalTexture.incrementReferences();
-                    }
-                    else {
-                        const creationOptions = entry.creationOptions;
-                        const size = creationOptions.sizeIsPercentage ? this.getAbsoluteDimensions(creationOptions.size) : creationOptions.size;
-                        entry.texture = this._engine.createMultipleRenderTarget(size, creationOptions.options, false);
+                    const creationOptions = entry.creationOptions;
+                    const size = creationOptions.sizeIsPercentage ? this.getAbsoluteDimensions(creationOptions.size) : creationOptions.size;
+                    const textureIndex = entry.textureIndex || 0;
+                    const internalTextureCreationOptions = {
+                        createMipMaps: creationOptions.options.createMipMaps,
+                        samples: creationOptions.options.samples,
+                        type: creationOptions.options.types?.[textureIndex],
+                        format: creationOptions.options.formats?.[textureIndex],
+                        useSRGBBuffer: creationOptions.options.useSRGBBuffers?.[textureIndex],
+                        creationFlags: creationOptions.options.creationFlags?.[textureIndex],
+                        label: creationOptions.options.labels?.[textureIndex] ?? `${entry.name}${textureIndex > 0 ? "#" + textureIndex : ""}`,
+                        samplingMode: 1,
+                        createMSAATexture: creationOptions.options.samples > 1,
+                    };
+                    const isDepthTexture = IsDepthTexture(internalTextureCreationOptions.format);
+                    const hasStencil = HasStencilAspect(internalTextureCreationOptions.format);
+                    const source = isDepthTexture && hasStencil
+                        ? 12 /* InternalTextureSource.DepthStencil */
+                        : isDepthTexture || hasStencil
+                            ? 14 /* InternalTextureSource.Depth */
+                            : 5 /* InternalTextureSource.RenderTarget */;
+                    const internalTexture = this.engine._createInternalTexture(size, internalTextureCreationOptions, false, source);
+                    if (isDepthTexture) {
+                        internalTexture.type = GetTypeForDepthTexture(internalTexture.format);
                     }
+                    entry.texture = internalTexture;
                 }
             }
             if (entry.texture && entry.refHandle === undefined) {
@@ -171,34 +336,8 @@ export class FrameGraphTextureManager {
             }
         });
     }
-    createDanglingHandle() {
-        return FrameGraphTextureManager._Counter++;
-    }
-    resolveDanglingHandle(danglingHandle, handle) {
-        const textureEntry = this._textures.get(handle);
-        if (textureEntry === undefined) {
-            throw new Error(`resolveDanglingHandle: Handle ${handle} does not exist!`);
-        }
-        this._textures.set(danglingHandle, {
-            texture: textureEntry.texture,
-            refHandle: handle,
-            name: textureEntry.name,
-            creationOptions: {
-                size: { ...textureEntry.creationOptions.size },
-                options: { ...textureEntry.creationOptions.options, label: textureEntry.name },
-                sizeIsPercentage: textureEntry.creationOptions.sizeIsPercentage,
-                isHistoryTexture: false,
-            },
-            namespace: textureEntry.namespace,
-            parentHandle: textureEntry.parentHandle,
-            parentTextureIndex: textureEntry.parentTextureIndex,
-        });
-        const historyEntry = this._historyTextures.get(handle);
-        if (historyEntry) {
-            historyEntry.refHandles.push(danglingHandle);
-        }
-    }
-    releaseTextures(releaseAll = true) {
+    /** @internal */
+    _releaseTextures(releaseAll = true) {
         this._textures.forEach((entry, handle) => {
             if (releaseAll || entry.namespace !== FrameGraphTextureNamespace.External) {
                 entry.debug?.dispose();
@@ -224,14 +363,34 @@ export class FrameGraphTextureManager {
             this._addSystemTextures();
         }
     }
+    /** @internal */
+    _updateHistoryTextures() {
+        this._historyTextures.forEach((entry) => {
+            entry.index = entry.index ^ 1;
+            const currentTexture = entry.textures[entry.index];
+            if (currentTexture) {
+                for (const { renderTargetWrapper, textureIndex } of entry.references) {
+                    renderTargetWrapper.setTexture(currentTexture, textureIndex, false);
+                }
+            }
+        });
+    }
     _addSystemTextures() {
-        const size = { width: this._engine.getRenderWidth(true), height: this._engine.getRenderHeight(true) };
+        const size = { width: this.engine.getRenderWidth(true), height: this.engine.getRenderHeight(true) };
         this._textures.set(backbufferColorTextureHandle, {
             name: "backbuffer color",
             texture: null,
             creationOptions: {
                 size,
-                options: {},
+                options: {
+                    createMipMaps: false,
+                    samples: this.engine.getCreationOptions().antialias ? 4 : 1,
+                    types: [0], // todo? get from engine
+                    formats: [5], // todo? get from engine
+                    useSRGBBuffers: [false],
+                    creationFlags: [0],
+                    labels: ["backbuffer color"],
+                },
                 sizeIsPercentage: false,
             },
             namespace: FrameGraphTextureNamespace.External,
@@ -241,19 +400,27 @@ export class FrameGraphTextureManager {
             texture: null,
             creationOptions: {
                 size,
-                options: {},
+                options: {
+                    createMipMaps: false,
+                    samples: this.engine.getCreationOptions().antialias ? 4 : 1,
+                    types: [0], // todo? get from engine
+                    formats: [16], // todo? get from engine
+                    useSRGBBuffers: [false],
+                    creationFlags: [0],
+                    labels: ["backbuffer depth/stencil"],
+                },
                 sizeIsPercentage: false,
             },
             namespace: FrameGraphTextureNamespace.External,
         });
     }
     _createDebugTexture(name, texture) {
-        if (!this._debugTextures || !this._scene) {
+        if (!this._debugTextures) {
             return;
         }
         const textureDebug = new Texture(null, this._scene);
         textureDebug.name = name;
-        textureDebug._texture = texture.texture || texture._depthStencilTexture;
+        textureDebug._texture = texture;
         textureDebug._texture.incrementReferences();
         return textureDebug;
     }
@@ -264,21 +431,22 @@ export class FrameGraphTextureManager {
             this._textures.delete(handle);
         }
     }
-    _createHandleForTexture(name, texture, creationOptions, namespace, multiTargetMode = false, handle, parentHandle, parentTextureIndex) {
+    _createHandleForTexture(name, texture, creationOptions, namespace, handle, textureIndex) {
         handle = handle ?? FrameGraphTextureManager._Counter++;
-        const textureName = creationOptions.isHistoryTexture ? `${name} - ping` : name;
+        textureIndex = textureIndex || 0;
+        const textureName = creationOptions.isHistoryTexture ? `${name} ping` : name;
+        const label = creationOptions.options.labels?.[textureIndex] ?? "";
         const textureEntry = {
             texture,
-            name: textureName,
+            name: `${textureName}${label ? " " + label : ""}`,
             creationOptions: {
-                size: getDimensionsFromTextureSize(creationOptions.size),
-                options: { ...creationOptions.options, label: textureName },
+                size: textureSizeIsObject(creationOptions.size) ? creationOptions.size : { width: creationOptions.size, height: creationOptions.size },
+                options: creationOptions.options,
                 sizeIsPercentage: creationOptions.sizeIsPercentage,
                 isHistoryTexture: creationOptions.isHistoryTexture,
             },
             namespace,
-            parentHandle,
-            parentTextureIndex,
+            textureIndex,
         };
         this._textures.set(handle, textureEntry);
         if (namespace === FrameGraphTextureNamespace.External) {
@@ -291,31 +459,45 @@ export class FrameGraphTextureManager {
                 sizeIsPercentage: textureEntry.creationOptions.sizeIsPercentage,
                 isHistoryTexture: false,
             };
-            const pongTexture = this._createHandleForTexture(`${name} - pong`, null, pongCreationOptions, namespace, false);
-            this._historyTextures.set(handle, { textures: [null, null], handles: [handle, pongTexture], index: 0, refHandles: [] });
+            const pongTexture = this._createHandleForTexture(`${name} pong`, null, pongCreationOptions, namespace);
+            this._historyTextures.set(handle, { textures: [null, null], handles: [handle, pongTexture], index: 0, references: [] });
             return handle;
         }
-        if (multiTargetMode) {
-            const textureCount = creationOptions.options.textureCount ?? 1;
-            for (let i = 0; i < textureCount; i++) {
-                const label = creationOptions.options.labels?.[i] ?? `${i}`;
-                const textureName = `${name} - ${label}`;
-                const creationOptionsForTexture = {
-                    size: getDimensionsFromTextureSize(creationOptions.size),
-                    options: {
-                        ...creationOptions.options,
-                        formats: [creationOptions.options.formats[i]],
-                        types: [creationOptions.options.types[i]],
-                        textureCount: 1,
-                    },
-                    sizeIsPercentage: creationOptions.sizeIsPercentage,
-                };
-                this._createHandleForTexture(textureName, null, creationOptionsForTexture, namespace, false, handle + i + 1, handle, i);
+        if (creationOptions.options.types && creationOptions.options.types.length > 1 && textureIndex === 0) {
+            const textureCount = creationOptions.options.types.length;
+            const creationOptionsForTexture = {
+                size: textureSizeIsObject(creationOptions.size) ? creationOptions.size : { width: creationOptions.size, height: creationOptions.size },
+                options: creationOptions.options,
+                sizeIsPercentage: creationOptions.sizeIsPercentage,
+            };
+            for (let i = 1; i < textureCount; i++) {
+                this._createHandleForTexture(textureName, null, creationOptionsForTexture, namespace, handle + i, i);
             }
-            FrameGraphTextureManager._Counter += textureCount;
+            FrameGraphTextureManager._Counter += textureCount - 1;
         }
         return handle;
     }
+    _cloneTextureOptions(options, textureIndex) {
+        return textureIndex !== undefined
+            ? {
+                createMipMaps: options.createMipMaps,
+                samples: options.samples,
+                types: options.types ? [options.types[textureIndex]] : undefined,
+                formats: options.formats ? [options.formats[textureIndex]] : undefined,
+                useSRGBBuffers: options.useSRGBBuffers ? [options.useSRGBBuffers[textureIndex]] : undefined,
+                creationFlags: options.creationFlags ? [options.creationFlags[textureIndex]] : undefined,
+                labels: options.labels ? [options.labels[textureIndex]] : undefined,
+            }
+            : {
+                createMipMaps: options.createMipMaps,
+                samples: options.samples,
+                types: options.types ? [...options.types] : undefined,
+                formats: options.formats ? [...options.formats] : undefined,
+                useSRGBBuffers: options.useSRGBBuffers ? [...options.useSRGBBuffers] : undefined,
+                creationFlags: options.creationFlags ? [...options.creationFlags] : undefined,
+                labels: options.labels ? [...options.labels] : undefined,
+            };
+    }
 }
 FrameGraphTextureManager._Counter = 2; // 0 and 1 are reserved for backbuffer textures
 //# sourceMappingURL=frameGraphTextureManager.js.map