diff --git a/include/SDL3/SDL_gpu.h b/include/SDL3/SDL_gpu.h index 21bdce416d..8937fc2cd7 100644 --- a/include/SDL3/SDL_gpu.h +++ b/include/SDL3/SDL_gpu.h @@ -198,18 +198,15 @@ typedef enum SDL_GPUTextureFormat SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT } SDL_GPUTextureFormat; -typedef enum SDL_GPUTextureUsageFlagBits -{ - SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT = 0x00000001, - SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT = 0x00000002, - SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT = 0x00000004, - SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT = 0x00000008, - SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT = 0x00000020, - SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT = 0x00000040 -} SDL_GPUTextureUsageFlagBits; - typedef Uint32 SDL_GPUTextureUsageFlags; +#define SDL_GPU_TEXTUREUSAGE_SAMPLER (1u << 0) /**< & if the texture supports sampling */ +#define SDL_GPU_TEXTUREUSAGE_COLOR_TARGET (1u << 1) /**< & if the texture is a color render target */ +#define SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET (1u << 2) /**< & if the texture is a depth stencil target */ +#define SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ (1u << 3) /**< & if the texture supports storage reads in graphics stages */ +#define SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ (1u << 4) /**< & if the texture supports storage reads in the compute stage */ +#define SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE (1u << 5) /**< & if the texture supports storage writes in the compute stage */ + typedef enum SDL_GPUTextureType { SDL_GPU_TEXTURETYPE_2D, @@ -236,18 +233,15 @@ typedef enum SDL_GPUCubeMapFace SDL_GPU_CUBEMAPFACE_NEGATIVEZ } SDL_GPUCubeMapFace; -typedef enum SDL_GPUBufferUsageFlagBits -{ - SDL_GPU_BUFFERUSAGE_VERTEX_BIT = 0x00000001, - SDL_GPU_BUFFERUSAGE_INDEX_BIT = 0x00000002, - SDL_GPU_BUFFERUSAGE_INDIRECT_BIT = 0x00000004, - SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT = 0x00000008, - SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT = 0x00000020, - SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT = 0x00000040 -} SDL_GPUBufferUsageFlagBits; - typedef Uint32 SDL_GPUBufferUsageFlags; +#define SDL_GPU_BUFFERUSAGE_VERTEX (1u << 0) /**< & if the buffer is a vertex buffer */ +#define SDL_GPU_BUFFERUSAGE_INDEX (1u << 1) /**< & if the buffer is an index buffer */ +#define SDL_GPU_BUFFERUSAGE_INDIRECT (1u << 2) /**< & if the buffer is an indirect buffer */ +#define SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ (1u << 3) /**< & if the buffer supports storage reads in graphics stages */ +#define SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ (1u << 4) /**< & if the buffer supports storage reads in the compute stage */ +#define SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE (1u << 5) /**< & if the buffer supports storage writes in the compute stage */ + typedef enum SDL_GPUTransferBufferUsage { SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD, @@ -260,19 +254,15 @@ typedef enum SDL_GPUShaderStage SDL_GPU_SHADERSTAGE_FRAGMENT } SDL_GPUShaderStage; -typedef enum SDL_GPUShaderFormatFlagBits -{ - SDL_GPU_SHADERFORMAT_INVALID = 0x00000000, - SDL_GPU_SHADERFORMAT_SECRET = 0x00000001, /* NDA'd platforms */ - SDL_GPU_SHADERFORMAT_SPIRV = 0x00000002, /* Vulkan */ - SDL_GPU_SHADERFORMAT_DXBC = 0x00000004, /* D3D11 (Shader Model 5_0) */ - SDL_GPU_SHADERFORMAT_DXIL = 0x00000008, /* D3D12 */ - SDL_GPU_SHADERFORMAT_MSL = 0x00000010, /* Metal */ - SDL_GPU_SHADERFORMAT_METALLIB = 0x00000020 /* Metal */ -} SDL_GPUShaderFormatFlagBits; - typedef Uint32 SDL_GPUShaderFormat; +#define SDL_GPU_SHADERFORMAT_SECRET (1u << 0) /**< & if you are providing shaders for NDA'd platforms */ +#define SDL_GPU_SHADERFORMAT_SPIRV (1u << 1) /**< & if you are providing SPIR-V shaders for Vulkan */ +#define SDL_GPU_SHADERFORMAT_DXBC (1u << 2) /**< & if you are providing DXBC SM5_0 shaders for D3D11 */ +#define SDL_GPU_SHADERFORMAT_DXIL (1u << 3) /**< & if you are providing DXIL shaders for D3D12 */ +#define SDL_GPU_SHADERFORMAT_MSL (1u << 4) /**< & if you are providing MSL shaders for Metal */ +#define SDL_GPU_SHADERFORMAT_METALLIB (1u << 5) /**< & if you are providing precompiled metallib shaders for Metal */ + typedef enum SDL_GPUVertexElementFormat { /* 32-bit Signed Integers */ @@ -405,16 +395,13 @@ typedef enum SDL_GPUBlendFactor SDL_GPU_BLENDFACTOR_SRC_ALPHA_SATURATE } SDL_GPUBlendFactor; -typedef enum SDL_GPUColorComponentFlagBits -{ - SDL_GPU_COLORCOMPONENT_R_BIT = 0x00000001, - SDL_GPU_COLORCOMPONENT_G_BIT = 0x00000002, - SDL_GPU_COLORCOMPONENT_B_BIT = 0x00000004, - SDL_GPU_COLORCOMPONENT_A_BIT = 0x00000008 -} SDL_GPUColorComponentFlagBits; - typedef Uint8 SDL_GPUColorComponentFlags; +#define SDL_GPU_COLORCOMPONENT_R (1u << 0) /**< & for the Red component */ +#define SDL_GPU_COLORCOMPONENT_G (1u << 1) /**< & for the Green component */ +#define SDL_GPU_COLORCOMPONENT_B (1u << 2) /**< & for the Blue component */ +#define SDL_GPU_COLORCOMPONENT_A (1u << 3) /**< & for the Alpha component */ + typedef enum SDL_GPUFilter { SDL_GPU_FILTER_NEAREST, @@ -1670,7 +1657,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_BindGPUIndexBuffer( /** * Binds texture-sampler pairs for use on the vertex shader. * - * The textures must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT. + * The textures must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER. * * \param renderPass a render pass handle. * \param firstSlot the vertex sampler slot to begin binding from. @@ -1690,7 +1677,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_BindGPUVertexSamplers( * Binds storage textures for use on the vertex shader. * * These textures must have been created with - * SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT. + * SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ. * * \param renderPass a render pass handle. * \param firstSlot the vertex storage texture slot to begin binding from. @@ -1709,7 +1696,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_BindGPUVertexStorageTextures( * Binds storage buffers for use on the vertex shader. * * These buffers must have been created with - * SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT. + * SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ. * * \param renderPass a render pass handle. * \param firstSlot the vertex storage buffer slot to begin binding from. @@ -1727,7 +1714,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_BindGPUVertexStorageBuffers( /** * Binds texture-sampler pairs for use on the fragment shader. * - * The textures must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT. + * The textures must have been created with SDL_GPU_TEXTUREUSAGE_SAMPLER. * * \param renderPass a render pass handle. * \param firstSlot the fragment sampler slot to begin binding from. @@ -1747,7 +1734,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_BindGPUFragmentSamplers( * Binds storage textures for use on the fragment shader. * * These textures must have been created with - * SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT. + * SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ. * * \param renderPass a render pass handle. * \param firstSlot the fragment storage texture slot to begin binding from. @@ -1766,7 +1753,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_BindGPUFragmentStorageTextures( * Binds storage buffers for use on the fragment shader. * * These buffers must have been created with - * SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT. + * SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ. * * \param renderPass a render pass handle. * \param firstSlot the fragment storage buffer slot to begin binding from. @@ -1953,7 +1940,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_BindGPUComputePipeline( * Binds storage textures as readonly for use on the compute pipeline. * * These textures must have been created with - * SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT. + * SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ. * * \param computePass a compute pass handle. * \param firstSlot the compute storage texture slot to begin binding from. @@ -1972,7 +1959,7 @@ extern SDL_DECLSPEC void SDLCALL SDL_BindGPUComputeStorageTextures( * Binds storage buffers as readonly for use on the compute pipeline. * * These buffers must have been created with - * SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT. + * SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ. * * \param computePass a compute pass handle. * \param firstSlot the compute storage buffer slot to begin binding from. diff --git a/src/gpu/SDL_gpu.c b/src/gpu/SDL_gpu.c index 183efb37c4..811216ff08 100644 --- a/src/gpu/SDL_gpu.c +++ b/src/gpu/SDL_gpu.c @@ -718,16 +718,16 @@ SDL_GPUTexture *SDL_CreateGPUTexture( SDL_assert_release(!"For any texture: levelCount must be >= 1"); failed = true; } - if ((textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT) && (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT)) { - SDL_assert_release(!"For any texture: usageFlags cannot contain both GRAPHICS_STORAGE_READ_BIT and SAMPLER_BIT"); + if ((textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ) && (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER)) { + SDL_assert_release(!"For any texture: usageFlags cannot contain both GRAPHICS_STORAGE_READ and SAMPLER"); failed = true; } - if (IsDepthFormat(textureCreateInfo->format) && (textureCreateInfo->usageFlags & ~(SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT | SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT))) { - SDL_assert_release(!"For depth textures: usageFlags cannot contain any flags except for DEPTH_STENCIL_TARGET_BIT and SAMPLER_BIT"); + if (IsDepthFormat(textureCreateInfo->format) && (textureCreateInfo->usageFlags & ~(SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER))) { + SDL_assert_release(!"For depth textures: usageFlags cannot contain any flags except for DEPTH_STENCIL_TARGET and SAMPLER"); failed = true; } - if (IsIntegerFormat(textureCreateInfo->format) && (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT)) { - SDL_assert_release(!"For any texture: usageFlags cannot contain SAMPLER_BIT for textures with an integer format"); + if (IsIntegerFormat(textureCreateInfo->format) && (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER)) { + SDL_assert_release(!"For any texture: usageFlags cannot contain SAMPLER for textures with an integer format"); failed = true; } @@ -759,8 +759,8 @@ SDL_GPUTexture *SDL_CreateGPUTexture( SDL_assert_release(!"For 3D textures: width, height, and layerCountOrDepth must be <= 2048"); failed = true; } - if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { - SDL_assert_release(!"For 3D textures: usageFlags must not contain DEPTH_STENCIL_TARGET_BIT"); + if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) { + SDL_assert_release(!"For 3D textures: usageFlags must not contain DEPTH_STENCIL_TARGET"); failed = true; } if (textureCreateInfo->sampleCount > SDL_GPU_SAMPLECOUNT_1) { @@ -774,8 +774,8 @@ SDL_GPUTexture *SDL_CreateGPUTexture( } else { if (textureCreateInfo->type == SDL_GPU_TEXTURETYPE_2D_ARRAY) { // Array Texture Validation - if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { - SDL_assert_release(!"For array textures: usageFlags must not contain DEPTH_STENCIL_TARGET_BIT"); + if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) { + SDL_assert_release(!"For array textures: usageFlags must not contain DEPTH_STENCIL_TARGET"); failed = true; } if (textureCreateInfo->sampleCount > SDL_GPU_SAMPLECOUNT_1) { @@ -2063,8 +2063,8 @@ void SDL_GenerateMipmapsForGPUTexture( return; } - if (!(header->info.usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) || !(header->info.usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT)) { - SDL_assert_release(!"GenerateMipmaps texture must be created with SAMPLER_BIT and COLOR_TARGET_BIT usage flags!"); + if (!(header->info.usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) || !(header->info.usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET)) { + SDL_assert_release(!"GenerateMipmaps texture must be created with SAMPLER and COLOR_TARGET usage flags!"); return; } } @@ -2108,12 +2108,12 @@ void SDL_BlitGPUTexture( SDL_assert_release(!"Blit source and destination textures must be non-NULL"); return; // attempting to proceed will crash } - if ((srcHeader->info.usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) == 0) { - SDL_assert_release(!"Blit source texture must be created with the SAMPLER_BIT usage flag"); + if ((srcHeader->info.usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) == 0) { + SDL_assert_release(!"Blit source texture must be created with the SAMPLER usage flag"); failed = true; } - if ((dstHeader->info.usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) == 0) { - SDL_assert_release(!"Blit destination texture must be created with the COLOR_TARGET_BIT usage flag"); + if ((dstHeader->info.usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) == 0) { + SDL_assert_release(!"Blit destination texture must be created with the COLOR_TARGET usage flag"); failed = true; } if (IsDepthFormat(srcHeader->info.format)) { diff --git a/src/gpu/d3d11/SDL_gpu_d3d11.c b/src/gpu/d3d11/SDL_gpu_d3d11.c index 6011699eb4..c231005981 100644 --- a/src/gpu/d3d11/SDL_gpu_d3d11.c +++ b/src/gpu/d3d11/SDL_gpu_d3d11.c @@ -1848,20 +1848,20 @@ static D3D11Texture *D3D11_INTERNAL_CreateTexture( D3D11Texture *d3d11Texture; HRESULT res; - isColorTarget = createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT; - isDepthStencil = createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT; + isColorTarget = createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; + isDepthStencil = createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET; needsSRV = - (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) || - (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT) || - (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT); + (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) || + (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ) || + (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ); needSubresourceUAV = - (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT); + (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE); isMultisample = createInfo->sampleCount > SDL_GPU_SAMPLECOUNT_1; isStaging = createInfo->usageFlags == 0; isMippable = createInfo->levelCount > 1 && - (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) && - (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT); + (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) && + (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET); format = SDLToD3D11_TextureFormat[createInfo->format]; if (isDepthStencil) { format = D3D11_INTERNAL_GetTypelessFormat(format); @@ -2370,19 +2370,19 @@ static SDL_GPUBuffer *D3D11_CreateBuffer( D3D11_BUFFER_DESC bufferDesc; bufferDesc.BindFlags = 0; - if (usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX_BIT) { + if (usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX) { bufferDesc.BindFlags |= D3D11_BIND_VERTEX_BUFFER; } - if (usageFlags & SDL_GPU_BUFFERUSAGE_INDEX_BIT) { + if (usageFlags & SDL_GPU_BUFFERUSAGE_INDEX) { bufferDesc.BindFlags |= D3D11_BIND_INDEX_BUFFER; } - if (usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT_BIT) { + if (usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT) { bufferDesc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS; } - if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT | - SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT | - SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { + if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ | + SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ | + SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE)) { bufferDesc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE; } @@ -2392,12 +2392,12 @@ static SDL_GPUBuffer *D3D11_CreateBuffer( bufferDesc.StructureByteStride = 0; bufferDesc.MiscFlags = 0; - if (usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT_BIT) { + if (usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT) { bufferDesc.MiscFlags |= D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS; } - if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT | - SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT | - SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { + if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ | + SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ | + SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE)) { bufferDesc.MiscFlags |= D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; } @@ -4151,7 +4151,7 @@ static void D3D11_BeginComputePass( for (i = 0; i < storageTextureBindingCount; i += 1) { textureContainer = (D3D11TextureContainer *)storageTextureBindings[i].texture; - if (!(textureContainer->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { + if (!(textureContainer->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE)) { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Attempted to bind read-only texture as compute write texture"); } @@ -4977,7 +4977,7 @@ static bool D3D11_INTERNAL_CreateSwapchain( windowData->textureContainer.header.info.type = SDL_GPU_TEXTURETYPE_2D; windowData->textureContainer.header.info.levelCount = 1; windowData->textureContainer.header.info.sampleCount = SDL_GPU_SAMPLECOUNT_1; - windowData->textureContainer.header.info.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT; + windowData->textureContainer.header.info.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; windowData->texture.container = &windowData->textureContainer; windowData->texture.containerIndex = 0; @@ -5547,20 +5547,20 @@ static bool D3D11_SupportsTextureFormat( } // Are the usage flags supported? - if ((usage & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) && !(formatSupport & D3D11_FORMAT_SUPPORT_SHADER_SAMPLE)) { + if ((usage & SDL_GPU_TEXTUREUSAGE_SAMPLER) && !(formatSupport & D3D11_FORMAT_SUPPORT_SHADER_SAMPLE)) { return false; } - if ((usage & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT | SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT)) && !(formatSupport & D3D11_FORMAT_SUPPORT_SHADER_LOAD)) { + if ((usage & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ | SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ)) && !(formatSupport & D3D11_FORMAT_SUPPORT_SHADER_LOAD)) { return false; } - if ((usage & (SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT) && !(formatSupport & D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW))) { + if ((usage & (SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE) && !(formatSupport & D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW))) { // TYPED_UNORDERED_ACCESS_VIEW implies support for typed UAV stores return false; } - if ((usage & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) && !(formatSupport & D3D11_FORMAT_SUPPORT_RENDER_TARGET)) { + if ((usage & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) && !(formatSupport & D3D11_FORMAT_SUPPORT_RENDER_TARGET)) { return false; } - if ((usage & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) && !(formatSupport & D3D11_FORMAT_SUPPORT_DEPTH_STENCIL)) { + if ((usage & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) && !(formatSupport & D3D11_FORMAT_SUPPORT_DEPTH_STENCIL)) { return false; } diff --git a/src/gpu/d3d12/SDL_gpu_d3d12.c b/src/gpu/d3d12/SDL_gpu_d3d12.c index 94ca373e70..2c19b365ae 100644 --- a/src/gpu/d3d12/SDL_gpu_d3d12.c +++ b/src/gpu/d3d12/SDL_gpu_d3d12.c @@ -1459,7 +1459,7 @@ static void D3D12_INTERNAL_TextureSubresourceBarrier( destinationState, textureSubresource->parent->resource, textureSubresource->index, - textureSubresource->parent->container->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT); + textureSubresource->parent->container->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE); } static D3D12_RESOURCE_STATES D3D12_INTERNAL_DefaultTextureResourceState( @@ -1467,17 +1467,17 @@ static D3D12_RESOURCE_STATES D3D12_INTERNAL_DefaultTextureResourceState( { // NOTE: order matters here! - if (usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) { + if (usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) { return D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE; - } else if (usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT) { + } else if (usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ) { return D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE; - } else if (usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) { + } else if (usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) { return D3D12_RESOURCE_STATE_RENDER_TARGET; - } else if (usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { + } else if (usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) { return D3D12_RESOURCE_STATE_DEPTH_WRITE; - } else if (usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT) { + } else if (usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ) { return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; - } else if (usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT) { + } else if (usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE) { return D3D12_RESOURCE_STATE_UNORDERED_ACCESS; } else { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Texture has no default usage mode!"); @@ -1538,17 +1538,17 @@ static void D3D12_INTERNAL_TextureTransitionToDefaultUsage( static D3D12_RESOURCE_STATES D3D12_INTERNAL_DefaultBufferResourceState( D3D12Buffer *buffer) { - if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX_BIT) { + if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX) { return D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER; - } else if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_INDEX_BIT) { + } else if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_INDEX) { return D3D12_RESOURCE_STATE_INDEX_BUFFER; - } else if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT_BIT) { + } else if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT) { return D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT; - } else if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT) { + } else if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ) { return D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE; - } else if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT) { + } else if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ) { return D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE; - } else if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT) { + } else if (buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE) { return D3D12_RESOURCE_STATE_UNORDERED_ACCESS; } else { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Buffer has no default usage mode!"); @@ -1568,7 +1568,7 @@ static void D3D12_INTERNAL_BufferBarrier( destinationState, buffer->handle, 0, - buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT); + buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE); buffer->transitioned = true; } @@ -2693,7 +2693,7 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture( Uint32 layerCount = textureCreateInfo->type == SDL_GPU_TEXTURETYPE_3D ? 1 : textureCreateInfo->layerCountOrDepth; Uint32 depth = textureCreateInfo->type == SDL_GPU_TEXTURETYPE_3D ? textureCreateInfo->layerCountOrDepth : 1; - if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) { + if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) { resourceFlags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; useClearValue = true; clearValue.Color[0] = SDL_GetFloatProperty(textureCreateInfo->props, SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_R_FLOAT, 0); @@ -2702,14 +2702,14 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture( clearValue.Color[3] = SDL_GetFloatProperty(textureCreateInfo->props, SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_A_FLOAT, 0); } - if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { + if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) { resourceFlags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; useClearValue = true; clearValue.DepthStencil.Depth = SDL_GetFloatProperty(textureCreateInfo->props, SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_DEPTH_FLOAT, 0); clearValue.DepthStencil.Stencil = (UINT8)SDL_GetNumberProperty(textureCreateInfo->props, SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_STENCIL_UINT8, 0); } - if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT) { + if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE) { resourceFlags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; } @@ -2768,9 +2768,9 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture( texture->resource = handle; // Create the SRV if applicable - if ((textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) || - (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT) || - (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT)) { + if ((textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) || + (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ) || + (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ)) { D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc; D3D12_INTERNAL_AssignCpuDescriptorHandle( @@ -2841,7 +2841,7 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture( texture->subresources[subresourceIndex].dsvHandle.heap = NULL; // Create RTV if needed - if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) { + if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) { texture->subresources[subresourceIndex].rtvHandles = (D3D12CPUDescriptor *)SDL_calloc(depth, sizeof(D3D12CPUDescriptor)); for (Uint32 depthIndex = 0; depthIndex < depth; depthIndex += 1) { @@ -2880,7 +2880,7 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture( } // Create DSV if needed - if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { + if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) { D3D12_DEPTH_STENCIL_VIEW_DESC dsvDesc; D3D12_INTERNAL_AssignCpuDescriptorHandle( @@ -2901,7 +2901,7 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture( } // Create subresource UAV if necessary - if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT) { + if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE) { D3D12_UNORDERED_ACCESS_VIEW_DESC uavDesc; D3D12_INTERNAL_AssignCpuDescriptorHandle( @@ -3007,11 +3007,11 @@ static D3D12Buffer *D3D12_INTERNAL_CreateBuffer( return NULL; } - if (usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT) { + if (usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE) { resourceFlags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS; } #if (defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)) - if (usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT_BIT) { + if (usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT) { resourceFlags |= D3D12XBOX_RESOURCE_FLAG_ALLOW_INDIRECT_BUFFER; } #endif @@ -3088,7 +3088,7 @@ static D3D12Buffer *D3D12_INTERNAL_CreateBuffer( buffer->srvDescriptor.heap = NULL; buffer->cbvDescriptor.heap = NULL; - if (usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT) { + if (usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE) { D3D12_INTERNAL_AssignCpuDescriptorHandle( renderer, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, @@ -3112,8 +3112,8 @@ static D3D12Buffer *D3D12_INTERNAL_CreateBuffer( } if ( - (usageFlags & SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT) || - (usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT)) { + (usageFlags & SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ) || + (usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ)) { D3D12_INTERNAL_AssignCpuDescriptorHandle( renderer, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, @@ -3768,7 +3768,7 @@ static void D3D12_BeginRenderPass( framebufferHeight = h; } - if (!(container->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT)) { + if (!(container->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET)) { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Color attachment texture was not designated as a color target!"); return; } @@ -3791,7 +3791,7 @@ static void D3D12_BeginRenderPass( } // Fixme: - if (!(container->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT)) { + if (!(container->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET)) { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Depth stencil attachment texture was not designated as a depth target!"); return; } @@ -4765,7 +4765,7 @@ static void D3D12_BeginComputePass( if (storageTextureBindingCount > 0) { for (Uint32 i = 0; i < storageTextureBindingCount; i += 1) { D3D12TextureContainer *container = (D3D12TextureContainer *)storageTextureBindings[i].texture; - if (!(container->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { + if (!(container->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE)) { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Attempted to bind read-only texture as compute write texture"); } @@ -4788,7 +4788,7 @@ static void D3D12_BeginComputePass( if (storageBufferBindingCount > 0) { for (Uint32 i = 0; i < storageBufferBindingCount; i += 1) { D3D12BufferContainer *container = (D3D12BufferContainer *)storageBufferBindings[i].buffer; - if (!(container->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { + if (!(container->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE)) { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Attempted to bind read-only texture as compute write texture"); } D3D12Buffer *buffer = D3D12_INTERNAL_PrepareBufferForWrite( @@ -5875,7 +5875,7 @@ static bool D3D12_INTERNAL_CreateSwapchain( createInfo.width = width; createInfo.height = height; createInfo.format = SwapchainCompositionToSDLTextureFormat[swapchainComposition]; - createInfo.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT; + createInfo.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; createInfo.layerCountOrDepth = 1; createInfo.levelCount = 1; @@ -6012,7 +6012,7 @@ static bool D3D12_INTERNAL_InitializeSwapchainTexture( pTextureContainer->header.info.layerCountOrDepth = 1; pTextureContainer->header.info.levelCount = 1; pTextureContainer->header.info.type = SDL_GPU_TEXTURETYPE_2D; - pTextureContainer->header.info.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT; + pTextureContainer->header.info.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; pTextureContainer->header.info.sampleCount = SDL_GPU_SAMPLECOUNT_1; pTextureContainer->header.info.format = SwapchainCompositionToSDLTextureFormat[composition]; @@ -7324,19 +7324,19 @@ static bool D3D12_SupportsTextureFormat( } // Are the usage flags supported? - if ((usage & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) && !(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE)) { + if ((usage & SDL_GPU_TEXTUREUSAGE_SAMPLER) && !(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE)) { return false; } - if ((usage & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT | SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT)) && !(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_SHADER_LOAD)) { + if ((usage & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ | SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ)) && !(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_SHADER_LOAD)) { return false; } - if ((usage & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT) && !(formatSupport.Support2 & D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE)) { + if ((usage & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE) && !(formatSupport.Support2 & D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE)) { return false; } - if ((usage & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) && !(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_RENDER_TARGET)) { + if ((usage & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) && !(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_RENDER_TARGET)) { return false; } - if ((usage & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) && !(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL)) { + if ((usage & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) && !(formatSupport.Support1 & D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL)) { return false; } diff --git a/src/gpu/metal/SDL_gpu_metal.m b/src/gpu/metal/SDL_gpu_metal.m index 58b48af2c4..ad55e74991 100644 --- a/src/gpu/metal/SDL_gpu_metal.m +++ b/src/gpu/metal/SDL_gpu_metal.m @@ -306,19 +306,19 @@ static MTLStoreAction SDLToMetal_StoreOp( }; static MTLColorWriteMask SDLToMetal_ColorWriteMask( - SDL_GPUColorComponentFlagBits mask) + SDL_GPUColorComponentFlags mask) { MTLColorWriteMask result = 0; - if (mask & SDL_GPU_COLORCOMPONENT_R_BIT) { + if (mask & SDL_GPU_COLORCOMPONENT_R) { result |= MTLColorWriteMaskRed; } - if (mask & SDL_GPU_COLORCOMPONENT_G_BIT) { + if (mask & SDL_GPU_COLORCOMPONENT_G) { result |= MTLColorWriteMaskGreen; } - if (mask & SDL_GPU_COLORCOMPONENT_B_BIT) { + if (mask & SDL_GPU_COLORCOMPONENT_B) { result |= MTLColorWriteMaskBlue; } - if (mask & SDL_GPU_COLORCOMPONENT_A_BIT) { + if (mask & SDL_GPU_COLORCOMPONENT_A) { result |= MTLColorWriteMaskAlpha; } return result; @@ -1311,16 +1311,16 @@ static MetalTexture *METAL_INTERNAL_CreateTexture( textureDescriptor.storageMode = MTLStorageModePrivate; textureDescriptor.usage = 0; - if (textureCreateInfo->usageFlags & (SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT | - SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT)) { + if (textureCreateInfo->usageFlags & (SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | + SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET)) { textureDescriptor.usage |= MTLTextureUsageRenderTarget; } - if (textureCreateInfo->usageFlags & (SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT | - SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT | - SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT)) { + if (textureCreateInfo->usageFlags & (SDL_GPU_TEXTUREUSAGE_SAMPLER | + SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ | + SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ)) { textureDescriptor.usage |= MTLTextureUsageShaderRead; } - if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT) { + if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE) { textureDescriptor.usage |= MTLTextureUsageShaderWrite; } @@ -3377,7 +3377,7 @@ static Uint8 METAL_INTERNAL_CreateSwapchain( windowData->textureContainer.header.info.levelCount = 1; windowData->textureContainer.header.info.layerCountOrDepth = 1; windowData->textureContainer.header.info.type = SDL_GPU_TEXTURETYPE_2D; - windowData->textureContainer.header.info.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT; + windowData->textureContainer.header.info.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; drawableSize = windowData->layer.drawableSize; windowData->textureContainer.header.info.width = (Uint32)drawableSize.width; @@ -3683,7 +3683,7 @@ static bool METAL_SupportsTextureFormat( MetalRenderer *renderer = (MetalRenderer *)driverData; // Only depth textures can be used as... depth textures - if ((usage & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT)) { + if ((usage & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET)) { if (!IsDepthFormat(format)) { return false; } @@ -3707,7 +3707,7 @@ static bool METAL_SupportsTextureFormat( if (@available(macOS 11.0, *)) { return ( [renderer->device supportsBCTextureCompression] && - !(usage & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT)); + !(usage & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET)); } else { return false; } diff --git a/src/gpu/vulkan/SDL_gpu_vulkan.c b/src/gpu/vulkan/SDL_gpu_vulkan.c index 2fb613596c..e841b5a9ea 100644 --- a/src/gpu/vulkan/SDL_gpu_vulkan.c +++ b/src/gpu/vulkan/SDL_gpu_vulkan.c @@ -2728,17 +2728,17 @@ static VulkanBufferUsageMode VULKAN_INTERNAL_DefaultBufferUsageMode( { // NOTE: order matters here! - if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX_BIT) { + if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX) { return VULKAN_BUFFER_USAGE_MODE_VERTEX_READ; - } else if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_INDEX_BIT) { + } else if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_INDEX) { return VULKAN_BUFFER_USAGE_MODE_INDEX_READ; - } else if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT_BIT) { + } else if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT) { return VULKAN_BUFFER_USAGE_MODE_INDIRECT; - } else if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT) { + } else if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ) { return VULKAN_BUFFER_USAGE_MODE_GRAPHICS_STORAGE_READ; - } else if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT) { + } else if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ) { return VULKAN_BUFFER_USAGE_MODE_COMPUTE_STORAGE_READ; - } else if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT) { + } else if (buffer->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE) { return VULKAN_BUFFER_USAGE_MODE_COMPUTE_STORAGE_READ_WRITE; } else { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Buffer has no default usage mode!"); @@ -2752,17 +2752,17 @@ static VulkanTextureUsageMode VULKAN_INTERNAL_DefaultTextureUsageMode( // NOTE: order matters here! // NOTE: graphics storage bits and sampler bit are mutually exclusive! - if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) { + if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) { return VULKAN_TEXTURE_USAGE_MODE_SAMPLER; - } else if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT) { + } else if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ) { return VULKAN_TEXTURE_USAGE_MODE_GRAPHICS_STORAGE_READ; - } else if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) { + } else if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) { return VULKAN_TEXTURE_USAGE_MODE_COLOR_ATTACHMENT; - } else if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { + } else if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) { return VULKAN_TEXTURE_USAGE_MODE_DEPTH_STENCIL_ATTACHMENT; - } else if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT) { + } else if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ) { return VULKAN_TEXTURE_USAGE_MODE_COMPUTE_STORAGE_READ; - } else if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT) { + } else if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE) { return VULKAN_TEXTURE_USAGE_MODE_COMPUTE_STORAGE_READ_WRITE; } else { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Texture has no default usage mode!"); @@ -2944,7 +2944,7 @@ static void VULKAN_INTERNAL_DestroyTexture( { // Clean up subresources for (Uint32 subresourceIndex = 0; subresourceIndex < texture->subresourceCount; subresourceIndex += 1) { - if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) { + if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) { for (Uint32 depthIndex = 0; depthIndex < texture->depth; depthIndex += 1) { VULKAN_INTERNAL_RemoveFramebuffersContainingView( renderer, @@ -2967,14 +2967,14 @@ static void VULKAN_INTERNAL_DestroyTexture( SDL_free(texture->subresources[subresourceIndex].renderTargetViews); } - if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT) { + if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE) { renderer->vkDestroyImageView( renderer->logicalDevice, texture->subresources[subresourceIndex].computeWriteView, NULL); } - if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { + if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) { renderer->vkDestroyImageView( renderer->logicalDevice, texture->subresources[subresourceIndex].depthStencilView, @@ -4016,21 +4016,21 @@ static VulkanBuffer *VULKAN_INTERNAL_CreateBuffer( VkBufferUsageFlags vulkanUsageFlags = 0; Uint8 bindResult; - if (usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX_BIT) { + if (usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX) { vulkanUsageFlags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; } - if (usageFlags & SDL_GPU_BUFFERUSAGE_INDEX_BIT) { + if (usageFlags & SDL_GPU_BUFFERUSAGE_INDEX) { vulkanUsageFlags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT; } - if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT | - SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT | - SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { + if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ | + SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ | + SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE)) { vulkanUsageFlags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; } - if (usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT_BIT) { + if (usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT) { vulkanUsageFlags |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; } @@ -4669,7 +4669,7 @@ static bool VULKAN_INTERNAL_CreateSwapchain( swapchainData->textureContainers[i].header.info.type = SDL_GPU_TEXTURETYPE_2D; swapchainData->textureContainers[i].header.info.levelCount = 1; swapchainData->textureContainers[i].header.info.sampleCount = SDL_GPU_SAMPLECOUNT_1; - swapchainData->textureContainers[i].header.info.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT; + swapchainData->textureContainers[i].header.info.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; swapchainData->textureContainers[i].activeTextureHandle = SDL_malloc(sizeof(VulkanTextureHandle)); @@ -4690,7 +4690,7 @@ static bool VULKAN_INTERNAL_CreateSwapchain( swapchainData->textureContainers[i].activeTextureHandle->vulkanTexture->levelCount = 1; swapchainData->textureContainers[i].activeTextureHandle->vulkanTexture->sampleCount = VK_SAMPLE_COUNT_1_BIT; swapchainData->textureContainers[i].activeTextureHandle->vulkanTexture->usageFlags = - SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT; + SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; swapchainData->textureContainers[i].activeTextureHandle->vulkanTexture->aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT; SDL_AtomicSet(&swapchainData->textureContainers[i].activeTextureHandle->vulkanTexture->referenceCount, 0); @@ -5630,8 +5630,8 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture( VkImageViewCreateInfo imageViewCreateInfo; Uint8 bindResult; Uint8 isRenderTarget = - ((textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) != 0) || - ((textureUsageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) != 0); + ((textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) != 0) || + ((textureUsageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) != 0); VkImageUsageFlags vkUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; VulkanTexture *texture = SDL_malloc(sizeof(VulkanTexture)); @@ -5645,18 +5645,18 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture( imageCreateFlags |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT; } - if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) { + if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) { vkUsageFlags |= VK_IMAGE_USAGE_SAMPLED_BIT; } - if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) { + if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) { vkUsageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; } - if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { + if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) { vkUsageFlags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; } - if (textureUsageFlags & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT | - SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT | - SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { + if (textureUsageFlags & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ | + SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ | + SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE)) { vkUsageFlags |= VK_IMAGE_USAGE_STORAGE_BIT; } @@ -5705,9 +5705,9 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture( texture->fullView = VK_NULL_HANDLE; if ( - (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) || - (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT) || - (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT)) { + (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) || + (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ) || + (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ)) { imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; imageViewCreateInfo.pNext = NULL; @@ -5775,7 +5775,7 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture( texture->subresources[subresourceIndex].computeWriteView = VK_NULL_HANDLE; texture->subresources[subresourceIndex].depthStencilView = VK_NULL_HANDLE; - if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) { + if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) { texture->subresources[subresourceIndex].renderTargetViews = SDL_malloc( texture->depth * sizeof(VkImageView)); @@ -5800,7 +5800,7 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture( } } - if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT) { + if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE) { VULKAN_INTERNAL_CreateSubresourceView( renderer, texture, @@ -5810,7 +5810,7 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture( &texture->subresources[subresourceIndex].computeWriteView); } - if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { + if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) { VULKAN_INTERNAL_CreateSubresourceView( renderer, texture, @@ -5843,7 +5843,7 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture( texture->format, texture->swizzle, aspectMask, - SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT, + SDL_GPU_TEXTUREUSAGE_COLOR_TARGET, true); } } @@ -7787,7 +7787,7 @@ static void VULKAN_BeginRenderPass( } // FIXME: validate this in gpu.c - if (!(textureContainer->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT)) { + if (!(textureContainer->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET)) { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Color attachment texture was not designated as a target!"); return; } @@ -7810,7 +7810,7 @@ static void VULKAN_BeginRenderPass( } // FIXME: validate this in gpu.c - if (!(textureContainer->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT)) { + if (!(textureContainer->header.info.usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET)) { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Depth stencil attachment texture was not designated as a target!"); return; } @@ -8162,7 +8162,7 @@ static void VULKAN_BeginComputePass( for (i = 0; i < storageTextureBindingCount; i += 1) { VulkanTextureContainer *textureContainer = (VulkanTextureContainer *)storageTextureBindings[i].texture; - if (!(textureContainer->activeTextureHandle->vulkanTexture->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { + if (!(textureContainer->activeTextureHandle->vulkanTexture->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE)) { SDL_LogError(SDL_LOG_CATEGORY_GPU, "Attempted to bind read-only texture as compute write texture"); } @@ -10775,18 +10775,18 @@ static bool VULKAN_SupportsTextureFormat( VkImageFormatProperties properties; VkResult vulkanResult; - if (usage & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) { + if (usage & SDL_GPU_TEXTUREUSAGE_SAMPLER) { vulkanUsage |= VK_IMAGE_USAGE_SAMPLED_BIT; } - if (usage & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) { + if (usage & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) { vulkanUsage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; } - if (usage & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { + if (usage & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) { vulkanUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; } - if (usage & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT | - SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT | - SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { + if (usage & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ | + SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ | + SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE)) { vulkanUsage |= VK_IMAGE_USAGE_STORAGE_BIT; } diff --git a/src/render/sdlgpu/SDL_render_gpu.c b/src/render/sdlgpu/SDL_render_gpu.c index f7a5e7db75..a67f158321 100644 --- a/src/render/sdlgpu/SDL_render_gpu.c +++ b/src/render/sdlgpu/SDL_render_gpu.c @@ -173,7 +173,7 @@ static bool GPU_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ GPU_RenderData *renderdata = (GPU_RenderData *)renderer->internal; GPU_TextureData *data; SDL_GPUTextureFormat format; - SDL_GPUTextureUsageFlags usage = SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT; + SDL_GPUTextureUsageFlags usage = SDL_GPU_TEXTUREUSAGE_SAMPLER; format = PixFormatToTexFormat(texture->format); @@ -211,7 +211,7 @@ static bool GPU_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_ } if (texture->access == SDL_TEXTUREACCESS_TARGET) { - usage |= SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT; + usage |= SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; } texture->internal = data; @@ -603,7 +603,7 @@ static bool InitVertexBuffer(GPU_RenderData *data, Uint32 size) SDL_GPUBufferCreateInfo bci; SDL_zero(bci); bci.sizeInBytes = size; - bci.usageFlags = SDL_GPU_BUFFERUSAGE_VERTEX_BIT; + bci.usageFlags = SDL_GPU_BUFFERUSAGE_VERTEX; data->vertices.buffer = SDL_CreateGPUBuffer(data->device, &bci); @@ -923,7 +923,7 @@ static bool CreateBackbuffer(GPU_RenderData *data, Uint32 w, Uint32 h, SDL_GPUTe tci.layerCountOrDepth = 1; tci.levelCount = 1; tci.sampleCount = SDL_GPU_SAMPLECOUNT_1; - tci.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT | SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT; + tci.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; data->backbuffer.texture = SDL_CreateGPUTexture(data->device, &tci); data->backbuffer.width = w; diff --git a/test/testgpu_spinning_cube.c b/test/testgpu_spinning_cube.c index 96c60415ea..dbf5f923e7 100644 --- a/test/testgpu_spinning_cube.c +++ b/test/testgpu_spinning_cube.c @@ -259,7 +259,7 @@ CreateDepthTexture(Uint32 drawablew, Uint32 drawableh) depthtex_createinfo.layerCountOrDepth = 1; depthtex_createinfo.levelCount = 1; depthtex_createinfo.sampleCount = render_state.sample_count; - depthtex_createinfo.usageFlags = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT; + depthtex_createinfo.usageFlags = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET; depthtex_createinfo.props = 0; result = SDL_CreateGPUTexture(gpu_device, &depthtex_createinfo); @@ -285,7 +285,7 @@ CreateMSAATexture(Uint32 drawablew, Uint32 drawableh) msaatex_createinfo.layerCountOrDepth = 1; msaatex_createinfo.levelCount = 1; msaatex_createinfo.sampleCount = render_state.sample_count; - msaatex_createinfo.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT | SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT; + msaatex_createinfo.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; msaatex_createinfo.props = 0; result = SDL_CreateGPUTexture(gpu_device, &msaatex_createinfo); @@ -492,7 +492,7 @@ init_render_state(int msaa) /* Create buffers */ - buffer_desc.usageFlags = SDL_GPU_BUFFERUSAGE_VERTEX_BIT; + buffer_desc.usageFlags = SDL_GPU_BUFFERUSAGE_VERTEX; buffer_desc.sizeInBytes = sizeof(vertex_data); buffer_desc.props = 0; render_state.buf_vertex = SDL_CreateGPUBuffer(