{"id":19133803,"url":"https://github.com/diligentgraphics/diligentcore","last_synced_at":"2025-05-14T11:10:42.386Z","repository":{"id":37695058,"uuid":"44292712","full_name":"DiligentGraphics/DiligentCore","owner":"DiligentGraphics","description":"A modern cross-platform low-level graphics API","archived":false,"fork":false,"pushed_at":"2025-05-14T02:09:00.000Z","size":48142,"stargazers_count":667,"open_issues_count":44,"forks_count":150,"subscribers_count":34,"default_branch":"master","last_synced_at":"2025-05-14T02:29:18.085Z","etag":null,"topics":["d3d11","d3d12","direct3d","directx-11","directx-12","directx11","directx12","graphics","graphics-engine","opengl","opengl-es","openxr","ray-tracing","raytracing","shaders","vulkan","vulkan-api","vulkan-engine"],"latest_commit_sha":null,"homepage":"http://diligentgraphics.com/diligent-engine/","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/DiligentGraphics.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"License.txt","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":"CODEOWNERS","security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2015-10-15T03:56:34.000Z","updated_at":"2025-05-14T01:56:24.000Z","dependencies_parsed_at":"2023-10-22T21:26:00.678Z","dependency_job_id":"6f6f3668-d649-4f3f-b8ab-13f779e55d30","html_url":"https://github.com/DiligentGraphics/DiligentCore","commit_stats":{"total_commits":4472,"total_committers":31,"mean_commits":"144.25806451612902","dds":"0.11314847942754924","last_synced_commit":"8d2e896ae189c589da00f6b84b80966731493d89"},"previous_names":[],"tags_count":87,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/DiligentGraphics%2FDiligentCore","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/DiligentGraphics%2FDiligentCore/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/DiligentGraphics%2FDiligentCore/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/DiligentGraphics%2FDiligentCore/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/DiligentGraphics","download_url":"https://codeload.github.com/DiligentGraphics/DiligentCore/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":254129489,"owners_count":22019628,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["d3d11","d3d12","direct3d","directx-11","directx-12","directx11","directx12","graphics","graphics-engine","opengl","opengl-es","openxr","ray-tracing","raytracing","shaders","vulkan","vulkan-api","vulkan-engine"],"created_at":"2024-11-09T06:23:53.430Z","updated_at":"2025-05-14T11:10:42.366Z","avatar_url":"https://github.com/DiligentGraphics.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Diligent Core [![Tweet](https://img.shields.io/twitter/url/http/shields.io.svg?style=social)](https://twitter.com/intent/tweet?text=An%20easy-to-use%20cross-platform%20graphics%20library%20that%20takes%20full%20advantage%20of%20%23Direct3D12%20and%20%23VulkanAPI\u0026url=https://github.com/DiligentGraphics/DiligentEngine) \u003cimg src=\"media/diligentgraphics-logo.png\" height=64 align=\"right\" valign=\"middle\"\u003e\n\nDiligent Core is a modern, cross-platform low-level graphics API that forms the foundation of [Diligent Engine](https://github.com/DiligentGraphics/DiligentEngine).\nIt provides implementations for Direct3D11, Direct3D12, OpenGL, OpenGLES, Vulkan, and WebGPU rendering backends.\nA Metal backend is also available for commercial clients. In addition, the module includes essential platform-specific utilities.\nDiligent Core is fully self-contained and can be built independently of the rest of the engine.\nFor details on supported platforms, features, and build instructions, please refer to the \n[main repository](https://github.com/DiligentGraphics/DiligentEngine).\n\n| Platform             | Build Status  |\n| ---------------------| ------------- |\n|\u003cimg src=\"media/windows-logo.png\" width=24 valign=\"middle\"\u003e Win32               | [![Build Status](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-windows.yml/badge.svg?branch=master)](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-windows.yml?query=branch%3Amaster) |\n|\u003cimg src=\"media/uwindows-logo.png\" width=24 valign=\"middle\"\u003e Universal Windows  | [![Build Status](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-windows.yml/badge.svg?branch=master)](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-windows.yml?query=branch%3Amaster) |\n|\u003cimg src=\"media/linux-logo.png\" width=24 valign=\"middle\"\u003e Linux                 | [![Build Status](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-linux.yml/badge.svg?branch=master)](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-linux.yml?query=branch%3Amaster) |\n|\u003cimg src=\"media/android-logo.png\" width=24 valign=\"middle\"\u003e Android             | [![Build Status](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-android.yml/badge.svg?branch=master)](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-android.yml?query=branch%3Amaster) |\n|\u003cimg src=\"media/macos-logo.png\" width=24 valign=\"middle\"\u003e MacOS                 | [![Build Status](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-apple.yml/badge.svg?branch=master)](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-apple.yml?query=branch%3Amaster) |\n|\u003cimg src=\"media/apple-logo.png\" width=24 valign=\"middle\"\u003e iOS                   | [![Build Status](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-apple.yml/badge.svg?branch=master)](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-apple.yml?query=branch%3Amaster) |\n|\u003cimg src=\"media/tvos-logo.png\" width=24 valign=\"middle\"\u003e tvOS                   | [![Build Status](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-apple.yml/badge.svg?branch=master)](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-apple.yml?query=branch%3Amaster) |\n|\u003cimg src=\"media/emscripten-logo.png\" width=24 valign=\"middle\"\u003e Web              | [![Build Status](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-emscripten.yml/badge.svg?branch=master)](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/build-emscripten.yml?query=branch%3Amaster) | \n\n\n[![Documentation](https://img.shields.io/badge/Documentation-online-0072B1?logo=readthedocs\u0026logoColor=white)](https://diligentgraphics.github.io/docs)\n[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](License.txt)\n[![Chat on Discord](https://img.shields.io/discord/730091778081947680?logo=discord)](https://discord.gg/t7HGBK7)\n[![Lines of code](https://sloc.xyz/github/DiligentGraphics/DiligentCore)](https://github.com/DiligentGraphics/DiligentCore)\n[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/DiligentGraphics/DiligentCore?svg=true)](https://ci.appveyor.com/project/DiligentGraphics/diligentcore)\n[![CodeQL Scanning](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/codeql.yml/badge.svg?branch=master)](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/codeql.yml?query=branch%3Amaster)\n[![MSVC Analysis](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/msvc_analysis.yml/badge.svg?branch=master)](https://github.com/DiligentGraphics/DiligentCore/actions/workflows/msvc_analysis.yml?query=branch%3Amaster)\n\n\n# Table of Contents\n\n- [Cloning the Repository](#cloning)\n- [API Basics](#api_basics)\n  - [Initializing the Engine](#initialization)\n    - [Win32](#initialization_win32)\n    - [Universal Windows Platform](#initialization_uwp)\n    - [Linux](#initialization_linux)\n    - [MacOS](#initialization_macos)\n    - [Android](#initialization_android)\n    - [iOS](#initialization_ios)\n    - [Web](#initialization_web)\n    - [Destroying the Engine](#initialization_destroying)\n  - [Creating Resources](#creating_resources)\n  - [Creating Shaders](#creating_shaders)\n  - [Initializing Pipeline State](#initializing_pso)\n    - [Pipeline Resource Layout](#pipeline_resource_layout)\n  - [Binding Shader Resources](#binding_resources)\n  - [Setting the Pipeline State and Invoking Draw Command](#draw_command)\n- [Low-level API interoperability](#low_level_api_interoperability)\n- [NuGet package build instructions](#nuget_build_instructions)\n- [License](#license)\n- [Contributing](#contributing)\n- [Release History](#release_history)\n\n\n\u003ca name=\"cloning\"\u003e\u003c/a\u003e\n# Cloning the Repository\n\nTo get the repository and all submodules, use the following command:\n\n```\ngit clone --recursive https://github.com/DiligentGraphics/DiligentCore.git\n```\n\nTo build the module, see \n[build instructions](https://github.com/DiligentGraphics/DiligentEngine/blob/master/README.md#build-and-run-instructions) \nin the master repository.\n\n\u003ca name=\"api_basics\"\u003e\u003c/a\u003e\n# API Basics\n\n\u003ca name=\"initialization\"\u003e\u003c/a\u003e\n## Initializing the Engine\n\nBefore you can use any functionality provided by the engine, you need to create a render device, an immediate context and a swap chain.\n\n\u003ca name=\"initialization_win32\"\u003e\u003c/a\u003e\n### Win32\nOn Win32 platform, you can create OpenGL, Direct3D11, Direct3D12 or Vulkan device as shown below:\n\n```cpp\nvoid InitializeDiligentEngine(HWND NativeWindowHandle)\n{\n    SwapChainDesc SCDesc;\n    // RefCntAutoPtr\u003cIRenderDevice\u003e  m_pDevice;\n    // RefCntAutoPtr\u003cIDeviceContext\u003e m_pImmediateContext;\n    // RefCntAutoPtr\u003cISwapChain\u003e     m_pSwapChain;\n    switch (m_DeviceType)\n    {\n        case RENDER_DEVICE_TYPE_D3D11:\n        {\n            EngineD3D11CreateInfo EngineCI;\n#    if ENGINE_DLL\n            // Load the dll and import GetEngineFactoryD3D11() function\n            auto* GetEngineFactoryD3D11 = LoadGraphicsEngineD3D11();\n#    endif\n            auto* pFactoryD3D11 = GetEngineFactoryD3D11();\n            pFactoryD3D11-\u003eCreateDeviceAndContextsD3D11(EngineCI, \u0026m_pDevice, \u0026m_pImmediateContext);\n            Win32NativeWindow Window{hWnd};\n            pFactoryD3D11-\u003eCreateSwapChainD3D11(m_pDevice, m_pImmediateContext, SCDesc,\n                                                FullScreenModeDesc{}, Window, \u0026m_pSwapChain);\n        }\n        break;\n\n        case RENDER_DEVICE_TYPE_D3D12:\n        {\n#    if ENGINE_DLL\n            // Load the dll and import GetEngineFactoryD3D12() function\n            auto GetEngineFactoryD3D12 = LoadGraphicsEngineD3D12();\n#    endif\n            EngineD3D12CreateInfo EngineCI;\n\n            auto* pFactoryD3D12 = GetEngineFactoryD3D12();\n            pFactoryD3D12-\u003eCreateDeviceAndContextsD3D12(EngineCI, \u0026m_pDevice, \u0026m_pImmediateContext);\n            Win32NativeWindow Window{hWnd};\n            pFactoryD3D12-\u003eCreateSwapChainD3D12(m_pDevice, m_pImmediateContext, SCDesc,\n                                                FullScreenModeDesc{}, Window, \u0026m_pSwapChain);\n        }\n        break;\n\n    case RENDER_DEVICE_TYPE_GL:\n    {\n#    if EXPLICITLY_LOAD_ENGINE_GL_DLL\n        // Load the dll and import GetEngineFactoryOpenGL() function\n        auto GetEngineFactoryOpenGL = LoadGraphicsEngineOpenGL();\n#    endif\n        auto* pFactoryOpenGL = GetEngineFactoryOpenGL();\n\n        EngineGLCreateInfo EngineCI;\n        EngineCI.Window.hWnd = hWnd;\n\n        pFactoryOpenGL-\u003eCreateDeviceAndSwapChainGL(EngineCI, \u0026m_pDevice, \u0026m_pImmediateContext,\n                                                   SCDesc, \u0026m_pSwapChain);\n    }\n    break;\n\n    case RENDER_DEVICE_TYPE_VULKAN:\n    {\n#    if EXPLICITLY_LOAD_ENGINE_VK_DLL\n        // Load the dll and import GetEngineFactoryVk() function\n        auto GetEngineFactoryVk = LoadGraphicsEngineVk();\n#    endif\n        EngineVkCreateInfo EngineCI;\n\n        auto* pFactoryVk = GetEngineFactoryVk();\n        pFactoryVk-\u003eCreateDeviceAndContextsVk(EngineCI, \u0026m_pDevice, \u0026m_pImmediateContext);\n        Win32NativeWindow Window{hWnd};\n        pFactoryVk-\u003eCreateSwapChainVk(m_pDevice, m_pImmediateContext, SCDesc, Window, \u0026m_pSwapChain);\n    }\n    break;\n\n    default:\n        std::cerr \u003c\u003c \"Unknown device type\";\n    }\n}\n```\n\nOn Windows, the engine can be statically linked to the application or built as a separate DLL. In the first case,\nfactory functions `GetEngineFactoryOpenGL()`, `GetEngineFactoryD3D11()`, `GetEngineFactoryD3D12()`, and `GetEngineFactoryVk()`\ncan be called directly. In the second case, you need to load the DLL into the process's address space using `LoadGraphicsEngineOpenGL()`,\n`LoadGraphicsEngineD3D11()`, `LoadGraphicsEngineD3D12()`, or `LoadGraphicsEngineVk()` function. Each function loads appropriate\ndynamic library and imports the functions required to initialize the engine. You need to include the following headers:\n\n```cpp\n#include \"EngineFactoryD3D11.h\"\n#include \"EngineFactoryD3D12.h\"\n#include \"EngineFactoryOpenGL.h\"\n#include \"EngineFactoryVk.h\"\n\n```\n\nYou also need to add the following directories to the include search paths:\n\n* `DiligentCore/Graphics/GraphicsEngineD3D11/interface`\n* `DiligentCore/Graphics/GraphicsEngineD3D12/interface`\n* `DiligentCore/Graphics/GraphicsEngineOpenGL/interface`\n* `DiligentCore/Graphics/GraphicsEngineVulkan/interface`\n\nAs an alternative, you may only add the path to the root folder and\nthen use include paths relative to it.\n\nEnable `Diligent` namespace:\n\n```cpp\nusing namespace Diligent;\n```\n\n`IEngineFactoryD3D11::CreateDeviceAndContextsD3D11()`, `IEngineFactoryD3D12::CreateDeviceAndContextsD3D12()`, and \n`IEngineFactoryVk::CreateDeviceAndContextsVk()` functions can also create a specified number of immediate and deferred contexts,\nwhich can be used for asynchronous rendering and multi-threaded command recording. The contexts may only be created during\nthe initialization of the engine. The function populates an array of pointers to the contexts, where the immediates contexts go first,\nfollowed by all deferred contexts.\n\nFor more details, take a look at \n[Tutorial00_HelloWin32.cpp](https://github.com/DiligentGraphics/DiligentSamples/blob/master/Tutorials/Tutorial00_HelloWin32/src/Tutorial00_HelloWin32.cpp) \nfile.\n\n\u003ca name=\"initialization_uwp\"\u003e\u003c/a\u003e\n### Universal Windows Platform\n\nOn Universal Windows Platform, you can create Direct3D11 or Direct3D12 device. Initialization is performed the same\nway as on Win32 Platform. The difference is that you first create the render device and device contexts by\ncalling `IEngineFactoryD3D11::CreateDeviceAndContextsD3D11()` or `IEngineFactoryD3D12::CreateDeviceAndContextsD3D12()`.\nThe swap chain is created later by a call to `IEngineFactoryD3D11::CreateSwapChainD3D11()` or `IEngineFactoryD3D12::CreateSwapChainD3D12()`.\nPlease look at\n[SampleAppUWP.cpp](https://github.com/DiligentGraphics/DiligentSamples/blob/master/SampleBase/src/UWP/SampleAppUWP.cpp) \nfile for more details.\n\n\u003ca name=\"initialization_linux\"\u003e\u003c/a\u003e\n### Linux\n\nOn Linux platform, the engine supports OpenGL and Vulkan backends. Initialization of GL context on Linux is tightly\ncoupled with window creation. As a result, Diligent Engine does not initialize the context, but\nattaches to the one initialized by the app. An example of the engine initialization on Linux can be found in\n[Tutorial00_HelloLinux.cpp](https://github.com/DiligentGraphics/DiligentSamples/blob/master/Tutorials/Tutorial00_HelloLinux/src/Tutorial00_HelloLinux.cpp).\n\n\u003ca name=\"initialization_macos\"\u003e\u003c/a\u003e\n### MacOS\n\nOn MacOS, Diligent Engine supports OpenGL, Vulkan and Metal backends. Initialization of GL context on MacOS is\nperformed by the application, and the engine attaches to the context created by the app; see\n[GLView.mm](https://github.com/DiligentGraphics/DiligentTools/blob/master/NativeApp/Apple/Source/Classes/OSX/GLView.mm)\nfor details. Vulkan backend is initialized similar to other platforms. See \n[MetalView.mm](https://github.com/DiligentGraphics/DiligentTools/blob/master/NativeApp/Apple/Source/Classes/OSX/MetalView.mm).\n\n\u003ca name=\"initialization_android\"\u003e\u003c/a\u003e\n### Android\n\nOn Android, you can create OpenGLES or Vulkan device. The following code snippet shows an example:\n\n```cpp\nauto* pFactoryOpenGL = GetEngineFactoryOpenGL();\nEngineGLCreateInfo EngineCI;\nEngineCI.Window.pAWindow = NativeWindowHandle;\npFactoryOpenGL-\u003eCreateDeviceAndSwapChainGL(\n    EngineCI, \u0026m_pDevice, \u0026m_pContext, SCDesc, \u0026m_pSwapChain);\n```\n\nIf the engine is built as dynamic library, the library needs to be loaded by the native activity. The following code shows one possible way:\n\n```java\nstatic\n{\n    try{\n        System.loadLibrary(\"GraphicsEngineOpenGL\");\n    } catch (UnsatisfiedLinkError e) {\n        Log.e(\"native-activity\", \"Failed to load GraphicsEngineOpenGL library.\\n\" + e);\n    }\n}\n```\n\n\u003ca name=\"initialization_ios\"\u003e\u003c/a\u003e\n### iOS\n\niOS implementation supports OpenGLES, Vulkan and Metal backend. Initialization of GL context on iOS is\nperformed by the application, and the engine attaches to the context initialized by the app; see\n[EAGLView.mm](https://github.com/DiligentGraphics/DiligentTools/blob/master/NativeApp/Apple/Source/Classes/iOS/EAGLView.mm)\nfor details.\n\n\u003ca name=\"initialization_web\"\u003e\u003c/a\u003e\n### Web\n\nOn the Web, you can create OpenGLES or WebGPU device. The following code snippet shows an example:\n\n```cpp\n//You need to pass the id of the canvas to NativeWindow\nauto* pFactoryOpenGL = GetEngineFactoryOpenGL();\nEngineGLCreateInfo EngineCI = {};\nEngineCI.Window = NativeWindow{\"#canvas\"};\npFactoryOpenGL-\u003eCreateDeviceAndSwapChainGL(EngineCI, \u0026m_pDevice, \u0026m_pContext, SCDesc, \u0026m_pSwapChain);\n```\nIf you are using SDL or GLFW with existing context, you can provide null as the native window handle:\n`EngineCI.Window = NativeWindow{nullptr}`\n\n\u003ca name=\"initialization_destroying\"\u003e\u003c/a\u003e\n### Destroying the Engine\n\nThe engine performs automatic reference counting and shuts down when the last reference to an engine object is released.\n\n\u003ca name=\"creating_resources\"\u003e\u003c/a\u003e\n## Creating Resources\n\nDevice resources are created by the render device. The two main resource types are buffers,\nwhich represent linear memory, and textures, which use memory layouts optimized for fast filtering.\nTo create a buffer, you need to populate `BufferDesc` structure and call `IRenderDevice::CreateBuffer()`.\nThe following code creates a uniform (constant) buffer:\n\n```cpp\nBufferDesc BuffDesc;\nBuffDesc.Name           = \"Uniform buffer\";\nBuffDesc.BindFlags      = BIND_UNIFORM_BUFFER;\nBuffDesc.Usage          = USAGE_DYNAMIC;\nBuffDesc.uiSizeInBytes  = sizeof(ShaderConstants);\nBuffDesc.CPUAccessFlags = CPU_ACCESS_WRITE;\nm_pDevice-\u003eCreateBuffer(BuffDesc, nullptr, \u0026m_pConstantBuffer);\n```\n\nSimilar, to create a texture, populate `TextureDesc` structure and call `IRenderDevice::CreateTexture()` as in the following example:\n\n```cpp\nTextureDesc TexDesc;\nTexDesc.Name      = \"My texture 2D\";\nTexDesc.Type      = TEXTURE_TYPE_2D;\nTexDesc.Width     = 1024;\nTexDesc.Height    = 1024;\nTexDesc.Format    = TEX_FORMAT_RGBA8_UNORM;\nTexDesc.Usage     = USAGE_DEFAULT;\nTexDesc.BindFlags = BIND_SHADER_RESOURCE | BIND_RENDER_TARGET | BIND_UNORDERED_ACCESS;\nTexDesc.Name      = \"Sample 2D Texture\";\nm_pRenderDevice-\u003eCreateTexture(TexDesc, nullptr, \u0026m_pTestTex);\n```\n\nThere is only one function `CreateTexture()` that is capable of creating all types of textures. Type, format,\narray size and all other parameters are specified by the members of the `TextureDesc` structure.\n\nFor every bind flag specified during the texture creation time, the texture object creates a default view.\nDefault shader resource view addresses the entire texture, default render target and depth stencil views reference\nall array slices in the most detailed mip level, and unordered access view references the entire texture. To get a\ndefault view from the texture, use `ITexture::GetDefaultView()` function. Note that this function does not increment\nthe reference counter of the returned interface. You can create additional texture views using `ITexture::CreateView()`.\nUse `IBuffer::CreateView()` to create additional views of a buffer.\n\n\u003ca name=\"creating_shaders\"\u003e\u003c/a\u003e\n## Creating Shaders\n\nTo create a shader, populate `ShaderCreateInfo` structure:\n\n```cpp\nShaderCreateInfo ShaderCI;\n```\n\nThere are three ways to create a shader. The first way is to provide a pointer to the shader source code through \n`ShaderCreateInfo::Source` member. The second way is to provide a file name. The third way is to provide a pointer\nto the compiled byte code through `ShaderCreateInfo::ByteCode` member. Graphics Engine is entirely decoupled\nfrom the platform. Since the host file system is platform-dependent, the structure exposes\n`ShaderCreateInfo::pShaderSourceStreamFactory` member that is intended to give the engine access to the file system.\nIf you provided the source file name, you must also provide a non-null pointer to the shader source stream factory.\nIf the shader source contains any `#include` directives, the source stream factory will also be used to load these\nfiles. The engine provides default implementation for every supported platform that should be sufficient in most cases.\nYou can however define your own implementation.\n\nAn important member is `ShaderCreateInfo::SourceLanguage`. The following are valid values for this member:\n\n* `SHADER_SOURCE_LANGUAGE_DEFAULT` - The shader source format matches the underlying graphics API: HLSL for D3D11 or D3D12 mode, and GLSL for OpenGL, OpenGLES, and Vulkan modes.\n* `SHADER_SOURCE_LANGUAGE_HLSL`    - The shader source is in HLSL. For OpenGL and OpenGLES modes, the source code will be \n                                     converted to GLSL. In Vulkan back-end, the code will be compiled to SPIRV directly.\n* `SHADER_SOURCE_LANGUAGE_GLSL`    - The shader source is in GLSL.\n* `SHADER_SOURCE_LANGUAGE_GLSL_VERBATIM` - The shader source language is GLSL and should be compiled verbatim.\n* `SHADER_SOURCE_LANGUAGE_MSL`     - The source language is Metal Shading Language.\n\nOther members of the `ShaderCreateInfo` structure define the shader include search directories, shader macro definitions,\nshader entry point and other parameters.\n\n```cpp\nShaderMacroHelper Macros;\nMacros.AddShaderMacro(\"USE_SHADOWS\", 1);\nMacros.AddShaderMacro(\"NUM_SHADOW_SAMPLES\", 4);\nMacros.Finalize();\nShaderCI.Macros = Macros;\n```\n\nWhen everything is ready, call `IRenderDevice::CreateShader()` to create the shader object:\n\n```cpp\nShaderCreateInfo ShaderCI;\nShaderCI.Desc.Name         = \"MyPixelShader\";\nShaderCI.FilePath          = \"MyShaderFile.fx\";\nShaderCI.EntryPoint        = \"MyPixelShader\";\nShaderCI.Desc.ShaderType   = SHADER_TYPE_PIXEL;\nShaderCI.SourceLanguage    = SHADER_SOURCE_LANGUAGE_HLSL;\nconst auto* SearchDirectories = \"shaders;shaders\\\\inc;\";\nRefCntAutoPtr\u003cIShaderSourceInputStreamFactory\u003e pShaderSourceFactory;\nm_pEngineFactory-\u003eCreateDefaultShaderSourceStreamFactory(SearchDirectories, \u0026pShaderSourceFactory);\nShaderCI.pShaderSourceStreamFactory = pShaderSourceFactory;\nRefCntAutoPtr\u003cIShader\u003e pShader;\nm_pDevice-\u003eCreateShader(ShaderCI, \u0026pShader);\n```\n\n\u003ca name=\"initializing_pso\"\u003e\u003c/a\u003e\n## Initializing Pipeline State\n\nDiligent Engine follows Direct3D12/Vulkan style to configure the graphics/compute pipeline. One monolithic Pipelines State Object (PSO)\nencompasses all required states (all shader stages, input layout description, depth stencil, rasterizer and blend state\ndescriptions etc.). To create a graphics pipeline state object, define an instance of `GraphicsPipelineStateCreateInfo` structure:\n\n```cpp\nGraphicsPipelineStateCreateInfo PSOCreateInfo;\nPipelineStateDesc\u0026              PSODesc = PSOCreateInfo.PSODesc;\n\nPSODesc.Name = \"My pipeline state\";\n```\n\nDescribe the pipeline specifics such as the number and format of render targets as well as depth-stencil format:\n\n```cpp\n// This is a graphics pipeline\nPSODesc.PipelineType                            = PIPELINE_TYPE_GRAPHICS;\nPSOCreateInfo.GraphicsPipeline.NumRenderTargets = 1;\nPSOCreateInfo.GraphicsPipeline.RTVFormats[0]    = TEX_FORMAT_RGBA8_UNORM_SRGB;\nPSOCreateInfo.GraphicsPipeline.DSVFormat        = TEX_FORMAT_D32_FLOAT;\n```\n\nInitialize depth-stencil state description `DepthStencilStateDesc`. Note that the constructor initializes\nthe members with default values and you may only set the ones that are different from default.\n\n```cpp\n// Init depth-stencil state\nDepthStencilStateDesc\u0026 DepthStencilDesc = PSOCreateInfo.GraphicsPipeline.DepthStencilDesc;\nDepthStencilDesc.DepthEnable            = true;\nDepthStencilDesc.DepthWriteEnable       = true;\n```\n\nInitialize blend state description `BlendStateDesc`:\n\n```cpp\n// Init blend state\nBlendStateDesc\u0026 BSDesc = PSOCreateInfo.GraphicsPipeline.BlendDesc;\nBSDesc.IndependentBlendEnable = False;\nauto \u0026RT0 = BSDesc.RenderTargets[0];\nRT0.BlendEnable           = True;\nRT0.RenderTargetWriteMask = COLOR_MASK_ALL;\nRT0.SrcBlend              = BLEND_FACTOR_SRC_ALPHA;\nRT0.DestBlend             = BLEND_FACTOR_INV_SRC_ALPHA;\nRT0.BlendOp               = BLEND_OPERATION_ADD;\nRT0.SrcBlendAlpha         = BLEND_FACTOR_SRC_ALPHA;\nRT0.DestBlendAlpha        = BLEND_FACTOR_INV_SRC_ALPHA;\nRT0.BlendOpAlpha          = BLEND_OPERATION_ADD;\n```\n\nInitialize rasterizer state description `RasterizerStateDesc`:\n\n```cpp\n// Init rasterizer state\nRasterizerStateDesc\u0026 RasterizerDesc = PSOCreateInfo.GraphicsPipeline.RasterizerDesc;\nRasterizerDesc.FillMode              = FILL_MODE_SOLID;\nRasterizerDesc.CullMode              = CULL_MODE_NONE;\nRasterizerDesc.FrontCounterClockwise = True;\nRasterizerDesc.ScissorEnable         = True;\nRasterizerDesc.AntialiasedLineEnable = False;\n```\n\nInitialize input layout description `InputLayoutDesc`:\n\n```cpp\n// Define input layout\nInputLayoutDesc\u0026 Layout = PSOCreateInfo.GraphicsPipeline.InputLayout;\nLayoutElement LayoutElems[] =\n{\n    LayoutElement( 0, 0, 3, VT_FLOAT32, False ),\n    LayoutElement( 1, 0, 4, VT_UINT8,   True ),\n    LayoutElement( 2, 0, 2, VT_FLOAT32, False ),\n};\nLayout.LayoutElements = LayoutElems;\nLayout.NumElements    = _countof(LayoutElems);\n```\n\nDefine primitive topology and set shader pointers:\n\n```cpp\n// Define shader and primitive topology\nPSOCreateInfo.GraphicsPipeline.PrimitiveTopology = PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;\nPSOCreateInfo.pVS = m_pVS;\nPSOCreateInfo.pPS = m_pPS;\n```\n\n\u003ca name=\"pipeline_resource_layout\"\u003e\u003c/a\u003e\n### Pipeline Resource Layout\n\nPipeline resource layout informs the engine how the application is going to use different shader resource variables.\nTo allow grouping of resources based on the expected frequency of resource bindings changes, Diligent Engine introduces\nclassification of shader variables:\n\n* **Static variables** (`SHADER_RESOURCE_VARIABLE_TYPE_STATIC`) are variables that are expected to be set only once.\n  They may not be changed once a resource is bound to the variable. Such variables are intended to hold global constants such \n  as camera attributes or global light attributes constant buffers. Note that it is the *resource binding* that may not change,\n  while the contents of the resource is allowed to change according to its usage.\n* **Mutable variables** (`SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE`) define resources that are expected to change on a per-material frequency.\n  Examples may include diffuse textures, normal maps etc. Again updates to the contents of the resource are orthogobal\n  to the binding changes.\n* **Dynamic variables** (`SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC`) are expected to change frequently and randomly.\n\nTo define variable types, prepare an array of `ShaderResourceVariableDesc` structures and\ninitialize `PSODesc.ResourceLayout.Variables` and `PSODesc.ResourceLayout.NumVariables` members. Also\n`PSODesc.ResourceLayout.DefaultVariableType` can be used to set the type that will be used if a variable name is not provided.\n\n```cpp\nShaderResourceVariableDesc ShaderVars[] =\n{\n    {SHADER_TYPE_PIXEL, \"g_StaticTexture\",  SHADER_RESOURCE_VARIABLE_TYPE_STATIC},\n    {SHADER_TYPE_PIXEL, \"g_MutableTexture\", SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},\n    {SHADER_TYPE_PIXEL, \"g_DynamicTexture\", SHADER_RESOURCE_VARIABLE_TYPE_DYNAMIC}\n};\nPSODesc.ResourceLayout.Variables           = ShaderVars;\nPSODesc.ResourceLayout.NumVariables        = _countof(ShaderVars);\nPSODesc.ResourceLayout.DefaultVariableType = SHADER_RESOURCE_VARIABLE_TYPE_STATIC;\n```\n\nWhen creating a pipeline state, textures can be permanently assigned immutable samplers. If an immutable sampler is assigned to a texture,\nit will always be used instead of the one initialized in the texture shader resource view. To define immutable samplers,\nprepare an array of `ImmutableSamplerDesc` structures and initialize `PSODesc.ResourceLayout.ImmutableSamplers` and\n`PSODesc.ResourceLayout.NumImmutableSamplers` members. Notice that immutable samplers can be assigned to a texture variable of any type,\nnot necessarily static, so that the texture binding can be changed at run-time, while the sampler will stay immutable.\nIt is highly recommended to use immutable samplers whenever possible.\n\n```cpp\nImmutableSamplerDesc ImtblSampler;\nImtblSampler.ShaderStages   = SHADER_TYPE_PIXEL;\nImtblSampler.Desc.MinFilter = FILTER_TYPE_LINEAR;\nImtblSampler.Desc.MagFilter = FILTER_TYPE_LINEAR;\nImtblSampler.Desc.MipFilter = FILTER_TYPE_LINEAR;\nImtblSampler.TextureName    = \"g_MutableTexture\";\nPSODesc.ResourceLayout.NumImmutableSamplers = 1;\nPSODesc.ResourceLayout.ImmutableSamplers    = \u0026ImtblSampler;\n```\n\n[This document](https://github.com/DiligentGraphics/DiligentCore/blob/master/doc/TextureSamplers.md) provides a detailed\ninformation about working with texture samplers.\n\nWhen all required fields of PSO description structure are set, call `IRenderDevice::CreateGraphicsPipelineState()`\nto create the PSO object:\n\n```cpp\nm_pDevice-\u003eCreateGraphicsPipelineState(PSOCreateInfo, \u0026m_pPSO);\n```\n\n\u003ca name=\"binding_resources\"\u003e\u003c/a\u003e\n## Binding Shader Resources\n\nAs mentioned above, [shader resource binding in Diligent Engine](http://diligentgraphics.com/2016/03/23/resource-binding-model-in-diligent-engine-2-0/)\nis based on grouping variables in 3 different groups (static, mutable and dynamic). Static variables are variables that are\nexpected to be set only once. They may not be changed once a resource is bound to the variable. Such variables are intended\nto hold global constants such as camera attributes or global light attributes constant buffers. They are bound directly to the\nPipeline State Object:\n\n```cpp\nm_pPSO-\u003eGetStaticShaderVariable(SHADER_TYPE_PIXEL, \"g_tex2DShadowMap\")-\u003eSet(pShadowMapSRV);\n```\n\nMutable and dynamic variables are bound via a new object called Shader Resource Binding (SRB), which is created by the pipeline state\n(`IPipelineState::CreateShaderResourceBinding()`), or pipeline resource signature in advanced use cases:\n\n```cpp\nm_pPSO-\u003eCreateShaderResourceBinding(\u0026m_pSRB, true);\n```\n\nThe second parameter tells the system to initialize internal structures in the SRB object\nthat reference static variables in the PSO.\n\nDynamic and mutable resources are then bound through the SRB object:\n\n```cpp\nm_pSRB-\u003eGetVariable(SHADER_TYPE_PIXEL,  \"tex2DDiffuse\")-\u003eSet(pDiffuseTexSRV);\nm_pSRB-\u003eGetVariable(SHADER_TYPE_VERTEX, \"cbRandomAttribs\")-\u003eSet(pRandomAttrsCB);\n```\n\nThe difference between mutable and dynamic resources is that mutable resources can only be set once per instance\nof a shader resource binding. Dynamic resources can be set multiple times. It is important to properly set the variable type as\nthis affects performance. Static and mutable variables are more efficient. Dynamic variables are more expensive\nand introduce some run-time overhead.\n\nAn alternative way to bind shader resources is to create an `IResourceMapping` interface that maps resource literal names to the\nactual resources:\n\n```cpp\nResourceMappingEntry Entries[] =\n{\n    {\"g_Texture\", pTexture-\u003eGetDefaultView(TEXTURE_VIEW_SHADER_RESOURCE)}\n};\nResourceMappingCreateInfo ResMappingCI;\nResMappingCI.pEntries   = Entries;\nResMappingCI.NumEntries = _countof(Entries);\nRefCntAutoPtr\u003cIResourceMapping\u003e pResMapping;\npRenderDevice-\u003eCreateResourceMapping(ResMappingCI, \u0026pResMapping);\n```\n\nThe resource mapping can then be used to bind all static resources in a pipeline state (`IPipelineState::BindStaticResources()`):\n\n```cpp\nm_pPSO-\u003eBindStaticResources(SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, pResMapping,\n                            BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED);\n```\n\nor all mutable and dynamic resources in a shader resource binding (`IShaderResourceBinding::BindResources()`):\n\n```cpp\nm_pSRB-\u003eBindResources(SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, pResMapping,\n                      BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED);\n```\n\nThe last parameter to all `BindResources()` functions defines how resources should be resolved:\n\n* `BIND_SHADER_RESOURCES_UPDATE_STATIC` - Indicates that static variable bindings are to be updated.\n* `BIND_SHADER_RESOURCES_UPDATE_MUTABLE` - Indicates that mutable variable bindings are to be updated.\n* `BIND_SHADER_RESOURCES_UPDATE_DYNAMIC` -Indicates that dynamic variable bindings are to be updated.\n* `BIND_SHADER_RESOURCES_UPDATE_ALL` - Indicates that all variable types (static, mutable and dynamic) are to be updated.\n   Note that if none of `BIND_SHADER_RESOURCES_UPDATE_STATIC`, `BIND_SHADER_RESOURCES_UPDATE_MUTABLE`, and \n   `BIND_SHADER_RESOURCES_UPDATE_DYNAMIC` flags are set, all variable types are updated as if `BIND_SHADER_RESOURCES_UPDATE_ALL` was specified.\n* `BIND_SHADER_RESOURCES_KEEP_EXISTING` - If this flag is specified, only unresolved bindings will be updated. All existing bindings will keep their original values. If this flag is not specified, every shader variable will be updated if the mapping contains corresponding resource.\n* `BIND_SHADER_RESOURCES_VERIFY_ALL_RESOLVED` - If this flag is specified, all shader bindings are expected be resolved after the call. If this is not the case, an error will be reported.\n\n`BindResources()` may be called several times with different resource mappings to bind resources.\nHowever, it is recommended to use one large resource mapping as the size of the mapping does not affect element search time.\n\nThe engine performs run-time checks to verify that correct resources are being bound. For example, if you try to bind\na constant buffer to a shader resource view variable, an error will be output to the debug console.\n\n\u003ca name=\"draw_command\"\u003e\u003c/a\u003e\n## Setting the Pipeline State and Invoking Draw Command\n\nBefore any draw command can be invoked, all required vertex and index buffers as well as the pipeline state should\nbe bound to the device context:\n\n```cpp\n// Set render targets before issuing any draw command.\nauto* pRTV = m_pSwapChain-\u003eGetCurrentBackBufferRTV();\nauto* pDSV = m_pSwapChain-\u003eGetDepthBufferDSV();\nm_pContext-\u003eSetRenderTargets(1, \u0026pRTV, pDSV, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);\n\n// Clear render target and depth-stencil\nconst float zero[4] = {0, 0, 0, 0};\nm_pContext-\u003eClearRenderTarget(pRTV, ClearColor, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);\nm_pContext-\u003eClearDepthStencil(pDSV, CLEAR_DEPTH_FLAG, 1.f, 0, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);\n\n// Set vertex and index buffers\nIBuffer* buffer[] = {m_pVertexBuffer};\nUint32 offsets[] = {0};\nm_pContext-\u003eSetVertexBuffers(0, 1, buffer, offsets, SET_VERTEX_BUFFERS_FLAG_RESET,\n                             RESOURCE_STATE_TRANSITION_MODE_TRANSITION);\nm_pContext-\u003eSetIndexBuffer(m_pIndexBuffer, 0, RESOURCE_STATE_TRANSITION_MODE_TRANSITION);\n\nm_pContext-\u003eSetPipelineState(m_pPSO);\n```\n\nAll methods that may need to perform resource state transitions take `RESOURCE_STATE_TRANSITION_MODE` enum\nas parameter. The enum defines the following modes:\n\n* `RESOURCE_STATE_TRANSITION_MODE_NONE` - Perform no resource state transitions.\n* `RESOURCE_STATE_TRANSITION_MODE_TRANSITION` - Transition resources to the states required by the command.\n* `RESOURCE_STATE_TRANSITION_MODE_VERIFY` - Do not transition, but verify that states are correct.\n\nThe final step is to commit shader resources to the device context. This is accomplished by\nthe `IDeviceContext::CommitShaderResources()` method:\n\n```cpp\nm_pContext-\u003eCommitShaderResources(m_pSRB, COMMIT_SHADER_RESOURCES_FLAG_TRANSITION_RESOURCES);\n```\n\nIf the method is not called, the engine will detect that resources are not committed and output a\ndebug message. Note that the last parameter tells the system to transition resources to correct states.\nIf this flag is not specified, the resources must be explicitly transitioned to required states by a call to\n`IDeviceContext::TransitionShaderResources()`:\n\n```cpp\nm_pContext-\u003eTransitionShaderResources(m_pPSO, m_pSRB);\n```\n\nNote that the method requires pointer to the pipeline state that created the shader resource binding.\n\nWhen all required states and resources are bound, `IDeviceContext::DrawIndexed()` can be used to execute a draw\ncommand or `IDeviceContext::DispatchCompute()` can be used to execute a compute command. Note that for a draw command,\na graphics pipeline must be bound, and for a dispatch command, a compute pipeline must be bound. `DrawIndexed()` takes\n`DrawIndexedAttribs` structure as an argument, for example:\n\n```cpp\nDrawIndexedAttribs attrs;\nattrs.IndexType  = VT_UINT16;\nattrs.NumIndices = 36;\nattrs.Flags      = DRAW_FLAG_VERIFY_STATES;\npContext-\u003eDrawIndexed(attrs);\n```\n\n`DRAW_FLAG_VERIFY_STATES` flag instructs the engine to verify that vertex and index buffers used by the\ndraw command are transitioned to proper states.\n\n`DispatchCompute()` takes `DispatchComputeAttribs` structure that defines compute grid dimensions:\n\n```cpp\nm_pContext-\u003eSetPipelineState(m_pComputePSO);\nm_pContext-\u003eCommitShaderResources(m_pComputeSRB, COMMIT_SHADER_RESOURCES_FLAG_TRANSITION_RESOURCES);\nDispatchComputeAttribs DispatchAttrs{64, 64, 8};\nm_pContext-\u003eDispatchCompute(DispatchAttrs);\n```\n\nYou can learn more about the engine API by studying [samples and tutorials](https://github.com/DiligentGraphics/DiligentSamples).\n\n\n\u003ca name=\"low_level_api_interoperability\"\u003e\u003c/a\u003e\n# Low-level API interoperability\n\nDiligent Engine extensively supports interoperability with underlying low-level APIs. The engine can be initialized\nby attaching to existing D3D11/D3D12 device or OpenGL/GLES context and provides access to the underlying native API\nobjects. Refer to the following pages for more information:\n\n[Direct3D11 Interoperability](https://github.com/DiligentGraphics/DiligentCore/tree/master/Graphics/GraphicsEngineD3D11#interoperability-with-direct3d11)\n\n[Direct3D12 Interoperability](https://github.com/DiligentGraphics/DiligentCore/tree/master/Graphics/GraphicsEngineD3D12#interoperability-with-direct3d12)\n\n[OpenGL/GLES Interoperability](https://github.com/DiligentGraphics/DiligentCore/tree/master/Graphics/GraphicsEngineOpenGL#interoperability-with-openglgles)\n\n[Vulkan Interoperability](https://github.com/DiligentGraphics/DiligentCore/tree/master/Graphics/GraphicsEngineVulkan#interoperability-with-vulkan)\n\n\n\u003ca name=\"nuget_build_instructions\"\u003e\u003c/a\u003e\n# NuGet Package Build Instructions\n\nFollow the following steps to build the NuGet package:\n\n1. Install the required Python packages\n\n\n```\npython -m pip install -r ./BuildTools/.NET/requirements.txt\n```\n\n2. Run the NuGet package build script, for example:\n\n\n```\npython ./BuildTools/.NET/dotnet-build-package.py -c Debug -d ./\n```\n\n## Command Line Arguments\n\n|       Argument             |         Description                                                             |   Required          |\n|----------------------------|---------------------------------------------------------------------------------|---------------------|\n| `-c` (`configuration`)     | Native dynamic libraries build configuration (e.g. Debug, Release, etc.)        |  Yes                |\n| `-d` (`root-dir`)          | The path to the root directory of DiligentCore                                  |  Yes                |\n| `-s` (`settings`)          | The path to the settings file                                                   |  No                 |\n| `dotnet-tests`             | Flag indicating whether to run .NET tests                                       |  No                 |\n| `dotnet-publish`           | Flag indicating whether to publish the package to NuGet Gallery                 |  No                 |\n| `free-memory`              | Use this argument if you encounter insufficient memory during the build process |  No                 |\n\nYou can override the default settings using a settings file \n(check the `default_settings` dictionary in `dotnet-build-package.py`)\n\n\u003ca name=\"license\"\u003e\u003c/a\u003e\n# License\n\nSee [Apache 2.0 license](License.txt).\n\nThis project has some third-party dependencies, each of which may have independent licensing:\n\n* [Vulkan-Headers](https://github.com/KhronosGroup/Vulkan-Headers): Vulkan Header files and API registry ([Apache License 2.0](https://github.com/DiligentGraphics/Vulkan-Headers/blob/master/LICENSE.md)).\n* [SPIRV-Cross](https://github.com/KhronosGroup/SPIRV-Cross): SPIRV parsing and cross-compilation tools ([Apache License 2.0](https://github.com/DiligentGraphics/SPIRV-Cross/blob/master/LICENSE)).\n* [SPIRV-Headers](https://github.com/KhronosGroup/SPIRV-Headers): SPIRV header files ([Khronos MIT-like license](https://github.com/DiligentGraphics/SPIRV-Headers/blob/master/LICENSE)).\n* [SPIRV-Tools](https://github.com/KhronosGroup/SPIRV-Tools): SPIRV optimization and validation tools ([Apache License 2.0](https://github.com/DiligentGraphics/SPIRV-Tools/blob/master/LICENSE)).\n* [glslang](https://github.com/KhronosGroup/glslang): Khronos reference compiler and validator for GLSL, ESSL, and HLSL ([3-Clause BSD License, 2-Clause BSD License, MIT, Apache License 2.0](https://github.com/DiligentGraphics/glslang/blob/master/LICENSE.txt)).\n* [glew](http://glew.sourceforge.net/): OpenGL Extension Wrangler Library ([Mesa 3-D graphics library, Khronos MIT-like license](https://github.com/DiligentGraphics/DiligentCore/blob/master/ThirdParty/glew/LICENSE.txt)).\n* [volk](https://github.com/zeux/volk): Meta loader for Vulkan API ([Arseny Kapoulkine MIT-like license](https://github.com/DiligentGraphics/volk/blob/master/LICENSE.md)).\n* [stb](https://github.com/nothings/stb): stb single-file public domain libraries for C/C++ ([MIT License or public domain](https://github.com/DiligentGraphics/DiligentCore/blob/master/ThirdParty/stb/stb_image_write.h#L1581)).\n* [googletest](https://github.com/google/googletest): Google Testing and Mocking Framework ([BSD 3-Clause \"New\" or \"Revised\" License](https://github.com/DiligentGraphics/googletest/blob/master/LICENSE)).\n* [DirectXShaderCompiler](https://github.com/microsoft/DirectXShaderCompiler): LLVM/Clang-based DirectX Shader Compiler ([LLVM Release License](https://github.com/DiligentGraphics/DiligentCore/blob/master/ThirdParty/DirectXShaderCompiler/LICENSE.TXT)).\n* [DXBCChecksum](ThirdParty/GPUOpenShaderUtils): DXBC Checksum computation algorithm by AMD Developer Tools Team ([MIT lincesne](ThirdParty/GPUOpenShaderUtils/License.txt)).\n* [xxHash](https://github.com/Cyan4973/xxHash): Extremely fast non-cryptographic hash algorithm ([2-Clause BSD License](https://github.com/DiligentGraphics/xxHash/blob/dev/LICENSE)).\n\n\u003ca name=\"contributing\"\u003e\u003c/a\u003e\n# Contributing\n\nTo contribute your code, submit a [Pull Request](https://github.com/DiligentGraphics/DiligentCore/pulls) \nto this repository. **Diligent Engine** is distributed under the [Apache 2.0 license](License.txt) that guarantees \nthat content in the **DiligentCore** repository is free of Intellectual Property encumbrances. \nIn submitting any content to this repository,\n[you license that content under the same terms](https://docs.github.com/en/free-pro-team@latest/github/site-policy/github-terms-of-service#6-contributions-under-repository-license),\nand you agree that the content is free of any Intellectual Property claims and you have the right to license it under those terms. \n\nDiligent Engine uses [clang-format](https://clang.llvm.org/docs/ClangFormat.html) to ensure\nconsistent source code style throughout the code base. The format is validated by CI\nfor each commit and pull request, and the build will fail if any code formatting issue is found. Please refer\nto [this page](https://github.com/DiligentGraphics/DiligentCore/blob/master/doc/code_formatting.md) for instructions\non how to set up clang-format and automatic code formatting.\n\n\n\u003ca name=\"release_history\"\u003e\u003c/a\u003e\n# Release History\n\nSee [Release History](ReleaseHistory.md)\n\n-------------------\n\n[diligentgraphics.com](http://diligentgraphics.com)\n\n[![Diligent Engine on Twitter](https://github.com/DiligentGraphics/DiligentCore/blob/master/media/twitter.png)](https://twitter.com/diligentengine)\n[![Diligent Engine on Facebook](https://github.com/DiligentGraphics/DiligentCore/blob/master/media/facebook.png)](https://www.facebook.com/DiligentGraphics/)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdiligentgraphics%2Fdiligentcore","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fdiligentgraphics%2Fdiligentcore","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fdiligentgraphics%2Fdiligentcore/lists"}