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 GPUDevice;
 
using GPUDeviceRaw = SDL_GPUDevice*;
 
// Forward decl
struct GPUDeviceRef;
 
struct GPUDeviceParam
{
  GPUDeviceRaw value; 
 
  constexpr GPUDeviceParam(GPUDeviceRaw value)
    : value(value)
  {
  }
 
  constexpr GPUDeviceParam(std::nullptr_t _ = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const GPUDeviceParam& other) const = default;
 
  constexpr operator GPUDeviceRaw() const { return value; }
};
 
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 = {})
    : m_gPUBuffer(gPUBuffer)
  {
  }
 
  GPUBuffer(GPUDeviceParam device, const GPUBufferCreateInfo& createinfo)
    : m_gPUBuffer(CheckError(SDL_CreateGPUBuffer(device, &createinfo)))
  {
  }
 
  constexpr operator GPUBufferRaw() const { return m_gPUBuffer; }
};
 
using GPUTransferBufferCreateInfo = SDL_GPUTransferBufferCreateInfo;
 
class GPUTransferBuffer
{
  GPUTransferBufferRaw m_gPUTransferBuffer;
 
public:
  constexpr GPUTransferBuffer(GPUTransferBufferRaw gPUTransferBuffer = {})
    : m_gPUTransferBuffer(gPUTransferBuffer)
  {
  }
 
  GPUTransferBuffer(GPUDeviceParam device,
                    const GPUTransferBufferCreateInfo& createinfo)
    : m_gPUTransferBuffer(
        CheckError(SDL_CreateGPUTransferBuffer(device, &createinfo)))
  {
  }
 
  constexpr operator GPUTransferBufferRaw() const
  {
    return m_gPUTransferBuffer;
  }
};
 
using GPUTextureCreateInfo = SDL_GPUTextureCreateInfo;
 
class GPUTexture
{
  GPUTextureRaw m_gPUTexture;
 
public:
  constexpr GPUTexture(GPUTextureRaw gPUTexture = {})
    : m_gPUTexture(gPUTexture)
  {
  }
 
  GPUTexture(GPUDeviceParam device, const GPUTextureCreateInfo& createinfo)
    : m_gPUTexture(CheckError(SDL_CreateGPUTexture(device, &createinfo)))
  {
  }
 
  constexpr operator GPUTextureRaw() const { return m_gPUTexture; }
};
 
using GPUSamplerCreateInfo = SDL_GPUSamplerCreateInfo;
 
class GPUSampler
{
  GPUSamplerRaw m_gPUSampler;
 
public:
  constexpr GPUSampler(GPUSamplerRaw gPUSampler = {})
    : m_gPUSampler(gPUSampler)
  {
  }
 
  GPUSampler(GPUDeviceParam device, const GPUSamplerCreateInfo& createinfo)
    : m_gPUSampler(CheckError(SDL_CreateGPUSampler(device, &createinfo)))
  {
  }
 
  constexpr operator GPUSamplerRaw() const { return m_gPUSampler; }
};
 
using GPUShaderCreateInfo = SDL_GPUShaderCreateInfo;
 
class GPUShader
{
  GPUShaderRaw m_gPUShader;
 
public:
  constexpr GPUShader(GPUShaderRaw gPUShader = {})
    : m_gPUShader(gPUShader)
  {
  }
 
  GPUShader(GPUDeviceParam device, const GPUShaderCreateInfo& createinfo)
    : m_gPUShader(CheckError(SDL_CreateGPUShader(device, &createinfo)))
  {
  }
 
  constexpr operator GPUShaderRaw() const { return m_gPUShader; }
};
 
using GPUComputePipelineCreateInfo = SDL_GPUComputePipelineCreateInfo;
 
class GPUComputePipeline
{
  GPUComputePipelineRaw m_gPUComputePipeline;
 
public:
  constexpr GPUComputePipeline(GPUComputePipelineRaw gPUComputePipeline = {})
    : m_gPUComputePipeline(gPUComputePipeline)
  {
  }
 
  GPUComputePipeline(GPUDeviceParam device,
                     const GPUComputePipelineCreateInfo& createinfo)
    : m_gPUComputePipeline(
        CheckError(SDL_CreateGPUComputePipeline(device, &createinfo)))
  {
  }
 
  constexpr operator GPUComputePipelineRaw() const
  {
    return m_gPUComputePipeline;
  }
};
 
using GPUGraphicsPipelineCreateInfo = SDL_GPUGraphicsPipelineCreateInfo;
 
class GPUGraphicsPipeline
{
  GPUGraphicsPipelineRaw m_gPUGraphicsPipeline;
 
public:
  constexpr GPUGraphicsPipeline(GPUGraphicsPipelineRaw gPUGraphicsPipeline = {})
    : m_gPUGraphicsPipeline(gPUGraphicsPipeline)
  {
  }
 
  GPUGraphicsPipeline(GPUDeviceParam device,
                      const GPUGraphicsPipelineCreateInfo& createinfo)
    : m_gPUGraphicsPipeline(
        CheckError(SDL_CreateGPUGraphicsPipeline(device, &createinfo)))
  {
  }
 
  constexpr operator GPUGraphicsPipelineRaw() const
  {
    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 = {})
    : m_gPURenderPass(gPURenderPass)
  {
  }
 
  constexpr operator GPURenderPassRaw() const { 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 = {})
    : m_gPUComputePass(gPUComputePass)
  {
  }
 
  constexpr operator GPUComputePassRaw() const { 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 = {})
    : m_gPUCopyPass(gPUCopyPass)
  {
  }
 
  constexpr operator GPUCopyPassRaw() const { 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 = {})
    : m_gPUCommandBuffer(gPUCommandBuffer)
  {
  }
 
  constexpr operator GPUCommandBufferRaw() const { 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(
    WindowParam window,
    Uint32* swapchain_texture_width = nullptr,
    Uint32* swapchain_texture_height = nullptr);
 
  GPUTexture WaitAndAcquireSwapchainTexture(
    WindowParam 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; 
 
class GPUDevice
{
  GPUDeviceRaw m_resource = nullptr;
 
public:
  constexpr GPUDevice() = default;
 
  constexpr explicit GPUDevice(const GPUDeviceRaw resource)
    : m_resource(resource)
  {
  }
 
  constexpr GPUDevice(const GPUDevice& other) = delete;
 
  constexpr GPUDevice(GPUDevice&& other)
    : GPUDevice(other.release())
  {
  }
 
  constexpr GPUDevice(const GPUDeviceRef& other) = delete;
 
  constexpr GPUDevice(GPUDeviceRef&& other) = delete;
 
  GPUDevice(GPUShaderFormat format_flags, bool debug_mode, StringParam name)
    : m_resource(
        CheckError(SDL_CreateGPUDevice(format_flags, debug_mode, name)))
  {
  }
 
  GPUDevice(PropertiesParam props)
    : m_resource(CheckError(SDL_CreateGPUDeviceWithProperties(props)))
  {
  }
 
  ~GPUDevice() { SDL_DestroyGPUDevice(m_resource); }
 
  GPUDevice& operator=(GPUDevice other)
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
  constexpr GPUDeviceRaw get() const { return m_resource; }
 
  constexpr GPUDeviceRaw release()
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const GPUDevice& other) const = default;
 
  constexpr bool operator==(std::nullptr_t _) const { return !m_resource; }
 
  constexpr explicit operator bool() const { return !!m_resource; }
 
  constexpr operator GPUDeviceParam() const { return {m_resource}; }
 
  void Destroy();
 
  const char* GetDriver();
 
  GPUShaderFormat GetShaderFormats();
 
  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(
    WindowParam window,
    GPUSwapchainComposition swapchain_composition);
 
  bool WindowSupportsPresentMode(WindowParam window,
                                 GPUPresentMode present_mode);
 
  void ClaimWindow(WindowParam window);
 
  void ReleaseWindow(WindowParam window);
 
  bool SetSwapchainParameters(WindowParam window,
                              GPUSwapchainComposition swapchain_composition,
                              GPUPresentMode present_mode);
 
  bool SetAllowedFramesInFlight(Uint32 allowed_frames_in_flight);
 
  GPUTextureFormat GetSwapchainTextureFormat(WindowParam window);
 
  void WaitForSwapchain(WindowParam 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 GPUDeviceRef : GPUDevice
{
  GPUDeviceRef(GPUDeviceParam resource)
    : GPUDevice(resource.value)
  {
  }
 
  GPUDeviceRef(const GPUDeviceRef& other)
    : GPUDevice(other.get())
  {
  }
 
  ~GPUDeviceRef() { release(); }
};
 
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(PropertiesParam 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 CreateGPUDeviceWithProperties(PropertiesParam props)
{
  return GPUDevice(props);
}
 
namespace prop::GpuDevice {
 
constexpr auto CREATE_DEBUGMODE_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_DEBUGMODE_BOOLEAN;
 
constexpr auto CREATE_PREFERLOWPOWER_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_PREFERLOWPOWER_BOOLEAN;
 
constexpr auto CREATE_NAME_STRING = SDL_PROP_GPU_DEVICE_CREATE_NAME_STRING;
 
constexpr auto CREATE_SHADERS_PRIVATE_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_PRIVATE_BOOLEAN;
 
constexpr auto CREATE_SHADERS_SPIRV_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_SPIRV_BOOLEAN;
 
constexpr auto CREATE_SHADERS_DXBC_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXBC_BOOLEAN;
 
constexpr auto CREATE_SHADERS_DXIL_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXIL_BOOLEAN;
 
constexpr auto CREATE_SHADERS_MSL_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_MSL_BOOLEAN;
 
constexpr auto CREATE_SHADERS_METALLIB_BOOLEAN =
  SDL_PROP_GPU_DEVICE_CREATE_SHADERS_METALLIB_BOOLEAN;
 
constexpr auto CREATE_D3D12_SEMANTIC_NAME_STRING =
  SDL_PROP_GPU_DEVICE_CREATE_D3D12_SEMANTIC_NAME_STRING;
 
} // namespace prop::GpuDevice
 
inline void DestroyGPUDevice(GPUDeviceRaw device)
{
  SDL_DestroyGPUDevice(device);
}
 
inline void GPUDevice::Destroy() { DestroyGPUDevice(release()); }
 
inline int GetNumGPUDrivers() { return SDL_GetNumGPUDrivers(); }
 
inline const char* GetGPUDriver(int index) { return SDL_GetGPUDriver(index); }
 
inline const char* GetGPUDeviceDriver(GPUDeviceParam device)
{
  return SDL_GetGPUDeviceDriver(device);
}
 
inline const char* GPUDevice::GetDriver()
{
  return SDL::GetGPUDeviceDriver(m_resource);
}
 
inline GPUShaderFormat GetGPUShaderFormats(GPUDeviceParam device)
{
  return SDL_GetGPUShaderFormats(device);
}
 
inline GPUShaderFormat GPUDevice::GetShaderFormats()
{
  return SDL::GetGPUShaderFormats(m_resource);
}
 
inline GPUComputePipeline CreateGPUComputePipeline(
  GPUDeviceParam device,
  const GPUComputePipelineCreateInfo& createinfo)
{
  return GPUComputePipeline(device, createinfo);
}
 
inline GPUComputePipeline GPUDevice::CreateComputePipeline(
  const GPUComputePipelineCreateInfo& createinfo)
{
  return GPUComputePipeline(m_resource, createinfo);
}
 
namespace prop::GPUComputePipeline {
 
constexpr auto CREATE_NAME_STRING =
  SDL_PROP_GPU_COMPUTEPIPELINE_CREATE_NAME_STRING;
 
} // namespace prop::GPUComputePipeline
 
inline GPUGraphicsPipeline CreateGPUGraphicsPipeline(
  GPUDeviceParam device,
  const GPUGraphicsPipelineCreateInfo& createinfo)
{
  return GPUGraphicsPipeline(device, createinfo);
}
 
inline GPUGraphicsPipeline GPUDevice::CreateGraphicsPipeline(
  const GPUGraphicsPipelineCreateInfo& createinfo)
{
  return GPUGraphicsPipeline(m_resource, createinfo);
}
 
namespace prop::GPUGraphicsPipeline {
 
constexpr auto CREATE_NAME_STRING =
  SDL_PROP_GPU_GRAPHICSPIPELINE_CREATE_NAME_STRING;
 
} // namespace prop::GPUGraphicsPipeline
 
inline GPUSampler CreateGPUSampler(GPUDeviceParam device,
                                   const GPUSamplerCreateInfo& createinfo)
{
  return GPUSampler(device, createinfo);
}
 
inline GPUSampler GPUDevice::CreateSampler(
  const GPUSamplerCreateInfo& createinfo)
{
  return GPUSampler(m_resource, createinfo);
}
 
namespace prop::GPUSampler {
 
constexpr auto CREATE_NAME_STRING = SDL_PROP_GPU_SAMPLER_CREATE_NAME_STRING;
 
} // namespace prop::GPUSampler
 
inline GPUShader CreateGPUShader(GPUDeviceParam device,
                                 const GPUShaderCreateInfo& createinfo)
{
  return GPUShader(device, createinfo);
}
 
inline GPUShader GPUDevice::CreateShader(const GPUShaderCreateInfo& createinfo)
{
  return GPUShader(m_resource, createinfo);
}
 
namespace prop::GPUShader {
 
constexpr auto CREATE_NAME_STRING = SDL_PROP_GPU_SHADER_CREATE_NAME_STRING;
 
} // namespace prop::GPUShader
 
inline GPUTexture CreateGPUTexture(GPUDeviceParam device,
                                   const GPUTextureCreateInfo& createinfo)
{
  return GPUTexture(device, createinfo);
}
 
inline GPUTexture GPUDevice::CreateTexture(
  const GPUTextureCreateInfo& createinfo)
{
  return GPUTexture(m_resource, createinfo);
}
 
namespace prop::GPUTexture {
 
constexpr auto CREATE_D3D12_CLEAR_R_FLOAT =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_R_FLOAT;
 
constexpr auto CREATE_D3D12_CLEAR_G_FLOAT =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_G_FLOAT;
 
constexpr auto CREATE_D3D12_CLEAR_B_FLOAT =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_B_FLOAT;
 
constexpr auto CREATE_D3D12_CLEAR_A_FLOAT =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_A_FLOAT;
 
constexpr auto CREATE_D3D12_CLEAR_DEPTH_FLOAT =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_DEPTH_FLOAT;
 
#if SDL_VERSION_ATLEAST(3, 2, 12)
 
constexpr auto CREATE_D3D12_CLEAR_STENCIL_NUMBER =
  SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_STENCIL_NUMBER;
 
#endif // SDL_VERSION_ATLEAST(3, 2, 12)
 
constexpr auto CREATE_NAME_STRING = SDL_PROP_GPU_TEXTURE_CREATE_NAME_STRING;
 
} // namespace prop::GPUTexture
 
inline GPUBuffer CreateGPUBuffer(GPUDeviceParam device,
                                 const GPUBufferCreateInfo& createinfo)
{
  return GPUBuffer(device, createinfo);
}
 
inline GPUBuffer GPUDevice::CreateBuffer(const GPUBufferCreateInfo& createinfo)
{
  return GPUBuffer(m_resource, createinfo);
}
 
namespace prop::GPUBuffer {
 
constexpr auto CREATE_NAME_STRING = SDL_PROP_GPU_BUFFER_CREATE_NAME_STRING;
 
} // namespace prop::GPUBuffer
 
inline GPUTransferBuffer CreateGPUTransferBuffer(
  GPUDeviceParam device,
  const GPUTransferBufferCreateInfo& createinfo)
{
  return GPUTransferBuffer(device, createinfo);
}
 
inline GPUTransferBuffer GPUDevice::CreateTransferBuffer(
  const GPUTransferBufferCreateInfo& createinfo)
{
  return GPUTransferBuffer(m_resource, createinfo);
}
 
namespace prop::GPUTransferBuffer {
 
constexpr auto CREATE_NAME_STRING =
  SDL_PROP_GPU_TRANSFERBUFFER_CREATE_NAME_STRING;
 
} // namespace prop::GPUTransferBuffer
 
inline void SetGPUBufferName(GPUDeviceParam device,
                             GPUBuffer buffer,
                             StringParam text)
{
  SDL_SetGPUBufferName(device, buffer, text);
}
 
inline void GPUDevice::SetBufferName(GPUBuffer buffer, StringParam text)
{
  SDL::SetGPUBufferName(m_resource, buffer, std::move(text));
}
 
inline void SetGPUTextureName(GPUDeviceParam device,
                              GPUTexture texture,
                              StringParam text)
{
  SDL_SetGPUTextureName(device, texture, text);
}
 
inline void GPUDevice::SetTextureName(GPUTexture texture, StringParam text)
{
  SDL::SetGPUTextureName(m_resource, 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(GPUDeviceParam device, GPUTexture texture)
{
  SDL_ReleaseGPUTexture(device, texture);
}
 
inline void GPUDevice::ReleaseTexture(GPUTexture texture)
{
  SDL::ReleaseGPUTexture(m_resource, texture);
}
 
inline void ReleaseGPUSampler(GPUDeviceParam device, GPUSampler sampler)
{
  SDL_ReleaseGPUSampler(device, sampler);
}
 
inline void GPUDevice::ReleaseSampler(GPUSampler sampler)
{
  SDL::ReleaseGPUSampler(m_resource, sampler);
}
 
inline void ReleaseGPUBuffer(GPUDeviceParam device, GPUBuffer buffer)
{
  SDL_ReleaseGPUBuffer(device, buffer);
}
 
inline void GPUDevice::ReleaseBuffer(GPUBuffer buffer)
{
  SDL::ReleaseGPUBuffer(m_resource, buffer);
}
 
inline void ReleaseGPUTransferBuffer(GPUDeviceParam device,
                                     GPUTransferBuffer transfer_buffer)
{
  SDL_ReleaseGPUTransferBuffer(device, transfer_buffer);
}
 
inline void GPUDevice::ReleaseTransferBuffer(GPUTransferBuffer transfer_buffer)
{
  SDL::ReleaseGPUTransferBuffer(m_resource, transfer_buffer);
}
 
inline void ReleaseGPUComputePipeline(GPUDeviceParam device,
                                      GPUComputePipeline compute_pipeline)
{
  SDL_ReleaseGPUComputePipeline(device, compute_pipeline);
}
 
inline void GPUDevice::ReleaseComputePipeline(
  GPUComputePipeline compute_pipeline)
{
  SDL::ReleaseGPUComputePipeline(m_resource, compute_pipeline);
}
 
inline void ReleaseGPUShader(GPUDeviceParam device, GPUShader shader)
{
  SDL_ReleaseGPUShader(device, shader);
}
 
inline void GPUDevice::ReleaseShader(GPUShader shader)
{
  SDL::ReleaseGPUShader(m_resource, shader);
}
 
inline void ReleaseGPUGraphicsPipeline(GPUDeviceParam device,
                                       GPUGraphicsPipeline graphics_pipeline)
{
  SDL_ReleaseGPUGraphicsPipeline(device, graphics_pipeline);
}
 
inline void GPUDevice::ReleaseGraphicsPipeline(
  GPUGraphicsPipeline graphics_pipeline)
{
  SDL::ReleaseGPUGraphicsPipeline(m_resource, graphics_pipeline);
}
 
inline GPUCommandBuffer AcquireGPUCommandBuffer(GPUDeviceParam device)
{
  return SDL_AcquireGPUCommandBuffer(device);
}
 
inline GPUCommandBuffer GPUDevice::AcquireCommandBuffer()
{
  return SDL::AcquireGPUCommandBuffer(m_resource);
}
 
inline void PushGPUVertexUniformData(GPUCommandBuffer command_buffer,
                                     Uint32 slot_index,
                                     SourceBytes data)
{
  SDL_PushGPUVertexUniformData(
    command_buffer, slot_index, data.data(), 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(), 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(), 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(),
                                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(), 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(),
                            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(), 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(), 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(),
                              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(), 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(), 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(),
                                 storage_texture_bindings.size(),
                                 storage_buffer_bindings.data(),
                                 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(),
                             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(), 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(), 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(GPUDeviceParam device,
                                  GPUTransferBuffer transfer_buffer,
                                  bool cycle)
{
  return SDL_MapGPUTransferBuffer(device, transfer_buffer, cycle);
}
 
inline void* GPUDevice::MapTransferBuffer(GPUTransferBuffer transfer_buffer,
                                          bool cycle)
{
  return SDL::MapGPUTransferBuffer(m_resource, transfer_buffer, cycle);
}
 
inline void UnmapGPUTransferBuffer(GPUDeviceParam device,
                                   GPUTransferBuffer transfer_buffer)
{
  SDL_UnmapGPUTransferBuffer(device, transfer_buffer);
}
 
inline void GPUDevice::UnmapTransferBuffer(GPUTransferBuffer transfer_buffer)
{
  SDL::UnmapGPUTransferBuffer(m_resource, 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(
  GPUDeviceParam device,
  WindowParam window,
  GPUSwapchainComposition swapchain_composition)
{
  return SDL_WindowSupportsGPUSwapchainComposition(
    device, window, swapchain_composition);
}
 
inline bool GPUDevice::WindowSupportsSwapchainComposition(
  WindowParam window,
  GPUSwapchainComposition swapchain_composition)
{
  return SDL::WindowSupportsGPUSwapchainComposition(
    m_resource, window, swapchain_composition);
}
 
inline bool WindowSupportsGPUPresentMode(GPUDeviceParam device,
                                         WindowParam window,
                                         GPUPresentMode present_mode)
{
  return SDL_WindowSupportsGPUPresentMode(device, window, present_mode);
}
 
inline bool GPUDevice::WindowSupportsPresentMode(WindowParam window,
                                                 GPUPresentMode present_mode)
{
  return SDL::WindowSupportsGPUPresentMode(m_resource, window, present_mode);
}
 
inline void ClaimWindowForGPUDevice(GPUDeviceParam device, WindowParam window)
{
  CheckError(SDL_ClaimWindowForGPUDevice(device, window));
}
 
inline void GPUDevice::ClaimWindow(WindowParam window)
{
  SDL::ClaimWindowForGPUDevice(m_resource, window);
}
 
inline void ReleaseWindowFromGPUDevice(GPUDeviceParam device,
                                       WindowParam window)
{
  SDL_ReleaseWindowFromGPUDevice(device, window);
}
 
inline void GPUDevice::ReleaseWindow(WindowParam window)
{
  SDL::ReleaseWindowFromGPUDevice(m_resource, window);
}
 
inline bool SetGPUSwapchainParameters(
  GPUDeviceParam device,
  WindowParam window,
  GPUSwapchainComposition swapchain_composition,
  GPUPresentMode present_mode)
{
  return SDL_SetGPUSwapchainParameters(
    device, window, swapchain_composition, present_mode);
}
 
inline bool GPUDevice::SetSwapchainParameters(
  WindowParam window,
  GPUSwapchainComposition swapchain_composition,
  GPUPresentMode present_mode)
{
  return SDL::SetGPUSwapchainParameters(
    m_resource, window, swapchain_composition, present_mode);
}
 
inline bool SetGPUAllowedFramesInFlight(GPUDeviceParam device,
                                        Uint32 allowed_frames_in_flight)
{
  return SDL_SetGPUAllowedFramesInFlight(device, allowed_frames_in_flight);
}
 
inline bool GPUDevice::SetAllowedFramesInFlight(Uint32 allowed_frames_in_flight)
{
  return SDL::SetGPUAllowedFramesInFlight(m_resource, allowed_frames_in_flight);
}
 
inline GPUTextureFormat GetGPUSwapchainTextureFormat(GPUDeviceParam device,
                                                     WindowParam window)
{
  return SDL_GetGPUSwapchainTextureFormat(device, window);
}
 
inline GPUTextureFormat GPUDevice::GetSwapchainTextureFormat(WindowParam window)
{
  return SDL::GetGPUSwapchainTextureFormat(m_resource, window);
}
 
inline GPUTexture AcquireGPUSwapchainTexture(
  GPUCommandBuffer command_buffer,
  WindowParam 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(
  WindowParam window,
  Uint32* swapchain_texture_width,
  Uint32* swapchain_texture_height)
{
  return SDL::AcquireGPUSwapchainTexture(m_gPUCommandBuffer,
                                         window,
                                         swapchain_texture_width,
                                         swapchain_texture_height);
}
 
inline void WaitForGPUSwapchain(GPUDeviceParam device, WindowParam window)
{
  CheckError(SDL_WaitForGPUSwapchain(device, window));
}
 
inline void GPUDevice::WaitForSwapchain(WindowParam window)
{
  SDL::WaitForGPUSwapchain(m_resource, window);
}
 
inline GPUTexture WaitAndAcquireGPUSwapchainTexture(
  GPUCommandBuffer command_buffer,
  WindowParam 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(
  WindowParam 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 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(GPUDeviceParam device)
{
  CheckError(SDL_WaitForGPUIdle(device));
}
 
inline void GPUDevice::WaitForIdle() { SDL::WaitForGPUIdle(m_resource); }
 
inline void WaitForGPUFences(GPUDeviceParam device,
                             bool wait_all,
                             std::span<GPUFence* const> fences)
{
  CheckError(
    SDL_WaitForGPUFences(device, wait_all, fences.data(), fences.size()));
}
 
inline void GPUDevice::WaitForFences(bool wait_all,
                                     std::span<GPUFence* const> fences)
{
  SDL::WaitForGPUFences(m_resource, wait_all, fences);
}
 
inline bool QueryGPUFence(GPUDeviceParam device, GPUFence* fence)
{
  return SDL_QueryGPUFence(device, fence);
}
 
inline bool GPUDevice::QueryFence(GPUFence* fence)
{
  return SDL::QueryGPUFence(m_resource, fence);
}
 
inline void ReleaseGPUFence(GPUDeviceParam device, GPUFence* fence)
{
  SDL_ReleaseGPUFence(device, fence);
}
 
inline void GPUDevice::ReleaseFence(GPUFence* fence)
{
  SDL::ReleaseGPUFence(m_resource, fence);
}
 
inline Uint32 GPUTextureFormatTexelBlockSize(GPUTextureFormat format)
{
  return SDL_GPUTextureFormatTexelBlockSize(format);
}
 
inline bool GPUTextureSupportsFormat(GPUDeviceParam device,
                                     GPUTextureFormat format,
                                     GPUTextureType type,
                                     GPUTextureUsageFlags usage)
{
  return SDL_GPUTextureSupportsFormat(device, format, type, usage);
}
 
inline bool GPUDevice::TextureSupportsFormat(GPUTextureFormat format,
                                             GPUTextureType type,
                                             GPUTextureUsageFlags usage)
{
  return SDL::GPUTextureSupportsFormat(m_resource, format, type, usage);
}
 
inline bool GPUTextureSupportsSampleCount(GPUDeviceParam device,
                                          GPUTextureFormat format,
                                          GPUSampleCount sample_count)
{
  return SDL_GPUTextureSupportsSampleCount(device, format, sample_count);
}
 
inline bool GPUDevice::TextureSupportsSampleCount(GPUTextureFormat format,
                                                  GPUSampleCount sample_count)
{
  return SDL::GPUTextureSupportsSampleCount(m_resource, 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);
}
 
#ifdef SDL_PLATFORM_GDK
 
inline void GDKSuspendGPU(GPUDeviceParam device) { SDL_GDKSuspendGPU(device); }
 
inline void GPUDevice::GDKSuspendGPU() { SDL::GDKSuspendGPU(m_resource); }
 
inline void GDKResumeGPU(GPUDeviceParam device) { SDL_GDKResumeGPU(device); }
 
inline void GPUDevice::GDKResumeGPU() { SDL::GDKResumeGPU(m_resource); }
 
#endif /* SDL_PLATFORM_GDK */
 
 
} // namespace SDL
 
#endif /* SDL3PP_GPU_H_ */