Atlas - SDL_gpu.h
Home / ext / SDL / include / SDL3 Lines: 1 | Size: 183520 bytes [Download] [Show on GitHub] [Search similar files] [Raw] [Raw (proxy)][FILE BEGIN]1/* 2 Simple DirectMedia Layer 3 Copyright (C) 1997-2026 Sam Lantinga <[email protected]> 4 5 This software is provided 'as-is', without any express or implied 6 warranty. In no event will the authors be held liable for any damages 7 arising from the use of this software. 8 9 Permission is granted to anyone to use this software for any purpose, 10 including commercial applications, and to alter it and redistribute it 11 freely, subject to the following restrictions: 12 13 1. The origin of this software must not be misrepresented; you must not 14 claim that you wrote the original software. If you use this software 15 in a product, an acknowledgment in the product documentation would be 16 appreciated but is not required. 17 2. Altered source versions must be plainly marked as such, and must not be 18 misrepresented as being the original software. 19 3. This notice may not be removed or altered from any source distribution. 20*/ 21 22/* WIKI CATEGORY: GPU */ 23 24/** 25 * # CategoryGPU 26 * 27 * The GPU API offers a cross-platform way for apps to talk to modern graphics 28 * hardware. It offers both 3D graphics and compute support, in the style of 29 * Metal, Vulkan, and Direct3D 12. 30 * 31 * A basic workflow might be something like this: 32 * 33 * The app creates a GPU device with SDL_CreateGPUDevice(), and assigns it to 34 * a window with SDL_ClaimWindowForGPUDevice()--although strictly speaking you 35 * can render offscreen entirely, perhaps for image processing, and not use a 36 * window at all. 37 * 38 * Next, the app prepares static data (things that are created once and used 39 * over and over). For example: 40 * 41 * - Shaders (programs that run on the GPU): use SDL_CreateGPUShader(). 42 * - Vertex buffers (arrays of geometry data) and other rendering data: use 43 * SDL_CreateGPUBuffer() and SDL_UploadToGPUBuffer(). 44 * - Textures (images): use SDL_CreateGPUTexture() and 45 * SDL_UploadToGPUTexture(). 46 * - Samplers (how textures should be read from): use SDL_CreateGPUSampler(). 47 * - Render pipelines (precalculated rendering state): use 48 * SDL_CreateGPUGraphicsPipeline() 49 * 50 * To render, the app creates one or more command buffers, with 51 * SDL_AcquireGPUCommandBuffer(). Command buffers collect rendering 52 * instructions that will be submitted to the GPU in batch. Complex scenes can 53 * use multiple command buffers, maybe configured across multiple threads in 54 * parallel, as long as they are submitted in the correct order, but many apps 55 * will just need one command buffer per frame. 56 * 57 * Rendering can happen to a texture (what other APIs call a "render target") 58 * or it can happen to the swapchain texture (which is just a special texture 59 * that represents a window's contents). The app can use 60 * SDL_WaitAndAcquireGPUSwapchainTexture() to render to the window. 61 * 62 * Rendering actually happens in a Render Pass, which is encoded into a 63 * command buffer. One can encode multiple render passes (or alternate between 64 * render and compute passes) in a single command buffer, but many apps might 65 * simply need a single render pass in a single command buffer. Render Passes 66 * can render to up to four color textures and one depth texture 67 * simultaneously. If the set of textures being rendered to needs to change, 68 * the Render Pass must be ended and a new one must be begun. 69 * 70 * The app calls SDL_BeginGPURenderPass(). Then it sets states it needs for 71 * each draw: 72 * 73 * - SDL_BindGPUGraphicsPipeline() 74 * - SDL_SetGPUViewport() 75 * - SDL_BindGPUVertexBuffers() 76 * - SDL_BindGPUVertexSamplers() 77 * - etc 78 * 79 * Then, make the actual draw commands with these states: 80 * 81 * - SDL_DrawGPUPrimitives() 82 * - SDL_DrawGPUPrimitivesIndirect() 83 * - SDL_DrawGPUIndexedPrimitivesIndirect() 84 * - etc 85 * 86 * After all the drawing commands for a pass are complete, the app should call 87 * SDL_EndGPURenderPass(). Once a render pass ends all render-related state is 88 * reset. 89 * 90 * The app can begin new Render Passes and make new draws in the same command 91 * buffer until the entire scene is rendered. 92 * 93 * Once all of the render commands for the scene are complete, the app calls 94 * SDL_SubmitGPUCommandBuffer() to send it to the GPU for processing. 95 * 96 * If the app needs to read back data from texture or buffers, the API has an 97 * efficient way of doing this, provided that the app is willing to tolerate 98 * some latency. When the app uses SDL_DownloadFromGPUTexture() or 99 * SDL_DownloadFromGPUBuffer(), submitting the command buffer with 100 * SDL_SubmitGPUCommandBufferAndAcquireFence() will return a fence handle that 101 * the app can poll or wait on in a thread. Once the fence indicates that the 102 * command buffer is done processing, it is safe to read the downloaded data. 103 * Make sure to call SDL_ReleaseGPUFence() when done with the fence. 104 * 105 * The API also has "compute" support. The app calls SDL_BeginGPUComputePass() 106 * with compute-writeable textures and/or buffers, which can be written to in 107 * a compute shader. Then it sets states it needs for the compute dispatches: 108 * 109 * - SDL_BindGPUComputePipeline() 110 * - SDL_BindGPUComputeStorageBuffers() 111 * - SDL_BindGPUComputeStorageTextures() 112 * 113 * Then, dispatch compute work: 114 * 115 * - SDL_DispatchGPUCompute() 116 * 117 * For advanced users, this opens up powerful GPU-driven workflows. 118 * 119 * Graphics and compute pipelines require the use of shaders, which as 120 * mentioned above are small programs executed on the GPU. Each backend 121 * (Vulkan, Metal, D3D12) requires a different shader format. When the app 122 * creates the GPU device, the app lets the device know which shader formats 123 * the app can provide. It will then select the appropriate backend depending 124 * on the available shader formats and the backends available on the platform. 125 * When creating shaders, the app must provide the correct shader format for 126 * the selected backend. If you would like to learn more about why the API 127 * works this way, there is a detailed 128 * [blog post](https://moonside.games/posts/layers-all-the-way-down/) 129 * explaining this situation. 130 * 131 * It is optimal for apps to pre-compile the shader formats they might use, 132 * but for ease of use SDL provides a separate project, 133 * [SDL_shadercross](https://github.com/libsdl-org/SDL_shadercross) 134 * , for performing runtime shader cross-compilation. It also has a CLI 135 * interface for offline precompilation as well. 136 * 137 * This is an extremely quick overview that leaves out several important 138 * details. Already, though, one can see that GPU programming can be quite 139 * complex! If you just need simple 2D graphics, the 140 * [Render API](https://wiki.libsdl.org/SDL3/CategoryRender) 141 * is much easier to use but still hardware-accelerated. That said, even for 142 * 2D applications the performance benefits and expressiveness of the GPU API 143 * are significant. 144 * 145 * The GPU API targets a feature set with a wide range of hardware support and 146 * ease of portability. It is designed so that the app won't have to branch 147 * itself by querying feature support. If you need cutting-edge features with 148 * limited hardware support, this API is probably not for you. 149 * 150 * Examples demonstrating proper usage of this API can be found 151 * [here](https://github.com/TheSpydog/SDL_gpu_examples) 152 * . 153 * 154 * ## Performance considerations 155 * 156 * Here are some basic tips for maximizing your rendering performance. 157 * 158 * - Beginning a new render pass is relatively expensive. Use as few render 159 * passes as you can. 160 * - Minimize the amount of state changes. For example, binding a pipeline is 161 * relatively cheap, but doing it hundreds of times when you don't need to 162 * will slow the performance significantly. 163 * - Perform your data uploads as early as possible in the frame. 164 * - Don't churn resources. Creating and releasing resources is expensive. 165 * It's better to create what you need up front and cache it. 166 * - Don't use uniform buffers for large amounts of data (more than a matrix 167 * or so). Use a storage buffer instead. 168 * - Use cycling correctly. There is a detailed explanation of cycling further 169 * below. 170 * - Use culling techniques to minimize pixel writes. The less writing the GPU 171 * has to do the better. Culling can be a very advanced topic but even 172 * simple culling techniques can boost performance significantly. 173 * 174 * In general try to remember the golden rule of performance: doing things is 175 * more expensive than not doing things. Don't Touch The Driver! 176 * 177 * ## FAQ 178 * 179 * **Question: When are you adding more advanced features, like ray tracing or 180 * mesh shaders?** 181 * 182 * Answer: We don't have immediate plans to add more bleeding-edge features, 183 * but we certainly might in the future, when these features prove worthwhile, 184 * and reasonable to implement across several platforms and underlying APIs. 185 * So while these things are not in the "never" category, they are definitely 186 * not "near future" items either. 187 * 188 * **Question: Why is my shader not working?** 189 * 190 * Answer: A common oversight when using shaders is not properly laying out 191 * the shader resources/registers correctly. The GPU API is very strict with 192 * how it wants resources to be laid out and it's difficult for the API to 193 * automatically validate shaders to see if they have a compatible layout. See 194 * the documentation for SDL_CreateGPUShader() and 195 * SDL_CreateGPUComputePipeline() for information on the expected layout. 196 * 197 * Another common issue is not setting the correct number of samplers, 198 * textures, and buffers in SDL_GPUShaderCreateInfo. If possible use shader 199 * reflection to extract the required information from the shader 200 * automatically instead of manually filling in the struct's values. 201 * 202 * **Question: My application isn't performing very well. Is this the GPU 203 * API's fault?** 204 * 205 * Answer: No. Long answer: The GPU API is a relatively thin layer over the 206 * underlying graphics API. While it's possible that we have done something 207 * inefficiently, it's very unlikely especially if you are relatively 208 * inexperienced with GPU rendering. Please see the performance tips above and 209 * make sure you are following them. Additionally, tools like 210 * [RenderDoc](https://renderdoc.org/) 211 * can be very helpful for diagnosing incorrect behavior and performance 212 * issues. 213 * 214 * ## System Requirements 215 * 216 * ### Vulkan 217 * 218 * SDL driver name: "vulkan" (for use in SDL_CreateGPUDevice() and 219 * SDL_PROP_GPU_DEVICE_CREATE_NAME_STRING) 220 * 221 * Supported on Windows, Linux, Nintendo Switch, and certain Android devices. 222 * Requires Vulkan 1.0 with the following extensions and device features: 223 * 224 * - `VK_KHR_swapchain` 225 * - `VK_KHR_maintenance1` 226 * - `independentBlend` 227 * - `imageCubeArray` 228 * - `depthClamp` 229 * - `shaderClipDistance` 230 * - `drawIndirectFirstInstance` 231 * - `sampleRateShading` 232 * 233 * You can remove some of these requirements to increase compatibility with 234 * Android devices by using these properties when creating the GPU device with 235 * SDL_CreateGPUDeviceWithProperties(): 236 * 237 * - SDL_PROP_GPU_DEVICE_CREATE_FEATURE_CLIP_DISTANCE_BOOLEAN 238 * - SDL_PROP_GPU_DEVICE_CREATE_FEATURE_DEPTH_CLAMPING_BOOLEAN 239 * - SDL_PROP_GPU_DEVICE_CREATE_FEATURE_INDIRECT_DRAW_FIRST_INSTANCE_BOOLEAN 240 * - SDL_PROP_GPU_DEVICE_CREATE_FEATURE_ANISOTROPY_BOOLEAN 241 * 242 * ### D3D12 243 * 244 * SDL driver name: "direct3d12" 245 * 246 * Supported on Windows 10 or newer, Xbox One (GDK), and Xbox Series X|S 247 * (GDK). Requires a GPU that supports DirectX 12 Feature Level 11_0 and 248 * Resource Binding Tier 2 or above. 249 * 250 * You can remove the Tier 2 resource binding requirement to support Intel 251 * Haswell and Broadwell GPUs by using this property when creating the GPU 252 * device with SDL_CreateGPUDeviceWithProperties(): 253 * 254 * - SDL_PROP_GPU_DEVICE_CREATE_D3D12_ALLOW_FEWER_RESOURCE_SLOTS_BOOLEAN 255 * 256 * ### Metal 257 * 258 * SDL driver name: "metal" 259 * 260 * Supported on macOS 10.14+ and iOS/tvOS 13.0+. Hardware requirements vary by 261 * operating system: 262 * 263 * - macOS requires an Apple Silicon or 264 * [Intel Mac2 family](https://developer.apple.com/documentation/metal/mtlfeatureset/mtlfeatureset_macos_gpufamily2_v1?language=objc) 265 * GPU 266 * - iOS/tvOS requires an A9 GPU or newer 267 * - iOS Simulator and tvOS Simulator are unsupported 268 * 269 * ## Coordinate System 270 * 271 * The GPU API uses a left-handed coordinate system, following the convention 272 * of D3D12 and Metal. Specifically: 273 * 274 * - **Normalized Device Coordinates:** The lower-left corner has an x,y 275 * coordinate of `(-1.0, -1.0)`. The upper-right corner is `(1.0, 1.0)`. Z 276 * values range from `[0.0, 1.0]` where 0 is the near plane. 277 * - **Viewport Coordinates:** The top-left corner has an x,y coordinate of 278 * `(0, 0)` and extends to the bottom-right corner at `(viewportWidth, 279 * viewportHeight)`. +Y is down. 280 * - **Texture Coordinates:** The top-left corner has an x,y coordinate of 281 * `(0, 0)` and extends to the bottom-right corner at `(1.0, 1.0)`. +Y is 282 * down. 283 * 284 * If the backend driver differs from this convention (e.g. Vulkan, which has 285 * an NDC that assumes +Y is down), SDL will automatically convert the 286 * coordinate system behind the scenes, so you don't need to perform any 287 * coordinate flipping logic in your shaders. 288 * 289 * ## Uniform Data 290 * 291 * Uniforms are for passing data to shaders. The uniform data will be constant 292 * across all executions of the shader. 293 * 294 * There are 4 available uniform slots per shader stage (where the stages are 295 * vertex, fragment, and compute). Uniform data pushed to a slot on a stage 296 * keeps its value throughout the command buffer until you call the relevant 297 * Push function on that slot again. 298 * 299 * For example, you could write your vertex shaders to read a camera matrix 300 * from uniform binding slot 0, push the camera matrix at the start of the 301 * command buffer, and that data will be used for every subsequent draw call. 302 * 303 * It is valid to push uniform data during a render or compute pass. 304 * 305 * Uniforms are best for pushing small amounts of data. If you are pushing 306 * more than a matrix or two per call you should consider using a storage 307 * buffer instead. 308 * 309 * ## A Note On Cycling 310 * 311 * When using a command buffer, operations do not occur immediately - they 312 * occur some time after the command buffer is submitted. 313 * 314 * When a resource is used in a pending or active command buffer, it is 315 * considered to be "bound". When a resource is no longer used in any pending 316 * or active command buffers, it is considered to be "unbound". 317 * 318 * If data resources are bound, it is unspecified when that data will be 319 * unbound unless you acquire a fence when submitting the command buffer and 320 * wait on it. However, this doesn't mean you need to track resource usage 321 * manually. 322 * 323 * All of the functions and structs that involve writing to a resource have a 324 * "cycle" bool. SDL_GPUTransferBuffer, SDL_GPUBuffer, and SDL_GPUTexture all 325 * effectively function as ring buffers on internal resources. When cycle is 326 * true, if the resource is bound, the cycle rotates to the next unbound 327 * internal resource, or if none are available, a new one is created. This 328 * means you don't have to worry about complex state tracking and 329 * synchronization as long as cycling is correctly employed. 330 * 331 * For example: you can call SDL_MapGPUTransferBuffer(), write texture data, 332 * SDL_UnmapGPUTransferBuffer(), and then SDL_UploadToGPUTexture(). The next 333 * time you write texture data to the transfer buffer, if you set the cycle 334 * param to true, you don't have to worry about overwriting any data that is 335 * not yet uploaded. 336 * 337 * Another example: If you are using a texture in a render pass every frame, 338 * this can cause a data dependency between frames. If you set cycle to true 339 * in the SDL_GPUColorTargetInfo struct, you can prevent this data dependency. 340 * 341 * Cycling will never undefine already bound data. When cycling, all data in 342 * the resource is considered to be undefined for subsequent commands until 343 * that data is written again. You must take care not to read undefined data. 344 * 345 * Note that when cycling a texture, the entire texture will be cycled, even 346 * if only part of the texture is used in the call, so you must consider the 347 * entire texture to contain undefined data after cycling. 348 * 349 * You must also take care not to overwrite a section of data that has been 350 * referenced in a command without cycling first. It is OK to overwrite 351 * unreferenced data in a bound resource without cycling, but overwriting a 352 * section of data that has already been referenced will produce unexpected 353 * results. 354 * 355 * ## Debugging 356 * 357 * At some point of your GPU journey, you will probably encounter issues that 358 * are not traceable with regular debugger - for example, your code compiles 359 * but you get an empty screen, or your shader fails in runtime. 360 * 361 * For debugging such cases, there are tools that allow visually inspecting 362 * the whole GPU frame, every drawcall, every bound resource, memory buffers, 363 * etc. They are the following, per platform: 364 * 365 * * For Windows/Linux, use 366 * [RenderDoc](https://renderdoc.org/) 367 * * For MacOS (Metal), use Xcode built-in debugger (Open XCode, go to Debug > 368 * Debug Executable..., select your application, set "GPU Frame Capture" to 369 * "Metal" in scheme "Options" window, run your app, and click the small 370 * Metal icon on the bottom to capture a frame) 371 * 372 * Aside from that, you may want to enable additional debug layers to receive 373 * more detailed error messages, based on your GPU backend: 374 * 375 * * For D3D12, the debug layer is an optional feature that can be installed 376 * via "Windows Settings -> System -> Optional features" and adding the 377 * "Graphics Tools" optional feature. 378 * * For Vulkan, you will need to install Vulkan SDK on Windows, and on Linux, 379 * you usually have some sort of `vulkan-validation-layers` system package 380 * that should be installed. 381 * * For Metal, it should be enough just to run the application from XCode to 382 * receive detailed errors or warnings in the output. 383 * 384 * Don't hesitate to use tools as RenderDoc when encountering runtime issues 385 * or unexpected output on screen, quick GPU frame inspection can usually help 386 * you fix the majority of such problems. 387 */ 388 389#ifndef SDL_gpu_h_ 390#define SDL_gpu_h_ 391 392#include <SDL3/SDL_stdinc.h> 393#include <SDL3/SDL_pixels.h> 394#include <SDL3/SDL_properties.h> 395#include <SDL3/SDL_rect.h> 396#include <SDL3/SDL_surface.h> 397#include <SDL3/SDL_video.h> 398 399#include <SDL3/SDL_begin_code.h> 400#ifdef __cplusplus 401extern "C" { 402#endif /* __cplusplus */ 403 404/* Type Declarations */ 405 406/** 407 * An opaque handle representing the SDL_GPU context. 408 * 409 * \since This struct is available since SDL 3.2.0. 410 */ 411typedef struct SDL_GPUDevice SDL_GPUDevice; 412 413/** 414 * An opaque handle representing a buffer. 415 * 416 * Used for vertices, indices, indirect draw commands, and general compute 417 * data. 418 * 419 * \since This struct is available since SDL 3.2.0. 420 * 421 * \sa SDL_CreateGPUBuffer 422 * \sa SDL_UploadToGPUBuffer 423 * \sa SDL_DownloadFromGPUBuffer 424 * \sa SDL_CopyGPUBufferToBuffer 425 * \sa SDL_BindGPUVertexBuffers 426 * \sa SDL_BindGPUIndexBuffer 427 * \sa SDL_BindGPUVertexStorageBuffers 428 * \sa SDL_BindGPUFragmentStorageBuffers 429 * \sa SDL_DrawGPUPrimitivesIndirect 430 * \sa SDL_DrawGPUIndexedPrimitivesIndirect 431 * \sa SDL_BindGPUComputeStorageBuffers 432 * \sa SDL_DispatchGPUComputeIndirect 433 * \sa SDL_ReleaseGPUBuffer 434 */ 435typedef struct SDL_GPUBuffer SDL_GPUBuffer; 436 437/** 438 * An opaque handle representing a transfer buffer. 439 * 440 * Used for transferring data to and from the device. 441 * 442 * \since This struct is available since SDL 3.2.0. 443 * 444 * \sa SDL_CreateGPUTransferBuffer 445 * \sa SDL_MapGPUTransferBuffer 446 * \sa SDL_UnmapGPUTransferBuffer 447 * \sa SDL_UploadToGPUBuffer 448 * \sa SDL_UploadToGPUTexture 449 * \sa SDL_DownloadFromGPUBuffer 450 * \sa SDL_DownloadFromGPUTexture 451 * \sa SDL_ReleaseGPUTransferBuffer 452 */ 453typedef struct SDL_GPUTransferBuffer SDL_GPUTransferBuffer; 454 455/** 456 * An opaque handle representing a texture. 457 * 458 * \since This struct is available since SDL 3.2.0. 459 * 460 * \sa SDL_CreateGPUTexture 461 * \sa SDL_UploadToGPUTexture 462 * \sa SDL_DownloadFromGPUTexture 463 * \sa SDL_CopyGPUTextureToTexture 464 * \sa SDL_BindGPUVertexSamplers 465 * \sa SDL_BindGPUVertexStorageTextures 466 * \sa SDL_BindGPUFragmentSamplers 467 * \sa SDL_BindGPUFragmentStorageTextures 468 * \sa SDL_BindGPUComputeStorageTextures 469 * \sa SDL_GenerateMipmapsForGPUTexture 470 * \sa SDL_BlitGPUTexture 471 * \sa SDL_ReleaseGPUTexture 472 */ 473typedef struct SDL_GPUTexture SDL_GPUTexture; 474 475/** 476 * An opaque handle representing a sampler. 477 * 478 * \since This struct is available since SDL 3.2.0. 479 * 480 * \sa SDL_CreateGPUSampler 481 * \sa SDL_BindGPUVertexSamplers 482 * \sa SDL_BindGPUFragmentSamplers 483 * \sa SDL_ReleaseGPUSampler 484 */ 485typedef struct SDL_GPUSampler SDL_GPUSampler; 486 487/** 488 * An opaque handle representing a compiled shader object. 489 * 490 * \since This struct is available since SDL 3.2.0. 491 * 492 * \sa SDL_CreateGPUShader 493 * \sa SDL_CreateGPUGraphicsPipeline 494 * \sa SDL_ReleaseGPUShader 495 */ 496typedef struct SDL_GPUShader SDL_GPUShader; 497 498/** 499 * An opaque handle representing a compute pipeline. 500 * 501 * Used during compute passes. 502 * 503 * \since This struct is available since SDL 3.2.0. 504 * 505 * \sa SDL_CreateGPUComputePipeline 506 * \sa SDL_BindGPUComputePipeline 507 * \sa SDL_ReleaseGPUComputePipeline 508 */ 509typedef struct SDL_GPUComputePipeline SDL_GPUComputePipeline; 510 511/** 512 * An opaque handle representing a graphics pipeline. 513 * 514 * Used during render passes. 515 * 516 * \since This struct is available since SDL 3.2.0. 517 * 518 * \sa SDL_CreateGPUGraphicsPipeline 519 * \sa SDL_BindGPUGraphicsPipeline 520 * \sa SDL_ReleaseGPUGraphicsPipeline 521 */ 522typedef struct SDL_GPUGraphicsPipeline SDL_GPUGraphicsPipeline; 523 524/** 525 * An opaque handle representing a command buffer. 526 * 527 * Most state is managed via command buffers. When setting state using a 528 * command buffer, that state is local to the command buffer. 529 * 530 * Commands only begin execution on the GPU once SDL_SubmitGPUCommandBuffer is 531 * called. Once the command buffer is submitted, it is no longer valid to use 532 * it. 533 * 534 * Command buffers are executed in submission order. If you submit command 535 * buffer A and then command buffer B all commands in A will begin executing 536 * before any command in B begins executing. 537 * 538 * In multi-threading scenarios, you should only access a command buffer on 539 * the thread you acquired it from. 540 * 541 * \since This struct is available since SDL 3.2.0. 542 * 543 * \sa SDL_AcquireGPUCommandBuffer 544 * \sa SDL_SubmitGPUCommandBuffer 545 * \sa SDL_SubmitGPUCommandBufferAndAcquireFence 546 */ 547typedef struct SDL_GPUCommandBuffer SDL_GPUCommandBuffer; 548 549/** 550 * An opaque handle representing a render pass. 551 * 552 * This handle is transient and should not be held or referenced after 553 * SDL_EndGPURenderPass is called. 554 * 555 * \since This struct is available since SDL 3.2.0. 556 * 557 * \sa SDL_BeginGPURenderPass 558 * \sa SDL_EndGPURenderPass 559 */ 560typedef struct SDL_GPURenderPass SDL_GPURenderPass; 561 562/** 563 * An opaque handle representing a compute pass. 564 * 565 * This handle is transient and should not be held or referenced after 566 * SDL_EndGPUComputePass is called. 567 * 568 * \since This struct is available since SDL 3.2.0. 569 * 570 * \sa SDL_BeginGPUComputePass 571 * \sa SDL_EndGPUComputePass 572 */ 573typedef struct SDL_GPUComputePass SDL_GPUComputePass; 574 575/** 576 * An opaque handle representing a copy pass. 577 * 578 * This handle is transient and should not be held or referenced after 579 * SDL_EndGPUCopyPass is called. 580 * 581 * \since This struct is available since SDL 3.2.0. 582 * 583 * \sa SDL_BeginGPUCopyPass 584 * \sa SDL_EndGPUCopyPass 585 */ 586typedef struct SDL_GPUCopyPass SDL_GPUCopyPass; 587 588/** 589 * An opaque handle representing a fence. 590 * 591 * \since This struct is available since SDL 3.2.0. 592 * 593 * \sa SDL_SubmitGPUCommandBufferAndAcquireFence 594 * \sa SDL_QueryGPUFence 595 * \sa SDL_WaitForGPUFences 596 * \sa SDL_ReleaseGPUFence 597 */ 598typedef struct SDL_GPUFence SDL_GPUFence; 599 600/** 601 * Specifies the primitive topology of a graphics pipeline. 602 * 603 * If you are using POINTLIST you must include a point size output in the 604 * vertex shader. 605 * 606 * - For HLSL compiling to SPIRV you must decorate a float output with 607 * [[vk::builtin("PointSize")]]. 608 * - For GLSL you must set the gl_PointSize builtin. 609 * - For MSL you must include a float output with the [[point_size]] 610 * decorator. 611 * 612 * Note that sized point topology is totally unsupported on D3D12. Any size 613 * other than 1 will be ignored. In general, you should avoid using point 614 * topology for both compatibility and performance reasons. You WILL regret 615 * using it. 616 * 617 * \since This enum is available since SDL 3.2.0. 618 * 619 * \sa SDL_CreateGPUGraphicsPipeline 620 */ 621typedef enum SDL_GPUPrimitiveType 622{ 623 SDL_GPU_PRIMITIVETYPE_TRIANGLELIST, /**< A series of separate triangles. */ 624 SDL_GPU_PRIMITIVETYPE_TRIANGLESTRIP, /**< A series of connected triangles. */ 625 SDL_GPU_PRIMITIVETYPE_LINELIST, /**< A series of separate lines. */ 626 SDL_GPU_PRIMITIVETYPE_LINESTRIP, /**< A series of connected lines. */ 627 SDL_GPU_PRIMITIVETYPE_POINTLIST /**< A series of separate points. */ 628} SDL_GPUPrimitiveType; 629 630/** 631 * Specifies how the contents of a texture attached to a render pass are 632 * treated at the beginning of the render pass. 633 * 634 * \since This enum is available since SDL 3.2.0. 635 * 636 * \sa SDL_BeginGPURenderPass 637 */ 638typedef enum SDL_GPULoadOp 639{ 640 SDL_GPU_LOADOP_LOAD, /**< The previous contents of the texture will be preserved. */ 641 SDL_GPU_LOADOP_CLEAR, /**< The contents of the texture will be cleared to a color. */ 642 SDL_GPU_LOADOP_DONT_CARE /**< The previous contents of the texture need not be preserved. The contents will be undefined. */ 643} SDL_GPULoadOp; 644 645/** 646 * Specifies how the contents of a texture attached to a render pass are 647 * treated at the end of the render pass. 648 * 649 * \since This enum is available since SDL 3.2.0. 650 * 651 * \sa SDL_BeginGPURenderPass 652 */ 653typedef enum SDL_GPUStoreOp 654{ 655 SDL_GPU_STOREOP_STORE, /**< The contents generated during the render pass will be written to memory. */ 656 SDL_GPU_STOREOP_DONT_CARE, /**< The contents generated during the render pass are not needed and may be discarded. The contents will be undefined. */ 657 SDL_GPU_STOREOP_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. */ 658 SDL_GPU_STOREOP_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. */ 659} SDL_GPUStoreOp; 660 661/** 662 * Specifies the size of elements in an index buffer. 663 * 664 * \since This enum is available since SDL 3.2.0. 665 * 666 * \sa SDL_CreateGPUGraphicsPipeline 667 */ 668typedef enum SDL_GPUIndexElementSize 669{ 670 SDL_GPU_INDEXELEMENTSIZE_16BIT, /**< The index elements are 16-bit. */ 671 SDL_GPU_INDEXELEMENTSIZE_32BIT /**< The index elements are 32-bit. */ 672} SDL_GPUIndexElementSize; 673 674/** 675 * Specifies the pixel format of a texture. 676 * 677 * Texture format support varies depending on driver, hardware, and usage 678 * flags. In general, you should use SDL_GPUTextureSupportsFormat to query if 679 * a format is supported before using it. However, there are a few guaranteed 680 * formats. 681 * 682 * FIXME: Check universal support for 32-bit component formats FIXME: Check 683 * universal support for SIMULTANEOUS_READ_WRITE 684 * 685 * For SAMPLER usage, the following formats are universally supported: 686 * 687 * - R8G8B8A8_UNORM 688 * - B8G8R8A8_UNORM 689 * - R8_UNORM 690 * - R8_SNORM 691 * - R8G8_UNORM 692 * - R8G8_SNORM 693 * - R8G8B8A8_SNORM 694 * - R16_FLOAT 695 * - R16G16_FLOAT 696 * - R16G16B16A16_FLOAT 697 * - R32_FLOAT 698 * - R32G32_FLOAT 699 * - R32G32B32A32_FLOAT 700 * - R11G11B10_UFLOAT 701 * - R8G8B8A8_UNORM_SRGB 702 * - B8G8R8A8_UNORM_SRGB 703 * - D16_UNORM 704 * 705 * For COLOR_TARGET usage, the following formats are universally supported: 706 * 707 * - R8G8B8A8_UNORM 708 * - B8G8R8A8_UNORM 709 * - R8_UNORM 710 * - R16_FLOAT 711 * - R16G16_FLOAT 712 * - R16G16B16A16_FLOAT 713 * - R32_FLOAT 714 * - R32G32_FLOAT 715 * - R32G32B32A32_FLOAT 716 * - R8_UINT 717 * - R8G8_UINT 718 * - R8G8B8A8_UINT 719 * - R16_UINT 720 * - R16G16_UINT 721 * - R16G16B16A16_UINT 722 * - R8_INT 723 * - R8G8_INT 724 * - R8G8B8A8_INT 725 * - R16_INT 726 * - R16G16_INT 727 * - R16G16B16A16_INT 728 * - R8G8B8A8_UNORM_SRGB 729 * - B8G8R8A8_UNORM_SRGB 730 * 731 * For STORAGE usages, the following formats are universally supported: 732 * 733 * - R8G8B8A8_UNORM 734 * - R8G8B8A8_SNORM 735 * - R16G16B16A16_FLOAT 736 * - R32_FLOAT 737 * - R32G32_FLOAT 738 * - R32G32B32A32_FLOAT 739 * - R8G8B8A8_UINT 740 * - R16G16B16A16_UINT 741 * - R8G8B8A8_INT 742 * - R16G16B16A16_INT 743 * 744 * For DEPTH_STENCIL_TARGET usage, the following formats are universally 745 * supported: 746 * 747 * - D16_UNORM 748 * - Either (but not necessarily both!) D24_UNORM or D32_FLOAT 749 * - Either (but not necessarily both!) D24_UNORM_S8_UINT or D32_FLOAT_S8_UINT 750 * 751 * Unless D16_UNORM is sufficient for your purposes, always check which of 752 * D24/D32 is supported before creating a depth-stencil texture! 753 * 754 * \since This enum is available since SDL 3.2.0. 755 * 756 * \sa SDL_CreateGPUTexture 757 * \sa SDL_GPUTextureSupportsFormat 758 */ 759typedef enum SDL_GPUTextureFormat 760{ 761 SDL_GPU_TEXTUREFORMAT_INVALID, 762 763 /* Unsigned Normalized Float Color Formats */ 764 SDL_GPU_TEXTUREFORMAT_A8_UNORM, 765 SDL_GPU_TEXTUREFORMAT_R8_UNORM, 766 SDL_GPU_TEXTUREFORMAT_R8G8_UNORM, 767 SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM, 768 SDL_GPU_TEXTUREFORMAT_R16_UNORM, 769 SDL_GPU_TEXTUREFORMAT_R16G16_UNORM, 770 SDL_GPU_TEXTUREFORMAT_R16G16B16A16_UNORM, 771 SDL_GPU_TEXTUREFORMAT_R10G10B10A2_UNORM, 772 SDL_GPU_TEXTUREFORMAT_B5G6R5_UNORM, 773 SDL_GPU_TEXTUREFORMAT_B5G5R5A1_UNORM, 774 SDL_GPU_TEXTUREFORMAT_B4G4R4A4_UNORM, 775 SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM, 776 /* Compressed Unsigned Normalized Float Color Formats */ 777 SDL_GPU_TEXTUREFORMAT_BC1_RGBA_UNORM, 778 SDL_GPU_TEXTUREFORMAT_BC2_RGBA_UNORM, 779 SDL_GPU_TEXTUREFORMAT_BC3_RGBA_UNORM, 780 SDL_GPU_TEXTUREFORMAT_BC4_R_UNORM, 781 SDL_GPU_TEXTUREFORMAT_BC5_RG_UNORM, 782 SDL_GPU_TEXTUREFORMAT_BC7_RGBA_UNORM, 783 /* Compressed Signed Float Color Formats */ 784 SDL_GPU_TEXTUREFORMAT_BC6H_RGB_FLOAT, 785 /* Compressed Unsigned Float Color Formats */ 786 SDL_GPU_TEXTUREFORMAT_BC6H_RGB_UFLOAT, 787 /* Signed Normalized Float Color Formats */ 788 SDL_GPU_TEXTUREFORMAT_R8_SNORM, 789 SDL_GPU_TEXTUREFORMAT_R8G8_SNORM, 790 SDL_GPU_TEXTUREFORMAT_R8G8B8A8_SNORM, 791 SDL_GPU_TEXTUREFORMAT_R16_SNORM, 792 SDL_GPU_TEXTUREFORMAT_R16G16_SNORM, 793 SDL_GPU_TEXTUREFORMAT_R16G16B16A16_SNORM, 794 /* Signed Float Color Formats */ 795 SDL_GPU_TEXTUREFORMAT_R16_FLOAT, 796 SDL_GPU_TEXTUREFORMAT_R16G16_FLOAT, 797 SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT, 798 SDL_GPU_TEXTUREFORMAT_R32_FLOAT, 799 SDL_GPU_TEXTUREFORMAT_R32G32_FLOAT, 800 SDL_GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT, 801 /* Unsigned Float Color Formats */ 802 SDL_GPU_TEXTUREFORMAT_R11G11B10_UFLOAT, 803 /* Unsigned Integer Color Formats */ 804 SDL_GPU_TEXTUREFORMAT_R8_UINT, 805 SDL_GPU_TEXTUREFORMAT_R8G8_UINT, 806 SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UINT, 807 SDL_GPU_TEXTUREFORMAT_R16_UINT, 808 SDL_GPU_TEXTUREFORMAT_R16G16_UINT, 809 SDL_GPU_TEXTUREFORMAT_R16G16B16A16_UINT, 810 SDL_GPU_TEXTUREFORMAT_R32_UINT, 811 SDL_GPU_TEXTUREFORMAT_R32G32_UINT, 812 SDL_GPU_TEXTUREFORMAT_R32G32B32A32_UINT, 813 /* Signed Integer Color Formats */ 814 SDL_GPU_TEXTUREFORMAT_R8_INT, 815 SDL_GPU_TEXTUREFORMAT_R8G8_INT, 816 SDL_GPU_TEXTUREFORMAT_R8G8B8A8_INT, 817 SDL_GPU_TEXTUREFORMAT_R16_INT, 818 SDL_GPU_TEXTUREFORMAT_R16G16_INT, 819 SDL_GPU_TEXTUREFORMAT_R16G16B16A16_INT, 820 SDL_GPU_TEXTUREFORMAT_R32_INT, 821 SDL_GPU_TEXTUREFORMAT_R32G32_INT, 822 SDL_GPU_TEXTUREFORMAT_R32G32B32A32_INT, 823 /* SRGB Unsigned Normalized Color Formats */ 824 SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM_SRGB, 825 SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM_SRGB, 826 /* Compressed SRGB Unsigned Normalized Color Formats */ 827 SDL_GPU_TEXTUREFORMAT_BC1_RGBA_UNORM_SRGB, 828 SDL_GPU_TEXTUREFORMAT_BC2_RGBA_UNORM_SRGB, 829 SDL_GPU_TEXTUREFORMAT_BC3_RGBA_UNORM_SRGB, 830 SDL_GPU_TEXTUREFORMAT_BC7_RGBA_UNORM_SRGB, 831 /* Depth Formats */ 832 SDL_GPU_TEXTUREFORMAT_D16_UNORM, 833 SDL_GPU_TEXTUREFORMAT_D24_UNORM, 834 SDL_GPU_TEXTUREFORMAT_D32_FLOAT, 835 SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT, 836 SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT, 837 /* Compressed ASTC Normalized Float Color Formats*/ 838 SDL_GPU_TEXTUREFORMAT_ASTC_4x4_UNORM, 839 SDL_GPU_TEXTUREFORMAT_ASTC_5x4_UNORM, 840 SDL_GPU_TEXTUREFORMAT_ASTC_5x5_UNORM, 841 SDL_GPU_TEXTUREFORMAT_ASTC_6x5_UNORM, 842 SDL_GPU_TEXTUREFORMAT_ASTC_6x6_UNORM, 843 SDL_GPU_TEXTUREFORMAT_ASTC_8x5_UNORM, 844 SDL_GPU_TEXTUREFORMAT_ASTC_8x6_UNORM, 845 SDL_GPU_TEXTUREFORMAT_ASTC_8x8_UNORM, 846 SDL_GPU_TEXTUREFORMAT_ASTC_10x5_UNORM, 847 SDL_GPU_TEXTUREFORMAT_ASTC_10x6_UNORM, 848 SDL_GPU_TEXTUREFORMAT_ASTC_10x8_UNORM, 849 SDL_GPU_TEXTUREFORMAT_ASTC_10x10_UNORM, 850 SDL_GPU_TEXTUREFORMAT_ASTC_12x10_UNORM, 851 SDL_GPU_TEXTUREFORMAT_ASTC_12x12_UNORM, 852 /* Compressed SRGB ASTC Normalized Float Color Formats*/ 853 SDL_GPU_TEXTUREFORMAT_ASTC_4x4_UNORM_SRGB, 854 SDL_GPU_TEXTUREFORMAT_ASTC_5x4_UNORM_SRGB, 855 SDL_GPU_TEXTUREFORMAT_ASTC_5x5_UNORM_SRGB, 856 SDL_GPU_TEXTUREFORMAT_ASTC_6x5_UNORM_SRGB, 857 SDL_GPU_TEXTUREFORMAT_ASTC_6x6_UNORM_SRGB, 858 SDL_GPU_TEXTUREFORMAT_ASTC_8x5_UNORM_SRGB, 859 SDL_GPU_TEXTUREFORMAT_ASTC_8x6_UNORM_SRGB, 860 SDL_GPU_TEXTUREFORMAT_ASTC_8x8_UNORM_SRGB, 861 SDL_GPU_TEXTUREFORMAT_ASTC_10x5_UNORM_SRGB, 862 SDL_GPU_TEXTUREFORMAT_ASTC_10x6_UNORM_SRGB, 863 SDL_GPU_TEXTUREFORMAT_ASTC_10x8_UNORM_SRGB, 864 SDL_GPU_TEXTUREFORMAT_ASTC_10x10_UNORM_SRGB, 865 SDL_GPU_TEXTUREFORMAT_ASTC_12x10_UNORM_SRGB, 866 SDL_GPU_TEXTUREFORMAT_ASTC_12x12_UNORM_SRGB, 867 /* Compressed ASTC Signed Float Color Formats*/ 868 SDL_GPU_TEXTUREFORMAT_ASTC_4x4_FLOAT, 869 SDL_GPU_TEXTUREFORMAT_ASTC_5x4_FLOAT, 870 SDL_GPU_TEXTUREFORMAT_ASTC_5x5_FLOAT, 871 SDL_GPU_TEXTUREFORMAT_ASTC_6x5_FLOAT, 872 SDL_GPU_TEXTUREFORMAT_ASTC_6x6_FLOAT, 873 SDL_GPU_TEXTUREFORMAT_ASTC_8x5_FLOAT, 874 SDL_GPU_TEXTUREFORMAT_ASTC_8x6_FLOAT, 875 SDL_GPU_TEXTUREFORMAT_ASTC_8x8_FLOAT, 876 SDL_GPU_TEXTUREFORMAT_ASTC_10x5_FLOAT, 877 SDL_GPU_TEXTUREFORMAT_ASTC_10x6_FLOAT, 878 SDL_GPU_TEXTUREFORMAT_ASTC_10x8_FLOAT, 879 SDL_GPU_TEXTUREFORMAT_ASTC_10x10_FLOAT, 880 SDL_GPU_TEXTUREFORMAT_ASTC_12x10_FLOAT, 881 SDL_GPU_TEXTUREFORMAT_ASTC_12x12_FLOAT 882} SDL_GPUTextureFormat; 883 884/** 885 * Specifies how a texture is intended to be used by the client. 886 * 887 * A texture must have at least one usage flag. Note that some usage flag 888 * combinations are invalid. 889 * 890 * With regards to compute storage usage, READ | WRITE means that you can have 891 * shader A that only writes into the texture and shader B that only reads 892 * from the texture and bind the same texture to either shader respectively. 893 * SIMULTANEOUS means that you can do reads and writes within the same shader 894 * or compute pass. It also implies that atomic ops can be used, since those 895 * are read-modify-write operations. If you use SIMULTANEOUS, you are 896 * responsible for avoiding data races, as there is no data synchronization 897 * within a compute pass. Note that SIMULTANEOUS usage is only supported by a 898 * limited number of texture formats. 899 * 900 * \since This datatype is available since SDL 3.2.0. 901 * 902 * \sa SDL_CreateGPUTexture 903 */ 904typedef Uint32 SDL_GPUTextureUsageFlags; 905 906#define SDL_GPU_TEXTUREUSAGE_SAMPLER (1u << 0) /**< Texture supports sampling. */ 907#define SDL_GPU_TEXTUREUSAGE_COLOR_TARGET (1u << 1) /**< Texture is a color render target. */ 908#define SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET (1u << 2) /**< Texture is a depth stencil target. */ 909#define SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ (1u << 3) /**< Texture supports storage reads in graphics stages. */ 910#define SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ (1u << 4) /**< Texture supports storage reads in the compute stage. */ 911#define SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE (1u << 5) /**< Texture supports storage writes in the compute stage. */ 912#define SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE (1u << 6) /**< Texture supports reads and writes in the same compute shader. This is NOT equivalent to READ | WRITE. */ 913 914/** 915 * Specifies the type of a texture. 916 * 917 * \since This enum is available since SDL 3.2.0. 918 * 919 * \sa SDL_CreateGPUTexture 920 */ 921typedef enum SDL_GPUTextureType 922{ 923 SDL_GPU_TEXTURETYPE_2D, /**< The texture is a 2-dimensional image. */ 924 SDL_GPU_TEXTURETYPE_2D_ARRAY, /**< The texture is a 2-dimensional array image. */ 925 SDL_GPU_TEXTURETYPE_3D, /**< The texture is a 3-dimensional image. */ 926 SDL_GPU_TEXTURETYPE_CUBE, /**< The texture is a cube image. */ 927 SDL_GPU_TEXTURETYPE_CUBE_ARRAY /**< The texture is a cube array image. */ 928} SDL_GPUTextureType; 929 930/** 931 * Specifies the sample count of a texture. 932 * 933 * Used in multisampling. Note that this value only applies when the texture 934 * is used as a render target. 935 * 936 * \since This enum is available since SDL 3.2.0. 937 * 938 * \sa SDL_CreateGPUTexture 939 * \sa SDL_GPUTextureSupportsSampleCount 940 */ 941typedef enum SDL_GPUSampleCount 942{ 943 SDL_GPU_SAMPLECOUNT_1, /**< No multisampling. */ 944 SDL_GPU_SAMPLECOUNT_2, /**< MSAA 2x */ 945 SDL_GPU_SAMPLECOUNT_4, /**< MSAA 4x */ 946 SDL_GPU_SAMPLECOUNT_8 /**< MSAA 8x */ 947} SDL_GPUSampleCount; 948 949 950/** 951 * Specifies the face of a cube map. 952 * 953 * Can be passed in as the layer field in texture-related structs. 954 * 955 * \since This enum is available since SDL 3.2.0. 956 */ 957typedef enum SDL_GPUCubeMapFace 958{ 959 SDL_GPU_CUBEMAPFACE_POSITIVEX, 960 SDL_GPU_CUBEMAPFACE_NEGATIVEX, 961 SDL_GPU_CUBEMAPFACE_POSITIVEY, 962 SDL_GPU_CUBEMAPFACE_NEGATIVEY, 963 SDL_GPU_CUBEMAPFACE_POSITIVEZ, 964 SDL_GPU_CUBEMAPFACE_NEGATIVEZ 965} SDL_GPUCubeMapFace; 966 967/** 968 * Specifies how a buffer is intended to be used by the client. 969 * 970 * A buffer must have at least one usage flag. Note that some usage flag 971 * combinations are invalid. 972 * 973 * Unlike textures, READ | WRITE can be used for simultaneous read-write 974 * usage. The same data synchronization concerns as textures apply. 975 * 976 * If you use a STORAGE flag, the data in the buffer must respect std140 977 * layout conventions. In practical terms this means you must ensure that vec3 978 * and vec4 fields are 16-byte aligned. 979 * 980 * \since This datatype is available since SDL 3.2.0. 981 * 982 * \sa SDL_CreateGPUBuffer 983 */ 984typedef Uint32 SDL_GPUBufferUsageFlags; 985 986#define SDL_GPU_BUFFERUSAGE_VERTEX (1u << 0) /**< Buffer is a vertex buffer. */ 987#define SDL_GPU_BUFFERUSAGE_INDEX (1u << 1) /**< Buffer is an index buffer. */ 988#define SDL_GPU_BUFFERUSAGE_INDIRECT (1u << 2) /**< Buffer is an indirect buffer. */ 989#define SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ (1u << 3) /**< Buffer supports storage reads in graphics stages. */ 990#define SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ (1u << 4) /**< Buffer supports storage reads in the compute stage. */ 991#define SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE (1u << 5) /**< Buffer supports storage writes in the compute stage. */ 992 993/** 994 * Specifies how a transfer buffer is intended to be used by the client. 995 * 996 * Note that mapping and copying FROM an upload transfer buffer or TO a 997 * download transfer buffer is undefined behavior. 998 * 999 * \since This enum is available since SDL 3.2.0. 1000 * 1001 * \sa SDL_CreateGPUTransferBuffer 1002 */ 1003typedef enum SDL_GPUTransferBufferUsage 1004{ 1005 SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD, 1006 SDL_GPU_TRANSFERBUFFERUSAGE_DOWNLOAD 1007} SDL_GPUTransferBufferUsage; 1008 1009/** 1010 * Specifies which stage a shader program corresponds to. 1011 * 1012 * \since This enum is available since SDL 3.2.0. 1013 * 1014 * \sa SDL_CreateGPUShader 1015 */ 1016typedef enum SDL_GPUShaderStage 1017{ 1018 SDL_GPU_SHADERSTAGE_VERTEX, 1019 SDL_GPU_SHADERSTAGE_FRAGMENT 1020} SDL_GPUShaderStage; 1021 1022/** 1023 * Specifies the format of shader code. 1024 * 1025 * Each format corresponds to a specific backend that accepts it. 1026 * 1027 * \since This datatype is available since SDL 3.2.0. 1028 * 1029 * \sa SDL_CreateGPUShader 1030 */ 1031typedef Uint32 SDL_GPUShaderFormat; 1032 1033#define SDL_GPU_SHADERFORMAT_INVALID 0 1034#define SDL_GPU_SHADERFORMAT_PRIVATE (1u << 0) /**< Shaders for NDA'd platforms. */ 1035#define SDL_GPU_SHADERFORMAT_SPIRV (1u << 1) /**< SPIR-V shaders for Vulkan. */ 1036#define SDL_GPU_SHADERFORMAT_DXBC (1u << 2) /**< DXBC SM5_1 shaders for D3D12. */ 1037#define SDL_GPU_SHADERFORMAT_DXIL (1u << 3) /**< DXIL SM6_0 shaders for D3D12. */ 1038#define SDL_GPU_SHADERFORMAT_MSL (1u << 4) /**< MSL shaders for Metal. */ 1039#define SDL_GPU_SHADERFORMAT_METALLIB (1u << 5) /**< Precompiled metallib shaders for Metal. */ 1040 1041/** 1042 * Specifies the format of a vertex attribute. 1043 * 1044 * \since This enum is available since SDL 3.2.0. 1045 * 1046 * \sa SDL_CreateGPUGraphicsPipeline 1047 */ 1048typedef enum SDL_GPUVertexElementFormat 1049{ 1050 SDL_GPU_VERTEXELEMENTFORMAT_INVALID, 1051 1052 /* 32-bit Signed Integers */ 1053 SDL_GPU_VERTEXELEMENTFORMAT_INT, 1054 SDL_GPU_VERTEXELEMENTFORMAT_INT2, 1055 SDL_GPU_VERTEXELEMENTFORMAT_INT3, 1056 SDL_GPU_VERTEXELEMENTFORMAT_INT4, 1057 1058 /* 32-bit Unsigned Integers */ 1059 SDL_GPU_VERTEXELEMENTFORMAT_UINT, 1060 SDL_GPU_VERTEXELEMENTFORMAT_UINT2, 1061 SDL_GPU_VERTEXELEMENTFORMAT_UINT3, 1062 SDL_GPU_VERTEXELEMENTFORMAT_UINT4, 1063 1064 /* 32-bit Floats */ 1065 SDL_GPU_VERTEXELEMENTFORMAT_FLOAT, 1066 SDL_GPU_VERTEXELEMENTFORMAT_FLOAT2, 1067 SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3, 1068 SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, 1069 1070 /* 8-bit Signed Integers */ 1071 SDL_GPU_VERTEXELEMENTFORMAT_BYTE2, 1072 SDL_GPU_VERTEXELEMENTFORMAT_BYTE4, 1073 1074 /* 8-bit Unsigned Integers */ 1075 SDL_GPU_VERTEXELEMENTFORMAT_UBYTE2, 1076 SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4, 1077 1078 /* 8-bit Signed Normalized */ 1079 SDL_GPU_VERTEXELEMENTFORMAT_BYTE2_NORM, 1080 SDL_GPU_VERTEXELEMENTFORMAT_BYTE4_NORM, 1081 1082 /* 8-bit Unsigned Normalized */ 1083 SDL_GPU_VERTEXELEMENTFORMAT_UBYTE2_NORM, 1084 SDL_GPU_VERTEXELEMENTFORMAT_UBYTE4_NORM, 1085 1086 /* 16-bit Signed Integers */ 1087 SDL_GPU_VERTEXELEMENTFORMAT_SHORT2, 1088 SDL_GPU_VERTEXELEMENTFORMAT_SHORT4, 1089 1090 /* 16-bit Unsigned Integers */ 1091 SDL_GPU_VERTEXELEMENTFORMAT_USHORT2, 1092 SDL_GPU_VERTEXELEMENTFORMAT_USHORT4, 1093 1094 /* 16-bit Signed Normalized */ 1095 SDL_GPU_VERTEXELEMENTFORMAT_SHORT2_NORM, 1096 SDL_GPU_VERTEXELEMENTFORMAT_SHORT4_NORM, 1097 1098 /* 16-bit Unsigned Normalized */ 1099 SDL_GPU_VERTEXELEMENTFORMAT_USHORT2_NORM, 1100 SDL_GPU_VERTEXELEMENTFORMAT_USHORT4_NORM, 1101 1102 /* 16-bit Floats */ 1103 SDL_GPU_VERTEXELEMENTFORMAT_HALF2, 1104 SDL_GPU_VERTEXELEMENTFORMAT_HALF4 1105} SDL_GPUVertexElementFormat; 1106 1107/** 1108 * Specifies the rate at which vertex attributes are pulled from buffers. 1109 * 1110 * \since This enum is available since SDL 3.2.0. 1111 * 1112 * \sa SDL_CreateGPUGraphicsPipeline 1113 */ 1114typedef enum SDL_GPUVertexInputRate 1115{ 1116 SDL_GPU_VERTEXINPUTRATE_VERTEX, /**< Attribute addressing is a function of the vertex index. */ 1117 SDL_GPU_VERTEXINPUTRATE_INSTANCE /**< Attribute addressing is a function of the instance index. */ 1118} SDL_GPUVertexInputRate; 1119 1120/** 1121 * Specifies the fill mode of the graphics pipeline. 1122 * 1123 * \since This enum is available since SDL 3.2.0. 1124 * 1125 * \sa SDL_CreateGPUGraphicsPipeline 1126 */ 1127typedef enum SDL_GPUFillMode 1128{ 1129 SDL_GPU_FILLMODE_FILL, /**< Polygons will be rendered via rasterization. */ 1130 SDL_GPU_FILLMODE_LINE /**< Polygon edges will be drawn as line segments. */ 1131} SDL_GPUFillMode; 1132 1133/** 1134 * Specifies the facing direction in which triangle faces will be culled. 1135 * 1136 * \since This enum is available since SDL 3.2.0. 1137 * 1138 * \sa SDL_CreateGPUGraphicsPipeline 1139 */ 1140typedef enum SDL_GPUCullMode 1141{ 1142 SDL_GPU_CULLMODE_NONE, /**< No triangles are culled. */ 1143 SDL_GPU_CULLMODE_FRONT, /**< Front-facing triangles are culled. */ 1144 SDL_GPU_CULLMODE_BACK /**< Back-facing triangles are culled. */ 1145} SDL_GPUCullMode; 1146 1147/** 1148 * Specifies the vertex winding that will cause a triangle to be determined to 1149 * be front-facing. 1150 * 1151 * \since This enum is available since SDL 3.2.0. 1152 * 1153 * \sa SDL_CreateGPUGraphicsPipeline 1154 */ 1155typedef enum SDL_GPUFrontFace 1156{ 1157 SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE, /**< A triangle with counter-clockwise vertex winding will be considered front-facing. */ 1158 SDL_GPU_FRONTFACE_CLOCKWISE /**< A triangle with clockwise vertex winding will be considered front-facing. */ 1159} SDL_GPUFrontFace; 1160 1161/** 1162 * Specifies a comparison operator for depth, stencil and sampler operations. 1163 * 1164 * \since This enum is available since SDL 3.2.0. 1165 * 1166 * \sa SDL_CreateGPUGraphicsPipeline 1167 */ 1168typedef enum SDL_GPUCompareOp 1169{ 1170 SDL_GPU_COMPAREOP_INVALID, 1171 SDL_GPU_COMPAREOP_NEVER, /**< The comparison always evaluates false. */ 1172 SDL_GPU_COMPAREOP_LESS, /**< The comparison evaluates reference < test. */ 1173 SDL_GPU_COMPAREOP_EQUAL, /**< The comparison evaluates reference == test. */ 1174 SDL_GPU_COMPAREOP_LESS_OR_EQUAL, /**< The comparison evaluates reference <= test. */ 1175 SDL_GPU_COMPAREOP_GREATER, /**< The comparison evaluates reference > test. */ 1176 SDL_GPU_COMPAREOP_NOT_EQUAL, /**< The comparison evaluates reference != test. */ 1177 SDL_GPU_COMPAREOP_GREATER_OR_EQUAL, /**< The comparison evaluates reference >= test. */ 1178 SDL_GPU_COMPAREOP_ALWAYS /**< The comparison always evaluates true. */ 1179} SDL_GPUCompareOp; 1180 1181/** 1182 * Specifies what happens to a stored stencil value if stencil tests fail or 1183 * pass. 1184 * 1185 * \since This enum is available since SDL 3.2.0. 1186 * 1187 * \sa SDL_CreateGPUGraphicsPipeline 1188 */ 1189typedef enum SDL_GPUStencilOp 1190{ 1191 SDL_GPU_STENCILOP_INVALID, 1192 SDL_GPU_STENCILOP_KEEP, /**< Keeps the current value. */ 1193 SDL_GPU_STENCILOP_ZERO, /**< Sets the value to 0. */ 1194 SDL_GPU_STENCILOP_REPLACE, /**< Sets the value to reference. */ 1195 SDL_GPU_STENCILOP_INCREMENT_AND_CLAMP, /**< Increments the current value and clamps to the maximum value. */ 1196 SDL_GPU_STENCILOP_DECREMENT_AND_CLAMP, /**< Decrements the current value and clamps to 0. */ 1197 SDL_GPU_STENCILOP_INVERT, /**< Bitwise-inverts the current value. */ 1198 SDL_GPU_STENCILOP_INCREMENT_AND_WRAP, /**< Increments the current value and wraps back to 0. */ 1199 SDL_GPU_STENCILOP_DECREMENT_AND_WRAP /**< Decrements the current value and wraps to the maximum value. */ 1200} SDL_GPUStencilOp; 1201 1202/** 1203 * Specifies the operator to be used when pixels in a render target are 1204 * blended with existing pixels in the texture. 1205 * 1206 * The source color is the value written by the fragment shader. The 1207 * destination color is the value currently existing in the texture. 1208 * 1209 * \since This enum is available since SDL 3.2.0. 1210 * 1211 * \sa SDL_CreateGPUGraphicsPipeline 1212 */ 1213typedef enum SDL_GPUBlendOp 1214{ 1215 SDL_GPU_BLENDOP_INVALID, 1216 SDL_GPU_BLENDOP_ADD, /**< (source * source_factor) + (destination * destination_factor) */ 1217 SDL_GPU_BLENDOP_SUBTRACT, /**< (source * source_factor) - (destination * destination_factor) */ 1218 SDL_GPU_BLENDOP_REVERSE_SUBTRACT, /**< (destination * destination_factor) - (source * source_factor) */ 1219 SDL_GPU_BLENDOP_MIN, /**< min(source, destination) */ 1220 SDL_GPU_BLENDOP_MAX /**< max(source, destination) */ 1221} SDL_GPUBlendOp; 1222 1223/** 1224 * Specifies a blending factor to be used when pixels in a render target are 1225 * blended with existing pixels in the texture. 1226 * 1227 * The source color is the value written by the fragment shader. The 1228 * destination color is the value currently existing in the texture. 1229 * 1230 * \since This enum is available since SDL 3.2.0. 1231 * 1232 * \sa SDL_CreateGPUGraphicsPipeline 1233 */ 1234typedef enum SDL_GPUBlendFactor 1235{ 1236 SDL_GPU_BLENDFACTOR_INVALID, 1237 SDL_GPU_BLENDFACTOR_ZERO, /**< 0 */ 1238 SDL_GPU_BLENDFACTOR_ONE, /**< 1 */ 1239 SDL_GPU_BLENDFACTOR_SRC_COLOR, /**< source color */ 1240 SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_COLOR, /**< 1 - source color */ 1241 SDL_GPU_BLENDFACTOR_DST_COLOR, /**< destination color */ 1242 SDL_GPU_BLENDFACTOR_ONE_MINUS_DST_COLOR, /**< 1 - destination color */ 1243 SDL_GPU_BLENDFACTOR_SRC_ALPHA, /**< source alpha */ 1244 SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA, /**< 1 - source alpha */ 1245 SDL_GPU_BLENDFACTOR_DST_ALPHA, /**< destination alpha */ 1246 SDL_GPU_BLENDFACTOR_ONE_MINUS_DST_ALPHA, /**< 1 - destination alpha */ 1247 SDL_GPU_BLENDFACTOR_CONSTANT_COLOR, /**< blend constant */ 1248 SDL_GPU_BLENDFACTOR_ONE_MINUS_CONSTANT_COLOR, /**< 1 - blend constant */ 1249 SDL_GPU_BLENDFACTOR_SRC_ALPHA_SATURATE /**< min(source alpha, 1 - destination alpha) */ 1250} SDL_GPUBlendFactor; 1251 1252/** 1253 * Specifies which color components are written in a graphics pipeline. 1254 * 1255 * \since This datatype is available since SDL 3.2.0. 1256 * 1257 * \sa SDL_CreateGPUGraphicsPipeline 1258 */ 1259typedef Uint8 SDL_GPUColorComponentFlags; 1260 1261#define SDL_GPU_COLORCOMPONENT_R (1u << 0) /**< the red component */ 1262#define SDL_GPU_COLORCOMPONENT_G (1u << 1) /**< the green component */ 1263#define SDL_GPU_COLORCOMPONENT_B (1u << 2) /**< the blue component */ 1264#define SDL_GPU_COLORCOMPONENT_A (1u << 3) /**< the alpha component */ 1265 1266/** 1267 * Specifies a filter operation used by a sampler. 1268 * 1269 * \since This enum is available since SDL 3.2.0. 1270 * 1271 * \sa SDL_CreateGPUSampler 1272 */ 1273typedef enum SDL_GPUFilter 1274{ 1275 SDL_GPU_FILTER_NEAREST, /**< Point filtering. */ 1276 SDL_GPU_FILTER_LINEAR /**< Linear filtering. */ 1277} SDL_GPUFilter; 1278 1279/** 1280 * Specifies a mipmap mode used by a sampler. 1281 * 1282 * \since This enum is available since SDL 3.2.0. 1283 * 1284 * \sa SDL_CreateGPUSampler 1285 */ 1286typedef enum SDL_GPUSamplerMipmapMode 1287{ 1288 SDL_GPU_SAMPLERMIPMAPMODE_NEAREST, /**< Point filtering. */ 1289 SDL_GPU_SAMPLERMIPMAPMODE_LINEAR /**< Linear filtering. */ 1290} SDL_GPUSamplerMipmapMode; 1291 1292/** 1293 * Specifies behavior of texture sampling when the coordinates exceed the 0-1 1294 * range. 1295 * 1296 * \since This enum is available since SDL 3.2.0. 1297 * 1298 * \sa SDL_CreateGPUSampler 1299 */ 1300typedef enum SDL_GPUSamplerAddressMode 1301{ 1302 SDL_GPU_SAMPLERADDRESSMODE_REPEAT, /**< Specifies that the coordinates will wrap around. */ 1303 SDL_GPU_SAMPLERADDRESSMODE_MIRRORED_REPEAT, /**< Specifies that the coordinates will wrap around mirrored. */ 1304 SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE /**< Specifies that the coordinates will clamp to the 0-1 range. */ 1305} SDL_GPUSamplerAddressMode; 1306 1307/** 1308 * Specifies the timing that will be used to present swapchain textures to the 1309 * OS. 1310 * 1311 * VSYNC mode will always be supported. IMMEDIATE and MAILBOX modes may not be 1312 * supported on certain systems. 1313 * 1314 * It is recommended to query SDL_WindowSupportsGPUPresentMode after claiming 1315 * the window if you wish to change the present mode to IMMEDIATE or MAILBOX. 1316 * 1317 * - VSYNC: Waits for vblank before presenting. No tearing is possible. If 1318 * there is a pending image to present, the new image is enqueued for 1319 * presentation. Disallows tearing at the cost of visual latency. 1320 * - IMMEDIATE: Immediately presents. Lowest latency option, but tearing may 1321 * occur. 1322 * - MAILBOX: Waits for vblank before presenting. No tearing is possible. If 1323 * there is a pending image to present, the pending image is replaced by the 1324 * new image. Similar to VSYNC, but with reduced visual latency. 1325 * 1326 * \since This enum is available since SDL 3.2.0. 1327 * 1328 * \sa SDL_SetGPUSwapchainParameters 1329 * \sa SDL_WindowSupportsGPUPresentMode 1330 * \sa SDL_WaitAndAcquireGPUSwapchainTexture 1331 */ 1332typedef enum SDL_GPUPresentMode 1333{ 1334 SDL_GPU_PRESENTMODE_VSYNC, 1335 SDL_GPU_PRESENTMODE_IMMEDIATE, 1336 SDL_GPU_PRESENTMODE_MAILBOX 1337} SDL_GPUPresentMode; 1338 1339/** 1340 * Specifies the texture format and colorspace of the swapchain textures. 1341 * 1342 * SDR will always be supported. Other compositions may not be supported on 1343 * certain systems. 1344 * 1345 * It is recommended to query SDL_WindowSupportsGPUSwapchainComposition after 1346 * claiming the window if you wish to change the swapchain composition from 1347 * SDR. 1348 * 1349 * - SDR: B8G8R8A8 or R8G8B8A8 swapchain. Pixel values are in sRGB encoding. 1350 * - SDR_LINEAR: B8G8R8A8_SRGB or R8G8B8A8_SRGB swapchain. Pixel values are 1351 * stored in memory in sRGB encoding but accessed in shaders in "linear 1352 * sRGB" encoding which is sRGB but with a linear transfer function. 1353 * - HDR_EXTENDED_LINEAR: R16G16B16A16_FLOAT swapchain. Pixel values are in 1354 * extended linear sRGB encoding and permits values outside of the [0, 1] 1355 * range. 1356 * - HDR10_ST2084: A2R10G10B10 or A2B10G10R10 swapchain. Pixel values are in 1357 * BT.2020 ST2084 (PQ) encoding. 1358 * 1359 * \since This enum is available since SDL 3.2.0. 1360 * 1361 * \sa SDL_SetGPUSwapchainParameters 1362 * \sa SDL_WindowSupportsGPUSwapchainComposition 1363 * \sa SDL_WaitAndAcquireGPUSwapchainTexture 1364 */ 1365typedef enum SDL_GPUSwapchainComposition 1366{ 1367 SDL_GPU_SWAPCHAINCOMPOSITION_SDR, 1368 SDL_GPU_SWAPCHAINCOMPOSITION_SDR_LINEAR, 1369 SDL_GPU_SWAPCHAINCOMPOSITION_HDR_EXTENDED_LINEAR, 1370 SDL_GPU_SWAPCHAINCOMPOSITION_HDR10_ST2084 1371} SDL_GPUSwapchainComposition; 1372 1373/* Structures */ 1374 1375/** 1376 * A structure specifying a viewport. 1377 * 1378 * \since This struct is available since SDL 3.2.0. 1379 * 1380 * \sa SDL_SetGPUViewport 1381 */ 1382typedef struct SDL_GPUViewport 1383{ 1384 float x; /**< The left offset of the viewport. */ 1385 float y; /**< The top offset of the viewport. */ 1386 float w; /**< The width of the viewport. */ 1387 float h; /**< The height of the viewport. */ 1388 float min_depth; /**< The minimum depth of the viewport. */ 1389 float max_depth; /**< The maximum depth of the viewport. */ 1390} SDL_GPUViewport; 1391 1392/** 1393 * A structure specifying parameters related to transferring data to or from a 1394 * texture. 1395 * 1396 * If either of `pixels_per_row` or `rows_per_layer` is zero, then width and 1397 * height of passed SDL_GPUTextureRegion to SDL_UploadToGPUTexture or 1398 * SDL_DownloadFromGPUTexture are used as default values respectively and data 1399 * is considered to be tightly packed. 1400 * 1401 * **WARNING**: On some older/integrated hardware, Direct3D 12 requires 1402 * texture data row pitch to be 256 byte aligned, and offsets to be aligned to 1403 * 512 bytes. If they are not, SDL will make a temporary copy of the data that 1404 * is properly aligned, but this adds overhead to the transfer process. Apps 1405 * can avoid this by aligning their data appropriately, or using a different 1406 * GPU backend than Direct3D 12. 1407 * 1408 * \since This struct is available since SDL 3.2.0. 1409 * 1410 * \sa SDL_UploadToGPUTexture 1411 * \sa SDL_DownloadFromGPUTexture 1412 */ 1413typedef struct SDL_GPUTextureTransferInfo 1414{ 1415 SDL_GPUTransferBuffer *transfer_buffer; /**< The transfer buffer used in the transfer operation. */ 1416 Uint32 offset; /**< The starting byte of the image data in the transfer buffer. */ 1417 Uint32 pixels_per_row; /**< The number of pixels from one row to the next. */ 1418 Uint32 rows_per_layer; /**< The number of rows from one layer/depth-slice to the next. */ 1419} SDL_GPUTextureTransferInfo; 1420 1421/** 1422 * A structure specifying a location in a transfer buffer. 1423 * 1424 * Used when transferring buffer data to or from a transfer buffer. 1425 * 1426 * \since This struct is available since SDL 3.2.0. 1427 * 1428 * \sa SDL_UploadToGPUBuffer 1429 * \sa SDL_DownloadFromGPUBuffer 1430 */ 1431typedef struct SDL_GPUTransferBufferLocation 1432{ 1433 SDL_GPUTransferBuffer *transfer_buffer; /**< The transfer buffer used in the transfer operation. */ 1434 Uint32 offset; /**< The starting byte of the buffer data in the transfer buffer. */ 1435} SDL_GPUTransferBufferLocation; 1436 1437/** 1438 * A structure specifying a location in a texture. 1439 * 1440 * Used when copying data from one texture to another. 1441 * 1442 * \since This struct is available since SDL 3.2.0. 1443 * 1444 * \sa SDL_CopyGPUTextureToTexture 1445 */ 1446typedef struct SDL_GPUTextureLocation 1447{ 1448 SDL_GPUTexture *texture; /**< The texture used in the copy operation. */ 1449 Uint32 mip_level; /**< The mip level index of the location. */ 1450 Uint32 layer; /**< The layer index of the location. */ 1451 Uint32 x; /**< The left offset of the location. */ 1452 Uint32 y; /**< The top offset of the location. */ 1453 Uint32 z; /**< The front offset of the location. */ 1454} SDL_GPUTextureLocation; 1455 1456/** 1457 * A structure specifying a region of a texture. 1458 * 1459 * Used when transferring data to or from a texture. 1460 * 1461 * \since This struct is available since SDL 3.2.0. 1462 * 1463 * \sa SDL_UploadToGPUTexture 1464 * \sa SDL_DownloadFromGPUTexture 1465 * \sa SDL_CreateGPUTexture 1466 */ 1467typedef struct SDL_GPUTextureRegion 1468{ 1469 SDL_GPUTexture *texture; /**< The texture used in the copy operation. */ 1470 Uint32 mip_level; /**< The mip level index to transfer. */ 1471 Uint32 layer; /**< The layer index to transfer. */ 1472 Uint32 x; /**< The left offset of the region. */ 1473 Uint32 y; /**< The top offset of the region. */ 1474 Uint32 z; /**< The front offset of the region. */ 1475 Uint32 w; /**< The width of the region. */ 1476 Uint32 h; /**< The height of the region. */ 1477 Uint32 d; /**< The depth of the region. */ 1478} SDL_GPUTextureRegion; 1479 1480/** 1481 * A structure specifying a region of a texture used in the blit operation. 1482 * 1483 * \since This struct is available since SDL 3.2.0. 1484 * 1485 * \sa SDL_BlitGPUTexture 1486 */ 1487typedef struct SDL_GPUBlitRegion 1488{ 1489 SDL_GPUTexture *texture; /**< The texture. */ 1490 Uint32 mip_level; /**< The mip level index of the region. */ 1491 Uint32 layer_or_depth_plane; /**< 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. */ 1492 Uint32 x; /**< The left offset of the region. */ 1493 Uint32 y; /**< The top offset of the region. */ 1494 Uint32 w; /**< The width of the region. */ 1495 Uint32 h; /**< The height of the region. */ 1496} SDL_GPUBlitRegion; 1497 1498/** 1499 * A structure specifying a location in a buffer. 1500 * 1501 * Used when copying data between buffers. 1502 * 1503 * \since This struct is available since SDL 3.2.0. 1504 * 1505 * \sa SDL_CopyGPUBufferToBuffer 1506 */ 1507typedef struct SDL_GPUBufferLocation 1508{ 1509 SDL_GPUBuffer *buffer; /**< The buffer. */ 1510 Uint32 offset; /**< The starting byte within the buffer. */ 1511} SDL_GPUBufferLocation; 1512 1513/** 1514 * A structure specifying a region of a buffer. 1515 * 1516 * Used when transferring data to or from buffers. 1517 * 1518 * \since This struct is available since SDL 3.2.0. 1519 * 1520 * \sa SDL_UploadToGPUBuffer 1521 * \sa SDL_DownloadFromGPUBuffer 1522 */ 1523typedef struct SDL_GPUBufferRegion 1524{ 1525 SDL_GPUBuffer *buffer; /**< The buffer. */ 1526 Uint32 offset; /**< The starting byte within the buffer. */ 1527 Uint32 size; /**< The size in bytes of the region. */ 1528} SDL_GPUBufferRegion; 1529 1530/** 1531 * A structure specifying the parameters of an indirect draw command. 1532 * 1533 * Note that the `first_vertex` and `first_instance` parameters are NOT 1534 * compatible with built-in vertex/instance ID variables in shaders (for 1535 * example, SV_VertexID); GPU APIs and shader languages do not define these 1536 * built-in variables consistently, so if your shader depends on them, the 1537 * only way to keep behavior consistent and portable is to always pass 0 for 1538 * the correlating parameter in the draw calls. 1539 * 1540 * \since This struct is available since SDL 3.2.0. 1541 * 1542 * \sa SDL_DrawGPUPrimitivesIndirect 1543 */ 1544typedef struct SDL_GPUIndirectDrawCommand 1545{ 1546 Uint32 num_vertices; /**< The number of vertices to draw. */ 1547 Uint32 num_instances; /**< The number of instances to draw. */ 1548 Uint32 first_vertex; /**< The index of the first vertex to draw. */ 1549 Uint32 first_instance; /**< The ID of the first instance to draw. */ 1550} SDL_GPUIndirectDrawCommand; 1551 1552/** 1553 * A structure specifying the parameters of an indexed indirect draw command. 1554 * 1555 * Note that the `first_vertex` and `first_instance` parameters are NOT 1556 * compatible with built-in vertex/instance ID variables in shaders (for 1557 * example, SV_VertexID); GPU APIs and shader languages do not define these 1558 * built-in variables consistently, so if your shader depends on them, the 1559 * only way to keep behavior consistent and portable is to always pass 0 for 1560 * the correlating parameter in the draw calls. 1561 * 1562 * \since This struct is available since SDL 3.2.0. 1563 * 1564 * \sa SDL_DrawGPUIndexedPrimitivesIndirect 1565 */ 1566typedef struct SDL_GPUIndexedIndirectDrawCommand 1567{ 1568 Uint32 num_indices; /**< The number of indices to draw per instance. */ 1569 Uint32 num_instances; /**< The number of instances to draw. */ 1570 Uint32 first_index; /**< The base index within the index buffer. */ 1571 Sint32 vertex_offset; /**< The value added to the vertex index before indexing into the vertex buffer. */ 1572 Uint32 first_instance; /**< The ID of the first instance to draw. */ 1573} SDL_GPUIndexedIndirectDrawCommand; 1574 1575/** 1576 * A structure specifying the parameters of an indexed dispatch command. 1577 * 1578 * \since This struct is available since SDL 3.2.0. 1579 * 1580 * \sa SDL_DispatchGPUComputeIndirect 1581 */ 1582typedef struct SDL_GPUIndirectDispatchCommand 1583{ 1584 Uint32 groupcount_x; /**< The number of local workgroups to dispatch in the X dimension. */ 1585 Uint32 groupcount_y; /**< The number of local workgroups to dispatch in the Y dimension. */ 1586 Uint32 groupcount_z; /**< The number of local workgroups to dispatch in the Z dimension. */ 1587} SDL_GPUIndirectDispatchCommand; 1588 1589/* State structures */ 1590 1591/** 1592 * A structure specifying the parameters of a sampler. 1593 * 1594 * Note that mip_lod_bias is a no-op for the Metal driver. For Metal, LOD bias 1595 * must be applied via shader instead. 1596 * 1597 * \since This function is available since SDL 3.2.0. 1598 * 1599 * \sa SDL_CreateGPUSampler 1600 * \sa SDL_GPUFilter 1601 * \sa SDL_GPUSamplerMipmapMode 1602 * \sa SDL_GPUSamplerAddressMode 1603 * \sa SDL_GPUCompareOp 1604 */ 1605typedef struct SDL_GPUSamplerCreateInfo 1606{ 1607 SDL_GPUFilter min_filter; /**< The minification filter to apply to lookups. */ 1608 SDL_GPUFilter mag_filter; /**< The magnification filter to apply to lookups. */ 1609 SDL_GPUSamplerMipmapMode mipmap_mode; /**< The mipmap filter to apply to lookups. */ 1610 SDL_GPUSamplerAddressMode address_mode_u; /**< The addressing mode for U coordinates outside [0, 1). */ 1611 SDL_GPUSamplerAddressMode address_mode_v; /**< The addressing mode for V coordinates outside [0, 1). */ 1612 SDL_GPUSamplerAddressMode address_mode_w; /**< The addressing mode for W coordinates outside [0, 1). */ 1613 float mip_lod_bias; /**< The bias to be added to mipmap LOD calculation. */ 1614 float max_anisotropy; /**< The anisotropy value clamp used by the sampler. If enable_anisotropy is false, this is ignored. */ 1615 SDL_GPUCompareOp compare_op; /**< The comparison operator to apply to fetched data before filtering. */ 1616 float min_lod; /**< Clamps the minimum of the computed LOD value. */ 1617 float max_lod; /**< Clamps the maximum of the computed LOD value. */ 1618 bool enable_anisotropy; /**< true to enable anisotropic filtering. */ 1619 bool enable_compare; /**< true to enable comparison against a reference value during lookups. */ 1620 Uint8 padding1; 1621 Uint8 padding2; 1622 1623 SDL_PropertiesID props; /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ 1624} SDL_GPUSamplerCreateInfo; 1625 1626/** 1627 * A structure specifying the parameters of vertex buffers used in a graphics 1628 * pipeline. 1629 * 1630 * When you call SDL_BindGPUVertexBuffers, you specify the binding slots of 1631 * the vertex buffers. For example if you called SDL_BindGPUVertexBuffers with 1632 * a first_slot of 2 and num_bindings of 3, the binding slots 2, 3, 4 would be 1633 * used by the vertex buffers you pass in. 1634 * 1635 * Vertex attributes are linked to buffers via the buffer_slot field of 1636 * SDL_GPUVertexAttribute. For example, if an attribute has a buffer_slot of 1637 * 0, then that attribute belongs to the vertex buffer bound at slot 0. 1638 * 1639 * \since This struct is available since SDL 3.2.0. 1640 * 1641 * \sa SDL_GPUVertexAttribute 1642 * \sa SDL_GPUVertexInputRate 1643 */ 1644typedef struct SDL_GPUVertexBufferDescription 1645{ 1646 Uint32 slot; /**< The binding slot of the vertex buffer. */ 1647 Uint32 pitch; /**< The size of a single element + the offset between elements. */ 1648 SDL_GPUVertexInputRate input_rate; /**< Whether attribute addressing is a function of the vertex index or instance index. */ 1649 Uint32 instance_step_rate; /**< Reserved for future use. Must be set to 0. */ 1650} SDL_GPUVertexBufferDescription; 1651 1652/** 1653 * A structure specifying a vertex attribute. 1654 * 1655 * All vertex attribute locations provided to an SDL_GPUVertexInputState must 1656 * be unique. 1657 * 1658 * \since This struct is available since SDL 3.2.0. 1659 * 1660 * \sa SDL_GPUVertexBufferDescription 1661 * \sa SDL_GPUVertexInputState 1662 * \sa SDL_GPUVertexElementFormat 1663 */ 1664typedef struct SDL_GPUVertexAttribute 1665{ 1666 Uint32 location; /**< The shader input location index. */ 1667 Uint32 buffer_slot; /**< The binding slot of the associated vertex buffer. */ 1668 SDL_GPUVertexElementFormat format; /**< The size and type of the attribute data. */ 1669 Uint32 offset; /**< The byte offset of this attribute relative to the start of the vertex element. */ 1670} SDL_GPUVertexAttribute; 1671 1672/** 1673 * A structure specifying the parameters of a graphics pipeline vertex input 1674 * state. 1675 * 1676 * \since This struct is available since SDL 3.2.0. 1677 * 1678 * \sa SDL_GPUGraphicsPipelineCreateInfo 1679 * \sa SDL_GPUVertexBufferDescription 1680 * \sa SDL_GPUVertexAttribute 1681 */ 1682typedef struct SDL_GPUVertexInputState 1683{ 1684 const SDL_GPUVertexBufferDescription *vertex_buffer_descriptions; /**< A pointer to an array of vertex buffer descriptions. */ 1685 Uint32 num_vertex_buffers; /**< The number of vertex buffer descriptions in the above array. */ 1686 const SDL_GPUVertexAttribute *vertex_attributes; /**< A pointer to an array of vertex attribute descriptions. */ 1687 Uint32 num_vertex_attributes; /**< The number of vertex attribute descriptions in the above array. */ 1688} SDL_GPUVertexInputState; 1689 1690/** 1691 * A structure specifying the stencil operation state of a graphics pipeline. 1692 * 1693 * \since This struct is available since SDL 3.2.0. 1694 * 1695 * \sa SDL_GPUDepthStencilState 1696 */ 1697typedef struct SDL_GPUStencilOpState 1698{ 1699 SDL_GPUStencilOp fail_op; /**< The action performed on samples that fail the stencil test. */ 1700 SDL_GPUStencilOp pass_op; /**< The action performed on samples that pass the depth and stencil tests. */ 1701 SDL_GPUStencilOp depth_fail_op; /**< The action performed on samples that pass the stencil test and fail the depth test. */ 1702 SDL_GPUCompareOp compare_op; /**< The comparison operator used in the stencil test. */ 1703} SDL_GPUStencilOpState; 1704 1705/** 1706 * A structure specifying the blend state of a color target. 1707 * 1708 * \since This struct is available since SDL 3.2.0. 1709 * 1710 * \sa SDL_GPUColorTargetDescription 1711 * \sa SDL_GPUBlendFactor 1712 * \sa SDL_GPUBlendOp 1713 * \sa SDL_GPUColorComponentFlags 1714 */ 1715typedef struct SDL_GPUColorTargetBlendState 1716{ 1717 SDL_GPUBlendFactor src_color_blendfactor; /**< The value to be multiplied by the source RGB value. */ 1718 SDL_GPUBlendFactor dst_color_blendfactor; /**< The value to be multiplied by the destination RGB value. */ 1719 SDL_GPUBlendOp color_blend_op; /**< The blend operation for the RGB components. */ 1720 SDL_GPUBlendFactor src_alpha_blendfactor; /**< The value to be multiplied by the source alpha. */ 1721 SDL_GPUBlendFactor dst_alpha_blendfactor; /**< The value to be multiplied by the destination alpha. */ 1722 SDL_GPUBlendOp alpha_blend_op; /**< The blend operation for the alpha component. */ 1723 SDL_GPUColorComponentFlags color_write_mask; /**< A bitmask specifying which of the RGBA components are enabled for writing. Writes to all channels if enable_color_write_mask is false. */ 1724 bool enable_blend; /**< Whether blending is enabled for the color target. */ 1725 bool enable_color_write_mask; /**< Whether the color write mask is enabled. */ 1726 Uint8 padding1; 1727 Uint8 padding2; 1728} SDL_GPUColorTargetBlendState; 1729 1730 1731/** 1732 * A structure specifying code and metadata for creating a shader object. 1733 * 1734 * \since This struct is available since SDL 3.2.0. 1735 * 1736 * \sa SDL_CreateGPUShader 1737 * \sa SDL_GPUShaderFormat 1738 * \sa SDL_GPUShaderStage 1739 */ 1740typedef struct SDL_GPUShaderCreateInfo 1741{ 1742 size_t code_size; /**< The size in bytes of the code pointed to. */ 1743 const Uint8 *code; /**< A pointer to shader code. */ 1744 const char *entrypoint; /**< A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. */ 1745 SDL_GPUShaderFormat format; /**< The format of the shader code. */ 1746 SDL_GPUShaderStage stage; /**< The stage the shader program corresponds to. */ 1747 Uint32 num_samplers; /**< The number of samplers defined in the shader. */ 1748 Uint32 num_storage_textures; /**< The number of storage textures defined in the shader. */ 1749 Uint32 num_storage_buffers; /**< The number of storage buffers defined in the shader. */ 1750 Uint32 num_uniform_buffers; /**< The number of uniform buffers defined in the shader. */ 1751 1752 SDL_PropertiesID props; /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ 1753} SDL_GPUShaderCreateInfo; 1754 1755/** 1756 * A structure specifying the parameters of a texture. 1757 * 1758 * Usage flags can be bitwise OR'd together for combinations of usages. Note 1759 * that certain usage combinations are invalid, for example SAMPLER and 1760 * GRAPHICS_STORAGE. 1761 * 1762 * \since This struct is available since SDL 3.2.0. 1763 * 1764 * \sa SDL_CreateGPUTexture 1765 * \sa SDL_GPUTextureType 1766 * \sa SDL_GPUTextureFormat 1767 * \sa SDL_GPUTextureUsageFlags 1768 * \sa SDL_GPUSampleCount 1769 */ 1770typedef struct SDL_GPUTextureCreateInfo 1771{ 1772 SDL_GPUTextureType type; /**< The base dimensionality of the texture. */ 1773 SDL_GPUTextureFormat format; /**< The pixel format of the texture. */ 1774 SDL_GPUTextureUsageFlags usage; /**< How the texture is intended to be used by the client. */ 1775 Uint32 width; /**< The width of the texture. */ 1776 Uint32 height; /**< The height of the texture. */ 1777 Uint32 layer_count_or_depth; /**< 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. */ 1778 Uint32 num_levels; /**< The number of mip levels in the texture. */ 1779 SDL_GPUSampleCount sample_count; /**< The number of samples per texel. Only applies if the texture is used as a render target. */ 1780 1781 SDL_PropertiesID props; /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ 1782} SDL_GPUTextureCreateInfo; 1783 1784/** 1785 * A structure specifying the parameters of a buffer. 1786 * 1787 * Usage flags can be bitwise OR'd together for combinations of usages. Note 1788 * that certain combinations are invalid, for example VERTEX and INDEX. 1789 * 1790 * \since This struct is available since SDL 3.2.0. 1791 * 1792 * \sa SDL_CreateGPUBuffer 1793 * \sa SDL_GPUBufferUsageFlags 1794 */ 1795typedef struct SDL_GPUBufferCreateInfo 1796{ 1797 SDL_GPUBufferUsageFlags usage; /**< How the buffer is intended to be used by the client. */ 1798 Uint32 size; /**< The size in bytes of the buffer. */ 1799 1800 SDL_PropertiesID props; /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ 1801} SDL_GPUBufferCreateInfo; 1802 1803/** 1804 * A structure specifying the parameters of a transfer buffer. 1805 * 1806 * \since This struct is available since SDL 3.2.0. 1807 * 1808 * \sa SDL_GPUTransferBufferUsage 1809 * \sa SDL_CreateGPUTransferBuffer 1810 */ 1811typedef struct SDL_GPUTransferBufferCreateInfo 1812{ 1813 SDL_GPUTransferBufferUsage usage; /**< How the transfer buffer is intended to be used by the client. */ 1814 Uint32 size; /**< The size in bytes of the transfer buffer. */ 1815 1816 SDL_PropertiesID props; /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ 1817} SDL_GPUTransferBufferCreateInfo; 1818 1819/* Pipeline state structures */ 1820 1821/** 1822 * A structure specifying the parameters of the graphics pipeline rasterizer 1823 * state. 1824 * 1825 * Note that SDL_GPU_FILLMODE_LINE is not supported on many Android devices. 1826 * For those devices, the fill mode will automatically fall back to FILL. 1827 * 1828 * Also note that the D3D12 driver will enable depth clamping even if 1829 * enable_depth_clip is true. If you need this clamp+clip behavior, consider 1830 * enabling depth clip and then manually clamping depth in your fragment 1831 * shaders on Metal and Vulkan. 1832 * 1833 * \since This struct is available since SDL 3.2.0. 1834 * 1835 * \sa SDL_GPUGraphicsPipelineCreateInfo 1836 */ 1837typedef struct SDL_GPURasterizerState 1838{ 1839 SDL_GPUFillMode fill_mode; /**< Whether polygons will be filled in or drawn as lines. */ 1840 SDL_GPUCullMode cull_mode; /**< The facing direction in which triangles will be culled. */ 1841 SDL_GPUFrontFace front_face; /**< The vertex winding that will cause a triangle to be determined as front-facing. */ 1842 float depth_bias_constant_factor; /**< A scalar factor controlling the depth value added to each fragment. */ 1843 float depth_bias_clamp; /**< The maximum depth bias of a fragment. */ 1844 float depth_bias_slope_factor; /**< A scalar factor applied to a fragment's slope in depth calculations. */ 1845 bool enable_depth_bias; /**< true to bias fragment depth values. */ 1846 bool enable_depth_clip; /**< true to enable depth clip, false to enable depth clamp. */ 1847 Uint8 padding1; 1848 Uint8 padding2; 1849} SDL_GPURasterizerState; 1850 1851/** 1852 * A structure specifying the parameters of the graphics pipeline multisample 1853 * state. 1854 * 1855 * \since This struct is available since SDL 3.2.0. 1856 * 1857 * \sa SDL_GPUGraphicsPipelineCreateInfo 1858 */ 1859typedef struct SDL_GPUMultisampleState 1860{ 1861 SDL_GPUSampleCount sample_count; /**< The number of samples to be used in rasterization. */ 1862 Uint32 sample_mask; /**< Reserved for future use. Must be set to 0. */ 1863 bool enable_mask; /**< Reserved for future use. Must be set to false. */ 1864 bool enable_alpha_to_coverage; /**< true enables the alpha-to-coverage feature. */ 1865 Uint8 padding2; 1866 Uint8 padding3; 1867} SDL_GPUMultisampleState; 1868 1869/** 1870 * A structure specifying the parameters of the graphics pipeline depth 1871 * stencil state. 1872 * 1873 * \since This struct is available since SDL 3.2.0. 1874 * 1875 * \sa SDL_GPUGraphicsPipelineCreateInfo 1876 */ 1877typedef struct SDL_GPUDepthStencilState 1878{ 1879 SDL_GPUCompareOp compare_op; /**< The comparison operator used for depth testing. */ 1880 SDL_GPUStencilOpState back_stencil_state; /**< The stencil op state for back-facing triangles. */ 1881 SDL_GPUStencilOpState front_stencil_state; /**< The stencil op state for front-facing triangles. */ 1882 Uint8 compare_mask; /**< Selects the bits of the stencil values participating in the stencil test. */ 1883 Uint8 write_mask; /**< Selects the bits of the stencil values updated by the stencil test. */ 1884 bool enable_depth_test; /**< true enables the depth test. */ 1885 bool enable_depth_write; /**< true enables depth writes. Depth writes are always disabled when enable_depth_test is false. */ 1886 bool enable_stencil_test; /**< true enables the stencil test. */ 1887 Uint8 padding1; 1888 Uint8 padding2; 1889 Uint8 padding3; 1890} SDL_GPUDepthStencilState; 1891 1892/** 1893 * A structure specifying the parameters of color targets used in a graphics 1894 * pipeline. 1895 * 1896 * \since This struct is available since SDL 3.2.0. 1897 * 1898 * \sa SDL_GPUGraphicsPipelineTargetInfo 1899 */ 1900typedef struct SDL_GPUColorTargetDescription 1901{ 1902 SDL_GPUTextureFormat format; /**< The pixel format of the texture to be used as a color target. */ 1903 SDL_GPUColorTargetBlendState blend_state; /**< The blend state to be used for the color target. */ 1904} SDL_GPUColorTargetDescription; 1905 1906/** 1907 * A structure specifying the descriptions of render targets used in a 1908 * graphics pipeline. 1909 * 1910 * \since This struct is available since SDL 3.2.0. 1911 * 1912 * \sa SDL_GPUGraphicsPipelineCreateInfo 1913 * \sa SDL_GPUColorTargetDescription 1914 * \sa SDL_GPUTextureFormat 1915 */ 1916typedef struct SDL_GPUGraphicsPipelineTargetInfo 1917{ 1918 const SDL_GPUColorTargetDescription *color_target_descriptions; /**< A pointer to an array of color target descriptions. */ 1919 Uint32 num_color_targets; /**< The number of color target descriptions in the above array. */ 1920 SDL_GPUTextureFormat depth_stencil_format; /**< The pixel format of the depth-stencil target. Ignored if has_depth_stencil_target is false. */ 1921 bool has_depth_stencil_target; /**< true specifies that the pipeline uses a depth-stencil target. */ 1922 Uint8 padding1; 1923 Uint8 padding2; 1924 Uint8 padding3; 1925} SDL_GPUGraphicsPipelineTargetInfo; 1926 1927/** 1928 * A structure specifying the parameters of a graphics pipeline state. 1929 * 1930 * \since This struct is available since SDL 3.2.0. 1931 * 1932 * \sa SDL_CreateGPUGraphicsPipeline 1933 * \sa SDL_GPUShader 1934 * \sa SDL_GPUVertexInputState 1935 * \sa SDL_GPUPrimitiveType 1936 * \sa SDL_GPURasterizerState 1937 * \sa SDL_GPUMultisampleState 1938 * \sa SDL_GPUDepthStencilState 1939 * \sa SDL_GPUGraphicsPipelineTargetInfo 1940 */ 1941typedef struct SDL_GPUGraphicsPipelineCreateInfo 1942{ 1943 SDL_GPUShader *vertex_shader; /**< The vertex shader used by the graphics pipeline. */ 1944 SDL_GPUShader *fragment_shader; /**< The fragment shader used by the graphics pipeline. */ 1945 SDL_GPUVertexInputState vertex_input_state; /**< The vertex layout of the graphics pipeline. */ 1946 SDL_GPUPrimitiveType primitive_type; /**< The primitive topology of the graphics pipeline. */ 1947 SDL_GPURasterizerState rasterizer_state; /**< The rasterizer state of the graphics pipeline. */ 1948 SDL_GPUMultisampleState multisample_state; /**< The multisample state of the graphics pipeline. */ 1949 SDL_GPUDepthStencilState depth_stencil_state; /**< The depth-stencil state of the graphics pipeline. */ 1950 SDL_GPUGraphicsPipelineTargetInfo target_info; /**< Formats and blend modes for the render targets of the graphics pipeline. */ 1951 1952 SDL_PropertiesID props; /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ 1953} SDL_GPUGraphicsPipelineCreateInfo; 1954 1955/** 1956 * A structure specifying the parameters of a compute pipeline state. 1957 * 1958 * \since This struct is available since SDL 3.2.0. 1959 * 1960 * \sa SDL_CreateGPUComputePipeline 1961 * \sa SDL_GPUShaderFormat 1962 */ 1963typedef struct SDL_GPUComputePipelineCreateInfo 1964{ 1965 size_t code_size; /**< The size in bytes of the compute shader code pointed to. */ 1966 const Uint8 *code; /**< A pointer to compute shader code. */ 1967 const char *entrypoint; /**< A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. */ 1968 SDL_GPUShaderFormat format; /**< The format of the compute shader code. */ 1969 Uint32 num_samplers; /**< The number of samplers defined in the shader. */ 1970 Uint32 num_readonly_storage_textures; /**< The number of readonly storage textures defined in the shader. */ 1971 Uint32 num_readonly_storage_buffers; /**< The number of readonly storage buffers defined in the shader. */ 1972 Uint32 num_readwrite_storage_textures; /**< The number of read-write storage textures defined in the shader. */ 1973 Uint32 num_readwrite_storage_buffers; /**< The number of read-write storage buffers defined in the shader. */ 1974 Uint32 num_uniform_buffers; /**< The number of uniform buffers defined in the shader. */ 1975 Uint32 threadcount_x; /**< The number of threads in the X dimension. This should match the value in the shader. */ 1976 Uint32 threadcount_y; /**< The number of threads in the Y dimension. This should match the value in the shader. */ 1977 Uint32 threadcount_z; /**< The number of threads in the Z dimension. This should match the value in the shader. */ 1978 1979 SDL_PropertiesID props; /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ 1980} SDL_GPUComputePipelineCreateInfo; 1981 1982/** 1983 * A structure specifying the parameters of a color target used by a render 1984 * pass. 1985 * 1986 * The load_op field determines what is done with the texture at the beginning 1987 * of the render pass. 1988 * 1989 * - LOAD: Loads the data currently in the texture. Not recommended for 1990 * multisample textures as it requires significant memory bandwidth. 1991 * - CLEAR: Clears the texture to a single color. 1992 * - DONT_CARE: The driver will do whatever it wants with the texture memory. 1993 * This is a good option if you know that every single pixel will be touched 1994 * in the render pass. 1995 * 1996 * The store_op field determines what is done with the color results of the 1997 * render pass. 1998 * 1999 * - STORE: Stores the results of the render pass in the texture. Not 2000 * recommended for multisample textures as it requires significant memory 2001 * bandwidth. 2002 * - DONT_CARE: The driver will do whatever it wants with the texture memory. 2003 * This is often a good option for depth/stencil textures. 2004 * - RESOLVE: Resolves a multisample texture into resolve_texture, which must 2005 * have a sample count of 1. Then the driver may discard the multisample 2006 * texture memory. This is the most performant method of resolving a 2007 * multisample target. 2008 * - RESOLVE_AND_STORE: Resolves a multisample texture into the 2009 * resolve_texture, which must have a sample count of 1. Then the driver 2010 * stores the multisample texture's contents. Not recommended as it requires 2011 * significant memory bandwidth. 2012 * 2013 * \since This struct is available since SDL 3.2.0. 2014 * 2015 * \sa SDL_BeginGPURenderPass 2016 * \sa SDL_FColor 2017 */ 2018typedef struct SDL_GPUColorTargetInfo 2019{ 2020 SDL_GPUTexture *texture; /**< The texture that will be used as a color target by a render pass. */ 2021 Uint32 mip_level; /**< The mip level to use as a color target. */ 2022 Uint32 layer_or_depth_plane; /**< 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. */ 2023 SDL_FColor clear_color; /**< The color to clear the color target to at the start of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. */ 2024 SDL_GPULoadOp load_op; /**< What is done with the contents of the color target at the beginning of the render pass. */ 2025 SDL_GPUStoreOp store_op; /**< What is done with the results of the render pass. */ 2026 SDL_GPUTexture *resolve_texture; /**< The texture that will receive the results of a multisample resolve operation. Ignored if a RESOLVE* store_op is not used. */ 2027 Uint32 resolve_mip_level; /**< The mip level of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used. */ 2028 Uint32 resolve_layer; /**< The layer index of the resolve texture to use for the resolve operation. Ignored if a RESOLVE* store_op is not used. */ 2029 bool cycle; /**< true cycles the texture if the texture is bound and load_op is not LOAD */ 2030 bool cycle_resolve_texture; /**< true cycles the resolve texture if the resolve texture is bound. Ignored if a RESOLVE* store_op is not used. */ 2031 Uint8 padding1; 2032 Uint8 padding2; 2033} SDL_GPUColorTargetInfo; 2034 2035/** 2036 * A structure specifying the parameters of a depth-stencil target used by a 2037 * render pass. 2038 * 2039 * The load_op field determines what is done with the depth contents of the 2040 * texture at the beginning of the render pass. 2041 * 2042 * - LOAD: Loads the depth values currently in the texture. 2043 * - CLEAR: Clears the texture to a single depth. 2044 * - DONT_CARE: The driver will do whatever it wants with the memory. This is 2045 * a good option if you know that every single pixel will be touched in the 2046 * render pass. 2047 * 2048 * The store_op field determines what is done with the depth results of the 2049 * render pass. 2050 * 2051 * - STORE: Stores the depth results in the texture. 2052 * - DONT_CARE: The driver will do whatever it wants with the depth results. 2053 * This is often a good option for depth/stencil textures that don't need to 2054 * be reused again. 2055 * 2056 * The stencil_load_op field determines what is done with the stencil contents 2057 * of the texture at the beginning of the render pass. 2058 * 2059 * - LOAD: Loads the stencil values currently in the texture. 2060 * - CLEAR: Clears the stencil values to a single value. 2061 * - DONT_CARE: The driver will do whatever it wants with the memory. This is 2062 * a good option if you know that every single pixel will be touched in the 2063 * render pass. 2064 * 2065 * The stencil_store_op field determines what is done with the stencil results 2066 * of the render pass. 2067 * 2068 * - STORE: Stores the stencil results in the texture. 2069 * - DONT_CARE: The driver will do whatever it wants with the stencil results. 2070 * This is often a good option for depth/stencil textures that don't need to 2071 * be reused again. 2072 * 2073 * Note that depth/stencil targets do not support multisample resolves. 2074 * 2075 * Due to ABI limitations, depth textures with more than 255 layers are not 2076 * supported. 2077 * 2078 * \since This struct is available since SDL 3.2.0. 2079 * 2080 * \sa SDL_BeginGPURenderPass 2081 */ 2082typedef struct SDL_GPUDepthStencilTargetInfo 2083{ 2084 SDL_GPUTexture *texture; /**< The texture that will be used as the depth stencil target by the render pass. */ 2085 float clear_depth; /**< The value to clear the depth component to at the beginning of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. */ 2086 SDL_GPULoadOp load_op; /**< What is done with the depth contents at the beginning of the render pass. */ 2087 SDL_GPUStoreOp store_op; /**< What is done with the depth results of the render pass. */ 2088 SDL_GPULoadOp stencil_load_op; /**< What is done with the stencil contents at the beginning of the render pass. */ 2089 SDL_GPUStoreOp stencil_store_op; /**< What is done with the stencil results of the render pass. */ 2090 bool cycle; /**< true cycles the texture if the texture is bound and any load ops are not LOAD */ 2091 Uint8 clear_stencil; /**< The value to clear the stencil component to at the beginning of the render pass. Ignored if SDL_GPU_LOADOP_CLEAR is not used. */ 2092 Uint8 mip_level; /**< The mip level to use as the depth stencil target. */ 2093 Uint8 layer; /**< The layer index to use as the depth stencil target. */ 2094} SDL_GPUDepthStencilTargetInfo; 2095 2096/** 2097 * A structure containing parameters for a blit command. 2098 * 2099 * \since This struct is available since SDL 3.2.0. 2100 * 2101 * \sa SDL_BlitGPUTexture 2102 */ 2103typedef struct SDL_GPUBlitInfo { 2104 SDL_GPUBlitRegion source; /**< The source region for the blit. */ 2105 SDL_GPUBlitRegion destination; /**< The destination region for the blit. */ 2106 SDL_GPULoadOp load_op; /**< What is done with the contents of the destination before the blit. */ 2107 SDL_FColor clear_color; /**< The color to clear the destination region to before the blit. Ignored if load_op is not SDL_GPU_LOADOP_CLEAR. */ 2108 SDL_FlipMode flip_mode; /**< The flip mode for the source region. */ 2109 SDL_GPUFilter filter; /**< The filter mode used when blitting. */ 2110 bool cycle; /**< true cycles the destination texture if it is already bound. */ 2111 Uint8 padding1; 2112 Uint8 padding2; 2113 Uint8 padding3; 2114} SDL_GPUBlitInfo; 2115 2116/* Binding structs */ 2117 2118/** 2119 * A structure specifying parameters in a buffer binding call. 2120 * 2121 * \since This struct is available since SDL 3.2.0. 2122 * 2123 * \sa SDL_BindGPUVertexBuffers 2124 * \sa SDL_BindGPUIndexBuffer 2125 */ 2126typedef struct SDL_GPUBufferBinding 2127{ 2128 SDL_GPUBuffer *buffer; /**< The buffer to bind. Must have been created with SDL_GPU_BUFFERUSAGE_VERTEX for SDL_BindGPUVertexBuffers, or SDL_GPU_BUFFERUSAGE_INDEX for SDL_BindGPUIndexBuffer. */ 2129 Uint32 offset; /**< The starting byte of the data to bind in the buffer. */ 2130} SDL_GPUBufferBinding; 2131 2132/** 2133 * A structure specifying parameters in a sampler binding call. 2134 * 2135 * \since This struct is available since SDL 3.2.0. 2136 * 2137 * \sa SDL_BindGPUVertexSamplers 2138 * \sa SDL_BindGPUFragmentSamplers 2139 * \sa SDL_GPUTexture 2140 * \sa SDL_GPUSampler 2141 */ 2142typedef struct SDL_GPUTextureSamplerBinding 2143{ 2144 SDL_GPUTexture *texture; /**< The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER. */ 2145 SDL_GPUSampler *sampler; /**< The sampler to bind. */ 2146} SDL_GPUTextureSamplerBinding; 2147 2148/** 2149 * A structure specifying parameters related to binding buffers in a compute 2150 * pass. 2151 * 2152 * \since This struct is available since SDL 3.2.0. 2153 * 2154 * \sa SDL_BeginGPUComputePass 2155 */ 2156typedef struct SDL_GPUStorageBufferReadWriteBinding 2157{ 2158 SDL_GPUBuffer *buffer; /**< The buffer to bind. Must have been created with SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE. */ 2159 bool cycle; /**< true cycles the buffer if it is already bound. */ 2160 Uint8 padding1; 2161 Uint8 padding2; 2162 Uint8 padding3; 2163} SDL_GPUStorageBufferReadWriteBinding; 2164 2165/** 2166 * A structure specifying parameters related to binding textures in a compute 2167 * pass. 2168 * 2169 * \since This struct is available since SDL 3.2.0. 2170 * 2171 * \sa SDL_BeginGPUComputePass 2172 */ 2173typedef struct SDL_GPUStorageTextureReadWriteBinding 2174{ 2175 SDL_GPUTexture *texture; /**< The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE or SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE. */ 2176 Uint32 mip_level; /**< The mip level index to bind. */ 2177 Uint32 layer; /**< The layer index to bind. */ 2178 bool cycle; /**< true cycles the texture if it is already bound. */ 2179 Uint8 padding1; 2180 Uint8 padding2; 2181 Uint8 padding3; 2182} SDL_GPUStorageTextureReadWriteBinding; 2183 2184/* Functions */ 2185 2186/* Device */ 2187 2188/** 2189 * Checks for GPU runtime support. 2190 * 2191 * \param format_flags a bitflag indicating which shader formats the app is 2192 * able to provide. 2193 * \param name the preferred GPU driver, or NULL to let SDL pick the optimal 2194 * driver. 2195 * \returns true if supported, false otherwise. 2196 * 2197 * \since This function is available since SDL 3.2.0. 2198 * 2199 * \sa SDL_CreateGPUDevice 2200 */ 2201extern SDL_DECLSPEC bool SDLCALL SDL_GPUSupportsShaderFormats( 2202 SDL_GPUShaderFormat format_flags, 2203 const char *name); 2204 2205/** 2206 * Checks for GPU runtime support. 2207 * 2208 * \param props the properties to use. 2209 * \returns true if supported, false otherwise. 2210 * 2211 * \since This function is available since SDL 3.2.0. 2212 * 2213 * \sa SDL_CreateGPUDeviceWithProperties 2214 */ 2215extern SDL_DECLSPEC bool SDLCALL SDL_GPUSupportsProperties( 2216 SDL_PropertiesID props); 2217 2218/** 2219 * Creates a GPU context. 2220 * 2221 * The GPU driver name can be one of the following: 2222 * 2223 * - "vulkan": [Vulkan](CategoryGPU#vulkan) 2224 * - "direct3d12": [D3D12](CategoryGPU#d3d12) 2225 * - "metal": [Metal](CategoryGPU#metal) 2226 * - NULL: let SDL pick the optimal driver 2227 * 2228 * \param format_flags a bitflag indicating which shader formats the app is 2229 * able to provide. 2230 * \param debug_mode enable debug mode properties and validations. 2231 * \param name the preferred GPU driver, or NULL to let SDL pick the optimal 2232 * driver. 2233 * \returns a GPU context on success or NULL on failure; call SDL_GetError() 2234 * for more information. 2235 * 2236 * \since This function is available since SDL 3.2.0. 2237 * 2238 * \sa SDL_CreateGPUDeviceWithProperties 2239 * \sa SDL_GetGPUShaderFormats 2240 * \sa SDL_GetGPUDeviceDriver 2241 * \sa SDL_DestroyGPUDevice 2242 * \sa SDL_GPUSupportsShaderFormats 2243 */ 2244extern SDL_DECLSPEC SDL_GPUDevice * SDLCALL SDL_CreateGPUDevice( 2245 SDL_GPUShaderFormat format_flags, 2246 bool debug_mode, 2247 const char *name); 2248 2249/** 2250 * Creates a GPU context. 2251 * 2252 * These are the supported properties: 2253 * 2254 * - `SDL_PROP_GPU_DEVICE_CREATE_DEBUGMODE_BOOLEAN`: enable debug mode 2255 * properties and validations, defaults to true. 2256 * - `SDL_PROP_GPU_DEVICE_CREATE_PREFERLOWPOWER_BOOLEAN`: enable to prefer 2257 * energy efficiency over maximum GPU performance, defaults to false. 2258 * - `SDL_PROP_GPU_DEVICE_CREATE_VERBOSE_BOOLEAN`: enable to automatically log 2259 * useful debug information on device creation, defaults to true. 2260 * - `SDL_PROP_GPU_DEVICE_CREATE_NAME_STRING`: the name of the GPU driver to 2261 * use, if a specific one is desired. 2262 * - `SDL_PROP_GPU_DEVICE_CREATE_FEATURE_CLIP_DISTANCE_BOOLEAN`: Enable Vulkan 2263 * device feature shaderClipDistance. If disabled, clip distances are not 2264 * supported in shader code: gl_ClipDistance[] built-ins of GLSL, 2265 * SV_ClipDistance0/1 semantics of HLSL and [[clip_distance]] attribute of 2266 * Metal. Disabling optional features allows the application to run on some 2267 * older Android devices. Defaults to true. 2268 * - `SDL_PROP_GPU_DEVICE_CREATE_FEATURE_DEPTH_CLAMPING_BOOLEAN`: Enable 2269 * Vulkan device feature depthClamp. If disabled, there is no depth clamp 2270 * support and enable_depth_clip in SDL_GPURasterizerState must always be 2271 * set to true. Disabling optional features allows the application to run on 2272 * some older Android devices. Defaults to true. 2273 * - `SDL_PROP_GPU_DEVICE_CREATE_FEATURE_INDIRECT_DRAW_FIRST_INSTANCE_BOOLEAN`: 2274 * Enable Vulkan device feature drawIndirectFirstInstance. If disabled, the 2275 * argument first_instance of SDL_GPUIndirectDrawCommand must be set to 2276 * zero. Disabling optional features allows the application to run on some 2277 * older Android devices. Defaults to true. 2278 * - `SDL_PROP_GPU_DEVICE_CREATE_FEATURE_ANISOTROPY_BOOLEAN`: Enable Vulkan 2279 * device feature samplerAnisotropy. If disabled, enable_anisotropy of 2280 * SDL_GPUSamplerCreateInfo must be set to false. Disabling optional 2281 * features allows the application to run on some older Android devices. 2282 * Defaults to true. 2283 * 2284 * These are the current shader format properties: 2285 * 2286 * - `SDL_PROP_GPU_DEVICE_CREATE_SHADERS_PRIVATE_BOOLEAN`: The app is able to 2287 * provide shaders for an NDA platform. 2288 * - `SDL_PROP_GPU_DEVICE_CREATE_SHADERS_SPIRV_BOOLEAN`: The app is able to 2289 * provide SPIR-V shaders if applicable. 2290 * - `SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXBC_BOOLEAN`: The app is able to 2291 * provide DXBC shaders if applicable 2292 * - `SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXIL_BOOLEAN`: The app is able to 2293 * provide DXIL shaders if applicable. 2294 * - `SDL_PROP_GPU_DEVICE_CREATE_SHADERS_MSL_BOOLEAN`: The app is able to 2295 * provide MSL shaders if applicable. 2296 * - `SDL_PROP_GPU_DEVICE_CREATE_SHADERS_METALLIB_BOOLEAN`: The app is able to 2297 * provide Metal shader libraries if applicable. 2298 * 2299 * With the D3D12 backend: 2300 * 2301 * - `SDL_PROP_GPU_DEVICE_CREATE_D3D12_SEMANTIC_NAME_STRING`: the prefix to 2302 * use for all vertex semantics, default is "TEXCOORD". 2303 * - `SDL_PROP_GPU_DEVICE_CREATE_D3D12_ALLOW_FEWER_RESOURCE_SLOTS_BOOLEAN`: By 2304 * default, Resourcing Binding Tier 2 is required for D3D12 support. 2305 * However, an application can set this property to true to enable Tier 1 2306 * support, if (and only if) the application uses 8 or fewer storage 2307 * resources across all shader stages. As of writing, this property is 2308 * useful for targeting Intel Haswell and Broadwell GPUs; other hardware 2309 * either supports Tier 2 Resource Binding or does not support D3D12 in any 2310 * capacity. Defaults to false. 2311 * - `SDL_PROP_GPU_DEVICE_CREATE_D3D12_AGILITY_SDK_VERSION_NUMBER`: Certain 2312 * feature checks are only possible on Windows 11 by default. By setting 2313 * this alongside `SDL_PROP_GPU_DEVICE_CREATE_D3D12_AGILITY_SDK_PATH_STRING` 2314 * and vendoring D3D12Core.dll from the D3D12 Agility SDK, you can make 2315 * those feature checks possible on older platforms. The version you provide 2316 * must match the one given in the DLL. 2317 * - `SDL_PROP_GPU_DEVICE_CREATE_D3D12_AGILITY_SDK_PATH_STRING`: Certain 2318 * feature checks are only possible on Windows 11 by default. By setting 2319 * this alongside 2320 * `SDL_PROP_GPU_DEVICE_CREATE_D3D12_AGILITY_SDK_VERSION_NUMBER` and 2321 * vendoring D3D12Core.dll from the D3D12 Agility SDK, you can make those 2322 * feature checks possible on older platforms. The path you provide must be 2323 * relative to the executable path of your app. Be sure not to put the DLL 2324 * in the same directory as the exe; Microsoft strongly advises against 2325 * this! 2326 * 2327 * With the Vulkan backend: 2328 * 2329 * - `SDL_PROP_GPU_DEVICE_CREATE_VULKAN_REQUIRE_HARDWARE_ACCELERATION_BOOLEAN`: 2330 * By default, Vulkan device enumeration includes drivers of all types, 2331 * including software renderers (for example, the Lavapipe Mesa driver). 2332 * This can be useful if your application _requires_ SDL_GPU, but if you can 2333 * provide your own fallback renderer (for example, an OpenGL renderer) this 2334 * property can be set to true. Defaults to false. 2335 * - `SDL_PROP_GPU_DEVICE_CREATE_VULKAN_OPTIONS_POINTER`: a pointer to an 2336 * SDL_GPUVulkanOptions structure to be processed during device creation. 2337 * This allows configuring a variety of Vulkan-specific options such as 2338 * increasing the API version and opting into extensions aside from the 2339 * minimal set SDL requires. 2340 * 2341 * With the Metal backend: - 2342 * `SDL_PROP_GPU_DEVICE_CREATE_METAL_ALLOW_MACFAMILY1_BOOLEAN`: By default, 2343 * macOS support requires what Apple calls "MTLGPUFamilyMac2" hardware or 2344 * newer. However, an application can set this property to true to enable 2345 * support for "MTLGPUFamilyMac1" hardware, if (and only if) the application 2346 * does not write to sRGB textures. (For history's sake: MacFamily1 also does 2347 * not support indirect command buffers, MSAA depth resolve, and stencil 2348 * resolve/feedback, but these are not exposed features in SDL_GPU.) 2349 * 2350 * \param props the properties to use. 2351 * \returns a GPU context on success or NULL on failure; call SDL_GetError() 2352 * for more information. 2353 * 2354 * \since This function is available since SDL 3.2.0. 2355 * 2356 * \sa SDL_GetGPUShaderFormats 2357 * \sa SDL_GetGPUDeviceDriver 2358 * \sa SDL_DestroyGPUDevice 2359 * \sa SDL_GPUSupportsProperties 2360 */ 2361extern SDL_DECLSPEC SDL_GPUDevice * SDLCALL SDL_CreateGPUDeviceWithProperties( 2362 SDL_PropertiesID props); 2363 2364#define SDL_PROP_GPU_DEVICE_CREATE_DEBUGMODE_BOOLEAN "SDL.gpu.device.create.debugmode" 2365#define SDL_PROP_GPU_DEVICE_CREATE_PREFERLOWPOWER_BOOLEAN "SDL.gpu.device.create.preferlowpower" 2366#define SDL_PROP_GPU_DEVICE_CREATE_VERBOSE_BOOLEAN "SDL.gpu.device.create.verbose" 2367#define SDL_PROP_GPU_DEVICE_CREATE_NAME_STRING "SDL.gpu.device.create.name" 2368#define SDL_PROP_GPU_DEVICE_CREATE_FEATURE_CLIP_DISTANCE_BOOLEAN "SDL.gpu.device.create.feature.clip_distance" 2369#define SDL_PROP_GPU_DEVICE_CREATE_FEATURE_DEPTH_CLAMPING_BOOLEAN "SDL.gpu.device.create.feature.depth_clamping" 2370#define SDL_PROP_GPU_DEVICE_CREATE_FEATURE_INDIRECT_DRAW_FIRST_INSTANCE_BOOLEAN "SDL.gpu.device.create.feature.indirect_draw_first_instance" 2371#define SDL_PROP_GPU_DEVICE_CREATE_FEATURE_ANISOTROPY_BOOLEAN "SDL.gpu.device.create.feature.anisotropy" 2372#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_PRIVATE_BOOLEAN "SDL.gpu.device.create.shaders.private" 2373#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_SPIRV_BOOLEAN "SDL.gpu.device.create.shaders.spirv" 2374#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXBC_BOOLEAN "SDL.gpu.device.create.shaders.dxbc" 2375#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_DXIL_BOOLEAN "SDL.gpu.device.create.shaders.dxil" 2376#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_MSL_BOOLEAN "SDL.gpu.device.create.shaders.msl" 2377#define SDL_PROP_GPU_DEVICE_CREATE_SHADERS_METALLIB_BOOLEAN "SDL.gpu.device.create.shaders.metallib" 2378#define SDL_PROP_GPU_DEVICE_CREATE_D3D12_ALLOW_FEWER_RESOURCE_SLOTS_BOOLEAN "SDL.gpu.device.create.d3d12.allowtier1resourcebinding" 2379#define SDL_PROP_GPU_DEVICE_CREATE_D3D12_SEMANTIC_NAME_STRING "SDL.gpu.device.create.d3d12.semantic" 2380#define SDL_PROP_GPU_DEVICE_CREATE_D3D12_AGILITY_SDK_VERSION_NUMBER "SDL.gpu.device.create.d3d12.agility_sdk_version" 2381#define SDL_PROP_GPU_DEVICE_CREATE_D3D12_AGILITY_SDK_PATH_STRING "SDL.gpu.device.create.d3d12.agility_sdk_path" 2382#define SDL_PROP_GPU_DEVICE_CREATE_VULKAN_REQUIRE_HARDWARE_ACCELERATION_BOOLEAN "SDL.gpu.device.create.vulkan.requirehardwareacceleration" 2383#define SDL_PROP_GPU_DEVICE_CREATE_VULKAN_OPTIONS_POINTER "SDL.gpu.device.create.vulkan.options" 2384#define SDL_PROP_GPU_DEVICE_CREATE_METAL_ALLOW_MACFAMILY1_BOOLEAN "SDL.gpu.device.create.metal.allowmacfamily1" 2385 2386#define SDL_PROP_GPU_DEVICE_CREATE_XR_ENABLE_BOOLEAN "SDL.gpu.device.create.xr.enable" 2387#define SDL_PROP_GPU_DEVICE_CREATE_XR_INSTANCE_POINTER "SDL.gpu.device.create.xr.instance_out" 2388#define SDL_PROP_GPU_DEVICE_CREATE_XR_SYSTEM_ID_POINTER "SDL.gpu.device.create.xr.system_id_out" 2389#define SDL_PROP_GPU_DEVICE_CREATE_XR_VERSION_NUMBER "SDL.gpu.device.create.xr.version" 2390#define SDL_PROP_GPU_DEVICE_CREATE_XR_FORM_FACTOR_NUMBER "SDL.gpu.device.create.xr.form_factor" 2391#define SDL_PROP_GPU_DEVICE_CREATE_XR_EXTENSION_COUNT_NUMBER "SDL.gpu.device.create.xr.extensions.count" 2392#define SDL_PROP_GPU_DEVICE_CREATE_XR_EXTENSION_NAMES_POINTER "SDL.gpu.device.create.xr.extensions.names" 2393#define SDL_PROP_GPU_DEVICE_CREATE_XR_LAYER_COUNT_NUMBER "SDL.gpu.device.create.xr.layers.count" 2394#define SDL_PROP_GPU_DEVICE_CREATE_XR_LAYER_NAMES_POINTER "SDL.gpu.device.create.xr.layers.names" 2395#define SDL_PROP_GPU_DEVICE_CREATE_XR_APPLICATION_NAME_STRING "SDL.gpu.device.create.xr.application.name" 2396#define SDL_PROP_GPU_DEVICE_CREATE_XR_APPLICATION_VERSION_NUMBER "SDL.gpu.device.create.xr.application.version" 2397#define SDL_PROP_GPU_DEVICE_CREATE_XR_ENGINE_NAME_STRING "SDL.gpu.device.create.xr.engine.name" 2398#define SDL_PROP_GPU_DEVICE_CREATE_XR_ENGINE_VERSION_NUMBER "SDL.gpu.device.create.xr.engine.version" 2399 2400 2401/** 2402 * A structure specifying additional options when using Vulkan. 2403 * 2404 * When no such structure is provided, SDL will use Vulkan API version 1.0 and 2405 * a minimal set of features. The requested API version influences how the 2406 * feature_list is processed by SDL. When requesting API version 1.0, the 2407 * feature_list is ignored. Only the vulkan_10_physical_device_features and 2408 * the extension lists are used. When requesting API version 1.1, the 2409 * feature_list is scanned for feature structures introduced in Vulkan 1.1. 2410 * When requesting Vulkan 1.2 or higher, the feature_list is additionally 2411 * scanned for compound feature structs such as 2412 * VkPhysicalDeviceVulkan11Features. The device and instance extension lists, 2413 * as well as vulkan_10_physical_device_features, are always processed. 2414 * 2415 * \since This struct is available since SDL 3.4.0. 2416 */ 2417typedef struct SDL_GPUVulkanOptions 2418{ 2419 Uint32 vulkan_api_version; /**< The Vulkan API version to request for the instance. Use Vulkan's VK_MAKE_VERSION or VK_MAKE_API_VERSION. */ 2420 void *feature_list; /**< Pointer to the first element of a chain of Vulkan feature structs. (Requires API version 1.1 or higher.)*/ 2421 void *vulkan_10_physical_device_features; /**< Pointer to a VkPhysicalDeviceFeatures struct to enable additional Vulkan 1.0 features. */ 2422 Uint32 device_extension_count; /**< Number of additional device extensions to require. */ 2423 const char **device_extension_names; /**< Pointer to a list of additional device extensions to require. */ 2424 Uint32 instance_extension_count; /**< Number of additional instance extensions to require. */ 2425 const char **instance_extension_names; /**< Pointer to a list of additional instance extensions to require. */ 2426} SDL_GPUVulkanOptions; 2427 2428/** 2429 * Destroys a GPU context previously returned by SDL_CreateGPUDevice. 2430 * 2431 * \param device a GPU Context to destroy. 2432 * 2433 * \since This function is available since SDL 3.2.0. 2434 * 2435 * \sa SDL_CreateGPUDevice 2436 */ 2437extern SDL_DECLSPEC void SDLCALL SDL_DestroyGPUDevice(SDL_GPUDevice *device); 2438 2439/** 2440 * Get the number of GPU drivers compiled into SDL. 2441 * 2442 * \returns the number of built in GPU drivers. 2443 * 2444 * \since This function is available since SDL 3.2.0. 2445 * 2446 * \sa SDL_GetGPUDriver 2447 */ 2448extern SDL_DECLSPEC int SDLCALL SDL_GetNumGPUDrivers(void); 2449 2450/** 2451 * Get the name of a built in GPU driver. 2452 * 2453 * The GPU drivers are presented in the order in which they are normally 2454 * checked during initialization. 2455 * 2456 * The names of drivers are all simple, low-ASCII identifiers, like "vulkan", 2457 * "metal" or "direct3d12". These never have Unicode characters, and are not 2458 * meant to be proper names. 2459 * 2460 * \param index the index of a GPU driver. 2461 * \returns the name of the GPU driver with the given **index**. 2462 * 2463 * \since This function is available since SDL 3.2.0. 2464 * 2465 * \sa SDL_GetNumGPUDrivers 2466 */ 2467extern SDL_DECLSPEC const char * SDLCALL SDL_GetGPUDriver(int index); 2468 2469/** 2470 * Returns the name of the backend used to create this GPU context. 2471 * 2472 * \param device a GPU context to query. 2473 * \returns the name of the device's driver, or NULL on error. 2474 * 2475 * \since This function is available since SDL 3.2.0. 2476 */ 2477extern SDL_DECLSPEC const char * SDLCALL SDL_GetGPUDeviceDriver(SDL_GPUDevice *device); 2478 2479/** 2480 * Returns the supported shader formats for this GPU context. 2481 * 2482 * \param device a GPU context to query. 2483 * \returns a bitflag indicating which shader formats the driver is able to 2484 * consume. 2485 * 2486 * \since This function is available since SDL 3.2.0. 2487 */ 2488extern SDL_DECLSPEC SDL_GPUShaderFormat SDLCALL SDL_GetGPUShaderFormats(SDL_GPUDevice *device); 2489 2490/** 2491 * Get the properties associated with a GPU device. 2492 * 2493 * All properties are optional and may differ between GPU backends and SDL 2494 * versions. 2495 * 2496 * The following properties are provided by SDL: 2497 * 2498 * `SDL_PROP_GPU_DEVICE_NAME_STRING`: Contains the name of the underlying 2499 * device as reported by the system driver. This string has no standardized 2500 * format, is highly inconsistent between hardware devices and drivers, and is 2501 * able to change at any time. Do not attempt to parse this string as it is 2502 * bound to fail at some point in the future when system drivers are updated, 2503 * new hardware devices are introduced, or when SDL adds new GPU backends or 2504 * modifies existing ones. 2505 * 2506 * Strings that have been found in the wild include: 2507 * 2508 * - GTX 970 2509 * - GeForce GTX 970 2510 * - NVIDIA GeForce GTX 970 2511 * - Microsoft Direct3D12 (NVIDIA GeForce GTX 970) 2512 * - NVIDIA Graphics Device 2513 * - GeForce GPU 2514 * - P106-100 2515 * - AMD 15D8:C9 2516 * - AMD Custom GPU 0405 2517 * - AMD Radeon (TM) Graphics 2518 * - ASUS Radeon RX 470 Series 2519 * - Intel(R) Arc(tm) A380 Graphics (DG2) 2520 * - Virtio-GPU Venus (NVIDIA TITAN V) 2521 * - SwiftShader Device (LLVM 16.0.0) 2522 * - llvmpipe (LLVM 15.0.4, 256 bits) 2523 * - Microsoft Basic Render Driver 2524 * - unknown device 2525 * 2526 * The above list shows that the same device can have different formats, the 2527 * vendor name may or may not appear in the string, the included vendor name 2528 * may not be the vendor of the chipset on the device, some manufacturers 2529 * include pseudo-legal marks while others don't, some devices may not use a 2530 * marketing name in the string, the device string may be wrapped by the name 2531 * of a translation interface, the device may be emulated in software, or the 2532 * string may contain generic text that does not identify the device at all. 2533 * 2534 * `SDL_PROP_GPU_DEVICE_DRIVER_NAME_STRING`: Contains the self-reported name 2535 * of the underlying system driver. 2536 * 2537 * Strings that have been found in the wild include: 2538 * 2539 * - Intel Corporation 2540 * - Intel open-source Mesa driver 2541 * - Qualcomm Technologies Inc. Adreno Vulkan Driver 2542 * - MoltenVK 2543 * - Mali-G715 2544 * - venus 2545 * 2546 * `SDL_PROP_GPU_DEVICE_DRIVER_VERSION_STRING`: Contains the self-reported 2547 * version of the underlying system driver. This is a relatively short version 2548 * string in an unspecified format. If SDL_PROP_GPU_DEVICE_DRIVER_INFO_STRING 2549 * is available then that property should be preferred over this one as it may 2550 * contain additional information that is useful for identifying the exact 2551 * driver version used. 2552 * 2553 * Strings that have been found in the wild include: 2554 * 2555 * - 53.0.0 2556 * - 0.405.2463 2557 * - 32.0.15.6614 2558 * 2559 * `SDL_PROP_GPU_DEVICE_DRIVER_INFO_STRING`: Contains the detailed version 2560 * information of the underlying system driver as reported by the driver. This 2561 * is an arbitrary string with no standardized format and it may contain 2562 * newlines. This property should be preferred over 2563 * SDL_PROP_GPU_DEVICE_DRIVER_VERSION_STRING if it is available as it usually 2564 * contains the same information but in a format that is easier to read. 2565 * 2566 * Strings that have been found in the wild include: 2567 * 2568 * - 101.6559 2569 * - 1.2.11 2570 * - Mesa 21.2.2 (LLVM 12.0.1) 2571 * - Mesa 22.2.0-devel (git-f226222 2022-04-14 impish-oibaf-ppa) 2572 * - v1.r53p0-00eac0.824c4f31403fb1fbf8ee1042422c2129 2573 * 2574 * This string has also been observed to be a multiline string (which has a 2575 * trailing newline): 2576 * 2577 * ``` 2578 * Driver Build: 85da404, I46ff5fc46f, 1606794520 2579 * Date: 11/30/20 2580 * Compiler Version: EV031.31.04.01 2581 * Driver Branch: promo490_3_Google 2582 * ``` 2583 * 2584 * \param device a GPU context to query. 2585 * \returns a valid property ID on success or 0 on failure; call 2586 * SDL_GetError() for more information. 2587 * 2588 * \threadsafety It is safe to call this function from any thread. 2589 * 2590 * \since This function is available since SDL 3.4.0. 2591 */ 2592extern SDL_DECLSPEC SDL_PropertiesID SDLCALL SDL_GetGPUDeviceProperties(SDL_GPUDevice *device); 2593 2594#define SDL_PROP_GPU_DEVICE_NAME_STRING "SDL.gpu.device.name" 2595#define SDL_PROP_GPU_DEVICE_DRIVER_NAME_STRING "SDL.gpu.device.driver_name" 2596#define SDL_PROP_GPU_DEVICE_DRIVER_VERSION_STRING "SDL.gpu.device.driver_version" 2597#define SDL_PROP_GPU_DEVICE_DRIVER_INFO_STRING "SDL.gpu.device.driver_info" 2598 2599 2600/* State Creation */ 2601 2602/** 2603 * Creates a pipeline object to be used in a compute workflow. 2604 * 2605 * Shader resource bindings must be authored to follow a particular order 2606 * depending on the shader format. 2607 * 2608 * For SPIR-V shaders, use the following resource sets: 2609 * 2610 * - 0: Sampled textures, followed by read-only storage textures, followed by 2611 * read-only storage buffers 2612 * - 1: Read-write storage textures, followed by read-write storage buffers 2613 * - 2: Uniform buffers 2614 * 2615 * For DXBC and DXIL shaders, use the following register order: 2616 * 2617 * - (t[n], space0): Sampled textures, followed by read-only storage textures, 2618 * followed by read-only storage buffers 2619 * - (u[n], space1): Read-write storage textures, followed by read-write 2620 * storage buffers 2621 * - (b[n], space2): Uniform buffers 2622 * 2623 * For MSL/metallib, use the following order: 2624 * 2625 * - [[buffer]]: Uniform buffers, followed by read-only storage buffers, 2626 * followed by read-write storage buffers 2627 * - [[texture]]: Sampled textures, followed by read-only storage textures, 2628 * followed by read-write storage textures 2629 * 2630 * There are optional properties that can be provided through `props`. These 2631 * are the supported properties: 2632 * 2633 * - `SDL_PROP_GPU_COMPUTEPIPELINE_CREATE_NAME_STRING`: a name that can be 2634 * displayed in debugging tools. 2635 * 2636 * \param device a GPU Context. 2637 * \param createinfo a struct describing the state of the compute pipeline to 2638 * create. 2639 * \returns a compute pipeline object on success, or NULL on failure; call 2640 * SDL_GetError() for more information. 2641 * 2642 * \since This function is available since SDL 3.2.0. 2643 * 2644 * \sa SDL_BindGPUComputePipeline 2645 * \sa SDL_ReleaseGPUComputePipeline 2646 */ 2647extern SDL_DECLSPEC SDL_GPUComputePipeline * SDLCALL SDL_CreateGPUComputePipeline( 2648 SDL_GPUDevice *device, 2649 const SDL_GPUComputePipelineCreateInfo *createinfo); 2650 2651#define SDL_PROP_GPU_COMPUTEPIPELINE_CREATE_NAME_STRING "SDL.gpu.computepipeline.create.name" 2652 2653/** 2654 * Creates a pipeline object to be used in a graphics workflow. 2655 * 2656 * There are optional properties that can be provided through `props`. These 2657 * are the supported properties: 2658 * 2659 * - `SDL_PROP_GPU_GRAPHICSPIPELINE_CREATE_NAME_STRING`: a name that can be 2660 * displayed in debugging tools. 2661 * 2662 * \param device a GPU Context. 2663 * \param createinfo a struct describing the state of the graphics pipeline to 2664 * create. 2665 * \returns a graphics pipeline object on success, or NULL on failure; call 2666 * SDL_GetError() for more information. 2667 * 2668 * \since This function is available since SDL 3.2.0. 2669 * 2670 * \sa SDL_CreateGPUShader 2671 * \sa SDL_BindGPUGraphicsPipeline 2672 * \sa SDL_ReleaseGPUGraphicsPipeline 2673 */ 2674extern SDL_DECLSPEC SDL_GPUGraphicsPipeline * SDLCALL SDL_CreateGPUGraphicsPipeline( 2675 SDL_GPUDevice *device, 2676 const SDL_GPUGraphicsPipelineCreateInfo *createinfo); 2677 2678#define SDL_PROP_GPU_GRAPHICSPIPELINE_CREATE_NAME_STRING "SDL.gpu.graphicspipeline.create.name" 2679 2680/** 2681 * Creates a sampler object to be used when binding textures in a graphics 2682 * workflow. 2683 * 2684 * There are optional properties that can be provided through `props`. These 2685 * are the supported properties: 2686 * 2687 * - `SDL_PROP_GPU_SAMPLER_CREATE_NAME_STRING`: a name that can be displayed 2688 * in debugging tools. 2689 * 2690 * \param device a GPU Context. 2691 * \param createinfo a struct describing the state of the sampler to create. 2692 * \returns a sampler object on success, or NULL on failure; call 2693 * SDL_GetError() for more information. 2694 * 2695 * \since This function is available since SDL 3.2.0. 2696 * 2697 * \sa SDL_BindGPUVertexSamplers 2698 * \sa SDL_BindGPUFragmentSamplers 2699 * \sa SDL_ReleaseGPUSampler 2700 */ 2701extern SDL_DECLSPEC SDL_GPUSampler * SDLCALL SDL_CreateGPUSampler( 2702 SDL_GPUDevice *device, 2703 const SDL_GPUSamplerCreateInfo *createinfo); 2704 2705#define SDL_PROP_GPU_SAMPLER_CREATE_NAME_STRING "SDL.gpu.sampler.create.name" 2706 2707/** 2708 * Creates a shader to be used when creating a graphics pipeline. 2709 * 2710 * Shader resource bindings must be authored to follow a particular order 2711 * depending on the shader format. 2712 * 2713 * For SPIR-V shaders, use the following resource sets: 2714 * 2715 * For vertex shaders: 2716 * 2717 * - 0: Sampled textures, followed by storage textures, followed by storage 2718 * buffers 2719 * - 1: Uniform buffers 2720 * 2721 * For fragment shaders: 2722 * 2723 * - 2: Sampled textures, followed by storage textures, followed by storage 2724 * buffers 2725 * - 3: Uniform buffers 2726 * 2727 * For DXBC and DXIL shaders, use the following register order: 2728 * 2729 * For vertex shaders: 2730 * 2731 * - (t[n], space0): Sampled textures, followed by storage textures, followed 2732 * by storage buffers 2733 * - (s[n], space0): Samplers with indices corresponding to the sampled 2734 * textures 2735 * - (b[n], space1): Uniform buffers 2736 * 2737 * For pixel shaders: 2738 * 2739 * - (t[n], space2): Sampled textures, followed by storage textures, followed 2740 * by storage buffers 2741 * - (s[n], space2): Samplers with indices corresponding to the sampled 2742 * textures 2743 * - (b[n], space3): Uniform buffers 2744 * 2745 * For MSL/metallib, use the following order: 2746 * 2747 * - [[texture]]: Sampled textures, followed by storage textures 2748 * - [[sampler]]: Samplers with indices corresponding to the sampled textures 2749 * - [[buffer]]: Uniform buffers, followed by storage buffers. Vertex buffer 0 2750 * is bound at [[buffer(14)]], vertex buffer 1 at [[buffer(15)]], and so on. 2751 * Rather than manually authoring vertex buffer indices, use the 2752 * [[stage_in]] attribute which will automatically use the vertex input 2753 * information from the SDL_GPUGraphicsPipeline. 2754 * 2755 * Shader semantics other than system-value semantics do not matter in D3D12 2756 * and for ease of use the SDL implementation assumes that non system-value 2757 * semantics will all be TEXCOORD. If you are using HLSL as the shader source 2758 * language, your vertex semantics should start at TEXCOORD0 and increment 2759 * like so: TEXCOORD1, TEXCOORD2, etc. If you wish to change the semantic 2760 * prefix to something other than TEXCOORD you can use 2761 * SDL_PROP_GPU_DEVICE_CREATE_D3D12_SEMANTIC_NAME_STRING with 2762 * SDL_CreateGPUDeviceWithProperties(). 2763 * 2764 * There are optional properties that can be provided through `props`. These 2765 * are the supported properties: 2766 * 2767 * - `SDL_PROP_GPU_SHADER_CREATE_NAME_STRING`: a name that can be displayed in 2768 * debugging tools. 2769 * 2770 * \param device a GPU Context. 2771 * \param createinfo a struct describing the state of the shader to create. 2772 * \returns a shader object on success, or NULL on failure; call 2773 * SDL_GetError() for more information. 2774 * 2775 * \since This function is available since SDL 3.2.0. 2776 * 2777 * \sa SDL_CreateGPUGraphicsPipeline 2778 * \sa SDL_ReleaseGPUShader 2779 */ 2780extern SDL_DECLSPEC SDL_GPUShader * SDLCALL SDL_CreateGPUShader( 2781 SDL_GPUDevice *device, 2782 const SDL_GPUShaderCreateInfo *createinfo); 2783 2784#define SDL_PROP_GPU_SHADER_CREATE_NAME_STRING "SDL.gpu.shader.create.name" 2785 2786/** 2787 * Creates a texture object to be used in graphics or compute workflows. 2788 * 2789 * The contents of this texture are undefined until data is written to the 2790 * texture, either via SDL_UploadToGPUTexture or by performing a render or 2791 * compute pass with this texture as a target. 2792 * 2793 * Note that certain combinations of usage flags are invalid. For example, a 2794 * texture cannot have both the SAMPLER and GRAPHICS_STORAGE_READ flags. 2795 * 2796 * If you request a sample count higher than the hardware supports, the 2797 * implementation will automatically fall back to the highest available sample 2798 * count. 2799 * 2800 * There are optional properties that can be provided through 2801 * SDL_GPUTextureCreateInfo's `props`. These are the supported properties: 2802 * 2803 * - `SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_R_FLOAT`: (Direct3D 12 only) if 2804 * the texture usage is SDL_GPU_TEXTUREUSAGE_COLOR_TARGET, clear the texture 2805 * to a color with this red intensity. Defaults to zero. 2806 * - `SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_G_FLOAT`: (Direct3D 12 only) if 2807 * the texture usage is SDL_GPU_TEXTUREUSAGE_COLOR_TARGET, clear the texture 2808 * to a color with this green intensity. Defaults to zero. 2809 * - `SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_B_FLOAT`: (Direct3D 12 only) if 2810 * the texture usage is SDL_GPU_TEXTUREUSAGE_COLOR_TARGET, clear the texture 2811 * to a color with this blue intensity. Defaults to zero. 2812 * - `SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_A_FLOAT`: (Direct3D 12 only) if 2813 * the texture usage is SDL_GPU_TEXTUREUSAGE_COLOR_TARGET, clear the texture 2814 * to a color with this alpha intensity. Defaults to zero. 2815 * - `SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_DEPTH_FLOAT`: (Direct3D 12 only) 2816 * if the texture usage is SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET, clear 2817 * the texture to a depth of this value. Defaults to zero. 2818 * - `SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_STENCIL_NUMBER`: (Direct3D 12 2819 * only) if the texture usage is SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET, 2820 * clear the texture to a stencil of this Uint8 value. Defaults to zero. 2821 * - `SDL_PROP_GPU_TEXTURE_CREATE_NAME_STRING`: a name that can be displayed 2822 * in debugging tools. 2823 * 2824 * \param device a GPU Context. 2825 * \param createinfo a struct describing the state of the texture to create. 2826 * \returns a texture object on success, or NULL on failure; call 2827 * SDL_GetError() for more information. 2828 * 2829 * \since This function is available since SDL 3.2.0. 2830 * 2831 * \sa SDL_UploadToGPUTexture 2832 * \sa SDL_DownloadFromGPUTexture 2833 * \sa SDL_BeginGPURenderPass 2834 * \sa SDL_BeginGPUComputePass 2835 * \sa SDL_BindGPUVertexSamplers 2836 * \sa SDL_BindGPUVertexStorageTextures 2837 * \sa SDL_BindGPUFragmentSamplers 2838 * \sa SDL_BindGPUFragmentStorageTextures 2839 * \sa SDL_BindGPUComputeStorageTextures 2840 * \sa SDL_BlitGPUTexture 2841 * \sa SDL_ReleaseGPUTexture 2842 * \sa SDL_GPUTextureSupportsFormat 2843 */ 2844extern SDL_DECLSPEC SDL_GPUTexture * SDLCALL SDL_CreateGPUTexture( 2845 SDL_GPUDevice *device, 2846 const SDL_GPUTextureCreateInfo *createinfo); 2847 2848#define SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_R_FLOAT "SDL.gpu.texture.create.d3d12.clear.r" 2849#define SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_G_FLOAT "SDL.gpu.texture.create.d3d12.clear.g" 2850#define SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_B_FLOAT "SDL.gpu.texture.create.d3d12.clear.b" 2851#define SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_A_FLOAT "SDL.gpu.texture.create.d3d12.clear.a" 2852#define SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_DEPTH_FLOAT "SDL.gpu.texture.create.d3d12.clear.depth" 2853#define SDL_PROP_GPU_TEXTURE_CREATE_D3D12_CLEAR_STENCIL_NUMBER "SDL.gpu.texture.create.d3d12.clear.stencil" 2854#define SDL_PROP_GPU_TEXTURE_CREATE_NAME_STRING "SDL.gpu.texture.create.name" 2855 2856/** 2857 * Creates a buffer object to be used in graphics or compute workflows. 2858 * 2859 * The contents of this buffer are undefined until data is written to the 2860 * buffer. 2861 * 2862 * Note that certain combinations of usage flags are invalid. For example, a 2863 * buffer cannot have both the VERTEX and INDEX flags. 2864 * 2865 * If you use a STORAGE flag, the data in the buffer must respect std140 2866 * layout conventions. In practical terms this means you must ensure that vec3 2867 * and vec4 fields are 16-byte aligned. 2868 * 2869 * For better understanding of underlying concepts and memory management with 2870 * SDL GPU API, you may refer 2871 * [this blog post](https://moonside.games/posts/sdl-gpu-concepts-cycling/) 2872 * . 2873 * 2874 * There are optional properties that can be provided through `props`. These 2875 * are the supported properties: 2876 * 2877 * - `SDL_PROP_GPU_BUFFER_CREATE_NAME_STRING`: a name that can be displayed in 2878 * debugging tools. 2879 * 2880 * \param device a GPU Context. 2881 * \param createinfo a struct describing the state of the buffer to create. 2882 * \returns a buffer object on success, or NULL on failure; call 2883 * SDL_GetError() for more information. 2884 * 2885 * \since This function is available since SDL 3.2.0. 2886 * 2887 * \sa SDL_UploadToGPUBuffer 2888 * \sa SDL_DownloadFromGPUBuffer 2889 * \sa SDL_CopyGPUBufferToBuffer 2890 * \sa SDL_BindGPUVertexBuffers 2891 * \sa SDL_BindGPUIndexBuffer 2892 * \sa SDL_BindGPUVertexStorageBuffers 2893 * \sa SDL_BindGPUFragmentStorageBuffers 2894 * \sa SDL_DrawGPUPrimitivesIndirect 2895 * \sa SDL_DrawGPUIndexedPrimitivesIndirect 2896 * \sa SDL_BindGPUComputeStorageBuffers 2897 * \sa SDL_DispatchGPUComputeIndirect 2898 * \sa SDL_ReleaseGPUBuffer 2899 */ 2900extern SDL_DECLSPEC SDL_GPUBuffer * SDLCALL SDL_CreateGPUBuffer( 2901 SDL_GPUDevice *device, 2902 const SDL_GPUBufferCreateInfo *createinfo); 2903 2904#define SDL_PROP_GPU_BUFFER_CREATE_NAME_STRING "SDL.gpu.buffer.create.name" 2905 2906/** 2907 * Creates a transfer buffer to be used when uploading to or downloading from 2908 * graphics resources. 2909 * 2910 * Download buffers can be particularly expensive to create, so it is good 2911 * practice to reuse them if data will be downloaded regularly. 2912 * 2913 * There are optional properties that can be provided through `props`. These 2914 * are the supported properties: 2915 * 2916 * - `SDL_PROP_GPU_TRANSFERBUFFER_CREATE_NAME_STRING`: a name that can be 2917 * displayed in debugging tools. 2918 * 2919 * \param device a GPU Context. 2920 * \param createinfo a struct describing the state of the transfer buffer to 2921 * create. 2922 * \returns a transfer buffer on success, or NULL on failure; call 2923 * SDL_GetError() for more information. 2924 * 2925 * \since This function is available since SDL 3.2.0. 2926 * 2927 * \sa SDL_UploadToGPUBuffer 2928 * \sa SDL_DownloadFromGPUBuffer 2929 * \sa SDL_UploadToGPUTexture 2930 * \sa SDL_DownloadFromGPUTexture 2931 * \sa SDL_ReleaseGPUTransferBuffer 2932 */ 2933extern SDL_DECLSPEC SDL_GPUTransferBuffer * SDLCALL SDL_CreateGPUTransferBuffer( 2934 SDL_GPUDevice *device, 2935 const SDL_GPUTransferBufferCreateInfo *createinfo); 2936 2937#define SDL_PROP_GPU_TRANSFERBUFFER_CREATE_NAME_STRING "SDL.gpu.transferbuffer.create.name" 2938 2939/* Debug Naming */ 2940 2941/** 2942 * Sets an arbitrary string constant to label a buffer. 2943 * 2944 * You should use SDL_PROP_GPU_BUFFER_CREATE_NAME_STRING with 2945 * SDL_CreateGPUBuffer instead of this function to avoid thread safety issues. 2946 * 2947 * \param device a GPU Context. 2948 * \param buffer a buffer to attach the name to. 2949 * \param text a UTF-8 string constant to mark as the name of the buffer. 2950 * 2951 * \threadsafety This function is not thread safe, you must make sure the 2952 * buffer is not simultaneously used by any other thread. 2953 * 2954 * \since This function is available since SDL 3.2.0. 2955 * 2956 * \sa SDL_CreateGPUBuffer 2957 */ 2958extern SDL_DECLSPEC void SDLCALL SDL_SetGPUBufferName( 2959 SDL_GPUDevice *device, 2960 SDL_GPUBuffer *buffer, 2961 const char *text); 2962 2963/** 2964 * Sets an arbitrary string constant to label a texture. 2965 * 2966 * You should use SDL_PROP_GPU_TEXTURE_CREATE_NAME_STRING with 2967 * SDL_CreateGPUTexture instead of this function to avoid thread safety 2968 * issues. 2969 * 2970 * \param device a GPU Context. 2971 * \param texture a texture to attach the name to. 2972 * \param text a UTF-8 string constant to mark as the name of the texture. 2973 * 2974 * \threadsafety This function is not thread safe, you must make sure the 2975 * texture is not simultaneously used by any other thread. 2976 * 2977 * \since This function is available since SDL 3.2.0. 2978 * 2979 * \sa SDL_CreateGPUTexture 2980 */ 2981extern SDL_DECLSPEC void SDLCALL SDL_SetGPUTextureName( 2982 SDL_GPUDevice *device, 2983 SDL_GPUTexture *texture, 2984 const char *text); 2985 2986/** 2987 * Inserts an arbitrary string label into the command buffer callstream. 2988 * 2989 * Useful for debugging. 2990 * 2991 * On Direct3D 12, using SDL_InsertGPUDebugLabel requires 2992 * WinPixEventRuntime.dll to be in your PATH or in the same directory as your 2993 * executable. See 2994 * [here](https://devblogs.microsoft.com/pix/winpixeventruntime/) 2995 * for instructions on how to obtain it. 2996 * 2997 * \param command_buffer a command buffer. 2998 * \param text a UTF-8 string constant to insert as the label. 2999 * 3000 * \since This function is available since SDL 3.2.0. 3001 */ 3002extern SDL_DECLSPEC void SDLCALL SDL_InsertGPUDebugLabel( 3003 SDL_GPUCommandBuffer *command_buffer, 3004 const char *text); 3005 3006/** 3007 * Begins a debug group with an arbitrary name. 3008 * 3009 * Used for denoting groups of calls when viewing the command buffer 3010 * callstream in a graphics debugging tool. 3011 * 3012 * Each call to SDL_PushGPUDebugGroup must have a corresponding call to 3013 * SDL_PopGPUDebugGroup. 3014 * 3015 * On Direct3D 12, using SDL_PushGPUDebugGroup requires WinPixEventRuntime.dll 3016 * to be in your PATH or in the same directory as your executable. See 3017 * [here](https://devblogs.microsoft.com/pix/winpixeventruntime/) 3018 * for instructions on how to obtain it. 3019 * 3020 * On some backends (e.g. Metal), pushing a debug group during a 3021 * render/blit/compute pass will create a group that is scoped to the native 3022 * pass rather than the command buffer. For best results, if you push a debug 3023 * group during a pass, always pop it in the same pass. 3024 * 3025 * \param command_buffer a command buffer. 3026 * \param name a UTF-8 string constant that names the group. 3027 * 3028 * \since This function is available since SDL 3.2.0. 3029 * 3030 * \sa SDL_PopGPUDebugGroup 3031 */ 3032extern SDL_DECLSPEC void SDLCALL SDL_PushGPUDebugGroup( 3033 SDL_GPUCommandBuffer *command_buffer, 3034 const char *name); 3035 3036/** 3037 * Ends the most-recently pushed debug group. 3038 * 3039 * On Direct3D 12, using SDL_PopGPUDebugGroup requires WinPixEventRuntime.dll 3040 * to be in your PATH or in the same directory as your executable. See 3041 * [here](https://devblogs.microsoft.com/pix/winpixeventruntime/) 3042 * for instructions on how to obtain it. 3043 * 3044 * \param command_buffer a command buffer. 3045 * 3046 * \since This function is available since SDL 3.2.0. 3047 * 3048 * \sa SDL_PushGPUDebugGroup 3049 */ 3050extern SDL_DECLSPEC void SDLCALL SDL_PopGPUDebugGroup( 3051 SDL_GPUCommandBuffer *command_buffer); 3052 3053/* Disposal */ 3054 3055/** 3056 * Frees the given texture as soon as it is safe to do so. 3057 * 3058 * You must not reference the texture after calling this function. 3059 * 3060 * \param device a GPU context. 3061 * \param texture a texture to be destroyed. 3062 * 3063 * \since This function is available since SDL 3.2.0. 3064 */ 3065extern SDL_DECLSPEC void SDLCALL SDL_ReleaseGPUTexture( 3066 SDL_GPUDevice *device, 3067 SDL_GPUTexture *texture); 3068 3069/** 3070 * Frees the given sampler as soon as it is safe to do so. 3071 * 3072 * You must not reference the sampler after calling this function. 3073 * 3074 * \param device a GPU context. 3075 * \param sampler a sampler to be destroyed. 3076 * 3077 * \since This function is available since SDL 3.2.0. 3078 */ 3079extern SDL_DECLSPEC void SDLCALL SDL_ReleaseGPUSampler( 3080 SDL_GPUDevice *device, 3081 SDL_GPUSampler *sampler); 3082 3083/** 3084 * Frees the given buffer as soon as it is safe to do so. 3085 * 3086 * You must not reference the buffer after calling this function. 3087 * 3088 * \param device a GPU context. 3089 * \param buffer a buffer to be destroyed. 3090 * 3091 * \since This function is available since SDL 3.2.0. 3092 */ 3093extern SDL_DECLSPEC void SDLCALL SDL_ReleaseGPUBuffer( 3094 SDL_GPUDevice *device, 3095 SDL_GPUBuffer *buffer); 3096 3097/** 3098 * Frees the given transfer buffer as soon as it is safe to do so. 3099 * 3100 * You must not reference the transfer buffer after calling this function. 3101 * 3102 * \param device a GPU context. 3103 * \param transfer_buffer a transfer buffer to be destroyed. 3104 * 3105 * \since This function is available since SDL 3.2.0. 3106 */ 3107extern SDL_DECLSPEC void SDLCALL SDL_ReleaseGPUTransferBuffer( 3108 SDL_GPUDevice *device, 3109 SDL_GPUTransferBuffer *transfer_buffer); 3110 3111/** 3112 * Frees the given compute pipeline as soon as it is safe to do so. 3113 * 3114 * You must not reference the compute pipeline after calling this function. 3115 * 3116 * \param device a GPU context. 3117 * \param compute_pipeline a compute pipeline to be destroyed. 3118 * 3119 * \since This function is available since SDL 3.2.0. 3120 */ 3121extern SDL_DECLSPEC void SDLCALL SDL_ReleaseGPUComputePipeline( 3122 SDL_GPUDevice *device, 3123 SDL_GPUComputePipeline *compute_pipeline); 3124 3125/** 3126 * Frees the given shader as soon as it is safe to do so. 3127 * 3128 * You must not reference the shader after calling this function. 3129 * 3130 * \param device a GPU context. 3131 * \param shader a shader to be destroyed. 3132 * 3133 * \since This function is available since SDL 3.2.0. 3134 */ 3135extern SDL_DECLSPEC void SDLCALL SDL_ReleaseGPUShader( 3136 SDL_GPUDevice *device, 3137 SDL_GPUShader *shader); 3138 3139/** 3140 * Frees the given graphics pipeline as soon as it is safe to do so. 3141 * 3142 * You must not reference the graphics pipeline after calling this function. 3143 * 3144 * \param device a GPU context. 3145 * \param graphics_pipeline a graphics pipeline to be destroyed. 3146 * 3147 * \since This function is available since SDL 3.2.0. 3148 */ 3149extern SDL_DECLSPEC void SDLCALL SDL_ReleaseGPUGraphicsPipeline( 3150 SDL_GPUDevice *device, 3151 SDL_GPUGraphicsPipeline *graphics_pipeline); 3152 3153/** 3154 * Acquire a command buffer. 3155 * 3156 * This command buffer is managed by the implementation and should not be 3157 * freed by the user. The command buffer may only be used on the thread it was 3158 * acquired on. The command buffer should be submitted on the thread it was 3159 * acquired on. 3160 * 3161 * It is valid to acquire multiple command buffers on the same thread at once. 3162 * In fact a common design pattern is to acquire two command buffers per frame 3163 * where one is dedicated to render and compute passes and the other is 3164 * dedicated to copy passes and other preparatory work such as generating 3165 * mipmaps. Interleaving commands between the two command buffers reduces the 3166 * total amount of passes overall which improves rendering performance. 3167 * 3168 * \param device a GPU context. 3169 * \returns a command buffer, or NULL on failure; call SDL_GetError() for more 3170 * information. 3171 * 3172 * \since This function is available since SDL 3.2.0. 3173 * 3174 * \sa SDL_SubmitGPUCommandBuffer 3175 * \sa SDL_SubmitGPUCommandBufferAndAcquireFence 3176 */ 3177extern SDL_DECLSPEC SDL_GPUCommandBuffer * SDLCALL SDL_AcquireGPUCommandBuffer( 3178 SDL_GPUDevice *device); 3179 3180/* Uniform Data */ 3181 3182/** 3183 * Pushes data to a vertex uniform slot on the command buffer. 3184 * 3185 * Subsequent draw calls in this command buffer will use this uniform data. 3186 * 3187 * The data being pushed must respect std140 layout conventions. In practical 3188 * terms this means you must ensure that vec3 and vec4 fields are 16-byte 3189 * aligned. 3190 * 3191 * For detailed information about accessing uniform data from a shader, please 3192 * refer to SDL_CreateGPUShader. 3193 * 3194 * \param command_buffer a command buffer. 3195 * \param slot_index the vertex uniform slot to push data to. 3196 * \param data client data to write. 3197 * \param length the length of the data to write. 3198 * 3199 * \since This function is available since SDL 3.2.0. 3200 */ 3201extern SDL_DECLSPEC void SDLCALL SDL_PushGPUVertexUniformData( 3202 SDL_GPUCommandBuffer *command_buffer, 3203 Uint32 slot_index, 3204 const void *data, 3205 Uint32 length); 3206 3207/** 3208 * Pushes data to a fragment uniform slot on the command buffer. 3209 * 3210 * Subsequent draw calls in this command buffer will use this uniform data. 3211 * 3212 * The data being pushed must respect std140 layout conventions. In practical 3213 * terms this means you must ensure that vec3 and vec4 fields are 16-byte 3214 * aligned. 3215 * 3216 * \param command_buffer a command buffer. 3217 * \param slot_index the fragment uniform slot to push data to. 3218 * \param data client data to write. 3219 * \param length the length of the data to write. 3220 * 3221 * \since This function is available since SDL 3.2.0. 3222 */ 3223extern SDL_DECLSPEC void SDLCALL SDL_PushGPUFragmentUniformData( 3224 SDL_GPUCommandBuffer *command_buffer, 3225 Uint32 slot_index, 3226 const void *data, 3227 Uint32 length); 3228 3229/** 3230 * Pushes data to a uniform slot on the command buffer. 3231 * 3232 * Subsequent draw calls in this command buffer will use this uniform data. 3233 * 3234 * The data being pushed must respect std140 layout conventions. In practical 3235 * terms this means you must ensure that vec3 and vec4 fields are 16-byte 3236 * aligned. 3237 * 3238 * \param command_buffer a command buffer. 3239 * \param slot_index the uniform slot to push data to. 3240 * \param data client data to write. 3241 * \param length the length of the data to write. 3242 * 3243 * \since This function is available since SDL 3.2.0. 3244 */ 3245extern SDL_DECLSPEC void SDLCALL SDL_PushGPUComputeUniformData( 3246 SDL_GPUCommandBuffer *command_buffer, 3247 Uint32 slot_index, 3248 const void *data, 3249 Uint32 length); 3250 3251/* Graphics State */ 3252 3253/** 3254 * Begins a render pass on a command buffer. 3255 * 3256 * A render pass consists of a set of texture subresources (or depth slices in 3257 * the 3D texture case) which will be rendered to during the render pass, 3258 * along with corresponding clear values and load/store operations. All 3259 * operations related to graphics pipelines must take place inside of a render 3260 * pass. A default viewport and scissor state are automatically set when this 3261 * is called. You cannot begin another render pass, or begin a compute pass or 3262 * copy pass until you have ended the render pass. 3263 * 3264 * Using SDL_GPU_LOADOP_LOAD before any contents have been written to the 3265 * texture subresource will result in undefined behavior. SDL_GPU_LOADOP_CLEAR 3266 * will set the contents of the texture subresource to a single value before 3267 * any rendering is performed. It's fine to do an empty render pass using 3268 * SDL_GPU_STOREOP_STORE to clear a texture, but in general it's better to 3269 * think of clearing not as an independent operation but as something that's 3270 * done as the beginning of a render pass. 3271 * 3272 * \param command_buffer a command buffer. 3273 * \param color_target_infos an array of texture subresources with 3274 * corresponding clear values and load/store ops. 3275 * \param num_color_targets the number of color targets in the 3276 * color_target_infos array. 3277 * \param depth_stencil_target_info a texture subresource with corresponding 3278 * clear value and load/store ops, may be 3279 * NULL. 3280 * \returns a render pass handle. 3281 * 3282 * \since This function is available since SDL 3.2.0. 3283 * 3284 * \sa SDL_EndGPURenderPass 3285 */ 3286extern SDL_DECLSPEC SDL_GPURenderPass * SDLCALL SDL_BeginGPURenderPass( 3287 SDL_GPUCommandBuffer *command_buffer, 3288 const SDL_GPUColorTargetInfo *color_target_infos, 3289 Uint32 num_color_targets, 3290 const SDL_GPUDepthStencilTargetInfo *depth_stencil_target_info); 3291 3292/** 3293 * Binds a graphics pipeline on a render pass to be used in rendering. 3294 * 3295 * A graphics pipeline must be bound before making any draw calls. 3296 * 3297 * \param render_pass a render pass handle. 3298 * \param graphics_pipeline the graphics pipeline to bind. 3299 * 3300 * \since This function is available since SDL 3.2.0. 3301 */ 3302extern SDL_DECLSPEC void SDLCALL SDL_BindGPUGraphicsPipeline( 3303 SDL_GPURenderPass *render_pass, 3304 SDL_GPUGraphicsPipeline *graphics_pipeline); 3305 3306/** 3307 * Sets the current viewport state on a command buffer. 3308 * 3309 * \param render_pass a render pass handle. 3310 * \param viewport the viewport to set. 3311 * 3312 * \since This function is available since SDL 3.2.0. 3313 */ 3314extern SDL_DECLSPEC void SDLCALL SDL_SetGPUViewport( 3315 SDL_GPURenderPass *render_pass, 3316 const SDL_GPUViewport *viewport); 3317 3318/** 3319 * Sets the current scissor state on a command buffer. 3320 * 3321 * \param render_pass a render pass handle. 3322 * \param scissor the scissor area to set. 3323 * 3324 * \since This function is available since SDL 3.2.0. 3325 */ 3326extern SDL_DECLSPEC void SDLCALL SDL_SetGPUScissor( 3327 SDL_GPURenderPass *render_pass, 3328 const SDL_Rect *scissor); 3329 3330/** 3331 * Sets the current blend constants on a command buffer. 3332 * 3333 * \param render_pass a render pass handle. 3334 * \param blend_constants the blend constant color. 3335 * 3336 * \since This function is available since SDL 3.2.0. 3337 * 3338 * \sa SDL_GPU_BLENDFACTOR_CONSTANT_COLOR 3339 * \sa SDL_GPU_BLENDFACTOR_ONE_MINUS_CONSTANT_COLOR 3340 */ 3341extern SDL_DECLSPEC void SDLCALL SDL_SetGPUBlendConstants( 3342 SDL_GPURenderPass *render_pass, 3343 SDL_FColor blend_constants); 3344 3345/** 3346 * Sets the current stencil reference value on a command buffer. 3347 * 3348 * \param render_pass a render pass handle. 3349 * \param reference the stencil reference value to set. 3350 * 3351 * \since This function is available since SDL 3.2.0. 3352 */ 3353extern SDL_DECLSPEC void SDLCALL SDL_SetGPUStencilReference( 3354 SDL_GPURenderPass *render_pass, 3355 Uint8 reference); 3356 3357/** 3358 * Binds vertex buffers on a command buffer for use with subsequent draw 3359 * calls. 3360 * 3361 * \param render_pass a render pass handle. 3362 * \param first_slot the vertex buffer slot to begin binding from. 3363 * \param bindings an array of SDL_GPUBufferBinding structs containing vertex 3364 * buffers and offset values. 3365 * \param num_bindings the number of bindings in the bindings array. 3366 * 3367 * \since This function is available since SDL 3.2.0. 3368 */ 3369extern SDL_DECLSPEC void SDLCALL SDL_BindGPUVertexBuffers( 3370 SDL_GPURenderPass *render_pass, 3371 Uint32 first_slot, 3372 const SDL_GPUBufferBinding *bindings, 3373 Uint32 num_bindings); 3374 3375/** 3376 * Binds an index buffer on a command buffer for use with subsequent draw 3377 * calls. 3378 * 3379 * \param render_pass a render pass handle. 3380 * \param binding a pointer to a struct containing an index buffer and offset. 3381 * \param index_element_size whether the index values in the buffer are 16- or 3382 * 32-bit. 3383 * 3384 * \since This function is available since SDL 3.2.0. 3385 */ 3386extern SDL_DECLSPEC void SDLCALL SDL_BindGPUIndexBuffer( 3387 SDL_GPURenderPass *render_pass, 3388 const SDL_GPUBufferBinding *binding, 3389 SDL_GPUIndexElementSize index_element_size); 3390 3391/** 3392 * Binds texture-sampler pairs for use on the vertex shader. 3393 * 3394 * The textures must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER. 3395 * 3396 * Be sure your shader is set up according to the requirements documented in 3397 * SDL_CreateGPUShader(). 3398 * 3399 * \param render_pass a render pass handle. 3400 * \param first_slot the vertex sampler slot to begin binding from. 3401 * \param texture_sampler_bindings an array of texture-sampler binding 3402 * structs. 3403 * \param num_bindings the number of texture-sampler pairs to bind from the 3404 * array. 3405 * 3406 * \since This function is available since SDL 3.2.0. 3407 * 3408 * \sa SDL_CreateGPUShader 3409 */ 3410extern SDL_DECLSPEC void SDLCALL SDL_BindGPUVertexSamplers( 3411 SDL_GPURenderPass *render_pass, 3412 Uint32 first_slot, 3413 const SDL_GPUTextureSamplerBinding *texture_sampler_bindings, 3414 Uint32 num_bindings); 3415 3416/** 3417 * Binds storage textures for use on the vertex shader. 3418 * 3419 * These textures must have been created with 3420 * SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ. 3421 * 3422 * Be sure your shader is set up according to the requirements documented in 3423 * SDL_CreateGPUShader(). 3424 * 3425 * \param render_pass a render pass handle. 3426 * \param first_slot the vertex storage texture slot to begin binding from. 3427 * \param storage_textures an array of storage textures. 3428 * \param num_bindings the number of storage texture to bind from the array. 3429 * 3430 * \since This function is available since SDL 3.2.0. 3431 * 3432 * \sa SDL_CreateGPUShader 3433 */ 3434extern SDL_DECLSPEC void SDLCALL SDL_BindGPUVertexStorageTextures( 3435 SDL_GPURenderPass *render_pass, 3436 Uint32 first_slot, 3437 SDL_GPUTexture *const *storage_textures, 3438 Uint32 num_bindings); 3439 3440/** 3441 * Binds storage buffers for use on the vertex shader. 3442 * 3443 * These buffers must have been created with 3444 * SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ. 3445 * 3446 * Be sure your shader is set up according to the requirements documented in 3447 * SDL_CreateGPUShader(). 3448 * 3449 * \param render_pass a render pass handle. 3450 * \param first_slot the vertex storage buffer slot to begin binding from. 3451 * \param storage_buffers an array of buffers. 3452 * \param num_bindings the number of buffers to bind from the array. 3453 * 3454 * \since This function is available since SDL 3.2.0. 3455 * 3456 * \sa SDL_CreateGPUShader 3457 */ 3458extern SDL_DECLSPEC void SDLCALL SDL_BindGPUVertexStorageBuffers( 3459 SDL_GPURenderPass *render_pass, 3460 Uint32 first_slot, 3461 SDL_GPUBuffer *const *storage_buffers, 3462 Uint32 num_bindings); 3463 3464/** 3465 * Binds texture-sampler pairs for use on the fragment shader. 3466 * 3467 * The textures must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER. 3468 * 3469 * Be sure your shader is set up according to the requirements documented in 3470 * SDL_CreateGPUShader(). 3471 * 3472 * \param render_pass a render pass handle. 3473 * \param first_slot the fragment sampler slot to begin binding from. 3474 * \param texture_sampler_bindings an array of texture-sampler binding 3475 * structs. 3476 * \param num_bindings the number of texture-sampler pairs to bind from the 3477 * array. 3478 * 3479 * \since This function is available since SDL 3.2.0. 3480 * 3481 * \sa SDL_CreateGPUShader 3482 */ 3483extern SDL_DECLSPEC void SDLCALL SDL_BindGPUFragmentSamplers( 3484 SDL_GPURenderPass *render_pass, 3485 Uint32 first_slot, 3486 const SDL_GPUTextureSamplerBinding *texture_sampler_bindings, 3487 Uint32 num_bindings); 3488 3489/** 3490 * Binds storage textures for use on the fragment shader. 3491 * 3492 * These textures must have been created with 3493 * SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ. 3494 * 3495 * Be sure your shader is set up according to the requirements documented in 3496 * SDL_CreateGPUShader(). 3497 * 3498 * \param render_pass a render pass handle. 3499 * \param first_slot the fragment storage texture slot to begin binding from. 3500 * \param storage_textures an array of storage textures. 3501 * \param num_bindings the number of storage textures to bind from the array. 3502 * 3503 * \since This function is available since SDL 3.2.0. 3504 * 3505 * \sa SDL_CreateGPUShader 3506 */ 3507extern SDL_DECLSPEC void SDLCALL SDL_BindGPUFragmentStorageTextures( 3508 SDL_GPURenderPass *render_pass, 3509 Uint32 first_slot, 3510 SDL_GPUTexture *const *storage_textures, 3511 Uint32 num_bindings); 3512 3513/** 3514 * Binds storage buffers for use on the fragment shader. 3515 * 3516 * These buffers must have been created with 3517 * SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ. 3518 * 3519 * Be sure your shader is set up according to the requirements documented in 3520 * SDL_CreateGPUShader(). 3521 * 3522 * \param render_pass a render pass handle. 3523 * \param first_slot the fragment storage buffer slot to begin binding from. 3524 * \param storage_buffers an array of storage buffers. 3525 * \param num_bindings the number of storage buffers to bind from the array. 3526 * 3527 * \since This function is available since SDL 3.2.0. 3528 * 3529 * \sa SDL_CreateGPUShader 3530 */ 3531extern SDL_DECLSPEC void SDLCALL SDL_BindGPUFragmentStorageBuffers( 3532 SDL_GPURenderPass *render_pass, 3533 Uint32 first_slot, 3534 SDL_GPUBuffer *const *storage_buffers, 3535 Uint32 num_bindings); 3536 3537/* Drawing */ 3538 3539/** 3540 * Draws data using bound graphics state with an index buffer and instancing 3541 * enabled. 3542 * 3543 * You must not call this function before binding a graphics pipeline. 3544 * 3545 * Note that the `first_vertex` and `first_instance` parameters are NOT 3546 * compatible with built-in vertex/instance ID variables in shaders (for 3547 * example, SV_VertexID); GPU APIs and shader languages do not define these 3548 * built-in variables consistently, so if your shader depends on them, the 3549 * only way to keep behavior consistent and portable is to always pass 0 for 3550 * the correlating parameter in the draw calls. 3551 * 3552 * \param render_pass a render pass handle. 3553 * \param num_indices the number of indices to draw per instance. 3554 * \param num_instances the number of instances to draw. 3555 * \param first_index the starting index within the index buffer. 3556 * \param vertex_offset value added to vertex index before indexing into the 3557 * vertex buffer. 3558 * \param first_instance the ID of the first instance to draw. 3559 * 3560 * \since This function is available since SDL 3.2.0. 3561 */ 3562extern SDL_DECLSPEC void SDLCALL SDL_DrawGPUIndexedPrimitives( 3563 SDL_GPURenderPass *render_pass, 3564 Uint32 num_indices, 3565 Uint32 num_instances, 3566 Uint32 first_index, 3567 Sint32 vertex_offset, 3568 Uint32 first_instance); 3569 3570/** 3571 * Draws data using bound graphics state. 3572 * 3573 * You must not call this function before binding a graphics pipeline. 3574 * 3575 * Note that the `first_vertex` and `first_instance` parameters are NOT 3576 * compatible with built-in vertex/instance ID variables in shaders (for 3577 * example, SV_VertexID); GPU APIs and shader languages do not define these 3578 * built-in variables consistently, so if your shader depends on them, the 3579 * only way to keep behavior consistent and portable is to always pass 0 for 3580 * the correlating parameter in the draw calls. 3581 * 3582 * \param render_pass a render pass handle. 3583 * \param num_vertices the number of vertices to draw. 3584 * \param num_instances the number of instances that will be drawn. 3585 * \param first_vertex the index of the first vertex to draw. 3586 * \param first_instance the ID of the first instance to draw. 3587 * 3588 * \since This function is available since SDL 3.2.0. 3589 */ 3590extern SDL_DECLSPEC void SDLCALL SDL_DrawGPUPrimitives( 3591 SDL_GPURenderPass *render_pass, 3592 Uint32 num_vertices, 3593 Uint32 num_instances, 3594 Uint32 first_vertex, 3595 Uint32 first_instance); 3596 3597/** 3598 * Draws data using bound graphics state and with draw parameters set from a 3599 * buffer. 3600 * 3601 * The buffer must consist of tightly-packed draw parameter sets that each 3602 * match the layout of SDL_GPUIndirectDrawCommand. You must not call this 3603 * function before binding a graphics pipeline. 3604 * 3605 * \param render_pass a render pass handle. 3606 * \param buffer a buffer containing draw parameters. 3607 * \param offset the offset to start reading from the draw buffer. 3608 * \param draw_count the number of draw parameter sets that should be read 3609 * from the draw buffer. 3610 * 3611 * \since This function is available since SDL 3.2.0. 3612 */ 3613extern SDL_DECLSPEC void SDLCALL SDL_DrawGPUPrimitivesIndirect( 3614 SDL_GPURenderPass *render_pass, 3615 SDL_GPUBuffer *buffer, 3616 Uint32 offset, 3617 Uint32 draw_count); 3618 3619/** 3620 * Draws data using bound graphics state with an index buffer enabled and with 3621 * draw parameters set from a buffer. 3622 * 3623 * The buffer must consist of tightly-packed draw parameter sets that each 3624 * match the layout of SDL_GPUIndexedIndirectDrawCommand. You must not call 3625 * this function before binding a graphics pipeline. 3626 * 3627 * \param render_pass a render pass handle. 3628 * \param buffer a buffer containing draw parameters. 3629 * \param offset the offset to start reading from the draw buffer. 3630 * \param draw_count the number of draw parameter sets that should be read 3631 * from the draw buffer. 3632 * 3633 * \since This function is available since SDL 3.2.0. 3634 */ 3635extern SDL_DECLSPEC void SDLCALL SDL_DrawGPUIndexedPrimitivesIndirect( 3636 SDL_GPURenderPass *render_pass, 3637 SDL_GPUBuffer *buffer, 3638 Uint32 offset, 3639 Uint32 draw_count); 3640 3641/** 3642 * Ends the given render pass. 3643 * 3644 * All bound graphics state on the render pass command buffer is unset. The 3645 * render pass handle is now invalid. 3646 * 3647 * \param render_pass a render pass handle. 3648 * 3649 * \since This function is available since SDL 3.2.0. 3650 */ 3651extern SDL_DECLSPEC void SDLCALL SDL_EndGPURenderPass( 3652 SDL_GPURenderPass *render_pass); 3653 3654/* Compute Pass */ 3655 3656/** 3657 * Begins a compute pass on a command buffer. 3658 * 3659 * A compute pass is defined by a set of texture subresources and buffers that 3660 * may be written to by compute pipelines. These textures and buffers must 3661 * have been created with the COMPUTE_STORAGE_WRITE bit or the 3662 * COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE bit. If you do not create a texture 3663 * with COMPUTE_STORAGE_SIMULTANEOUS_READ_WRITE, you must not read from the 3664 * texture in the compute pass. All operations related to compute pipelines 3665 * must take place inside of a compute pass. You must not begin another 3666 * compute pass, or a render pass or copy pass before ending the compute pass. 3667 * 3668 * A VERY IMPORTANT NOTE - Reads and writes in compute passes are NOT 3669 * implicitly synchronized. This means you may cause data races by both 3670 * reading and writing a resource region in a compute pass, or by writing 3671 * multiple times to a resource region. If your compute work depends on 3672 * reading the completed output from a previous dispatch, you MUST end the 3673 * current compute pass and begin a new one before you can safely access the 3674 * data. Otherwise you will receive unexpected results. Reading and writing a 3675 * texture in the same compute pass is only supported by specific texture 3676 * formats. Make sure you check the format support! 3677 * 3678 * \param command_buffer a command buffer. 3679 * \param storage_texture_bindings an array of writeable storage texture 3680 * binding structs. 3681 * \param num_storage_texture_bindings the number of storage textures to bind 3682 * from the array. 3683 * \param storage_buffer_bindings an array of writeable storage buffer binding 3684 * structs. 3685 * \param num_storage_buffer_bindings the number of storage buffers to bind 3686 * from the array. 3687 * \returns a compute pass handle. 3688 * 3689 * \since This function is available since SDL 3.2.0. 3690 * 3691 * \sa SDL_EndGPUComputePass 3692 */ 3693extern SDL_DECLSPEC SDL_GPUComputePass * SDLCALL SDL_BeginGPUComputePass( 3694 SDL_GPUCommandBuffer *command_buffer, 3695 const SDL_GPUStorageTextureReadWriteBinding *storage_texture_bindings, 3696 Uint32 num_storage_texture_bindings, 3697 const SDL_GPUStorageBufferReadWriteBinding *storage_buffer_bindings, 3698 Uint32 num_storage_buffer_bindings); 3699 3700/** 3701 * Binds a compute pipeline on a command buffer for use in compute dispatch. 3702 * 3703 * \param compute_pass a compute pass handle. 3704 * \param compute_pipeline a compute pipeline to bind. 3705 * 3706 * \since This function is available since SDL 3.2.0. 3707 */ 3708extern SDL_DECLSPEC void SDLCALL SDL_BindGPUComputePipeline( 3709 SDL_GPUComputePass *compute_pass, 3710 SDL_GPUComputePipeline *compute_pipeline); 3711 3712/** 3713 * Binds texture-sampler pairs for use on the compute shader. 3714 * 3715 * The textures must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER. 3716 * 3717 * Be sure your shader is set up according to the requirements documented in 3718 * SDL_CreateGPUComputePipeline(). 3719 * 3720 * \param compute_pass a compute pass handle. 3721 * \param first_slot the compute sampler slot to begin binding from. 3722 * \param texture_sampler_bindings an array of texture-sampler binding 3723 * structs. 3724 * \param num_bindings the number of texture-sampler bindings to bind from the 3725 * array. 3726 * 3727 * \since This function is available since SDL 3.2.0. 3728 * 3729 * \sa SDL_CreateGPUComputePipeline 3730 */ 3731extern SDL_DECLSPEC void SDLCALL SDL_BindGPUComputeSamplers( 3732 SDL_GPUComputePass *compute_pass, 3733 Uint32 first_slot, 3734 const SDL_GPUTextureSamplerBinding *texture_sampler_bindings, 3735 Uint32 num_bindings); 3736 3737/** 3738 * Binds storage textures as readonly for use on the compute pipeline. 3739 * 3740 * These textures must have been created with 3741 * SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ. 3742 * 3743 * Be sure your shader is set up according to the requirements documented in 3744 * SDL_CreateGPUComputePipeline(). 3745 * 3746 * \param compute_pass a compute pass handle. 3747 * \param first_slot the compute storage texture slot to begin binding from. 3748 * \param storage_textures an array of storage textures. 3749 * \param num_bindings the number of storage textures to bind from the array. 3750 * 3751 * \since This function is available since SDL 3.2.0. 3752 * 3753 * \sa SDL_CreateGPUComputePipeline 3754 */ 3755extern SDL_DECLSPEC void SDLCALL SDL_BindGPUComputeStorageTextures( 3756 SDL_GPUComputePass *compute_pass, 3757 Uint32 first_slot, 3758 SDL_GPUTexture *const *storage_textures, 3759 Uint32 num_bindings); 3760 3761/** 3762 * Binds storage buffers as readonly for use on the compute pipeline. 3763 * 3764 * These buffers must have been created with 3765 * SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ. 3766 * 3767 * Be sure your shader is set up according to the requirements documented in 3768 * SDL_CreateGPUComputePipeline(). 3769 * 3770 * \param compute_pass a compute pass handle. 3771 * \param first_slot the compute storage buffer slot to begin binding from. 3772 * \param storage_buffers an array of storage buffer binding structs. 3773 * \param num_bindings the number of storage buffers to bind from the array. 3774 * 3775 * \since This function is available since SDL 3.2.0. 3776 * 3777 * \sa SDL_CreateGPUComputePipeline 3778 */ 3779extern SDL_DECLSPEC void SDLCALL SDL_BindGPUComputeStorageBuffers( 3780 SDL_GPUComputePass *compute_pass, 3781 Uint32 first_slot, 3782 SDL_GPUBuffer *const *storage_buffers, 3783 Uint32 num_bindings); 3784 3785/** 3786 * Dispatches compute work. 3787 * 3788 * You must not call this function before binding a compute pipeline. 3789 * 3790 * A VERY IMPORTANT NOTE If you dispatch multiple times in a compute pass, and 3791 * the dispatches write to the same resource region as each other, there is no 3792 * guarantee of which order the writes will occur. If the write order matters, 3793 * you MUST end the compute pass and begin another one. 3794 * 3795 * \param compute_pass a compute pass handle. 3796 * \param groupcount_x number of local workgroups to dispatch in the X 3797 * dimension. 3798 * \param groupcount_y number of local workgroups to dispatch in the Y 3799 * dimension. 3800 * \param groupcount_z number of local workgroups to dispatch in the Z 3801 * dimension. 3802 * 3803 * \since This function is available since SDL 3.2.0. 3804 */ 3805extern SDL_DECLSPEC void SDLCALL SDL_DispatchGPUCompute( 3806 SDL_GPUComputePass *compute_pass, 3807 Uint32 groupcount_x, 3808 Uint32 groupcount_y, 3809 Uint32 groupcount_z); 3810 3811/** 3812 * Dispatches compute work with parameters set from a buffer. 3813 * 3814 * The buffer layout should match the layout of 3815 * SDL_GPUIndirectDispatchCommand. You must not call this function before 3816 * binding a compute pipeline. 3817 * 3818 * A VERY IMPORTANT NOTE If you dispatch multiple times in a compute pass, and 3819 * the dispatches write to the same resource region as each other, there is no 3820 * guarantee of which order the writes will occur. If the write order matters, 3821 * you MUST end the compute pass and begin another one. 3822 * 3823 * \param compute_pass a compute pass handle. 3824 * \param buffer a buffer containing dispatch parameters. 3825 * \param offset the offset to start reading from the dispatch buffer. 3826 * 3827 * \since This function is available since SDL 3.2.0. 3828 */ 3829extern SDL_DECLSPEC void SDLCALL SDL_DispatchGPUComputeIndirect( 3830 SDL_GPUComputePass *compute_pass, 3831 SDL_GPUBuffer *buffer, 3832 Uint32 offset); 3833 3834/** 3835 * Ends the current compute pass. 3836 * 3837 * All bound compute state on the command buffer is unset. The compute pass 3838 * handle is now invalid. 3839 * 3840 * \param compute_pass a compute pass handle. 3841 * 3842 * \since This function is available since SDL 3.2.0. 3843 */ 3844extern SDL_DECLSPEC void SDLCALL SDL_EndGPUComputePass( 3845 SDL_GPUComputePass *compute_pass); 3846 3847/* TransferBuffer Data */ 3848 3849/** 3850 * Maps a transfer buffer into application address space. 3851 * 3852 * You must unmap the transfer buffer before encoding upload commands. The 3853 * memory is owned by the graphics driver - do NOT call SDL_free() on the 3854 * returned pointer. 3855 * 3856 * \param device a GPU context. 3857 * \param transfer_buffer a transfer buffer. 3858 * \param cycle if true, cycles the transfer buffer if it is already bound. 3859 * \returns the address of the mapped transfer buffer memory, or NULL on 3860 * failure; call SDL_GetError() for more information. 3861 * 3862 * \since This function is available since SDL 3.2.0. 3863 */ 3864extern SDL_DECLSPEC void * SDLCALL SDL_MapGPUTransferBuffer( 3865 SDL_GPUDevice *device, 3866 SDL_GPUTransferBuffer *transfer_buffer, 3867 bool cycle); 3868 3869/** 3870 * Unmaps a previously mapped transfer buffer. 3871 * 3872 * \param device a GPU context. 3873 * \param transfer_buffer a previously mapped transfer buffer. 3874 * 3875 * \since This function is available since SDL 3.2.0. 3876 */ 3877extern SDL_DECLSPEC void SDLCALL SDL_UnmapGPUTransferBuffer( 3878 SDL_GPUDevice *device, 3879 SDL_GPUTransferBuffer *transfer_buffer); 3880 3881/* Copy Pass */ 3882 3883/** 3884 * Begins a copy pass on a command buffer. 3885 * 3886 * All operations related to copying to or from buffers or textures take place 3887 * inside a copy pass. You must not begin another copy pass, or a render pass 3888 * or compute pass before ending the copy pass. 3889 * 3890 * \param command_buffer a command buffer. 3891 * \returns a copy pass handle. 3892 * 3893 * \since This function is available since SDL 3.2.0. 3894 * 3895 * \sa SDL_EndGPUCopyPass 3896 */ 3897extern SDL_DECLSPEC SDL_GPUCopyPass * SDLCALL SDL_BeginGPUCopyPass( 3898 SDL_GPUCommandBuffer *command_buffer); 3899 3900/** 3901 * Uploads data from a transfer buffer to a texture. 3902 * 3903 * The upload occurs on the GPU timeline. You may assume that the upload has 3904 * finished in subsequent commands. 3905 * 3906 * You must align the data in the transfer buffer to a multiple of the texel 3907 * size of the texture format. 3908 * 3909 * \param copy_pass a copy pass handle. 3910 * \param source the source transfer buffer with image layout information. 3911 * \param destination the destination texture region. 3912 * \param cycle if true, cycles the texture if the texture is bound, otherwise 3913 * overwrites the data. 3914 * 3915 * \since This function is available since SDL 3.2.0. 3916 */ 3917extern SDL_DECLSPEC void SDLCALL SDL_UploadToGPUTexture( 3918 SDL_GPUCopyPass *copy_pass, 3919 const SDL_GPUTextureTransferInfo *source, 3920 const SDL_GPUTextureRegion *destination, 3921 bool cycle); 3922 3923/** 3924 * Uploads data from a transfer buffer to a buffer. 3925 * 3926 * The upload occurs on the GPU timeline. You may assume that the upload has 3927 * finished in subsequent commands. 3928 * 3929 * \param copy_pass a copy pass handle. 3930 * \param source the source transfer buffer with offset. 3931 * \param destination the destination buffer with offset and size. 3932 * \param cycle if true, cycles the buffer if it is already bound, otherwise 3933 * overwrites the data. 3934 * 3935 * \since This function is available since SDL 3.2.0. 3936 */ 3937extern SDL_DECLSPEC void SDLCALL SDL_UploadToGPUBuffer( 3938 SDL_GPUCopyPass *copy_pass, 3939 const SDL_GPUTransferBufferLocation *source, 3940 const SDL_GPUBufferRegion *destination, 3941 bool cycle); 3942 3943/** 3944 * Performs a texture-to-texture copy. 3945 * 3946 * This copy occurs on the GPU timeline. You may assume the copy has finished 3947 * in subsequent commands. 3948 * 3949 * This function does not support copying between depth and color textures. 3950 * For those, copy the texture to a buffer and then to the destination 3951 * texture. 3952 * 3953 * \param copy_pass a copy pass handle. 3954 * \param source a source texture region. 3955 * \param destination a destination texture region. 3956 * \param w the width of the region to copy. 3957 * \param h the height of the region to copy. 3958 * \param d the depth of the region to copy. 3959 * \param cycle if true, cycles the destination texture if the destination 3960 * texture is bound, otherwise overwrites the data. 3961 * 3962 * \since This function is available since SDL 3.2.0. 3963 */ 3964extern SDL_DECLSPEC void SDLCALL SDL_CopyGPUTextureToTexture( 3965 SDL_GPUCopyPass *copy_pass, 3966 const SDL_GPUTextureLocation *source, 3967 const SDL_GPUTextureLocation *destination, 3968 Uint32 w, 3969 Uint32 h, 3970 Uint32 d, 3971 bool cycle); 3972 3973/** 3974 * Performs a buffer-to-buffer copy. 3975 * 3976 * This copy occurs on the GPU timeline. You may assume the copy has finished 3977 * in subsequent commands. 3978 * 3979 * \param copy_pass a copy pass handle. 3980 * \param source the buffer and offset to copy from. 3981 * \param destination the buffer and offset to copy to. 3982 * \param size the length of the buffer to copy. 3983 * \param cycle if true, cycles the destination buffer if it is already bound, 3984 * otherwise overwrites the data. 3985 * 3986 * \since This function is available since SDL 3.2.0. 3987 */ 3988extern SDL_DECLSPEC void SDLCALL SDL_CopyGPUBufferToBuffer( 3989 SDL_GPUCopyPass *copy_pass, 3990 const SDL_GPUBufferLocation *source, 3991 const SDL_GPUBufferLocation *destination, 3992 Uint32 size, 3993 bool cycle); 3994 3995/** 3996 * Copies data from a texture to a transfer buffer on the GPU timeline. 3997 * 3998 * This data is not guaranteed to be copied until the command buffer fence is 3999 * signaled. 4000 * 4001 * \param copy_pass a copy pass handle. 4002 * \param source the source texture region. 4003 * \param destination the destination transfer buffer with image layout 4004 * information. 4005 * 4006 * \since This function is available since SDL 3.2.0. 4007 */ 4008extern SDL_DECLSPEC void SDLCALL SDL_DownloadFromGPUTexture( 4009 SDL_GPUCopyPass *copy_pass, 4010 const SDL_GPUTextureRegion *source, 4011 const SDL_GPUTextureTransferInfo *destination); 4012 4013/** 4014 * Copies data from a buffer to a transfer buffer on the GPU timeline. 4015 * 4016 * This data is not guaranteed to be copied until the command buffer fence is 4017 * signaled. 4018 * 4019 * \param copy_pass a copy pass handle. 4020 * \param source the source buffer with offset and size. 4021 * \param destination the destination transfer buffer with offset. 4022 * 4023 * \since This function is available since SDL 3.2.0. 4024 */ 4025extern SDL_DECLSPEC void SDLCALL SDL_DownloadFromGPUBuffer( 4026 SDL_GPUCopyPass *copy_pass, 4027 const SDL_GPUBufferRegion *source, 4028 const SDL_GPUTransferBufferLocation *destination); 4029 4030/** 4031 * Ends the current copy pass. 4032 * 4033 * \param copy_pass a copy pass handle. 4034 * 4035 * \since This function is available since SDL 3.2.0. 4036 */ 4037extern SDL_DECLSPEC void SDLCALL SDL_EndGPUCopyPass( 4038 SDL_GPUCopyPass *copy_pass); 4039 4040/** 4041 * Generates mipmaps for the given texture. 4042 * 4043 * This function must not be called inside of any pass. 4044 * 4045 * \param command_buffer a command_buffer. 4046 * \param texture a texture with more than 1 mip level. 4047 * 4048 * \since This function is available since SDL 3.2.0. 4049 */ 4050extern SDL_DECLSPEC void SDLCALL SDL_GenerateMipmapsForGPUTexture( 4051 SDL_GPUCommandBuffer *command_buffer, 4052 SDL_GPUTexture *texture); 4053 4054/** 4055 * Blits from a source texture region to a destination texture region. 4056 * 4057 * This function must not be called inside of any pass. 4058 * 4059 * \param command_buffer a command buffer. 4060 * \param info the blit info struct containing the blit parameters. 4061 * 4062 * \since This function is available since SDL 3.2.0. 4063 */ 4064extern SDL_DECLSPEC void SDLCALL SDL_BlitGPUTexture( 4065 SDL_GPUCommandBuffer *command_buffer, 4066 const SDL_GPUBlitInfo *info); 4067 4068/* Submission/Presentation */ 4069 4070/** 4071 * Determines whether a swapchain composition is supported by the window. 4072 * 4073 * The window must be claimed before calling this function. 4074 * 4075 * \param device a GPU context. 4076 * \param window an SDL_Window. 4077 * \param swapchain_composition the swapchain composition to check. 4078 * \returns true if supported, false if unsupported. 4079 * 4080 * \since This function is available since SDL 3.2.0. 4081 * 4082 * \sa SDL_ClaimWindowForGPUDevice 4083 */ 4084extern SDL_DECLSPEC bool SDLCALL SDL_WindowSupportsGPUSwapchainComposition( 4085 SDL_GPUDevice *device, 4086 SDL_Window *window, 4087 SDL_GPUSwapchainComposition swapchain_composition); 4088 4089/** 4090 * Determines whether a presentation mode is supported by the window. 4091 * 4092 * The window must be claimed before calling this function. 4093 * 4094 * \param device a GPU context. 4095 * \param window an SDL_Window. 4096 * \param present_mode the presentation mode to check. 4097 * \returns true if supported, false if unsupported. 4098 * 4099 * \since This function is available since SDL 3.2.0. 4100 * 4101 * \sa SDL_ClaimWindowForGPUDevice 4102 */ 4103extern SDL_DECLSPEC bool SDLCALL SDL_WindowSupportsGPUPresentMode( 4104 SDL_GPUDevice *device, 4105 SDL_Window *window, 4106 SDL_GPUPresentMode present_mode); 4107 4108/** 4109 * Claims a window, creating a swapchain structure for it. 4110 * 4111 * This must be called before SDL_AcquireGPUSwapchainTexture is called using 4112 * the window. You should only call this function from the thread that created 4113 * the window. 4114 * 4115 * The swapchain will be created with SDL_GPU_SWAPCHAINCOMPOSITION_SDR and 4116 * SDL_GPU_PRESENTMODE_VSYNC. If you want to have different swapchain 4117 * parameters, you must call SDL_SetGPUSwapchainParameters after claiming the 4118 * window. 4119 * 4120 * \param device a GPU context. 4121 * \param window an SDL_Window. 4122 * \returns true on success, or false on failure; call SDL_GetError() for more 4123 * information. 4124 * 4125 * \threadsafety This function should only be called from the thread that 4126 * created the window. 4127 * 4128 * \since This function is available since SDL 3.2.0. 4129 * 4130 * \sa SDL_WaitAndAcquireGPUSwapchainTexture 4131 * \sa SDL_ReleaseWindowFromGPUDevice 4132 * \sa SDL_WindowSupportsGPUPresentMode 4133 * \sa SDL_WindowSupportsGPUSwapchainComposition 4134 */ 4135extern SDL_DECLSPEC bool SDLCALL SDL_ClaimWindowForGPUDevice( 4136 SDL_GPUDevice *device, 4137 SDL_Window *window); 4138 4139/** 4140 * Unclaims a window, destroying its swapchain structure. 4141 * 4142 * \param device a GPU context. 4143 * \param window an SDL_Window that has been claimed. 4144 * 4145 * \since This function is available since SDL 3.2.0. 4146 * 4147 * \sa SDL_ClaimWindowForGPUDevice 4148 */ 4149extern SDL_DECLSPEC void SDLCALL SDL_ReleaseWindowFromGPUDevice( 4150 SDL_GPUDevice *device, 4151 SDL_Window *window); 4152 4153/** 4154 * Changes the swapchain parameters for the given claimed window. 4155 * 4156 * This function will fail if the requested present mode or swapchain 4157 * composition are unsupported by the device. Check if the parameters are 4158 * supported via SDL_WindowSupportsGPUPresentMode / 4159 * SDL_WindowSupportsGPUSwapchainComposition prior to calling this function. 4160 * 4161 * SDL_GPU_PRESENTMODE_VSYNC with SDL_GPU_SWAPCHAINCOMPOSITION_SDR is always 4162 * supported. 4163 * 4164 * \param device a GPU context. 4165 * \param window an SDL_Window that has been claimed. 4166 * \param swapchain_composition the desired composition of the swapchain. 4167 * \param present_mode the desired present mode for the swapchain. 4168 * \returns true if successful, false on error; call SDL_GetError() for more 4169 * information. 4170 * 4171 * \since This function is available since SDL 3.2.0. 4172 * 4173 * \sa SDL_WindowSupportsGPUPresentMode 4174 * \sa SDL_WindowSupportsGPUSwapchainComposition 4175 */ 4176extern SDL_DECLSPEC bool SDLCALL SDL_SetGPUSwapchainParameters( 4177 SDL_GPUDevice *device, 4178 SDL_Window *window, 4179 SDL_GPUSwapchainComposition swapchain_composition, 4180 SDL_GPUPresentMode present_mode); 4181 4182/** 4183 * Configures the maximum allowed number of frames in flight. 4184 * 4185 * The default value when the device is created is 2. This means that after 4186 * you have submitted 2 frames for presentation, if the GPU has not finished 4187 * working on the first frame, SDL_AcquireGPUSwapchainTexture() will fill the 4188 * swapchain texture pointer with NULL, and 4189 * SDL_WaitAndAcquireGPUSwapchainTexture() will block. 4190 * 4191 * Higher values increase throughput at the expense of visual latency. Lower 4192 * values decrease visual latency at the expense of throughput. 4193 * 4194 * Note that calling this function will stall and flush the command queue to 4195 * prevent synchronization issues. 4196 * 4197 * The minimum value of allowed frames in flight is 1, and the maximum is 3. 4198 * 4199 * \param device a GPU context. 4200 * \param allowed_frames_in_flight the maximum number of frames that can be 4201 * pending on the GPU. 4202 * \returns true if successful, false on error; call SDL_GetError() for more 4203 * information. 4204 * 4205 * \since This function is available since SDL 3.2.0. 4206 */ 4207extern SDL_DECLSPEC bool SDLCALL SDL_SetGPUAllowedFramesInFlight( 4208 SDL_GPUDevice *device, 4209 Uint32 allowed_frames_in_flight); 4210 4211/** 4212 * Obtains the texture format of the swapchain for the given window. 4213 * 4214 * Note that this format can change if the swapchain parameters change. 4215 * 4216 * \param device a GPU context. 4217 * \param window an SDL_Window that has been claimed. 4218 * \returns the texture format of the swapchain. 4219 * 4220 * \since This function is available since SDL 3.2.0. 4221 */ 4222extern SDL_DECLSPEC SDL_GPUTextureFormat SDLCALL SDL_GetGPUSwapchainTextureFormat( 4223 SDL_GPUDevice *device, 4224 SDL_Window *window); 4225 4226/** 4227 * Acquire a texture to use in presentation. 4228 * 4229 * When a swapchain texture is acquired on a command buffer, it will 4230 * automatically be submitted for presentation when the command buffer is 4231 * submitted. The swapchain texture should only be referenced by the command 4232 * buffer used to acquire it. 4233 * 4234 * This function will fill the swapchain texture handle with NULL if too many 4235 * frames are in flight. This is not an error. This NULL pointer should not be 4236 * passed back into SDL. Instead, it should be considered as an indication to 4237 * wait until the swapchain is available. 4238 * 4239 * If you use this function, it is possible to create a situation where many 4240 * command buffers are allocated while the rendering context waits for the GPU 4241 * to catch up, which will cause memory usage to grow. You should use 4242 * SDL_WaitAndAcquireGPUSwapchainTexture() unless you know what you are doing 4243 * with timing. 4244 * 4245 * The swapchain texture is managed by the implementation and must not be 4246 * freed by the user. You MUST NOT call this function from any thread other 4247 * than the one that created the window. 4248 * 4249 * \param command_buffer a command buffer. 4250 * \param window a window that has been claimed. 4251 * \param swapchain_texture a pointer filled in with a swapchain texture 4252 * handle. 4253 * \param swapchain_texture_width a pointer filled in with the swapchain 4254 * texture width, may be NULL. 4255 * \param swapchain_texture_height a pointer filled in with the swapchain 4256 * texture height, may be NULL. 4257 * \returns true on success, false on error; call SDL_GetError() for more 4258 * information. 4259 * 4260 * \threadsafety This function should only be called from the thread that 4261 * created the window. 4262 * 4263 * \since This function is available since SDL 3.2.0. 4264 * 4265 * \sa SDL_ClaimWindowForGPUDevice 4266 * \sa SDL_SubmitGPUCommandBuffer 4267 * \sa SDL_SubmitGPUCommandBufferAndAcquireFence 4268 * \sa SDL_CancelGPUCommandBuffer 4269 * \sa SDL_GetWindowSizeInPixels 4270 * \sa SDL_WaitForGPUSwapchain 4271 * \sa SDL_WaitAndAcquireGPUSwapchainTexture 4272 * \sa SDL_SetGPUAllowedFramesInFlight 4273 */ 4274extern SDL_DECLSPEC bool SDLCALL SDL_AcquireGPUSwapchainTexture( 4275 SDL_GPUCommandBuffer *command_buffer, 4276 SDL_Window *window, 4277 SDL_GPUTexture **swapchain_texture, 4278 Uint32 *swapchain_texture_width, 4279 Uint32 *swapchain_texture_height); 4280 4281/** 4282 * Blocks the thread until a swapchain texture is available to be acquired. 4283 * 4284 * \param device a GPU context. 4285 * \param window a window that has been claimed. 4286 * \returns true on success, false on failure; call SDL_GetError() for more 4287 * information. 4288 * 4289 * \threadsafety This function should only be called from the thread that 4290 * created the window. 4291 * 4292 * \since This function is available since SDL 3.2.0. 4293 * 4294 * \sa SDL_AcquireGPUSwapchainTexture 4295 * \sa SDL_WaitAndAcquireGPUSwapchainTexture 4296 * \sa SDL_SetGPUAllowedFramesInFlight 4297 */ 4298extern SDL_DECLSPEC bool SDLCALL SDL_WaitForGPUSwapchain( 4299 SDL_GPUDevice *device, 4300 SDL_Window *window); 4301 4302/** 4303 * Blocks the thread until a swapchain texture is available to be acquired, 4304 * and then acquires it. 4305 * 4306 * When a swapchain texture is acquired on a command buffer, it will 4307 * automatically be submitted for presentation when the command buffer is 4308 * submitted. The swapchain texture should only be referenced by the command 4309 * buffer used to acquire it. It is an error to call 4310 * SDL_CancelGPUCommandBuffer() after a swapchain texture is acquired. 4311 * 4312 * This function can fill the swapchain texture handle with NULL in certain 4313 * cases, for example if the window is minimized. This is not an error. You 4314 * should always make sure to check whether the pointer is NULL before 4315 * actually using it. 4316 * 4317 * The swapchain texture is managed by the implementation and must not be 4318 * freed by the user. You MUST NOT call this function from any thread other 4319 * than the one that created the window. 4320 * 4321 * The swapchain texture is write-only and cannot be used as a sampler or for 4322 * another reading operation. 4323 * 4324 * \param command_buffer a command buffer. 4325 * \param window a window that has been claimed. 4326 * \param swapchain_texture a pointer filled in with a swapchain texture 4327 * handle. 4328 * \param swapchain_texture_width a pointer filled in with the swapchain 4329 * texture width, may be NULL. 4330 * \param swapchain_texture_height a pointer filled in with the swapchain 4331 * texture height, may be NULL. 4332 * \returns true on success, false on error; call SDL_GetError() for more 4333 * information. 4334 * 4335 * \threadsafety This function should only be called from the thread that 4336 * created the window. 4337 * 4338 * \since This function is available since SDL 3.2.0. 4339 * 4340 * \sa SDL_SubmitGPUCommandBuffer 4341 * \sa SDL_SubmitGPUCommandBufferAndAcquireFence 4342 * \sa SDL_AcquireGPUSwapchainTexture 4343 */ 4344extern SDL_DECLSPEC bool SDLCALL SDL_WaitAndAcquireGPUSwapchainTexture( 4345 SDL_GPUCommandBuffer *command_buffer, 4346 SDL_Window *window, 4347 SDL_GPUTexture **swapchain_texture, 4348 Uint32 *swapchain_texture_width, 4349 Uint32 *swapchain_texture_height); 4350 4351/** 4352 * Submits a command buffer so its commands can be processed on the GPU. 4353 * 4354 * It is invalid to use the command buffer after this is called. 4355 * 4356 * This must be called from the thread the command buffer was acquired on. 4357 * 4358 * All commands in the submission are guaranteed to begin executing before any 4359 * command in a subsequent submission begins executing. 4360 * 4361 * \param command_buffer a command buffer. 4362 * \returns true on success, false on failure; call SDL_GetError() for more 4363 * information. 4364 * 4365 * \since This function is available since SDL 3.2.0. 4366 * 4367 * \sa SDL_AcquireGPUCommandBuffer 4368 * \sa SDL_WaitAndAcquireGPUSwapchainTexture 4369 * \sa SDL_AcquireGPUSwapchainTexture 4370 * \sa SDL_SubmitGPUCommandBufferAndAcquireFence 4371 */ 4372extern SDL_DECLSPEC bool SDLCALL SDL_SubmitGPUCommandBuffer( 4373 SDL_GPUCommandBuffer *command_buffer); 4374 4375/** 4376 * Submits a command buffer so its commands can be processed on the GPU, and 4377 * acquires a fence associated with the command buffer. 4378 * 4379 * You must release this fence when it is no longer needed or it will cause a 4380 * leak. It is invalid to use the command buffer after this is called. 4381 * 4382 * This must be called from the thread the command buffer was acquired on. 4383 * 4384 * All commands in the submission are guaranteed to begin executing before any 4385 * command in a subsequent submission begins executing. 4386 * 4387 * \param command_buffer a command buffer. 4388 * \returns a fence associated with the command buffer, or NULL on failure; 4389 * call SDL_GetError() for more information. 4390 * 4391 * \since This function is available since SDL 3.2.0. 4392 * 4393 * \sa SDL_AcquireGPUCommandBuffer 4394 * \sa SDL_WaitAndAcquireGPUSwapchainTexture 4395 * \sa SDL_AcquireGPUSwapchainTexture 4396 * \sa SDL_SubmitGPUCommandBuffer 4397 * \sa SDL_ReleaseGPUFence 4398 */ 4399extern SDL_DECLSPEC SDL_GPUFence * SDLCALL SDL_SubmitGPUCommandBufferAndAcquireFence( 4400 SDL_GPUCommandBuffer *command_buffer); 4401 4402/** 4403 * Cancels a command buffer. 4404 * 4405 * None of the enqueued commands are executed. 4406 * 4407 * It is an error to call this function after a swapchain texture has been 4408 * acquired. 4409 * 4410 * This must be called from the thread the command buffer was acquired on. 4411 * 4412 * You must not reference the command buffer after calling this function. 4413 * 4414 * \param command_buffer a command buffer. 4415 * \returns true on success, false on error; call SDL_GetError() for more 4416 * information. 4417 * 4418 * \since This function is available since SDL 3.2.0. 4419 * 4420 * \sa SDL_WaitAndAcquireGPUSwapchainTexture 4421 * \sa SDL_AcquireGPUCommandBuffer 4422 * \sa SDL_AcquireGPUSwapchainTexture 4423 */ 4424extern SDL_DECLSPEC bool SDLCALL SDL_CancelGPUCommandBuffer( 4425 SDL_GPUCommandBuffer *command_buffer); 4426 4427/** 4428 * Blocks the thread until the GPU is completely idle. 4429 * 4430 * \param device a GPU context. 4431 * \returns true on success, false on failure; call SDL_GetError() for more 4432 * information. 4433 * 4434 * \since This function is available since SDL 3.2.0. 4435 * 4436 * \sa SDL_WaitForGPUFences 4437 */ 4438extern SDL_DECLSPEC bool SDLCALL SDL_WaitForGPUIdle( 4439 SDL_GPUDevice *device); 4440 4441/** 4442 * Blocks the thread until the given fences are signaled. 4443 * 4444 * \param device a GPU context. 4445 * \param wait_all if 0, wait for any fence to be signaled, if 1, wait for all 4446 * fences to be signaled. 4447 * \param fences an array of fences to wait on. 4448 * \param num_fences the number of fences in the fences array. 4449 * \returns true on success, false on failure; call SDL_GetError() for more 4450 * information. 4451 * 4452 * \since This function is available since SDL 3.2.0. 4453 * 4454 * \sa SDL_SubmitGPUCommandBufferAndAcquireFence 4455 * \sa SDL_WaitForGPUIdle 4456 */ 4457extern SDL_DECLSPEC bool SDLCALL SDL_WaitForGPUFences( 4458 SDL_GPUDevice *device, 4459 bool wait_all, 4460 SDL_GPUFence *const *fences, 4461 Uint32 num_fences); 4462 4463/** 4464 * Checks the status of a fence. 4465 * 4466 * \param device a GPU context. 4467 * \param fence a fence. 4468 * \returns true if the fence is signaled, false if it is not. 4469 * 4470 * \since This function is available since SDL 3.2.0. 4471 * 4472 * \sa SDL_SubmitGPUCommandBufferAndAcquireFence 4473 */ 4474extern SDL_DECLSPEC bool SDLCALL SDL_QueryGPUFence( 4475 SDL_GPUDevice *device, 4476 SDL_GPUFence *fence); 4477 4478/** 4479 * Releases a fence obtained from SDL_SubmitGPUCommandBufferAndAcquireFence. 4480 * 4481 * You must not reference the fence after calling this function. 4482 * 4483 * \param device a GPU context. 4484 * \param fence a fence. 4485 * 4486 * \since This function is available since SDL 3.2.0. 4487 * 4488 * \sa SDL_SubmitGPUCommandBufferAndAcquireFence 4489 */ 4490extern SDL_DECLSPEC void SDLCALL SDL_ReleaseGPUFence( 4491 SDL_GPUDevice *device, 4492 SDL_GPUFence *fence); 4493 4494/* Format Info */ 4495 4496/** 4497 * Obtains the texel block size for a texture format. 4498 * 4499 * \param format the texture format you want to know the texel size of. 4500 * \returns the texel block size of the texture format. 4501 * 4502 * \since This function is available since SDL 3.2.0. 4503 * 4504 * \sa SDL_UploadToGPUTexture 4505 */ 4506extern SDL_DECLSPEC Uint32 SDLCALL SDL_GPUTextureFormatTexelBlockSize( 4507 SDL_GPUTextureFormat format); 4508 4509/** 4510 * Determines whether a texture format is supported for a given type and 4511 * usage. 4512 * 4513 * \param device a GPU context. 4514 * \param format the texture format to check. 4515 * \param type the type of texture (2D, 3D, Cube). 4516 * \param usage a bitmask of all usage scenarios to check. 4517 * \returns whether the texture format is supported for this type and usage. 4518 * 4519 * \since This function is available since SDL 3.2.0. 4520 */ 4521extern SDL_DECLSPEC bool SDLCALL SDL_GPUTextureSupportsFormat( 4522 SDL_GPUDevice *device, 4523 SDL_GPUTextureFormat format, 4524 SDL_GPUTextureType type, 4525 SDL_GPUTextureUsageFlags usage); 4526 4527/** 4528 * Determines if a sample count for a texture format is supported. 4529 * 4530 * \param device a GPU context. 4531 * \param format the texture format to check. 4532 * \param sample_count the sample count to check. 4533 * \returns whether the sample count is supported for this texture format. 4534 * 4535 * \since This function is available since SDL 3.2.0. 4536 */ 4537extern SDL_DECLSPEC bool SDLCALL SDL_GPUTextureSupportsSampleCount( 4538 SDL_GPUDevice *device, 4539 SDL_GPUTextureFormat format, 4540 SDL_GPUSampleCount sample_count); 4541 4542/** 4543 * Calculate the size in bytes of a texture format with dimensions. 4544 * 4545 * \param format a texture format. 4546 * \param width width in pixels. 4547 * \param height height in pixels. 4548 * \param depth_or_layer_count depth for 3D textures or layer count otherwise. 4549 * \returns the size of a texture with this format and dimensions. 4550 * 4551 * \since This function is available since SDL 3.2.0. 4552 */ 4553extern SDL_DECLSPEC Uint32 SDLCALL SDL_CalculateGPUTextureFormatSize( 4554 SDL_GPUTextureFormat format, 4555 Uint32 width, 4556 Uint32 height, 4557 Uint32 depth_or_layer_count); 4558 4559/** 4560 * Get the SDL pixel format corresponding to a GPU texture format. 4561 * 4562 * \param format a texture format. 4563 * \returns the corresponding pixel format, or SDL_PIXELFORMAT_UNKNOWN if 4564 * there is no corresponding pixel format. 4565 * 4566 * \since This function is available since SDL 3.4.0. 4567 */ 4568extern SDL_DECLSPEC SDL_PixelFormat SDLCALL SDL_GetPixelFormatFromGPUTextureFormat(SDL_GPUTextureFormat format); 4569 4570/** 4571 * Get the GPU texture format corresponding to an SDL pixel format. 4572 * 4573 * \param format a pixel format. 4574 * \returns the corresponding GPU texture format, or 4575 * SDL_GPU_TEXTUREFORMAT_INVALID if there is no corresponding GPU 4576 * texture format. 4577 * 4578 * \since This function is available since SDL 3.4.0. 4579 */ 4580extern SDL_DECLSPEC SDL_GPUTextureFormat SDLCALL SDL_GetGPUTextureFormatFromPixelFormat(SDL_PixelFormat format); 4581 4582#ifdef SDL_PLATFORM_GDK 4583 4584/** 4585 * Call this to suspend GPU operation on Xbox after receiving the 4586 * SDL_EVENT_DID_ENTER_BACKGROUND event. 4587 * 4588 * Do NOT call any SDL_GPU functions after calling this function! This must 4589 * also be called before calling SDL_GDKSuspendComplete. 4590 * 4591 * This function MUST be called from the application's render thread. 4592 * 4593 * \param device a GPU context. 4594 * 4595 * \since This function is available since SDL 3.2.0. 4596 * 4597 * \sa SDL_AddEventWatch 4598 */ 4599extern SDL_DECLSPEC void SDLCALL SDL_GDKSuspendGPU(SDL_GPUDevice *device); 4600 4601/** 4602 * Call this to resume GPU operation on Xbox after receiving the 4603 * SDL_EVENT_WILL_ENTER_FOREGROUND event. 4604 * 4605 * When resuming, this function MUST be called before calling any other 4606 * SDL_GPU functions. 4607 * 4608 * This function MUST be called from the application's render thread. 4609 * 4610 * \param device a GPU context. 4611 * 4612 * \since This function is available since SDL 3.2.0. 4613 * 4614 * \sa SDL_AddEventWatch 4615 */ 4616extern SDL_DECLSPEC void SDLCALL SDL_GDKResumeGPU(SDL_GPUDevice *device); 4617 4618#endif /* SDL_PLATFORM_GDK */ 4619 4620#ifdef __cplusplus 4621} 4622#endif /* __cplusplus */ 4623#include <SDL3/SDL_close_code.h> 4624 4625#endif /* SDL_gpu_h_ */ 4626[FILE END](C) 2025 0x4248 (C) 2025 4248 Media and 4248 Systems, All part of 0x4248 See LICENCE files for more information. Not all files are by 0x4248 always check Licencing.