eden-emu/SDL
15
0
Fork 0
mirror of https://github.com/libsdl-org/SDL.git synced 2025-05-31 00:47:39 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Change GPU flag enums to defines (#10681)

Browse source
This commit is contained in:
Caleb Cornett 2024-09-02 17:19:43 -05:00 • committed by GitHub
parent d501f6db07
commit f405def691
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
8 changed files with 182 additions and 195 deletions
Download patch file Download diff file Expand all files Collapse all files

81
include/SDL3/SDL_gpu.h
View file

@ -198,18 +198,15 @@ typedef enum SDL_GPUTextureFormat
SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT
} SDL_GPUTextureFormat; } 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; 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 typedef enum SDL_GPUTextureType
{ {
SDL_GPU_TEXTURETYPE_2D, SDL_GPU_TEXTURETYPE_2D,
@ -236,18 +233,15 @@ typedef enum SDL_GPUCubeMapFace
SDL_GPU_CUBEMAPFACE_NEGATIVEZ SDL_GPU_CUBEMAPFACE_NEGATIVEZ
} SDL_GPUCubeMapFace; } 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; 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 typedef enum SDL_GPUTransferBufferUsage
{ {
SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD, SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD,
@ -260,19 +254,15 @@ typedef enum SDL_GPUShaderStage
SDL_GPU_SHADERSTAGE_FRAGMENT SDL_GPU_SHADERSTAGE_FRAGMENT
} SDL_GPUShaderStage; } 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; 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 typedef enum SDL_GPUVertexElementFormat
{ {
/* 32-bit Signed Integers */ /* 32-bit Signed Integers */
@ -405,16 +395,13 @@ typedef enum SDL_GPUBlendFactor
SDL_GPU_BLENDFACTOR_SRC_ALPHA_SATURATE SDL_GPU_BLENDFACTOR_SRC_ALPHA_SATURATE
} SDL_GPUBlendFactor; } 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; 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 typedef enum SDL_GPUFilter
{ {
SDL_GPU_FILTER_NEAREST, 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. * 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 renderPass a render pass handle.
* \param firstSlot the vertex sampler slot to begin binding from. * \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. * Binds storage textures for use on the vertex shader.
* *
* These textures must have been created with * 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 renderPass a render pass handle.
* \param firstSlot the vertex storage texture slot to begin binding from. * \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. * Binds storage buffers for use on the vertex shader.
* *
* These buffers must have been created with * 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 renderPass a render pass handle.
* \param firstSlot the vertex storage buffer slot to begin binding from. * \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. * 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 renderPass a render pass handle.
* \param firstSlot the fragment sampler slot to begin binding from. * \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. * Binds storage textures for use on the fragment shader.
* *
* These textures must have been created with * 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 renderPass a render pass handle.
* \param firstSlot the fragment storage texture slot to begin binding from. * \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. * Binds storage buffers for use on the fragment shader.
* *
* These buffers must have been created with * 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 renderPass a render pass handle.
* \param firstSlot the fragment storage buffer slot to begin binding from. * \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. * Binds storage textures as readonly for use on the compute pipeline.
* *
* These textures must have been created with * 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 computePass a compute pass handle.
* \param firstSlot the compute storage texture slot to begin binding from. * \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. * Binds storage buffers as readonly for use on the compute pipeline.
* *
* These buffers must have been created with * 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 computePass a compute pass handle.
* \param firstSlot the compute storage buffer slot to begin binding from. * \param firstSlot the compute storage buffer slot to begin binding from.

32
src/gpu/SDL_gpu.c
View file

@ -718,16 +718,16 @@ SDL_GPUTexture *SDL_CreateGPUTexture(
SDL_assert_release(!"For any texture: levelCount must be >= 1"); SDL_assert_release(!"For any texture: levelCount must be >= 1");
failed = true; failed = true;
} }
if ((textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT) && (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_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_BIT and SAMPLER_BIT"); SDL_assert_release(!"For any texture: usageFlags cannot contain both GRAPHICS_STORAGE_READ and SAMPLER");
failed = true; failed = true;
} }
if (IsDepthFormat(textureCreateInfo->format) && (textureCreateInfo->usageFlags & ~(SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT | SDL_GPU_TEXTUREUSAGE_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_BIT and SAMPLER_BIT"); SDL_assert_release(!"For depth textures: usageFlags cannot contain any flags except for DEPTH_STENCIL_TARGET and SAMPLER");
failed = true; failed = true;
} }
if (IsIntegerFormat(textureCreateInfo->format) && (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT)) { if (IsIntegerFormat(textureCreateInfo->format) && (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER)) {
SDL_assert_release(!"For any texture: usageFlags cannot contain SAMPLER_BIT for textures with an integer format"); SDL_assert_release(!"For any texture: usageFlags cannot contain SAMPLER for textures with an integer format");
failed = true; failed = true;
} }
@ -759,8 +759,8 @@ SDL_GPUTexture *SDL_CreateGPUTexture(
SDL_assert_release(!"For 3D textures: width, height, and layerCountOrDepth must be <= 2048"); SDL_assert_release(!"For 3D textures: width, height, and layerCountOrDepth must be <= 2048");
failed = true; failed = true;
} }
if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_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_BIT"); SDL_assert_release(!"For 3D textures: usageFlags must not contain DEPTH_STENCIL_TARGET");
failed = true; failed = true;
} }
if (textureCreateInfo->sampleCount > SDL_GPU_SAMPLECOUNT_1) { if (textureCreateInfo->sampleCount > SDL_GPU_SAMPLECOUNT_1) {
@ -774,8 +774,8 @@ SDL_GPUTexture *SDL_CreateGPUTexture(
} else { } else {
if (textureCreateInfo->type == SDL_GPU_TEXTURETYPE_2D_ARRAY) { if (textureCreateInfo->type == SDL_GPU_TEXTURETYPE_2D_ARRAY) {
// Array Texture Validation // Array Texture Validation
if (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_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_BIT"); SDL_assert_release(!"For array textures: usageFlags must not contain DEPTH_STENCIL_TARGET");
failed = true; failed = true;
} }
if (textureCreateInfo->sampleCount > SDL_GPU_SAMPLECOUNT_1) { if (textureCreateInfo->sampleCount > SDL_GPU_SAMPLECOUNT_1) {
@ -2063,8 +2063,8 @@ void SDL_GenerateMipmapsForGPUTexture(
return; return;
} }
if (!(header->info.usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) || !(header->info.usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT)) { 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_BIT and COLOR_TARGET_BIT usage flags!"); SDL_assert_release(!"GenerateMipmaps texture must be created with SAMPLER and COLOR_TARGET usage flags!");
return; return;
} }
} }
@ -2108,12 +2108,12 @@ void SDL_BlitGPUTexture(
SDL_assert_release(!"Blit source and destination textures must be non-NULL"); SDL_assert_release(!"Blit source and destination textures must be non-NULL");
return; // attempting to proceed will crash return; // attempting to proceed will crash
} }
if ((srcHeader->info.usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) == 0) { if ((srcHeader->info.usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) == 0) {
SDL_assert_release(!"Blit source texture must be created with the SAMPLER_BIT usage flag"); SDL_assert_release(!"Blit source texture must be created with the SAMPLER usage flag");
failed = true; failed = true;
} }
if ((dstHeader->info.usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) == 0) { if ((dstHeader->info.usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) == 0) {
SDL_assert_release(!"Blit destination texture must be created with the COLOR_TARGET_BIT usage flag"); SDL_assert_release(!"Blit destination texture must be created with the COLOR_TARGET usage flag");
failed = true; failed = true;
} }
if (IsDepthFormat(srcHeader->info.format)) { if (IsDepthFormat(srcHeader->info.format)) {

50
src/gpu/d3d11/SDL_gpu_d3d11.c
View file

@ -1848,20 +1848,20 @@ static D3D11Texture *D3D11_INTERNAL_CreateTexture(
D3D11Texture *d3d11Texture; D3D11Texture *d3d11Texture;
HRESULT res; HRESULT res;
isColorTarget = createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT; isColorTarget = createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET;
isDepthStencil = createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT; isDepthStencil = createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET;
needsSRV = needsSRV =
(createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) || (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) ||
(createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT) || (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ) ||
(createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT); (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ);
needSubresourceUAV = 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; isMultisample = createInfo->sampleCount > SDL_GPU_SAMPLECOUNT_1;
isStaging = createInfo->usageFlags == 0; isStaging = createInfo->usageFlags == 0;
isMippable = isMippable =
createInfo->levelCount > 1 && createInfo->levelCount > 1 &&
(createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) && (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) &&
(createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT); (createInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET);
format = SDLToD3D11_TextureFormat[createInfo->format]; format = SDLToD3D11_TextureFormat[createInfo->format];
if (isDepthStencil) { if (isDepthStencil) {
format = D3D11_INTERNAL_GetTypelessFormat(format); format = D3D11_INTERNAL_GetTypelessFormat(format);
@ -2370,19 +2370,19 @@ static SDL_GPUBuffer *D3D11_CreateBuffer(
D3D11_BUFFER_DESC bufferDesc; D3D11_BUFFER_DESC bufferDesc;
bufferDesc.BindFlags = 0; bufferDesc.BindFlags = 0;
if (usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX_BIT) { if (usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX) {
bufferDesc.BindFlags |= D3D11_BIND_VERTEX_BUFFER; 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; 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; bufferDesc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
} }
if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT | if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ |
SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT | SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ |
SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE)) {
bufferDesc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE; bufferDesc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS | D3D11_BIND_SHADER_RESOURCE;
} }
@ -2392,12 +2392,12 @@ static SDL_GPUBuffer *D3D11_CreateBuffer(
bufferDesc.StructureByteStride = 0; bufferDesc.StructureByteStride = 0;
bufferDesc.MiscFlags = 0; bufferDesc.MiscFlags = 0;
if (usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT_BIT) { if (usageFlags & SDL_GPU_BUFFERUSAGE_INDIRECT) {
bufferDesc.MiscFlags |= D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS; bufferDesc.MiscFlags |= D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS;
} }
if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT | if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ |
SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT | SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ |
SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE)) {
bufferDesc.MiscFlags |= D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS; bufferDesc.MiscFlags |= D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS;
} }
@ -4151,7 +4151,7 @@ static void D3D11_BeginComputePass(
for (i = 0; i < storageTextureBindingCount; i += 1) { for (i = 0; i < storageTextureBindingCount; i += 1) {
textureContainer = (D3D11TextureContainer *)storageTextureBindings[i].texture; 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"); 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.type = SDL_GPU_TEXTURETYPE_2D;
windowData->textureContainer.header.info.levelCount = 1; windowData->textureContainer.header.info.levelCount = 1;
windowData->textureContainer.header.info.sampleCount = SDL_GPU_SAMPLECOUNT_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.container = &windowData->textureContainer;
windowData->texture.containerIndex = 0; windowData->texture.containerIndex = 0;
@ -5547,20 +5547,20 @@ static bool D3D11_SupportsTextureFormat(
} }
// Are the usage flags supported? // 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; 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; 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 // TYPED_UNORDERED_ACCESS_VIEW implies support for typed UAV stores
return false; 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; 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; return false;
} }

78
src/gpu/d3d12/SDL_gpu_d3d12.c
View file

@ -1459,7 +1459,7 @@ static void D3D12_INTERNAL_TextureSubresourceBarrier(
destinationState, destinationState,
textureSubresource->parent->resource, textureSubresource->parent->resource,
textureSubresource->index, 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( static D3D12_RESOURCE_STATES D3D12_INTERNAL_DefaultTextureResourceState(
@ -1467,17 +1467,17 @@ static D3D12_RESOURCE_STATES D3D12_INTERNAL_DefaultTextureResourceState(
{ {
// NOTE: order matters here! // NOTE: order matters here!
if (usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) { if (usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) {
return D3D12_RESOURCE_STATE_ALL_SHADER_RESOURCE; 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; 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; 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; 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; 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; return D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
} else { } else {
SDL_LogError(SDL_LOG_CATEGORY_GPU, "Texture has no default usage mode!"); 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( static D3D12_RESOURCE_STATES D3D12_INTERNAL_DefaultBufferResourceState(
D3D12Buffer *buffer) 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; 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; 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; 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; 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; 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; return D3D12_RESOURCE_STATE_UNORDERED_ACCESS;
} else { } else {
SDL_LogError(SDL_LOG_CATEGORY_GPU, "Buffer has no default usage mode!"); SDL_LogError(SDL_LOG_CATEGORY_GPU, "Buffer has no default usage mode!");
@ -1568,7 +1568,7 @@ static void D3D12_INTERNAL_BufferBarrier(
destinationState, destinationState,
buffer->handle, buffer->handle,
0, 0,
buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT); buffer->container->usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE);
buffer->transitioned = true; buffer->transitioned = true;
} }
@ -2693,7 +2693,7 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture(
Uint32 layerCount = textureCreateInfo->type == SDL_GPU_TEXTURETYPE_3D ? 1 : textureCreateInfo->layerCountOrDepth; Uint32 layerCount = textureCreateInfo->type == SDL_GPU_TEXTURETYPE_3D ? 1 : textureCreateInfo->layerCountOrDepth;
Uint32 depth = textureCreateInfo->type == SDL_GPU_TEXTURETYPE_3D ? textureCreateInfo->layerCountOrDepth : 1; 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; resourceFlags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET;
useClearValue = true; useClearValue = true;
clearValue.Color[0] = SDL_GetFloatProperty(textureCreateInfo->props, SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_R_FLOAT, 0); 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); 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; resourceFlags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL;
useClearValue = true; useClearValue = true;
clearValue.DepthStencil.Depth = SDL_GetFloatProperty(textureCreateInfo->props, SDL_PROP_GPU_CREATETEXTURE_D3D12_CLEAR_DEPTH_FLOAT, 0); 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); 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; resourceFlags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
} }
@ -2768,9 +2768,9 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture(
texture->resource = handle; texture->resource = handle;
// Create the SRV if applicable // Create the SRV if applicable
if ((textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) || if ((textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) ||
(textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT) || (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ) ||
(textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT)) { (textureCreateInfo->usageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ)) {
D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc; D3D12_SHADER_RESOURCE_VIEW_DESC srvDesc;
D3D12_INTERNAL_AssignCpuDescriptorHandle( D3D12_INTERNAL_AssignCpuDescriptorHandle(
@ -2841,7 +2841,7 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture(
texture->subresources[subresourceIndex].dsvHandle.heap = NULL; texture->subresources[subresourceIndex].dsvHandle.heap = NULL;
// Create RTV if needed // 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)); texture->subresources[subresourceIndex].rtvHandles = (D3D12CPUDescriptor *)SDL_calloc(depth, sizeof(D3D12CPUDescriptor));
for (Uint32 depthIndex = 0; depthIndex < depth; depthIndex += 1) { for (Uint32 depthIndex = 0; depthIndex < depth; depthIndex += 1) {
@ -2880,7 +2880,7 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture(
} }
// Create DSV if needed // 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_DEPTH_STENCIL_VIEW_DESC dsvDesc;
D3D12_INTERNAL_AssignCpuDescriptorHandle( D3D12_INTERNAL_AssignCpuDescriptorHandle(
@ -2901,7 +2901,7 @@ static D3D12Texture *D3D12_INTERNAL_CreateTexture(
} }
// Create subresource UAV if necessary // 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_UNORDERED_ACCESS_VIEW_DESC uavDesc;
D3D12_INTERNAL_AssignCpuDescriptorHandle( D3D12_INTERNAL_AssignCpuDescriptorHandle(
@ -3007,11 +3007,11 @@ static D3D12Buffer *D3D12_INTERNAL_CreateBuffer(
return NULL; 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; resourceFlags |= D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
} }
#if (defined(SDL_PLATFORM_XBOXONE) || defined(SDL_PLATFORM_XBOXSERIES)) #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; resourceFlags |= D3D12XBOX_RESOURCE_FLAG_ALLOW_INDIRECT_BUFFER;
} }
#endif #endif
@ -3088,7 +3088,7 @@ static D3D12Buffer *D3D12_INTERNAL_CreateBuffer(
buffer->srvDescriptor.heap = NULL; buffer->srvDescriptor.heap = NULL;
buffer->cbvDescriptor.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( D3D12_INTERNAL_AssignCpuDescriptorHandle(
renderer, renderer,
D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
@ -3112,8 +3112,8 @@ static D3D12Buffer *D3D12_INTERNAL_CreateBuffer(
} }
if ( if (
(usageFlags & SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT) || (usageFlags & SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ) ||
(usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT)) { (usageFlags & SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ)) {
D3D12_INTERNAL_AssignCpuDescriptorHandle( D3D12_INTERNAL_AssignCpuDescriptorHandle(
renderer, renderer,
D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV,
@ -3768,7 +3768,7 @@ static void D3D12_BeginRenderPass(
framebufferHeight = h; 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!"); SDL_LogError(SDL_LOG_CATEGORY_GPU, "Color attachment texture was not designated as a color target!");
return; return;
} }
@ -3791,7 +3791,7 @@ static void D3D12_BeginRenderPass(
} }
// Fixme: // 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!"); SDL_LogError(SDL_LOG_CATEGORY_GPU, "Depth stencil attachment texture was not designated as a depth target!");
return; return;
} }
@ -4765,7 +4765,7 @@ static void D3D12_BeginComputePass(
if (storageTextureBindingCount > 0) { if (storageTextureBindingCount > 0) {
for (Uint32 i = 0; i < storageTextureBindingCount; i += 1) { for (Uint32 i = 0; i < storageTextureBindingCount; i += 1) {
D3D12TextureContainer *container = (D3D12TextureContainer *)storageTextureBindings[i].texture; 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"); 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) { if (storageBufferBindingCount > 0) {
for (Uint32 i = 0; i < storageBufferBindingCount; i += 1) { for (Uint32 i = 0; i < storageBufferBindingCount; i += 1) {
D3D12BufferContainer *container = (D3D12BufferContainer *)storageBufferBindings[i].buffer; 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"); SDL_LogError(SDL_LOG_CATEGORY_GPU, "Attempted to bind read-only texture as compute write texture");
} }
D3D12Buffer *buffer = D3D12_INTERNAL_PrepareBufferForWrite( D3D12Buffer *buffer = D3D12_INTERNAL_PrepareBufferForWrite(
@ -5875,7 +5875,7 @@ static bool D3D12_INTERNAL_CreateSwapchain(
createInfo.width = width; createInfo.width = width;
createInfo.height = height; createInfo.height = height;
createInfo.format = SwapchainCompositionToSDLTextureFormat[swapchainComposition]; createInfo.format = SwapchainCompositionToSDLTextureFormat[swapchainComposition];
createInfo.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT; createInfo.usageFlags = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET;
createInfo.layerCountOrDepth = 1; createInfo.layerCountOrDepth = 1;
createInfo.levelCount = 1; createInfo.levelCount = 1;
@ -6012,7 +6012,7 @@ static bool D3D12_INTERNAL_InitializeSwapchainTexture(
pTextureContainer->header.info.layerCountOrDepth = 1; pTextureContainer->header.info.layerCountOrDepth = 1;
pTextureContainer->header.info.levelCount = 1; pTextureContainer->header.info.levelCount = 1;
pTextureContainer->header.info.type = SDL_GPU_TEXTURETYPE_2D; 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.sampleCount = SDL_GPU_SAMPLECOUNT_1;
pTextureContainer->header.info.format = SwapchainCompositionToSDLTextureFormat[composition]; pTextureContainer->header.info.format = SwapchainCompositionToSDLTextureFormat[composition];
@ -7324,19 +7324,19 @@ static bool D3D12_SupportsTextureFormat(
} }
// Are the usage flags supported? // 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; 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; 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; 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; 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; return false;
} }

28
src/gpu/metal/SDL_gpu_metal.m
View file

@ -306,19 +306,19 @@ static MTLStoreAction SDLToMetal_StoreOp(
}; };
static MTLColorWriteMask SDLToMetal_ColorWriteMask( static MTLColorWriteMask SDLToMetal_ColorWriteMask(
SDL_GPUColorComponentFlagBits mask) SDL_GPUColorComponentFlags mask)
{ {
MTLColorWriteMask result = 0; MTLColorWriteMask result = 0;
if (mask & SDL_GPU_COLORCOMPONENT_R_BIT) { if (mask & SDL_GPU_COLORCOMPONENT_R) {
result |= MTLColorWriteMaskRed; result |= MTLColorWriteMaskRed;
} }
if (mask & SDL_GPU_COLORCOMPONENT_G_BIT) { if (mask & SDL_GPU_COLORCOMPONENT_G) {
result |= MTLColorWriteMaskGreen; result |= MTLColorWriteMaskGreen;
} }
if (mask & SDL_GPU_COLORCOMPONENT_B_BIT) { if (mask & SDL_GPU_COLORCOMPONENT_B) {
result |= MTLColorWriteMaskBlue; result |= MTLColorWriteMaskBlue;
} }
if (mask & SDL_GPU_COLORCOMPONENT_A_BIT) { if (mask & SDL_GPU_COLORCOMPONENT_A) {
result |= MTLColorWriteMaskAlpha; result |= MTLColorWriteMaskAlpha;
} }
return result; return result;
@ -1311,16 +1311,16 @@ static MetalTexture *METAL_INTERNAL_CreateTexture(
textureDescriptor.storageMode = MTLStorageModePrivate; textureDescriptor.storageMode = MTLStorageModePrivate;
textureDescriptor.usage = 0; textureDescriptor.usage = 0;
if (textureCreateInfo->usageFlags & (SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT | if (textureCreateInfo->usageFlags & (SDL_GPU_TEXTUREUSAGE_COLOR_TARGET |
SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT)) { SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET)) {
textureDescriptor.usage |= MTLTextureUsageRenderTarget; textureDescriptor.usage |= MTLTextureUsageRenderTarget;
} }
if (textureCreateInfo->usageFlags & (SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT | if (textureCreateInfo->usageFlags & (SDL_GPU_TEXTUREUSAGE_SAMPLER |
SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT | SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ |
SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT)) { SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ)) {
textureDescriptor.usage |= MTLTextureUsageShaderRead; 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; textureDescriptor.usage |= MTLTextureUsageShaderWrite;
} }
@ -3377,7 +3377,7 @@ static Uint8 METAL_INTERNAL_CreateSwapchain(
windowData->textureContainer.header.info.levelCount = 1; windowData->textureContainer.header.info.levelCount = 1;
windowData->textureContainer.header.info.layerCountOrDepth = 1; windowData->textureContainer.header.info.layerCountOrDepth = 1;
windowData->textureContainer.header.info.type = SDL_GPU_TEXTURETYPE_2D; 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; drawableSize = windowData->layer.drawableSize;
windowData->textureContainer.header.info.width = (Uint32)drawableSize.width; windowData->textureContainer.header.info.width = (Uint32)drawableSize.width;
@ -3683,7 +3683,7 @@ static bool METAL_SupportsTextureFormat(
MetalRenderer *renderer = (MetalRenderer *)driverData; MetalRenderer *renderer = (MetalRenderer *)driverData;
// Only depth textures can be used as... depth textures // 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)) { if (!IsDepthFormat(format)) {
return false; return false;
} }
@ -3707,7 +3707,7 @@ static bool METAL_SupportsTextureFormat(
if (@available(macOS 11.0, *)) { if (@available(macOS 11.0, *)) {
return ( return (
[renderer->device supportsBCTextureCompression] && [renderer->device supportsBCTextureCompression] &&
!(usage & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT)); !(usage & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET));
} else { } else {
return false; return false;
} }

94
src/gpu/vulkan/SDL_gpu_vulkan.c
View file

@ -2728,17 +2728,17 @@ static VulkanBufferUsageMode VULKAN_INTERNAL_DefaultBufferUsageMode(
{ {
// NOTE: order matters here! // 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; 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; 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; 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; 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; 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; return VULKAN_BUFFER_USAGE_MODE_COMPUTE_STORAGE_READ_WRITE;
} else { } else {
SDL_LogError(SDL_LOG_CATEGORY_GPU, "Buffer has no default usage mode!"); 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: order matters here!
// NOTE: graphics storage bits and sampler bit are mutually exclusive! // 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; 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; 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; 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; 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; 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; return VULKAN_TEXTURE_USAGE_MODE_COMPUTE_STORAGE_READ_WRITE;
} else { } else {
SDL_LogError(SDL_LOG_CATEGORY_GPU, "Texture has no default usage mode!"); SDL_LogError(SDL_LOG_CATEGORY_GPU, "Texture has no default usage mode!");
@ -2944,7 +2944,7 @@ static void VULKAN_INTERNAL_DestroyTexture(
{ {
// Clean up subresources // Clean up subresources
for (Uint32 subresourceIndex = 0; subresourceIndex < texture->subresourceCount; subresourceIndex += 1) { 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) { for (Uint32 depthIndex = 0; depthIndex < texture->depth; depthIndex += 1) {
VULKAN_INTERNAL_RemoveFramebuffersContainingView( VULKAN_INTERNAL_RemoveFramebuffersContainingView(
renderer, renderer,
@ -2967,14 +2967,14 @@ static void VULKAN_INTERNAL_DestroyTexture(
SDL_free(texture->subresources[subresourceIndex].renderTargetViews); 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->vkDestroyImageView(
renderer->logicalDevice, renderer->logicalDevice,
texture->subresources[subresourceIndex].computeWriteView, texture->subresources[subresourceIndex].computeWriteView,
NULL); NULL);
} }
if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { if (texture->usageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) {
renderer->vkDestroyImageView( renderer->vkDestroyImageView(
renderer->logicalDevice, renderer->logicalDevice,
texture->subresources[subresourceIndex].depthStencilView, texture->subresources[subresourceIndex].depthStencilView,
@ -4016,21 +4016,21 @@ static VulkanBuffer *VULKAN_INTERNAL_CreateBuffer(
VkBufferUsageFlags vulkanUsageFlags = 0; VkBufferUsageFlags vulkanUsageFlags = 0;
Uint8 bindResult; Uint8 bindResult;
if (usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX_BIT) { if (usageFlags & SDL_GPU_BUFFERUSAGE_VERTEX) {
vulkanUsageFlags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; 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; vulkanUsageFlags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
} }
if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ_BIT | if (usageFlags & (SDL_GPU_BUFFERUSAGE_GRAPHICS_STORAGE_READ |
SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ_BIT | SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_READ |
SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { SDL_GPU_BUFFERUSAGE_COMPUTE_STORAGE_WRITE)) {
vulkanUsageFlags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; 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; 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.type = SDL_GPU_TEXTURETYPE_2D;
swapchainData->textureContainers[i].header.info.levelCount = 1; swapchainData->textureContainers[i].header.info.levelCount = 1;
swapchainData->textureContainers[i].header.info.sampleCount = SDL_GPU_SAMPLECOUNT_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)); 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->levelCount = 1;
swapchainData->textureContainers[i].activeTextureHandle->vulkanTexture->sampleCount = VK_SAMPLE_COUNT_1_BIT; swapchainData->textureContainers[i].activeTextureHandle->vulkanTexture->sampleCount = VK_SAMPLE_COUNT_1_BIT;
swapchainData->textureContainers[i].activeTextureHandle->vulkanTexture->usageFlags = 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; swapchainData->textureContainers[i].activeTextureHandle->vulkanTexture->aspectFlags = VK_IMAGE_ASPECT_COLOR_BIT;
SDL_AtomicSet(&swapchainData->textureContainers[i].activeTextureHandle->vulkanTexture->referenceCount, 0); SDL_AtomicSet(&swapchainData->textureContainers[i].activeTextureHandle->vulkanTexture->referenceCount, 0);
@ -5630,8 +5630,8 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture(
VkImageViewCreateInfo imageViewCreateInfo; VkImageViewCreateInfo imageViewCreateInfo;
Uint8 bindResult; Uint8 bindResult;
Uint8 isRenderTarget = Uint8 isRenderTarget =
((textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT) != 0) || ((textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COLOR_TARGET) != 0) ||
((textureUsageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) != 0); ((textureUsageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) != 0);
VkImageUsageFlags vkUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT; VkImageUsageFlags vkUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
VulkanTexture *texture = SDL_malloc(sizeof(VulkanTexture)); VulkanTexture *texture = SDL_malloc(sizeof(VulkanTexture));
@ -5645,18 +5645,18 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture(
imageCreateFlags |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT; 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; 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; 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; vkUsageFlags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
} }
if (textureUsageFlags & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT | if (textureUsageFlags & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ |
SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT | SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ |
SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE)) {
vkUsageFlags |= VK_IMAGE_USAGE_STORAGE_BIT; vkUsageFlags |= VK_IMAGE_USAGE_STORAGE_BIT;
} }
@ -5705,9 +5705,9 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture(
texture->fullView = VK_NULL_HANDLE; texture->fullView = VK_NULL_HANDLE;
if ( if (
(textureUsageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) || (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_SAMPLER) ||
(textureUsageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT) || (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ) ||
(textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT)) { (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ)) {
imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCreateInfo.pNext = NULL; imageViewCreateInfo.pNext = NULL;
@ -5775,7 +5775,7 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture(
texture->subresources[subresourceIndex].computeWriteView = VK_NULL_HANDLE; texture->subresources[subresourceIndex].computeWriteView = VK_NULL_HANDLE;
texture->subresources[subresourceIndex].depthStencilView = 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->subresources[subresourceIndex].renderTargetViews = SDL_malloc(
texture->depth * sizeof(VkImageView)); 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( VULKAN_INTERNAL_CreateSubresourceView(
renderer, renderer,
texture, texture,
@ -5810,7 +5810,7 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture(
&texture->subresources[subresourceIndex].computeWriteView); &texture->subresources[subresourceIndex].computeWriteView);
} }
if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT) { if (textureUsageFlags & SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET) {
VULKAN_INTERNAL_CreateSubresourceView( VULKAN_INTERNAL_CreateSubresourceView(
renderer, renderer,
texture, texture,
@ -5843,7 +5843,7 @@ static VulkanTexture *VULKAN_INTERNAL_CreateTexture(
texture->format, texture->format,
texture->swizzle, texture->swizzle,
aspectMask, aspectMask,
SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT, SDL_GPU_TEXTUREUSAGE_COLOR_TARGET,
true); true);
} }
} }
@ -7787,7 +7787,7 @@ static void VULKAN_BeginRenderPass(
} }
// FIXME: validate this in gpu.c // 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!"); SDL_LogError(SDL_LOG_CATEGORY_GPU, "Color attachment texture was not designated as a target!");
return; return;
} }
@ -7810,7 +7810,7 @@ static void VULKAN_BeginRenderPass(
} }
// FIXME: validate this in gpu.c // 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!"); SDL_LogError(SDL_LOG_CATEGORY_GPU, "Depth stencil attachment texture was not designated as a target!");
return; return;
} }
@ -8162,7 +8162,7 @@ static void VULKAN_BeginComputePass(
for (i = 0; i < storageTextureBindingCount; i += 1) { for (i = 0; i < storageTextureBindingCount; i += 1) {
VulkanTextureContainer *textureContainer = (VulkanTextureContainer *)storageTextureBindings[i].texture; 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"); 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; VkImageFormatProperties properties;
VkResult vulkanResult; VkResult vulkanResult;
if (usage & SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT) { if (usage & SDL_GPU_TEXTUREUSAGE_SAMPLER) {
vulkanUsage |= VK_IMAGE_USAGE_SAMPLED_BIT; 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; 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; vulkanUsage |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
} }
if (usage & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ_BIT | if (usage & (SDL_GPU_TEXTUREUSAGE_GRAPHICS_STORAGE_READ |
SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ_BIT | SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_READ |
SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE_BIT)) { SDL_GPU_TEXTUREUSAGE_COMPUTE_STORAGE_WRITE)) {
vulkanUsage |= VK_IMAGE_USAGE_STORAGE_BIT; vulkanUsage |= VK_IMAGE_USAGE_STORAGE_BIT;
} }

8
src/render/sdlgpu/SDL_render_gpu.c
View file

@ -173,7 +173,7 @@ static bool GPU_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_
GPU_RenderData *renderdata = (GPU_RenderData *)renderer->internal; GPU_RenderData *renderdata = (GPU_RenderData *)renderer->internal;
GPU_TextureData *data; GPU_TextureData *data;
SDL_GPUTextureFormat format; SDL_GPUTextureFormat format;
SDL_GPUTextureUsageFlags usage = SDL_GPU_TEXTUREUSAGE_SAMPLER_BIT; SDL_GPUTextureUsageFlags usage = SDL_GPU_TEXTUREUSAGE_SAMPLER;
format = PixFormatToTexFormat(texture->format); 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) { if (texture->access == SDL_TEXTUREACCESS_TARGET) {
usage |= SDL_GPU_TEXTUREUSAGE_COLOR_TARGET_BIT; usage |= SDL_GPU_TEXTUREUSAGE_COLOR_TARGET;
} }
texture->internal = data; texture->internal = data;
@ -603,7 +603,7 @@ static bool InitVertexBuffer(GPU_RenderData *data, Uint32 size)
SDL_GPUBufferCreateInfo bci; SDL_GPUBufferCreateInfo bci;
SDL_zero(bci); SDL_zero(bci);
bci.sizeInBytes = size; bci.sizeInBytes = size;
bci.usageFlags = SDL_GPU_BUFFERUSAGE_VERTEX_BIT; bci.usageFlags = SDL_GPU_BUFFERUSAGE_VERTEX;
data->vertices.buffer = SDL_CreateGPUBuffer(data->device, &bci); 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.layerCountOrDepth = 1;
tci.levelCount = 1; tci.levelCount = 1;
tci.sampleCount = SDL_GPU_SAMPLECOUNT_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.texture = SDL_CreateGPUTexture(data->device, &tci);
data->backbuffer.width = w; data->backbuffer.width = w;

6
test/testgpu_spinning_cube.c
View file

@ -259,7 +259,7 @@ CreateDepthTexture(Uint32 drawablew, Uint32 drawableh)
depthtex_createinfo.layerCountOrDepth = 1; depthtex_createinfo.layerCountOrDepth = 1;
depthtex_createinfo.levelCount = 1; depthtex_createinfo.levelCount = 1;
depthtex_createinfo.sampleCount = render_state.sample_count; 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; depthtex_createinfo.props = 0;
result = SDL_CreateGPUTexture(gpu_device, &depthtex_createinfo); result = SDL_CreateGPUTexture(gpu_device, &depthtex_createinfo);
@ -285,7 +285,7 @@ CreateMSAATexture(Uint32 drawablew, Uint32 drawableh)
msaatex_createinfo.layerCountOrDepth = 1; msaatex_createinfo.layerCountOrDepth = 1;
msaatex_createinfo.levelCount = 1; msaatex_createinfo.levelCount = 1;
msaatex_createinfo.sampleCount = render_state.sample_count; 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; msaatex_createinfo.props = 0;
result = SDL_CreateGPUTexture(gpu_device, &msaatex_createinfo); result = SDL_CreateGPUTexture(gpu_device, &msaatex_createinfo);
@ -492,7 +492,7 @@ init_render_state(int msaa)
/* Create buffers */ /* 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.sizeInBytes = sizeof(vertex_data);
buffer_desc.props = 0; buffer_desc.props = 0;
render_state.buf_vertex = SDL_CreateGPUBuffer( render_state.buf_vertex = SDL_CreateGPUBuffer(