GPU: Document structs (#10742)

include/SDL3/SDL_gpu.h

@@ -1,4 +1,4 @@
-/*
+/*
   Simple DirectMedia Layer
   Copyright (C) 1997-2024 Sam Lantinga <slouken@libsdl.org>
 
@@ -943,212 +943,382 @@ typedef enum SDL_GPUDriver
 
 /* Structures */
 
+/**
+ * A structure specifying a depth-stencil clear value.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_GPUDepthStencilTargetInfo
+ * \sa SDL_BeginGPURenderPass
+ */
 typedef struct SDL_GPUDepthStencilValue
 {
-    float depth;
-    Uint8 stencil;
+    float depth;    /**< The clear value for the depth aspect of the depth-stencil target. */
+    Uint8 stencil;  /**< The clear value for the stencil aspect of the depth-stencil target. */
     Uint8 padding1;
     Uint8 padding2;
     Uint8 padding3;
 } SDL_GPUDepthStencilValue;
 
+/**
+ * A structure specifying a viewport.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_SetGPUViewport
+ */
 typedef struct SDL_GPUViewport
 {
-    float x;
-    float y;
-    float w;
-    float h;
-    float min_depth;
-    float max_depth;
+    float x;          /**< The left offset of the viewport. */
+    float y;          /**< The top offset of the viewport. */
+    float w;          /**< The width of the viewport. */
+    float h;          /**< The height of the viewport. */
+    float min_depth;  /**< The minimum depth of the viewport. */
+    float max_depth;  /**< The maximum depth of the viewport. */
 } SDL_GPUViewport;
 
+/**
+ * A structure specifying parameters related to transferring data to or from a texture.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_UploadToGPUTexture
+ * \sa SDL_DownloadFromGPUTexture
+ */
 typedef struct SDL_GPUTextureTransferInfo
 {
-    SDL_GPUTransferBuffer *transfer_buffer;
-    Uint32 offset;         /* starting location of the image data */
-    Uint32 pixels_per_row; /* number of pixels from one row to the next */
-    Uint32 rows_per_layer; /* number of rows from one layer/depth-slice to the next */
+    SDL_GPUTransferBuffer *transfer_buffer;  /**< The transfer buffer used in the transfer operation. */
+    Uint32 offset;                           /**< The starting byte of the image data in the transfer buffer. */
+    Uint32 pixels_per_row;                   /**< The number of pixels from one row to the next. */
+    Uint32 rows_per_layer;                   /**< The number of rows from one layer/depth-slice to the next. */
 } SDL_GPUTextureTransferInfo;
 
+/**
+ * A structure specifying a location in a transfer buffer.
+ *
+ * Used when transferring buffer data to or from a transfer buffer.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_UploadToGPUBuffer
+ * \sa SDL_DownloadFromGPUBuffer
+ */
 typedef struct SDL_GPUTransferBufferLocation
 {
-    SDL_GPUTransferBuffer *transfer_buffer;
-    Uint32 offset;
+    SDL_GPUTransferBuffer *transfer_buffer;  /**< The transfer buffer used in the transfer operation. */
+    Uint32 offset;                           /**< The starting byte of the buffer data in the transfer buffer. */
 } SDL_GPUTransferBufferLocation;
 
+/**
+ * A structure specifying a location in a texture.
+ *
+ * Used when copying data from one texture to another.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_CopyGPUTextureToTexture
+ */
 typedef struct SDL_GPUTextureLocation
 {
-    SDL_GPUTexture *texture;
-    Uint32 mip_level;
-    Uint32 layer;
-    Uint32 x;
-    Uint32 y;
-    Uint32 z;
+    SDL_GPUTexture *texture;  /**< The texture used in the copy operation. */
+    Uint32 mip_level;         /**< The mip level index of the location. */
+    Uint32 layer;             /**< The layer index of the location. */
+    Uint32 x;                 /**< The left offset of the location. */
+    Uint32 y;                 /**< The top offset of the location. */
+    Uint32 z;                 /**< The front offset of the location. */
 } SDL_GPUTextureLocation;
 
+/**
+ * A structure specifying a region of a texture.
+ *
+ * Used when transferring data to or from a texture.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_UploadToGPUTexture
+ * \sa SDL_DownloadFromGPUTexture
+ */
 typedef struct SDL_GPUTextureRegion
 {
-    SDL_GPUTexture *texture;
-    Uint32 mip_level;
-    Uint32 layer;
-    Uint32 x;
-    Uint32 y;
-    Uint32 z;
-    Uint32 w;
-    Uint32 h;
-    Uint32 d;
+    SDL_GPUTexture *texture;  /**< The texture used in the copy operation. */
+    Uint32 mip_level;         /**< The mip level index to transfer. */
+    Uint32 layer;             /**< The layer index to transfer. */
+    Uint32 x;                 /** The left offset of the region. */
+    Uint32 y;                 /** The top offset of the region. */
+    Uint32 z;                 /** The front offset of the region. */
+    Uint32 w;                 /** The width of the region. */
+    Uint32 h;                 /** The height of the region. */
+    Uint32 d;                 /** The depth of the region. */
 } SDL_GPUTextureRegion;
 
+/**
+ * A structure specifying a region of a texture used in the blit operation.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_BlitGPUTexture
+ */
 typedef struct SDL_GPUBlitRegion
 {
-    SDL_GPUTexture *texture;
-    Uint32 mip_level;
-    Uint32 layer_or_depth_plane;
-    Uint32 x;
-    Uint32 y;
-    Uint32 w;
-    Uint32 h;
+    SDL_GPUTexture *texture;  /**< The texture. */
+    Uint32 mip_level;             /**< The mip level index of the region. */
+    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. */
+    Uint32 x;                     /**< The left offset of the region. */
+    Uint32 y;                     /**< The top offset of the region.  */
+    Uint32 w;                     /**< The width of the region. */
+    Uint32 h;                     /**< The height of the region. */
 } SDL_GPUBlitRegion;
 
+/**
+ * A structure specifying a location in a buffer.
+ *
+ * Used when copying data between buffers.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_CopyGPUBufferToBuffer
+ */
 typedef struct SDL_GPUBufferLocation
 {
-    SDL_GPUBuffer *buffer;
-    Uint32 offset;
+    SDL_GPUBuffer *buffer;  /**< The buffer. */
+    Uint32 offset;          /**< The starting byte within the buffer. */
 } SDL_GPUBufferLocation;
 
+/**
+ * A structure specifying a region of a buffer.
+ *
+ * Used when transferring data to or from buffers.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_UploadToGPUBuffer
+ * \sa SDL_DownloadFromGPUBuffer
+ */
 typedef struct SDL_GPUBufferRegion
 {
-    SDL_GPUBuffer *buffer;
-    Uint32 offset;
-    Uint32 size;
+    SDL_GPUBuffer *buffer;  /**< The buffer. */
+    Uint32 offset;          /**< The starting byte within the buffer. */
+    Uint32 size;            /**< The size in bytes of the region. */
 } SDL_GPUBufferRegion;
 
-/* Note that the `first_vertex` and `first_instance` parameters are NOT compatible with
+/**
+ * A structure specifying the parameters of an indirect draw command.
+ *
+ * Note that the `first_vertex` and `first_instance` parameters are NOT compatible with
  * built-in vertex/instance ID variables in shaders (for example, SV_VertexID). If
  * your shader depends on these variables, the correlating draw call parameter MUST
  * be 0.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_DrawGPUPrimitivesIndirect
  */
 typedef struct SDL_GPUIndirectDrawCommand
 {
-    Uint32 num_vertices;   /* number of vertices to draw */
-    Uint32 num_instances;  /* number of instances to draw */
-    Uint32 first_vertex;   /* index of the first vertex to draw */
-    Uint32 first_instance; /* ID of the first instance to draw */
+    Uint32 num_vertices;   /**< The number of vertices to draw. */
+    Uint32 num_instances;  /**< The number of instances to draw. */
+    Uint32 first_vertex;   /**< The index of the first vertex to draw. */
+    Uint32 first_instance; /**< The ID of the first instance to draw. */
 } SDL_GPUIndirectDrawCommand;
 
+/**
+ * A structure specifying the parameters of an indexed indirect draw command.
+ *
+ * Note that the `first_vertex` and `first_instance` parameters are NOT compatible with
+ * built-in vertex/instance ID variables in shaders (for example, SV_VertexID). If
+ * your shader depends on these variables, the correlating draw call parameter MUST
+ * be 0.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_DrawGPUIndexedPrimitivesIndirect
+ */
 typedef struct SDL_GPUIndexedIndirectDrawCommand
 {
-    Uint32 num_indices;    /* number of vertices to draw per instance */
-    Uint32 num_instances;  /* number of instances to draw */
-    Uint32 first_index;    /* base index within the index buffer */
-    Sint32 vertex_offset;  /* value added to vertex index before indexing into the vertex buffer */
-    Uint32 first_instance; /* ID of the first instance to draw */
+    Uint32 num_indices;    /**< The number of indices to draw per instance. */
+    Uint32 num_instances;  /**< The number of instances to draw. */
+    Uint32 first_index;    /**< The base index within the index buffer. */
+    Sint32 vertex_offset;  /**< The value added to the vertex index before indexing into the vertex buffer. */
+    Uint32 first_instance; /**< The ID of the first instance to draw. */
 } SDL_GPUIndexedIndirectDrawCommand;
 
+/**
+ * A structure specifying the parameters of an indexed dispatch command.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_DispatchGPUComputeIndirect
+ */
 typedef struct SDL_GPUIndirectDispatchCommand
 {
-    Uint32 groupcount_x;
-    Uint32 groupcount_y;
-    Uint32 groupcount_z;
+    Uint32 groupcount_x;  /**< The number of local workgroups to dispatch in the X dimension. */
+    Uint32 groupcount_y;  /**< The number of local workgroups to dispatch in the Y dimension. */
+    Uint32 groupcount_z;  /**< The number of local workgroups to dispatch in the Z dimension. */
 } SDL_GPUIndirectDispatchCommand;
 
 /* State structures */
 
+/**
+ * A structure specifying the parameters of a sampler.
+ *
+ * \since This function is available since SDL 3.0.0
+ *
+ * \sa SDL_CreateGPUSampler
+ */
 typedef struct SDL_GPUSamplerCreateInfo
 {
-    SDL_GPUFilter min_filter;
-    SDL_GPUFilter mag_filter;
-    SDL_GPUSamplerMipmapMode mipmap_mode;
-    SDL_GPUSamplerAddressMode address_mode_u;
-    SDL_GPUSamplerAddressMode address_mode_v;
-    SDL_GPUSamplerAddressMode address_mode_w;
-    float mip_lod_bias;
-    float max_anisotropy;
-    SDL_bool enable_anisotropy;
-    SDL_bool enable_compare;
+    SDL_GPUFilter min_filter;                  /**< The minification filter to apply to lookups. */
+    SDL_GPUFilter mag_filter;                  /**< The magnification filter to apply to lookups. */
+    SDL_GPUSamplerMipmapMode mipmap_mode;      /**< The mipmap filter to apply to lookups. */
+    SDL_GPUSamplerAddressMode address_mode_u;  /**< The addressing mode for U coordinates outside [0, 1). */
+    SDL_GPUSamplerAddressMode address_mode_v;  /**< The addressing mode for V coordinates outside [0, 1). */
+    SDL_GPUSamplerAddressMode address_mode_w;  /**< The addressing mode for W coordinates outside [0, 1). */
+    float mip_lod_bias;                        /**< The bias to be added to mipmap LOD calculation. */
+    float max_anisotropy;                      /**< The anisotropy value clamp used by the sampler. If enable_anisotropy is SDL_FALSE, this is ignored. */
+    SDL_bool enable_anisotropy;                /**< SDL_TRUE to enable anisotropic filtering. */
+    SDL_bool enable_compare;                   /**< SDL_TRUE to enable comparison against a reference value during lookups. */
     Uint8 padding1;
     Uint8 padding2;
-    SDL_GPUCompareOp compare_op;
-    float min_lod;
-    float max_lod;
+    SDL_GPUCompareOp compare_op;               /**< The comparison operator to apply to fetched data before filtering. */
+    float min_lod;                             /**< Clamps the minimum of the computed LOD value. */
+    float max_lod;                             /**< Clamps the maximum of the computed LOD value. */
 
-    SDL_PropertiesID props;
+    SDL_PropertiesID props;                    /**< A properties ID for extensions. Should be 0 if no extensions are needed. */
 } SDL_GPUSamplerCreateInfo;
 
+/**
+ * A structure specifying a vertex binding.
+ *
+ * When you call SDL_BindGPUVertexBuffers, you specify the binding indices of the vertex buffers.
+ * For example if you called SDL_BindGPUVertexBuffers with a first_binding of 2 and num_bindings of 3, the binding indices 2, 3, 4 would be used by the vertex buffers you pass in.
+ *
+ * Vertex attributes are linked to bindings via the index. The binding_index field of SDL_GPUVertexAttribute specifies the vertex buffer binding index that the attribute will be read from.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_GPUVertexAttribute
+ * \sa SDL_GPUVertexInputState
+ */
 typedef struct SDL_GPUVertexBinding
 {
-    Uint32 binding;
-    Uint32 pitch;
-    SDL_GPUVertexInputRate input_rate;
-    Uint32 instance_step_rate; /* ignored unless input_rate is INSTANCE */
+    Uint32 index;                     /**< The binding index. */
+    Uint32 pitch;                       /**< The byte pitch between consecutive elements of the vertex buffer. */
+    SDL_GPUVertexInputRate input_rate;  /**< Whether attribute addressing is a function of the vertex index or instance index. */
+    Uint32 instance_step_rate;          /**< The number of instances to draw using the same per-instance data before advancing in the instance buffer by one element. Ignored unless input_rate is SDL_GPU_VERTEXINPUTRATE_INSTANCE */
 } SDL_GPUVertexBinding;
 
+/**
+ * A structure specifying a vertex attribute.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_GPUVertexBinding
+ * \sa SDL_GPUVertexInputState
+ */
 typedef struct SDL_GPUVertexAttribute
 {
-    Uint32 location;
-    Uint32 binding;
-    SDL_GPUVertexElementFormat format;
-    Uint32 offset;
+    Uint32 location;                    /**< The shader input location index. */
+    Uint32 binding_index;               /**< The binding index. */
+    SDL_GPUVertexElementFormat format;  /**< The size and type of the attribute data. */
+    Uint32 offset;                      /**< The byte offset of this attribute relative to the start of the vertex element. */
 } SDL_GPUVertexAttribute;
 
+/**
+ * A structure specifying the parameters of a graphics pipeline vertex input state.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_GPUGraphicsPipelineCreateInfo
+ */
 typedef struct SDL_GPUVertexInputState
 {
-    const SDL_GPUVertexBinding *vertex_bindings;
-    Uint32 num_vertex_bindings;
-    const SDL_GPUVertexAttribute *vertex_attributes;
-    Uint32 num_vertex_attributes;
+    const SDL_GPUVertexBinding *vertex_bindings;      /**< A pointer to an array of vertex binding descriptions. */
+    Uint32 num_vertex_bindings;                       /**< The number of vertex binding descriptions in the above array. */
+    const SDL_GPUVertexAttribute *vertex_attributes;  /**< A pointer to an array of vertex attribute descriptions. */
+    Uint32 num_vertex_attributes;                     /**< The number of vertex attribute descriptions in the above array. */
 } SDL_GPUVertexInputState;
 
+/**
+ * A structure specifying the stencil operation state of a graphics pipeline.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_GPUDepthStencilState
+ */
 typedef struct SDL_GPUStencilOpState
 {
-    SDL_GPUStencilOp fail_op;
-    SDL_GPUStencilOp pass_op;
-    SDL_GPUStencilOp depth_fail_op;
-    SDL_GPUCompareOp compare_op;
+    SDL_GPUStencilOp fail_op;        /**< The action performed on samples that fail the stencil test. */
+    SDL_GPUStencilOp pass_op;        /**< The action performed on samples that pass the depth and stencil tests. */
+    SDL_GPUStencilOp depth_fail_op;  /**< The action performed on samples that pass the stencil test and fail the depth test. */
+    SDL_GPUCompareOp compare_op;     /**< The comparison operator used in the stencil test. */
 } SDL_GPUStencilOpState;
 
+/**
+ * A structure specifying the blend state of a color target.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_GPUColorTargetDescription
+ */
 typedef struct SDL_GPUColorTargetBlendState
 {
-    SDL_bool enable_blend;
+    SDL_bool enable_blend;                        /**< Whether blending is enabled for the color target. */
     Uint8 padding1;
     Uint8 padding2;
     Uint8 padding3;
-    SDL_GPUBlendFactor src_color_blendfactor;
-    SDL_GPUBlendFactor dst_color_blendfactor;
-    SDL_GPUBlendOp color_blend_op;
-    SDL_GPUBlendFactor src_alpha_blendfactor;
-    SDL_GPUBlendFactor dst_alpha_blendfactor;
-    SDL_GPUBlendOp alpha_blend_op;
-    SDL_GPUColorComponentFlags color_write_mask;
+    SDL_GPUBlendFactor src_color_blendfactor;     /**< The value to be multiplied by the source RGB value. */
+    SDL_GPUBlendFactor dst_color_blendfactor;     /**< The value to be multiplied by the destination RGB value. */
+    SDL_GPUBlendOp color_blend_op;                /**< The blend operation for the RGB components. */
+    SDL_GPUBlendFactor src_alpha_blendfactor;     /**< The value to be multiplied by the source alpha. */
+    SDL_GPUBlendFactor dst_alpha_blendfactor;     /**< The value to be multiplied by the destination alpha. */
+    SDL_GPUBlendOp alpha_blend_op;                /**< The blend operation for the alpha component. */
+    SDL_GPUColorComponentFlags color_write_mask;  /**< A bitmask specifying which of the RGBA components are enabled for writing. */
 } SDL_GPUColorTargetBlendState;
 
+
+/**
+ * A structure specifying code and metadata for creating a shader object.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_CreateGPUShader
+ */
 typedef struct SDL_GPUShaderCreateInfo
 {
-    size_t code_size;
-    const Uint8 *code;
-    const char *entrypoint;
-    SDL_GPUShaderFormat format;
-    SDL_GPUShaderStage stage;
-    Uint32 num_samplers;
-    Uint32 num_storage_textures;
-    Uint32 num_storage_buffers;
-    Uint32 num_uniform_buffers;
-
-    SDL_PropertiesID props;
+    size_t code_size;             /**< The size in bytes of the code pointed to. */
+    const Uint8 *code;            /**< A pointer to shader code. */
+    const char *entrypoint;       /**< A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. */
+    SDL_GPUShaderFormat format;   /**< The format of the shader code. */
+    SDL_GPUShaderStage stage;     /**< The stage the shader program corresponds to. */
+    Uint32 num_samplers;          /**< The number of samplers defined in the shader. */
+    Uint32 num_storage_textures;  /**< The number of storage textures defined in the shader. */
+    Uint32 num_storage_buffers;   /**< The number of storage buffers defined in the shader. */
+    Uint32 num_uniform_buffers;   /**< The number of uniform buffers defined in the shader. */
+
+    SDL_PropertiesID props;       /**< A properties ID for extensions. Should be 0 if no extensions are needed. */
 } SDL_GPUShaderCreateInfo;
 
+/**
+ * A structure specifying the parameters of a texture.
+ *
+ * Usage flags can be bitwise OR'd together for combinations of usages. Note that certain usage combinations are invalid, for example SAMPLER and GRAPHICS_STORAGE.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_CreateGPUTexture
+ */
 typedef struct SDL_GPUTextureCreateInfo
 {
-    SDL_GPUTextureType type;
-    SDL_GPUTextureFormat format;
-    SDL_GPUTextureUsageFlags usage;
-    Uint32 width;
-    Uint32 height;
-    Uint32 layer_count_or_depth;
-    Uint32 num_levels;
-    SDL_GPUSampleCount sample_count;
-
-    SDL_PropertiesID props;
+    SDL_GPUTextureType type;          /**< The base dimensionality of the texture. */
+    SDL_GPUTextureFormat format;      /**< The pixel format of the texture. */
+    SDL_GPUTextureUsageFlags usage;   /**< How the texture is intended to be used by the client. */
+    Uint32 width;                     /**< The width of the texture. */
+    Uint32 height;                    /**< The height of the texture. */
+    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. */
+    Uint32 num_levels;                /**< The number of mip levels in the texture. */
+    SDL_GPUSampleCount sample_count;  /**< The number of samples per texel. Only applies if the texture is used as a render target. */
+
+    SDL_PropertiesID props;           /**< A properties ID for extensions. Should be 0 if no extensions are needed. */
 } SDL_GPUTextureCreateInfo;
 
 #define SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_R_FLOAT       "SDL.gpu.createtexture.d3d12.clear.r"
@@ -1158,210 +1328,243 @@ typedef struct SDL_GPUTextureCreateInfo
 #define SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_DEPTH_FLOAT   "SDL.gpu.createtexture.d3d12.clear.depth"
 #define SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_STENCIL_UINT8 "SDL.gpu.createtexture.d3d12.clear.stencil"
 
+/**
+ * A structure specifying the parameters of a buffer.
+ *
+ * Usage flags can be bitwise OR'd together for combinations of usages. Note that certain combinations are invalid, for example VERTEX and INDEX.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_CreateGPUBuffer
+ */
 typedef struct SDL_GPUBufferCreateInfo
 {
-    SDL_GPUBufferUsageFlags usage;
-    Uint32 size;
+    SDL_GPUBufferUsageFlags usage;  /** How the buffer is intended to be used by the client. */
+    Uint32 size;                    /** The size in bytes of the buffer. */
 
-    SDL_PropertiesID props;
+    SDL_PropertiesID props;         /**< A properties ID for extensions. Should be 0 if no extensions are needed. */
 } SDL_GPUBufferCreateInfo;
 
+/**
+ * A structure specifying the parameters of a transfer buffer.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_CreateGPUTransferBuffer
+ */
 typedef struct SDL_GPUTransferBufferCreateInfo
 {
-    SDL_GPUTransferBufferUsage usage;
-    Uint32 size;
+    SDL_GPUTransferBufferUsage usage;  /** How the transfer buffer is intended to be used by the client. */
+    Uint32 size;                       /** The size in bytes of the transfer buffer. */
 
-    SDL_PropertiesID props;
+    SDL_PropertiesID props;            /**< A properties ID for extensions. Should be 0 if no extensions are needed. */
 } SDL_GPUTransferBufferCreateInfo;
 
 /* Pipeline state structures */
 
+/**
+ * A structure specifying the parameters of the graphics pipeline rasterizer state.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_GPUGraphicsPipelineCreateInfo
+ */
 typedef struct SDL_GPURasterizerState
 {
-    SDL_GPUFillMode fill_mode;
-    SDL_GPUCullMode cull_mode;
-    SDL_GPUFrontFace front_face;
-    SDL_bool enable_depth_bias;
+    SDL_GPUFillMode fill_mode;         /**< Whether polygons will be filled in or drawn as lines. */
+    SDL_GPUCullMode cull_mode;         /**< The facing direction in which triangles will be culled. */
+    SDL_GPUFrontFace front_face;       /**< The vertex winding that will cause a triangle to be determined as front-facing. */
+    SDL_bool enable_depth_bias;        /**< SDL_TRUE to bias fragment depth values. */
     Uint8 padding1;
     Uint8 padding2;
     Uint8 padding3;
-    float depth_bias_constant_factor;
-    float depth_bias_clamp;
-    float depth_bias_slope_factor;
+    float depth_bias_constant_factor;  /**< A scalar factor controlling the depth value added to each fragment. */
+    float depth_bias_clamp;            /**< The maximum depth bias of a fragment. */
+    float depth_bias_slope_factor;     /**< A scalar factor applied to a fragment's slope in depth calculations. */
 } SDL_GPURasterizerState;
 
+/**
+ * A structure specifying the parameters of the graphics pipeline multisample state.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_GPUGraphicsPipelineCreateInfo
+ */
 typedef struct SDL_GPUMultisampleState
 {
-    SDL_GPUSampleCount sample_count;
-    Uint32 sample_mask;
+    SDL_GPUSampleCount sample_count;  /**< The number of samples to be used in rasterization. */
+    Uint32 sample_mask;               /**< Determines which samples get updated in the render targets. 0xFFFFFFFF is a reasonable default. */
 } SDL_GPUMultisampleState;
 
+/**
+ * A structure specifying the parameters of the graphics pipeline depth stencil state.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_GPUGraphicsPipelineCreateInfo
+ */
 typedef struct SDL_GPUDepthStencilState
 {
-    SDL_bool enable_depth_test;
-    SDL_bool enable_depth_write;
-    SDL_bool enable_stencil_test;
+    SDL_bool enable_depth_test;                 /**< SDL_TRUE enables the depth test. */
+    SDL_bool enable_depth_write;                /**< SDL_TRUE enables depth writes. Depth writes are always disabled when enable_depth_test is SDL_FALSE. */
+    SDL_bool enable_stencil_test;               /**< SDL_TRUE enables the stencil test. */
     Uint8 padding1;
-    SDL_GPUCompareOp compare_op;
-    SDL_GPUStencilOpState back_stencil_state;
-    SDL_GPUStencilOpState front_stencil_state;
-    Uint8 compare_mask;
-    Uint8 write_mask;
+    SDL_GPUCompareOp compare_op;                /**< The comparison operator used for depth testing. */
+    SDL_GPUStencilOpState back_stencil_state;   /**< The stencil op state for back-facing triangles. */
+    SDL_GPUStencilOpState front_stencil_state;  /**< The stencil op state for front-facing triangles. */
+    Uint8 compare_mask;                         /**< Selects the bits of the stencil values participating in the stencil test. */
+    Uint8 write_mask;                           /**< Selects the bits of the stencil values updated by the stencil test. */
     Uint8 padding2;
     Uint8 padding3;
 } SDL_GPUDepthStencilState;
 
+/**
+ * A structure specifying the parameters of color targets used in a graphics pipeline.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_GPUGraphicsPipelineTargetInfo
+ */
 typedef struct SDL_GPUColorTargetDescription
 {
-    SDL_GPUTextureFormat format;
-    SDL_GPUColorTargetBlendState blend_state;
+    SDL_GPUTextureFormat format;               /**< The pixel format of the texture to be used as a color target. */
+    SDL_GPUColorTargetBlendState blend_state;  /**< The blend state to be used for the color target. */
 } SDL_GPUColorTargetDescription;
 
+/**
+ * A structure specifying the descriptions of render targets used in a graphics pipeline.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_GPUGraphicsPipelineCreateInfo
+ */
 typedef struct SDL_GpuGraphicsPipelineTargetInfo
 {
-    const SDL_GPUColorTargetDescription *color_target_descriptions;
-    Uint32 num_color_targets;
-    SDL_bool has_depth_stencil_target;
+    const SDL_GPUColorTargetDescription *color_target_descriptions;  /**< A pointer to an array of color target descriptions. */
+    Uint32 num_color_targets;                                        /**< The number of color target descriptions in the above array. */
+    SDL_bool has_depth_stencil_target;                               /**< SDL_TRUE specifies that the pipeline uses a depth-stencil target. */
     Uint8 padding1;
     Uint8 padding2;
     Uint8 padding3;
-    SDL_GPUTextureFormat depth_stencil_format;
+    SDL_GPUTextureFormat depth_stencil_format;                       /**< The pixel format of the depth-stencil target. Ignored if has_depth_stencil_target is SDL_FALSE. */
 } SDL_GpuGraphicsPipelineTargetInfo;
 
+/**
+ * A structure specifying the parameters of a graphics pipeline state.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_CreateGPUGraphicsPipeline
+ */
 typedef struct SDL_GPUGraphicsPipelineCreateInfo
 {
-    SDL_GPUShader *vertex_shader;
-    SDL_GPUShader *fragment_shader;
-    SDL_GPUVertexInputState vertex_input_state;
-    SDL_GPUPrimitiveType primitive_type;
-    SDL_GPURasterizerState rasterizer_state;
-    SDL_GPUMultisampleState multisample_state;
-    SDL_GPUDepthStencilState depth_stencil_state;
-    SDL_GpuGraphicsPipelineTargetInfo target_info;
-
-    SDL_PropertiesID props;
+    SDL_GPUShader *vertex_shader;                   /**< The vertex shader used by the graphics pipeline. */
+    SDL_GPUShader *fragment_shader;                 /**< The fragment shader used by the graphics pipeline. */
+    SDL_GPUVertexInputState vertex_input_state;     /**< The vertex layout of the graphics pipeline. */
+    SDL_GPUPrimitiveType primitive_type;            /**< The primitive topology of the graphics pipeline. */
+    SDL_GPURasterizerState rasterizer_state;        /**< The rasterizer state of the graphics pipeline. */
+    SDL_GPUMultisampleState multisample_state;      /**< The multisample state of the graphics pipeline. */
+    SDL_GPUDepthStencilState depth_stencil_state;   /**< The depth-stencil state of the graphics pipeline. */
+    SDL_GpuGraphicsPipelineTargetInfo target_info;  /**< Formats and blend modes for the render targets of the graphics pipeline. */
+
+    SDL_PropertiesID props;                         /**< A properties ID for extensions. Should be 0 if no extensions are needed. */
 } SDL_GPUGraphicsPipelineCreateInfo;
 
+/**
+ * A structure specifying the parameters of a compute pipeline state.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_CreateGPUComputePipeline
+ */
 typedef struct SDL_GPUComputePipelineCreateInfo
 {
-    size_t code_size;
-    const Uint8 *code;
-    const char *entrypoint;
-    SDL_GPUShaderFormat format;
-    Uint32 num_readonly_storage_textures;
-    Uint32 num_readonly_storage_buffers;
-    Uint32 num_writeonly_storage_textures;
-    Uint32 num_writeonly_storage_buffers;
-    Uint32 num_uniform_buffers;
-    Uint32 threadcount_x;
-    Uint32 threadcount_y;
-    Uint32 threadcount_z;
-
-    SDL_PropertiesID props;
+    size_t code_size;                       /**< The size in bytes of the compute shader code pointed to. */
+    const Uint8 *code;                      /**< A pointer to compute shader code. */
+    const char *entrypoint;                 /**< A pointer to a null-terminated UTF-8 string specifying the entry point function name for the shader. */
+    SDL_GPUShaderFormat format;             /**< The format of the compute shader code. */
+    Uint32 num_readonly_storage_textures;   /**< The number of readonly storage textures defined in the shader. */
+    Uint32 num_readonly_storage_buffers;    /**< The number of readonly storage buffers defined in the shader. */
+    Uint32 num_writeonly_storage_textures;  /**< The number of writeonly storage textures defined in the shader. */
+    Uint32 num_writeonly_storage_buffers;   /**< The number of writeonly storage buffers defined in the shader. */
+    Uint32 num_uniform_buffers;             /** The number of uniform buffers defined in the shader. */
+    Uint32 threadcount_x;                   /** The number of threads in the X dimension. This should match the value in the shader. */
+    Uint32 threadcount_y;                   /** The number of threads in the Y dimension. This should match the value in the shader. */
+    Uint32 threadcount_z;                   /** The number of threads in the Z dimension. This should match the value in the shader. */
+
+    SDL_PropertiesID props;                 /**< A properties ID for extensions. Should be 0 if no extensions are needed. */
 } SDL_GPUComputePipelineCreateInfo;
 
+/**
+ * A structure specifying the parameters of a color target used by a render pass.
+ *
+ * The load_op field determines what is done with the texture at the beginning of the render pass.
+ *
+ * - LOAD: Loads the data currently in the texture.
+ * - CLEAR: Clears the texture to a single color.
+ * - DONT_CARE: The driver will do whatever it wants with the texture memory. This is a good option if you know that every single pixel will be touched in the render pass.
+ *
+ * The store_op field determines what is done with the color results of the render pass.
+ *
+ * - STORE: Stores the results of the render pass in the texture.
+ * - DONT_CARE: The driver will do whatever it wants with the texture memory. This is often a good option for depth/stencil textures.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_BeginGPURenderPass
+ */
 typedef struct SDL_GPUColorTargetInfo
 {
-    /* The texture that will be used as a color target by a render pass. */
-    SDL_GPUTexture *texture;
-    Uint32 mip_level;
-    Uint32 layer_or_depth_plane; /* For 3D textures, you can bind an individual depth plane as a target. */
-
-    /* Can be ignored by RenderPass if CLEAR is not used */
-    SDL_FColor clear_color;
-
-    /* Determines what is done with the texture at the beginning of the render pass.
-     *
-     *   LOAD:
-     *     Loads the data currently in the texture.
-     *
-     *   CLEAR:
-     *     Clears the texture to a single color.
-     *
-     *   DONT_CARE:
-     *     The driver will do whatever it wants with the texture memory.
-     *     This is a good option if you know that every single pixel will be touched in the render pass.
-     */
-    SDL_GPULoadOp load_op;
-
-    /* Determines what is done with the texture at the end of the render pass.
-     *
-     *   STORE:
-     *     Stores the results of the render pass in the texture.
-     *
-     *   DONT_CARE:
-     *     The driver will do whatever it wants with the texture memory.
-     *     This is often a good option for depth/stencil textures.
-     */
-    SDL_GPUStoreOp store_op;
-
-    /* if SDL_TRUE, cycles the texture if the texture is bound and load_op is not LOAD */
-    SDL_bool cycle;
+    SDL_GPUTexture *texture;      /**< The texture that will be used as a color target by a render pass. */
+    Uint32 mip_level;             /**< The mip level to use as a color target. */
+    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. */
+    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. */
+    SDL_GPULoadOp load_op;        /**< What is done with the contents of the color target at the beginning of the render pass. */
+    SDL_GPUStoreOp store_op;      /**< What is done with the results of the render pass. */
+    SDL_bool cycle;               /**< SDL_TRUE cycles the texture if the texture is bound and load_op is not LOAD */
     Uint8 padding1;
     Uint8 padding2;
     Uint8 padding3;
 } SDL_GPUColorTargetInfo;
 
+/**
+ * A structure specifying the parameters of a depth-stencil target used by a render pass.
+ *
+ * The load_op field determines what is done with the depth contents of the texture at the beginning of the render pass.
+ *
+ * - LOAD: Loads the depth values currently in the texture.
+ * - CLEAR: Clears the texture to a single depth.
+ * - DONT_CARE: The driver will do whatever it wants with the memory. This is a good option if you know that every single pixel will be touched in the render pass.
+ *
+ * The store_op field determines what is done with the depth results of the render pass.
+ *
+ * - STORE: Stores the depth results in the texture.
+ * - DONT_CARE: The driver will do whatever it wants with the depth results. This is often a good option for depth/stencil textures that don't need to be reused again.
+ *
+ * The stencil_load_op field determines what is done with the stencil contents of the texture at the beginning of the render pass.
+ *
+ * - LOAD: Loads the stencil values currently in the texture.
+ * - CLEAR: Clears the stencil values to a single value.
+ * - DONT_CARE: The driver will do whatever it wants with the memory. This is a good option if you know that every single pixel will be touched in the render pass.
+ *
+ * The stencil_store_op field determines what is done with the stencil results of the render pass.
+ *
+ * - STORE: Stores the stencil results in the texture.
+ * - DONT_CARE: The driver will do whatever it wants with the stencil results. This is often a good option for depth/stencil textures that don't need to be reused again.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_BeginGPURenderPass
+ */
 typedef struct SDL_GPUDepthStencilTargetInfo
 {
-    /* The texture that will be used as the depth stencil target by a render pass. */
-    SDL_GPUTexture *texture;
-
-    /* Can be ignored by the render pass if CLEAR is not used */
-    SDL_GPUDepthStencilValue clear_value;
-
-    /* Determines what is done with the depth values at the beginning of the render pass.
-     *
-     *   LOAD:
-     *     Loads the depth values currently in the texture.
-     *
-     *   CLEAR:
-     *     Clears the texture to a single depth.
-     *
-     *   DONT_CARE:
-     *     The driver will do whatever it wants with the memory.
-     *     This is a good option if you know that every single pixel will be touched in the render pass.
-     */
-    SDL_GPULoadOp load_op;
-
-    /* Determines what is done with the depth values at the end of the render pass.
-     *
-     *   STORE:
-     *     Stores the depth results in the texture.
-     *
-     *   DONT_CARE:
-     *     The driver will do whatever it wants with the texture memory.
-     *     This is often a good option for depth/stencil textures.
-     */
-    SDL_GPUStoreOp store_op;
-
-    /* Determines what is done with the stencil values at the beginning of the render pass.
-     *
-     *   LOAD:
-     *     Loads the stencil values currently in the texture.
-     *
-     *   CLEAR:
-     *     Clears the texture to a single stencil value.
-     *
-     *   DONT_CARE:
-     *     The driver will do whatever it wants with the memory.
-     *     This is a good option if you know that every single pixel will be touched in the render pass.
-     */
-    SDL_GPULoadOp stencil_load_op;
-
-    /* Determines what is done with the stencil values at the end of the render pass.
-     *
-     *   STORE:
-     *     Stores the stencil results in the texture.
-     *
-     *   DONT_CARE:
-     *     The driver will do whatever it wants with the texture memory.
-     *     This is often a good option for depth/stencil textures.
-     */
-    SDL_GPUStoreOp stencil_store_op;
-
-    /* if SDL_TRUE, cycles the texture if the texture is bound and any load ops are not LOAD */
-    SDL_bool cycle;
+    SDL_GPUTexture *texture;               /**< The texture that will be used as the depth stencil target by the render pass. */
+    SDL_GPUDepthStencilValue clear_value;  /**< The depth-stencil clear values. Can be ignored by the render pass if SDL_GPU_LOADOP_CLEAR is not used. */
+    SDL_GPULoadOp load_op;                 /**< What is done with the depth contents at the beginning of the render pass. */
+    SDL_GPUStoreOp store_op;               /**< What is done with the depth results of the render pass. */
+    SDL_GPULoadOp stencil_load_op;         /**< What is done with the stencil contents at the beginning of the render pass. */
+    SDL_GPUStoreOp stencil_store_op;       /**< What is done with the stencil results of the render pass. */
+    SDL_bool cycle;                        /**< SDL_TRUE cycles the texture if the texture is bound and any load ops are not LOAD */
     Uint8 padding1;
     Uint8 padding2;
     Uint8 padding3;
@@ -1369,37 +1572,63 @@ typedef struct SDL_GPUDepthStencilTargetInfo
 
 /* Binding structs */
 
+/**
+ * A structure specifying parameters in a buffer binding call.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_BindGPUVertexBuffers
+ * \sa SDL_BindGPUIndexBuffers
+ */
 typedef struct SDL_GPUBufferBinding
 {
-    SDL_GPUBuffer *buffer;
-    Uint32 offset;
+    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_BindGPUIndexBuffers. */
+    Uint32 offset;          /**< The starting byte of the data to bind in the buffer. */
 } SDL_GPUBufferBinding;
 
+/**
+ * A structure specifying parameters in a sampler binding call.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_BindGPUVertexSamplers
+ * \sa SDL_BindGPUFragmentSamplers
+ */
 typedef struct SDL_GPUTextureSamplerBinding
 {
-    SDL_GPUTexture *texture;
-    SDL_GPUSampler *sampler;
+    SDL_GPUTexture *texture;  /**< The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER. */
+    SDL_GPUSampler *sampler;  /**< The sampler to bind. */
 } SDL_GPUTextureSamplerBinding;
 
+/**
+ * A structure specifying parameters related to binding buffers in a compute pass.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_BeginGPUComputePass
+ */
 typedef struct SDL_GPUStorageBufferWriteOnlyBinding
 {
-    SDL_GPUBuffer *buffer;
-
-    /* if SDL_TRUE, cycles the buffer if it is bound. */
-    SDL_bool cycle;
+    SDL_GPUBuffer *buffer;  /**< The buffer to bind. Must have been created with SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE. */
+    SDL_bool cycle;         /**< SDL_TRUE cycles the buffer if it is already bound. */
     Uint8 padding1;
     Uint8 padding2;
     Uint8 padding3;
 } SDL_GPUStorageBufferWriteOnlyBinding;
 
+/**
+ * A structure specifying parameters related to binding textures in a compute pass.
+ *
+ * \since This struct is available since SDL 3.0.0
+ *
+ * \sa SDL_BeginGPUComputePass
+ */
 typedef struct SDL_GPUStorageTextureWriteOnlyBinding
 {
-    SDL_GPUTexture *texture;
-    Uint32 mip_level;
-    Uint32 layer;
-
-    /* if SDL_TRUE, cycles the texture if the texture is bound. */
-    SDL_bool cycle;
+    SDL_GPUTexture *texture;  /**< The texture to bind. Must have been created with SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE. */
+    Uint32 mip_level;         /**< The mip level index to bind. */
+    Uint32 layer;             /**< The layer index to bind. */
+    SDL_bool cycle;           /**< SDL_TRUE cycles the texture if it is already bound. */
     Uint8 padding1;
     Uint8 padding2;
     Uint8 padding3;
@@ -2326,7 +2555,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_BindGPUFragmentStorageBuffers(
  * correlating draw call parameter MUST be 0.
  *
  * \param render_pass a render pass handle.
- * \param num_indices the number of vertices to draw per instance.
+ * \param num_indices the number of indices to draw per instance.
  * \param num_instances the number of instances to draw.
  * \param first_index the starting index within the index buffer.
  * \param vertex_offset value added to vertex index before indexing into the
@@ -2589,7 +2818,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_EndGPUComputePass(
  *
  * \param device a GPU context.
  * \param transfer_buffer a transfer buffer.
- * \param cycle if SDL_TRUE, cycles the transfer buffer if it is bound.
+ * \param cycle if SDL_TRUE, cycles the transfer buffer if it is already bound.
  * \returns the address of the mapped transfer buffer memory.
  *
  * \since This function is available since SDL 3.0.0.
@@ -2662,7 +2891,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_UploadToGPUTexture(
  * \param copy_pass a copy pass handle.
  * \param source the source transfer buffer with offset.
  * \param destination the destination buffer with offset and size.
- * \param cycle if SDL_TRUE, cycles the buffer if it is bound, otherwise
+ * \param cycle if SDL_TRUE, cycles the buffer if it is already bound, otherwise
  *              overwrites the data.
  *
  * \since This function is available since SDL 3.0.0.
@@ -2711,7 +2940,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_CopyGPUTextureToTexture(
  * \param source the buffer and offset to copy from.
  * \param destination the buffer and offset to copy to.
  * \param size the length of the buffer to copy.
- * \param cycle if SDL_TRUE, cycles the destination buffer if it is bound,
+ * \param cycle if SDL_TRUE, cycles the destination buffer if it is already bound,
  *              otherwise overwrites the data.
  *
  * \since This function is available since SDL 3.0.0.

src/gpu/d3d11/SDL_gpu_d3d11.c

@@ -1358,7 +1358,7 @@ static Uint32 D3D11_INTERNAL_FindIndexOfVertexBinding(
     Uint32 numBindings)
 {
     for (Uint32 i = 0; i < numBindings; i += 1) {
-        if (bindings[i].binding == targetBinding) {
+        if (bindings[i].index == targetBinding) {
             return i;
         }
     }
@@ -1392,7 +1392,7 @@ static ID3D11InputLayout *D3D11_INTERNAL_FetchInputLayout(
     for (Uint32 i = 0; i < inputState.num_vertex_attributes; i += 1) {
         elementDescs[i].AlignedByteOffset = inputState.vertex_attributes[i].offset;
         elementDescs[i].Format = SDLToD3D11_VertexFormat[inputState.vertex_attributes[i].format];
-        elementDescs[i].InputSlot = inputState.vertex_attributes[i].binding;
+        elementDescs[i].InputSlot = inputState.vertex_attributes[i].binding_index;
 
         bindingIndex = D3D11_INTERNAL_FindIndexOfVertexBinding(
             elementDescs[i].InputSlot,

src/gpu/d3d12/SDL_gpu_d3d12.c

@@ -2470,10 +2470,10 @@ static bool D3D12_INTERNAL_ConvertVertexInputState(SDL_GPUVertexInputState verte
         desc[i].SemanticName = semantic;
         desc[i].SemanticIndex = attribute.location;
         desc[i].Format = SDLToD3D12_VertexFormat[attribute.format];
-        desc[i].InputSlot = attribute.binding;
+        desc[i].InputSlot = attribute.binding_index;
         desc[i].AlignedByteOffset = attribute.offset;
-        desc[i].InputSlotClass = SDLToD3D12_InputRate[vertexInputState.vertex_bindings[attribute.binding].input_rate];
-        desc[i].InstanceDataStepRate = (vertexInputState.vertex_bindings[attribute.binding].input_rate == SDL_GPU_VERTEXINPUTRATE_INSTANCE) ? vertexInputState.vertex_bindings[attribute.binding].instance_step_rate : 0;
+        desc[i].InputSlotClass = SDLToD3D12_InputRate[vertexInputState.vertex_bindings[attribute.binding_index].input_rate];
+        desc[i].InstanceDataStepRate = (vertexInputState.vertex_bindings[attribute.binding_index].input_rate == SDL_GPU_VERTEXINPUTRATE_INSTANCE) ? vertexInputState.vertex_bindings[attribute.binding_index].instance_step_rate : 0;
     }
 
     return true;

src/gpu/metal/SDL_gpu_metal.m

@@ -1076,11 +1076,11 @@ static SDL_GPUGraphicsPipeline *METAL_CreateGraphicsPipeline(
                 Uint32 loc = createinfo->vertex_input_state.vertex_attributes[i].location;
                 vertexDescriptor.attributes[loc].format = SDLToMetal_VertexFormat[createinfo->vertex_input_state.vertex_attributes[i].format];
                 vertexDescriptor.attributes[loc].offset = createinfo->vertex_input_state.vertex_attributes[i].offset;
-                vertexDescriptor.attributes[loc].bufferIndex = METAL_INTERNAL_GetVertexBufferIndex(createinfo->vertex_input_state.vertex_attributes[i].binding);
+                vertexDescriptor.attributes[loc].bufferIndex = METAL_INTERNAL_GetVertexBufferIndex(createinfo->vertex_input_state.vertex_attributes[i].binding_index);
             }
 
             for (Uint32 i = 0; i < createinfo->vertex_input_state.num_vertex_bindings; i += 1) {
-                binding = METAL_INTERNAL_GetVertexBufferIndex(createinfo->vertex_input_state.vertex_bindings[i].binding);
+                binding = METAL_INTERNAL_GetVertexBufferIndex(createinfo->vertex_input_state.vertex_bindings[i].index);
                 vertexDescriptor.layouts[binding].stepFunction = SDLToMetal_StepFunction[createinfo->vertex_input_state.vertex_bindings[i].input_rate];
                 vertexDescriptor.layouts[binding].stepRate = (createinfo->vertex_input_state.vertex_bindings[i].input_rate == SDL_GPU_VERTEXINPUTRATE_INSTANCE) ? createinfo->vertex_input_state.vertex_bindings[i].instance_step_rate : 1;
                 vertexDescriptor.layouts[binding].stride = createinfo->vertex_input_state.vertex_bindings[i].pitch;

src/gpu/vulkan/SDL_gpu_vulkan.c

@@ -6483,7 +6483,7 @@ static SDL_GPUGraphicsPipeline *VULKAN_CreateGraphicsPipeline(
     // Vertex input
 
     for (i = 0; i < createinfo->vertex_input_state.num_vertex_bindings; i += 1) {
-        vertexInputBindingDescriptions[i].binding = createinfo->vertex_input_state.vertex_bindings[i].binding;
+        vertexInputBindingDescriptions[i].binding = createinfo->vertex_input_state.vertex_bindings[i].index;
         vertexInputBindingDescriptions[i].inputRate = SDLToVK_VertexInputRate[createinfo->vertex_input_state.vertex_bindings[i].input_rate];
         vertexInputBindingDescriptions[i].stride = createinfo->vertex_input_state.vertex_bindings[i].pitch;
 
@@ -6493,7 +6493,7 @@ static SDL_GPUGraphicsPipeline *VULKAN_CreateGraphicsPipeline(
     }
 
     for (i = 0; i < createinfo->vertex_input_state.num_vertex_attributes; i += 1) {
-        vertexInputAttributeDescriptions[i].binding = createinfo->vertex_input_state.vertex_attributes[i].binding;
+        vertexInputAttributeDescriptions[i].binding = createinfo->vertex_input_state.vertex_attributes[i].binding_index;
         vertexInputAttributeDescriptions[i].format = SDLToVK_VertexFormat[createinfo->vertex_input_state.vertex_attributes[i].format];
         vertexInputAttributeDescriptions[i].location = createinfo->vertex_input_state.vertex_attributes[i].location;
         vertexInputAttributeDescriptions[i].offset = createinfo->vertex_input_state.vertex_attributes[i].offset;
@@ -6512,7 +6512,7 @@ static SDL_GPUGraphicsPipeline *VULKAN_CreateGraphicsPipeline(
 
         for (i = 0; i < createinfo->vertex_input_state.num_vertex_bindings; i += 1) {
             if (createinfo->vertex_input_state.vertex_bindings[i].input_rate == SDL_GPU_VERTEXINPUTRATE_INSTANCE) {
-                divisorDescriptions[divisorDescriptionCount].binding = createinfo->vertex_input_state.vertex_bindings[i].binding;
+                divisorDescriptions[divisorDescriptionCount].binding = createinfo->vertex_input_state.vertex_bindings[i].index;
                 divisorDescriptions[divisorDescriptionCount].divisor = createinfo->vertex_input_state.vertex_bindings[i].instance_step_rate;
 
                 divisorDescriptionCount += 1;

test/testgpu_spinning_cube.c

@@ -571,17 +571,17 @@ init_render_state(int msaa)
     pipelinedesc.vertex_shader = vertex_shader;
     pipelinedesc.fragment_shader = fragment_shader;
 
-    vertex_binding.binding = 0;
+    vertex_binding.index = 0;
     vertex_binding.input_rate = SDL_GPU_VERTEXINPUTRATE_VERTEX;
     vertex_binding.instance_step_rate = 0;
     vertex_binding.pitch = sizeof(VertexData);
 
-    vertex_attributes[0].binding = 0;
+    vertex_attributes[0].binding_index = 0;
     vertex_attributes[0].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3;
     vertex_attributes[0].location = 0;
     vertex_attributes[0].offset = 0;
 
-    vertex_attributes[1].binding = 0;
+    vertex_attributes[1].binding_index = 0;
     vertex_attributes[1].format = SDL_GPU_VERTEXELEMENTFORMAT_FLOAT3;
     vertex_attributes[1].location = 1;
     vertex_attributes[1].offset = sizeof(float) * 3;