diff --git a/include/SDL3/SDL_gpu.h b/include/SDL3/SDL_gpu.h index ffbc51a96..e6dbdf52c 100644 --- a/include/SDL3/SDL_gpu.h +++ b/include/SDL3/SDL_gpu.h @@ -250,11 +250,11 @@ typedef struct SDL_GPUFence SDL_GPUFence; */ typedef enum SDL_GPUPrimitiveType { - SDL_GPU_PRIMITIVETYPE_POINTLIST, /**< A series of separate points. */ + SDL_GPU_PRIMITIVETYPE_TRIANGLELIST, /**< A series of separate triangles. */ + SDL_GPU_PRIMITIVETYPE_TRIANGLESTRIP, /**< A series of connected triangles. */ SDL_GPU_PRIMITIVETYPE_LINELIST, /**< A series of separate lines. */ SDL_GPU_PRIMITIVETYPE_LINESTRIP, /**< A series of connected lines. */ - SDL_GPU_PRIMITIVETYPE_TRIANGLELIST, /**< A series of separate triangles. */ - SDL_GPU_PRIMITIVETYPE_TRIANGLESTRIP /**< A series of connected triangles. */ + SDL_GPU_PRIMITIVETYPE_POINTLIST /**< A series of separate points. */ } SDL_GPUPrimitiveType; /** @@ -384,7 +384,7 @@ typedef enum SDL_GPUIndexElementSize */ typedef enum SDL_GPUTextureFormat { - SDL_GPU_TEXTUREFORMAT_INVALID = -1, + SDL_GPU_TEXTUREFORMAT_INVALID, /* Unsigned Normalized Float Color Formats */ SDL_GPU_TEXTUREFORMAT_A8_UNORM, @@ -586,12 +586,13 @@ typedef enum SDL_GPUShaderStage */ typedef Uint32 SDL_GPUShaderFormat; -#define SDL_GPU_SHADERFORMAT_PRIVATE (1u << 0) /**< Shaders for NDA'd platforms. */ -#define SDL_GPU_SHADERFORMAT_SPIRV (1u << 1) /**< SPIR-V shaders for Vulkan. */ -#define SDL_GPU_SHADERFORMAT_DXBC (1u << 2) /**< DXBC SM5_0 shaders for D3D11. */ -#define SDL_GPU_SHADERFORMAT_DXIL (1u << 3) /**< DXIL shaders for D3D12. */ -#define SDL_GPU_SHADERFORMAT_MSL (1u << 4) /**< MSL shaders for Metal. */ -#define SDL_GPU_SHADERFORMAT_METALLIB (1u << 5) /**< Precompiled metallib shaders for Metal. */ +#define SDL_GPU_SHADERFORMAT_INVALID 0 +#define SDL_GPU_SHADERFORMAT_PRIVATE (1u << 1) /**< Shaders for NDA'd platforms. */ +#define SDL_GPU_SHADERFORMAT_SPIRV (1u << 2) /**< SPIR-V shaders for Vulkan. */ +#define SDL_GPU_SHADERFORMAT_DXBC (1u << 3) /**< DXBC SM5_0 shaders for D3D11. */ +#define SDL_GPU_SHADERFORMAT_DXIL (1u << 4) /**< DXIL shaders for D3D12. */ +#define SDL_GPU_SHADERFORMAT_MSL (1u << 5) /**< MSL shaders for Metal. */ +#define SDL_GPU_SHADERFORMAT_METALLIB (1u << 6) /**< Precompiled metallib shaders for Metal. */ /** * Specifies the format of a vertex attribute. @@ -602,6 +603,8 @@ typedef Uint32 SDL_GPUShaderFormat; */ typedef enum SDL_GPUVertexElementFormat { + SDL_GPU_VERTEXELEMENTFORMAT_INVALID, + /* 32-bit Signed Integers */ SDL_GPU_VERTEXELEMENTFORMAT_INT, SDL_GPU_VERTEXELEMENTFORMAT_INT2, @@ -666,8 +669,8 @@ typedef enum SDL_GPUVertexElementFormat */ typedef enum SDL_GPUVertexInputRate { - SDL_GPU_VERTEXINPUTRATE_VERTEX = 0, /**< Attribute addressing is a function of the vertex index. */ - SDL_GPU_VERTEXINPUTRATE_INSTANCE = 1 /**< Attribute addressing is a function of the instance index. */ + SDL_GPU_VERTEXINPUTRATE_VERTEX, /**< Attribute addressing is a function of the vertex index. */ + SDL_GPU_VERTEXINPUTRATE_INSTANCE /**< Attribute addressing is a function of the instance index. */ } SDL_GPUVertexInputRate; /** @@ -720,6 +723,7 @@ typedef enum SDL_GPUFrontFace */ typedef enum SDL_GPUCompareOp { + SDL_GPU_COMPAREOP_INVALID, SDL_GPU_COMPAREOP_NEVER, /**< The comparison always evaluates false. */ SDL_GPU_COMPAREOP_LESS, /**< The comparison evaluates reference < test. */ SDL_GPU_COMPAREOP_EQUAL, /**< The comparison evaluates reference == test. */ @@ -740,6 +744,7 @@ typedef enum SDL_GPUCompareOp */ typedef enum SDL_GPUStencilOp { + SDL_GPU_STENCILOP_INVALID, SDL_GPU_STENCILOP_KEEP, /**< Keeps the current value. */ SDL_GPU_STENCILOP_ZERO, /**< Sets the value to 0. */ SDL_GPU_STENCILOP_REPLACE, /**< Sets the value to reference. */ @@ -763,6 +768,7 @@ typedef enum SDL_GPUStencilOp */ typedef enum SDL_GPUBlendOp { + SDL_GPU_BLENDOP_INVALID, SDL_GPU_BLENDOP_ADD, /**< (source * source_factor) + (destination * destination_factor) */ SDL_GPU_BLENDOP_SUBTRACT, /**< (source * source_factor) - (destination * destination_factor) */ SDL_GPU_BLENDOP_REVERSE_SUBTRACT, /**< (destination * destination_factor) - (source * source_factor) */ @@ -783,6 +789,7 @@ typedef enum SDL_GPUBlendOp */ typedef enum SDL_GPUBlendFactor { + SDL_GPU_BLENDFACTOR_INVALID, SDL_GPU_BLENDFACTOR_ZERO, /**< 0 */ SDL_GPU_BLENDFACTOR_ONE, /**< 1 */ SDL_GPU_BLENDFACTOR_SRC_COLOR, /**< source color */ @@ -933,7 +940,7 @@ typedef enum SDL_GPUSwapchainComposition */ typedef enum SDL_GPUDriver { - SDL_GPU_DRIVER_INVALID = -1, + SDL_GPU_DRIVER_INVALID, SDL_GPU_DRIVER_PRIVATE, /* NDA'd platforms */ SDL_GPU_DRIVER_VULKAN, SDL_GPU_DRIVER_D3D11, @@ -1159,13 +1166,13 @@ typedef struct SDL_GPUSamplerCreateInfo 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_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_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; /**< 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; /**< A properties ID for extensions. Should be 0 if no extensions are needed. */ } SDL_GPUSamplerCreateInfo; @@ -1251,17 +1258,17 @@ typedef struct SDL_GPUStencilOpState */ typedef struct SDL_GPUColorTargetBlendState { - SDL_bool enable_blend; /**< Whether blending is enabled for the color target. */ - Uint8 padding1; - Uint8 padding2; - Uint8 padding3; 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_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 SDL_FALSE. */ + SDL_bool enable_blend; /**< Whether blending is enabled for the color target. */ + SDL_bool enable_color_write_mask; /**< Whether the color write mask is enabled. */ + Uint8 padding2; + Uint8 padding3; } SDL_GPUColorTargetBlendState; @@ -1367,13 +1374,13 @@ typedef struct SDL_GPURasterizerState 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. */ + 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_bool enable_depth_bias; /**< SDL_TRUE to bias fragment depth values. */ Uint8 padding1; Uint8 padding2; Uint8 padding3; - 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; /** @@ -1387,7 +1394,11 @@ typedef struct SDL_GPURasterizerState typedef struct SDL_GPUMultisampleState { 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. */ + Uint32 sample_mask; /**< Determines which samples get updated in the render targets. Treated as 0xFFFFFFFF if enable_mask is SDL_FALSE. */ + SDL_bool enable_mask; /**< Enables sample masking. */ + Uint8 padding1; + Uint8 padding2; + Uint8 padding3; } SDL_GPUMultisampleState; /** @@ -1400,15 +1411,15 @@ typedef struct SDL_GPUMultisampleState */ typedef struct SDL_GPUDepthStencilState { - 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; /**< 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. */ + 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; Uint8 padding2; Uint8 padding3; } SDL_GPUDepthStencilState; @@ -1439,11 +1450,11 @@ typedef struct SDL_GpuGraphicsPipelineTargetInfo { 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_GPUTextureFormat depth_stencil_format; /**< The pixel format of the depth-stencil target. Ignored if has_depth_stencil_target is SDL_FALSE. */ 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; /**< The pixel format of the depth-stencil target. Ignored if has_depth_stencil_target is SDL_FALSE. */ } SDL_GpuGraphicsPipelineTargetInfo; /** @@ -1601,7 +1612,7 @@ typedef struct SDL_GPUBlitInfo { SDL_FlipMode flip_mode; /**< The flip mode for the source region. */ SDL_GPUFilter filter; /**< The filter mode used when blitting. */ SDL_bool cycle; /**< SDL_TRUE cycles the destination texture if it is already bound. */ - Uint8 padding; + Uint8 padding1; Uint8 padding2; Uint8 padding3; } SDL_GPUBlitInfo; diff --git a/src/gpu/SDL_gpu.c b/src/gpu/SDL_gpu.c index bfd94b683..7e2396d92 100644 --- a/src/gpu/SDL_gpu.c +++ b/src/gpu/SDL_gpu.c @@ -79,20 +79,50 @@ return; \ } -#define CHECK_TEXTUREFORMAT_ENUM_INVALID(format, retval) \ - if (format >= SDL_GPU_TEXTUREFORMAT_MAX) { \ +#define CHECK_TEXTUREFORMAT_ENUM_INVALID(enumval, retval) \ + if (enumval <= SDL_GPU_TEXTUREFORMAT_INVALID || enumval >= SDL_GPU_TEXTUREFORMAT_MAX_ENUM_VALUE) { \ SDL_assert_release(!"Invalid texture format enum!"); \ return retval; \ } +#define CHECK_VERTEXELEMENTFORMAT_ENUM_INVALID(enumval, retval) \ + if (enumval <= SDL_GPU_VERTEXELEMENTFORMAT_INVALID || enumval >= SDL_GPU_VERTEXELEMENTFORMAT_MAX_ENUM_VALUE) { \ + SDL_assert_release(!"Invalid vertex format enum!"); \ + return retval; \ + } + +#define CHECK_COMPAREOP_ENUM_INVALID(enumval, retval) \ + if (enumval <= SDL_GPU_COMPAREOP_INVALID || enumval >= SDL_GPU_COMPAREOP_MAX_ENUM_VALUE) { \ + SDL_assert_release(!"Invalid compare op enum!"); \ + return retval; \ + } + +#define CHECK_STENCILOP_ENUM_INVALID(enumval, retval) \ + if (enumval <= SDL_GPU_STENCILOP_INVALID || enumval >= SDL_GPU_STENCILOP_MAX_ENUM_VALUE) { \ + SDL_assert_release(!"Invalid stencil op enum!"); \ + return retval; \ + } + +#define CHECK_BLENDOP_ENUM_INVALID(enumval, retval) \ + if (enumval <= SDL_GPU_BLENDOP_INVALID || enumval >= SDL_GPU_BLENDOP_MAX_ENUM_VALUE) { \ + SDL_assert_release(!"Invalid blend op enum!"); \ + return retval; \ + } + +#define CHECK_BLENDFACTOR_ENUM_INVALID(enumval, retval) \ + if (enumval <= SDL_GPU_BLENDFACTOR_INVALID || enumval >= SDL_GPU_BLENDFACTOR_MAX_ENUM_VALUE) { \ + SDL_assert_release(!"Invalid blend factor enum!"); \ + return retval; \ + } + #define CHECK_SWAPCHAINCOMPOSITION_ENUM_INVALID(enumval, retval) \ - if (enumval >= SDL_GPU_SWAPCHAINCOMPOSITION_MAX) { \ + if (enumval < 0 || enumval >= SDL_GPU_SWAPCHAINCOMPOSITION_MAX_ENUM_VALUE) { \ SDL_assert_release(!"Invalid swapchain composition enum!"); \ return retval; \ } #define CHECK_PRESENTMODE_ENUM_INVALID(enumval, retval) \ - if (enumval >= SDL_GPU_PRESENTMODE_MAX) { \ + if (enumval < 0 || enumval >= SDL_GPU_PRESENTMODE_MAX_ENUM_VALUE) { \ SDL_assert_release(!"Invalid present mode enum!"); \ return retval; \ } @@ -190,7 +220,7 @@ SDL_GPUGraphicsPipeline *SDL_GPU_FetchBlitPipeline( } blit_pipeline_create_info.multisample_state.sample_count = SDL_GPU_SAMPLECOUNT_1; - blit_pipeline_create_info.multisample_state.sample_mask = 0xFFFFFFFF; + blit_pipeline_create_info.multisample_state.enable_mask = SDL_FALSE; blit_pipeline_create_info.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST; @@ -590,11 +620,14 @@ SDL_GPUComputePipeline *SDL_CreateGPUComputePipeline( } if (device->debug_mode) { + if (createinfo->format == SDL_GPU_SHADERFORMAT_INVALID) { + SDL_assert_release(!"Shader format cannot be INVALID!"); + return NULL; + } if (!(createinfo->format & device->shader_formats)) { SDL_assert_release(!"Incompatible shader format for GPU backend"); return NULL; } - if (createinfo->num_writeonly_storage_textures > MAX_COMPUTE_WRITE_TEXTURES) { SDL_assert_release(!"Compute pipeline write-only texture count cannot be higher than 8!"); return NULL; @@ -627,12 +660,25 @@ SDL_GPUGraphicsPipeline *SDL_CreateGPUGraphicsPipeline( } if (device->debug_mode) { + if (graphicsPipelineCreateInfo->target_info.num_color_targets > 0 && graphicsPipelineCreateInfo->target_info.color_target_descriptions == NULL) { + SDL_assert_release(!"Color target descriptions array pointer cannot be NULL if num_color_targets is greater than zero!"); + return NULL; + } for (Uint32 i = 0; i < graphicsPipelineCreateInfo->target_info.num_color_targets; i += 1) { CHECK_TEXTUREFORMAT_ENUM_INVALID(graphicsPipelineCreateInfo->target_info.color_target_descriptions[i].format, NULL); if (IsDepthFormat(graphicsPipelineCreateInfo->target_info.color_target_descriptions[i].format)) { SDL_assert_release(!"Color target formats cannot be a depth format!"); return NULL; } + if (graphicsPipelineCreateInfo->target_info.color_target_descriptions[i].blend_state.enable_blend) { + const SDL_GPUColorTargetBlendState *blend_state = &graphicsPipelineCreateInfo->target_info.color_target_descriptions[i].blend_state; + CHECK_BLENDFACTOR_ENUM_INVALID(blend_state->src_color_blendfactor, NULL) + CHECK_BLENDFACTOR_ENUM_INVALID(blend_state->dst_color_blendfactor, NULL) + CHECK_BLENDOP_ENUM_INVALID(blend_state->color_blend_op, NULL) + CHECK_BLENDFACTOR_ENUM_INVALID(blend_state->src_alpha_blendfactor, NULL) + CHECK_BLENDFACTOR_ENUM_INVALID(blend_state->dst_alpha_blendfactor, NULL) + CHECK_BLENDOP_ENUM_INVALID(blend_state->alpha_blend_op, NULL) + } } if (graphicsPipelineCreateInfo->target_info.has_depth_stencil_target) { CHECK_TEXTUREFORMAT_ENUM_INVALID(graphicsPipelineCreateInfo->target_info.depth_stencil_format, NULL); @@ -641,6 +687,27 @@ SDL_GPUGraphicsPipeline *SDL_CreateGPUGraphicsPipeline( return NULL; } } + if (graphicsPipelineCreateInfo->vertex_input_state.num_vertex_bindings > 0 && graphicsPipelineCreateInfo->vertex_input_state.vertex_bindings == NULL) { + SDL_assert_release(!"Vertex bindings array pointer cannot be NULL!"); + return NULL; + } + if (graphicsPipelineCreateInfo->vertex_input_state.num_vertex_attributes > 0 && graphicsPipelineCreateInfo->vertex_input_state.vertex_attributes == NULL) { + SDL_assert_release(!"Vertex attributes array pointer cannot be NULL!"); + return NULL; + } + for (Uint32 i = 0; i < graphicsPipelineCreateInfo->vertex_input_state.num_vertex_attributes; i += 1) { + CHECK_VERTEXELEMENTFORMAT_ENUM_INVALID(graphicsPipelineCreateInfo->vertex_input_state.vertex_attributes[i].format, NULL); + } + if (graphicsPipelineCreateInfo->depth_stencil_state.enable_depth_test) { + CHECK_COMPAREOP_ENUM_INVALID(graphicsPipelineCreateInfo->depth_stencil_state.compare_op, NULL) + } + if (graphicsPipelineCreateInfo->depth_stencil_state.enable_stencil_test) { + const SDL_GPUStencilOpState *stencil_state = &graphicsPipelineCreateInfo->depth_stencil_state.back_stencil_state; + CHECK_COMPAREOP_ENUM_INVALID(stencil_state->compare_op, NULL) + CHECK_STENCILOP_ENUM_INVALID(stencil_state->fail_op, NULL) + CHECK_STENCILOP_ENUM_INVALID(stencil_state->pass_op, NULL) + CHECK_STENCILOP_ENUM_INVALID(stencil_state->depth_fail_op, NULL) + } } return device->CreateGraphicsPipeline( @@ -674,6 +741,10 @@ SDL_GPUShader *SDL_CreateGPUShader( } if (device->debug_mode) { + if (createinfo->format == SDL_GPU_SHADERFORMAT_INVALID) { + SDL_assert_release(!"Shader format cannot be INVALID!"); + return NULL; + } if (!(createinfo->format & device->shader_formats)) { SDL_assert_release(!"Incompatible shader format for GPU backend"); return NULL; @@ -1909,6 +1980,14 @@ void SDL_UploadToGPUTexture( if (COPYPASS_DEVICE->debug_mode) { CHECK_COPYPASS + if (source->transfer_buffer == NULL) { + SDL_assert_release(!"Source transfer buffer cannot be NULL!"); + return; + } + if (destination->texture == NULL) { + SDL_assert_release(!"Destination texture cannot be NULL!"); + return; + } } COPYPASS_DEVICE->UploadToTexture( @@ -1937,6 +2016,18 @@ void SDL_UploadToGPUBuffer( return; } + if (COPYPASS_DEVICE->debug_mode) { + CHECK_COPYPASS + if (source->transfer_buffer == NULL) { + SDL_assert_release(!"Source transfer buffer cannot be NULL!"); + return; + } + if (destination->buffer == NULL) { + SDL_assert_release(!"Destination buffer cannot be NULL!"); + return; + } + } + COPYPASS_DEVICE->UploadToBuffer( COPYPASS_COMMAND_BUFFER, source, @@ -1966,6 +2057,18 @@ void SDL_CopyGPUTextureToTexture( return; } + if (COPYPASS_DEVICE->debug_mode) { + CHECK_COPYPASS + if (source->texture == NULL) { + SDL_assert_release(!"Source texture cannot be NULL!"); + return; + } + if (destination->texture == NULL) { + SDL_assert_release(!"Destination texture cannot be NULL!"); + return; + } + } + COPYPASS_DEVICE->CopyTextureToTexture( COPYPASS_COMMAND_BUFFER, source, @@ -1996,6 +2099,18 @@ void SDL_CopyGPUBufferToBuffer( return; } + if (COPYPASS_DEVICE->debug_mode) { + CHECK_COPYPASS + if (source->buffer == NULL) { + SDL_assert_release(!"Source buffer cannot be NULL!"); + return; + } + if (destination->buffer == NULL) { + SDL_assert_release(!"Destination buffer cannot be NULL!"); + return; + } + } + COPYPASS_DEVICE->CopyBufferToBuffer( COPYPASS_COMMAND_BUFFER, source, @@ -2022,6 +2137,18 @@ void SDL_DownloadFromGPUTexture( return; } + if (COPYPASS_DEVICE->debug_mode) { + CHECK_COPYPASS + if (source->texture == NULL) { + SDL_assert_release(!"Source texture cannot be NULL!"); + return; + } + if (destination->transfer_buffer == NULL) { + SDL_assert_release(!"Destination transfer buffer cannot be NULL!"); + return; + } + } + COPYPASS_DEVICE->DownloadFromTexture( COPYPASS_COMMAND_BUFFER, source, @@ -2046,6 +2173,18 @@ void SDL_DownloadFromGPUBuffer( return; } + if (COPYPASS_DEVICE->debug_mode) { + CHECK_COPYPASS + if (source->buffer == NULL) { + SDL_assert_release(!"Source buffer cannot be NULL!"); + return; + } + if (destination->transfer_buffer == NULL) { + SDL_assert_release(!"Destination transfer buffer cannot be NULL!"); + return; + } + } + COPYPASS_DEVICE->DownloadFromBuffer( COPYPASS_COMMAND_BUFFER, source, diff --git a/src/gpu/SDL_sysgpu.h b/src/gpu/SDL_sysgpu.h index 47a965320..1706071dc 100644 --- a/src/gpu/SDL_sysgpu.h +++ b/src/gpu/SDL_sysgpu.h @@ -69,9 +69,14 @@ typedef struct BlitPipelineCacheEntry // Internal Helper Utilities -#define SDL_GPU_TEXTUREFORMAT_MAX (SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT + 1) -#define SDL_GPU_SWAPCHAINCOMPOSITION_MAX (SDL_GPU_SWAPCHAINCOMPOSITION_HDR10_ST2048 + 1) -#define SDL_GPU_PRESENTMODE_MAX (SDL_GPU_PRESENTMODE_MAILBOX + 1) +#define SDL_GPU_TEXTUREFORMAT_MAX_ENUM_VALUE (SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT + 1) +#define SDL_GPU_VERTEXELEMENTFORMAT_MAX_ENUM_VALUE (SDL_GPU_VERTEXELEMENTFORMAT_HALF4 + 1) +#define SDL_GPU_COMPAREOP_MAX_ENUM_VALUE (SDL_GPU_COMPAREOP_ALWAYS + 1) +#define SDL_GPU_STENCILOP_MAX_ENUM_VALUE (SDL_GPU_STENCILOP_DECREMENT_AND_WRAP + 1) +#define SDL_GPU_BLENDOP_MAX_ENUM_VALUE (SDL_GPU_BLENDOP_MAX + 1) +#define SDL_GPU_BLENDFACTOR_MAX_ENUM_VALUE (SDL_GPU_BLENDFACTOR_SRC_ALPHA_SATURATE + 1) +#define SDL_GPU_SWAPCHAINCOMPOSITION_MAX_ENUM_VALUE (SDL_GPU_SWAPCHAINCOMPOSITION_HDR10_ST2048 + 1) +#define SDL_GPU_PRESENTMODE_MAX_ENUM_VALUE (SDL_GPU_PRESENTMODE_MAILBOX + 1) static inline Sint32 Texture_GetBlockSize( SDL_GPUTextureFormat format) diff --git a/src/gpu/d3d11/SDL_gpu_d3d11.c b/src/gpu/d3d11/SDL_gpu_d3d11.c index e2df61430..711688ae3 100644 --- a/src/gpu/d3d11/SDL_gpu_d3d11.c +++ b/src/gpu/d3d11/SDL_gpu_d3d11.c @@ -168,6 +168,7 @@ static DXGI_COLOR_SPACE_TYPE SwapchainCompositionToColorSpace[] = { }; static DXGI_FORMAT SDLToD3D11_TextureFormat[] = { + DXGI_FORMAT_UNKNOWN, // INVALID DXGI_FORMAT_A8_UNORM, // A8_UNORM DXGI_FORMAT_R8_UNORM, // R8_UNORM DXGI_FORMAT_R8G8_UNORM, // R8G8_UNORM @@ -225,9 +226,10 @@ static DXGI_FORMAT SDLToD3D11_TextureFormat[] = { DXGI_FORMAT_D24_UNORM_S8_UINT, // D24_UNORM_S8_UINT DXGI_FORMAT_D32_FLOAT_S8X24_UINT, // D32_FLOAT_S8_UINT }; -SDL_COMPILE_TIME_ASSERT(SDLToD3D11_TextureFormat, SDL_arraysize(SDLToD3D11_TextureFormat) == SDL_GPU_TEXTUREFORMAT_MAX); +SDL_COMPILE_TIME_ASSERT(SDLToD3D11_TextureFormat, SDL_arraysize(SDLToD3D11_TextureFormat) == SDL_GPU_TEXTUREFORMAT_MAX_ENUM_VALUE); static DXGI_FORMAT SDLToD3D11_VertexFormat[] = { + DXGI_FORMAT_UNKNOWN, // INVALID DXGI_FORMAT_R32_SINT, // INT DXGI_FORMAT_R32G32_SINT, // INT2 DXGI_FORMAT_R32G32B32_SINT, // INT3 @@ -259,6 +261,7 @@ static DXGI_FORMAT SDLToD3D11_VertexFormat[] = { DXGI_FORMAT_R16G16_FLOAT, // HALF2 DXGI_FORMAT_R16G16B16A16_FLOAT // HALF4 }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D11_VertexFormat, SDL_arraysize(SDLToD3D11_VertexFormat) == SDL_GPU_VERTEXELEMENTFORMAT_MAX_ENUM_VALUE); static Uint32 SDLToD3D11_SampleCount[] = { 1, // SDL_GPU_SAMPLECOUNT_1 @@ -273,11 +276,11 @@ static DXGI_FORMAT SDLToD3D11_IndexType[] = { }; static D3D11_PRIMITIVE_TOPOLOGY SDLToD3D11_PrimitiveType[] = { - D3D_PRIMITIVE_TOPOLOGY_POINTLIST, // POINTLIST - D3D_PRIMITIVE_TOPOLOGY_LINELIST, // LINELIST - D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, // LINESTRIP - D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, // TRIANGLELIST - D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP // TRIANGLESTRIP + D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, // TRIANGLELIST + D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, // TRIANGLESTRIP + D3D_PRIMITIVE_TOPOLOGY_LINELIST, // LINELIST + D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, // LINESTRIP + D3D_PRIMITIVE_TOPOLOGY_POINTLIST // POINTLIST }; static D3D11_CULL_MODE SDLToD3D11_CullMode[] = { @@ -287,6 +290,7 @@ static D3D11_CULL_MODE SDLToD3D11_CullMode[] = { }; static D3D11_BLEND SDLToD3D11_BlendFactor[] = { + D3D11_BLEND_ZERO, // INVALID D3D11_BLEND_ZERO, // ZERO D3D11_BLEND_ONE, // ONE D3D11_BLEND_SRC_COLOR, // SRC_COLOR @@ -301,8 +305,10 @@ static D3D11_BLEND SDLToD3D11_BlendFactor[] = { D3D11_BLEND_INV_BLEND_FACTOR, // ONE_MINUS_CONSTANT_COLOR D3D11_BLEND_SRC_ALPHA_SAT, // SRC_ALPHA_SATURATE }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D11_BlendFactor, SDL_arraysize(SDLToD3D11_BlendFactor) == SDL_GPU_BLENDFACTOR_MAX_ENUM_VALUE); static D3D11_BLEND SDLToD3D11_BlendFactorAlpha[] = { + D3D11_BLEND_ZERO, // ALPHA D3D11_BLEND_ZERO, // ZERO D3D11_BLEND_ONE, // ONE D3D11_BLEND_SRC_ALPHA, // SRC_COLOR @@ -317,16 +323,20 @@ static D3D11_BLEND SDLToD3D11_BlendFactorAlpha[] = { D3D11_BLEND_INV_BLEND_FACTOR, // ONE_MINUS_CONSTANT_COLOR D3D11_BLEND_SRC_ALPHA_SAT, // SRC_ALPHA_SATURATE }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D11_BlendFactorAlpha, SDL_arraysize(SDLToD3D11_BlendFactorAlpha) == SDL_GPU_BLENDFACTOR_MAX_ENUM_VALUE); static D3D11_BLEND_OP SDLToD3D11_BlendOp[] = { + D3D11_BLEND_OP_ADD, // INVALID D3D11_BLEND_OP_ADD, // ADD D3D11_BLEND_OP_SUBTRACT, // SUBTRACT D3D11_BLEND_OP_REV_SUBTRACT, // REVERSE_SUBTRACT D3D11_BLEND_OP_MIN, // MIN D3D11_BLEND_OP_MAX // MAX }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D11_BlendOp, SDL_arraysize(SDLToD3D11_BlendOp) == SDL_GPU_BLENDOP_MAX_ENUM_VALUE); static D3D11_COMPARISON_FUNC SDLToD3D11_CompareOp[] = { + D3D11_COMPARISON_NEVER, // INVALID D3D11_COMPARISON_NEVER, // NEVER D3D11_COMPARISON_LESS, // LESS D3D11_COMPARISON_EQUAL, // EQUAL @@ -336,8 +346,10 @@ static D3D11_COMPARISON_FUNC SDLToD3D11_CompareOp[] = { D3D11_COMPARISON_GREATER_EQUAL, // GREATER_OR_EQUAL D3D11_COMPARISON_ALWAYS // ALWAYS }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D11_CompareOp, SDL_arraysize(SDLToD3D11_CompareOp) == SDL_GPU_COMPAREOP_MAX_ENUM_VALUE); static D3D11_STENCIL_OP SDLToD3D11_StencilOp[] = { + D3D11_STENCIL_OP_KEEP, // INVALID D3D11_STENCIL_OP_KEEP, // KEEP D3D11_STENCIL_OP_ZERO, // ZERO D3D11_STENCIL_OP_REPLACE, // REPLACE @@ -347,6 +359,7 @@ static D3D11_STENCIL_OP SDLToD3D11_StencilOp[] = { D3D11_STENCIL_OP_INCR, // INCREMENT_AND_WRAP D3D11_STENCIL_OP_DECR // DECREMENT_AND_WRAP }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D11_StencilOp, SDL_arraysize(SDLToD3D11_StencilOp) == SDL_GPU_STENCILOP_MAX_ENUM_VALUE); static D3D11_INPUT_CLASSIFICATION SDLToD3D11_VertexInputRate[] = { D3D11_INPUT_PER_VERTEX_DATA, // VERTEX @@ -1264,12 +1277,16 @@ static ID3D11BlendState *D3D11_INTERNAL_FetchBlendState( blendDesc.IndependentBlendEnable = TRUE; for (Uint32 i = 0; i < numColorTargets; i += 1) { + SDL_GPUColorComponentFlags colorWriteMask = colorTargets[i].blend_state.enable_color_write_mask ? + colorTargets[i].blend_state.color_write_mask : + 0xF; + blendDesc.RenderTarget[i].BlendEnable = colorTargets[i].blend_state.enable_blend; blendDesc.RenderTarget[i].BlendOp = SDLToD3D11_BlendOp[colorTargets[i].blend_state.color_blend_op]; blendDesc.RenderTarget[i].BlendOpAlpha = SDLToD3D11_BlendOp[colorTargets[i].blend_state.alpha_blend_op]; blendDesc.RenderTarget[i].DestBlend = SDLToD3D11_BlendFactor[colorTargets[i].blend_state.dst_color_blendfactor]; blendDesc.RenderTarget[i].DestBlendAlpha = SDLToD3D11_BlendFactorAlpha[colorTargets[i].blend_state.dst_alpha_blendfactor]; - blendDesc.RenderTarget[i].RenderTargetWriteMask = colorTargets[i].blend_state.color_write_mask; + blendDesc.RenderTarget[i].RenderTargetWriteMask = colorWriteMask; blendDesc.RenderTarget[i].SrcBlend = SDLToD3D11_BlendFactor[colorTargets[i].blend_state.src_color_blendfactor]; blendDesc.RenderTarget[i].SrcBlendAlpha = SDLToD3D11_BlendFactorAlpha[colorTargets[i].blend_state.src_alpha_blendfactor]; } @@ -3427,7 +3444,9 @@ static void D3D11_SetBlendConstants( { D3D11CommandBuffer *d3d11CommandBuffer = (D3D11CommandBuffer *)commandBuffer; FLOAT blendFactor[4] = { blendConstants.r, blendConstants.g, blendConstants.b, blendConstants.a }; - + Uint32 sample_mask = d3d11CommandBuffer->graphicsPipeline->multisampleState.enable_mask ? + d3d11CommandBuffer->graphicsPipeline->multisampleState.sample_mask : + 0xFFFFFFFF; d3d11CommandBuffer->blendConstants = blendConstants; if (d3d11CommandBuffer->graphicsPipeline != NULL) { @@ -3435,7 +3454,7 @@ static void D3D11_SetBlendConstants( d3d11CommandBuffer->context, d3d11CommandBuffer->graphicsPipeline->colorTargetBlendState, blendFactor, - d3d11CommandBuffer->graphicsPipeline->multisampleState.sample_mask); + sample_mask); } } @@ -3643,14 +3662,16 @@ static void D3D11_BindGraphicsPipeline( d3d11CommandBuffer->blendConstants.b, d3d11CommandBuffer->blendConstants.a }; - + Uint32 sample_mask = pipeline->multisampleState.enable_mask ? + pipeline->multisampleState.sample_mask : + 0xFFFFFFFF; d3d11CommandBuffer->graphicsPipeline = pipeline; ID3D11DeviceContext_OMSetBlendState( d3d11CommandBuffer->context, pipeline->colorTargetBlendState, blendFactor, - pipeline->multisampleState.sample_mask); + sample_mask); ID3D11DeviceContext_OMSetDepthStencilState( d3d11CommandBuffer->context, @@ -5825,7 +5846,7 @@ static void D3D11_INTERNAL_InitBlitPipelines( blitPipelineCreateInfo.fragment_shader = blitFrom2DPixelShader; blitPipelineCreateInfo.multisample_state.sample_count = SDL_GPU_SAMPLECOUNT_1; - blitPipelineCreateInfo.multisample_state.sample_mask = 0xFFFFFFFF; + blitPipelineCreateInfo.multisample_state.enable_mask = SDL_FALSE; blitPipelineCreateInfo.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST; diff --git a/src/gpu/d3d12/SDL_gpu_d3d12.c b/src/gpu/d3d12/SDL_gpu_d3d12.c index 2792bde74..87638011f 100644 --- a/src/gpu/d3d12/SDL_gpu_d3d12.c +++ b/src/gpu/d3d12/SDL_gpu_d3d12.c @@ -192,6 +192,7 @@ static DXGI_COLOR_SPACE_TYPE SwapchainCompositionToColorSpace[] = { }; static D3D12_BLEND SDLToD3D12_BlendFactor[] = { + D3D12_BLEND_ZERO, // INVALID D3D12_BLEND_ZERO, // ZERO D3D12_BLEND_ONE, // ONE D3D12_BLEND_SRC_COLOR, // SRC_COLOR @@ -206,8 +207,10 @@ static D3D12_BLEND SDLToD3D12_BlendFactor[] = { D3D12_BLEND_INV_BLEND_FACTOR, // ONE_MINUS_CONSTANT_COLOR D3D12_BLEND_SRC_ALPHA_SAT, // SRC_ALPHA_SATURATE }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D12_BlendFactor, SDL_arraysize(SDLToD3D12_BlendFactor) == SDL_GPU_BLENDFACTOR_MAX_ENUM_VALUE); static D3D12_BLEND SDLToD3D12_BlendFactorAlpha[] = { + D3D12_BLEND_ZERO, // INVALID D3D12_BLEND_ZERO, // ZERO D3D12_BLEND_ONE, // ONE D3D12_BLEND_SRC_ALPHA, // SRC_COLOR @@ -222,16 +225,20 @@ static D3D12_BLEND SDLToD3D12_BlendFactorAlpha[] = { D3D12_BLEND_INV_BLEND_FACTOR, // ONE_MINUS_CONSTANT_COLOR D3D12_BLEND_SRC_ALPHA_SAT, // SRC_ALPHA_SATURATE }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D12_BlendFactorAlpha, SDL_arraysize(SDLToD3D12_BlendFactorAlpha) == SDL_GPU_BLENDFACTOR_MAX_ENUM_VALUE); static D3D12_BLEND_OP SDLToD3D12_BlendOp[] = { + D3D12_BLEND_OP_ADD, // INVALID D3D12_BLEND_OP_ADD, // ADD D3D12_BLEND_OP_SUBTRACT, // SUBTRACT D3D12_BLEND_OP_REV_SUBTRACT, // REVERSE_SUBTRACT D3D12_BLEND_OP_MIN, // MIN D3D12_BLEND_OP_MAX // MAX }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D12_BlendOp, SDL_arraysize(SDLToD3D12_BlendOp) == SDL_GPU_BLENDOP_MAX_ENUM_VALUE); static DXGI_FORMAT SDLToD3D12_TextureFormat[] = { + DXGI_FORMAT_UNKNOWN, // INVALID DXGI_FORMAT_A8_UNORM, // A8_UNORM DXGI_FORMAT_R8_UNORM, // R8_UNORM DXGI_FORMAT_R8G8_UNORM, // R8G8_UNORM @@ -289,9 +296,10 @@ static DXGI_FORMAT SDLToD3D12_TextureFormat[] = { DXGI_FORMAT_D24_UNORM_S8_UINT, // D24_UNORM_S8_UINT DXGI_FORMAT_D32_FLOAT_S8X24_UINT, // D32_FLOAT_S8_UINT }; -SDL_COMPILE_TIME_ASSERT(SDLToD3D12_TextureFormat, SDL_arraysize(SDLToD3D12_TextureFormat) == SDL_GPU_TEXTUREFORMAT_MAX); +SDL_COMPILE_TIME_ASSERT(SDLToD3D12_TextureFormat, SDL_arraysize(SDLToD3D12_TextureFormat) == SDL_GPU_TEXTUREFORMAT_MAX_ENUM_VALUE); static D3D12_COMPARISON_FUNC SDLToD3D12_CompareOp[] = { + D3D12_COMPARISON_FUNC_NEVER, // INVALID D3D12_COMPARISON_FUNC_NEVER, // NEVER D3D12_COMPARISON_FUNC_LESS, // LESS D3D12_COMPARISON_FUNC_EQUAL, // EQUAL @@ -301,8 +309,10 @@ static D3D12_COMPARISON_FUNC SDLToD3D12_CompareOp[] = { D3D12_COMPARISON_FUNC_GREATER_EQUAL, // GREATER_OR_EQUAL D3D12_COMPARISON_FUNC_ALWAYS // ALWAYS }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D12_CompareOp, SDL_arraysize(SDLToD3D12_CompareOp) == SDL_GPU_COMPAREOP_MAX_ENUM_VALUE); static D3D12_STENCIL_OP SDLToD3D12_StencilOp[] = { + D3D12_STENCIL_OP_KEEP, // INVALID D3D12_STENCIL_OP_KEEP, // KEEP D3D12_STENCIL_OP_ZERO, // ZERO D3D12_STENCIL_OP_REPLACE, // REPLACE @@ -312,6 +322,7 @@ static D3D12_STENCIL_OP SDLToD3D12_StencilOp[] = { D3D12_STENCIL_OP_INCR, // INCREMENT_AND_WRAP D3D12_STENCIL_OP_DECR // DECREMENT_AND_WRAP }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D12_StencilOp, SDL_arraysize(SDLToD3D12_StencilOp) == SDL_GPU_STENCILOP_MAX_ENUM_VALUE); static D3D12_CULL_MODE SDLToD3D12_CullMode[] = { D3D12_CULL_MODE_NONE, // NONE @@ -330,6 +341,7 @@ static D3D12_INPUT_CLASSIFICATION SDLToD3D12_InputRate[] = { }; static DXGI_FORMAT SDLToD3D12_VertexFormat[] = { + DXGI_FORMAT_UNKNOWN, // UNKNOWN DXGI_FORMAT_R32_SINT, // INT DXGI_FORMAT_R32G32_SINT, // INT2 DXGI_FORMAT_R32G32B32_SINT, // INT3 @@ -361,6 +373,7 @@ static DXGI_FORMAT SDLToD3D12_VertexFormat[] = { DXGI_FORMAT_R16G16_FLOAT, // HALF2 DXGI_FORMAT_R16G16B16A16_FLOAT // HALF4 }; +SDL_COMPILE_TIME_ASSERT(SDLToD3D12_VertexFormat, SDL_arraysize(SDLToD3D12_VertexFormat) == SDL_GPU_VERTEXELEMENTFORMAT_MAX_ENUM_VALUE); static Uint32 SDLToD3D12_SampleCount[] = { 1, // SDL_GPU_SAMPLECOUNT_1 @@ -370,11 +383,11 @@ static Uint32 SDLToD3D12_SampleCount[] = { }; static D3D12_PRIMITIVE_TOPOLOGY SDLToD3D12_PrimitiveType[] = { - D3D_PRIMITIVE_TOPOLOGY_POINTLIST, // POINTLIST - D3D_PRIMITIVE_TOPOLOGY_LINELIST, // LINELIST - D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, // LINESTRIP - D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, // TRIANGLELIST - D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP // TRIANGLESTRIP + D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, // TRIANGLELIST + D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, // TRIANGLESTRIP + D3D_PRIMITIVE_TOPOLOGY_LINELIST, // LINELIST + D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, // LINESTRIP + D3D_PRIMITIVE_TOPOLOGY_POINTLIST // POINTLIST }; static D3D12_TEXTURE_ADDRESS_MODE SDLToD3D12_SamplerAddressMode[] = { @@ -2409,8 +2422,10 @@ static bool D3D12_INTERNAL_ConvertBlendState( // If target_info has more blend states, you can set IndependentBlendEnable to TRUE and assign different blend states to each render target slot if (i < pipelineInfo->target_info.num_color_targets) { - SDL_GPUColorTargetBlendState sdlBlendState = pipelineInfo->target_info.color_target_descriptions[i].blend_state; + SDL_GPUColorComponentFlags colorWriteMask = sdlBlendState.enable_color_write_mask ? + sdlBlendState.color_write_mask : + 0xF; rtBlendDesc.BlendEnable = sdlBlendState.enable_blend; rtBlendDesc.SrcBlend = SDLToD3D12_BlendFactor[sdlBlendState.src_color_blendfactor]; @@ -2419,7 +2434,7 @@ static bool D3D12_INTERNAL_ConvertBlendState( rtBlendDesc.SrcBlendAlpha = SDLToD3D12_BlendFactorAlpha[sdlBlendState.src_alpha_blendfactor]; rtBlendDesc.DestBlendAlpha = SDLToD3D12_BlendFactorAlpha[sdlBlendState.dst_alpha_blendfactor]; rtBlendDesc.BlendOpAlpha = SDLToD3D12_BlendOp[sdlBlendState.alpha_blend_op]; - rtBlendDesc.RenderTargetWriteMask = sdlBlendState.color_write_mask; + rtBlendDesc.RenderTargetWriteMask = colorWriteMask; if (i > 0) { blendDesc->IndependentBlendEnable = TRUE; @@ -2550,7 +2565,11 @@ static SDL_GPUGraphicsPipeline *D3D12_CreateGraphicsPipeline( return NULL; } - psoDesc.SampleMask = UINT_MAX; + Uint32 sampleMask = createinfo->multisample_state.enable_mask ? + createinfo->multisample_state.sample_mask : + 0xFFFFFFFF; + + psoDesc.SampleMask = sampleMask; psoDesc.SampleDesc.Count = SDLToD3D12_SampleCount[createinfo->multisample_state.sample_count]; psoDesc.SampleDesc.Quality = 0; diff --git a/src/gpu/metal/SDL_gpu_metal.m b/src/gpu/metal/SDL_gpu_metal.m index aee3bdbb6..a71a0f007 100644 --- a/src/gpu/metal/SDL_gpu_metal.m +++ b/src/gpu/metal/SDL_gpu_metal.m @@ -68,6 +68,7 @@ static void METAL_INTERNAL_DestroyBlitResources(SDL_GPURenderer *driverData); // Conversions static MTLPixelFormat SDLToMetal_SurfaceFormat[] = { + MTLPixelFormatInvalid, // INVALID MTLPixelFormatA8Unorm, // A8_UNORM MTLPixelFormatR8Unorm, // R8_UNORM MTLPixelFormatRG8Unorm, // R8G8_UNORM @@ -151,9 +152,10 @@ static MTLPixelFormat SDLToMetal_SurfaceFormat[] = { #endif MTLPixelFormatDepth32Float_Stencil8, // D32_FLOAT_S8_UINT }; -SDL_COMPILE_TIME_ASSERT(SDLToMetal_SurfaceFormat, SDL_arraysize(SDLToMetal_SurfaceFormat) == SDL_GPU_TEXTUREFORMAT_MAX); +SDL_COMPILE_TIME_ASSERT(SDLToMetal_SurfaceFormat, SDL_arraysize(SDLToMetal_SurfaceFormat) == SDL_GPU_TEXTUREFORMAT_MAX_ENUM_VALUE); static MTLVertexFormat SDLToMetal_VertexFormat[] = { + MTLVertexFormatInvalid, // INVALID MTLVertexFormatInt, // INT MTLVertexFormatInt2, // INT2 MTLVertexFormatInt3, // INT3 @@ -185,6 +187,7 @@ static MTLVertexFormat SDLToMetal_VertexFormat[] = { MTLVertexFormatHalf2, // HALF2 MTLVertexFormatHalf4 // HALF4 }; +SDL_COMPILE_TIME_ASSERT(SDLToMetal_VertexFormat, SDL_arraysize(SDLToMetal_VertexFormat) == SDL_GPU_VERTEXELEMENTFORMAT_MAX_ENUM_VALUE); static MTLIndexType SDLToMetal_IndexType[] = { MTLIndexTypeUInt16, // 16BIT @@ -192,11 +195,11 @@ static MTLIndexType SDLToMetal_IndexType[] = { }; static MTLPrimitiveType SDLToMetal_PrimitiveType[] = { - MTLPrimitiveTypePoint, // POINTLIST - MTLPrimitiveTypeLine, // LINELIST - MTLPrimitiveTypeLineStrip, // LINESTRIP - MTLPrimitiveTypeTriangle, // TRIANGLELIST - MTLPrimitiveTypeTriangleStrip // TRIANGLESTRIP + MTLPrimitiveTypeTriangle, // TRIANGLELIST + MTLPrimitiveTypeTriangleStrip, // TRIANGLESTRIP + MTLPrimitiveTypeLine, // LINELIST + MTLPrimitiveTypeLineStrip, // LINESTRIP + MTLPrimitiveTypePoint // POINTLIST }; static MTLTriangleFillMode SDLToMetal_PolygonMode[] = { @@ -216,6 +219,7 @@ static MTLWinding SDLToMetal_FrontFace[] = { }; static MTLBlendFactor SDLToMetal_BlendFactor[] = { + MTLBlendFactorZero, // INVALID MTLBlendFactorZero, // ZERO MTLBlendFactorOne, // ONE MTLBlendFactorSourceColor, // SRC_COLOR @@ -230,16 +234,20 @@ static MTLBlendFactor SDLToMetal_BlendFactor[] = { MTLBlendFactorOneMinusBlendColor, // ONE_MINUS_CONSTANT_COLOR MTLBlendFactorSourceAlphaSaturated, // SRC_ALPHA_SATURATE }; +SDL_COMPILE_TIME_ASSERT(SDLToMetal_BlendFactor, SDL_arraysize(SDLToMetal_BlendFactor) == SDL_GPU_BLENDFACTOR_MAX_ENUM_VALUE); static MTLBlendOperation SDLToMetal_BlendOp[] = { + MTLBlendOperationAdd, // INVALID MTLBlendOperationAdd, // ADD MTLBlendOperationSubtract, // SUBTRACT MTLBlendOperationReverseSubtract, // REVERSE_SUBTRACT MTLBlendOperationMin, // MIN MTLBlendOperationMax, // MAX }; +SDL_COMPILE_TIME_ASSERT(SDLToMetal_BlendOp, SDL_arraysize(SDLToMetal_BlendOp) == SDL_GPU_BLENDOP_MAX_ENUM_VALUE); static MTLCompareFunction SDLToMetal_CompareOp[] = { + MTLCompareFunctionNever, // INVALID MTLCompareFunctionNever, // NEVER MTLCompareFunctionLess, // LESS MTLCompareFunctionEqual, // EQUAL @@ -249,8 +257,10 @@ static MTLCompareFunction SDLToMetal_CompareOp[] = { MTLCompareFunctionGreaterEqual, // GREATER_OR_EQUAL MTLCompareFunctionAlways, // ALWAYS }; +SDL_COMPILE_TIME_ASSERT(SDLToMetal_CompareOp, SDL_arraysize(SDLToMetal_CompareOp) == SDL_GPU_COMPAREOP_MAX_ENUM_VALUE); static MTLStencilOperation SDLToMetal_StencilOp[] = { + MTLStencilOperationKeep, // INVALID MTLStencilOperationKeep, // KEEP MTLStencilOperationZero, // ZERO MTLStencilOperationReplace, // REPLACE @@ -260,6 +270,7 @@ static MTLStencilOperation SDLToMetal_StencilOp[] = { MTLStencilOperationIncrementWrap, // INCREMENT_AND_WRAP MTLStencilOperationDecrementWrap, // DECREMENT_AND_WRAP }; +SDL_COMPILE_TIME_ASSERT(SDLToMetal_StencilOp, SDL_arraysize(SDLToMetal_StencilOp) == SDL_GPU_STENCILOP_MAX_ENUM_VALUE); static MTLSamplerAddressMode SDLToMetal_SamplerAddressMode[] = { MTLSamplerAddressModeRepeat, // REPEAT @@ -1012,9 +1023,12 @@ static SDL_GPUGraphicsPipeline *METAL_CreateGraphicsPipeline( for (Uint32 i = 0; i < createinfo->target_info.num_color_targets; i += 1) { blendState = &createinfo->target_info.color_target_descriptions[i].blend_state; + SDL_GPUColorComponentFlags colorWriteMask = blendState->enable_color_write_mask ? + blendState->color_write_mask : + 0xF; pipelineDescriptor.colorAttachments[i].pixelFormat = SDLToMetal_SurfaceFormat[createinfo->target_info.color_target_descriptions[i].format]; - pipelineDescriptor.colorAttachments[i].writeMask = SDLToMetal_ColorWriteMask(blendState->color_write_mask); + pipelineDescriptor.colorAttachments[i].writeMask = SDLToMetal_ColorWriteMask(colorWriteMask); pipelineDescriptor.colorAttachments[i].blendingEnabled = blendState->enable_blend; pipelineDescriptor.colorAttachments[i].rgbBlendOperation = SDLToMetal_BlendOp[blendState->color_blend_op]; pipelineDescriptor.colorAttachments[i].alphaBlendOperation = SDLToMetal_BlendOp[blendState->alpha_blend_op]; @@ -1099,9 +1113,13 @@ static SDL_GPUGraphicsPipeline *METAL_CreateGraphicsPipeline( return NULL; } + Uint32 sampleMask = createinfo->multisample_state.enable_mask ? + createinfo->multisample_state.sample_mask : + 0xFFFFFFFF; + result = SDL_calloc(1, sizeof(MetalGraphicsPipeline)); result->handle = pipelineState; - result->sample_mask = createinfo->multisample_state.sample_mask; + result->sample_mask = sampleMask; result->depth_stencil_state = depthStencilState; result->rasterizerState = createinfo->rasterizer_state; result->primitiveType = createinfo->primitive_type; diff --git a/src/gpu/vulkan/SDL_gpu_vulkan.c b/src/gpu/vulkan/SDL_gpu_vulkan.c index 3c31422d4..976287ce4 100644 --- a/src/gpu/vulkan/SDL_gpu_vulkan.c +++ b/src/gpu/vulkan/SDL_gpu_vulkan.c @@ -136,6 +136,7 @@ static VkPresentModeKHR SDLToVK_PresentMode[] = { }; static VkFormat SDLToVK_SurfaceFormat[] = { + VK_FORMAT_UNDEFINED, // INVALID VK_FORMAT_R8_UNORM, // A8_UNORM VK_FORMAT_R8_UNORM, // R8_UNORM VK_FORMAT_R8G8_UNORM, // R8G8_UNORM @@ -193,9 +194,10 @@ static VkFormat SDLToVK_SurfaceFormat[] = { VK_FORMAT_D24_UNORM_S8_UINT, // D24_UNORM_S8_UINT VK_FORMAT_D32_SFLOAT_S8_UINT, // D32_FLOAT_S8_UINT }; -SDL_COMPILE_TIME_ASSERT(SDLToVK_SurfaceFormat, SDL_arraysize(SDLToVK_SurfaceFormat) == SDL_GPU_TEXTUREFORMAT_MAX); +SDL_COMPILE_TIME_ASSERT(SDLToVK_SurfaceFormat, SDL_arraysize(SDLToVK_SurfaceFormat) == SDL_GPU_TEXTUREFORMAT_MAX_ENUM_VALUE); static VkComponentMapping SDLToVK_SurfaceSwizzle[] = { + IDENTITY_SWIZZLE, { // A8 VK_COMPONENT_SWIZZLE_ZERO, @@ -283,6 +285,7 @@ static VkComponentMapping SDLToVK_SurfaceSwizzle[] = { IDENTITY_SWIZZLE, // D24_UNORM_S8_UINT IDENTITY_SWIZZLE, // D32_SFLOAT_S8_UINT }; +SDL_COMPILE_TIME_ASSERT(SDLToVK_SurfaceSwizzle, SDL_arraysize(SDLToVK_SurfaceSwizzle) == SDL_GPU_TEXTUREFORMAT_MAX_ENUM_VALUE); static VkFormat SwapchainCompositionToFormat[] = { VK_FORMAT_B8G8R8A8_UNORM, // SDR @@ -337,6 +340,7 @@ static VkComponentMapping SwapchainCompositionSwizzle[] = { }; static VkFormat SDLToVK_VertexFormat[] = { + VK_FORMAT_UNDEFINED, // INVALID VK_FORMAT_R32_SINT, // INT VK_FORMAT_R32G32_SINT, // INT2 VK_FORMAT_R32G32B32_SINT, // INT3 @@ -368,6 +372,7 @@ static VkFormat SDLToVK_VertexFormat[] = { VK_FORMAT_R16G16_SFLOAT, // HALF2 VK_FORMAT_R16G16B16A16_SFLOAT // HALF4 }; +SDL_COMPILE_TIME_ASSERT(SDLToVK_VertexFormat, SDL_arraysize(SDLToVK_VertexFormat) == SDL_GPU_VERTEXELEMENTFORMAT_MAX_ENUM_VALUE); static VkIndexType SDLToVK_IndexType[] = { VK_INDEX_TYPE_UINT16, @@ -375,11 +380,11 @@ static VkIndexType SDLToVK_IndexType[] = { }; static VkPrimitiveTopology SDLToVK_PrimitiveType[] = { - VK_PRIMITIVE_TOPOLOGY_POINT_LIST, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP + VK_PRIMITIVE_TOPOLOGY_POINT_LIST }; static VkCullModeFlags SDLToVK_CullMode[] = { @@ -395,6 +400,7 @@ static VkFrontFace SDLToVK_FrontFace[] = { }; static VkBlendFactor SDLToVK_BlendFactor[] = { + VK_BLEND_FACTOR_ZERO, // INVALID VK_BLEND_FACTOR_ZERO, VK_BLEND_FACTOR_ONE, VK_BLEND_FACTOR_SRC_COLOR, @@ -407,20 +413,22 @@ static VkBlendFactor SDLToVK_BlendFactor[] = { VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, VK_BLEND_FACTOR_CONSTANT_COLOR, VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, - VK_BLEND_FACTOR_CONSTANT_ALPHA, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, VK_BLEND_FACTOR_SRC_ALPHA_SATURATE }; +SDL_COMPILE_TIME_ASSERT(SDLToVK_BlendFactor, SDL_arraysize(SDLToVK_BlendFactor) == SDL_GPU_BLENDFACTOR_MAX_ENUM_VALUE); static VkBlendOp SDLToVK_BlendOp[] = { + VK_BLEND_OP_ADD, // INVALID VK_BLEND_OP_ADD, VK_BLEND_OP_SUBTRACT, VK_BLEND_OP_REVERSE_SUBTRACT, VK_BLEND_OP_MIN, VK_BLEND_OP_MAX }; +SDL_COMPILE_TIME_ASSERT(SDLToVK_BlendOp, SDL_arraysize(SDLToVK_BlendOp) == SDL_GPU_BLENDOP_MAX_ENUM_VALUE); static VkCompareOp SDLToVK_CompareOp[] = { + VK_COMPARE_OP_NEVER, // INVALID VK_COMPARE_OP_NEVER, VK_COMPARE_OP_LESS, VK_COMPARE_OP_EQUAL, @@ -430,8 +438,10 @@ static VkCompareOp SDLToVK_CompareOp[] = { VK_COMPARE_OP_GREATER_OR_EQUAL, VK_COMPARE_OP_ALWAYS }; +SDL_COMPILE_TIME_ASSERT(SDLToVK_CompareOp, SDL_arraysize(SDLToVK_CompareOp) == SDL_GPU_COMPAREOP_MAX_ENUM_VALUE); static VkStencilOp SDLToVK_StencilOp[] = { + VK_STENCIL_OP_KEEP, // INVALID VK_STENCIL_OP_KEEP, VK_STENCIL_OP_ZERO, VK_STENCIL_OP_REPLACE, @@ -441,6 +451,7 @@ static VkStencilOp SDLToVK_StencilOp[] = { VK_STENCIL_OP_INCREMENT_AND_WRAP, VK_STENCIL_OP_DECREMENT_AND_WRAP }; +SDL_COMPILE_TIME_ASSERT(SDLToVK_StencilOp, SDL_arraysize(SDLToVK_StencilOp) == SDL_GPU_STENCILOP_MAX_ENUM_VALUE); static VkAttachmentLoadOp SDLToVK_LoadOp[] = { VK_ATTACHMENT_LOAD_OP_LOAD, @@ -6573,6 +6584,10 @@ static SDL_GPUGraphicsPipeline *VULKAN_CreateGraphicsPipeline( // Multisample + Uint32 sampleMask = createinfo->multisample_state.enable_mask ? + createinfo->multisample_state.sample_mask : + 0xFFFFFFFF; + multisampleStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; multisampleStateCreateInfo.pNext = NULL; multisampleStateCreateInfo.flags = 0; @@ -6580,7 +6595,7 @@ static SDL_GPUGraphicsPipeline *VULKAN_CreateGraphicsPipeline( multisampleStateCreateInfo.sampleShadingEnable = VK_FALSE; multisampleStateCreateInfo.minSampleShading = 1.0f; multisampleStateCreateInfo.pSampleMask = - &createinfo->multisample_state.sample_mask; + &sampleMask; multisampleStateCreateInfo.alphaToCoverageEnable = VK_FALSE; multisampleStateCreateInfo.alphaToOneEnable = VK_FALSE; @@ -6626,6 +6641,9 @@ static SDL_GPUGraphicsPipeline *VULKAN_CreateGraphicsPipeline( for (i = 0; i < createinfo->target_info.num_color_targets; i += 1) { SDL_GPUColorTargetBlendState blendState = createinfo->target_info.color_target_descriptions[i].blend_state; + SDL_GPUColorComponentFlags colorWriteMask = blendState.enable_color_write_mask ? + blendState.color_write_mask : + 0xF; colorBlendAttachmentStates[i].blendEnable = blendState.enable_blend; @@ -6636,7 +6654,7 @@ static SDL_GPUGraphicsPipeline *VULKAN_CreateGraphicsPipeline( colorBlendAttachmentStates[i].dstAlphaBlendFactor = SDLToVK_BlendFactor[blendState.dst_alpha_blendfactor]; colorBlendAttachmentStates[i].alphaBlendOp = SDLToVK_BlendOp[blendState.alpha_blend_op]; colorBlendAttachmentStates[i].colorWriteMask = - blendState.color_write_mask; + colorWriteMask; } colorBlendStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; diff --git a/src/render/sdlgpu/SDL_pipeline_gpu.c b/src/render/sdlgpu/SDL_pipeline_gpu.c index b15bb1cd0..a5448cc0b 100644 --- a/src/render/sdlgpu/SDL_pipeline_gpu.c +++ b/src/render/sdlgpu/SDL_pipeline_gpu.c @@ -119,7 +119,7 @@ static SDL_GPUGraphicsPipeline *MakePipeline(SDL_GPUDevice *device, GPU_Shaders pci.vertex_shader = GPU_GetVertexShader(shaders, params->vert_shader); pci.fragment_shader = GPU_GetFragmentShader(shaders, params->frag_shader); pci.multisample_state.sample_count = SDL_GPU_SAMPLECOUNT_1; - pci.multisample_state.sample_mask = 0xFFFF; + pci.multisample_state.enable_mask = SDL_FALSE; pci.primitive_type = params->primitive_type; pci.rasterizer_state.cull_mode = SDL_GPU_CULLMODE_NONE; diff --git a/test/testgpu_spinning_cube.c b/test/testgpu_spinning_cube.c index 653cadc60..f8dcf9ba3 100644 --- a/test/testgpu_spinning_cube.c +++ b/test/testgpu_spinning_cube.c @@ -545,18 +545,10 @@ init_render_state(int msaa) /* Set up the graphics pipeline */ SDL_zero(pipelinedesc); + SDL_zero(color_target_desc); color_target_desc.format = SDL_GetGPUSwapchainTextureFormat(gpu_device, state->windows[0]); - color_target_desc.blend_state.enable_blend = 0; - color_target_desc.blend_state.alpha_blend_op = SDL_GPU_BLENDOP_ADD; - color_target_desc.blend_state.color_blend_op = SDL_GPU_BLENDOP_ADD; - color_target_desc.blend_state.color_write_mask = 0xF; - color_target_desc.blend_state.src_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE; - color_target_desc.blend_state.dst_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ZERO; - color_target_desc.blend_state.src_color_blendfactor = SDL_GPU_BLENDFACTOR_ONE; - color_target_desc.blend_state.dst_color_blendfactor = SDL_GPU_BLENDFACTOR_ZERO; - pipelinedesc.target_info.num_color_targets = 1; pipelinedesc.target_info.color_target_descriptions = &color_target_desc; pipelinedesc.target_info.depth_stencil_format = SDL_GPU_TEXTUREFORMAT_D16_UNORM; @@ -567,7 +559,6 @@ init_render_state(int msaa) pipelinedesc.depth_stencil_state.compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL; pipelinedesc.multisample_state.sample_count = render_state.sample_count; - pipelinedesc.multisample_state.sample_mask = 0xF; pipelinedesc.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;