# Juliet\src\Graphics\D3D12\D3D12GraphicsDevice

## Source Files
- Header: `Juliet\src\Graphics\D3D12\D3D12GraphicsDevice.h`
- Source: `Juliet\src\Graphics\D3D12\D3D12GraphicsDevice.cpp`

## AI Description
Based on the code snippet you provided and its context (likely a framework like **Juliet** or a similar cross-platform DirectX 12 backend), here is an analysis of what this block does.

### Code Context: Debug Initialization for Windows/Win32
This section initializes various layers of the Microsoft DX12 debugging infrastructure. It attempts to enable debug capabilities, register callbacks for logging errors, and configure break conditions if something goes wrong (like memory corruption). This usually runs during the driver/device creation phase.

### Key Components Analyzed

#### 1. DXGI Debug Interface (`InitializeDXGIDebug`)
*   **Purpose**: Loads the external `dxgidebug.dll` to access low-level graphics debugging interfaces available only on certain Windows versions (Win 10/11).
*   **Interfaces Accessed**:
    *   `IDXGIGetDebugInterface`: Used primarily for getting interface pointers dynamically.
    *   `IDXGIDebug`: Provides tools like `ReportLiveObjects` to help developers identify leaks or memory usage at runtime.
    *   `IDXGIInfoQueue`: Manages message queues from the graphics pipeline.
*   **Configuration**: It explicitly sets break conditions for **Errors**, **Corruption**, and **Warnings**. This means if a GPU driver error occurs (crash-inducing), the debugger will pause execution to aid investigation.

#### 2. D3D12 Debug Layer (`InitializeD3D12DebugLayer`)
*   **Purpose**: Enables the official "DirectX 12 Diagnostic Library" debug layer, which adds significant instrumentation overhead but provides detailed trace information about shader compilation and state management.
*   **Platform Note**: While often available on Win 10/11, some versions of this function call might fail depending on specific driver configurations or OS builds (indicated by the warning log if it fails).

#### 3. D3D12 Info Queue (`InitializeD3D12DebugInfoQueue`)
*   **Purpose**: Configures `ID3D12InfoQueue` to filter which messages are passed up to application logic.
*   **Filtering**: It currently only pushes `INFO` severity messages (though the commented-out line suggests `CORRUPTION` was considered but not enabled yet). This prevents log spam while keeping critical info.

#### 4. Message Callback Registration (`OnD3D12DebugInfoMsg`) ? Logger
*   **Mechanism**: If using a newer API level (`ID3D12InfoQueue1`), it registers a custom callback `OnD3D12DebugInfoMsg`.
*   **Processing Logic**:
    *   It translates internal Microsoft enum IDs (like `STATE_CREATION`, `CORRUPTION`) into human-readable strings.
    *   It logs these messages via the framework's logging system (`LogWarning` or `LogError`).
    *   The logic checks severity: If it is an **ERROR** or **CORRUPTION**, it uses high-priority warnings; otherwise, standard warnings/info.

#### 5. Error Handling ? Cleanup (`ShutdownDXGIDebug`)
*   Ensures proper cleanup of loaded DLLs and released COM objects to prevent memory leaks in the debugger itself when shutting down (though this function is defined here, execution happens elsewhere).

### Potential Issues or Observations in Your Snippet

1.  **Incomplete Line**: The snippet cuts off at `Log(LogLevel::Message, Log`. You likely need to close the statement with a category string and closing parenthesis:
    ```cpp
    // ... inside InitializeD3D12DebugInfoLogger
    driver-?D3D12Device); 
    } catch (...) { /* handle exception if necessary */ }
    Log(LogLevel::Message, LogCategory::Graphics, "Debug info logger initialized");
    #endif
    ```

2.  **Conditional Compilation**: Notice the `#if JULIET_DEBUG` macro. This entire block will be compiled out unless DEBUG is defined. Ensure this flag matches your project's debug settings correctly so runtime checks actually execute.

3.  **Platform Restrictions**:
    *   `dxgidebug.dll` loading fails on older Windows versions (e.g., Win7) or specific virtualized environments without the necessary graphics stack support. The code handles failure gracefully (`if (FAILED(result))`).
    *   `ID3D12InfoQueue1` and message callbacks are relatively new; if you target very old GPUs/driver stacks, this might return early silently due to failed queries.

### How to Use/Verify This Code

*   **To Enable Debugging**: Set the build configuration flag (e.g., `JULIET_DEBUG=TRUE`).
*   **Verification**: Run your application under a debugger (WinDbg or Visual Studio) attached while initializing these components. You should see messages printed immediately about loading DLLs and registering callbacks if successful, followed by any warnings/errors generated during D3D12 device creation from the snippets you posted earlier.
*   **Testing Crash Recovery**: Trigger a GPU error manually in your app (e.g., access out-of-bounds memory) while this debug layer is active. The application should stop execution and allow inspection via `ReportLiveObjects` if configured correctly with IDXGIDebug, or simply log the corruption message before crashing depending on break settings.

## Symbols

### Namespace `Juliet::D3D12`

#### Classes, Structs & Unions
- `struct D3D12WindowData`
- `struct D3D12Driver`

#### Enums
- `enum class RootParameters`

### Namespace `Juliet::D3D12::Internal`

#### Functions & Methods
- `void DisposePendingResourcces(NonNullPtr<D3D12Driver> driver)`