package sdl3 import "core:c" GPUDevice :: struct {} GPUBuffer :: struct {} GPUTransferBuffer :: struct {} GPUTexture :: struct {} GPUSampler :: struct {} GPUShader :: struct {} GPUComputePipeline :: struct {} GPUGraphicsPipeline :: struct {} GPUCommandBuffer :: struct {} GPURenderPass :: struct {} GPUComputePass :: struct {} GPUCopyPass :: struct {} GPUFence :: struct {} GPUPrimitiveType :: enum c.int { TRIANGLELIST, /**< A series of separate triangles. */ TRIANGLESTRIP, /**< A series of connected triangles. */ LINELIST, /**< A series of separate lines. */ LINESTRIP, /**< A series of connected lines. */ POINTLIST, /**< A series of separate points. */ } GPULoadOp :: enum c.int { LOAD, /**< The previous contents of the texture will be preserved. */ CLEAR, /**< The contents of the texture will be cleared to a color. */ DONT_CARE, /**< The previous contents of the texture need not be preserved. The contents will be undefined. */ } GPUStoreOp :: enum c.int { STORE, /**< The contents generated during the render pass will be written to memory. */ DONT_CARE, /**< The contents generated during the render pass are not needed and may be discarded. The contents will be undefined. */ RESOLVE, /**< The multisample contents generated during the render pass will be resolved to a non-multisample texture. The contents in the multisample texture may then be discarded and will be undefined. */ RESOLVE_AND_STORE, /**< The multisample contents generated during the render pass will be resolved to a non-multisample texture. The contents in the multisample texture will be written to memory. */ } GPUIndexElementSize :: enum c.int { _16BIT, /**< The index elements are 16-bit. */ _32BIT, /**< The index elements are 32-bit. */ } GPUTextureFormat :: enum c.int { INVALID, /* Unsigned Normalized Float Color Formats */ A8_UNORM, R8_UNORM, R8G8_UNORM, R8G8B8A8_UNORM, R16_UNORM, R16G16_UNORM, R16G16B16A16_UNORM, R10G10B10A2_UNORM, B5G6R5_UNORM, B5G5R5A1_UNORM, B4G4R4A4_UNORM, B8G8R8A8_UNORM, /* Compressed Unsigned Normalized Float Color Formats */ BC1_RGBA_UNORM, BC2_RGBA_UNORM, BC3_RGBA_UNORM, BC4_R_UNORM, BC5_RG_UNORM, BC7_RGBA_UNORM, /* Compressed Signed Float Color Formats */ BC6H_RGB_FLOAT, /* Compressed Unsigned Float Color Formats */ BC6H_RGB_UFLOAT, /* Signed Normalized Float Color Formats */ R8_SNORM, R8G8_SNORM, R8G8B8A8_SNORM, R16_SNORM, R16G16_SNORM, R16G16B16A16_SNORM, /* Signed Float Color Formats */ R16_FLOAT, R16G16_FLOAT, R16G16B16A16_FLOAT, R32_FLOAT, R32G32_FLOAT, R32G32B32A32_FLOAT, /* Unsigned Float Color Formats */ R11G11B10_UFLOAT, /* Unsigned Integer Color Formats */ R8_UINT, R8G8_UINT, R8G8B8A8_UINT, R16_UINT, R16G16_UINT, R16G16B16A16_UINT, R32_UINT, R32G32_UINT, R32G32B32A32_UINT, /* Signed Integer Color Formats */ R8_INT, R8G8_INT, R8G8B8A8_INT, R16_INT, R16G16_INT, R16G16B16A16_INT, R32_INT, R32G32_INT, R32G32B32A32_INT, /* SRGB Unsigned Normalized Color Formats */ R8G8B8A8_UNORM_SRGB, B8G8R8A8_UNORM_SRGB, /* Compressed SRGB Unsigned Normalized Color Formats */ BC1_RGBA_UNORM_SRGB, BC2_RGBA_UNORM_SRGB, BC3_RGBA_UNORM_SRGB, BC7_RGBA_UNORM_SRGB, /* Depth Formats */ D16_UNORM, D24_UNORM, D32_FLOAT, D24_UNORM_S8_UINT, D32_FLOAT_S8_UINT, /* Compressed ASTC Normalized Float Color Formats*/ ASTC_4x4_UNORM, ASTC_5x4_UNORM, ASTC_5x5_UNORM, ASTC_6x5_UNORM, ASTC_6x6_UNORM, ASTC_8x5_UNORM, ASTC_8x6_UNORM, ASTC_8x8_UNORM, ASTC_10x5_UNORM, ASTC_10x6_UNORM, ASTC_10x8_UNORM, ASTC_10x10_UNORM, ASTC_12x10_UNORM, ASTC_12x12_UNORM, /* Compressed SRGB ASTC Normalized Float Color Formats*/ ASTC_4x4_UNORM_SRGB, ASTC_5x4_UNORM_SRGB, ASTC_5x5_UNORM_SRGB, ASTC_6x5_UNORM_SRGB, ASTC_6x6_UNORM_SRGB, ASTC_8x5_UNORM_SRGB, ASTC_8x6_UNORM_SRGB, ASTC_8x8_UNORM_SRGB, ASTC_10x5_UNORM_SRGB, ASTC_10x6_UNORM_SRGB, ASTC_10x8_UNORM_SRGB, ASTC_10x10_UNORM_SRGB, ASTC_12x10_UNORM_SRGB, ASTC_12x12_UNORM_SRGB, /* Compressed ASTC Signed Float Color Formats*/ ASTC_4x4_FLOAT, ASTC_5x4_FLOAT, ASTC_5x5_FLOAT, ASTC_6x5_FLOAT, ASTC_6x6_FLOAT, ASTC_8x5_FLOAT, ASTC_8x6_FLOAT, ASTC_8x8_FLOAT, ASTC_10x5_FLOAT, ASTC_10x6_FLOAT, ASTC_10x8_FLOAT, ASTC_10x10_FLOAT, ASTC_12x10_FLOAT, ASTC_12x12_FLOAT, } GPUTextureUsageFlags :: distinct bit_set[GPUTextureUsageFlag; Uint32] GPUTextureUsageFlag :: enum Uint32 { SAMPLER = 0, /**< Texture supports sampling. */ COLOR_TARGET = 1, /**< Texture is a color render target. */ DEPTH_STENCIL_TARGET = 2, /**< Texture is a depth stencil target. */ GRAPHICS_STORAGE_READ = 3, /**< Texture supports storage reads in graphics stages. */ COMPUTE_STORAGE_READ = 4, /**< Texture supports storage reads in the compute stage. */ COMPUTE_STORAGE_WRITE = 5, /**< Texture supports storage writes in the compute stage. */ COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE = 6, /**< Texture supports reads and writes in the same compute shader. This is NOT equivalent to READ | WRITE. */ } GPUTextureType :: enum c.int { D2, /**< The texture is a 2-dimensional image. */ D2_ARRAY, /**< The texture is a 2-dimensional array image. */ D3, /**< The texture is a 3-dimensional image. */ CUBE, /**< The texture is a cube image. */ CUBE_ARRAY, /**< The texture is a cube array image. */ } GPUSampleCount :: enum c.int { _1, /**< No multisampling. */ _2, /**< MSAA 2x */ _4, /**< MSAA 4x */ _8, /**< MSAA 8x */ } GPUCubeMapFace :: enum c.int { POSITIVEX, NEGATIVEX, POSITIVEY, NEGATIVEY, POSITIVEZ, NEGATIVEZ, } GPUBufferUsageFlags :: distinct bit_set[GPUBufferUsageFlag; Uint32] GPUBufferUsageFlag :: enum Uint32 { VERTEX = 0, /**< Buffer is a vertex buffer. */ INDEX = 1, /**< Buffer is an index buffer. */ INDIRECT = 2, /**< Buffer is an indirect buffer. */ GRAPHICS_STORAGE_READ = 3, /**< Buffer supports storage reads in graphics stages. */ COMPUTE_STORAGE_READ = 4, /**< Buffer supports storage reads in the compute stage. */ COMPUTE_STORAGE_WRITE = 5, /**< Buffer supports storage writes in the compute stage. */ } GPUTransferBufferUsage :: enum c.int { UPLOAD, DOWNLOAD, } GPUShaderStage :: enum c.int { VERTEX, FRAGMENT, } GPUShaderFormat :: distinct bit_set[GPUShaderFormatFlag; Uint32] GPUShaderFormatFlag :: enum Uint32 { PRIVATE = 0, /**< Shaders for NDA'd platforms. */ SPIRV = 1, /**< SPIR-V shaders for Vulkan. */ DXBC = 2, /**< DXBC SM5_1 shaders for D3D12. */ DXIL = 3, /**< DXIL SM6_0 shaders for D3D12. */ MSL = 4, /**< MSL shaders for Metal. */ METALLIB = 5, /**< Precompiled metallib shaders for Metal. */ } GPU_SHADERFORMAT_INVALID :: GPUShaderFormat{} GPUVertexElementFormat :: enum c.int { INVALID, /* 32-bit Signed Integers */ INT, INT2, INT3, INT4, /* 32-bit Unsigned Integers */ UINT, UINT2, UINT3, UINT4, /* 32-bit Floats */ FLOAT, FLOAT2, FLOAT3, FLOAT4, /* 8-bit Signed Integers */ BYTE2, BYTE4, /* 8-bit Unsigned Integers */ UBYTE2, UBYTE4, /* 8-bit Signed Normalized */ BYTE2_NORM, BYTE4_NORM, /* 8-bit Unsigned Normalized */ UBYTE2_NORM, UBYTE4_NORM, /* 16-bit Signed Integers */ SHORT2, SHORT4, /* 16-bit Unsigned Integers */ USHORT2, USHORT4, /* 16-bit Signed Normalized */ SHORT2_NORM, SHORT4_NORM, /* 16-bit Unsigned Normalized */ USHORT2_NORM, USHORT4_NORM, /* 16-bit Floats */ HALF2, HALF4, } GPUVertexInputRate :: enum c.int { VERTEX, /**< Attribute addressing is a function of the vertex index. */ INSTANCE, /**< Attribute addressing is a function of the instance index. */ } GPUFillMode :: enum c.int { FILL, /**< Polygons will be rendered via rasterization. */ LINE, /**< Polygon edges will be drawn as line segments. */ } GPUCullMode :: enum c.int { NONE, /**< No triangles are culled. */ FRONT, /**< Front-facing triangles are culled. */ BACK, /**< Back-facing triangles are culled. */ } GPUFrontFace :: enum c.int { COUNTER_CLOCKWISE, /**< A triangle with counter-clockwise vertex winding will be considered front-facing. */ CLOCKWISE, /**< A triangle with clockwise vertex winding will be considered front-facing. */ } GPUCompareOp :: enum c.int { INVALID, NEVER, /**< The comparison always evaluates false. */ LESS, /**< The comparison evaluates reference < test. */ EQUAL, /**< The comparison evaluates reference == test. */ LESS_OR_EQUAL, /**< The comparison evaluates reference <= test. */ GREATER, /**< The comparison evaluates reference > test. */ NOT_EQUAL, /**< The comparison evaluates reference != test. */ GREATER_OR_EQUAL, /**< The comparison evalutes reference >= test. */ ALWAYS, /**< The comparison always evaluates true. */ } GPUStencilOp :: enum c.int { INVALID, KEEP, /**< Keeps the current value. */ ZERO, /**< Sets the value to 0. */ REPLACE, /**< Sets the value to reference. */ INCREMENT_AND_CLAMP, /**< Increments the current value and clamps to the maximum value. */ DECREMENT_AND_CLAMP, /**< Decrements the current value and clamps to 0. */ INVERT, /**< Bitwise-inverts the current value. */ INCREMENT_AND_WRAP, /**< Increments the current value and wraps back to 0. */ DECREMENT_AND_WRAP, /**< Decrements the current value and wraps to the maximum value. */ } GPUBlendOp :: enum c.int { INVALID, ADD, /**< (source * source_factor) + (destination * destination_factor) */ SUBTRACT, /**< (source * source_factor) - (destination * destination_factor) */ REVERSE_SUBTRACT, /**< (destination * destination_factor) - (source * source_factor) */ MIN, /**< min(source, destination) */ MAX, /**< max(source, destination) */ } GPUBlendFactor :: enum c.int { INVALID, ZERO, /**< 0 */ ONE, /**< 1 */ SRC_COLOR, /**< source color */ ONE_MINUS_SRC_COLOR, /**< 1 - source color */ DST_COLOR, /**< destination color */ ONE_MINUS_DST_COLOR, /**< 1 - destination color */ SRC_ALPHA, /**< source alpha */ ONE_MINUS_SRC_ALPHA, /**< 1 - source alpha */ DST_ALPHA, /**< destination alpha */ ONE_MINUS_DST_ALPHA, /**< 1 - destination alpha */ CONSTANT_COLOR, /**< blend constant */ ONE_MINUS_CONSTANT_COLOR, /**< 1 - blend constant */ SRC_ALPHA_SATURATE, /**< min(source alpha, 1 - destination alpha) */ } GPUColorComponentFlags :: distinct bit_set[GPUColorComponentFlag; Uint8] GPUColorComponentFlag :: enum Uint8 { R = 0, /**< the red component */ G = 1, /**< the green component */ B = 2, /**< the blue component */ A = 3, /**< the alpha component */ } GPUFilter :: enum c.int { NEAREST, /**< Point filtering. */ LINEAR, /**< Linear filtering. */ } GPUSamplerMipmapMode :: enum c.int { NEAREST, /**< Point filtering. */ LINEAR, /**< Linear filtering. */ } GPUSamplerAddressMode :: enum c.int { REPEAT, /**< Specifies that the coordinates will wrap around. */ MIRRORED_REPEAT, /**< Specifies that the coordinates will wrap around mirrored. */ CLAMP_TO_EDGE, /**< Specifies that the coordinates will clamp to the 0-1 range. */ } GPUPresentMode :: enum c.int { VSYNC, IMMEDIATE, MAILBOX, } GPUSwapchainComposition :: enum c.int { SDR, SDR_LINEAR, HDR_EXTENDED_LINEAR, HDR10_ST2084, } GPUViewport :: struct { x: f32, /**< The left offset of the viewport. */ y: f32, /**< The top offset of the viewport. */ w: f32, /**< The width of the viewport. */ h: f32, /**< The height of the viewport. */ min_depth: f32, /**< The minimum depth of the viewport. */ max_depth: f32, /**< The maximum depth of the viewport. */ } GPUTextureTransferInfo :: struct { transfer_buffer: ^GPUTransferBuffer, /**< The transfer buffer used in the transfer operation. */ offset: Uint32, /**< The starting byte of the image data in the transfer buffer. */ pixels_per_row: Uint32, /**< The number of pixels from one row to the next. */ rows_per_layer: Uint32, /**< The number of rows from one layer/depth-slice to the next. */ } GPUTransferBufferLocation :: struct { transfer_buffer: ^GPUTransferBuffer, /**< The transfer buffer used in the transfer operation. */ offset: Uint32, /**< The starting byte of the buffer data in the transfer buffer. */ } GPUTextureLocation :: struct { texture: ^GPUTexture, /**< The texture used in the copy operation. */ mip_level: Uint32, /**< The mip level index of the location. */ layer: Uint32, /**< The layer index of the location. */ x: Uint32, /**< The left offset of the location. */ y: Uint32, /**< The top offset of the location. */ z: Uint32, /**< The front offset of the location. */ } GPUTextureRegion :: struct { texture: ^GPUTexture, /**< The texture used in the copy operation. */ mip_level: Uint32, /**< The mip level index to transfer. */ layer: Uint32, /**< The layer index to transfer. */ x: Uint32, /**< The left offset of the region. */ y: Uint32, /**< The top offset of the region. */ z: Uint32, /**< The front offset of the region. */ w: Uint32, /**< The width of the region. */ h: Uint32, /**< The height of the region. */ d: Uint32, /**< The depth of the region. */ } GPUBlitRegion :: struct { texture: ^GPUTexture, /**< The texture. */ mip_level: Uint32, /**< The mip level index of the region. */ layer_or_depth_plane: Uint32, /**< The layer index or depth plane of the region. This value is treated as a layer index on 2D array and cube textures, and as a depth plane on 3D textures. */ x: Uint32, /**< The left offset of the region. */ y: Uint32, /**< The top offset of the region. */ w: Uint32, /**< The width of the region. */ h: Uint32, /**< The height of the region. */ } GPUBufferLocation :: struct { buffer: ^GPUBuffer, /**< The buffer. */ offset: Uint32, /**< The starting byte within the buffer. */ } GPUBufferRegion :: struct { buffer: ^GPUBuffer, /**< The buffer. */ offset: Uint32, /**< The starting byte within the buffer. */ size: Uint32, /**< The size in bytes of the region. */ } GPUIndirectDrawCommand :: struct { num_vertices: Uint32, /**< The number of vertices to draw. */ num_instances: Uint32, /**< The number of instances to draw. */ first_vertex: Uint32, /**< The index of the first vertex to draw. */ first_instance: Uint32, /**< The ID of the first instance to draw. */ } GPUIndexedIndirectDrawCommand :: struct { num_indices: Uint32, /**< The number of indices to draw per instance. */ num_instances: Uint32, /**< The number of instances to draw. */ first_index: Uint32, /**< The base index within the index buffer. */ vertex_offset: Sint32, /**< The value added to the vertex index before indexing into the vertex buffer. */ first_instance: Uint32, /**< The ID of the first instance to draw. */ } GPUIndirectDispatchCommand :: struct { groupcount_x: Uint32, /**< The number of local workgroups to dispatch in the X dimension. */ groupcount_y: Uint32, /**< The number of local workgroups to dispatch in the Y dimension. */ groupcount_z: Uint32, /**< The number of local workgroups to dispatch in the Z dimension. */ } GPUSamplerCreateInfo :: struct { min_filter: GPUFilter, /**< The minification filter to apply to lookups. */ mag_filter: GPUFilter, /**< The magnification filter to apply to lookups. */ mipmap_mode: GPUSamplerMipmapMode, /**< The mipmap filter to apply to lookups. */ address_mode_u: GPUSamplerAddressMode, /**< The addressing mode for U coordinates outside [0, 1). */ address_mode_v: GPUSamplerAddressMode, /**< The addressing mode for V coordinates outside [0, 1). */ address_mode_w: GPUSamplerAddressMode, /**< The addressing mode for W coordinates outside [0, 1). */ mip_lod_bias: f32, /**< The bias to be added to mipmap LOD calculation. */ max_anisotropy: f32, /**< The anisotropy value clamp used by the sampler. If enable_anisotropy is false, this is ignored. */ compare_op: GPUCompareOp, /**< The comparison operator to apply to fetched data before filtering. */ min_lod: f32, /**< Clamps the minimum of the computed LOD value. */ max_lod: f32, /**< Clamps the maximum of the computed LOD value. */ enable_anisotropy: bool, /**< true to enable anisotropic filtering. */ enable_compare: bool, /**< true to enable comparison against a reference value during lookups. */ _: Uint8, _: Uint8, props: PropertiesID, /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ } GPUVertexBufferDescription :: struct { slot: Uint32, /**< The binding slot of the vertex buffer. */ pitch: Uint32, /**< The byte pitch between consecutive elements of the vertex buffer. */ input_rate: GPUVertexInputRate, /**< Whether attribute addressing is a function of the vertex index or instance index. */ instance_step_rate: Uint32, /**< Reserved for future use. Must be set to 0. */ } GPUVertexAttribute :: struct { location: Uint32, /**< The shader input location index. */ buffer_slot: Uint32, /**< The binding slot of the associated vertex buffer. */ format: GPUVertexElementFormat, /**< The size and type of the attribute data. */ offset: Uint32, /**< The byte offset of this attribute relative to the start of the vertex element. */ } GPUVertexInputState :: struct { vertex_buffer_descriptions: [^]GPUVertexBufferDescription `fmt:"v,num_vertex_buffers"`, /**< A pointer to an array of vertex buffer descriptions. */ num_vertex_buffers: Uint32, /**< The number of vertex buffer descriptions in the above array. */ vertex_attributes: [^]GPUVertexAttribute `fmt:"v,num_vertex_attributes"`, /**< A pointer to an array of vertex attribute descriptions. */ num_vertex_attributes: Uint32, /**< The number of vertex attribute descriptions in the above array. */ } GPUStencilOpState :: struct { fail_op: GPUStencilOp, /**< The action performed on samples that fail the stencil test. */ pass_op: GPUStencilOp, /**< The action performed on samples that pass the depth and stencil tests. */ depth_fail_op: GPUStencilOp, /**< The action performed on samples that pass the stencil test and fail the depth test. */ compare_op: GPUCompareOp, /**< The comparison operator used in the stencil test. */ } GPUColorTargetBlendState :: struct { src_color_blendfactor: GPUBlendFactor, /**< The value to be multiplied by the source RGB value. */ dst_color_blendfactor: GPUBlendFactor, /**< The value to be multiplied by the destination RGB value. */ color_blend_op: GPUBlendOp, /**< The blend operation for the RGB components. */ src_alpha_blendfactor: GPUBlendFactor, /**< The value to be multiplied by the source alpha. */ dst_alpha_blendfactor: GPUBlendFactor, /**< The value to be multiplied by the destination alpha. */ alpha_blend_op: GPUBlendOp, /**< The blend operation for the alpha component. */ color_write_mask: GPUColorComponentFlags, /**< A bitmask specifying which of the RGBA components are enabled for writing. Writes to all channels if enable_color_write_mask is false. */ enable_blend: bool, /**< Whether blending is enabled for the color target. */ enable_color_write_mask: bool, /**< Whether the color write mask is enabled. */ _: Uint8, _: Uint8, } GPUShaderCreateInfo :: struct { code_size: uint, /**< The size in bytes of the code pointed to. */ code: [^]Uint8, /**< A pointer to shader code. */ entrypoint: cstring, /**< A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. */ format: GPUShaderFormat, /**< The format of the shader code. */ stage: GPUShaderStage, /**< The stage the shader program corresponds to. */ num_samplers: Uint32, /**< The number of samplers defined in the shader. */ num_storage_textures: Uint32, /**< The number of storage textures defined in the shader. */ num_storage_buffers: Uint32, /**< The number of storage buffers defined in the shader. */ num_uniform_buffers: Uint32, /**< The number of uniform buffers defined in the shader. */ props: PropertiesID, /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ } GPUTextureCreateInfo :: struct { type: GPUTextureType, /**< The base dimensionality of the texture. */ format: GPUTextureFormat, /**< The pixel format of the texture. */ usage: GPUTextureUsageFlags, /**< How the texture is intended to be used by the client. */ width: Uint32, /**< The width of the texture. */ height: Uint32, /**< The height of the texture. */ layer_count_or_depth: Uint32, /**< The layer count or depth of the texture. This value is treated as a layer count on 2D array textures, and as a depth value on 3D textures. */ num_levels: Uint32, /**< The number of mip levels in the texture. */ sample_count: GPUSampleCount, /**< The number of samples per texel. Only applies if the texture is used as a render target. */ props: PropertiesID, /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ } GPUBufferCreateInfo :: struct { usage: GPUBufferUsageFlags, /**< How the buffer is intended to be used by the client. */ size: Uint32, /**< The size in bytes of the buffer. */ props: PropertiesID, /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ } GPUTransferBufferCreateInfo :: struct { usage: GPUTransferBufferUsage, /**< How the transfer buffer is intended to be used by the client. */ size: Uint32, /**< The size in bytes of the transfer buffer. */ props: PropertiesID, /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ } GPURasterizerState :: struct { fill_mode: GPUFillMode, /**< Whether polygons will be filled in or drawn as lines. */ cull_mode: GPUCullMode, /**< The facing direction in which triangles will be culled. */ front_face: GPUFrontFace, /**< The vertex winding that will cause a triangle to be determined as front-facing. */ depth_bias_constant_factor: f32, /**< A scalar factor controlling the depth value added to each fragment. */ depth_bias_clamp: f32, /**< The maximum depth bias of a fragment. */ depth_bias_slope_factor: f32, /**< A scalar factor applied to a fragment's slope in depth calculations. */ enable_depth_bias: bool, /**< true to bias fragment depth values. */ enable_depth_clip: bool, /**< true to enable depth clip, false to enable depth clamp. */ _: Uint8, _: Uint8, } GPUMultisampleState :: struct { sample_count: GPUSampleCount, /**< The number of samples to be used in rasterization. */ sample_mask: Uint32, /**< Reserved for future use. Must be set to 0. */ enable_mask: bool, /**< Reserved for future use. Must be set to false. */ _: Uint8, _: Uint8, _: Uint8, } GPUDepthStencilState :: struct { compare_op: GPUCompareOp, /**< The comparison operator used for depth testing. */ back_stencil_state: GPUStencilOpState, /**< The stencil op state for back-facing triangles. */ front_stencil_state: GPUStencilOpState, /**< The stencil op state for front-facing triangles. */ compare_mask: Uint8, /**< Selects the bits of the stencil values participating in the stencil test. */ write_mask: Uint8, /**< Selects the bits of the stencil values updated by the stencil test. */ enable_depth_test: bool, /**< true enables the depth test. */ enable_depth_write: bool, /**< true enables depth writes. Depth writes are always disabled when enable_depth_test is false. */ enable_stencil_test: bool, /**< true enables the stencil test. */ _: Uint8, _: Uint8, _: Uint8, } GPUColorTargetDescription :: struct { format: GPUTextureFormat, /**< The pixel format of the texture to be used as a color target. */ blend_state: GPUColorTargetBlendState, /**< The blend state to be used for the color target. */ } GPUGraphicsPipelineTargetInfo :: struct { color_target_descriptions: [^]GPUColorTargetDescription `fmt:"v,num_color_targets"`, /**< A pointer to an array of color target descriptions. */ num_color_targets: Uint32, /**< The number of color target descriptions in the above array. */ depth_stencil_format: GPUTextureFormat, /**< The pixel format of the depth-stencil target. Ignored if has_depth_stencil_target is false. */ has_depth_stencil_target: bool, /**< true specifies that the pipeline uses a depth-stencil target. */ _: Uint8, _: Uint8, _: Uint8, } GPUGraphicsPipelineCreateInfo :: struct { vertex_shader: ^GPUShader, /**< The vertex shader used by the graphics pipeline. */ fragment_shader: ^GPUShader, /**< The fragment shader used by the graphics pipeline. */ vertex_input_state: GPUVertexInputState, /**< The vertex layout of the graphics pipeline. */ primitive_type: GPUPrimitiveType, /**< The primitive topology of the graphics pipeline. */ rasterizer_state: GPURasterizerState, /**< The rasterizer state of the graphics pipeline. */ multisample_state: GPUMultisampleState, /**< The multisample state of the graphics pipeline. */ depth_stencil_state: GPUDepthStencilState, /**< The depth-stencil state of the graphics pipeline. */ target_info: GPUGraphicsPipelineTargetInfo, /**< Formats and blend modes for the render targets of the graphics pipeline. */ props: PropertiesID, /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ } GPUComputePipelineCreateInfo :: struct { code_size: uint, /**< The size in bytes of the compute shader code pointed to. */ code: [^]Uint8, /**< A pointer to compute shader code. */ entrypoint: cstring, /**< A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. */ format: GPUShaderFormat, /**< The format of the compute shader code. */ num_samplers: Uint32, /**< The number of samplers defined in the shader. */ num_readonly_storage_textures: Uint32, /**< The number of readonly storage textures defined in the shader. */ num_readonly_storage_buffers: Uint32, /**< The number of readonly storage buffers defined in the shader. */ num_readwrite_storage_textures: Uint32, /**< The number of read-write storage textures defined in the shader. */ num_readwrite_storage_buffers: Uint32, /**< The number of read-write storage buffers defined in the shader. */ num_uniform_buffers: Uint32, /**< The number of uniform buffers defined in the shader. */ threadcount_x: Uint32, /**< The number of threads in the X dimension. This should match the value in the shader. */ threadcount_y: Uint32, /**< The number of threads in the Y dimension. This should match the value in the shader. */ threadcount_z: Uint32, /**< The number of threads in the Z dimension. This should match the value in the shader. */ props: PropertiesID, /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ } GPUColorTargetInfo :: struct { texture: ^GPUTexture, /**< The texture that will be used as a color target by a render pass. */ mip_level: Uint32, /**< The mip level to use as a color target. */ layer_or_depth_plane: Uint32, /**< The layer index or depth plane to use as a color target. This value is treated as a layer index on 2D array and cube textures, and as a depth plane on 3D textures. */ clear_color: FColor, /**< The color to clear the color target to at the start of the render pass. Ignored if GPU_LOADOP_CLEAR is not used. */ load_op: GPULoadOp, /**< What is done with the contents of the color target at the beginning of the render pass. */ store_op: GPUStoreOp, /**< What is done with the results of the render pass. */ resolve_texture: ^GPUTexture, /**< The texture that will receive the results of a multisample resolve operation. Ignored if a RESOLVE* store_op is not used. */ resolve_mip_level: Uint32, /**< The mip level of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used. */ resolve_layer: Uint32, /**< The layer index of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used. */ cycle: bool, /**< true cycles the texture if the texture is bound and load_op is not LOAD */ cycle_resolve_texture: bool, /**< true cycles the resolve texture if the resolve texture is bound. Ignored if a RESOLVE* store_op is not used. */ _: Uint8, _: Uint8, } GPUDepthStencilTargetInfo :: struct { texture: ^GPUTexture, /**< The texture that will be used as the depth stencil target by the render pass. */ clear_depth: f32, /**< The value to clear the depth component to at the beginning of the render pass. Ignored if GPU_LOADOP_CLEAR is not used. */ load_op: GPULoadOp, /**< What is done with the depth contents at the beginning of the render pass. */ store_op: GPUStoreOp, /**< What is done with the depth results of the render pass. */ stencil_load_op: GPULoadOp, /**< What is done with the stencil contents at the beginning of the render pass. */ stencil_store_op: GPUStoreOp, /**< What is done with the stencil results of the render pass. */ cycle: bool, /**< true cycles the texture if the texture is bound and any load ops are not LOAD */ clear_stencil: Uint8, /**< The value to clear the stencil component to at the beginning of the render pass. Ignored if GPU_LOADOP_CLEAR is not used. */ _: Uint8, _: Uint8, } GPUBlitInfo :: struct { source: GPUBlitRegion, /**< The source region for the blit. */ destination: GPUBlitRegion, /**< The destination region for the blit. */ load_op: GPULoadOp, /**< What is done with the contents of the destination before the blit. */ clear_color: FColor, /**< The color to clear the destination region to before the blit. Ignored if load_op is not GPU_LOADOP_CLEAR. */ flip_mode: FlipMode, /**< The flip mode for the source region. */ filter: GPUFilter, /**< The filter mode used when blitting. */ cycle: bool, /**< true cycles the destination texture if it is already bound. */ _: Uint8, _: Uint8, _: Uint8, } GPUBufferBinding :: struct { buffer: ^GPUBuffer, /**< The buffer to bind. Must have been created with GPU_BUFFERUSAGE_VERTEX for BindGPUVertexBuffers, or GPU_BUFFERUSAGE_INDEX for BindGPUIndexBuffer. */ offset: Uint32, /**< The starting byte of the data to bind in the buffer. */ } GPUTextureSamplerBinding :: struct { texture: ^GPUTexture, /**< The texture to bind. Must have been created with GPU_TEXTUREUSAGE_SAMPLER. */ sampler: ^GPUSampler, /**< The sampler to bind. */ } GPUStorageBufferReadWriteBinding :: struct { buffer: ^GPUBuffer, /**< The buffer to bind. Must have been created with GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE. */ cycle: bool, /**< true cycles the buffer if it is already bound. */ _: Uint8, _: Uint8, _: Uint8, } GPUStorageTextureReadWriteBinding :: struct { texture: ^GPUTexture, /**< The texture to bind. Must have been created with GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE or GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE. */ mip_level: Uint32, /**< The mip level index to bind. */ layer: Uint32, /**< The layer index to bind. */ cycle: bool, /**< true cycles the texture if it is already bound. */ _: Uint8, _: Uint8, _: Uint8, } PROP_GPU_DEVICE_CREATE_DEBUGMODE_BOOLEAN :: "SDL.gpu.device.create.debugmode" PROP_GPU_DEVICE_CREATE_PREFERLOWPOWER_BOOLEAN :: "SDL.gpu.device.create.preferlowpower" PROP_GPU_DEVICE_CREATE_NAME_STRING :: "SDL.gpu.device.create.name" PROP_GPU_DEVICE_CREATE_SHADERS_PRIVATE_BOOLEAN :: "SDL.gpu.device.create.shaders.private" PROP_GPU_DEVICE_CREATE_SHADERS_SPIRV_BOOLEAN :: "SDL.gpu.device.create.shaders.spirv" PROP_GPU_DEVICE_CREATE_SHADERS_DXBC_BOOLEAN :: "SDL.gpu.device.create.shaders.dxbc" PROP_GPU_DEVICE_CREATE_SHADERS_DXIL_BOOLEAN :: "SDL.gpu.device.create.shaders.dxil" PROP_GPU_DEVICE_CREATE_SHADERS_MSL_BOOLEAN :: "SDL.gpu.device.create.shaders.msl" PROP_GPU_DEVICE_CREATE_SHADERS_METALLIB_BOOLEAN :: "SDL.gpu.device.create.shaders.metallib" PROP_GPU_DEVICE_CREATE_D3D12_SEMANTIC_NAME_STRING :: "SDL.gpu.device.create.d3d12.semantic" PROP_GPU_COMPUTEPIPELINE_CREATE_NAME_STRING :: "SDL.gpu.computepipeline.create.name" PROP_GPU_GRAPHICSPIPELINE_CREATE_NAME_STRING :: "SDL.gpu.graphicspipeline.create.name" PROP_GPU_SAMPLER_CREATE_NAME_STRING :: "SDL.gpu.sampler.create.name" PROP_GPU_SHADER_CREATE_NAME_STRING :: "SDL.gpu.shader.create.name" PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_R_FLOAT :: "SDL.gpu.texture.create.d3d12.clear.r" PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_G_FLOAT :: "SDL.gpu.texture.create.d3d12.clear.g" PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_B_FLOAT :: "SDL.gpu.texture.create.d3d12.clear.b" PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_A_FLOAT :: "SDL.gpu.texture.create.d3d12.clear.a" PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_DEPTH_FLOAT :: "SDL.gpu.texture.create.d3d12.clear.depth" PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_STENCIL_NUMBER :: "SDL.gpu.texture.create.d3d12.clear.stencil" PROP_GPU_TEXTURE_CREATE_NAME_STRING :: "SDL.gpu.texture.create.name" PROP_GPU_BUFFER_CREATE_NAME_STRING :: "SDL.gpu.buffer.create.name" PROP_GPU_TRANSFERBUFFER_CREATE_NAME_STRING :: "SDL.gpu.transferbuffer.create.name" @(default_calling_convention="c", link_prefix="SDL_", require_results) foreign lib { GPUSupportsShaderFormats :: proc(format_flags: GPUShaderFormat, name: cstring) -> bool --- GPUSupportsProperties :: proc(props: PropertiesID) -> bool --- CreateGPUDevice :: proc(format_flags: GPUShaderFormat, debug_mode: bool, name: cstring) -> ^GPUDevice --- CreateGPUDeviceWithProperties :: proc(props: PropertiesID) -> ^GPUDevice --- DestroyGPUDevice :: proc(device: ^GPUDevice) --- GetNumGPUDrivers :: proc() -> c.int --- GetGPUDriver :: proc(index: c.int) -> cstring --- GetGPUDeviceDriver :: proc(device: ^GPUDevice) -> cstring --- GetGPUShaderFormats :: proc(device: ^GPUDevice) -> GPUShaderFormat --- CreateGPUComputePipeline :: proc(device: ^GPUDevice, #by_ptr createinfo: GPUComputePipelineCreateInfo) -> ^GPUComputePipeline --- CreateGPUGraphicsPipeline :: proc(device: ^GPUDevice, #by_ptr createinfo: GPUGraphicsPipelineCreateInfo) -> ^GPUGraphicsPipeline --- CreateGPUSampler :: proc(device: ^GPUDevice, #by_ptr createinfo: GPUSamplerCreateInfo) -> ^GPUSampler --- CreateGPUShader :: proc(device: ^GPUDevice, #by_ptr createinfo: GPUShaderCreateInfo) -> ^GPUShader --- CreateGPUTexture :: proc(device: ^GPUDevice, #by_ptr createinfo: GPUTextureCreateInfo) -> ^GPUTexture --- CreateGPUBuffer :: proc(device: ^GPUDevice, #by_ptr createinfo: GPUBufferCreateInfo) -> ^GPUBuffer --- CreateGPUTransferBuffer :: proc(device: ^GPUDevice, #by_ptr createinfo: GPUTransferBufferCreateInfo) -> ^GPUTransferBuffer --- SetGPUBufferName :: proc(device: ^GPUDevice, buffer: ^GPUBuffer, text: cstring) --- SetGPUTextureName :: proc(device: ^GPUDevice, texture: ^GPUTexture, text: cstring) --- InsertGPUDebugLabel :: proc(command_buffer: ^GPUCommandBuffer, text: cstring) --- PushGPUDebugGroup :: proc(command_buffer: ^GPUCommandBuffer, name: cstring) --- PopGPUDebugGroup :: proc(command_buffer: ^GPUCommandBuffer) --- ReleaseGPUTexture :: proc(device: ^GPUDevice, texture: ^GPUTexture) --- ReleaseGPUSampler :: proc(device: ^GPUDevice, sampler: ^GPUSampler) --- ReleaseGPUBuffer :: proc(device: ^GPUDevice, buffer: ^GPUBuffer) --- ReleaseGPUTransferBuffer :: proc(device: ^GPUDevice, transfer_buffer: ^GPUTransferBuffer) --- ReleaseGPUComputePipeline :: proc(device: ^GPUDevice, compute_pipeline: ^GPUComputePipeline) --- ReleaseGPUShader :: proc(device: ^GPUDevice, shader: ^GPUShader) --- ReleaseGPUGraphicsPipeline :: proc(device: ^GPUDevice, graphics_pipeline: ^GPUGraphicsPipeline) --- AcquireGPUCommandBuffer :: proc(device: ^GPUDevice) -> ^GPUCommandBuffer --- PushGPUVertexUniformData :: proc(command_buffer: ^GPUCommandBuffer, slot_index: Uint32, data: rawptr, length: Uint32) --- PushGPUFragmentUniformData :: proc(command_buffer: ^GPUCommandBuffer, slot_index: Uint32, data: rawptr, length: Uint32) --- PushGPUComputeUniformData :: proc(command_buffer: ^GPUCommandBuffer, slot_index: Uint32, data: rawptr, length: Uint32) --- BeginGPURenderPass :: proc(command_buffer: ^GPUCommandBuffer, color_target_infos: [^]GPUColorTargetInfo, num_color_targets: Uint32, depth_stencil_target_info: Maybe(^GPUDepthStencilTargetInfo)) -> ^GPURenderPass --- BindGPUGraphicsPipeline :: proc(render_pass: ^GPURenderPass, graphics_pipeline: ^GPUGraphicsPipeline) --- SetGPUViewport :: proc(render_pass: ^GPURenderPass, #by_ptr viewport: GPUViewport) --- SetGPUScissor :: proc(render_pass: ^GPURenderPass, #by_ptr scissor: Rect) --- SetGPUBlendConstants :: proc(render_pass: ^GPURenderPass, blend_constants: FColor) --- SetGPUStencilReference :: proc(render_pass: ^GPURenderPass, reference: Uint8) --- BindGPUVertexBuffers :: proc(render_pass: ^GPURenderPass, first_slot: Uint32, bindings: [^]GPUBufferBinding, num_bindings: Uint32) --- BindGPUIndexBuffer :: proc(render_pass: ^GPURenderPass, #by_ptr binding: GPUBufferBinding, index_element_size: GPUIndexElementSize) --- BindGPUVertexSamplers :: proc(render_pass: ^GPURenderPass, first_slot: Uint32, texture_sampler_bindings: [^]GPUTextureSamplerBinding, num_bindings: Uint32) --- BindGPUVertexStorageTextures :: proc(render_pass: ^GPURenderPass, first_slot: Uint32, storage_textures: [^]^GPUTexture, num_bindings: Uint32) --- BindGPUVertexStorageBuffers :: proc(render_pass: ^GPURenderPass, first_slot: Uint32, storage_buffers: [^]^GPUBuffer, num_bindings: Uint32) --- BindGPUFragmentSamplers :: proc(render_pass: ^GPURenderPass, first_slot: Uint32, texture_sampler_bindings: [^]GPUTextureSamplerBinding, num_bindings: Uint32) --- BindGPUFragmentStorageTextures :: proc(render_pass: ^GPURenderPass, first_slot: Uint32, storage_textures: [^]^GPUTexture, num_bindings: Uint32) --- BindGPUFragmentStorageBuffers :: proc(render_pass: ^GPURenderPass, first_slot: Uint32, storage_buffers: [^]^GPUBuffer, num_bindings: Uint32) --- DrawGPUIndexedPrimitives :: proc(render_pass: ^GPURenderPass, num_indices: Uint32, num_instances: Uint32, first_index: Uint32, vertex_offset: Sint32, first_instance: Uint32) --- DrawGPUPrimitives :: proc(render_pass: ^GPURenderPass, num_vertices: Uint32, num_instances: Uint32, first_vertex: Uint32, first_instance: Uint32) --- DrawGPUPrimitivesIndirect :: proc(render_pass: ^GPURenderPass, buffer: ^GPUBuffer, offset: Uint32, draw_count: Uint32) --- DrawGPUIndexedPrimitivesIndirect :: proc(render_pass: ^GPURenderPass, buffer: ^GPUBuffer, offset: Uint32, draw_count: Uint32) --- EndGPURenderPass :: proc(render_pass: ^GPURenderPass) --- BeginGPUComputePass :: proc(command_buffer: ^GPUCommandBuffer, storage_texture_bindings: [^]GPUStorageTextureReadWriteBinding, num_storage_texture_bindings: Uint32, storage_buffer_bindings: [^]GPUStorageBufferReadWriteBinding, num_storage_buffer_bindings: Uint32) -> ^GPUComputePass --- BindGPUComputePipeline :: proc(compute_pass: ^GPUComputePass, compute_pipeline: ^GPUComputePipeline) --- BindGPUComputeSamplers :: proc(compute_pass: ^GPUComputePass, first_slot: Uint32, texture_sampler_bindings: [^]GPUTextureSamplerBinding, num_bindings: Uint32) --- BindGPUComputeStorageTextures :: proc(compute_pass: ^GPUComputePass, first_slot: Uint32, storage_textures: [^]^GPUTexture, num_bindings: Uint32) --- BindGPUComputeStorageBuffers :: proc(compute_pass: ^GPUComputePass, first_slot: Uint32, storage_buffers: [^]^GPUBuffer, num_bindings: Uint32) --- DispatchGPUCompute :: proc(compute_pass: ^GPUComputePass, groupcount_x, groupcount_y, groupcount_z: Uint32) --- DispatchGPUComputeIndirect :: proc(compute_pass: ^GPUComputePass, buffer: ^GPUBuffer, offset: Uint32) --- EndGPUComputePass :: proc(compute_pass: ^GPUComputePass) --- MapGPUTransferBuffer :: proc(device: ^GPUDevice, transfer_buffer: ^GPUTransferBuffer, cycle: bool) -> rawptr --- UnmapGPUTransferBuffer :: proc(device: ^GPUDevice, transfer_buffer: ^GPUTransferBuffer) --- BeginGPUCopyPass :: proc(command_buffer: ^GPUCommandBuffer) -> ^GPUCopyPass --- UploadToGPUTexture :: proc(copy_pass: ^GPUCopyPass, #by_ptr source: GPUTextureTransferInfo, #by_ptr destination: GPUTextureRegion, cycle: bool) --- UploadToGPUBuffer :: proc(copy_pass: ^GPUCopyPass, #by_ptr source: GPUTransferBufferLocation, #by_ptr destination: GPUBufferRegion, cycle: bool) --- CopyGPUTextureToTexture :: proc(copy_pass: ^GPUCopyPass, #by_ptr source: GPUTextureLocation, #by_ptr destination: GPUTextureLocation, w, h, d: Uint32, cycle: bool) --- CopyGPUBufferToBuffer :: proc(copy_pass: ^GPUCopyPass, #by_ptr source: GPUBufferLocation, #by_ptr destination: GPUBufferLocation, size: Uint32, cycle: bool) --- DownloadFromGPUTexture :: proc(copy_pass: ^GPUCopyPass, #by_ptr source: GPUTextureRegion, #by_ptr destination: GPUTextureTransferInfo) --- DownloadFromGPUBuffer :: proc(copy_pass: ^GPUCopyPass, #by_ptr source: GPUBufferRegion, #by_ptr destination: GPUTransferBufferLocation) --- EndGPUCopyPass :: proc(copy_pass: ^GPUCopyPass) --- GenerateMipmapsForGPUTexture :: proc(command_buffer: ^GPUCommandBuffer, texture: ^GPUTexture) --- BlitGPUTexture :: proc(command_buffer: ^GPUCommandBuffer, #by_ptr info: GPUBlitInfo) --- WindowSupportsGPUSwapchainComposition :: proc(device: ^GPUDevice, window: ^Window, swapchain_composition: GPUSwapchainComposition) -> bool --- WindowSupportsGPUPresentMode :: proc(device: ^GPUDevice, window: ^Window, present_mode: GPUPresentMode) -> bool --- ClaimWindowForGPUDevice :: proc(device: ^GPUDevice, window: ^Window) -> bool --- ReleaseWindowFromGPUDevice :: proc(device: ^GPUDevice, window: ^Window) --- SetGPUSwapchainParameters :: proc(device: ^GPUDevice, window: ^Window, swapchain_composition: GPUSwapchainComposition, present_mode: GPUPresentMode) -> bool --- SetGPUAllowedFramesInFlight :: proc(device: ^GPUDevice, allowed_frames_in_flight: Uint32) -> bool --- GetGPUSwapchainTextureFormat :: proc(device: ^GPUDevice, window: ^Window) -> GPUTextureFormat --- AcquireGPUSwapchainTexture :: proc(command_buffer: ^GPUCommandBuffer, window: ^Window, swapchain_texture: ^^GPUTexture, swapchain_texture_width, swapchain_texture_height: ^Uint32) -> bool --- WaitForGPUSwapchain :: proc(device: ^GPUDevice, window: ^Window) -> bool --- WaitAndAcquireGPUSwapchainTexture :: proc(command_buffer: ^GPUCommandBuffer, window: ^Window, swapchain_texture: ^^GPUTexture, swapchain_texture_width, swapchain_texture_height: ^Uint32) -> bool --- SubmitGPUCommandBuffer :: proc(command_buffer: ^GPUCommandBuffer) -> bool --- SubmitGPUCommandBufferAndAcquireFence :: proc(command_buffer: ^GPUCommandBuffer) -> ^GPUFence --- CancelGPUCommandBuffer :: proc(command_buffer: ^GPUCommandBuffer) -> bool --- WaitForGPUIdle :: proc(device: ^GPUDevice) -> bool --- WaitForGPUFences :: proc(device: ^GPUDevice, wait_all: bool, fences: [^]^GPUFence, num_fences: Uint32) -> bool --- QueryGPUFence :: proc(device: ^GPUDevice, fence: ^GPUFence) -> bool --- ReleaseGPUFence :: proc(device: ^GPUDevice, fence: ^GPUFence) --- GPUTextureFormatTexelBlockSize :: proc(format: GPUTextureFormat) -> Uint32 --- GPUTextureSupportsFormat :: proc(device: ^GPUDevice, format: GPUTextureFormat, type: GPUTextureType, usage: GPUTextureUsageFlags) -> bool --- GPUTextureSupportsSampleCount :: proc(device: ^GPUDevice, format: GPUTextureFormat, sample_count: GPUSampleCount) -> bool --- CalculateGPUTextureFormatSize :: proc(format: GPUTextureFormat, width, height: Uint32, depth_or_layer_count: Uint32) -> Uint32 --- } // GDK @(default_calling_convention="c", link_prefix="SDL_") foreign lib { GDKSuspendGPU :: proc(device: ^GPUDevice) --- GDKResumeGPU :: proc(device: ^GPUDevice) --- }