@babylonjs/core 7.44.1 → 7.46.0

package/FrameGraph/frameGraphTextureManager.js

@@ -2,8 +2,10 @@ import { getDimensionsFromTextureSize, textureSizeIsObject } from "../Materials/
 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";
+import { FrameGraphRenderPass } from "./Passes/renderPass.js";
+import { Logger } from "../Misc/logger.js";
+import { GetTypeForDepthTexture, IsDepthTexture, HasStencilAspect } from "../Materials/Textures/textureHelper.functions.js";
 var FrameGraphTextureNamespace;
 (function (FrameGraphTextureNamespace) {
     FrameGraphTextureNamespace[FrameGraphTextureNamespace["Task"] = 0] = "Task";
@@ -31,6 +33,10 @@ export class FrameGraphTextureManager {
         this._historyTextures = new Map();
         /** @internal */
         this._isRecordingTask = false;
+        /**
+         * Gets or sets a boolean indicating if debug logs should be shown when applying texture allocation optimization (default: false)
+         */
+        this.showDebugLogsForTextureAllcationOptimization = false;
         this._addSystemTextures();
     }
     /**
@@ -276,12 +282,48 @@ export class FrameGraphTextureManager {
             height: Math.floor((height * screenHeight) / 100),
         };
     }
+    /**
+     * Calculates the total byte size of all textures used by the frame graph texture manager (including external textures)
+     * @param optimizedSize True if the calculation should not factor in aliased textures
+     * @param outputWidth The output width of the frame graph. Will be used to calculate the size of percentage-based textures
+     * @param outputHeight The output height of the frame graph. Will be used to calculate the size of percentage-based textures
+     * @returns The total size of all textures
+     */
+    computeTotalTextureSize(optimizedSize, outputWidth, outputHeight) {
+        let totalSize = 0;
+        this._textures.forEach((entry, handle) => {
+            if (handle === backbufferColorTextureHandle || handle === backbufferDepthStencilTextureHandle || entry.refHandle !== undefined) {
+                return;
+            }
+            if (optimizedSize && entry.aliasHandle !== undefined) {
+                return;
+            }
+            const options = entry.creationOptions;
+            const textureIndex = entry.textureIndex || 0;
+            const dimensions = options.sizeIsPercentage ? this.getAbsoluteDimensions(options.size, outputWidth, outputHeight) : getDimensionsFromTextureSize(options.size);
+            const blockInfo = FrameGraphTextureManager._GetTextureBlockInformation(options.options.types?.[textureIndex] ?? 0, options.options.formats[textureIndex]);
+            const textureByteSize = Math.ceil(dimensions.width / blockInfo.width) * Math.ceil(dimensions.height / blockInfo.height) * blockInfo.length;
+            let byteSize = textureByteSize;
+            if (options.options.createMipMaps) {
+                byteSize = Math.floor((byteSize * 4) / 3);
+            }
+            if ((options.options.samples || 1) > 1) {
+                // We need an additional texture in the case of MSAA
+                byteSize += textureByteSize;
+            }
+            totalSize += byteSize;
+        });
+        return totalSize;
+    }
     /** @internal */
     _dispose() {
         this._releaseTextures();
     }
     /** @internal */
-    _allocateTextures() {
+    _allocateTextures(tasks) {
+        if (tasks) {
+            this._optimizeTextureAllocation(tasks);
+        }
         this._textures.forEach((entry) => {
             if (!entry.texture) {
                 if (entry.refHandle !== undefined) {
@@ -297,32 +339,39 @@ export class FrameGraphTextureManager {
                     }
                 }
                 else if (entry.namespace !== FrameGraphTextureNamespace.External) {
-                    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);
+                    if (entry.aliasHandle !== undefined) {
+                        const aliasEntry = this._textures.get(entry.aliasHandle);
+                        entry.texture = aliasEntry.texture;
+                        entry.texture.incrementReferences();
+                    }
+                    else {
+                        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;
                     }
-                    entry.texture = internalTexture;
                 }
             }
             if (entry.texture && entry.refHandle === undefined) {
@@ -339,6 +388,11 @@ export class FrameGraphTextureManager {
     /** @internal */
     _releaseTextures(releaseAll = true) {
         this._textures.forEach((entry, handle) => {
+            if (entry.lifespan) {
+                entry.lifespan.firstTask = Number.MAX_VALUE;
+                entry.lifespan.lastTask = 0;
+            }
+            entry.aliasHandle = undefined;
             if (releaseAll || entry.namespace !== FrameGraphTextureNamespace.External) {
                 entry.debug?.dispose();
                 entry.debug = undefined;
@@ -450,6 +504,11 @@ export class FrameGraphTextureManager {
             },
             namespace,
             textureIndex,
+            textureDescriptionHash: this._createTextureDescriptionHash(creationOptions),
+            lifespan: {
+                firstTask: Number.MAX_VALUE,
+                lastTask: 0,
+            },
         };
         this._textures.set(handle, textureEntry);
         if (namespace === FrameGraphTextureNamespace.External) {
@@ -480,6 +539,138 @@ export class FrameGraphTextureManager {
         }
         return handle;
     }
+    _createTextureDescriptionHash(options) {
+        const hash = [];
+        hash.push(textureSizeIsObject(options.size) ? `${options.size.width}_${options.size.height}` : `${options.size}`);
+        hash.push(options.sizeIsPercentage ? "%" : "A");
+        hash.push(options.options.createMipMaps ? "M" : "N");
+        hash.push(options.options.samples ? `${options.options.samples}` : "S1");
+        hash.push(options.options.types ? options.options.types.join("_") : `${0}`);
+        hash.push(options.options.formats ? options.options.formats.join("_") : `${5}`);
+        hash.push(options.options.useSRGBBuffers ? options.options.useSRGBBuffers.join("_") : "false");
+        hash.push(options.options.creationFlags ? options.options.creationFlags.join("_") : "0");
+        return hash.join("_");
+    }
+    _optimizeTextureAllocation(tasks) {
+        this._computeTextureLifespan(tasks);
+        if (this.showDebugLogsForTextureAllcationOptimization) {
+            Logger.Log(`================== Optimization of texture allocation ==================`);
+        }
+        const cache = new Map();
+        const iterator = this._textures.keys();
+        for (let key = iterator.next(); key.done !== true; key = iterator.next()) {
+            const textureHandle = key.value;
+            const textureEntry = this._textures.get(textureHandle);
+            if (textureEntry.refHandle !== undefined || textureEntry.namespace === FrameGraphTextureNamespace.External || this._historyTextures.has(textureHandle)) {
+                continue;
+            }
+            const textureHash = textureEntry.textureDescriptionHash;
+            const textureLifespan = textureEntry.lifespan;
+            const cacheEntries = cache.get(textureHash);
+            if (cacheEntries) {
+                let cacheEntryFound = false;
+                for (const cacheEntry of cacheEntries) {
+                    const [sourceHandle, lifespanArray] = cacheEntry;
+                    let overlapped = false;
+                    for (const lifespan of lifespanArray) {
+                        if (lifespan.firstTask <= textureLifespan.lastTask && lifespan.lastTask >= textureLifespan.firstTask) {
+                            overlapped = true;
+                            break;
+                        }
+                    }
+                    if (!overlapped) {
+                        // No overlap between texture lifespan and all lifespans in the array, this texture can reuse the same entry cache
+                        if (this.showDebugLogsForTextureAllcationOptimization) {
+                            Logger.Log(`Texture ${textureHandle} (${textureEntry.name}) reuses cache entry ${sourceHandle}`);
+                        }
+                        lifespanArray.push(textureLifespan);
+                        textureEntry.aliasHandle = sourceHandle;
+                        cacheEntryFound = true;
+                        break;
+                    }
+                }
+                if (!cacheEntryFound) {
+                    cacheEntries.push([textureHandle, [textureLifespan]]);
+                }
+            }
+            else {
+                cache.set(textureHash, [[textureHandle, [textureLifespan]]]);
+            }
+        }
+    }
+    // Loop through all task/pass dependencies and compute the lifespan of each texture (that is, the first task/pass that uses it and the last task/pass that uses it)
+    _computeTextureLifespan(tasks) {
+        if (this.showDebugLogsForTextureAllcationOptimization) {
+            Logger.Log(`================== Dump of texture dependencies for all tasks/passes ==================`);
+        }
+        for (let t = 0; t < tasks.length; ++t) {
+            const task = tasks[t];
+            if (task.passes.length > 0) {
+                this._computeTextureLifespanForPasses(task, t, task.passes);
+            }
+            if (task.passesDisabled.length > 0) {
+                this._computeTextureLifespanForPasses(task, t, task.passesDisabled);
+            }
+            if (task.dependencies) {
+                if (this.showDebugLogsForTextureAllcationOptimization) {
+                    Logger.Log(`task#${t} (${task.name}), global dependencies`);
+                }
+                this._updateLifespan(t * 100 + 99, task.dependencies);
+            }
+        }
+        if (this.showDebugLogsForTextureAllcationOptimization) {
+            Logger.Log(`================== Texture lifespans ==================`);
+            const iterator = this._textures.keys();
+            for (let key = iterator.next(); key.done !== true; key = iterator.next()) {
+                const textureHandle = key.value;
+                const textureEntry = this._textures.get(textureHandle);
+                if (textureEntry.refHandle !== undefined || textureEntry.namespace === FrameGraphTextureNamespace.External || this._historyTextures.has(textureHandle)) {
+                    continue;
+                }
+                Logger.Log(`${textureHandle} (${textureEntry.name}): ${textureEntry.lifespan.firstTask} - ${textureEntry.lifespan.lastTask}`);
+            }
+        }
+    }
+    _computeTextureLifespanForPasses(task, taskIndex, passes) {
+        for (let p = 0; p < passes.length; ++p) {
+            const dependencies = new Set();
+            const pass = passes[p];
+            if (!FrameGraphRenderPass.IsRenderPass(pass)) {
+                continue;
+            }
+            pass.collectDependencies(dependencies);
+            if (this.showDebugLogsForTextureAllcationOptimization) {
+                Logger.Log(`task#${taskIndex} (${task.name}), pass#${p} (${pass.name})`);
+            }
+            this._updateLifespan(taskIndex * 100 + p, dependencies);
+        }
+    }
+    _updateLifespan(passOrderNum, dependencies) {
+        const iterator = dependencies.keys();
+        for (let key = iterator.next(); key.done !== true; key = iterator.next()) {
+            const textureHandle = key.value;
+            let textureEntry = this._textures.get(textureHandle);
+            if (!textureEntry) {
+                throw new Error(`FrameGraph._computeTextureLifespan: Texture handle "${textureHandle}" not found in the texture manager.`);
+            }
+            let handle = textureHandle;
+            while (textureEntry.refHandle !== undefined) {
+                handle = textureEntry.refHandle;
+                textureEntry = this._textures.get(handle);
+                if (!textureEntry) {
+                    throw new Error(`FrameGraph._computeTextureLifespan: Texture handle "${handle}" not found in the texture manager (source handle="${textureHandle}").`);
+                }
+            }
+            if (textureEntry.namespace === FrameGraphTextureNamespace.External || this._historyTextures.has(handle)) {
+                continue;
+            }
+            if (this.showDebugLogsForTextureAllcationOptimization) {
+                Logger.Log(`    ${handle} (${textureEntry.name})`);
+            }
+            textureEntry.lifespan.firstTask = Math.min(textureEntry.lifespan.firstTask, passOrderNum);
+            textureEntry.lifespan.lastTask = Math.max(textureEntry.lifespan.lastTask, passOrderNum);
+        }
+    }
     /**
      * Clones a texture options
      * @param options The options to clone
@@ -507,6 +698,156 @@ export class FrameGraphTextureManager {
                 labels: options.labels ? [...options.labels] : undefined,
             };
     }
+    /**
+     * Gets the texture block information.
+     * @param type Type of the texture.
+     * @param format Format of the texture.
+     * @returns The texture block information. You can calculate the byte size of the texture by doing: Math.ceil(width / blockInfo.width) * Math.ceil(height / blockInfo.height) * blockInfo.length
+     */
+    static _GetTextureBlockInformation(type, format) {
+        switch (format) {
+            case 15:
+                return { width: 1, height: 1, length: 2 };
+            case 16:
+                return { width: 1, height: 1, length: 3 };
+            case 13:
+                return { width: 1, height: 1, length: 4 };
+            case 14:
+                return { width: 1, height: 1, length: 4 };
+            case 18:
+                return { width: 1, height: 1, length: 5 };
+            case 19:
+                return { width: 1, height: 1, length: 1 };
+            case 36492:
+                return { width: 4, height: 4, length: 16 };
+            case 36495:
+                return { width: 4, height: 4, length: 16 };
+            case 36494:
+                return { width: 4, height: 4, length: 16 };
+            case 33779:
+                return { width: 4, height: 4, length: 16 };
+            case 33778:
+                return { width: 4, height: 4, length: 16 };
+            case 33777:
+            case 33776:
+                return { width: 4, height: 4, length: 8 };
+            case 37808:
+                return { width: 4, height: 4, length: 16 };
+            case 36196:
+            case 37492:
+                return { width: 4, height: 4, length: 8 };
+            case 37496:
+                return { width: 4, height: 4, length: 16 };
+        }
+        switch (type) {
+            case 3:
+            case 0:
+                switch (format) {
+                    case 6:
+                    case 8:
+                    case 0:
+                    case 1:
+                    case 2:
+                        return { width: 1, height: 1, length: 1 };
+                    case 7:
+                    case 9:
+                        return { width: 1, height: 1, length: 2 };
+                    case 4:
+                    case 10:
+                        return { width: 1, height: 1, length: 3 };
+                    case 11:
+                        return { width: 1, height: 1, length: 4 };
+                    default:
+                        return { width: 1, height: 1, length: 4 };
+                }
+            case 4:
+            case 5:
+                switch (format) {
+                    case 8:
+                        return { width: 1, height: 1, length: 2 };
+                    case 9:
+                        return { width: 1, height: 1, length: 4 };
+                    case 10:
+                        return { width: 1, height: 1, length: 6 };
+                    case 11:
+                        return { width: 1, height: 1, length: 8 };
+                    default:
+                        return { width: 1, height: 1, length: 8 };
+                }
+            case 6:
+            case 7: // Refers to UNSIGNED_INT
+                switch (format) {
+                    case 8:
+                        return { width: 1, height: 1, length: 4 };
+                    case 9:
+                        return { width: 1, height: 1, length: 8 };
+                    case 10:
+                        return { width: 1, height: 1, length: 12 };
+                    case 11:
+                        return { width: 1, height: 1, length: 16 };
+                    default:
+                        return { width: 1, height: 1, length: 16 };
+                }
+            case 1:
+                switch (format) {
+                    case 6:
+                        return { width: 1, height: 1, length: 4 };
+                    case 7:
+                        return { width: 1, height: 1, length: 8 };
+                    case 4:
+                        return { width: 1, height: 1, length: 12 };
+                    case 5:
+                        return { width: 1, height: 1, length: 16 };
+                    default:
+                        return { width: 1, height: 1, length: 16 };
+                }
+            case 2:
+                switch (format) {
+                    case 6:
+                        return { width: 1, height: 1, length: 2 };
+                    case 7:
+                        return { width: 1, height: 1, length: 4 };
+                    case 4:
+                        return { width: 1, height: 1, length: 6 };
+                    case 5:
+                        return { width: 1, height: 1, length: 8 };
+                    default:
+                        return { width: 1, height: 1, length: 8 };
+                }
+            case 10:
+                return { width: 1, height: 1, length: 2 };
+            case 13:
+                switch (format) {
+                    case 5:
+                    case 11:
+                        return { width: 1, height: 1, length: 4 };
+                    default:
+                        return { width: 1, height: 1, length: 4 };
+                }
+            case 14:
+                switch (format) {
+                    case 5:
+                    case 11:
+                        return { width: 1, height: 1, length: 4 };
+                    default:
+                        return { width: 1, height: 1, length: 4 };
+                }
+            case 8:
+                return { width: 1, height: 1, length: 2 };
+            case 9:
+                return { width: 1, height: 1, length: 2 };
+            case 11:
+                switch (format) {
+                    case 5:
+                        return { width: 1, height: 1, length: 4 };
+                    case 11:
+                        return { width: 1, height: 1, length: 4 };
+                    default:
+                        return { width: 1, height: 1, length: 4 };
+                }
+        }
+        return { width: 1, height: 1, length: 4 };
+    }
 }
 FrameGraphTextureManager._Counter = 2; // 0 and 1 are reserved for backbuffer textures
 //# sourceMappingURL=frameGraphTextureManager.js.map