mirror of
https://github.com/libsdl-org/SDL.git
synced 2025-05-27 15:09:11 +00:00
GPU: Zero-init handling (#10786)
This commit is contained in:
parent
b8dbc7086d
commit
0b6f993dea
9 changed files with 310 additions and 88 deletions
|
@ -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;
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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_TRIANGLELIST, // TRIANGLELIST
|
||||
D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, // TRIANGLESTRIP
|
||||
D3D_PRIMITIVE_TOPOLOGY_LINELIST, // LINELIST
|
||||
D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, // LINESTRIP
|
||||
D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, // TRIANGLELIST
|
||||
D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP // TRIANGLESTRIP
|
||||
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;
|
||||
|
||||
|
|
|
@ -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_TRIANGLELIST, // TRIANGLELIST
|
||||
D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP, // TRIANGLESTRIP
|
||||
D3D_PRIMITIVE_TOPOLOGY_LINELIST, // LINELIST
|
||||
D3D_PRIMITIVE_TOPOLOGY_LINESTRIP, // LINESTRIP
|
||||
D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST, // TRIANGLELIST
|
||||
D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP // TRIANGLESTRIP
|
||||
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;
|
||||
|
||||
|
|
|
@ -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
|
||||
MTLPrimitiveTypeTriangle, // TRIANGLELIST
|
||||
MTLPrimitiveTypeTriangleStrip, // TRIANGLESTRIP
|
||||
MTLPrimitiveTypeLine, // LINELIST
|
||||
MTLPrimitiveTypeLineStrip, // LINESTRIP
|
||||
MTLPrimitiveTypeTriangle, // TRIANGLELIST
|
||||
MTLPrimitiveTypeTriangleStrip // TRIANGLESTRIP
|
||||
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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue