SDL3pp_gpu.h

#ifndef SDL3PP_GPU_H_
#define SDL3PP_GPU_H_
 
#include <SDL3/SDL_gpu.h>
#include "SDL3pp_pixels.h"
#include "SDL3pp_properties.h"
#include "SDL3pp_rect.h"
#include "SDL3pp_stdinc.h"
#include "SDL3pp_surface.h"
#include "SDL3pp_video.h"
 
namespace SDL {

 
// Forward decl
struct GPUDeviceBase;
 
// Forward decl
struct GPUDevice;

using GPUDeviceRaw = SDL_GPUDevice*;

using GPUDeviceRef = ResourceRefT<GPUDeviceBase>;

using GPUBufferRaw = SDL_GPUBuffer*;
 
// Forward decl
struct GPUBuffer;

using GPUTransferBufferRaw = SDL_GPUTransferBuffer*;
 
// Forward decl
struct GPUTransferBuffer;

using GPUTextureRaw = SDL_GPUTexture*;
 
// Forward decl
struct GPUTexture;

using GPUSamplerRaw = SDL_GPUSampler*;
 
// Forward decl
struct GPUSampler;

using GPUShaderRaw = SDL_GPUShader*;
 
// Forward decl
struct GPUShader;

using GPUComputePipelineRaw = SDL_GPUComputePipeline*;
 
// Forward decl
struct GPUComputePipeline;

using GPUGraphicsPipelineRaw = SDL_GPUGraphicsPipeline*;
 
// Forward decl
struct GPUGraphicsPipeline;

using GPUCommandBufferRaw = SDL_GPUCommandBuffer*;
 
// Forward decl
struct GPUCommandBuffer;

using GPURenderPassRaw = SDL_GPURenderPass*;
 
// Forward decl
struct GPURenderPass;

using GPUComputePassRaw = SDL_GPUComputePass*;
 
// Forward decl
struct GPUComputePass;

using GPUCopyPassRaw = SDL_GPUCopyPass*;
 
// Forward decl
struct GPUCopyPass;

using GPUBufferCreateInfo = SDL_GPUBufferCreateInfo;

class GPUBuffer
{
  GPUBufferRaw m_gPUBuffer;
 
public:
  constexpr GPUBuffer(GPUBufferRaw gPUBuffer = {}) noexcept
    : m_gPUBuffer(gPUBuffer)
  {
  }

  GPUBuffer(GPUDeviceRef device, const GPUBufferCreateInfo& createinfo);

  constexpr operator GPUBufferRaw() const noexcept { return m_gPUBuffer; }
};

using GPUTransferBufferCreateInfo = SDL_GPUTransferBufferCreateInfo;

class GPUTransferBuffer
{
  GPUTransferBufferRaw m_gPUTransferBuffer;
 
public:
  constexpr GPUTransferBuffer(
    GPUTransferBufferRaw gPUTransferBuffer = {}) noexcept
    : m_gPUTransferBuffer(gPUTransferBuffer)
  {
  }

  GPUTransferBuffer(GPUDeviceRef device,
                    const GPUTransferBufferCreateInfo& createinfo);

  constexpr operator GPUTransferBufferRaw() const noexcept
  {
    return m_gPUTransferBuffer;
  }
};

using GPUTextureCreateInfo = SDL_GPUTextureCreateInfo;

class GPUTexture
{
  GPUTextureRaw m_gPUTexture;
 
public:
  constexpr GPUTexture(GPUTextureRaw gPUTexture = {}) noexcept
    : m_gPUTexture(gPUTexture)
  {
  }

  GPUTexture(GPUDeviceRef device, const GPUTextureCreateInfo& createinfo);

  constexpr operator GPUTextureRaw() const noexcept { return m_gPUTexture; }
};

using GPUSamplerCreateInfo = SDL_GPUSamplerCreateInfo;

class GPUSampler
{
  GPUSamplerRaw m_gPUSampler;
 
public:
  constexpr GPUSampler(GPUSamplerRaw gPUSampler = {}) noexcept
    : m_gPUSampler(gPUSampler)
  {
  }

  GPUSampler(GPUDeviceRef device, const GPUSamplerCreateInfo& createinfo);

  constexpr operator GPUSamplerRaw() const noexcept { return m_gPUSampler; }
};

using GPUShaderCreateInfo = SDL_GPUShaderCreateInfo;

class GPUShader
{
  GPUShaderRaw m_gPUShader;
 
public:
  constexpr GPUShader(GPUShaderRaw gPUShader = {}) noexcept
    : m_gPUShader(gPUShader)
  {
  }

  GPUShader(GPUDeviceRef device, const GPUShaderCreateInfo& createinfo);

  constexpr operator GPUShaderRaw() const noexcept { return m_gPUShader; }
};

using GPUComputePipelineCreateInfo = SDL_GPUComputePipelineCreateInfo;

class GPUComputePipeline
{
  GPUComputePipelineRaw m_gPUComputePipeline;
 
public:
  constexpr GPUComputePipeline(
    GPUComputePipelineRaw gPUComputePipeline = {}) noexcept
    : m_gPUComputePipeline(gPUComputePipeline)
  {
  }

  GPUComputePipeline(GPUDeviceRef device,
                     const GPUComputePipelineCreateInfo& createinfo);

  constexpr operator GPUComputePipelineRaw() const noexcept
  {
    return m_gPUComputePipeline;
  }
};

using GPUGraphicsPipelineCreateInfo = SDL_GPUGraphicsPipelineCreateInfo;

class GPUGraphicsPipeline
{
  GPUGraphicsPipelineRaw m_gPUGraphicsPipeline;
 
public:
  constexpr GPUGraphicsPipeline(
    GPUGraphicsPipelineRaw gPUGraphicsPipeline = {}) noexcept
    : m_gPUGraphicsPipeline(gPUGraphicsPipeline)
  {
  }

  GPUGraphicsPipeline(GPUDeviceRef device,
                      const GPUGraphicsPipelineCreateInfo& createinfo);

  constexpr operator GPUGraphicsPipelineRaw() const noexcept
  {
    return m_gPUGraphicsPipeline;
  }
};

using GPUViewport = SDL_GPUViewport;

using GPUBufferBinding = SDL_GPUBufferBinding;

using GPUIndexElementSize = SDL_GPUIndexElementSize;
 
constexpr GPUIndexElementSize GPU_INDEXELEMENTSIZE_16BIT =
  SDL_GPU_INDEXELEMENTSIZE_16BIT; 
 
constexpr GPUIndexElementSize GPU_INDEXELEMENTSIZE_32BIT =
  SDL_GPU_INDEXELEMENTSIZE_32BIT; 

using GPUTextureSamplerBinding = SDL_GPUTextureSamplerBinding;

class GPURenderPass
{
  GPURenderPassRaw m_gPURenderPass;
 
public:
  constexpr GPURenderPass(GPURenderPassRaw gPURenderPass = {}) noexcept
    : m_gPURenderPass(gPURenderPass)
  {
  }

  constexpr operator GPURenderPassRaw() const noexcept
  {
    return m_gPURenderPass;
  }

  void BindPipeline(GPUGraphicsPipeline graphics_pipeline);

  void SetViewport(const GPUViewport& viewport);

  void SetScissor(const RectRaw& scissor);

  void SetBlendConstants(FColorRaw blend_constants);

  void SetStencilReference(Uint8 reference);

  void BindVertexBuffers(Uint32 first_slot,
                         std::span<const GPUBufferBinding> bindings);

  void BindIndexBuffer(const GPUBufferBinding& binding,
                       GPUIndexElementSize index_element_size);

  void BindVertexSamplers(
    Uint32 first_slot,
    std::span<const GPUTextureSamplerBinding> texture_sampler_bindings);

  void BindVertexStorageTextures(Uint32 first_slot,
                                 SpanRef<const GPUTextureRaw> storage_textures);

  void BindVertexStorageBuffers(Uint32 first_slot,
                                SpanRef<const GPUBufferRaw> storage_buffers);

  void BindFragmentSamplers(
    Uint32 first_slot,
    std::span<const GPUTextureSamplerBinding> texture_sampler_bindings);

  void BindFragmentStorageTextures(
    Uint32 first_slot,
    SpanRef<const GPUTextureRaw> storage_textures);

  void BindFragmentStorageBuffers(Uint32 first_slot,
                                  SpanRef<const GPUBufferRaw> storage_buffers);

  void DrawIndexedPrimitives(Uint32 num_indices,
                             Uint32 num_instances,
                             Uint32 first_index,
                             Sint32 vertex_offset,
                             Uint32 first_instance);

  void DrawPrimitives(Uint32 num_vertices,
                      Uint32 num_instances,
                      Uint32 first_vertex,
                      Uint32 first_instance);

  void DrawPrimitivesIndirect(GPUBuffer buffer,
                              Uint32 offset,
                              Uint32 draw_count);

  void DrawIndexedPrimitivesIndirect(GPUBuffer buffer,
                                     Uint32 offset,
                                     Uint32 draw_count);

  void End();
};

class GPUComputePass
{
  GPUComputePassRaw m_gPUComputePass;
 
public:
  constexpr GPUComputePass(GPUComputePassRaw gPUComputePass = {}) noexcept
    : m_gPUComputePass(gPUComputePass)
  {
  }

  constexpr operator GPUComputePassRaw() const noexcept
  {
    return m_gPUComputePass;
  }

  void BindPipeline(GPUComputePipeline compute_pipeline);

  void BindSamplers(
    Uint32 first_slot,
    std::span<const GPUTextureSamplerBinding> texture_sampler_bindings);

  void BindStorageTextures(Uint32 first_slot,
                           SpanRef<const GPUTextureRaw> storage_textures);

  void BindStorageBuffers(Uint32 first_slot,
                          SpanRef<const GPUBufferRaw> storage_buffers);

  void Dispatch(Uint32 groupcount_x, Uint32 groupcount_y, Uint32 groupcount_z);

  void DispatchIndirect(GPUBuffer buffer, Uint32 offset);

  void End();
};

using GPUBufferRegion = SDL_GPUBufferRegion;

using GPUTextureLocation = SDL_GPUTextureLocation;

using GPUBufferLocation = SDL_GPUBufferLocation;

using GPUTextureRegion = SDL_GPUTextureRegion;

using GPUTextureTransferInfo = SDL_GPUTextureTransferInfo;

using GPUTransferBufferLocation = SDL_GPUTransferBufferLocation;

class GPUCopyPass
{
  GPUCopyPassRaw m_gPUCopyPass;
 
public:
  constexpr GPUCopyPass(GPUCopyPassRaw gPUCopyPass = {}) noexcept
    : m_gPUCopyPass(gPUCopyPass)
  {
  }

  constexpr operator GPUCopyPassRaw() const noexcept { return m_gPUCopyPass; }

  void UploadToTexture(const GPUTextureTransferInfo& source,
                       const GPUTextureRegion& destination,
                       bool cycle);

  void UploadToBuffer(const GPUTransferBufferLocation& source,
                      const GPUBufferRegion& destination,
                      bool cycle);

  void CopyTextureToTexture(const GPUTextureLocation& source,
                            const GPUTextureLocation& destination,
                            Uint32 w,
                            Uint32 h,
                            Uint32 d,
                            bool cycle);

  void CopyBufferToBuffer(const GPUBufferLocation& source,
                          const GPUBufferLocation& destination,
                          Uint32 size,
                          bool cycle);

  void DownloadFromTexture(const GPUTextureRegion& source,
                           const GPUTextureTransferInfo& destination);

  void DownloadFromBuffer(const GPUBufferRegion& source,
                          const GPUTransferBufferLocation& destination);

  void End();
};

using GPUColorTargetInfo = SDL_GPUColorTargetInfo;

using GPUDepthStencilTargetInfo = SDL_GPUDepthStencilTargetInfo;

using GPUStorageTextureReadWriteBinding = SDL_GPUStorageTextureReadWriteBinding;

using GPUStorageBufferReadWriteBinding = SDL_GPUStorageBufferReadWriteBinding;

using GPUBlitInfo = SDL_GPUBlitInfo;

using GPUFence = SDL_GPUFence;

class GPUCommandBuffer
{
  GPUCommandBufferRaw m_gPUCommandBuffer;
 
public:
  constexpr GPUCommandBuffer(GPUCommandBufferRaw gPUCommandBuffer = {}) noexcept
    : m_gPUCommandBuffer(gPUCommandBuffer)
  {
  }

  constexpr operator GPUCommandBufferRaw() const noexcept
  {
    return m_gPUCommandBuffer;
  }

  void InsertDebugLabel(StringParam text);

  void PushDebugGroup(StringParam name);

  void PopDebugGroup();

  void PushVertexUniformData(Uint32 slot_index, SourceBytes data);

  void PushFragmentUniformData(Uint32 slot_index, SourceBytes data);

  void PushComputeUniformData(Uint32 slot_index, SourceBytes data);

  GPURenderPass BeginRenderPass(
    std::span<const GPUColorTargetInfo> color_target_infos,
    OptionalRef<const GPUDepthStencilTargetInfo> depth_stencil_target_info);

  GPUComputePass BeginComputePass(
    std::span<const GPUStorageTextureReadWriteBinding> storage_texture_bindings,
    std::span<const GPUStorageBufferReadWriteBinding> storage_buffer_bindings);

  GPUCopyPass BeginCopyPass();

  void GenerateMipmapsForTexture(GPUTexture texture);

  void BlitTexture(const GPUBlitInfo& info);

  GPUTexture AcquireSwapchainTexture(
    WindowRef window,
    Uint32* swapchain_texture_width = nullptr,
    Uint32* swapchain_texture_height = nullptr);

  GPUTexture WaitAndAcquireSwapchainTexture(
    WindowRef window,
    Uint32* swapchain_texture_width = nullptr,
    Uint32* swapchain_texture_height = nullptr);

  void Submit();

  GPUFence* SubmitAndAcquireFence();

  void Cancel();
};

using GPUShaderFormat = Uint32;
 
constexpr GPUShaderFormat GPU_SHADERFORMAT_INVALID =
  SDL_GPU_SHADERFORMAT_INVALID; 
 
constexpr GPUShaderFormat GPU_SHADERFORMAT_PRIVATE =
  SDL_GPU_SHADERFORMAT_PRIVATE; 
 
constexpr GPUShaderFormat GPU_SHADERFORMAT_SPIRV =
  SDL_GPU_SHADERFORMAT_SPIRV; 
 
constexpr GPUShaderFormat GPU_SHADERFORMAT_DXBC =
  SDL_GPU_SHADERFORMAT_DXBC; 
 
constexpr GPUShaderFormat GPU_SHADERFORMAT_DXIL =
  SDL_GPU_SHADERFORMAT_DXIL; 
 
constexpr GPUShaderFormat GPU_SHADERFORMAT_MSL =
  SDL_GPU_SHADERFORMAT_MSL; 
 
constexpr GPUShaderFormat GPU_SHADERFORMAT_METALLIB =
  SDL_GPU_SHADERFORMAT_METALLIB; 

using GPUSwapchainComposition = SDL_GPUSwapchainComposition;
 
constexpr GPUSwapchainComposition GPU_SWAPCHAINCOMPOSITION_SDR =
  SDL_GPU_SWAPCHAINCOMPOSITION_SDR; 
 
constexpr GPUSwapchainComposition GPU_SWAPCHAINCOMPOSITION_SDR_LINEAR =
  SDL_GPU_SWAPCHAINCOMPOSITION_SDR_LINEAR; 
 
constexpr GPUSwapchainComposition GPU_SWAPCHAINCOMPOSITION_HDR_EXTENDED_LINEAR =
  SDL_GPU_SWAPCHAINCOMPOSITION_HDR_EXTENDED_LINEAR; 
 
constexpr GPUSwapchainComposition GPU_SWAPCHAINCOMPOSITION_HDR10_ST2084 =
  SDL_GPU_SWAPCHAINCOMPOSITION_HDR10_ST2084; 

using GPUPresentMode = SDL_GPUPresentMode;
 
constexpr GPUPresentMode GPU_PRESENTMODE_VSYNC =
  SDL_GPU_PRESENTMODE_VSYNC; 
 
constexpr GPUPresentMode GPU_PRESENTMODE_IMMEDIATE =
  SDL_GPU_PRESENTMODE_IMMEDIATE; 
 
constexpr GPUPresentMode GPU_PRESENTMODE_MAILBOX =
  SDL_GPU_PRESENTMODE_MAILBOX; 

using GPUTextureFormat = SDL_GPUTextureFormat;
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_INVALID =
  SDL_GPU_TEXTUREFORMAT_INVALID; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_A8_UNORM =
  SDL_GPU_TEXTUREFORMAT_A8_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8_UNORM =
  SDL_GPU_TEXTUREFORMAT_R8_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8G8_UNORM =
  SDL_GPU_TEXTUREFORMAT_R8G8_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8G8B8A8_UNORM =
  SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16_UNORM =
  SDL_GPU_TEXTUREFORMAT_R16_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16G16_UNORM =
  SDL_GPU_TEXTUREFORMAT_R16G16_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16G16B16A16_UNORM =
  SDL_GPU_TEXTUREFORMAT_R16G16B16A16_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R10G10B10A2_UNORM =
  SDL_GPU_TEXTUREFORMAT_R10G10B10A2_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_B5G6R5_UNORM =
  SDL_GPU_TEXTUREFORMAT_B5G6R5_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_B5G5R5A1_UNORM =
  SDL_GPU_TEXTUREFORMAT_B5G5R5A1_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_B4G4R4A4_UNORM =
  SDL_GPU_TEXTUREFORMAT_B4G4R4A4_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_B8G8R8A8_UNORM =
  SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC1_RGBA_UNORM =
  SDL_GPU_TEXTUREFORMAT_BC1_RGBA_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC2_RGBA_UNORM =
  SDL_GPU_TEXTUREFORMAT_BC2_RGBA_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC3_RGBA_UNORM =
  SDL_GPU_TEXTUREFORMAT_BC3_RGBA_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC4_R_UNORM =
  SDL_GPU_TEXTUREFORMAT_BC4_R_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC5_RG_UNORM =
  SDL_GPU_TEXTUREFORMAT_BC5_RG_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC7_RGBA_UNORM =
  SDL_GPU_TEXTUREFORMAT_BC7_RGBA_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC6H_RGB_FLOAT =
  SDL_GPU_TEXTUREFORMAT_BC6H_RGB_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC6H_RGB_UFLOAT =
  SDL_GPU_TEXTUREFORMAT_BC6H_RGB_UFLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8_SNORM =
  SDL_GPU_TEXTUREFORMAT_R8_SNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8G8_SNORM =
  SDL_GPU_TEXTUREFORMAT_R8G8_SNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8G8B8A8_SNORM =
  SDL_GPU_TEXTUREFORMAT_R8G8B8A8_SNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16_SNORM =
  SDL_GPU_TEXTUREFORMAT_R16_SNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16G16_SNORM =
  SDL_GPU_TEXTUREFORMAT_R16G16_SNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16G16B16A16_SNORM =
  SDL_GPU_TEXTUREFORMAT_R16G16B16A16_SNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16_FLOAT =
  SDL_GPU_TEXTUREFORMAT_R16_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16G16_FLOAT =
  SDL_GPU_TEXTUREFORMAT_R16G16_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT =
  SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R32_FLOAT =
  SDL_GPU_TEXTUREFORMAT_R32_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R32G32_FLOAT =
  SDL_GPU_TEXTUREFORMAT_R32G32_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT =
  SDL_GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R11G11B10_UFLOAT =
  SDL_GPU_TEXTUREFORMAT_R11G11B10_UFLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8_UINT =
  SDL_GPU_TEXTUREFORMAT_R8_UINT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8G8_UINT =
  SDL_GPU_TEXTUREFORMAT_R8G8_UINT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8G8B8A8_UINT =
  SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UINT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16_UINT =
  SDL_GPU_TEXTUREFORMAT_R16_UINT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16G16_UINT =
  SDL_GPU_TEXTUREFORMAT_R16G16_UINT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16G16B16A16_UINT =
  SDL_GPU_TEXTUREFORMAT_R16G16B16A16_UINT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R32_UINT =
  SDL_GPU_TEXTUREFORMAT_R32_UINT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R32G32_UINT =
  SDL_GPU_TEXTUREFORMAT_R32G32_UINT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R32G32B32A32_UINT =
  SDL_GPU_TEXTUREFORMAT_R32G32B32A32_UINT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8_INT =
  SDL_GPU_TEXTUREFORMAT_R8_INT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8G8_INT =
  SDL_GPU_TEXTUREFORMAT_R8G8_INT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8G8B8A8_INT =
  SDL_GPU_TEXTUREFORMAT_R8G8B8A8_INT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16_INT =
  SDL_GPU_TEXTUREFORMAT_R16_INT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16G16_INT =
  SDL_GPU_TEXTUREFORMAT_R16G16_INT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R16G16B16A16_INT =
  SDL_GPU_TEXTUREFORMAT_R16G16B16A16_INT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R32_INT =
  SDL_GPU_TEXTUREFORMAT_R32_INT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R32G32_INT =
  SDL_GPU_TEXTUREFORMAT_R32G32_INT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R32G32B32A32_INT =
  SDL_GPU_TEXTUREFORMAT_R32G32B32A32_INT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_R8G8B8A8_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_B8G8R8A8_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC1_RGBA_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_BC1_RGBA_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC2_RGBA_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_BC2_RGBA_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC3_RGBA_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_BC3_RGBA_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_BC7_RGBA_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_BC7_RGBA_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_D16_UNORM =
  SDL_GPU_TEXTUREFORMAT_D16_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_D24_UNORM =
  SDL_GPU_TEXTUREFORMAT_D24_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_D32_FLOAT =
  SDL_GPU_TEXTUREFORMAT_D32_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT =
  SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT =
  SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_4x4_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_4x4_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_5x4_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_5x4_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_5x5_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_5x5_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_6x5_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_6x5_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_6x6_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_6x6_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_8x5_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_8x5_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_8x6_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_8x6_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_8x8_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_8x8_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x5_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x5_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x6_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x6_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x8_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x8_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x10_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x10_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_12x10_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_12x10_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_12x12_UNORM =
  SDL_GPU_TEXTUREFORMAT_ASTC_12x12_UNORM; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_4x4_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_4x4_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_5x4_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_5x4_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_5x5_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_5x5_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_6x5_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_6x5_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_6x6_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_6x6_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_8x5_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_8x5_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_8x6_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_8x6_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_8x8_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_8x8_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x5_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x5_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x6_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x6_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x8_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x8_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x10_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x10_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_12x10_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_12x10_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_12x12_UNORM_SRGB =
  SDL_GPU_TEXTUREFORMAT_ASTC_12x12_UNORM_SRGB; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_4x4_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_4x4_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_5x4_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_5x4_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_5x5_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_5x5_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_6x5_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_6x5_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_6x6_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_6x6_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_8x5_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_8x5_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_8x6_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_8x6_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_8x8_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_8x8_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x5_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x5_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x6_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x6_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x8_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x8_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_10x10_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_10x10_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_12x10_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_12x10_FLOAT; 
 
constexpr GPUTextureFormat GPU_TEXTUREFORMAT_ASTC_12x12_FLOAT =
  SDL_GPU_TEXTUREFORMAT_ASTC_12x12_FLOAT; 

using GPUTextureType = SDL_GPUTextureType;
 
constexpr GPUTextureType GPU_TEXTURETYPE_2D =
  SDL_GPU_TEXTURETYPE_2D; 
 
constexpr GPUTextureType GPU_TEXTURETYPE_2D_ARRAY =
  SDL_GPU_TEXTURETYPE_2D_ARRAY; 
 
constexpr GPUTextureType GPU_TEXTURETYPE_3D =
  SDL_GPU_TEXTURETYPE_3D; 
 
constexpr GPUTextureType GPU_TEXTURETYPE_CUBE =
  SDL_GPU_TEXTURETYPE_CUBE; 
 
constexpr GPUTextureType GPU_TEXTURETYPE_CUBE_ARRAY =
  SDL_GPU_TEXTURETYPE_CUBE_ARRAY; 

using GPUTextureUsageFlags = Uint32;
 
constexpr GPUTextureUsageFlags GPU_TEXTUREUSAGE_SAMPLER =
  SDL_GPU_TEXTUREUSAGE_SAMPLER; 
 
constexpr GPUTextureUsageFlags GPU_TEXTUREUSAGE_COLOR_TARGET =
  SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; 
 
constexpr GPUTextureUsageFlags GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET =
  SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET; 
 
constexpr GPUTextureUsageFlags GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ =
  SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ; 

constexpr GPUTextureUsageFlags GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ =
  SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ;

constexpr GPUTextureUsageFlags GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE =
  SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE;

constexpr GPUTextureUsageFlags
  GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE =
    SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE;

using GPUSampleCount = SDL_GPUSampleCount;
 
constexpr GPUSampleCount GPU_SAMPLECOUNT_1 =
  SDL_GPU_SAMPLECOUNT_1; 
 
constexpr GPUSampleCount GPU_SAMPLECOUNT_2 = SDL_GPU_SAMPLECOUNT_2; 
 
constexpr GPUSampleCount GPU_SAMPLECOUNT_4 = SDL_GPU_SAMPLECOUNT_4; 
 
constexpr GPUSampleCount GPU_SAMPLECOUNT_8 = SDL_GPU_SAMPLECOUNT_8; 

struct GPUDeviceBase : ResourceBaseT<GPUDeviceRaw>
{
  using ResourceBaseT::ResourceBaseT;

  void Destroy();

  const char* GetDriver();

  GPUShaderFormat GetShaderFormats();
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

  PropertiesRef GetProperties();
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

  GPUComputePipeline CreateComputePipeline(
    const GPUComputePipelineCreateInfo& createinfo);

  GPUGraphicsPipeline CreateGraphicsPipeline(
    const GPUGraphicsPipelineCreateInfo& createinfo);

  GPUSampler CreateSampler(const GPUSamplerCreateInfo& createinfo);

  GPUShader CreateShader(const GPUShaderCreateInfo& createinfo);

  GPUTexture CreateTexture(const GPUTextureCreateInfo& createinfo);

  GPUBuffer CreateBuffer(const GPUBufferCreateInfo& createinfo);

  GPUTransferBuffer CreateTransferBuffer(
    const GPUTransferBufferCreateInfo& createinfo);

  void SetBufferName(GPUBuffer buffer, StringParam text);

  void SetTextureName(GPUTexture texture, StringParam text);

  void ReleaseTexture(GPUTexture texture);

  void ReleaseSampler(GPUSampler sampler);

  void ReleaseBuffer(GPUBuffer buffer);

  void ReleaseTransferBuffer(GPUTransferBuffer transfer_buffer);

  void ReleaseComputePipeline(GPUComputePipeline compute_pipeline);

  void ReleaseShader(GPUShader shader);

  void ReleaseGraphicsPipeline(GPUGraphicsPipeline graphics_pipeline);

  GPUCommandBuffer AcquireCommandBuffer();

  void* MapTransferBuffer(GPUTransferBuffer transfer_buffer, bool cycle);

  void UnmapTransferBuffer(GPUTransferBuffer transfer_buffer);

  bool WindowSupportsSwapchainComposition(
    WindowRef window,
    GPUSwapchainComposition swapchain_composition);

  bool WindowSupportsPresentMode(WindowRef window, GPUPresentMode present_mode);

  void ClaimWindow(WindowRef window);

  void ReleaseWindow(WindowRef window);

  bool SetSwapchainParameters(WindowRef window,
                              GPUSwapchainComposition swapchain_composition,
                              GPUPresentMode present_mode);

  bool SetAllowedFramesInFlight(Uint32 allowed_frames_in_flight);

  GPUTextureFormat GetSwapchainTextureFormat(WindowRef window);

  void WaitForSwapchain(WindowRef window);

  void WaitForIdle();

  void WaitForFences(bool wait_all, std::span<GPUFence* const> fences);

  bool QueryFence(GPUFence* fence);

  void ReleaseFence(GPUFence* fence);

  bool TextureSupportsFormat(GPUTextureFormat format,
                             GPUTextureType type,
                             GPUTextureUsageFlags usage);

  bool TextureSupportsSampleCount(GPUTextureFormat format,
                                  GPUSampleCount sample_count);
 
#ifdef SDL_PLATFORM_GDK

  void GDKSuspendGPU();

  void GDKResumeGPU();
 
#endif /* SDL_PLATFORM_GDK */
};

struct GPUDevice : GPUDeviceBase
{
  using GPUDeviceBase::GPUDeviceBase;

  constexpr explicit GPUDevice(GPUDeviceRaw resource) noexcept
    : GPUDeviceBase(resource)
  {
  }

  constexpr GPUDevice(GPUDevice&& other) noexcept
    : GPUDevice(other.release())
  {
  }

  GPUDevice(GPUShaderFormat format_flags, bool debug_mode, StringParam name);

  GPUDevice(PropertiesRef props);

  ~GPUDevice() { SDL_DestroyGPUDevice(get()); }

  constexpr GPUDevice& operator=(GPUDevice&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

using GPUPrimitiveType = SDL_GPUPrimitiveType;
 
constexpr GPUPrimitiveType GPU_PRIMITIVETYPE_TRIANGLELIST =
  SDL_GPU_PRIMITIVETYPE_TRIANGLELIST; 
 
constexpr GPUPrimitiveType GPU_PRIMITIVETYPE_TRIANGLESTRIP =
  SDL_GPU_PRIMITIVETYPE_TRIANGLESTRIP; 
 
constexpr GPUPrimitiveType GPU_PRIMITIVETYPE_LINELIST =
  SDL_GPU_PRIMITIVETYPE_LINELIST; 
 
constexpr GPUPrimitiveType GPU_PRIMITIVETYPE_LINESTRIP =
  SDL_GPU_PRIMITIVETYPE_LINESTRIP; 
 
constexpr GPUPrimitiveType GPU_PRIMITIVETYPE_POINTLIST =
  SDL_GPU_PRIMITIVETYPE_POINTLIST; 

using GPULoadOp = SDL_GPULoadOp;

constexpr GPULoadOp GPU_LOADOP_LOAD = SDL_GPU_LOADOP_LOAD;

constexpr GPULoadOp GPU_LOADOP_CLEAR = SDL_GPU_LOADOP_CLEAR;

constexpr GPULoadOp GPU_LOADOP_DONT_CARE = SDL_GPU_LOADOP_DONT_CARE;

using GPUStoreOp = SDL_GPUStoreOp;

constexpr GPUStoreOp GPU_STOREOP_STORE = SDL_GPU_STOREOP_STORE;

constexpr GPUStoreOp GPU_STOREOP_DONT_CARE = SDL_GPU_STOREOP_DONT_CARE;

constexpr GPUStoreOp GPU_STOREOP_RESOLVE = SDL_GPU_STOREOP_RESOLVE;

constexpr GPUStoreOp GPU_STOREOP_RESOLVE_AND_STORE =
  SDL_GPU_STOREOP_RESOLVE_AND_STORE;

using GPUCubeMapFace = SDL_GPUCubeMapFace;
 
constexpr GPUCubeMapFace GPU_CUBEMAPFACE_POSITIVEX =
  SDL_GPU_CUBEMAPFACE_POSITIVEX; 
 
constexpr GPUCubeMapFace GPU_CUBEMAPFACE_NEGATIVEX =
  SDL_GPU_CUBEMAPFACE_NEGATIVEX; 
 
constexpr GPUCubeMapFace GPU_CUBEMAPFACE_POSITIVEY =
  SDL_GPU_CUBEMAPFACE_POSITIVEY; 
 
constexpr GPUCubeMapFace GPU_CUBEMAPFACE_NEGATIVEY =
  SDL_GPU_CUBEMAPFACE_NEGATIVEY; 
 
constexpr GPUCubeMapFace GPU_CUBEMAPFACE_POSITIVEZ =
  SDL_GPU_CUBEMAPFACE_POSITIVEZ; 
 
constexpr GPUCubeMapFace GPU_CUBEMAPFACE_NEGATIVEZ =
  SDL_GPU_CUBEMAPFACE_NEGATIVEZ; 

using GPUBufferUsageFlags = Uint32;
 
constexpr GPUBufferUsageFlags GPU_BUFFERUSAGE_VERTEX =
  SDL_GPU_BUFFERUSAGE_VERTEX; 
 
constexpr GPUBufferUsageFlags GPU_BUFFERUSAGE_INDEX =
  SDL_GPU_BUFFERUSAGE_INDEX; 
 
constexpr GPUBufferUsageFlags GPU_BUFFERUSAGE_INDIRECT =
  SDL_GPU_BUFFERUSAGE_INDIRECT; 
 
constexpr GPUBufferUsageFlags GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ =
  SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ; 

constexpr GPUBufferUsageFlags GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ =
  SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ;

constexpr GPUBufferUsageFlags GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE =
  SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE;

using GPUTransferBufferUsage = SDL_GPUTransferBufferUsage;
 
constexpr GPUTransferBufferUsage GPU_TRANSFERBUFFERUSAGE_UPLOAD =
  SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD; 
 
constexpr GPUTransferBufferUsage GPU_TRANSFERBUFFERUSAGE_DOWNLOAD =
  SDL_GPU_TRANSFERBUFFERUSAGE_DOWNLOAD; 

using GPUShaderStage = SDL_GPUShaderStage;
 
constexpr GPUShaderStage GPU_SHADERSTAGE_VERTEX =
  SDL_GPU_SHADERSTAGE_VERTEX; 
 
constexpr GPUShaderStage GPU_SHADERSTAGE_FRAGMENT =
  SDL_GPU_SHADERSTAGE_FRAGMENT; 

using GPUVertexElementFormat = SDL_GPUVertexElementFormat;
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_INVALID =
  SDL_GPU_VERTEXELEMENTFORMAT_INVALID; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_INT =
  SDL_GPU_VERTEXELEMENTFORMAT_INT; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_INT2 =
  SDL_GPU_VERTEXELEMENTFORMAT_INT2; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_INT3 =
  SDL_GPU_VERTEXELEMENTFORMAT_INT3; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_INT4 =
  SDL_GPU_VERTEXELEMENTFORMAT_INT4; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_UINT =
  SDL_GPU_VERTEXELEMENTFORMAT_UINT; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_UINT2 =
  SDL_GPU_VERTEXELEMENTFORMAT_UINT2; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_UINT3 =
  SDL_GPU_VERTEXELEMENTFORMAT_UINT3; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_UINT4 =
  SDL_GPU_VERTEXELEMENTFORMAT_UINT4; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_FLOAT =
  SDL_GPU_VERTEXELEMENTFORMAT_FLOAT; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_FLOAT2 =
  SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_FLOAT3 =
  SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_FLOAT4 =
  SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_BYTE2 =
  SDL_GPU_VERTEXELEMENTFORMAT_BYTE2; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_BYTE4 =
  SDL_GPU_VERTEXELEMENTFORMAT_BYTE4; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_UBYTE2 =
  SDL_GPU_VERTEXELEMENTFORMAT_UBYTE2; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_UBYTE4 =
  SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_BYTE2_NORM =
  SDL_GPU_VERTEXELEMENTFORMAT_BYTE2_NORM; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_BYTE4_NORM =
  SDL_GPU_VERTEXELEMENTFORMAT_BYTE4_NORM; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_UBYTE2_NORM =
  SDL_GPU_VERTEXELEMENTFORMAT_UBYTE2_NORM; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_UBYTE4_NORM =
  SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4_NORM; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_SHORT2 =
  SDL_GPU_VERTEXELEMENTFORMAT_SHORT2; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_SHORT4 =
  SDL_GPU_VERTEXELEMENTFORMAT_SHORT4; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_USHORT2 =
  SDL_GPU_VERTEXELEMENTFORMAT_USHORT2; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_USHORT4 =
  SDL_GPU_VERTEXELEMENTFORMAT_USHORT4; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_SHORT2_NORM =
  SDL_GPU_VERTEXELEMENTFORMAT_SHORT2_NORM; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_SHORT4_NORM =
  SDL_GPU_VERTEXELEMENTFORMAT_SHORT4_NORM; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_USHORT2_NORM =
  SDL_GPU_VERTEXELEMENTFORMAT_USHORT2_NORM; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_USHORT4_NORM =
  SDL_GPU_VERTEXELEMENTFORMAT_USHORT4_NORM; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_HALF2 =
  SDL_GPU_VERTEXELEMENTFORMAT_HALF2; 
 
constexpr GPUVertexElementFormat GPU_VERTEXELEMENTFORMAT_HALF4 =
  SDL_GPU_VERTEXELEMENTFORMAT_HALF4; 

using GPUVertexInputRate = SDL_GPUVertexInputRate;

constexpr GPUVertexInputRate GPU_VERTEXINPUTRATE_VERTEX =
  SDL_GPU_VERTEXINPUTRATE_VERTEX;

constexpr GPUVertexInputRate GPU_VERTEXINPUTRATE_INSTANCE =
  SDL_GPU_VERTEXINPUTRATE_INSTANCE;

using GPUFillMode = SDL_GPUFillMode;
 
constexpr GPUFillMode GPU_FILLMODE_FILL =
  SDL_GPU_FILLMODE_FILL; 
 
constexpr GPUFillMode GPU_FILLMODE_LINE =
  SDL_GPU_FILLMODE_LINE; 

using GPUCullMode = SDL_GPUCullMode;
 
constexpr GPUCullMode GPU_CULLMODE_NONE =
  SDL_GPU_CULLMODE_NONE; 
 
constexpr GPUCullMode GPU_CULLMODE_FRONT =
  SDL_GPU_CULLMODE_FRONT; 
 
constexpr GPUCullMode GPU_CULLMODE_BACK =
  SDL_GPU_CULLMODE_BACK; 

using GPUFrontFace = SDL_GPUFrontFace;

constexpr GPUFrontFace GPU_FRONTFACE_COUNTER_CLOCKWISE =
  SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE;

constexpr GPUFrontFace GPU_FRONTFACE_CLOCKWISE = SDL_GPU_FRONTFACE_CLOCKWISE;

using GPUCompareOp = SDL_GPUCompareOp;
 
constexpr GPUCompareOp GPU_COMPAREOP_INVALID =
  SDL_GPU_COMPAREOP_INVALID; 
 
constexpr GPUCompareOp GPU_COMPAREOP_NEVER =
  SDL_GPU_COMPAREOP_NEVER; 
 
constexpr GPUCompareOp GPU_COMPAREOP_LESS =
  SDL_GPU_COMPAREOP_LESS; 
 
constexpr GPUCompareOp GPU_COMPAREOP_EQUAL =
  SDL_GPU_COMPAREOP_EQUAL; 
 
constexpr GPUCompareOp GPU_COMPAREOP_LESS_OR_EQUAL =
  SDL_GPU_COMPAREOP_LESS_OR_EQUAL; 
 
constexpr GPUCompareOp GPU_COMPAREOP_GREATER =
  SDL_GPU_COMPAREOP_GREATER; 
 
constexpr GPUCompareOp GPU_COMPAREOP_NOT_EQUAL =
  SDL_GPU_COMPAREOP_NOT_EQUAL; 
 
constexpr GPUCompareOp GPU_COMPAREOP_GREATER_OR_EQUAL =
  SDL_GPU_COMPAREOP_GREATER_OR_EQUAL; 
 
constexpr GPUCompareOp GPU_COMPAREOP_ALWAYS =
  SDL_GPU_COMPAREOP_ALWAYS; 

using GPUStencilOp = SDL_GPUStencilOp;
 
constexpr GPUStencilOp GPU_STENCILOP_INVALID =
  SDL_GPU_STENCILOP_INVALID; 
 
constexpr GPUStencilOp GPU_STENCILOP_KEEP =
  SDL_GPU_STENCILOP_KEEP; 
 
constexpr GPUStencilOp GPU_STENCILOP_ZERO =
  SDL_GPU_STENCILOP_ZERO; 
 
constexpr GPUStencilOp GPU_STENCILOP_REPLACE =
  SDL_GPU_STENCILOP_REPLACE; 

constexpr GPUStencilOp GPU_STENCILOP_INCREMENT_AND_CLAMP =
  SDL_GPU_STENCILOP_INCREMENT_AND_CLAMP;
 
constexpr GPUStencilOp GPU_STENCILOP_DECREMENT_AND_CLAMP =
  SDL_GPU_STENCILOP_DECREMENT_AND_CLAMP; 
 
constexpr GPUStencilOp GPU_STENCILOP_INVERT =
  SDL_GPU_STENCILOP_INVERT; 
 
constexpr GPUStencilOp GPU_STENCILOP_INCREMENT_AND_WRAP =
  SDL_GPU_STENCILOP_INCREMENT_AND_WRAP; 

constexpr GPUStencilOp GPU_STENCILOP_DECREMENT_AND_WRAP =
  SDL_GPU_STENCILOP_DECREMENT_AND_WRAP;

using GPUBlendOp = SDL_GPUBlendOp;
 
constexpr GPUBlendOp GPU_BLENDOP_INVALID =
  SDL_GPU_BLENDOP_INVALID; 

constexpr GPUBlendOp GPU_BLENDOP_ADD = SDL_GPU_BLENDOP_ADD;

constexpr GPUBlendOp GPU_BLENDOP_SUBTRACT = SDL_GPU_BLENDOP_SUBTRACT;

constexpr GPUBlendOp GPU_BLENDOP_REVERSE_SUBTRACT =
  SDL_GPU_BLENDOP_REVERSE_SUBTRACT;
 
constexpr GPUBlendOp GPU_BLENDOP_MIN =
  SDL_GPU_BLENDOP_MIN; 
 
constexpr GPUBlendOp GPU_BLENDOP_MAX =
  SDL_GPU_BLENDOP_MAX; 

using GPUBlendFactor = SDL_GPUBlendFactor;
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_INVALID =
  SDL_GPU_BLENDFACTOR_INVALID; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_ZERO = SDL_GPU_BLENDFACTOR_ZERO; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_ONE = SDL_GPU_BLENDFACTOR_ONE; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_SRC_COLOR =
  SDL_GPU_BLENDFACTOR_SRC_COLOR; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_ONE_MINUS_SRC_COLOR =
  SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_COLOR; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_DST_COLOR =
  SDL_GPU_BLENDFACTOR_DST_COLOR; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_ONE_MINUS_DST_COLOR =
  SDL_GPU_BLENDFACTOR_ONE_MINUS_DST_COLOR; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_SRC_ALPHA =
  SDL_GPU_BLENDFACTOR_SRC_ALPHA; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA =
  SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_DST_ALPHA =
  SDL_GPU_BLENDFACTOR_DST_ALPHA; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_ONE_MINUS_DST_ALPHA =
  SDL_GPU_BLENDFACTOR_ONE_MINUS_DST_ALPHA; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_CONSTANT_COLOR =
  SDL_GPU_BLENDFACTOR_CONSTANT_COLOR; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_ONE_MINUS_CONSTANT_COLOR =
  SDL_GPU_BLENDFACTOR_ONE_MINUS_CONSTANT_COLOR; 
 
constexpr GPUBlendFactor GPU_BLENDFACTOR_SRC_ALPHA_SATURATE =
  SDL_GPU_BLENDFACTOR_SRC_ALPHA_SATURATE; 

using GPUColorComponentFlags = Uint8;
 
constexpr GPUColorComponentFlags GPU_COLORCOMPONENT_R =
  SDL_GPU_COLORCOMPONENT_R; 
 
constexpr GPUColorComponentFlags GPU_COLORCOMPONENT_G =
  SDL_GPU_COLORCOMPONENT_G; 
 
constexpr GPUColorComponentFlags GPU_COLORCOMPONENT_B =
  SDL_GPU_COLORCOMPONENT_B; 
 
constexpr GPUColorComponentFlags GPU_COLORCOMPONENT_A =
  SDL_GPU_COLORCOMPONENT_A; 

using GPUFilter = SDL_GPUFilter;
 
constexpr GPUFilter GPU_FILTER_NEAREST =
  SDL_GPU_FILTER_NEAREST; 
 
constexpr GPUFilter GPU_FILTER_LINEAR =
  SDL_GPU_FILTER_LINEAR; 

using GPUSamplerMipmapMode = SDL_GPUSamplerMipmapMode;
 
constexpr GPUSamplerMipmapMode GPU_SAMPLERMIPMAPMODE_NEAREST =
  SDL_GPU_SAMPLERMIPMAPMODE_NEAREST; 
 
constexpr GPUSamplerMipmapMode GPU_SAMPLERMIPMAPMODE_LINEAR =
  SDL_GPU_SAMPLERMIPMAPMODE_LINEAR; 

using GPUSamplerAddressMode = SDL_GPUSamplerAddressMode;
 
constexpr GPUSamplerAddressMode GPU_SAMPLERADDRESSMODE_REPEAT =
  SDL_GPU_SAMPLERADDRESSMODE_REPEAT; 

constexpr GPUSamplerAddressMode GPU_SAMPLERADDRESSMODE_MIRRORED_REPEAT =
  SDL_GPU_SAMPLERADDRESSMODE_MIRRORED_REPEAT;

constexpr GPUSamplerAddressMode GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE =
  SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE;

using GPUBlitRegion = SDL_GPUBlitRegion;

using GPUIndirectDrawCommand = SDL_GPUIndirectDrawCommand;

using GPUIndexedIndirectDrawCommand = SDL_GPUIndexedIndirectDrawCommand;

using GPUIndirectDispatchCommand = SDL_GPUIndirectDispatchCommand;

using GPUVertexBufferDescription = SDL_GPUVertexBufferDescription;

using GPUVertexAttribute = SDL_GPUVertexAttribute;

using GPUVertexInputState = SDL_GPUVertexInputState;

using GPUStencilOpState = SDL_GPUStencilOpState;

using GPUColorTargetBlendState = SDL_GPUColorTargetBlendState;

using GPURasterizerState = SDL_GPURasterizerState;

using GPUMultisampleState = SDL_GPUMultisampleState;

using GPUDepthStencilState = SDL_GPUDepthStencilState;

using GPUColorTargetDescription = SDL_GPUColorTargetDescription;

using GPUGraphicsPipelineTargetInfo = SDL_GPUGraphicsPipelineTargetInfo;

inline bool GPUSupportsShaderFormats(GPUShaderFormat format_flags,
                                     StringParam name)
{
  return SDL_GPUSupportsShaderFormats(format_flags, name);
}

inline bool GPUSupportsProperties(PropertiesRef props)
{
  return SDL_GPUSupportsProperties(props);
}

inline GPUDevice CreateGPUDevice(GPUShaderFormat format_flags,
                                 bool debug_mode,
                                 StringParam name)
{
  return GPUDevice(format_flags, debug_mode, std::move(name));
}
 
inline GPUDevice::GPUDevice(GPUShaderFormat format_flags,
                            bool debug_mode,
                            StringParam name)
  : GPUDevice(CheckError(SDL_CreateGPUDevice(format_flags, debug_mode, name)))
{
}
 
inline GPUDevice::GPUDevice(PropertiesRef props)
  : GPUDevice(CheckError(SDL_CreateGPUDeviceWithProperties(props)))
{
}

inline GPUDevice CreateGPUDeviceWithProperties(PropertiesRef props)
{
  return GPUDevice(props);
}

namespace prop::GPUDevice::Create {
 
constexpr auto DEBUGMODE_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_DEBUGMODE_BOOLEAN; 
 
constexpr auto PREFERLOWPOWER_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_PREFERLOWPOWER_BOOLEAN; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto VERBOSE_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_VERBOSE_BOOLEAN; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto NAME_STRING =
  SDL_PROP_GPU_DEVICE_CREATE_NAME_STRING; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto FEATURE_CLIP_DISTANCE_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_FEATURE_CLIP_DISTANCE_BOOLEAN; 
 
constexpr auto FEATURE_DEPTH_CLAMPING_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_FEATURE_DEPTH_CLAMPING_BOOLEAN; 
 
constexpr auto FEATURE_INDIRECT_DRAW_FIRST_INSTANCE_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_FEATURE_INDIRECT_DRAW_FIRST_INSTANCE_BOOLEAN; 
 
constexpr auto FEATURE_ANISOTROPY_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_FEATURE_ANISOTROPY_BOOLEAN; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto SHADERS_PRIVATE_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_PRIVATE_BOOLEAN; 
 
constexpr auto SHADERS_SPIRV_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_SPIRV_BOOLEAN; 
 
constexpr auto SHADERS_DXBC_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXBC_BOOLEAN; 
 
constexpr auto SHADERS_DXIL_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXIL_BOOLEAN; 
 
constexpr auto SHADERS_MSL_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_MSL_BOOLEAN; 
 
constexpr auto SHADERS_METALLIB_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_METALLIB_BOOLEAN; 
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto D3D12_ALLOW_FEWER_RESOURCE_SLOTS_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_D3D12_ALLOW_FEWER_RESOURCE_SLOTS_BOOLEAN; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto D3D12_SEMANTIC_NAME_STRING =
  SDL_PROP_GPU_DEVICE_CREATE_D3D12_SEMANTIC_NAME_STRING; 
 
#if SDL_VERSION_ATLEAST(3, 4, 2)
 
constexpr auto D3D12_AGILITY_SDK_VERSION_NUMBER =
  SDL_PROP_GPU_DEVICE_CREATE_D3D12_AGILITY_SDK_VERSION_NUMBER; 
 
constexpr auto D3D12_AGILITY_SDK_PATH_STRING =
  SDL_PROP_GPU_DEVICE_CREATE_D3D12_AGILITY_SDK_PATH_STRING; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 2)
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
constexpr auto VULKAN_REQUIRE_HARDWARE_ACCELERATION_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_VULKAN_REQUIRE_HARDWARE_ACCELERATION_BOOLEAN; 
 
constexpr auto VULKAN_OPTIONS_POINTER =
  SDL_PROP_GPU_DEVICE_CREATE_VULKAN_OPTIONS_POINTER; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
#if SDL_VERSION_ATLEAST(3, 4, 2)
 
constexpr auto METAL_ALLOW_MACFAMILY1_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_METAL_ALLOW_MACFAMILY1_BOOLEAN; 
 
#endif // SDL_VERSION_ATLEAST(3, 4, 2)
 
} // namespace prop::GPUDevice::Create
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

using GPUVulkanOptions = SDL_GPUVulkanOptions;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

inline void DestroyGPUDevice(GPUDeviceRaw device)
{
  SDL_DestroyGPUDevice(device);
}
 
inline void GPUDeviceBase::Destroy() { DestroyGPUDevice(release()); }

inline int GetNumGPUDrivers() { return SDL_GetNumGPUDrivers(); }

inline const char* GetGPUDriver(int index) { return SDL_GetGPUDriver(index); }

inline const char* GetGPUDeviceDriver(GPUDeviceRef device)
{
  return SDL_GetGPUDeviceDriver(device);
}
 
inline const char* GPUDeviceBase::GetDriver()
{
  return SDL::GetGPUDeviceDriver(get());
}

inline GPUShaderFormat GetGPUShaderFormats(GPUDeviceRef device)
{
  return SDL_GetGPUShaderFormats(device);
}
 
inline GPUShaderFormat GPUDeviceBase::GetShaderFormats()
{
  return SDL::GetGPUShaderFormats(get());
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline PropertiesRef GetGPUDeviceProperties(GPUDeviceRef device)
{
  return CheckError(SDL_GetGPUDeviceProperties(device));
}
 
inline PropertiesRef GPUDeviceBase::GetProperties()
{
  return SDL::GetGPUDeviceProperties(get());
}

namespace prop::GPUDevice {
 
constexpr auto NAME_STRING =
  SDL_PROP_GPU_DEVICE_NAME_STRING; 
 
constexpr auto DRIVER_NAME_STRING =
  SDL_PROP_GPU_DEVICE_DRIVER_NAME_STRING; 
 
constexpr auto DRIVER_VERSION_STRING =
  SDL_PROP_GPU_DEVICE_DRIVER_VERSION_STRING; 
 
constexpr auto DRIVER_INFO_STRING =
  SDL_PROP_GPU_DEVICE_DRIVER_INFO_STRING; 
 
} // namespace prop::GPUDevice
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)

inline GPUComputePipeline CreateGPUComputePipeline(
  GPUDeviceRef device,
  const GPUComputePipelineCreateInfo& createinfo)
{
  return GPUComputePipeline(device, createinfo);
}
 
inline GPUComputePipeline GPUDeviceBase::CreateComputePipeline(
  const GPUComputePipelineCreateInfo& createinfo)
{
  return GPUComputePipeline(get(), createinfo);
}
 
inline GPUComputePipeline::GPUComputePipeline(
  GPUDeviceRef device,
  const GPUComputePipelineCreateInfo& createinfo)
  : m_gPUComputePipeline(
      CheckError(SDL_CreateGPUComputePipeline(device, &createinfo)))
{
}

namespace prop::GPUComputePipeline::Create {
 
constexpr auto NAME_STRING =
  SDL_PROP_GPU_COMPUTEPIPELINE_CREATE_NAME_STRING; 
 
} // namespace prop::GPUComputePipeline::Create

inline GPUGraphicsPipeline CreateGPUGraphicsPipeline(
  GPUDeviceRef device,
  const GPUGraphicsPipelineCreateInfo& createinfo)
{
  return GPUGraphicsPipeline(device, createinfo);
}
 
inline GPUGraphicsPipeline GPUDeviceBase::CreateGraphicsPipeline(
  const GPUGraphicsPipelineCreateInfo& createinfo)
{
  return GPUGraphicsPipeline(get(), createinfo);
}
 
inline GPUGraphicsPipeline::GPUGraphicsPipeline(
  GPUDeviceRef device,
  const GPUGraphicsPipelineCreateInfo& createinfo)
  : m_gPUGraphicsPipeline(
      CheckError(SDL_CreateGPUGraphicsPipeline(device, &createinfo)))
{
}

namespace prop::GPUGraphicsPipeline::Create {
 
constexpr auto NAME_STRING =
  SDL_PROP_GPU_GRAPHICSPIPELINE_CREATE_NAME_STRING; 
 
} // namespace prop::GPUGraphicsPipeline::Create

inline GPUSampler CreateGPUSampler(GPUDeviceRef device,
                                   const GPUSamplerCreateInfo& createinfo)
{
  return GPUSampler(device, createinfo);
}
 
inline GPUSampler GPUDeviceBase::CreateSampler(
  const GPUSamplerCreateInfo& createinfo)
{
  return GPUSampler(get(), createinfo);
}
 
inline GPUSampler::GPUSampler(GPUDeviceRef device,
                              const GPUSamplerCreateInfo& createinfo)
  : m_gPUSampler(CheckError(SDL_CreateGPUSampler(device, &createinfo)))
{
}

namespace prop::GPUSampler::Create {
 
constexpr auto NAME_STRING =
  SDL_PROP_GPU_SAMPLER_CREATE_NAME_STRING; 
 
} // namespace prop::GPUSampler::Create

inline GPUShader CreateGPUShader(GPUDeviceRef device,
                                 const GPUShaderCreateInfo& createinfo)
{
  return GPUShader(device, createinfo);
}
 
inline GPUShader GPUDeviceBase::CreateShader(
  const GPUShaderCreateInfo& createinfo)
{
  return GPUShader(get(), createinfo);
}
 
inline GPUShader::GPUShader(GPUDeviceRef device,
                            const GPUShaderCreateInfo& createinfo)
  : m_gPUShader(CheckError(SDL_CreateGPUShader(device, &createinfo)))
{
}

namespace prop::GPUShader::Create {
 
constexpr auto NAME_STRING =
  SDL_PROP_GPU_SHADER_CREATE_NAME_STRING; 
 
} // namespace prop::GPUShader::Create

inline GPUTexture CreateGPUTexture(GPUDeviceRef device,
                                   const GPUTextureCreateInfo& createinfo)
{
  return GPUTexture(device, createinfo);
}
 
inline GPUTexture GPUDeviceBase::CreateTexture(
  const GPUTextureCreateInfo& createinfo)
{
  return GPUTexture(get(), createinfo);
}
 
inline GPUTexture::GPUTexture(GPUDeviceRef device,
                              const GPUTextureCreateInfo& createinfo)
  : m_gPUTexture(CheckError(SDL_CreateGPUTexture(device, &createinfo)))
{
}

namespace prop::GPUTexture::Create {
 
constexpr auto D3D12_CLEAR_R_FLOAT =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_R_FLOAT; 
 
constexpr auto D3D12_CLEAR_G_FLOAT =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_G_FLOAT; 
 
constexpr auto D3D12_CLEAR_B_FLOAT =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_B_FLOAT; 
 
constexpr auto D3D12_CLEAR_A_FLOAT =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_A_FLOAT; 
 
constexpr auto D3D12_CLEAR_DEPTH_FLOAT =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_DEPTH_FLOAT; 
 
#if SDL_VERSION_ATLEAST(3, 2, 12)
 
constexpr auto D3D12_CLEAR_STENCIL_NUMBER =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_STENCIL_NUMBER; 
 
#endif // SDL_VERSION_ATLEAST(3, 2, 12)
 
constexpr auto NAME_STRING =
  SDL_PROP_GPU_TEXTURE_CREATE_NAME_STRING; 
 
} // namespace prop::GPUTexture::Create

inline GPUBuffer CreateGPUBuffer(GPUDeviceRef device,
                                 const GPUBufferCreateInfo& createinfo)
{
  return GPUBuffer(device, createinfo);
}
 
inline GPUBuffer GPUDeviceBase::CreateBuffer(
  const GPUBufferCreateInfo& createinfo)
{
  return GPUBuffer(get(), createinfo);
}
 
inline GPUBuffer::GPUBuffer(GPUDeviceRef device,
                            const GPUBufferCreateInfo& createinfo)
  : m_gPUBuffer(CheckError(SDL_CreateGPUBuffer(device, &createinfo)))
{
}

namespace prop::GPUBuffer::Create {
 
constexpr auto NAME_STRING =
  SDL_PROP_GPU_BUFFER_CREATE_NAME_STRING; 
 
} // namespace prop::GPUBuffer::Create

inline GPUTransferBuffer CreateGPUTransferBuffer(
  GPUDeviceRef device,
  const GPUTransferBufferCreateInfo& createinfo)
{
  return GPUTransferBuffer(device, createinfo);
}
 
inline GPUTransferBuffer GPUDeviceBase::CreateTransferBuffer(
  const GPUTransferBufferCreateInfo& createinfo)
{
  return GPUTransferBuffer(get(), createinfo);
}
 
inline GPUTransferBuffer::GPUTransferBuffer(
  GPUDeviceRef device,
  const GPUTransferBufferCreateInfo& createinfo)
  : m_gPUTransferBuffer(
      CheckError(SDL_CreateGPUTransferBuffer(device, &createinfo)))
{
}

namespace prop::GPUTransferBuffer::Create {
 
constexpr auto NAME_STRING =
  SDL_PROP_GPU_TRANSFERBUFFER_CREATE_NAME_STRING; 
 
} // namespace prop::GPUTransferBuffer::Create

inline void SetGPUBufferName(GPUDeviceRef device,
                             GPUBuffer buffer,
                             StringParam text)
{
  SDL_SetGPUBufferName(device, buffer, text);
}
 
inline void GPUDeviceBase::SetBufferName(GPUBuffer buffer, StringParam text)
{
  SDL::SetGPUBufferName(get(), buffer, std::move(text));
}

inline void SetGPUTextureName(GPUDeviceRef device,
                              GPUTexture texture,
                              StringParam text)
{
  SDL_SetGPUTextureName(device, texture, text);
}
 
inline void GPUDeviceBase::SetTextureName(GPUTexture texture, StringParam text)
{
  SDL::SetGPUTextureName(get(), texture, std::move(text));
}

inline void InsertGPUDebugLabel(GPUCommandBuffer command_buffer,
                                StringParam text)
{
  SDL_InsertGPUDebugLabel(command_buffer, text);
}
 
inline void GPUCommandBuffer::InsertDebugLabel(StringParam text)
{
  SDL::InsertGPUDebugLabel(m_gPUCommandBuffer, std::move(text));
}

inline void PushGPUDebugGroup(GPUCommandBuffer command_buffer, StringParam name)
{
  SDL_PushGPUDebugGroup(command_buffer, name);
}
 
inline void GPUCommandBuffer::PushDebugGroup(StringParam name)
{
  SDL::PushGPUDebugGroup(m_gPUCommandBuffer, std::move(name));
}

inline void PopGPUDebugGroup(GPUCommandBuffer command_buffer)
{
  SDL_PopGPUDebugGroup(command_buffer);
}
 
inline void GPUCommandBuffer::PopDebugGroup()
{
  SDL::PopGPUDebugGroup(m_gPUCommandBuffer);
}

inline void ReleaseGPUTexture(GPUDeviceRef device, GPUTexture texture)
{
  SDL_ReleaseGPUTexture(device, texture);
}
 
inline void GPUDeviceBase::ReleaseTexture(GPUTexture texture)
{
  SDL::ReleaseGPUTexture(get(), texture);
}

inline void ReleaseGPUSampler(GPUDeviceRef device, GPUSampler sampler)
{
  SDL_ReleaseGPUSampler(device, sampler);
}
 
inline void GPUDeviceBase::ReleaseSampler(GPUSampler sampler)
{
  SDL::ReleaseGPUSampler(get(), sampler);
}

inline void ReleaseGPUBuffer(GPUDeviceRef device, GPUBuffer buffer)
{
  SDL_ReleaseGPUBuffer(device, buffer);
}
 
inline void GPUDeviceBase::ReleaseBuffer(GPUBuffer buffer)
{
  SDL::ReleaseGPUBuffer(get(), buffer);
}

inline void ReleaseGPUTransferBuffer(GPUDeviceRef device,
                                     GPUTransferBuffer transfer_buffer)
{
  SDL_ReleaseGPUTransferBuffer(device, transfer_buffer);
}
 
inline void GPUDeviceBase::ReleaseTransferBuffer(
  GPUTransferBuffer transfer_buffer)
{
  SDL::ReleaseGPUTransferBuffer(get(), transfer_buffer);
}

inline void ReleaseGPUComputePipeline(GPUDeviceRef device,
                                      GPUComputePipeline compute_pipeline)
{
  SDL_ReleaseGPUComputePipeline(device, compute_pipeline);
}
 
inline void GPUDeviceBase::ReleaseComputePipeline(
  GPUComputePipeline compute_pipeline)
{
  SDL::ReleaseGPUComputePipeline(get(), compute_pipeline);
}

inline void ReleaseGPUShader(GPUDeviceRef device, GPUShader shader)
{
  SDL_ReleaseGPUShader(device, shader);
}
 
inline void GPUDeviceBase::ReleaseShader(GPUShader shader)
{
  SDL::ReleaseGPUShader(get(), shader);
}

inline void ReleaseGPUGraphicsPipeline(GPUDeviceRef device,
                                       GPUGraphicsPipeline graphics_pipeline)
{
  SDL_ReleaseGPUGraphicsPipeline(device, graphics_pipeline);
}
 
inline void GPUDeviceBase::ReleaseGraphicsPipeline(
  GPUGraphicsPipeline graphics_pipeline)
{
  SDL::ReleaseGPUGraphicsPipeline(get(), graphics_pipeline);
}

inline GPUCommandBuffer AcquireGPUCommandBuffer(GPUDeviceRef device)
{
  return CheckError(SDL_AcquireGPUCommandBuffer(device));
}
 
inline GPUCommandBuffer GPUDeviceBase::AcquireCommandBuffer()
{
  return SDL::AcquireGPUCommandBuffer(get());
}

inline void PushGPUVertexUniformData(GPUCommandBuffer command_buffer,
                                     Uint32 slot_index,
                                     SourceBytes data)
{
  SDL_PushGPUVertexUniformData(
    command_buffer, slot_index, data.data(), narrowU32(data.size_bytes()));
}
 
inline void GPUCommandBuffer::PushVertexUniformData(Uint32 slot_index,
                                                    SourceBytes data)
{
  SDL::PushGPUVertexUniformData(
    m_gPUCommandBuffer, slot_index, std::move(data));
}

inline void PushGPUFragmentUniformData(GPUCommandBuffer command_buffer,
                                       Uint32 slot_index,
                                       SourceBytes data)
{
  SDL_PushGPUFragmentUniformData(
    command_buffer, slot_index, data.data(), narrowU32(data.size_bytes()));
}
 
inline void GPUCommandBuffer::PushFragmentUniformData(Uint32 slot_index,
                                                      SourceBytes data)
{
  SDL::PushGPUFragmentUniformData(
    m_gPUCommandBuffer, slot_index, std::move(data));
}

inline void PushGPUComputeUniformData(GPUCommandBuffer command_buffer,
                                      Uint32 slot_index,
                                      SourceBytes data)
{
  SDL_PushGPUComputeUniformData(
    command_buffer, slot_index, data.data(), narrowU32(data.size_bytes()));
}
 
inline void GPUCommandBuffer::PushComputeUniformData(Uint32 slot_index,
                                                     SourceBytes data)
{
  SDL::PushGPUComputeUniformData(
    m_gPUCommandBuffer, slot_index, std::move(data));
}

inline GPURenderPass BeginGPURenderPass(
  GPUCommandBuffer command_buffer,
  std::span<const GPUColorTargetInfo> color_target_infos,
  OptionalRef<const GPUDepthStencilTargetInfo> depth_stencil_target_info)
{
  return SDL_BeginGPURenderPass(command_buffer,
                                color_target_infos.data(),
                                narrowU32(color_target_infos.size()),
                                depth_stencil_target_info);
}
 
inline GPURenderPass GPUCommandBuffer::BeginRenderPass(
  std::span<const GPUColorTargetInfo> color_target_infos,
  OptionalRef<const GPUDepthStencilTargetInfo> depth_stencil_target_info)
{
  return SDL::BeginGPURenderPass(
    m_gPUCommandBuffer, color_target_infos, depth_stencil_target_info);
}

inline void BindGPUGraphicsPipeline(GPURenderPass render_pass,
                                    GPUGraphicsPipeline graphics_pipeline)
{
  SDL_BindGPUGraphicsPipeline(render_pass, graphics_pipeline);
}
 
inline void GPURenderPass::BindPipeline(GPUGraphicsPipeline graphics_pipeline)
{
  SDL::BindGPUGraphicsPipeline(m_gPURenderPass, graphics_pipeline);
}

inline void SetGPUViewport(GPURenderPass render_pass,
                           const GPUViewport& viewport)
{
  SDL_SetGPUViewport(render_pass, &viewport);
}
 
inline void GPURenderPass::SetViewport(const GPUViewport& viewport)
{
  SDL::SetGPUViewport(m_gPURenderPass, viewport);
}

inline void SetGPUScissor(GPURenderPass render_pass, const RectRaw& scissor)
{
  SDL_SetGPUScissor(render_pass, &scissor);
}
 
inline void GPURenderPass::SetScissor(const RectRaw& scissor)
{
  SDL::SetGPUScissor(m_gPURenderPass, scissor);
}

inline void SetGPUBlendConstants(GPURenderPass render_pass,
                                 FColorRaw blend_constants)
{
  SDL_SetGPUBlendConstants(render_pass, blend_constants);
}
 
inline void GPURenderPass::SetBlendConstants(FColorRaw blend_constants)
{
  SDL::SetGPUBlendConstants(m_gPURenderPass, blend_constants);
}

inline void SetGPUStencilReference(GPURenderPass render_pass, Uint8 reference)
{
  SDL_SetGPUStencilReference(render_pass, reference);
}
 
inline void GPURenderPass::SetStencilReference(Uint8 reference)
{
  SDL::SetGPUStencilReference(m_gPURenderPass, reference);
}

inline void BindGPUVertexBuffers(GPURenderPass render_pass,
                                 Uint32 first_slot,
                                 std::span<const GPUBufferBinding> bindings)
{
  SDL_BindGPUVertexBuffers(
    render_pass, first_slot, bindings.data(), narrowU32(bindings.size()));
}
 
inline void GPURenderPass::BindVertexBuffers(
  Uint32 first_slot,
  std::span<const GPUBufferBinding> bindings)
{
  SDL::BindGPUVertexBuffers(m_gPURenderPass, first_slot, bindings);
}

inline void BindGPUIndexBuffer(GPURenderPass render_pass,
                               const GPUBufferBinding& binding,
                               GPUIndexElementSize index_element_size)
{
  SDL_BindGPUIndexBuffer(render_pass, &binding, index_element_size);
}
 
inline void GPURenderPass::BindIndexBuffer(
  const GPUBufferBinding& binding,
  GPUIndexElementSize index_element_size)
{
  SDL::BindGPUIndexBuffer(m_gPURenderPass, binding, index_element_size);
}

inline void BindGPUVertexSamplers(
  GPURenderPass render_pass,
  Uint32 first_slot,
  std::span<const GPUTextureSamplerBinding> texture_sampler_bindings)
{
  SDL_BindGPUVertexSamplers(render_pass,
                            first_slot,
                            texture_sampler_bindings.data(),
                            narrowU32(texture_sampler_bindings.size()));
}
 
inline void GPURenderPass::BindVertexSamplers(
  Uint32 first_slot,
  std::span<const GPUTextureSamplerBinding> texture_sampler_bindings)
{
  SDL::BindGPUVertexSamplers(
    m_gPURenderPass, first_slot, texture_sampler_bindings);
}

inline void BindGPUVertexStorageTextures(
  GPURenderPass render_pass,
  Uint32 first_slot,
  SpanRef<const GPUTextureRaw> storage_textures)
{
  SDL_BindGPUVertexStorageTextures(render_pass,
                                   first_slot,
                                   storage_textures.data(),
                                   narrowU32(storage_textures.size()));
}
 
inline void GPURenderPass::BindVertexStorageTextures(
  Uint32 first_slot,
  SpanRef<const GPUTextureRaw> storage_textures)
{
  SDL::BindGPUVertexStorageTextures(
    m_gPURenderPass, first_slot, storage_textures);
}

inline void BindGPUVertexStorageBuffers(
  GPURenderPass render_pass,
  Uint32 first_slot,
  SpanRef<const GPUBufferRaw> storage_buffers)
{
  SDL_BindGPUVertexStorageBuffers(render_pass,
                                  first_slot,
                                  storage_buffers.data(),
                                  narrowU32(storage_buffers.size()));
}
 
inline void GPURenderPass::BindVertexStorageBuffers(
  Uint32 first_slot,
  SpanRef<const GPUBufferRaw> storage_buffers)
{
  SDL::BindGPUVertexStorageBuffers(
    m_gPURenderPass, first_slot, storage_buffers);
}

inline void BindGPUFragmentSamplers(
  GPURenderPass render_pass,
  Uint32 first_slot,
  std::span<const GPUTextureSamplerBinding> texture_sampler_bindings)
{
  SDL_BindGPUFragmentSamplers(render_pass,
                              first_slot,
                              texture_sampler_bindings.data(),
                              narrowU32(texture_sampler_bindings.size()));
}
 
inline void GPURenderPass::BindFragmentSamplers(
  Uint32 first_slot,
  std::span<const GPUTextureSamplerBinding> texture_sampler_bindings)
{
  SDL::BindGPUFragmentSamplers(
    m_gPURenderPass, first_slot, texture_sampler_bindings);
}

inline void BindGPUFragmentStorageTextures(
  GPURenderPass render_pass,
  Uint32 first_slot,
  SpanRef<const GPUTextureRaw> storage_textures)
{
  SDL_BindGPUFragmentStorageTextures(render_pass,
                                     first_slot,
                                     storage_textures.data(),
                                     narrowU32(storage_textures.size()));
}
 
inline void GPURenderPass::BindFragmentStorageTextures(
  Uint32 first_slot,
  SpanRef<const GPUTextureRaw> storage_textures)
{
  SDL::BindGPUFragmentStorageTextures(
    m_gPURenderPass, first_slot, storage_textures);
}

inline void BindGPUFragmentStorageBuffers(
  GPURenderPass render_pass,
  Uint32 first_slot,
  SpanRef<const GPUBufferRaw> storage_buffers)
{
  SDL_BindGPUFragmentStorageBuffers(render_pass,
                                    first_slot,
                                    storage_buffers.data(),
                                    narrowU32(storage_buffers.size()));
}
 
inline void GPURenderPass::BindFragmentStorageBuffers(
  Uint32 first_slot,
  SpanRef<const GPUBufferRaw> storage_buffers)
{
  SDL::BindGPUFragmentStorageBuffers(
    m_gPURenderPass, first_slot, storage_buffers);
}

inline void DrawGPUIndexedPrimitives(GPURenderPass render_pass,
                                     Uint32 num_indices,
                                     Uint32 num_instances,
                                     Uint32 first_index,
                                     Sint32 vertex_offset,
                                     Uint32 first_instance)
{
  SDL_DrawGPUIndexedPrimitives(render_pass,
                               num_indices,
                               num_instances,
                               first_index,
                               vertex_offset,
                               first_instance);
}
 
inline void GPURenderPass::DrawIndexedPrimitives(Uint32 num_indices,
                                                 Uint32 num_instances,
                                                 Uint32 first_index,
                                                 Sint32 vertex_offset,
                                                 Uint32 first_instance)
{
  SDL::DrawGPUIndexedPrimitives(m_gPURenderPass,
                                num_indices,
                                num_instances,
                                first_index,
                                vertex_offset,
                                first_instance);
}

inline void DrawGPUPrimitives(GPURenderPass render_pass,
                              Uint32 num_vertices,
                              Uint32 num_instances,
                              Uint32 first_vertex,
                              Uint32 first_instance)
{
  SDL_DrawGPUPrimitives(
    render_pass, num_vertices, num_instances, first_vertex, first_instance);
}
 
inline void GPURenderPass::DrawPrimitives(Uint32 num_vertices,
                                          Uint32 num_instances,
                                          Uint32 first_vertex,
                                          Uint32 first_instance)
{
  SDL::DrawGPUPrimitives(
    m_gPURenderPass, num_vertices, num_instances, first_vertex, first_instance);
}

inline void DrawGPUPrimitivesIndirect(GPURenderPass render_pass,
                                      GPUBuffer buffer,
                                      Uint32 offset,
                                      Uint32 draw_count)
{
  SDL_DrawGPUPrimitivesIndirect(render_pass, buffer, offset, draw_count);
}
 
inline void GPURenderPass::DrawPrimitivesIndirect(GPUBuffer buffer,
                                                  Uint32 offset,
                                                  Uint32 draw_count)
{
  SDL::DrawGPUPrimitivesIndirect(m_gPURenderPass, buffer, offset, draw_count);
}

inline void DrawGPUIndexedPrimitivesIndirect(GPURenderPass render_pass,
                                             GPUBuffer buffer,
                                             Uint32 offset,
                                             Uint32 draw_count)
{
  SDL_DrawGPUIndexedPrimitivesIndirect(render_pass, buffer, offset, draw_count);
}
 
inline void GPURenderPass::DrawIndexedPrimitivesIndirect(GPUBuffer buffer,
                                                         Uint32 offset,
                                                         Uint32 draw_count)
{
  SDL::DrawGPUIndexedPrimitivesIndirect(
    m_gPURenderPass, buffer, offset, draw_count);
}

inline void EndGPURenderPass(GPURenderPass render_pass)
{
  SDL_EndGPURenderPass(render_pass);
}
 
inline void GPURenderPass::End() { SDL::EndGPURenderPass(m_gPURenderPass); }

inline GPUComputePass BeginGPUComputePass(
  GPUCommandBuffer command_buffer,
  std::span<const GPUStorageTextureReadWriteBinding> storage_texture_bindings,
  std::span<const GPUStorageBufferReadWriteBinding> storage_buffer_bindings)
{
  return SDL_BeginGPUComputePass(command_buffer,
                                 storage_texture_bindings.data(),
                                 narrowU32(storage_texture_bindings.size()),
                                 storage_buffer_bindings.data(),
                                 narrowU32(storage_buffer_bindings.size()));
}
 
inline GPUComputePass GPUCommandBuffer::BeginComputePass(
  std::span<const GPUStorageTextureReadWriteBinding> storage_texture_bindings,
  std::span<const GPUStorageBufferReadWriteBinding> storage_buffer_bindings)
{
  return SDL::BeginGPUComputePass(
    m_gPUCommandBuffer, storage_texture_bindings, storage_buffer_bindings);
}

inline void BindGPUComputePipeline(GPUComputePass compute_pass,
                                   GPUComputePipeline compute_pipeline)
{
  SDL_BindGPUComputePipeline(compute_pass, compute_pipeline);
}
 
inline void GPUComputePass::BindPipeline(GPUComputePipeline compute_pipeline)
{
  SDL::BindGPUComputePipeline(m_gPUComputePass, compute_pipeline);
}

inline void BindGPUComputeSamplers(
  GPUComputePass compute_pass,
  Uint32 first_slot,
  std::span<const GPUTextureSamplerBinding> texture_sampler_bindings)
{
  SDL_BindGPUComputeSamplers(compute_pass,
                             first_slot,
                             texture_sampler_bindings.data(),
                             narrowU32(texture_sampler_bindings.size()));
}
 
inline void GPUComputePass::BindSamplers(
  Uint32 first_slot,
  std::span<const GPUTextureSamplerBinding> texture_sampler_bindings)
{
  SDL::BindGPUComputeSamplers(
    m_gPUComputePass, first_slot, texture_sampler_bindings);
}

inline void BindGPUComputeStorageTextures(
  GPUComputePass compute_pass,
  Uint32 first_slot,
  SpanRef<const GPUTextureRaw> storage_textures)
{
  SDL_BindGPUComputeStorageTextures(compute_pass,
                                    first_slot,
                                    storage_textures.data(),
                                    narrowU32(storage_textures.size()));
}
 
inline void GPUComputePass::BindStorageTextures(
  Uint32 first_slot,
  SpanRef<const GPUTextureRaw> storage_textures)
{
  SDL::BindGPUComputeStorageTextures(
    m_gPUComputePass, first_slot, storage_textures);
}

inline void BindGPUComputeStorageBuffers(
  GPUComputePass compute_pass,
  Uint32 first_slot,
  SpanRef<const GPUBufferRaw> storage_buffers)
{
  SDL_BindGPUComputeStorageBuffers(compute_pass,
                                   first_slot,
                                   storage_buffers.data(),
                                   narrowU32(storage_buffers.size()));
}
 
inline void GPUComputePass::BindStorageBuffers(
  Uint32 first_slot,
  SpanRef<const GPUBufferRaw> storage_buffers)
{
  SDL::BindGPUComputeStorageBuffers(
    m_gPUComputePass, first_slot, storage_buffers);
}

inline void DispatchGPUCompute(GPUComputePass compute_pass,
                               Uint32 groupcount_x,
                               Uint32 groupcount_y,
                               Uint32 groupcount_z)
{
  SDL_DispatchGPUCompute(
    compute_pass, groupcount_x, groupcount_y, groupcount_z);
}
 
inline void GPUComputePass::Dispatch(Uint32 groupcount_x,
                                     Uint32 groupcount_y,
                                     Uint32 groupcount_z)
{
  SDL::DispatchGPUCompute(
    m_gPUComputePass, groupcount_x, groupcount_y, groupcount_z);
}

inline void DispatchGPUComputeIndirect(GPUComputePass compute_pass,
                                       GPUBuffer buffer,
                                       Uint32 offset)
{
  SDL_DispatchGPUComputeIndirect(compute_pass, buffer, offset);
}
 
inline void GPUComputePass::DispatchIndirect(GPUBuffer buffer, Uint32 offset)
{
  SDL::DispatchGPUComputeIndirect(m_gPUComputePass, buffer, offset);
}

inline void EndGPUComputePass(GPUComputePass compute_pass)
{
  SDL_EndGPUComputePass(compute_pass);
}
 
inline void GPUComputePass::End() { SDL::EndGPUComputePass(m_gPUComputePass); }

inline void* MapGPUTransferBuffer(GPUDeviceRef device,
                                  GPUTransferBuffer transfer_buffer,
                                  bool cycle)
{
  return CheckError(SDL_MapGPUTransferBuffer(device, transfer_buffer, cycle));
}
 
inline void* GPUDeviceBase::MapTransferBuffer(GPUTransferBuffer transfer_buffer,
                                              bool cycle)
{
  return SDL::MapGPUTransferBuffer(get(), transfer_buffer, cycle);
}

inline void UnmapGPUTransferBuffer(GPUDeviceRef device,
                                   GPUTransferBuffer transfer_buffer)
{
  SDL_UnmapGPUTransferBuffer(device, transfer_buffer);
}
 
inline void GPUDeviceBase::UnmapTransferBuffer(
  GPUTransferBuffer transfer_buffer)
{
  SDL::UnmapGPUTransferBuffer(get(), transfer_buffer);
}

inline GPUCopyPass BeginGPUCopyPass(GPUCommandBuffer command_buffer)
{
  return SDL_BeginGPUCopyPass(command_buffer);
}
 
inline GPUCopyPass GPUCommandBuffer::BeginCopyPass()
{
  return SDL::BeginGPUCopyPass(m_gPUCommandBuffer);
}

inline void UploadToGPUTexture(GPUCopyPass copy_pass,
                               const GPUTextureTransferInfo& source,
                               const GPUTextureRegion& destination,
                               bool cycle)
{
  SDL_UploadToGPUTexture(copy_pass, &source, &destination, cycle);
}
 
inline void GPUCopyPass::UploadToTexture(const GPUTextureTransferInfo& source,
                                         const GPUTextureRegion& destination,
                                         bool cycle)
{
  SDL::UploadToGPUTexture(m_gPUCopyPass, source, destination, cycle);
}

inline void UploadToGPUBuffer(GPUCopyPass copy_pass,
                              const GPUTransferBufferLocation& source,
                              const GPUBufferRegion& destination,
                              bool cycle)
{
  SDL_UploadToGPUBuffer(copy_pass, &source, &destination, cycle);
}
 
inline void GPUCopyPass::UploadToBuffer(const GPUTransferBufferLocation& source,
                                        const GPUBufferRegion& destination,
                                        bool cycle)
{
  SDL::UploadToGPUBuffer(m_gPUCopyPass, source, destination, cycle);
}

inline void CopyGPUTextureToTexture(GPUCopyPass copy_pass,
                                    const GPUTextureLocation& source,
                                    const GPUTextureLocation& destination,
                                    Uint32 w,
                                    Uint32 h,
                                    Uint32 d,
                                    bool cycle)
{
  SDL_CopyGPUTextureToTexture(copy_pass, &source, &destination, w, h, d, cycle);
}
 
inline void GPUCopyPass::CopyTextureToTexture(
  const GPUTextureLocation& source,
  const GPUTextureLocation& destination,
  Uint32 w,
  Uint32 h,
  Uint32 d,
  bool cycle)
{
  SDL::CopyGPUTextureToTexture(
    m_gPUCopyPass, source, destination, w, h, d, cycle);
}

inline void CopyGPUBufferToBuffer(GPUCopyPass copy_pass,
                                  const GPUBufferLocation& source,
                                  const GPUBufferLocation& destination,
                                  Uint32 size,
                                  bool cycle)
{
  SDL_CopyGPUBufferToBuffer(copy_pass, &source, &destination, size, cycle);
}
 
inline void GPUCopyPass::CopyBufferToBuffer(
  const GPUBufferLocation& source,
  const GPUBufferLocation& destination,
  Uint32 size,
  bool cycle)
{
  SDL::CopyGPUBufferToBuffer(m_gPUCopyPass, source, destination, size, cycle);
}

inline void DownloadFromGPUTexture(GPUCopyPass copy_pass,
                                   const GPUTextureRegion& source,
                                   const GPUTextureTransferInfo& destination)
{
  SDL_DownloadFromGPUTexture(copy_pass, &source, &destination);
}
 
inline void GPUCopyPass::DownloadFromTexture(
  const GPUTextureRegion& source,
  const GPUTextureTransferInfo& destination)
{
  SDL::DownloadFromGPUTexture(m_gPUCopyPass, source, destination);
}

inline void DownloadFromGPUBuffer(GPUCopyPass copy_pass,
                                  const GPUBufferRegion& source,
                                  const GPUTransferBufferLocation& destination)
{
  SDL_DownloadFromGPUBuffer(copy_pass, &source, &destination);
}
 
inline void GPUCopyPass::DownloadFromBuffer(
  const GPUBufferRegion& source,
  const GPUTransferBufferLocation& destination)
{
  SDL::DownloadFromGPUBuffer(m_gPUCopyPass, source, destination);
}

inline void EndGPUCopyPass(GPUCopyPass copy_pass)
{
  SDL_EndGPUCopyPass(copy_pass);
}
 
inline void GPUCopyPass::End() { SDL::EndGPUCopyPass(m_gPUCopyPass); }

inline void GenerateMipmapsForGPUTexture(GPUCommandBuffer command_buffer,
                                         GPUTexture texture)
{
  SDL_GenerateMipmapsForGPUTexture(command_buffer, texture);
}
 
inline void GPUCommandBuffer::GenerateMipmapsForTexture(GPUTexture texture)
{
  SDL::GenerateMipmapsForGPUTexture(m_gPUCommandBuffer, texture);
}

inline void BlitGPUTexture(GPUCommandBuffer command_buffer,
                           const GPUBlitInfo& info)
{
  SDL_BlitGPUTexture(command_buffer, &info);
}
 
inline void GPUCommandBuffer::BlitTexture(const GPUBlitInfo& info)
{
  SDL::BlitGPUTexture(m_gPUCommandBuffer, info);
}

inline bool WindowSupportsGPUSwapchainComposition(
  GPUDeviceRef device,
  WindowRef window,
  GPUSwapchainComposition swapchain_composition)
{
  return SDL_WindowSupportsGPUSwapchainComposition(
    device, window, swapchain_composition);
}
 
inline bool GPUDeviceBase::WindowSupportsSwapchainComposition(
  WindowRef window,
  GPUSwapchainComposition swapchain_composition)
{
  return SDL::WindowSupportsGPUSwapchainComposition(
    get(), window, swapchain_composition);
}

inline bool WindowSupportsGPUPresentMode(GPUDeviceRef device,
                                         WindowRef window,
                                         GPUPresentMode present_mode)
{
  return SDL_WindowSupportsGPUPresentMode(device, window, present_mode);
}
 
inline bool GPUDeviceBase::WindowSupportsPresentMode(
  WindowRef window,
  GPUPresentMode present_mode)
{
  return SDL::WindowSupportsGPUPresentMode(get(), window, present_mode);
}

inline void ClaimWindowForGPUDevice(GPUDeviceRef device, WindowRef window)
{
  CheckError(SDL_ClaimWindowForGPUDevice(device, window));
}
 
inline void GPUDeviceBase::ClaimWindow(WindowRef window)
{
  SDL::ClaimWindowForGPUDevice(get(), window);
}

inline void ReleaseWindowFromGPUDevice(GPUDeviceRef device, WindowRef window)
{
  SDL_ReleaseWindowFromGPUDevice(device, window);
}
 
inline void GPUDeviceBase::ReleaseWindow(WindowRef window)
{
  SDL::ReleaseWindowFromGPUDevice(get(), window);
}

inline bool SetGPUSwapchainParameters(
  GPUDeviceRef device,
  WindowRef window,
  GPUSwapchainComposition swapchain_composition,
  GPUPresentMode present_mode)
{
  return SDL_SetGPUSwapchainParameters(
    device, window, swapchain_composition, present_mode);
}
 
inline bool GPUDeviceBase::SetSwapchainParameters(
  WindowRef window,
  GPUSwapchainComposition swapchain_composition,
  GPUPresentMode present_mode)
{
  return SDL::SetGPUSwapchainParameters(
    get(), window, swapchain_composition, present_mode);
}

inline bool SetGPUAllowedFramesInFlight(GPUDeviceRef device,
                                        Uint32 allowed_frames_in_flight)
{
  return SDL_SetGPUAllowedFramesInFlight(device, allowed_frames_in_flight);
}
 
inline bool GPUDeviceBase::SetAllowedFramesInFlight(
  Uint32 allowed_frames_in_flight)
{
  return SDL::SetGPUAllowedFramesInFlight(get(), allowed_frames_in_flight);
}

inline GPUTextureFormat GetGPUSwapchainTextureFormat(GPUDeviceRef device,
                                                     WindowRef window)
{
  return SDL_GetGPUSwapchainTextureFormat(device, window);
}
 
inline GPUTextureFormat GPUDeviceBase::GetSwapchainTextureFormat(
  WindowRef window)
{
  return SDL::GetGPUSwapchainTextureFormat(get(), window);
}

inline GPUTexture AcquireGPUSwapchainTexture(
  GPUCommandBuffer command_buffer,
  WindowRef window,
  Uint32* swapchain_texture_width = nullptr,
  Uint32* swapchain_texture_height = nullptr)
{
  GPUTextureRaw texture;
  CheckError(SDL_AcquireGPUSwapchainTexture(command_buffer,
                                            window,
                                            &texture,
                                            swapchain_texture_width,
                                            swapchain_texture_height));
  return texture;
}
 
inline GPUTexture GPUCommandBuffer::AcquireSwapchainTexture(
  WindowRef window,
  Uint32* swapchain_texture_width,
  Uint32* swapchain_texture_height)
{
  return SDL::AcquireGPUSwapchainTexture(m_gPUCommandBuffer,
                                         window,
                                         swapchain_texture_width,
                                         swapchain_texture_height);
}

inline void WaitForGPUSwapchain(GPUDeviceRef device, WindowRef window)
{
  CheckError(SDL_WaitForGPUSwapchain(device, window));
}
 
inline void GPUDeviceBase::WaitForSwapchain(WindowRef window)
{
  SDL::WaitForGPUSwapchain(get(), window);
}

inline GPUTexture WaitAndAcquireGPUSwapchainTexture(
  GPUCommandBuffer command_buffer,
  WindowRef window,
  Uint32* swapchain_texture_width = nullptr,
  Uint32* swapchain_texture_height = nullptr)
{
  GPUTextureRaw texture;
  CheckError(SDL_WaitAndAcquireGPUSwapchainTexture(command_buffer,
                                                   window,
                                                   &texture,
                                                   swapchain_texture_width,
                                                   swapchain_texture_height));
  return texture;
}
 
inline GPUTexture GPUCommandBuffer::WaitAndAcquireSwapchainTexture(
  WindowRef window,
  Uint32* swapchain_texture_width,
  Uint32* swapchain_texture_height)
{
  return SDL::WaitAndAcquireGPUSwapchainTexture(m_gPUCommandBuffer,
                                                window,
                                                swapchain_texture_width,
                                                swapchain_texture_height);
}

inline void SubmitGPUCommandBuffer(GPUCommandBuffer command_buffer)
{
  CheckError(SDL_SubmitGPUCommandBuffer(command_buffer));
}
 
inline void GPUCommandBuffer::Submit()
{
  SDL::SubmitGPUCommandBuffer(m_gPUCommandBuffer);
}

inline GPUFence* SubmitGPUCommandBufferAndAcquireFence(
  GPUCommandBuffer command_buffer)
{
  return CheckError(SDL_SubmitGPUCommandBufferAndAcquireFence(command_buffer));
}
 
inline GPUFence* GPUCommandBuffer::SubmitAndAcquireFence()
{
  return SDL::SubmitGPUCommandBufferAndAcquireFence(m_gPUCommandBuffer);
}

inline void CancelGPUCommandBuffer(GPUCommandBuffer command_buffer)
{
  CheckError(SDL_CancelGPUCommandBuffer(command_buffer));
}
 
inline void GPUCommandBuffer::Cancel()
{
  SDL::CancelGPUCommandBuffer(m_gPUCommandBuffer);
}

inline void WaitForGPUIdle(GPUDeviceRef device)
{
  CheckError(SDL_WaitForGPUIdle(device));
}
 
inline void GPUDeviceBase::WaitForIdle() { SDL::WaitForGPUIdle(get()); }

inline void WaitForGPUFences(GPUDeviceRef device,
                             bool wait_all,
                             std::span<GPUFence* const> fences)
{
  CheckError(SDL_WaitForGPUFences(
    device, wait_all, fences.data(), narrowU32(fences.size())));
}
 
inline void GPUDeviceBase::WaitForFences(bool wait_all,
                                         std::span<GPUFence* const> fences)
{
  SDL::WaitForGPUFences(get(), wait_all, fences);
}

inline bool QueryGPUFence(GPUDeviceRef device, GPUFence* fence)
{
  return SDL_QueryGPUFence(device, fence);
}
 
inline bool GPUDeviceBase::QueryFence(GPUFence* fence)
{
  return SDL::QueryGPUFence(get(), fence);
}

inline void ReleaseGPUFence(GPUDeviceRef device, GPUFence* fence)
{
  SDL_ReleaseGPUFence(device, fence);
}
 
inline void GPUDeviceBase::ReleaseFence(GPUFence* fence)
{
  SDL::ReleaseGPUFence(get(), fence);
}

inline Uint32 GPUTextureFormatTexelBlockSize(GPUTextureFormat format)
{
  return SDL_GPUTextureFormatTexelBlockSize(format);
}

inline bool GPUTextureSupportsFormat(GPUDeviceRef device,
                                     GPUTextureFormat format,
                                     GPUTextureType type,
                                     GPUTextureUsageFlags usage)
{
  return SDL_GPUTextureSupportsFormat(device, format, type, usage);
}
 
inline bool GPUDeviceBase::TextureSupportsFormat(GPUTextureFormat format,
                                                 GPUTextureType type,
                                                 GPUTextureUsageFlags usage)
{
  return SDL::GPUTextureSupportsFormat(get(), format, type, usage);
}

inline bool GPUTextureSupportsSampleCount(GPUDeviceRef device,
                                          GPUTextureFormat format,
                                          GPUSampleCount sample_count)
{
  return SDL_GPUTextureSupportsSampleCount(device, format, sample_count);
}
 
inline bool GPUDeviceBase::TextureSupportsSampleCount(
  GPUTextureFormat format,
  GPUSampleCount sample_count)
{
  return SDL::GPUTextureSupportsSampleCount(get(), format, sample_count);
}

inline Uint32 CalculateGPUTextureFormatSize(GPUTextureFormat format,
                                            Uint32 width,
                                            Uint32 height,
                                            Uint32 depth_or_layer_count)
{
  return SDL_CalculateGPUTextureFormatSize(
    format, width, height, depth_or_layer_count);
}
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

inline PixelFormat GetPixelFormatFromGPUTextureFormat(GPUTextureFormat format)
{
  return SDL_GetPixelFormatFromGPUTextureFormat(format);
}

inline GPUTextureFormat GetGPUTextureFormatFromPixelFormat(PixelFormat format)
{
  return SDL_GetGPUTextureFormatFromPixelFormat(format);
}
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
#ifdef SDL_PLATFORM_GDK

inline void GDKSuspendGPU(GPUDeviceRef device) { SDL_GDKSuspendGPU(device); }
 
inline void GPUDeviceBase::GDKSuspendGPU() { SDL::GDKSuspendGPU(get()); }

inline void GDKResumeGPU(GPUDeviceRef device) { SDL_GDKResumeGPU(device); }
 
inline void GPUDeviceBase::GDKResumeGPU() { SDL::GDKResumeGPU(get()); }
 
#endif /* SDL_PLATFORM_GDK */

 
} // namespace SDL
 
#endif /* SDL3PP_GPU_H_ */