Metal improvements (#319)

* fix render pipeline creation

* fix capture support

* add support for clearing depth/stencil textures

* add depth/stencil clear test (disabled)

---------

Co-authored-by: Simon Kallweit <[email protected]>

Author: westlicht

src/debug-layer/debug-command-encoder.cpp

@@ -557,6 +557,7 @@ void DebugCommandEncoder::clearTextureDepthStencil(
         }
         break;
     case DeviceType::Metal:
+        break;
     case DeviceType::WGPU:
         RHI_VALIDATION_ERROR("Not implemented");
         return;

src/format-conversion.cpp

@@ -77,7 +77,7 @@ static const FormatConversionFuncs sFuncs[] = {
     {Format::R11G11B10Float, nullptr, nullptr, nullptr, nullptr},
 
     {Format::D32Float, packInt32<1>, unpackInt32<1>, packFloat32<1>, unpackFloat32<1>},
-    {Format::D16Unorm, nullptr, nullptr, nullptr, nullptr},
+    {Format::D16Unorm, packInt16<1>, unpackInt16<1>, packUnorm16<1>, unpackUnorm16<1>},
     {Format::D32FloatS8Uint, nullptr, nullptr, nullptr, nullptr},
 };
 

src/metal/metal-command.cpp

@@ -261,7 +261,63 @@ void CommandRecorder::cmdClearTextureUint(const commands::ClearTextureUint& cmd)
 
 void CommandRecorder::cmdClearTextureDepthStencil(const commands::ClearTextureDepthStencil& cmd)
 {
-    NOT_SUPPORTED(S_CommandEncoder_clearTextureDepthStencil);
+    TextureImpl* texture = checked_cast<TextureImpl*>(cmd.texture);
+    const TextureDesc& desc = texture->m_desc;
+    if (!is_set(desc.usage, TextureUsage::DepthStencil))
+        return;
+
+    // Create a dummy render pass descriptor
+    NS::SharedPtr<MTL::RenderPassDescriptor> renderPassDesc =
+        NS::TransferPtr(MTL::RenderPassDescriptor::alloc()->init());
+
+    // Setup depth stencil attachment
+    if (MetalUtil::isDepthFormat(texture->m_pixelFormat) && cmd.clearDepth)
+    {
+        MTL::RenderPassDepthAttachmentDescriptor* depthAttachment = renderPassDesc->depthAttachment();
+        depthAttachment->setLoadAction(MTL::LoadActionClear);
+        depthAttachment->setStoreAction(MTL::StoreActionStore);
+        depthAttachment->setClearDepth(cmd.depthValue);
+        depthAttachment->setTexture(texture->m_texture.get());
+    }
+    if (MetalUtil::isStencilFormat(texture->m_pixelFormat) && cmd.clearStencil)
+    {
+        MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment = renderPassDesc->stencilAttachment();
+        stencilAttachment->setLoadAction(MTL::LoadActionClear);
+        stencilAttachment->setStoreAction(MTL::StoreActionStore);
+        stencilAttachment->setClearStencil(cmd.stencilValue);
+        stencilAttachment->setTexture(texture->m_texture.get());
+    }
+
+    // Loop through all requested mip levels and array layers
+    for (uint32_t layerOffset = 0; layerOffset < cmd.subresourceRange.layerCount; layerOffset++)
+    {
+        uint32_t layerIndex = cmd.subresourceRange.layer + layerOffset;
+        for (uint32_t mipOffset = 0; mipOffset < cmd.subresourceRange.mipLevelCount; mipOffset++)
+        {
+            uint32_t mipLevel = cmd.subresourceRange.mipLevel + mipOffset;
+
+            // Set the level and slice for this iteration
+            if (MetalUtil::isDepthFormat(texture->m_pixelFormat) && cmd.clearDepth)
+            {
+                renderPassDesc->depthAttachment()->setLevel(mipLevel);
+                renderPassDesc->depthAttachment()->setSlice(layerIndex);
+            }
+            if (MetalUtil::isStencilFormat(texture->m_pixelFormat) && cmd.clearStencil)
+            {
+                renderPassDesc->stencilAttachment()->setLevel(mipLevel);
+                renderPassDesc->stencilAttachment()->setSlice(layerIndex);
+            }
+
+            // Set render target size for this mip level
+            Extent3D mipSize = calcMipSize(desc.size, mipLevel);
+            renderPassDesc->setRenderTargetWidth(mipSize.width);
+            renderPassDesc->setRenderTargetHeight(mipSize.height);
+
+            // Create and execute the render pass for this subresource
+            getRenderCommandEncoder(renderPassDesc.get());
+            endCommandEncoder();
+        }
+    }
 }
 
 void CommandRecorder::cmdUploadTextureData(const commands::UploadTextureData& cmd)

src/metal/metal-device.cpp

@@ -24,6 +24,12 @@ DeviceImpl::DeviceImpl() {}
 
 DeviceImpl::~DeviceImpl()
 {
+    if (captureEnabled())
+    {
+        MTL::CaptureManager* captureManager = MTL::CaptureManager::sharedCaptureManager();
+        captureManager->stopCapture();
+    }
+
     m_queue.setNull();
     m_clearEngine.release();
 }
@@ -82,6 +88,8 @@ Result DeviceImpl::initialize(const DeviceDesc& desc)
             .initialize(desc.slang, SLANG_METAL_LIB, "", std::array{slang::PreprocessorMacroDesc{"__METAL__", "1"}})
     );
 
+    SLANG_RETURN_ON_FAIL(m_clearEngine.initialize(m_device.get()));
+
     // TODO: expose via some other means
     if (captureEnabled())
     {
@@ -110,8 +118,6 @@ Result DeviceImpl::initialize(const DeviceDesc& desc)
         }
     }
 
-    SLANG_RETURN_ON_FAIL(m_clearEngine.initialize(m_device.get()));
-
     return SLANG_OK;
 }
 

src/metal/metal-device.h

@@ -108,7 +108,7 @@ class DeviceImpl : public Device
     DeviceInfo m_info;
     std::string m_adapterName;
 
-    bool captureEnabled() const { return std::getenv("MTL_CAPTURE") != nullptr; }
+    bool captureEnabled() const { return std::getenv("MTL_CAPTURE_ENABLED") != nullptr; }
 
     DeviceDesc m_desc;
     NS::SharedPtr<MTL::Device> m_device;

src/metal/metal-pipeline.cpp

@@ -131,12 +131,6 @@ Result DeviceImpl::createRenderPipeline2(const RenderPipelineDesc& desc, IRender
     const auto& depthStencil = desc.depthStencil;
     NS::SharedPtr<MTL::DepthStencilDescriptor> depthStencilDesc =
         NS::TransferPtr(MTL::DepthStencilDescriptor::alloc()->init());
-    NS::SharedPtr<MTL::DepthStencilState> depthStencilState =
-        NS::TransferPtr(m_device->newDepthStencilState(depthStencilDesc.get()));
-    if (!depthStencilState)
-    {
-        return SLANG_FAIL;
-    }
     if (depthStencil.depthTestEnable)
     {
         depthStencilDesc->setDepthCompareFunction(MetalUtil::translateCompareFunction(depthStencil.depthFunc));
@@ -151,6 +145,12 @@ Result DeviceImpl::createRenderPipeline2(const RenderPipelineDesc& desc, IRender
             createStencilDesc(depthStencil.backFace, depthStencil.stencilReadMask, depthStencil.stencilWriteMask).get()
         );
     }
+    NS::SharedPtr<MTL::DepthStencilState> depthStencilState =
+        NS::TransferPtr(m_device->newDepthStencilState(depthStencilDesc.get()));
+    if (!depthStencilState)
+    {
+        return SLANG_FAIL;
+    }
 
     RefPtr<RenderPipelineImpl> pipeline = new RenderPipelineImpl(this);
     pipeline->m_program = program;

src/metal/metal-texture.cpp

@@ -87,7 +87,7 @@ Result DeviceImpl::createTexture(const TextureDesc& desc_, const SubresourceData
     textureDesc->setSampleCount(desc.sampleCount);
 
     MTL::TextureUsage textureUsage = MTL::TextureUsageUnknown;
-    if (is_set(desc.usage, TextureUsage::RenderTarget))
+    if (is_set(desc.usage, TextureUsage::RenderTarget) || is_set(desc.usage, TextureUsage::DepthStencil))
     {
         textureUsage |= MTL::TextureUsageRenderTarget;
     }

tests/test-cmd-clear-texture.cpp

@@ -100,6 +100,12 @@ static const std::vector<Format> kSintFormats = {
     // Format::R64Sint, // TODO not supported yet
 };
 
+static const std::vector<Format> kDepthStencilFormats = {
+    Format::D16Unorm,
+    Format::D32Float,
+    Format::D32FloatS8Uint,
+};
+
 GPU_TEST_CASE("cmd-clear-texture-float-zero", D3D11 | D3D12 | Vulkan | Metal | CUDA)
 {
     TextureTestOptions options(device, 1);
@@ -274,4 +280,47 @@ GPU_TEST_CASE("cmd-clear-texture-sint-pattern", D3D11 | D3D12 | Vulkan | Metal |
     );
 }
 
-GPU_TEST_CASE("cmd-clear-texture-depth-stencil", D3D11 | D3D12 | Vulkan | Metal) {}
+GPU_TEST_CASE("cmd-clear-texture-depth-stencil", D3D11 | D3D12 | Vulkan | Metal)
+{
+#if 0
+    TextureTestOptions options(device, 1);
+    options.addVariants(
+        TTShape::D2,
+        TTArray::Both,
+        TTMip::Both,
+        TTMS::Off,
+        kDepthStencilFormats,
+        TextureUsage::DepthStencil
+    );
+
+    runTextureTest(
+        options,
+        [device](TextureTestContext* c)
+        {
+            printf("cmd-clear-texture-depth-stencil\n");
+            ComPtr<ITexture> texture = c->getTexture();
+            ComPtr<ICommandQueue> queue = device->getQueue(QueueType::Graphics);
+            {
+                ComPtr<ICommandEncoder> encoder = queue->createCommandEncoder();
+
+                // Clear depth to 0.5 and stencil to 42
+                float depthValue = 0.5f;
+                uint8_t stencilValue = 42;
+
+                // Create a subresource range that covers all mips and array layers
+                SubresourceRange range = kEntireTexture;
+
+                // Clear both depth and stencil
+                encoder->clearTextureDepthStencil(texture, range, true, depthValue, true, stencilValue);
+                queue->submit(encoder->finish());
+
+                // Verify the clear values
+                // For depth formats, we use clearFloat with the depth value
+                float clearValues[4] = {depthValue, 0.0f, 0.0f, 0.0f};
+                c->getTextureData().clearFloat(clearValues);
+                c->getTextureData().checkEqual(texture);
+            }
+        }
+    );
+#endif
+}

tests/texture-test.cpp

@@ -1224,7 +1224,7 @@ void TextureTestOptions::filterFormat(int state, TextureTestVariant variant)
 
         const FormatInfo& info = getFormatInfo(format);
 
-        // WebGPU doesn't support writing into depth textures.
+        // Metal doesn't support writing into depth textures.
         if (m_device->getDeviceType() == DeviceType::Metal && (info.hasDepth || info.hasStencil))
             return;