Graphics Utilities: added GetDeviceDXCompiler function

Author: TheMostDiligent

Graphics/GraphicsTools/interface/GraphicsUtilities.h

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *  Copyright 2015-2019 Egor Yusov
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
@@ -278,6 +278,15 @@ void DILIGENT_GLOBAL_FUNCTION(CreateGeometryPrimitiveBuffers)(IRenderDevice*
                                                               IBuffer**                                 ppIndices,
                                                               GeometryPrimitiveInfo* pInfo              DEFAULT_VALUE(nullptr));
 
+
+/// Returns the DirectX shader compiler interface associated with the specified render device.
+
+/// \param [in] pDevice - A pointer to the render device.
+/// \return     A pointer to the DirectX shader compiler interface.
+///             If the device does not support DirectX shader compiler,
+///             or if the compiler is not loaded, returns null.
+struct IDXCompiler* DILIGENT_GLOBAL_FUNCTION(GetDeviceDXCompiler)(IRenderDevice* pDevice);
+
 #include "../../../Primitives/interface/UndefRefMacro.h"
 
 DILIGENT_END_NAMESPACE // namespace Diligent

Graphics/GraphicsTools/src/GraphicsUtilities.cpp

@@ -49,6 +49,7 @@ TEXTURE_FORMAT GetTextureFormatFromNativeD3D11(int64_t NativeFormat);
 #if D3D12_SUPPORTED
 int64_t        GetNativeTextureFormatD3D12(TEXTURE_FORMAT TexFormat);
 TEXTURE_FORMAT GetTextureFormatFromNativeD3D12(int64_t NativeFormat);
+IDXCompiler*   GetDeviceDXCompilerD3D12(IRenderDevice* pDevice);
 #endif
 
 #if GL_SUPPORTED || GLES_SUPPORTED
@@ -59,6 +60,7 @@ TEXTURE_FORMAT GetTextureFormatFromNativeGL(int64_t NativeFormat);
 #if VULKAN_SUPPORTED
 int64_t        GetNativeTextureFormatVk(TEXTURE_FORMAT TexFormat);
 TEXTURE_FORMAT GetTextureFormatFromNativeVk(int64_t NativeFormat);
+IDXCompiler*   GetDeviceDXCompilerVk(IRenderDevice* pDevice);
 #endif
 
 #if METAL_SUPPORTED
@@ -580,6 +582,7 @@ const char* GetWebGPUEmulatedArrayIndexSuffix(IShader* pShader)
 
 int64_t GetNativeTextureFormat(TEXTURE_FORMAT TexFormat, RENDER_DEVICE_TYPE DeviceType)
 {
+    static_assert(RENDER_DEVICE_TYPE_COUNT == 8, "Please handle the new device type below");
     switch (DeviceType)
     {
 #if D3D11_SUPPORTED
@@ -621,6 +624,7 @@ int64_t GetNativeTextureFormat(TEXTURE_FORMAT TexFormat, RENDER_DEVICE_TYPE Devi
 
 TEXTURE_FORMAT GetTextureFormatFromNative(int64_t NativeFormat, RENDER_DEVICE_TYPE DeviceType)
 {
+    static_assert(RENDER_DEVICE_TYPE_COUNT == 8, "Please handle the new device type below");
     switch (DeviceType)
     {
 #if D3D11_SUPPORTED
@@ -731,6 +735,55 @@ void CreateGeometryPrimitiveBuffers(IRenderDevice*                            pD
     }
 }
 
+
+IDXCompiler* GetDeviceDXCompiler(IRenderDevice* pDevice)
+{
+    if (pDevice == nullptr)
+    {
+        return nullptr;
+    }
+
+    const RENDER_DEVICE_TYPE DeviceType = pDevice->GetDeviceInfo().Type;
+    static_assert(RENDER_DEVICE_TYPE_COUNT == 8, "Please handle the new device type below");
+    switch (DeviceType)
+    {
+#if D3D11_SUPPORTED
+        case RENDER_DEVICE_TYPE_D3D11:
+            return nullptr;
+#endif
+
+#if D3D12_SUPPORTED
+        case RENDER_DEVICE_TYPE_D3D12:
+            return GetDeviceDXCompilerD3D12(pDevice);
+#endif
+
+#if GL_SUPPORTED || GLES_SUPPORTED
+        case RENDER_DEVICE_TYPE_GL:
+        case RENDER_DEVICE_TYPE_GLES:
+            return nullptr;
+#endif
+
+#if METAL_SUPPORTED
+        case RENDER_DEVICE_TYPE_METAL:
+            return nullptr;
+#endif
+
+#if VULKAN_SUPPORTED
+        case RENDER_DEVICE_TYPE_VULKAN:
+            return GetDeviceDXCompilerVk(pDevice);
+#endif
+
+#if WEBGPU_SUPPORTED
+        case RENDER_DEVICE_TYPE_WEBGPU:
+            return nullptr;
+#endif
+
+        default:
+            UNSUPPORTED("Unsupported device type");
+            return nullptr;
+    }
+}
+
 } // namespace Diligent
 
 
@@ -827,4 +880,9 @@ extern "C"
     {
         Diligent::CreateGeometryPrimitiveBuffers(pDevice, Attribs, pBufferCI, ppVertices, ppIndices, pInfo);
     }
+
+    Diligent::IDXCompiler* Diligent_GetDeviceDXCompiler(Diligent::IRenderDevice* pDevice)
+    {
+        return Diligent::GetDeviceDXCompiler(pDevice);
+    }
 }

Graphics/GraphicsTools/src/GraphicsUtilitiesD3D12.cpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -26,8 +26,16 @@
 
 #include "GraphicsUtilities.h"
 
+#include "WinHPreface.h"
+#include <d3d12.h>
+#include <atlbase.h>
+#include "WinHPostface.h"
+
 #include "../../GraphicsEngineD3DBase/include/DXGITypeConversions.hpp"
 
+#include "RenderDeviceD3D12.h"
+#include "RefCntAutoPtr.hpp"
+
 namespace Diligent
 {
 
@@ -41,4 +49,16 @@ TEXTURE_FORMAT GetTextureFormatFromNativeD3D12(int64_t NativeFormat)
     return DXGI_FormatToTexFormat(static_cast<DXGI_FORMAT>(NativeFormat));
 }
 
+IDXCompiler* GetDeviceDXCompilerD3D12(IRenderDevice* pDevice)
+{
+    if (RefCntAutoPtr<IRenderDeviceD3D12> pDeviceD3D12{pDevice, IID_RenderDeviceD3D12})
+    {
+        return pDeviceD3D12->GetDXCompiler();
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+
 } // namespace Diligent

Graphics/GraphicsTools/src/GraphicsUtilitiesVk.cpp

@@ -1,5 +1,5 @@
 /*
- *  Copyright 2019-2024 Diligent Graphics LLC
+ *  Copyright 2019-2025 Diligent Graphics LLC
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
@@ -27,12 +27,12 @@
 #include "GraphicsUtilities.h"
 #include "DeviceContext.h"
 
-#if VULKAN_SUPPORTED
-#    include "../../GraphicsEngineVulkan/include/VulkanUtilities/VulkanHeaders.h"
-#endif
-
+#include "../../GraphicsEngineVulkan/include/VulkanUtilities/VulkanHeaders.h"
 #include "../../GraphicsEngineVulkan/include/VulkanTypeConversions.hpp"
 
+#include "RenderDeviceVk.h"
+#include "RefCntAutoPtr.hpp"
+
 namespace Diligent
 {
 
@@ -46,4 +46,16 @@ TEXTURE_FORMAT GetTextureFormatFromNativeVk(int64_t NativeFormat)
     return VkFormatToTexFormat(static_cast<VkFormat>(NativeFormat));
 }
 
+IDXCompiler* GetDeviceDXCompilerVk(IRenderDevice* pDevice)
+{
+    if (RefCntAutoPtr<IRenderDeviceVk> pDeviceVk{pDevice, IID_RenderDeviceVk})
+    {
+        return pDeviceVk->GetDXCompiler();
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+
 } // namespace Diligent