# diligentgraphics/diligentcore architecture

> Architecture diagram of the GitHub repository diligentgraphics/diligentcore, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2026-06-29). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/diligentgraphics/diligentcore
- Repository: https://github.com/diligentgraphics/diligentcore

## Overview

1. **Repository role**
   - This is the core, low-level graphics layer for Diligent Engine.
   - It is not an application; it is a cross-platform engine foundation that exposes a unified API over multiple graphics backends.

2. **Top-level architecture**
   - The codebase is organized into reusable strata:
     - `Primitives` for base types, reference counting, memory utilities, and C-style interface helpers.
     - `Platforms` for OS-specific filesystem, window, debug, and platform glue.
     - `Common` for engine-agnostic utilities shared across all graphics backends.
     - `Graphics` for the graphics API, backend implementations, shader tools, and auxiliary graphics modules.
     - `Tests` for API, include, and GPU validation.
     - `ThirdParty` for bundled external libraries used by shader compilation, graphics API loading, testing, and math/hash utilities.

3. **Core runtime flow**
   - An application starts by obtaining a backend-specific factory, then creates:
     - a `RenderDevice`
     - one or more `DeviceContext`s
     - an `SwapChain`
   - From there, resources are created on the device, state is encoded in pipeline objects, shader resources are bound, and commands are submitted through the device context.
   - The engine performs resource state tracking and transitions internally, so the API is closer to D3D12/Vulkan than to older immediate-mode APIs.

4. **Backend split**
   - There are separate backend modules for:
     - D3D11
     - D3D12
     - OpenGL / OpenGLES
     - Vulkan
     - WebGPU
     - Metal appears as a commercial backend
   - Each backend has its own `GraphicsEngine<API>` module with:
     - `interface` headers for API-specific extensions
     - `include` for internal implementation types
     - `src` for concrete object implementations
   - These backends implement the same conceptual object model, but map it to different native APIs and lifetime rules.

5. **Shared graphics core**
   - `Graphics/GraphicsEngine` contains the backend-neutral interfaces and base implementations for engine objects such as buffers, textures, shaders, pipeline states, render passes, fences, queries, resource mappings, and swap chains.
   - This is the central abstraction layer that all backend-specific implementations inherit from or wrap.
   - It is where the common object model is defined, while backend modules specialize behavior.

6. **Platform boundary**
   - `Platforms/*` encapsulates OS-specific integration:
     - native window handles
     - filesystem access for shader/source loading
     - debug output
     - platform capability and misc helpers
   - This keeps the graphics layer decoupled from the host OS, especially for shader source loading and swap chain creation.
   - The repository supports Win32, UWP, Linux, Android, Apple platforms, and Emscripten/Web.

7. **Shader and pipeline compilation toolchain**
   - `Graphics/ShaderTools` and `ThirdParty/DirectXShaderCompiler`, `glslang`, `SPIRV-Tools`, `SPIRV-Cross`, and `volk` form the shader compilation and translation toolchain.
   - `ShaderTools` handles parsing, preprocessing, resource binding analysis, HLSL/GLSL/WGSL utilities, and DXBC/DXIL-related helpers.
   - This subsystem materially affects architecture because shader sources may be compiled differently per backend:
     - HLSL can be compiled to DXIL, SPIR-V, GLSL, or MSL depending on target
     - GLSL and WGSL paths have their own validation/resource extraction helpers

8. **Resource binding and PSO model**
   - The engine centers around monolithic pipeline state objects and explicit shader resource binding.
   - Resource layout is split into static, mutable, and dynamic variables to reflect binding frequency and performance expectations.
   - This model is consistent across backends, but each backend stores and resolves bindings using its own native descriptor, root signature, or binding-layout structures.
   - Immutable samplers and resource mappings are first-class parts of the pipeline/resource architecture.

9. **Command submission and synchronization**
   - `DeviceContext` is the main submission boundary for drawing, dispatch, clearing, and resource transitions.
   - Synchronization is represented by fences, queries, and backend-specific command queues or managers.
   - The architecture separates:
     - resource creation on `RenderDevice`
     - command encoding on `DeviceContext`
     - presentation through `SwapChain`
   - Backends like D3D12/Vulkan/WebGPU use more explicit queue, descriptor, and heap management internally, while D3D11/OpenGL adapt the same API to more implicit driver models.

10. **Backend support modules**
   - Some shared helper layers exist for families of APIs:
     - `GraphicsEngineD3DBase` for D3D11/D3D12 common conversions and shader/resource validation
     - `GraphicsEngineNextGenBase` for shared next-gen patterns
     - `GraphicsAccessories` for cross-backend utilities such as dynamic atlases, upload helpers, ring buffers, caches, and screen capture
   - These modules reduce duplication across implementations and are important diagram nodes because they sit between the generic engine and individual backends.

11. **Specialized feature modules**
   - `Graphics/Archiver` provides serialization/de-serialization for engine objects and pipeline state assets.
   - `Graphics/SuperResolution` wraps upscaling features such as DLSS, FSR, and DSR-style providers behind a common factory/provider API.
   - `Graphics/GraphicsEngine.NET` exposes the core engine to .NET consumers through interop bindings.
   - `Graphics/HLSL2GLSLConverterLib` is a standalone shader translation library used by shader tooling.

12. **Tests and validation**
   - `Tests/DiligentCoreTest` and `Tests/DiligentCoreAPITest` validate the common utilities, shader tools, graphics utilities, and runtime API behavior.
   - `Tests/GPUTestFramework` provides backend-specific test environments and swap chains.
   - `Tests/IncludeTest` checks header usability and C/C++ interface stability.
   - There are also .NET tests under `Tests/DiligentCoreTest.NET`.
   - These tests are architecture-relevant because they mirror the repo’s public layering and backend separation.

13. **Build, packaging, and CI**
   - CMake is the primary build system, with extra build tooling for Android, .NET/NuGet packaging, formatting validation, and sanitizer support.
   - GitHub Actions workflows build per platform and backend, including Windows, Linux, Android, Apple, Emscripten, and NuGet publication.
   - The presence of separate workflows and per-platform build tools reflects the repo’s multi-target deployment model.

14. **External dependencies that shape the design**
   - The repo vendors graphics and shader dependencies directly under `ThirdParty`.
   - OpenGL and Vulkan loading/header layers, shader compiler stacks, testing framework, and utility libraries are not incidental; they are part of the engine’s portability and cross-API strategy.
   - These dependencies make the architecture highly modular but also backend-sensitive, especially for shader compilation and native API interop.

15. **How to draw the diagram**
   - A good architecture diagram should show:
     - the application at the top
     - the unified Diligent Core API in the middle
     - platform glue and shader tooling as supporting subsystems
     - multiple backend implementations underneath the shared API
     - native graphics APIs and OS services at the bottom
   - Then show the optional side paths for archiving, super-resolution, .NET bindings, and test harnesses.

Main entry points: [`Graphics/GraphicsEngine`](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngine) (Graphics core), [`Graphics/ShaderTools`](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/ShaderTools) (Shader tools), [`Graphics/GraphicsEngineD3D12`](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineD3D12) (D3D12 backend), [`Tests/DiligentCoreAPITest`](https://github.com/diligentgraphics/diligentcore/tree/master/Tests/DiligentCoreAPITest) (API tests)

## Diagram (Mermaid)

```mermaid
flowchart TD

subgraph group_grp_primitives["Primitives"]
  node_primitives["Base layer<br/>core primitives"]
end

subgraph group_grp_platforms["Platforms"]
  node_platforms["Platform glue<br/>os abstraction"]
end

subgraph group_grp_common["Common"]
  node_common["Shared utils<br/>utility core"]
end

subgraph group_grp_graphics["Graphics"]
  node_graphics_engine["Graphics core<br/>unified API"]
  node_shader_tools["Shader tools<br/>compiler tooling"]
  node_graphics_accessories["Accessories<br/>cross-backend helpers"]
  node_graphics_tools["Graphics tools<br/>higher-level helpers"]
  node_archiver["Archiver<br/>serialization"]
  node_super_resolution["Super resolution<br/>upscaling API"]
  node_dotnet[".NET binding<br/>interop layer<br/>[GraphicsEngine.NET]"]
  node_d3d_base["D3D base<br/>shared D3D support"]
  node_nextgen_base["Next-gen base<br/>shared backend base"]
  node_d3d11["D3D11 backend<br/>backend impl"]
  node_d3d12["D3D12 backend<br/>backend impl"]
  node_opengl["OpenGL backend<br/>backend impl"]
  node_vulkan["Vulkan backend<br/>backend impl"]
  node_webgpu["WebGPU backend<br/>backend impl"]
  node_metal["Metal backend<br/>commercial backend"]
end

subgraph group_grp_tests["Tests"]
  node_tests_core["Core tests<br/>validation suite"]
  node_tests_api["API tests<br/>validation suite"]
  node_tests_include["Include tests<br/>validation suite"]
  node_tests_gpu["GPU framework<br/>test harness"]
  node_tests_dotnet[".NET tests<br/>validation suite"]
end

subgraph group_grp_thirdparty["ThirdParty"]
  node_dxcompiler["DXC<br/>shader compiler"]
  node_glslang["glslang<br/>shader compiler"]
  node_spirv_tools["SPIRV-Tools<br/>shader tooling"]
  node_spirv_cross["SPIRV-Cross<br/>shader translation"]
  node_volk["volk<br/>vulkan loader"]
  node_dawn["dawn<br/>webgpu stack"]
  node_glew["glew<br/>gl loader"]
end

node_app(("Application<br/>consumer"))

node_app -->|"creates device/context/swapchain"| node_graphics_engine
node_app -->|"uses host services"| node_platforms
node_graphics_engine -->|"built on"| node_primitives
node_graphics_engine -->|"reuses utilities"| node_common
node_graphics_engine -->|"depends on"| node_platforms
node_graphics_engine -->|"feeds shader data"| node_shader_tools
node_graphics_tools -->|"extends"| node_graphics_engine
node_graphics_accessories -->|"supports"| node_graphics_engine
node_archiver -->|"serializes"| node_graphics_engine
node_super_resolution -->|"uses"| node_graphics_engine
node_dotnet -->|"binds"| node_graphics_engine
node_tests_core -->|"validates"| node_common
node_tests_core -->|"validates"| node_shader_tools
node_tests_api -->|"validates"| node_graphics_engine
node_tests_api -->|"validates"| node_archiver
node_tests_api -->|"validates"| node_super_resolution
node_tests_include -->|"checks headers"| node_graphics_engine
node_tests_gpu -->|"hosts"| node_graphics_engine
node_tests_dotnet -->|"validates"| node_dotnet
node_shader_tools -->|"uses"| node_dxcompiler
node_shader_tools -->|"uses"| node_glslang
node_shader_tools -->|"uses"| node_spirv_tools
node_shader_tools -->|"uses"| node_spirv_cross
node_d3d_base -->|"specializes"| node_graphics_engine
node_nextgen_base -->|"specializes"| node_graphics_engine
node_d3d11 -->|"inherits patterns"| node_d3d_base
node_d3d12 -->|"inherits patterns"| node_d3d_base
node_d3d12 -->|"inherits patterns"| node_nextgen_base
node_d3d11 -->|"shader path"| node_dxcompiler
node_d3d12 -->|"shader path"| node_dxcompiler
node_opengl -->|"loads API"| node_glew
node_vulkan -->|"loads API"| node_volk
node_webgpu -->|"integrates"| node_dawn
node_opengl -->|"uses"| node_shader_tools
node_vulkan -->|"uses"| node_shader_tools
node_webgpu -->|"uses"| node_shader_tools
node_metal -->|"uses"| node_shader_tools

click node_primitives "https://github.com/diligentgraphics/diligentcore/tree/master/Primitives"
click node_platforms "https://github.com/diligentgraphics/diligentcore/tree/master/Platforms"
click node_common "https://github.com/diligentgraphics/diligentcore/tree/master/Common"
click node_graphics_engine "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngine"
click node_shader_tools "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/ShaderTools"
click node_graphics_accessories "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsAccessories"
click node_graphics_tools "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsTools"
click node_archiver "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/Archiver"
click node_super_resolution "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/SuperResolution"
click node_dotnet "https://github.com/diligentgraphics/diligentcore/blob/master/Graphics/GraphicsEngine.NET"
click node_d3d_base "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineD3DBase"
click node_nextgen_base "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineNextGenBase"
click node_d3d11 "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineD3D11"
click node_d3d12 "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineD3D12"
click node_opengl "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineOpenGL"
click node_vulkan "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineVulkan"
click node_webgpu "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineWebGPU"
click node_metal "https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineMetal"
click node_tests_core "https://github.com/diligentgraphics/diligentcore/tree/master/Tests/DiligentCoreTest"
click node_tests_api "https://github.com/diligentgraphics/diligentcore/tree/master/Tests/DiligentCoreAPITest"
click node_tests_include "https://github.com/diligentgraphics/diligentcore/tree/master/Tests/IncludeTest"
click node_tests_gpu "https://github.com/diligentgraphics/diligentcore/tree/master/Tests/GPUTestFramework"
click node_tests_dotnet "https://github.com/diligentgraphics/diligentcore/blob/master/Tests/DiligentCoreTest.NET"
click node_dxcompiler "https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/DirectXShaderCompiler"
click node_glslang "https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/glslang"
click node_spirv_tools "https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/SPIRV-Tools"
click node_spirv_cross "https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/SPIRV-Cross"
click node_volk "https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/volk"
click node_dawn "https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/dawn"
click node_glew "https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/glew"

classDef toneNeutral fill:#f8fafc,stroke:#334155,stroke-width:1.5px,color:#0f172a
classDef toneBlue fill:#dbeafe,stroke:#2563eb,stroke-width:1.5px,color:#172554
classDef toneAmber fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
classDef toneMint fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef toneRose fill:#ffe4e6,stroke:#e11d48,stroke-width:1.5px,color:#881337
classDef toneIndigo fill:#e0e7ff,stroke:#4f46e5,stroke-width:1.5px,color:#312e81
classDef toneTeal fill:#ccfbf1,stroke:#0f766e,stroke-width:1.5px,color:#134e4a
class node_primitives toneBlue
class node_platforms toneAmber
class node_common toneMint
class node_graphics_engine,node_shader_tools,node_graphics_accessories,node_graphics_tools,node_archiver,node_super_resolution,node_dotnet,node_d3d_base,node_nextgen_base,node_d3d11,node_d3d12,node_opengl,node_vulkan,node_webgpu,node_metal toneRose
class node_tests_core,node_tests_api,node_tests_include,node_tests_gpu,node_tests_dotnet toneIndigo
class node_dxcompiler,node_glslang,node_spirv_tools,node_spirv_cross,node_volk,node_dawn,node_glew toneTeal
class node_app toneNeutral
```

## Components

### Primitives

Base types, memory, ref counting, and C-style interface macros.

- [Base layer](https://github.com/diligentgraphics/diligentcore/tree/master/Primitives): core primitives · Fundamental types, allocators, object model, and interface macros. · `Primitives`

### Platforms

OS-specific filesystem, window, and debug glue.

- [Platform glue](https://github.com/diligentgraphics/diligentcore/tree/master/Platforms): os abstraction · Native windows, filesystem, debug output, and platform capabilities. · `Platforms`

### Common

Engine-agnostic utilities shared across the core.

- [Shared utils](https://github.com/diligentgraphics/diligentcore/tree/master/Common): utility core · Common allocators, math, strings, threading, serialization, and image helpers. · `Common`

### Graphics

Unified graphics API, backend implementations, shader tooling, and helpers.

- [Graphics core](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngine): unified API · Backend-neutral engine object model and common base implementations. · `Graphics/GraphicsEngine`
- [Shader tools](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/ShaderTools): compiler tooling · Shader parsing, preprocessing, reflection, resource binding analysis, and translation helpers. · `Graphics/ShaderTools`
- [Accessories](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsAccessories): cross-backend helpers · Atlases, ring buffers, upload helpers, caches, and screen capture utilities. · `Graphics/GraphicsAccessories`
- [Graphics tools](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsTools): higher-level helpers · Caching, async PSO, upload, reloadable shaders, and render-state helpers. · `Graphics/GraphicsTools`
- [Archiver](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/Archiver): serialization · Serialization and deserialization of engine objects and pipeline assets. · `Graphics/Archiver`
- [Super resolution](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/SuperResolution): upscaling API · Common factory/provider layer for DLSS, FSR, and related features. · `Graphics/SuperResolution`
- [.NET binding](https://github.com/diligentgraphics/diligentcore/blob/master/Graphics/GraphicsEngine.NET): interop layer · Managed bindings exposing core graphics concepts to .NET consumers. · `Graphics/GraphicsEngine.NET`
- [D3D base](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineD3DBase): shared D3D support · Common conversions, validation, and base helpers for D3D11/D3D12. · `Graphics/GraphicsEngineD3DBase`
- [Next-gen base](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineNextGenBase): shared backend base · Shared patterns for modern explicit backends. · `Graphics/GraphicsEngineNextGenBase`
- [D3D11 backend](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineD3D11): backend impl · D3D11-specific render device, context, swap chain, and resource objects. · `Graphics/GraphicsEngineD3D11`
- [D3D12 backend](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineD3D12): backend impl · D3D12-specific explicit queues, descriptors, heaps, and resource objects. · `Graphics/GraphicsEngineD3D12`
- [OpenGL backend](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineOpenGL): backend impl · OpenGL/OpenGLES implementation plus platform GL context handling. · `Graphics/GraphicsEngineOpenGL`
- [Vulkan backend](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineVulkan): backend impl · Vulkan implementation with explicit command, descriptor, and sync management. · `Graphics/GraphicsEngineVulkan`
- [WebGPU backend](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineWebGPU): backend impl · WebGPU implementation with explicit resource and command translation. · `Graphics/GraphicsEngineWebGPU`
- [Metal backend](https://github.com/diligentgraphics/diligentcore/tree/master/Graphics/GraphicsEngineMetal): commercial backend · Metal-specific backend module. · `Graphics/GraphicsEngineMetal`

### Tests

API, include, GPU, and .NET validation.

- [Core tests](https://github.com/diligentgraphics/diligentcore/tree/master/Tests/DiligentCoreTest): validation suite · Common utility, graphics utility, shader tool, and API behavior tests. · `Tests/DiligentCoreTest`
- [API tests](https://github.com/diligentgraphics/diligentcore/tree/master/Tests/DiligentCoreAPITest): validation suite · Runtime API, shader resource, archiver, and backend reference tests. · `Tests/DiligentCoreAPITest`
- [Include tests](https://github.com/diligentgraphics/diligentcore/tree/master/Tests/IncludeTest): validation suite · Header usability and interface stability checks. · `Tests/IncludeTest`
- [GPU framework](https://github.com/diligentgraphics/diligentcore/tree/master/Tests/GPUTestFramework): test harness · Backend-specific testing environments and swap chains. · `Tests/GPUTestFramework`
- [.NET tests](https://github.com/diligentgraphics/diligentcore/blob/master/Tests/DiligentCoreTest.NET): validation suite · Managed tests for graphics engine and archiver bindings. · `Tests/DiligentCoreTest.NET`

### ThirdParty

Vendored external dependencies for APIs, shader tools, and utilities.

- [DXC](https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/DirectXShaderCompiler): shader compiler · DirectX Shader Compiler used for HLSL and DXIL paths. · `ThirdParty/DirectXShaderCompiler`
- [glslang](https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/glslang): shader compiler · GLSL and SPIR-V shader language tooling. · `ThirdParty/glslang`
- [SPIRV-Tools](https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/SPIRV-Tools): shader tooling · SPIR-V validation and manipulation utilities. · `ThirdParty/SPIRV-Tools`
- [SPIRV-Cross](https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/SPIRV-Cross): shader translation · SPIR-V cross-compilation to target shading languages. · `ThirdParty/SPIRV-Cross`
- [volk](https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/volk): vulkan loader · Vulkan function loading layer. · `ThirdParty/volk`
- [dawn](https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/dawn): webgpu stack · WebGPU native implementation support. · `ThirdParty/dawn`
- [glew](https://github.com/diligentgraphics/diligentcore/tree/master/ThirdParty/glew): gl loader · OpenGL extension loading and context bootstrapping. · `ThirdParty/glew`

### Other components

- **Application**: consumer · Host application or game using the core API.

## Connections

- Application → Graphics core: creates device/context/swapchain · Application uses the unified engine API to obtain backend factories and core objects.
- Application → Platform glue: uses host services · Windowing, filesystem, and debug integration come from platform glue.
- Graphics core → Base layer: built on · Core engine objects rely on base object, memory, and interface primitives.
- Graphics core → Shared utils: reuses utilities · Engine base code uses shared allocators, serialization, threading, and image helpers.
- Graphics core → Platform glue: depends on · Swap chains, native windows, and shader source loading use platform abstractions.
- Graphics core → Shader tools: feeds shader data · Shader compilation and reflection are central to pipeline setup.
- Graphics tools → Graphics core: extends · Higher-level helpers wrap the core API for caching, upload, and reload flows.
- Accessories → Graphics core: supports · Reusable utility layer above the core graphics objects.
- Archiver → Graphics core: serializes · Archived pipeline state and engine objects are derived from the core model.
- Super resolution → Graphics core: uses · Upscaling providers integrate with devices, contexts, and swap chains.
- .NET binding → Graphics core: binds · Managed wrappers map the native graphics engine API into .NET.
- Core tests → Shared utils: validates · Covers common utilities and shared helpers.
- Core tests → Shader tools: validates · Exercises shader preprocessing, reflection, and language utilities.
- API tests → Graphics core: validates · Checks runtime API behavior and backend object model consistency.
- API tests → Archiver: validates · Exercises serialization and dearchiving flows.
- API tests → Super resolution: validates · Checks the common super-resolution provider API.
- Include tests → Graphics core: checks headers · Ensures public and backend headers remain usable and stable.
- GPU framework → Graphics core: hosts · Provides backend-specific test environments and swap chains.
- .NET tests → .NET binding: validates · Exercises managed interop and .NET-facing API surface.
- Shader tools → DXC: uses · HLSL/DXIL compilation and validation paths.
- Shader tools → glslang: uses · GLSL/SPIR-V parsing and compilation support.
- Shader tools → SPIRV-Tools: uses · SPIR-V validation and processing.
- Shader tools → SPIRV-Cross: uses · Target-language translation, especially non-DX backends.
- D3D base → Graphics core: specializes · Shared D3D support sits between the core and D3D backends.
- Next-gen base → Graphics core: specializes · Shared patterns for explicit backends.
- D3D11 backend → D3D base: inherits patterns · D3D11 backend uses common D3D conversions and validation.
- D3D12 backend → D3D base: inherits patterns · D3D12 backend uses common D3D conversions and validation.
- D3D12 backend → Next-gen base: inherits patterns · D3D12 uses explicit command and descriptor management patterns.
- D3D11 backend → DXC: shader path · HLSL compilation and validation support.
- D3D12 backend → DXC: shader path · HLSL and DXIL compilation support.
- OpenGL backend → glew: loads API · OpenGL backend depends on GL extension loading.
- Vulkan backend → volk: loads API · Vulkan backend depends on Vulkan function loading.
- WebGPU backend → dawn: integrates · WebGPU backend is built around Dawn support.
- OpenGL backend → Shader tools: uses · OpenGL backend consumes shared shader tooling and translation.
- Vulkan backend → Shader tools: uses · Vulkan backend consumes SPIR-V-centric shader tooling.
- WebGPU backend → Shader tools: uses · WebGPU backend consumes WGSL and translation helpers.
- Metal backend → Shader tools: uses · Metal backend relies on cross-language shader tooling.