# Juliet\include\Graphics\Graphics

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

## AI Description
The provided code snippet is a C++ implementation of a graphics rendering engine using the Juliet library. It includes functions for managing render passes, shaders, and graphics buffers. The `RenderPass` class represents a set of commands that can be executed together to draw graphics. The `CommandList` class manages a list of commands that are executed on a GPU.

Here's a brief overview of the key functionalities:

1. **Rendering Pass Management**:
   - `BeginRenderPass`: Begins a new render pass with specified color and depth/stencil targets.
   - `EndRenderPass`: Ends the current render pass.
   - `SetGraphicsViewPort`, `SetScissorRect`, `SetBlendConstants`, `SetStencilReference`: Set various rendering state parameters.

2. **Shader Management**:
   - `CreateShader`: Loads a shader from a file and creates a shader object.
   - `DestroyShader`: Destroys a previously created shader object.

3. **Graphics Pipeline Management**:
   - `CreateGraphicsPipeline`: Creates a graphics pipeline with specified create information.
   - `DestroyGraphicsPipeline`: Destroys a previously created graphics pipeline object.

4. **Buffer Management**:
   - `CreateGraphicsBuffer`, `CreateGraphicsTransferBuffer`: Create buffers for storing graphics data.
   - `MapGraphicsBuffer`, `UnmapGraphicsBuffer`, `MapGraphicsTransferBuffer`, `UnmapGraphicsTransferBuffer`: Map and unmap memory from the GPU.
   - `CopyBuffer`, `CopyBufferToTexture`, `TransitionBufferToReadable`: Copy data between buffers or transfer data to/from textures.

5. **Descriptor Management**:
   - `GetDescriptorIndex`: Retrieve the descriptor index for a buffer or texture.

6. **Resource Destruction**:
   - `DestroyGraphicsBuffer`, `DestroyGraphicsTransferBuffer`: Destroy previously created graphics buffer and transfer buffer objects.

This code snippet provides a comprehensive set of tools for managing graphics resources in a C++ application using the Juliet library, allowing developers to create complex 3D scenes efficiently.

## Symbols

### Namespace `Juliet`

#### Classes, Structs & Unions
- `struct IndirectDrawCommand`
- `struct IndexedIndirectDrawCommand`
- `struct IndirectDispatchCommand`
- `struct GraphicsViewPort`

#### Enums
- `enum class QueueType`
- `enum class IndexFormat`
- `enum struct`
- `enum struct`

#### Functions & Methods
- `extern JULIET_API GraphicsDevice* CreateGraphicsDevice(GraphicsConfig config)`
- `extern JULIET_API void DestroyGraphicsDevice(NonNullPtr<GraphicsDevice> device)`
- `// Attach To Window
    extern JULIET_API bool AttachToWindow(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window)`
- `extern JULIET_API void DetachFromWindow(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window)`
- `// SwapChain
    extern JULIET_API bool AcquireSwapChainTexture(NonNullPtr<CommandList> commandList, NonNullPtr<Window> window,
                                                   Texture** swapChainTexture)`
- `extern JULIET_API bool WaitAndAcquireSwapChainTexture(NonNullPtr<CommandList> commandList,
                                                          NonNullPtr<Window> window, Texture** swapChainTexture)`
- `extern JULIET_API bool WaitForSwapchain(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window)`
- `extern JULIET_API TextureFormat GetSwapChainTextureFormat(NonNullPtr<GraphicsDevice> device, NonNullPtr<Window> window)`
- `// Textures
    extern JULIET_API Texture* CreateTexture(NonNullPtr<GraphicsDevice> device, const TextureCreateInfo& createInfo)`
- `extern JULIET_API void DestroyTexture(NonNullPtr<GraphicsDevice> device, NonNullPtr<Texture> texture)`
- `// Command List
    extern JULIET_API CommandList* AcquireCommandList(NonNullPtr<GraphicsDevice> device, QueueType queueType = QueueType::Graphics)`
- `extern JULIET_API void SubmitCommandLists(NonNullPtr<CommandList> commandList)`
- `// RenderPass
    extern JULIET_API RenderPass* BeginRenderPass(NonNullPtr<CommandList> commandList, ColorTargetInfo& colorTargetInfo,
                                                  DepthStencilTargetInfo* depthStencilTargetInfo = nullptr)`
- `extern JULIET_API RenderPass* BeginRenderPass(NonNullPtr<CommandList> commandList,
                                                  NonNullPtr<const ColorTargetInfo> colorTargetInfos, uint32 colorTargetInfoCount,
                                                  DepthStencilTargetInfo* depthStencilTargetInfo = nullptr)`
- `extern JULIET_API void EndRenderPass(NonNullPtr<RenderPass> renderPass)`
- `extern JULIET_API void SetGraphicsViewPort(NonNullPtr<RenderPass> renderPass, const GraphicsViewPort& viewPort)`
- `extern JULIET_API void SetScissorRect(NonNullPtr<RenderPass> renderPass, const Rectangle& rectangle)`
- `extern JULIET_API void SetBlendConstants(NonNullPtr<RenderPass> renderPass, FColor blendConstants)`
- `extern JULIET_API void SetStencilReference(NonNullPtr<RenderPass> renderPass, uint8 reference)`
- `extern JULIET_API void BindGraphicsPipeline(NonNullPtr<RenderPass> renderPass, NonNullPtr<GraphicsPipeline> graphicsPipeline)`
- `extern JULIET_API void DrawPrimitives(NonNullPtr<RenderPass> renderPass, uint32 numVertices, uint32 numInstances,
                                          uint32 firstVertex, uint32 firstInstance)`
- `extern JULIET_API void DrawIndexedPrimitives(NonNullPtr<RenderPass> renderPass, uint32 numIndices, uint32 numInstances,
                                                 uint32 firstIndex, uint32 vertexOffset, uint32 firstInstance)`
- `extern JULIET_API void SetIndexBuffer(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer,
                                          IndexFormat format, size_t indexCount, index_t offset)`
- `extern JULIET_API void SetPushConstants(NonNullPtr<CommandList> commandList, ShaderStage stage,
                                            uint32 rootParameterIndex, uint32 numConstants, const void* constants)`
- `// Fences
    extern JULIET_API bool WaitUntilGPUIsIdle(NonNullPtr<GraphicsDevice> device)`
- `// Shaders
    extern JULIET_API Shader* CreateShader(NonNullPtr<GraphicsDevice> device, String filename, ShaderCreateInfo& shaderCreateInfo)`
- `extern JULIET_API void DestroyShader(NonNullPtr<GraphicsDevice> device, NonNullPtr<Shader> shader)`
- `// Pipelines
    extern JULIET_API GraphicsPipeline* CreateGraphicsPipeline(NonNullPtr<GraphicsDevice>        device,
                                                               const GraphicsPipelineCreateInfo& createInfo)`
- `extern JULIET_API void DestroyGraphicsPipeline(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsPipeline> graphicsPipeline)`
- `#if ALLOW_SHADER_HOT_RELOAD
    // Allows updating the graphics pipeline shaders. Can update either one or both shaders.
    extern JULIET_API bool UpdateGraphicsPipelineShaders(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsPipeline> graphicsPipeline,
                                                         Shader* optional_vertexShader, Shader* optional_fragmentShader)`
- `#endif

    // Buffers
    extern JULIET_API GraphicsBuffer* CreateGraphicsBuffer(NonNullPtr<GraphicsDevice> device, const BufferCreateInfo& createInfo)`
- `extern JULIET_API GraphicsTransferBuffer* CreateGraphicsTransferBuffer(NonNullPtr<GraphicsDevice>      device,
                                                                           const TransferBufferCreateInfo& createInfo)`
- `extern JULIET_API void* MapGraphicsBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer)`
- `extern JULIET_API void UnmapGraphicsBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer)`
- `extern JULIET_API void* MapGraphicsTransferBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsTransferBuffer> buffer)`
- `extern JULIET_API void UnmapGraphicsTransferBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsTransferBuffer> buffer)`
- `extern JULIET_API void CopyBuffer(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> dst,
                                      NonNullPtr<GraphicsTransferBuffer> src, size_t size, size_t dstOffset = 0,
                                      size_t srcOffset = 0)`
- `extern JULIET_API void CopyBufferToTexture(NonNullPtr<CommandList> commandList, NonNullPtr<Texture> dst,
                                               NonNullPtr<GraphicsTransferBuffer> src)`
- `extern JULIET_API void TransitionBufferToReadable(NonNullPtr<CommandList> commandList, NonNullPtr<GraphicsBuffer> buffer)`
- `extern JULIET_API uint32 GetDescriptorIndex(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer)`
- `extern JULIET_API uint32 GetDescriptorIndex(NonNullPtr<GraphicsDevice> device, NonNullPtr<Texture> texture)`
- `extern JULIET_API void DestroyGraphicsBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsBuffer> buffer)`
- `extern JULIET_API void DestroyGraphicsTransferBuffer(NonNullPtr<GraphicsDevice> device, NonNullPtr<GraphicsTransferBuffer> buffer)`