NativeEngine: support standalone sampleable depth/stencil textures

Babylon's NativeEngine._createDepthStencilTexture requests a standalone,
sampleable depth/stencil texture by calling createFrameBuffer with a
freshly-created (and therefore uninitialized) color texture whose bgfx
handle is still kInvalidHandle. CreateFrameBuffer only guarded against a
null texture, so it attached the invalid handle as a color target. bgfx
framebuffer validation then rejected the attachment ("Invalid texture
attachment") and threw, aborting the entire headless Playground sweep.

Detect this request (non-null texture with an invalid bgfx handle) and:
  - skip attaching the invalid color handle (depth-only framebuffer),
  - allocate the depth attachment as a readable BGFX_TEXTURE_RT so it can
    be sampled, and
  - alias the framebuffer's depth attachment back into the caller-supplied
    texture (ownsHandle=false; the framebuffer owns the handle) so Babylon
    can sample it (e.g. fluid rendering's depth copy).

This removes the whole-sweep abort and makes the depth/stencil texture
sampleable per Babylon's contract.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: bkaradzic-microsoft

Plugins/NativeEngine/Source/NativeEngine.cpp

@@ -1814,7 +1814,13 @@ namespace Babylon
         std::array<bgfx::Attachment, 2> attachments{};
         uint8_t numAttachments = 0;
 
-        if (texture != nullptr)
+        // Babylon's NativeEngine._createDepthStencilTexture asks for a standalone, *sampleable* depth/stencil
+        // texture by passing a freshly created (and therefore uninitialized) color texture: its bgfx handle is
+        // still kInvalidHandle. Detect that here so we (a) don't attach the invalid handle as a color target and
+        // (b) create a readable depth attachment and alias it back into the supplied texture so it can be sampled.
+        const bool requestDepthStencilTexture = (texture != nullptr && !bgfx::isValid(texture->Handle()));
+
+        if (texture != nullptr && bgfx::isValid(texture->Handle()))
         {
             const bgfx::Caps* caps = bgfx::getCaps();
             // bgfx validation now asserts when trying to use BGFX_RESOLVE_AUTO_GEN_MIPS with a texture that doesn't have the BGFX_CAPS_FORMAT_TEXTURE_MIP_AUTOGEN flag,
@@ -1827,14 +1833,18 @@ namespace Babylon
 
         bgfx::TextureHandle depthStencilTextureHandle = BGFX_INVALID_HANDLE;
         int8_t depthStencilAttachmentIndex = -1;
+        bgfx::TextureFormat::Enum depthStencilTextureFormat = bgfx::TextureFormat::Unknown;
+        uint64_t depthStencilTextureFlags = 0;
         if (generateStencilBuffer || generateDepth)
         {
             if (generateStencilBuffer && !generateDepth)
             {
                 JsConsoleLogger::LogWarn(info.Env(), "Stencil without depth is not supported, assuming depth and stencil");
             }
 
-            auto flags = BGFX_TEXTURE_RT_WRITE_ONLY | RenderTargetSamplesToBgfxMsaaFlag(samples);
+            // A standalone depth/stencil texture must be readable; render-target-only depth attachments stay
+            // write-only (cheaper, and the resolve path below relies on it).
+            auto flags = (requestDepthStencilTexture ? BGFX_TEXTURE_RT : BGFX_TEXTURE_RT_WRITE_ONLY) | RenderTargetSamplesToBgfxMsaaFlag(samples);
 #ifdef ANDROID
             // On Android with Mali GPU (Oppo Find x5 lite, Google Pixel 8, Samsung Galaxy Tab Active 3, ...)
             // D32 depth buffer gives glitches. Everything is fine with D24S8.
@@ -1846,6 +1856,8 @@ namespace Babylon
 #endif
             assert(bgfx::isTextureValid(0, false, 1, depthStencilFormat, flags));
             depthStencilTextureHandle = bgfx::createTexture2D(width, height, false, 1, depthStencilFormat, flags);
+            depthStencilTextureFormat = depthStencilFormat;
+            depthStencilTextureFlags = flags;
 
             // bgfx doesn't add flag D3D11_RESOURCE_MISC_GENERATE_MIPS for depth textures (missing that flag will crash D3D with resolving)
             // And not sure it makes sense to generate mipmaps from a depth buffer with exponential values.
@@ -1867,6 +1879,16 @@ namespace Babylon
         }
 
         Graphics::FrameBuffer* frameBuffer = new Graphics::FrameBuffer(m_deviceContext, frameBufferHandle, width, height, false, generateDepth, generateStencilBuffer, depthStencilAttachmentIndex);
+
+        // For a standalone depth/stencil texture request, alias the framebuffer's readable depth attachment back
+        // into the caller-supplied texture so Babylon can sample it (e.g. fluid rendering's depth copy). The
+        // framebuffer owns the handle (its destructor destroys it), so the texture must not own it.
+        if (requestDepthStencilTexture && depthStencilAttachmentIndex >= 0)
+        {
+            texture->Attach(bgfx::getTexture(frameBufferHandle, static_cast<uint8_t>(depthStencilAttachmentIndex)),
+                false, width, height, false, 1, depthStencilTextureFormat, depthStencilTextureFlags);
+        }
+
         return Napi::Pointer<Graphics::FrameBuffer>::Create(info.Env(), frameBuffer, Napi::NapiPointerDeleter(frameBuffer));
     }