@babylonjs/core 8.37.3 → 8.39.0

package/Engines/WebGPU/webgpuTextureManager.d.ts

@@ -44,6 +44,7 @@ export declare class WebGPUTextureManager {
     generateMipmaps(gpuOrHdwTexture: GPUTexture | WebGPUHardwareTexture, format: GPUTextureFormat, mipLevelCount: number, faceIndex?: number, is3D?: boolean, commandEncoder?: GPUCommandEncoder): void;
     createGPUTextureForInternalTexture(texture: InternalTexture, width?: number, height?: number, depth?: number, creationFlags?: number, dontCreateMSAATexture?: boolean): WebGPUHardwareTexture;
     createMSAATexture(texture: InternalTexture, samples: number, releaseExisting?: boolean, index?: number): void;
+    resolveMSAADepthTexture(msaaTexture: GPUTexture, outputTexture: GPUTexture, commandEncoder?: GPUCommandEncoder): void;
     updateCubeTextures(imageBitmaps: ImageBitmap[] | Uint8Array[], gpuTexture: GPUTexture, width: number, height: number, format: GPUTextureFormat, invertY?: boolean, premultiplyAlpha?: boolean, offsetX?: number, offsetY?: number): void;
     updateTexture(imageBitmap: ImageBitmap | Uint8Array | ImageData | HTMLImageElement | HTMLVideoElement | VideoFrame | HTMLCanvasElement | OffscreenCanvas, texture: GPUTexture | InternalTexture, width: number, height: number, layers: number, format: GPUTextureFormat, faceIndex?: number, mipLevel?: number, invertY?: boolean, premultiplyAlpha?: boolean, offsetX?: number, offsetY?: number, allowGPUOptimization?: boolean): void;
     readPixels(texture: GPUTexture, x: number, y: number, width: number, height: number, format: GPUTextureFormat, faceIndex?: number, mipLevel?: number, buffer?: Nullable<ArrayBufferView>, noDataConversion?: boolean): Promise<ArrayBufferView>;

package/Engines/WebGPU/webgpuTextureManager.js

@@ -129,7 +129,6 @@ const clearVertexSource = `
 const clearFragmentSource = `
     uniform color: vec4f;
 
-
     @fragment
     fn main(input: FragmentInputs) -> FragmentOutputs {
         fragmentOutputs.color = uniforms.color;
@@ -188,12 +187,40 @@ const copyVideoToTextureInvertYFragmentSource = `
         return textureSampleBaseClampToEdge(videoTexture, videoSampler, vec2<f32>(fragUV.x, 1.0 - fragUV.y));
     }
     `;
+const resolveDepthVertexSource = `
+    const pos = array<vec2<f32>, 4>( vec2f(-1.0f, 1.0f),  vec2f(1.0f, 1.0f),  vec2f(-1.0f, -1.0f),  vec2f(1.0f, -1.0f));
+
+    @vertex
+    fn main(input : VertexInputs) -> FragmentInputs {
+        vertexOutputs.position = vec4f(pos[input.vertexIndex], 0.0, 1.0);
+    }
+    `;
+const resolveDepthFragmentSource = `
+    var msaaDepthTexture: texture_depth_multisampled_2d;
+
+    @fragment
+    fn main(input: FragmentInputs) -> FragmentOutputs {
+    #ifdef USE_MIN
+        let numSamples = textureNumSamples(msaaDepthTexture);
+        var depth = 1.0;
+
+        for (var i = 0u; i < numSamples; i = i + 1u) {
+            depth = min(depth, textureLoad(msaaDepthTexture, vec2u(input.position.xy), i));
+        }
+        
+        fragmentOutputs.color = vec4f(depth);
+    #else
+        fragmentOutputs.color = vec4f(textureLoad(msaaDepthTexture, vec2u(input.position.xy), 0)); // do like WebGL, take the first sample
+    #endif
+    }
+    `;
 var PipelineType;
 (function (PipelineType) {
     PipelineType[PipelineType["MipMap"] = 0] = "MipMap";
     PipelineType[PipelineType["InvertYPremultiplyAlpha"] = 1] = "InvertYPremultiplyAlpha";
     PipelineType[PipelineType["Clear"] = 2] = "Clear";
     PipelineType[PipelineType["InvertYPremultiplyAlphaWithOfst"] = 3] = "InvertYPremultiplyAlphaWithOfst";
+    PipelineType[PipelineType["ResolveDepth"] = 4] = "ResolveDepth";
 })(PipelineType || (PipelineType = {}));
 var VideoPipelineType;
 (function (VideoPipelineType) {
@@ -205,6 +232,7 @@ const shadersForPipelineType = [
     { vertex: invertYPreMultiplyAlphaVertexSource, fragment: invertYPreMultiplyAlphaFragmentSource },
     { vertex: clearVertexSource, fragment: clearFragmentSource },
     { vertex: invertYPreMultiplyAlphaWithOfstVertexSource, fragment: invertYPreMultiplyAlphaWithOfstFragmentSource },
+    { vertex: resolveDepthVertexSource, fragment: resolveDepthFragmentSource },
 ];
 /**
  * Map a (renderable) texture format (GPUTextureFormat) to an index for fast lookup (in caches for eg)
@@ -291,7 +319,9 @@ export class WebGPUTextureManager {
                     ? 1 << 3
                     : type === PipelineType.InvertYPremultiplyAlphaWithOfst
                         ? ((params.invertY ? 1 : 0) << 4) + ((params.premultiplyAlpha ? 1 : 0) << 5)
-                        : 0;
+                        : type === PipelineType.ResolveDepth
+                            ? 1 << 6
+                            : 0;
         if (!this._pipelines[format]) {
             this._pipelines[format] = [];
         }
@@ -772,9 +802,29 @@ export class WebGPUTextureManager {
         if (depth === undefined) {
             depth = texture.depth;
         }
+        texture.width = texture.baseWidth = width;
+        texture.height = texture.baseHeight = height;
+        texture.depth = texture.baseDepth = depth;
         const gpuTextureWrapper = texture._hardwareTexture;
         const isStorageTexture = ((creationFlags ?? 0) & 1) !== 0;
         gpuTextureWrapper.format = WebGPUTextureHelper.GetWebGPUTextureFormat(texture.type, texture.format, texture._useSRGBBuffer);
+        if (!dontCreateMSAATexture) {
+            this.createMSAATexture(texture, texture.samples);
+        }
+        if (texture.samples > 1) {
+            // In case of a MSAA texture, the current texture will be the "resolve" texture, which cannot have a depth format
+            switch (gpuTextureWrapper.format) {
+                case "depth16unorm" /* WebGPUConstants.TextureFormat.Depth16Unorm */:
+                    gpuTextureWrapper.format = "r16unorm" /* WebGPUConstants.TextureFormat.R16Unorm */;
+                    break;
+                case "depth24plus" /* WebGPUConstants.TextureFormat.Depth24Plus */:
+                case "depth24plus-stencil8" /* WebGPUConstants.TextureFormat.Depth24PlusStencil8 */:
+                case "depth32float" /* WebGPUConstants.TextureFormat.Depth32Float */:
+                case "depth32float-stencil8" /* WebGPUConstants.TextureFormat.Depth32FloatStencil8 */:
+                    gpuTextureWrapper.format = "r32float" /* WebGPUConstants.TextureFormat.R32Float */;
+                    break;
+            }
+        }
         gpuTextureWrapper.textureUsages =
             texture._source === 5 /* InternalTextureSource.RenderTarget */ || texture.source === 6 /* InternalTextureSource.MultiRenderTarget */
                 ? 4 /* WebGPUConstants.TextureUsage.TextureBinding */ | 1 /* WebGPUConstants.TextureUsage.CopySrc */ | 16 /* WebGPUConstants.TextureUsage.RenderAttachment */
@@ -831,12 +881,6 @@ export class WebGPUTextureManager {
                 aspect,
             }, isStorageTexture);
         }
-        texture.width = texture.baseWidth = width;
-        texture.height = texture.baseHeight = height;
-        texture.depth = texture.baseDepth = depth;
-        if (!dontCreateMSAATexture) {
-            this.createMSAATexture(texture, texture.samples);
-        }
         return gpuTextureWrapper;
     }
     createMSAATexture(texture, samples, releaseExisting = true, index = 0) {
@@ -849,9 +893,56 @@ export class WebGPUTextureManager {
         }
         const width = texture.width;
         const height = texture.height;
-        const gpuMSAATexture = this.createTexture({ width, height, layers: 1 }, false, false, false, false, false, gpuTextureWrapper.format, samples, this._commandEncoderForCreation, 16 /* WebGPUConstants.TextureUsage.RenderAttachment */, 0, texture.label ? "MSAA_" + texture.label : "MSAA");
+        const gpuMSAATexture = this.createTexture({ width, height, layers: 1 }, false, false, false, false, false, gpuTextureWrapper.format, samples, this._commandEncoderForCreation, 16 /* WebGPUConstants.TextureUsage.RenderAttachment */ | 4 /* WebGPUConstants.TextureUsage.TextureBinding */, 0, texture.label ? "MSAA_" + texture.label : "MSAA");
         gpuTextureWrapper.setMSAATexture(gpuMSAATexture, index);
     }
+    resolveMSAADepthTexture(msaaTexture, outputTexture, commandEncoder) {
+        const format = outputTexture.format;
+        const useOwnCommandEncoder = commandEncoder === undefined;
+        const [pipeline, bindGroupLayout] = this._getPipeline(format, PipelineType.ResolveDepth);
+        if (useOwnCommandEncoder) {
+            commandEncoder = this._device.createCommandEncoder({});
+        }
+        commandEncoder.pushDebugGroup(`resolve MSAA Depth texture${msaaTexture.label ? " - " + msaaTexture.label : ""}`);
+        const renderPassDescriptor = {
+            label: `BabylonWebGPUDevice${this._engine.uniqueId}_resolveMSAADepthTexture${msaaTexture.label ? "_" + msaaTexture.label : ""}`,
+            colorAttachments: [
+                {
+                    view: outputTexture,
+                    loadOp: "load" /* WebGPUConstants.LoadOp.Load */,
+                    storeOp: "store" /* WebGPUConstants.StoreOp.Store */,
+                },
+            ],
+        };
+        const passEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
+        const descriptor = {
+            layout: bindGroupLayout,
+            entries: [
+                {
+                    binding: 0,
+                    resource: msaaTexture.createView({
+                        format: WebGPUTextureHelper.GetDepthFormatOnly(msaaTexture.format),
+                        dimension: "2d" /* WebGPUConstants.TextureViewDimension.E2d */,
+                        mipLevelCount: 1,
+                        baseArrayLayer: 0,
+                        baseMipLevel: 0,
+                        arrayLayerCount: 1,
+                        aspect: "depth-only" /* WebGPUConstants.TextureAspect.DepthOnly */,
+                    }),
+                },
+            ],
+        };
+        const bindGroup = this._device.createBindGroup(descriptor);
+        passEncoder.setPipeline(pipeline);
+        passEncoder.setBindGroup(0, bindGroup);
+        passEncoder.draw(4, 1, 0, 0);
+        passEncoder.end();
+        commandEncoder.popDebugGroup();
+        if (useOwnCommandEncoder) {
+            this._device.queue.submit([commandEncoder.finish()]);
+            commandEncoder = null;
+        }
+    }
     //------------------------------------------------------------------------------
     //                                  Update
     //------------------------------------------------------------------------------