@babylonjs/core 7.35.2 → 7.37.0

package/Engines/thinEngine.js

@@ -1,4 +1,4 @@
-import { createPipelineContext, createRawShaderProgram, createShaderProgram, _finalizePipelineContext, _preparePipelineContext, _setProgram, _executeWhenRenderingStateIsCompiled, getStateObject, _createShaderProgram, deleteStateObject, } from "./thinEngine.functions.js";
+import { createPipelineContext, createRawShaderProgram, createShaderProgram, _finalizePipelineContext, _preparePipelineContext, _setProgram, _executeWhenRenderingStateIsCompiled, getStateObject, _createShaderProgram, deleteStateObject, _isRenderingStateCompiled, } from "./thinEngine.functions.js";
 import { IsWrapper } from "../Materials/drawWrapper.functions.js";
 import { Logger } from "../Misc/logger.js";
 import { IsWindowObjectExist } from "../Misc/domManagement.js";
@@ -9,7 +9,7 @@ import { GetExponentOfTwo } from "../Misc/tools.functions.js";
 import { AbstractEngine } from "./abstractEngine.js";
 
 import { WebGLHardwareTexture } from "./WebGL/webGLHardwareTexture.js";
-import { InternalTexture } from "../Materials/Textures/internalTexture.js";
+import { InternalTexture, IsDepthTexture, HasStencilAspect } from "../Materials/Textures/internalTexture.js";
 import { Effect } from "../Materials/effect.js";
 import { _ConcatenateShader, _getGlobalDefines } from "./abstractEngine.functions.js";
 import { resetCachedPipeline } from "../Materials/effect.functions.js";
@@ -365,6 +365,7 @@ export class ThinEngine extends AbstractEngine {
             textureMaxLevel: this._webGLVersion > 1,
             texture2DArrayMaxLayerCount: this._webGLVersion > 1 ? this._gl.getParameter(this._gl.MAX_ARRAY_TEXTURE_LAYERS) : 128,
             disableMorphTargetTexture: false,
+            textureNorm16: this._gl.getExtension("EXT_texture_norm16") ? true : false,
         };
         this._caps.supportFloatTexturesResolve = this._caps.colorBufferFloat;
         this._caps.rg11b10ufColorRenderable = this._caps.colorBufferFloat;
@@ -409,6 +410,16 @@ export class ThinEngine extends AbstractEngine {
         this._caps.textureFloatRender = this._caps.textureFloat && this._canRenderToFloatFramebuffer() ? true : false;
         this._caps.textureHalfFloatLinearFiltering =
             this._webGLVersion > 1 || (this._caps.textureHalfFloat && this._gl.getExtension("OES_texture_half_float_linear")) ? true : false;
+        if (this._caps.textureNorm16) {
+            this._gl.R16_EXT = 0x822a;
+            this._gl.RG16_EXT = 0x822c;
+            this._gl.RGB16_EXT = 0x8054;
+            this._gl.RGBA16_EXT = 0x805b;
+            this._gl.R16_SNORM_EXT = 0x8f98;
+            this._gl.RG16_SNORM_EXT = 0x8f99;
+            this._gl.RGB16_SNORM_EXT = 0x8f9a;
+            this._gl.RGBA16_SNORM_EXT = 0x8f9b;
+        }
         // Compressed formats
         if (this._caps.astc) {
             this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;
@@ -885,20 +896,21 @@ export class ThinEngine extends AbstractEngine {
     unBindFramebuffer(texture, disableGenerateMipMaps = false, onBeforeUnbind) {
         const webglRTWrapper = texture;
         this._currentRenderTarget = null;
-        // If MSAA, we need to bitblt back to main texture
-        const gl = this._gl;
-        if (webglRTWrapper._MSAAFramebuffer) {
+        if (!webglRTWrapper.disableAutomaticMSAAResolve) {
             if (texture.isMulti) {
-                // This texture is part of a MRT texture, we need to treat all attachments
-                this.unBindMultiColorAttachmentFramebuffer(texture, disableGenerateMipMaps, onBeforeUnbind);
-                return;
+                this.resolveMultiFramebuffer(texture);
+            }
+            else {
+                this.resolveFramebuffer(texture);
             }
-            gl.bindFramebuffer(gl.READ_FRAMEBUFFER, webglRTWrapper._MSAAFramebuffer);
-            gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, webglRTWrapper._framebuffer);
-            gl.blitFramebuffer(0, 0, texture.width, texture.height, 0, 0, texture.width, texture.height, gl.COLOR_BUFFER_BIT, gl.NEAREST);
         }
-        if (texture.texture?.generateMipMaps && !disableGenerateMipMaps && !texture.isCube) {
-            this.generateMipmaps(texture.texture);
+        if (!disableGenerateMipMaps) {
+            if (texture.isMulti) {
+                this.generateMipMapsMultiFramebuffer(texture);
+            }
+            else {
+                this.generateMipMapsFramebuffer(texture);
+            }
         }
         if (onBeforeUnbind) {
             if (webglRTWrapper._MSAAFramebuffer) {
@@ -909,6 +921,33 @@ export class ThinEngine extends AbstractEngine {
         }
         this._bindUnboundFramebuffer(null);
     }
+    /**
+     * Generates mipmaps for the texture of the (single) render target
+     * @param texture The render target containing the texture to generate the mipmaps for
+     */
+    generateMipMapsFramebuffer(texture) {
+        if (!texture.isMulti && texture.texture?.generateMipMaps && !texture.isCube) {
+            this.generateMipmaps(texture.texture);
+        }
+    }
+    /**
+     * Resolves the MSAA texture of the (single) render target into its non-MSAA version.
+     * Note that if "texture" is not a MSAA render target, no resolve is performed.
+     * @param texture  The render target texture containing the MSAA textures to resolve
+     */
+    resolveFramebuffer(texture) {
+        const rtWrapper = texture;
+        const gl = this._gl;
+        if (!rtWrapper._MSAAFramebuffer || rtWrapper.isMulti) {
+            return;
+        }
+        let bufferBits = rtWrapper.resolveMSAAColors ? gl.COLOR_BUFFER_BIT : 0;
+        bufferBits |= rtWrapper._generateDepthBuffer && rtWrapper.resolveMSAADepth ? gl.DEPTH_BUFFER_BIT : 0;
+        bufferBits |= rtWrapper._generateStencilBuffer && rtWrapper.resolveMSAAStencil ? gl.STENCIL_BUFFER_BIT : 0;
+        gl.bindFramebuffer(gl.READ_FRAMEBUFFER, rtWrapper._MSAAFramebuffer);
+        gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, rtWrapper._framebuffer);
+        gl.blitFramebuffer(0, 0, texture.width, texture.height, 0, 0, texture.width, texture.height, bufferBits, gl.NEAREST);
+    }
     /**
      * Force a webGL flush (ie. a flush of all waiting webGL commands)
      */
@@ -1666,15 +1705,10 @@ export class ThinEngine extends AbstractEngine {
      * @internal
      */
     _isRenderingStateCompiled(pipelineContext) {
-        const webGLPipelineContext = pipelineContext;
-        if (this._isDisposed || webGLPipelineContext._isDisposed) {
+        if (this._isDisposed) {
             return false;
         }
-        if (this._gl.getProgramParameter(webGLPipelineContext.program, this._caps.parallelShaderCompile.COMPLETION_STATUS_KHR)) {
-            this._finalizePipelineContext(webGLPipelineContext);
-            return true;
-        }
-        return false;
+        return _isRenderingStateCompiled(pipelineContext, this._gl, this.validateShaderPrograms);
     }
     /**
      * @internal
@@ -2286,20 +2320,26 @@ export class ThinEngine extends AbstractEngine {
      */
     _createInternalTexture(size, options, delayGPUTextureCreation = true, source = 0 /* InternalTextureSource.Unknown */) {
         let generateMipMaps = false;
+        let createMipMaps = false;
         let type = 0;
         let samplingMode = 3;
         let format = 5;
         let useSRGBBuffer = false;
         let samples = 1;
         let label;
+        let createMSAATexture = false;
+        let comparisonFunction = 0;
         if (options !== undefined && typeof options === "object") {
             generateMipMaps = !!options.generateMipMaps;
+            createMipMaps = !!options.createMipMaps;
             type = options.type === undefined ? 0 : options.type;
             samplingMode = options.samplingMode === undefined ? 3 : options.samplingMode;
             format = options.format === undefined ? 5 : options.format;
             useSRGBBuffer = options.useSRGBBuffer === undefined ? false : options.useSRGBBuffer;
             samples = options.samples ?? 1;
             label = options.label;
+            createMSAATexture = !!options.createMSAATexture;
+            comparisonFunction = options.comparisonFunction || 0;
         }
         else {
             generateMipMaps = !!options;
@@ -2317,17 +2357,21 @@ export class ThinEngine extends AbstractEngine {
             type = 0;
             Logger.Warn("Float textures are not supported. Type forced to TEXTURETYPE_UNSIGNED_BYTE");
         }
+        const isDepthTexture = IsDepthTexture(format);
+        const hasStencil = HasStencilAspect(format);
         const gl = this._gl;
         const texture = new InternalTexture(this, source);
         const width = size.width || size;
         const height = size.height || size;
         const depth = size.depth || 0;
         const layers = size.layers || 0;
-        const filters = this._getSamplingParameters(samplingMode, generateMipMaps);
+        const filters = this._getSamplingParameters(samplingMode, (generateMipMaps || createMipMaps) && !isDepthTexture);
         const target = layers !== 0 ? gl.TEXTURE_2D_ARRAY : depth !== 0 ? gl.TEXTURE_3D : gl.TEXTURE_2D;
-        const sizedFormat = this._getRGBABufferInternalSizedFormat(type, format, useSRGBBuffer);
-        const internalFormat = this._getInternalFormat(format);
-        const textureType = this._getWebGLTextureType(type);
+        const sizedFormat = isDepthTexture
+            ? this._getInternalFormatFromDepthTextureFormat(format, true, hasStencil)
+            : this._getRGBABufferInternalSizedFormat(type, format, useSRGBBuffer);
+        const internalFormat = isDepthTexture ? (hasStencil ? gl.DEPTH_STENCIL : gl.DEPTH_COMPONENT) : this._getInternalFormat(format);
+        const textureType = isDepthTexture ? this._getWebGLTextureTypeFromDepthTextureFormat(format) : this._getWebGLTextureType(type);
         // Bind
         this._bindTextureDirectly(target, texture);
         if (layers !== 0) {
@@ -2345,8 +2389,18 @@ export class ThinEngine extends AbstractEngine {
         gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, filters.min);
         gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
         gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        if (isDepthTexture && this.webGLVersion > 1) {
+            if (comparisonFunction === 0) {
+                gl.texParameteri(target, gl.TEXTURE_COMPARE_FUNC, 515);
+                gl.texParameteri(target, gl.TEXTURE_COMPARE_MODE, gl.NONE);
+            }
+            else {
+                gl.texParameteri(target, gl.TEXTURE_COMPARE_FUNC, comparisonFunction);
+                gl.texParameteri(target, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);
+            }
+        }
         // MipMaps
-        if (generateMipMaps) {
+        if (generateMipMaps || createMipMaps) {
             this._gl.generateMipmap(target);
         }
         this._bindTextureDirectly(target, null);
@@ -2355,7 +2409,7 @@ export class ThinEngine extends AbstractEngine {
         texture.baseHeight = height;
         texture.width = width;
         texture.height = height;
-        texture.depth = layers;
+        texture.depth = layers || depth;
         texture.isReady = true;
         texture.samples = samples;
         texture.generateMipMaps = generateMipMaps;
@@ -2363,7 +2417,26 @@ export class ThinEngine extends AbstractEngine {
         texture.type = type;
         texture.format = format;
         texture.label = label;
+        texture.comparisonFunction = comparisonFunction;
         this._internalTexturesCache.push(texture);
+        if (createMSAATexture) {
+            let renderBuffer = null;
+            if (IsDepthTexture(texture.format)) {
+                renderBuffer = this._setupFramebufferDepthAttachments(HasStencilAspect(texture.format), texture.format !== 19, texture.width, texture.height, samples, texture.format, true);
+            }
+            else {
+                renderBuffer = this._createRenderBuffer(texture.width, texture.height, samples, -1 /* not used */, this._getRGBABufferInternalSizedFormat(texture.type, texture.format, texture._useSRGBBuffer), -1 /* attachment */);
+            }
+            if (!renderBuffer) {
+                throw new Error("Unable to create render buffer");
+            }
+            texture._autoMSAAManagement = true;
+            let hardwareTexture = texture._hardwareTexture;
+            if (!hardwareTexture) {
+                hardwareTexture = texture._hardwareTexture = this._createHardwareTexture();
+            }
+            hardwareTexture.addMSAARenderBuffer(renderBuffer);
+        }
         return texture;
     }
     /**
@@ -2759,22 +2832,42 @@ export class ThinEngine extends AbstractEngine {
         }
         return internalFormat;
     }
+    _getWebGLTextureTypeFromDepthTextureFormat(textureFormat) {
+        const gl = this._gl;
+        let type = gl.UNSIGNED_INT;
+        if (textureFormat === 15) {
+            type = gl.UNSIGNED_SHORT;
+        }
+        else if (textureFormat === 17 || textureFormat === 13) {
+            type = gl.UNSIGNED_INT_24_8;
+        }
+        else if (textureFormat === 14) {
+            type = gl.FLOAT;
+        }
+        else if (textureFormat === 18) {
+            type = gl.FLOAT_32_UNSIGNED_INT_24_8_REV;
+        }
+        else if (textureFormat === 19) {
+            type = gl.UNSIGNED_BYTE;
+        }
+        return type;
+    }
     /**
      * @internal
      */
-    _setupFramebufferDepthAttachments(generateStencilBuffer, generateDepthBuffer, width, height, samples = 1, depthTextureFormat) {
+    _setupFramebufferDepthAttachments(generateStencilBuffer, generateDepthBuffer, width, height, samples = 1, depthTextureFormat, dontBindRenderBufferToFrameBuffer = false) {
         const gl = this._gl;
         depthTextureFormat = depthTextureFormat ?? (generateStencilBuffer ? 13 : 14);
         const internalFormat = this._getInternalFormatFromDepthTextureFormat(depthTextureFormat, generateDepthBuffer, generateStencilBuffer);
         // Create the depth/stencil buffer
         if (generateStencilBuffer && generateDepthBuffer) {
-            return this._createRenderBuffer(width, height, samples, gl.DEPTH_STENCIL, internalFormat, gl.DEPTH_STENCIL_ATTACHMENT);
+            return this._createRenderBuffer(width, height, samples, gl.DEPTH_STENCIL, internalFormat, dontBindRenderBufferToFrameBuffer ? -1 : gl.DEPTH_STENCIL_ATTACHMENT);
         }
         if (generateDepthBuffer) {
-            return this._createRenderBuffer(width, height, samples, internalFormat, internalFormat, gl.DEPTH_ATTACHMENT);
+            return this._createRenderBuffer(width, height, samples, internalFormat, internalFormat, dontBindRenderBufferToFrameBuffer ? -1 : gl.DEPTH_ATTACHMENT);
         }
         if (generateStencilBuffer) {
-            return this._createRenderBuffer(width, height, samples, internalFormat, internalFormat, gl.STENCIL_ATTACHMENT);
+            return this._createRenderBuffer(width, height, samples, internalFormat, internalFormat, dontBindRenderBufferToFrameBuffer ? -1 : gl.STENCIL_ATTACHMENT);
         }
         return null;
     }
@@ -2795,7 +2888,9 @@ export class ThinEngine extends AbstractEngine {
         else {
             gl.renderbufferStorage(gl.RENDERBUFFER, internalFormat, width, height);
         }
-        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, renderBuffer);
+        if (attachment !== -1) {
+            gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, renderBuffer);
+        }
         if (unbindBuffer) {
             gl.bindRenderbuffer(gl.RENDERBUFFER, null);
         }
@@ -3123,7 +3218,7 @@ export class ThinEngine extends AbstractEngine {
         const keys = Object.keys(this._compiledEffects);
         for (const name of keys) {
             const effect = this._compiledEffects[name];
-            effect.dispose();
+            effect.dispose(true);
         }
         this._compiledEffects = {};
     }
@@ -3311,15 +3406,23 @@ export class ThinEngine extends AbstractEngine {
                 internalFormat = this._gl.LUMINANCE_ALPHA;
                 break;
             case 6:
+            case 33322:
+            case 36760:
                 internalFormat = this._gl.RED;
                 break;
             case 7:
+            case 33324:
+            case 36761:
                 internalFormat = this._gl.RG;
                 break;
             case 4:
+            case 32852:
+            case 36762:
                 internalFormat = useSRGBBuffer ? this._glSRGBExtensionValues.SRGB : this._gl.RGB;
                 break;
             case 5:
+            case 32859:
+            case 36763:
                 internalFormat = useSRGBBuffer ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : this._gl.RGBA;
                 break;
         }
@@ -3411,6 +3514,14 @@ export class ThinEngine extends AbstractEngine {
                 switch (format) {
                     case 8:
                         return this._gl.R16I;
+                    case 36760:
+                        return this._gl.R16_SNORM_EXT;
+                    case 36761:
+                        return this._gl.RG16_SNORM_EXT;
+                    case 36762:
+                        return this._gl.RGB16_SNORM_EXT;
+                    case 36763:
+                        return this._gl.RGBA16_SNORM_EXT;
                     case 9:
                         return this._gl.RG16I;
                     case 10:
@@ -3424,6 +3535,14 @@ export class ThinEngine extends AbstractEngine {
                 switch (format) {
                     case 8:
                         return this._gl.R16UI;
+                    case 33322:
+                        return this._gl.R16_EXT;
+                    case 33324:
+                        return this._gl.RG16_EXT;
+                    case 32852:
+                        return this._gl.RGB16_EXT;
+                    case 32859:
+                        return this._gl.RGBA16_EXT;
                     case 9:
                         return this._gl.RG16UI;
                     case 10: