MoonsideGames
/
Refresh
1
0
Fork 1
Code Issues 1 Pull Requests 2 Projects Releases 33 Wiki Activity

remove distinction between color target and depth target
continuous-integration/drone/push Build is passing Details

pull/1/head
cosmonaut 2021-01-26 18:57:46 -08:00
parent 81ca5371a5
commit 316e662f44
4 changed files with 216 additions and 392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
include/Refresh.h
View File

@ -64,8 +64,7 @@ typedef struct Refresh_Device Refresh_Device;
typedef struct Refresh_Buffer Refresh_Buffer; typedef struct Refresh_Buffer Refresh_Buffer;
typedef struct Refresh_Texture Refresh_Texture; typedef struct Refresh_Texture Refresh_Texture;
typedef struct Refresh_Sampler Refresh_Sampler; typedef struct Refresh_Sampler Refresh_Sampler;
typedef struct Refresh_ColorTarget Refresh_ColorTarget; typedef struct Refresh_RenderTarget Refresh_RenderTarget;
typedef struct Refresh_DepthStencilTarget Refresh_DepthStencilTarget;
typedef struct Refresh_Framebuffer Refresh_Framebuffer; typedef struct Refresh_Framebuffer Refresh_Framebuffer;
typedef struct Refresh_ShaderModule Refresh_ShaderModule; typedef struct Refresh_ShaderModule Refresh_ShaderModule;
typedef struct Refresh_RenderPass Refresh_RenderPass; typedef struct Refresh_RenderPass Refresh_RenderPass;
@ -118,41 +117,40 @@ typedef enum Refresh_IndexElementSize
REFRESH_INDEXELEMENTSIZE_32BIT REFRESH_INDEXELEMENTSIZE_32BIT
} Refresh_IndexElementSize; } Refresh_IndexElementSize;
typedef enum Refresh_ColorFormat typedef enum Refresh_TextureFormat
{ {
REFRESH_COLORFORMAT_R8G8B8A8, /* Color Formats */
REFRESH_COLORFORMAT_R5G6B5, REFRESH_TEXTUREFORMAT_R8G8B8A8,
REFRESH_COLORFORMAT_A1R5G5B5, REFRESH_TEXTUREFORMAT_R5G6B5,
REFRESH_COLORFORMAT_B4G4R4A4, REFRESH_TEXTUREFORMAT_A1R5G5B5,
REFRESH_COLORFORMAT_BC1, REFRESH_TEXTUREFORMAT_B4G4R4A4,
REFRESH_COLORFORMAT_BC2, REFRESH_TEXTUREFORMAT_BC1,
REFRESH_COLORFORMAT_BC3, REFRESH_TEXTUREFORMAT_BC2,
REFRESH_COLORFORMAT_R8G8_SNORM, REFRESH_TEXTUREFORMAT_BC3,
REFRESH_COLORFORMAT_R8G8B8A8_SNORM, REFRESH_TEXTUREFORMAT_R8G8_SNORM,
REFRESH_COLORFORMAT_A2R10G10B10, REFRESH_TEXTUREFORMAT_R8G8B8A8_SNORM,
REFRESH_COLORFORMAT_R16G16, REFRESH_TEXTUREFORMAT_A2R10G10B10,
REFRESH_COLORFORMAT_R16G16B16A16, REFRESH_TEXTUREFORMAT_R16G16,
REFRESH_COLORFORMAT_R8, REFRESH_TEXTUREFORMAT_R16G16B16A16,
REFRESH_COLORFORMAT_R32_SFLOAT, REFRESH_TEXTUREFORMAT_R8,
REFRESH_COLORFORMAT_R32G32_SFLOAT, REFRESH_TEXTUREFORMAT_R32_SFLOAT,
REFRESH_COLORFORMAT_R32G32B32A32_SFLOAT, REFRESH_TEXTUREFORMAT_R32G32_SFLOAT,
REFRESH_COLORFORMAT_R16_SFLOAT, REFRESH_TEXTUREFORMAT_R32G32B32A32_SFLOAT,
REFRESH_COLORFORMAT_R16G16_SFLOAT, REFRESH_TEXTUREFORMAT_R16_SFLOAT,
REFRESH_COLORFORMAT_R16G16B16A16_SFLOAT REFRESH_TEXTUREFORMAT_R16G16_SFLOAT,
} Refresh_ColorFormat; REFRESH_TEXTUREFORMAT_R16G16B16A16_SFLOAT,
/* Depth Formats */
typedef enum Refresh_DepthFormat REFRESH_TEXTUREFORMAT_D16_UNORM,
{ REFRESH_TEXTUREFORMAT_D32_SFLOAT,
REFRESH_DEPTHFORMAT_D16_UNORM, REFRESH_TEXTUREFORMAT_D16_UNORM_S8_UINT,
REFRESH_DEPTHFORMAT_D32_SFLOAT, REFRESH_TEXTUREFORMAT_D32_SFLOAT_S8_UINT
REFRESH_DEPTHFORMAT_D16_UNORM_S8_UINT, } Refresh_TextureFormat;
REFRESH_DEPTHFORMAT_D32_SFLOAT_S8_UINT
} Refresh_DepthFormat;
typedef enum Refresh_TextureUsageFlagBits typedef enum Refresh_TextureUsageFlagBits
{ {
REFRESH_TEXTUREUSAGE_SAMPLER_BIT = 0x00000001, REFRESH_TEXTUREUSAGE_SAMPLER_BIT = 0x00000001,
REFRESH_TEXTUREUSAGE_COLOR_TARGET_BIT = 0x00000002 REFRESH_TEXTUREUSAGE_COLOR_TARGET_BIT = 0x00000002,
REFRESH_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT = 0x00000004
} Refresh_TextureUsageFlagBits; } Refresh_TextureUsageFlagBits;
typedef uint32_t Refresh_TextureUsageFlags; typedef uint32_t Refresh_TextureUsageFlags;
@ -491,7 +489,7 @@ typedef struct Refresh_GraphicsPipelineLayoutCreateInfo
typedef struct Refresh_ColorTargetDescription typedef struct Refresh_ColorTargetDescription
{ {
Refresh_ColorFormat format; Refresh_TextureFormat format;
Refresh_SampleCount multisampleCount; Refresh_SampleCount multisampleCount;
Refresh_LoadOp loadOp; Refresh_LoadOp loadOp;
Refresh_StoreOp storeOp; Refresh_StoreOp storeOp;
@ -499,7 +497,7 @@ typedef struct Refresh_ColorTargetDescription
typedef struct Refresh_DepthStencilTargetDescription typedef struct Refresh_DepthStencilTargetDescription
{ {
Refresh_DepthFormat depthFormat; Refresh_TextureFormat depthStencilFormat;
Refresh_LoadOp loadOp; Refresh_LoadOp loadOp;
Refresh_StoreOp storeOp; Refresh_StoreOp storeOp;
Refresh_LoadOp stencilLoadOp; Refresh_LoadOp stencilLoadOp;
@ -527,7 +525,7 @@ typedef struct Refresh_TextureCreateInfo
uint8_t isCube; uint8_t isCube;
Refresh_SampleCount sampleCount; Refresh_SampleCount sampleCount;
uint32_t levelCount; uint32_t levelCount;
Refresh_ColorFormat format; Refresh_TextureFormat format;
Refresh_TextureUsageFlags usageFlags; Refresh_TextureUsageFlags usageFlags;
} Refresh_TextureCreateInfo; } Refresh_TextureCreateInfo;
@ -613,9 +611,9 @@ typedef struct Refresh_GraphicsPipelineCreateInfo
typedef struct Refresh_FramebufferCreateInfo typedef struct Refresh_FramebufferCreateInfo
{ {
Refresh_RenderPass *renderPass; Refresh_RenderPass *renderPass;
Refresh_ColorTarget **pColorTargets; Refresh_RenderTarget **pColorTargets;
uint32_t colorTargetCount; uint32_t colorTargetCount;
Refresh_DepthStencilTarget *pDepthStencilTarget; Refresh_RenderTarget *pDepthStencilTarget;
uint32_t width; uint32_t width;
uint32_t height; uint32_t height;
} Refresh_FramebufferCreateInfo; } Refresh_FramebufferCreateInfo;
@ -876,26 +874,13 @@ REFRESHAPI Refresh_Texture* Refresh_CreateTexture(
/* Creates a color target. /* Creates a color target.
* *
* multisampleCount: The MSAA value for the color target.
* textureSlice: The texture slice that the color target will resolve to. * textureSlice: The texture slice that the color target will resolve to.
* multisampleCount: The MSAA value for the color target.
*/ */
REFRESHAPI Refresh_ColorTarget* Refresh_CreateColorTarget( REFRESHAPI Refresh_RenderTarget* Refresh_CreateRenderTarget(
Refresh_Device *device, Refresh_Device *device,
Refresh_SampleCount multisampleCount, Refresh_TextureSlice *textureSlice,
Refresh_TextureSlice *textureSlice Refresh_SampleCount multisampleCount
);
/* Creates a depth/stencil target.
*
* width: The width of the depth/stencil target.
* height: The height of the depth/stencil target.
* format: The storage format of the depth/stencil target.
*/
REFRESHAPI Refresh_DepthStencilTarget* Refresh_CreateDepthStencilTarget(
Refresh_Device *device,
uint32_t width,
uint32_t height,
Refresh_DepthFormat format
); );
/* Creates a buffer. /* Creates a buffer.
@ -1108,23 +1093,11 @@ REFRESHAPI void Refresh_QueueDestroyBuffer(
* this is not called from the main thread (for example, if a garbage collector * this is not called from the main thread (for example, if a garbage collector
* deletes the resource instead of the programmer). * deletes the resource instead of the programmer).
* *
* colorTarget: The Refresh_ColorTarget to be destroyed. * renderTarget: The Refresh_ColorTarget to be destroyed.
*/ */
REFRESHAPI void Refresh_QueueDestroyColorTarget( REFRESHAPI void Refresh_QueueDestroyRenderTarget(
Refresh_Device *device, Refresh_Device *device,
Refresh_ColorTarget *colorTarget Refresh_RenderTarget *renderTarget
);
/* Sends a depth/stencil target to be destroyed by the renderer. Note that we call it
* "QueueDestroy" because it may not be immediately destroyed by the renderer if
* this is not called from the main thread (for example, if a garbage collector
* deletes the resource instead of the programmer).
*
* depthStencilTarget: The Refresh_DepthStencilTarget to be destroyed.
*/
REFRESHAPI void Refresh_QueueDestroyDepthStencilTarget(
Refresh_Device *device,
Refresh_DepthStencilTarget *depthStencilTarget
); );
/* Sends a framebuffer to be destroyed by the renderer. Note that we call it /* Sends a framebuffer to be destroyed by the renderer. Note that we call it

44
src/Refresh.c
View File

@ -347,31 +347,16 @@ Refresh_Texture* Refresh_CreateTexture(
); );
} }
Refresh_ColorTarget* Refresh_CreateColorTarget( Refresh_RenderTarget* Refresh_CreateColorTarget(
Refresh_Device *device, Refresh_Device *device,
Refresh_SampleCount multisampleCount, Refresh_TextureSlice *textureSlice,
Refresh_TextureSlice *textureSlice Refresh_SampleCount multisampleCount
) { ) {
NULL_RETURN_NULL(device); NULL_RETURN_NULL(device);
return device->CreateColorTarget( return device->CreateRenderTarget(
device->driverData, device->driverData,
multisampleCount, textureSlice,
textureSlice multisampleCount
);
}
Refresh_DepthStencilTarget* Refresh_CreateDepthStencilTarget(
Refresh_Device *device,
uint32_t width,
uint32_t height,
Refresh_DepthFormat format
) {
NULL_RETURN_NULL(device);
return device->CreateDepthStencilTarget(
device->driverData,
width,
height,
format
); );
} }
@ -604,23 +589,12 @@ void Refresh_QueueDestroyBuffer(
void Refresh_QueueDestroyColorTarget( void Refresh_QueueDestroyColorTarget(
Refresh_Device *device, Refresh_Device *device,
Refresh_ColorTarget *colorTarget Refresh_RenderTarget *renderTarget
) { ) {
NULL_RETURN(device); NULL_RETURN(device);
device->QueueDestroyColorTarget( device->QueueDestroyRenderTarget(
device->driverData, device->driverData,
colorTarget renderTarget
);
}
void Refresh_QueueDestroyDepthStencilTarget(
Refresh_Device *device,
Refresh_DepthStencilTarget *depthStencilTarget
) {
NULL_RETURN(device);
device->QueueDestroyDepthStencilTarget(
device->driverData,
depthStencilTarget
); );
} }

82
src/Refresh_Driver.h
View File

@ -43,34 +43,34 @@ extern void Refresh_LogError(const char *fmt, ...);
/* Internal Helper Utilities */ /* Internal Helper Utilities */
static inline uint32_t Texture_GetFormatSize( static inline uint32_t Texture_GetFormatSize(
Refresh_ColorFormat format Refresh_TextureFormat format
) { ) {
switch (format) switch (format)
{ {
case REFRESH_COLORFORMAT_BC1: case REFRESH_TEXTUREFORMAT_BC1:
return 8; return 8;
case REFRESH_COLORFORMAT_BC2: case REFRESH_TEXTUREFORMAT_BC2:
case REFRESH_COLORFORMAT_BC3: case REFRESH_TEXTUREFORMAT_BC3:
return 16; return 16;
case REFRESH_COLORFORMAT_R8: case REFRESH_TEXTUREFORMAT_R8:
return 1; return 1;
case REFRESH_COLORFORMAT_R5G6B5: case REFRESH_TEXTUREFORMAT_R5G6B5:
case REFRESH_COLORFORMAT_B4G4R4A4: case REFRESH_TEXTUREFORMAT_B4G4R4A4:
case REFRESH_COLORFORMAT_A1R5G5B5: case REFRESH_TEXTUREFORMAT_A1R5G5B5:
case REFRESH_COLORFORMAT_R16_SFLOAT: case REFRESH_TEXTUREFORMAT_R16_SFLOAT:
case REFRESH_COLORFORMAT_R8G8_SNORM: case REFRESH_TEXTUREFORMAT_R8G8_SNORM:
return 2; return 2;
case REFRESH_COLORFORMAT_R8G8B8A8: case REFRESH_TEXTUREFORMAT_R8G8B8A8:
case REFRESH_COLORFORMAT_R32_SFLOAT: case REFRESH_TEXTUREFORMAT_R32_SFLOAT:
case REFRESH_COLORFORMAT_R16G16_SFLOAT: case REFRESH_TEXTUREFORMAT_R16G16_SFLOAT:
case REFRESH_COLORFORMAT_R8G8B8A8_SNORM: case REFRESH_TEXTUREFORMAT_R8G8B8A8_SNORM:
case REFRESH_COLORFORMAT_A2R10G10B10: case REFRESH_TEXTUREFORMAT_A2R10G10B10:
return 4; return 4;
case REFRESH_COLORFORMAT_R16G16B16A16_SFLOAT: case REFRESH_TEXTUREFORMAT_R16G16B16A16_SFLOAT:
case REFRESH_COLORFORMAT_R16G16B16A16: case REFRESH_TEXTUREFORMAT_R16G16B16A16:
case REFRESH_COLORFORMAT_R32G32_SFLOAT: case REFRESH_TEXTUREFORMAT_R32G32_SFLOAT:
return 8; return 8;
case REFRESH_COLORFORMAT_R32G32B32A32_SFLOAT: case REFRESH_TEXTUREFORMAT_R32G32B32A32_SFLOAT:
return 16; return 16;
default: default:
Refresh_LogError( Refresh_LogError(
@ -111,13 +111,13 @@ static inline uint32_t IndexSize(Refresh_IndexElementSize size)
static inline uint32_t BytesPerRow( static inline uint32_t BytesPerRow(
int32_t width, int32_t width,
Refresh_ColorFormat format Refresh_TextureFormat format
) { ) {
uint32_t blocksPerRow = width; uint32_t blocksPerRow = width;
if ( format == REFRESH_COLORFORMAT_BC1 || if ( format == REFRESH_TEXTUREFORMAT_BC1 ||
format == REFRESH_COLORFORMAT_BC2 || format == REFRESH_TEXTUREFORMAT_BC2 ||
format == REFRESH_COLORFORMAT_BC3 ) format == REFRESH_TEXTUREFORMAT_BC3 )
{ {
blocksPerRow = (width + 3) / 4; blocksPerRow = (width + 3) / 4;
} }
@ -128,14 +128,14 @@ static inline uint32_t BytesPerRow(
static inline int32_t BytesPerImage( static inline int32_t BytesPerImage(
uint32_t width, uint32_t width,
uint32_t height, uint32_t height,
Refresh_ColorFormat format Refresh_TextureFormat format
) { ) {
uint32_t blocksPerRow = width; uint32_t blocksPerRow = width;
uint32_t blocksPerColumn = height; uint32_t blocksPerColumn = height;
if ( format == REFRESH_COLORFORMAT_BC1 || if ( format == REFRESH_TEXTUREFORMAT_BC1 ||
format == REFRESH_COLORFORMAT_BC2 || format == REFRESH_TEXTUREFORMAT_BC2 ||
format == REFRESH_COLORFORMAT_BC3 ) format == REFRESH_TEXTUREFORMAT_BC3 )
{ {
blocksPerRow = (width + 3) / 4; blocksPerRow = (width + 3) / 4;
blocksPerColumn = (height + 3) / 4; blocksPerColumn = (height + 3) / 4;
@ -253,17 +253,10 @@ struct Refresh_Device
Refresh_TextureCreateInfo *textureCreateInfo Refresh_TextureCreateInfo *textureCreateInfo
); );
Refresh_ColorTarget* (*CreateColorTarget)( Refresh_RenderTarget* (*CreateRenderTarget)(
Refresh_Renderer *driverData, Refresh_Renderer *driverData,
Refresh_SampleCount multisampleCount, Refresh_TextureSlice *textureSlice,
Refresh_TextureSlice *textureSlice Refresh_SampleCount multisampleCount
);
Refresh_DepthStencilTarget* (*CreateDepthStencilTarget)(
Refresh_Renderer *driverData,
uint32_t width,
uint32_t height,
Refresh_DepthFormat format
); );
Refresh_Buffer* (*CreateBuffer)( Refresh_Buffer* (*CreateBuffer)(
@ -378,14 +371,9 @@ struct Refresh_Device
Refresh_Buffer *buffer Refresh_Buffer *buffer
); );
void(*QueueDestroyColorTarget)( void(*QueueDestroyRenderTarget)(
Refresh_Renderer *driverData, Refresh_Renderer *driverData,
Refresh_ColorTarget *colorTarget Refresh_RenderTarget *renderTarget
);
void(*QueueDestroyDepthStencilTarget)(
Refresh_Renderer *driverData,
Refresh_DepthStencilTarget *depthStencilTarget
); );
void(*QueueDestroyFramebuffer)( void(*QueueDestroyFramebuffer)(
@ -521,8 +509,7 @@ struct Refresh_Device
ASSIGN_DRIVER_FUNC(CreateFramebuffer, name) \ ASSIGN_DRIVER_FUNC(CreateFramebuffer, name) \
ASSIGN_DRIVER_FUNC(CreateShaderModule, name) \ ASSIGN_DRIVER_FUNC(CreateShaderModule, name) \
ASSIGN_DRIVER_FUNC(CreateTexture, name) \ ASSIGN_DRIVER_FUNC(CreateTexture, name) \
ASSIGN_DRIVER_FUNC(CreateColorTarget, name) \ ASSIGN_DRIVER_FUNC(CreateRenderTarget, name) \
ASSIGN_DRIVER_FUNC(CreateDepthStencilTarget, name) \
ASSIGN_DRIVER_FUNC(CreateBuffer, name) \ ASSIGN_DRIVER_FUNC(CreateBuffer, name) \
ASSIGN_DRIVER_FUNC(SetTextureData, name) \ ASSIGN_DRIVER_FUNC(SetTextureData, name) \
ASSIGN_DRIVER_FUNC(SetTextureDataYUV, name) \ ASSIGN_DRIVER_FUNC(SetTextureDataYUV, name) \
@ -538,8 +525,7 @@ struct Refresh_Device
ASSIGN_DRIVER_FUNC(QueueDestroyTexture, name) \ ASSIGN_DRIVER_FUNC(QueueDestroyTexture, name) \
ASSIGN_DRIVER_FUNC(QueueDestroySampler, name) \ ASSIGN_DRIVER_FUNC(QueueDestroySampler, name) \
ASSIGN_DRIVER_FUNC(QueueDestroyBuffer, name) \ ASSIGN_DRIVER_FUNC(QueueDestroyBuffer, name) \
ASSIGN_DRIVER_FUNC(QueueDestroyColorTarget, name) \ ASSIGN_DRIVER_FUNC(QueueDestroyRenderTarget, name) \
ASSIGN_DRIVER_FUNC(QueueDestroyDepthStencilTarget, name) \
ASSIGN_DRIVER_FUNC(QueueDestroyFramebuffer, name) \ ASSIGN_DRIVER_FUNC(QueueDestroyFramebuffer, name) \
ASSIGN_DRIVER_FUNC(QueueDestroyShaderModule, name) \ ASSIGN_DRIVER_FUNC(QueueDestroyShaderModule, name) \
ASSIGN_DRIVER_FUNC(QueueDestroyRenderPass, name) \ ASSIGN_DRIVER_FUNC(QueueDestroyRenderPass, name) \

369
src/Refresh_Driver_Vulkan.c
View File

@ -758,38 +758,27 @@ typedef struct VulkanTexture
uint32_t layerCount; uint32_t layerCount;
uint32_t levelCount; uint32_t levelCount;
VkFormat format; VkFormat format;
Refresh_ColorFormat refreshFormat; Refresh_TextureFormat refreshFormat;
VulkanResourceAccessType resourceAccessType; VulkanResourceAccessType resourceAccessType;
uint32_t queueFamilyIndex; uint32_t queueFamilyIndex;
Refresh_TextureUsageFlags usageFlags; VkImageUsageFlags usageFlags;
REFRESHNAMELESS union
{
Refresh_ColorFormat colorFormat;
Refresh_DepthFormat depthStencilFormat;
};
} VulkanTexture; } VulkanTexture;
typedef struct VulkanColorTarget typedef struct VulkanRenderTarget
{ {
VulkanTexture *texture; VulkanTexture *texture;
uint32_t layer; uint32_t layer;
VkImageView view; VkImageView view;
VulkanTexture *multisampleTexture; VulkanTexture *multisampleTexture;
VkSampleCountFlags multisampleCount; VkSampleCountFlags multisampleCount;
} VulkanColorTarget; } VulkanRenderTarget;
typedef struct VulkanDepthStencilTarget
{
VulkanTexture *texture;
VkImageView view;
} VulkanDepthStencilTarget;
typedef struct VulkanFramebuffer typedef struct VulkanFramebuffer
{ {
VkFramebuffer framebuffer; VkFramebuffer framebuffer;
VulkanColorTarget *colorTargets[MAX_COLOR_TARGET_BINDINGS]; VulkanRenderTarget *colorTargets[MAX_COLOR_TARGET_BINDINGS];
uint32_t colorTargetCount; uint32_t colorTargetCount;
VulkanDepthStencilTarget *depthStencilTarget; VulkanRenderTarget *depthStencilTarget;
uint32_t width; uint32_t width;
uint32_t height; uint32_t height;
} VulkanFramebuffer; } VulkanFramebuffer;
@ -1367,21 +1356,13 @@ typedef struct VulkanRenderer
/* Deferred destroy storage */ /* Deferred destroy storage */
VulkanColorTarget **colorTargetsToDestroy; VulkanRenderTarget **renderTargetsToDestroy;
uint32_t colorTargetsToDestroyCount; uint32_t renderTargetsToDestroyCount;
uint32_t colorTargetsToDestroyCapacity; uint32_t renderTargetsToDestroyCapacity;
VulkanColorTarget **submittedColorTargetsToDestroy; VulkanRenderTarget **submittedRenderTargetsToDestroy;
uint32_t submittedColorTargetsToDestroyCount; uint32_t submittedRenderTargetsToDestroyCount;
uint32_t submittedColorTargetsToDestroyCapacity; uint32_t submittedRenderTargetsToDestroyCapacity;
VulkanDepthStencilTarget **depthStencilTargetsToDestroy;
uint32_t depthStencilTargetsToDestroyCount;
uint32_t depthStencilTargetsToDestroyCapacity;
VulkanDepthStencilTarget **submittedDepthStencilTargetsToDestroy;
uint32_t submittedDepthStencilTargetsToDestroyCount;
uint32_t submittedDepthStencilTargetsToDestroyCapacity;
VulkanTexture **texturesToDestroy; VulkanTexture **texturesToDestroy;
uint32_t texturesToDestroyCount; uint32_t texturesToDestroyCount;
@ -1508,19 +1489,30 @@ static inline void LogVulkanResult(
/* Utility */ /* Utility */
static inline uint8_t DepthFormatContainsStencil(VkFormat format) static inline uint8_t IsDepthFormat(Refresh_TextureFormat format)
{ {
switch(format) switch(format)
{ {
case VK_FORMAT_D16_UNORM: case REFRESH_TEXTUREFORMAT_D16_UNORM:
case VK_FORMAT_D32_SFLOAT: case REFRESH_TEXTUREFORMAT_D32_SFLOAT:
return 0; case REFRESH_TEXTUREFORMAT_D16_UNORM_S8_UINT:
case VK_FORMAT_D16_UNORM_S8_UINT: case REFRESH_TEXTUREFORMAT_D32_SFLOAT_S8_UINT:
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
return 1; return 1;
default:
return 0;
}
}
static inline uint8_t IsStencilFormat(Refresh_TextureFormat format)
{
switch(format)
{
case REFRESH_TEXTUREFORMAT_D16_UNORM_S8_UINT:
case REFRESH_TEXTUREFORMAT_D32_SFLOAT_S8_UINT:
return 1;
default: default:
SDL_assert(0 && "Invalid depth format");
return 0; return 0;
} }
} }
@ -2223,9 +2215,9 @@ static void VULKAN_INTERNAL_DestroyTexture(
SDL_free(texture); SDL_free(texture);
} }
static void VULKAN_INTERNAL_DestroyColorTarget( static void VULKAN_INTERNAL_DestroyRenderTarget(
VulkanRenderer *renderer, VulkanRenderer *renderer,
VulkanColorTarget *colorTarget VulkanRenderTarget *colorTarget
) { ) {
renderer->vkDestroyImageView( renderer->vkDestroyImageView(
renderer->logicalDevice, renderer->logicalDevice,
@ -2248,14 +2240,6 @@ static void VULKAN_INTERNAL_DestroyColorTarget(
SDL_free(colorTarget); SDL_free(colorTarget);
} }
static void VULKAN_INTERNAL_DestroyDepthStencilTarget(
VulkanRenderer *renderer,
VulkanDepthStencilTarget *depthStencilTarget
) {
VULKAN_INTERNAL_DestroyTexture(renderer, depthStencilTarget->texture);
SDL_free(depthStencilTarget);
}
static void VULKAN_INTERNAL_DestroyBuffer( static void VULKAN_INTERNAL_DestroyBuffer(
VulkanRenderer* renderer, VulkanRenderer* renderer,
VulkanBuffer* buffer VulkanBuffer* buffer
@ -2523,23 +2507,14 @@ static void VULKAN_INTERNAL_PostWorkCleanup(VulkanRenderer* renderer)
SDL_LockMutex(renderer->disposeLock); SDL_LockMutex(renderer->disposeLock);
for (i = 0; i < renderer->submittedColorTargetsToDestroyCount; i += 1) for (i = 0; i < renderer->submittedRenderTargetsToDestroyCount; i += 1)
{ {
VULKAN_INTERNAL_DestroyColorTarget( VULKAN_INTERNAL_DestroyRenderTarget(
renderer, renderer,
renderer->submittedColorTargetsToDestroy[i] renderer->submittedRenderTargetsToDestroy[i]
); );
} }
renderer->submittedColorTargetsToDestroyCount = 0; renderer->submittedRenderTargetsToDestroyCount = 0;
for (i = 0; i < renderer->submittedDepthStencilTargetsToDestroyCount; i += 1)
{
VULKAN_INTERNAL_DestroyDepthStencilTarget(
renderer,
renderer->submittedDepthStencilTargetsToDestroy[i]
);
}
renderer->submittedDepthStencilTargetsToDestroyCount = 0;
for (i = 0; i < renderer->submittedTexturesToDestroyCount; i += 1) for (i = 0; i < renderer->submittedTexturesToDestroyCount; i += 1)
{ {
@ -2616,19 +2591,11 @@ static void VULKAN_INTERNAL_PostWorkCleanup(VulkanRenderer* renderer)
/* Re-size submitted destroy lists */ /* Re-size submitted destroy lists */
EXPAND_ARRAY_IF_NEEDED( EXPAND_ARRAY_IF_NEEDED(
renderer->submittedColorTargetsToDestroy, renderer->submittedRenderTargetsToDestroy,
VulkanColorTarget*, VulkanRenderTarget*,
renderer->colorTargetsToDestroyCount, renderer->renderTargetsToDestroyCount,
renderer->submittedColorTargetsToDestroyCapacity, renderer->submittedRenderTargetsToDestroyCapacity,
renderer->colorTargetsToDestroyCount renderer->renderTargetsToDestroyCount
)
EXPAND_ARRAY_IF_NEEDED(
renderer->submittedDepthStencilTargetsToDestroy,
VulkanDepthStencilTarget*,
renderer->depthStencilTargetsToDestroyCount,
renderer->submittedDepthStencilTargetsToDestroyCapacity,
renderer->depthStencilTargetsToDestroyCount
) )
EXPAND_ARRAY_IF_NEEDED( EXPAND_ARRAY_IF_NEEDED(
@ -2699,18 +2666,10 @@ static void VULKAN_INTERNAL_PostWorkCleanup(VulkanRenderer* renderer)
MOVE_ARRAY_CONTENTS_AND_RESET( MOVE_ARRAY_CONTENTS_AND_RESET(
i, i,
renderer->submittedColorTargetsToDestroy, renderer->submittedRenderTargetsToDestroy,
renderer->submittedColorTargetsToDestroyCount, renderer->submittedRenderTargetsToDestroyCount,
renderer->colorTargetsToDestroy, renderer->renderTargetsToDestroy,
renderer->colorTargetsToDestroyCount renderer->renderTargetsToDestroyCount
)
MOVE_ARRAY_CONTENTS_AND_RESET(
i,
renderer->submittedDepthStencilTargetsToDestroy,
renderer->submittedDepthStencilTargetsToDestroyCount,
renderer->depthStencilTargetsToDestroy,
renderer->depthStencilTargetsToDestroyCount
) )
MOVE_ARRAY_CONTENTS_AND_RESET( MOVE_ARRAY_CONTENTS_AND_RESET(
@ -4127,7 +4086,7 @@ static Refresh_RenderPass* VULKAN_CreateRenderPass(
{ {
attachmentDescriptions[attachmentDescriptionCount].flags = 0; attachmentDescriptions[attachmentDescriptionCount].flags = 0;
attachmentDescriptions[attachmentDescriptionCount].format = RefreshToVK_DepthFormat[ attachmentDescriptions[attachmentDescriptionCount].format = RefreshToVK_DepthFormat[
renderPassCreateInfo->depthTargetDescription->depthFormat renderPassCreateInfo->depthTargetDescription->depthStencilFormat
]; ];
attachmentDescriptions[attachmentDescriptionCount].samples = attachmentDescriptions[attachmentDescriptionCount].samples =
VK_SAMPLE_COUNT_1_BIT; /* FIXME: do these take multisamples? */ VK_SAMPLE_COUNT_1_BIT; /* FIXME: do these take multisamples? */
@ -5326,12 +5285,12 @@ static Refresh_Framebuffer* VULKAN_CreateFramebuffer(
for (i = 0; i < colorAttachmentCount; i += 1) for (i = 0; i < colorAttachmentCount; i += 1)
{ {
imageViews[i] = ((VulkanColorTarget*)framebufferCreateInfo->pColorTargets[i])->view; imageViews[i] = ((VulkanRenderTarget*)framebufferCreateInfo->pColorTargets[i])->view;
} }
if (framebufferCreateInfo->pDepthStencilTarget != NULL) if (framebufferCreateInfo->pDepthStencilTarget != NULL)
{ {
imageViews[colorAttachmentCount] = ((VulkanDepthStencilTarget*)framebufferCreateInfo->pDepthStencilTarget)->view; imageViews[colorAttachmentCount] = ((VulkanRenderTarget*)framebufferCreateInfo->pDepthStencilTarget)->view;
} }
vkFramebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; vkFramebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
@ -5361,12 +5320,12 @@ static Refresh_Framebuffer* VULKAN_CreateFramebuffer(
for (i = 0; i < colorAttachmentCount; i += 1) for (i = 0; i < colorAttachmentCount; i += 1)
{ {
vulkanFramebuffer->colorTargets[i] = vulkanFramebuffer->colorTargets[i] =
(VulkanColorTarget*) framebufferCreateInfo->pColorTargets[i]; (VulkanRenderTarget*) framebufferCreateInfo->pColorTargets[i];
} }
vulkanFramebuffer->colorTargetCount = colorAttachmentCount; vulkanFramebuffer->colorTargetCount = colorAttachmentCount;
vulkanFramebuffer->depthStencilTarget = vulkanFramebuffer->depthStencilTarget =
(VulkanDepthStencilTarget*) framebufferCreateInfo->pDepthStencilTarget; (VulkanRenderTarget*) framebufferCreateInfo->pDepthStencilTarget;
vulkanFramebuffer->width = framebufferCreateInfo->width; vulkanFramebuffer->width = framebufferCreateInfo->width;
vulkanFramebuffer->height = framebufferCreateInfo->height; vulkanFramebuffer->height = framebufferCreateInfo->height;
@ -5421,7 +5380,6 @@ static uint8_t VULKAN_INTERNAL_CreateTexture(
VkImageTiling tiling, VkImageTiling tiling,
VkImageType imageType, VkImageType imageType,
VkImageUsageFlags imageUsageFlags, VkImageUsageFlags imageUsageFlags,
Refresh_TextureUsageFlags textureUsageFlags,
VulkanTexture *texture VulkanTexture *texture
) { ) {
VkResult vulkanResult; VkResult vulkanResult;
@ -5564,7 +5522,7 @@ static uint8_t VULKAN_INTERNAL_CreateTexture(
texture->layerCount = layerCount; texture->layerCount = layerCount;
texture->resourceAccessType = RESOURCE_ACCESS_NONE; texture->resourceAccessType = RESOURCE_ACCESS_NONE;
texture->queueFamilyIndex = renderer->queueFamilyIndices.graphicsFamily; texture->queueFamilyIndex = renderer->queueFamilyIndices.graphicsFamily;
texture->usageFlags = textureUsageFlags; texture->usageFlags = imageUsageFlags;
return 1; return 1;
} }
@ -5576,16 +5534,25 @@ static Refresh_Texture* VULKAN_CreateTexture(
VulkanRenderer *renderer = (VulkanRenderer*) driverData; VulkanRenderer *renderer = (VulkanRenderer*) driverData;
VulkanTexture *result; VulkanTexture *result;
VkImageUsageFlags imageUsageFlags = ( VkImageUsageFlags imageUsageFlags = (
VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT VK_IMAGE_USAGE_TRANSFER_SRC_BIT
); );
if (textureCreateInfo->usageFlags & REFRESH_TEXTUREUSAGE_SAMPLER_BIT)
{
imageUsageFlags |= VK_IMAGE_USAGE_SAMPLED_BIT;
}
if (textureCreateInfo->usageFlags & REFRESH_TEXTUREUSAGE_COLOR_TARGET_BIT) if (textureCreateInfo->usageFlags & REFRESH_TEXTUREUSAGE_COLOR_TARGET_BIT)
{ {
imageUsageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; imageUsageFlags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
} }
if (textureCreateInfo->usageFlags & REFRESH_TEXTUREUSAGE_DEPTH_STENCIL_TARGET_BIT)
{
imageUsageFlags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
}
result = (VulkanTexture*) SDL_malloc(sizeof(VulkanTexture)); result = (VulkanTexture*) SDL_malloc(sizeof(VulkanTexture));
VULKAN_INTERNAL_CreateTexture( VULKAN_INTERNAL_CreateTexture(
@ -5601,72 +5568,86 @@ static Refresh_Texture* VULKAN_CreateTexture(
VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_TYPE_2D, VK_IMAGE_TYPE_2D,
imageUsageFlags, imageUsageFlags,
textureCreateInfo->usageFlags,
result result
); );
result->colorFormat = textureCreateInfo->format; result->refreshFormat = textureCreateInfo->format;
return (Refresh_Texture*) result; return (Refresh_Texture*) result;
} }
static Refresh_ColorTarget* VULKAN_CreateColorTarget( static Refresh_RenderTarget* VULKAN_CreateRenderTarget(
Refresh_Renderer *driverData, Refresh_Renderer *driverData,
Refresh_SampleCount multisampleCount, Refresh_TextureSlice *textureSlice,
Refresh_TextureSlice *textureSlice Refresh_SampleCount multisampleCount
) { ) {
VkResult vulkanResult; VkResult vulkanResult;
VulkanRenderer *renderer = (VulkanRenderer*) driverData; VulkanRenderer *renderer = (VulkanRenderer*) driverData;
VulkanColorTarget *colorTarget = (VulkanColorTarget*) SDL_malloc(sizeof(VulkanColorTarget)); VulkanRenderTarget *renderTarget = (VulkanRenderTarget*) SDL_malloc(sizeof(VulkanRenderTarget));
VkImageViewCreateInfo imageViewCreateInfo; VkImageViewCreateInfo imageViewCreateInfo;
VkComponentMapping swizzle = IDENTITY_SWIZZLE; VkComponentMapping swizzle = IDENTITY_SWIZZLE;
VkImageAspectFlags aspectFlags = 0;
renderTarget->texture = (VulkanTexture*) textureSlice->texture;
renderTarget->layer = textureSlice->layer;
renderTarget->multisampleTexture = NULL;
renderTarget->multisampleCount = 1;
if (IsDepthFormat(renderTarget->texture->refreshFormat))
{
aspectFlags |= VK_IMAGE_ASPECT_DEPTH_BIT;
if (IsStencilFormat(renderTarget->texture->refreshFormat))
{
aspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
}
}
else
{
aspectFlags |= VK_IMAGE_ASPECT_COLOR_BIT;
}
colorTarget->texture = (VulkanTexture*) textureSlice->texture;
colorTarget->layer = textureSlice->layer;
colorTarget->multisampleTexture = NULL;
colorTarget->multisampleCount = 1;
/* create resolve target for multisample */ /* create resolve target for multisample */
if (multisampleCount > REFRESH_SAMPLECOUNT_1) if (multisampleCount > REFRESH_SAMPLECOUNT_1)
{ {
colorTarget->multisampleTexture = renderTarget->multisampleTexture =
(VulkanTexture*) SDL_malloc(sizeof(VulkanTexture)); (VulkanTexture*) SDL_malloc(sizeof(VulkanTexture));
VULKAN_INTERNAL_CreateTexture( VULKAN_INTERNAL_CreateTexture(
renderer, renderer,
colorTarget->texture->dimensions.width, renderTarget->texture->dimensions.width,
colorTarget->texture->dimensions.height, renderTarget->texture->dimensions.height,
1, 1,
0, 0,
RefreshToVK_SampleCount[multisampleCount], RefreshToVK_SampleCount[multisampleCount],
1, 1,
colorTarget->texture->format, renderTarget->texture->format,
VK_IMAGE_ASPECT_COLOR_BIT, aspectFlags,
VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_TYPE_2D, VK_IMAGE_TYPE_2D,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
REFRESH_TEXTUREUSAGE_COLOR_TARGET_BIT, renderTarget->multisampleTexture
colorTarget->multisampleTexture
); );
colorTarget->multisampleTexture->colorFormat = colorTarget->texture->colorFormat; renderTarget->multisampleTexture->refreshFormat = renderTarget->texture->refreshFormat;
colorTarget->multisampleCount = multisampleCount; renderTarget->multisampleCount = multisampleCount;
} }
/* create framebuffer compatible views for RenderTarget */ /* create framebuffer compatible views for RenderTarget */
imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCreateInfo.pNext = NULL; imageViewCreateInfo.pNext = NULL;
imageViewCreateInfo.flags = 0; imageViewCreateInfo.flags = 0;
imageViewCreateInfo.image = colorTarget->texture->image; imageViewCreateInfo.image = renderTarget->texture->image;
imageViewCreateInfo.format = colorTarget->texture->format; imageViewCreateInfo.format = renderTarget->texture->format;
imageViewCreateInfo.components = swizzle; imageViewCreateInfo.components = swizzle;
imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageViewCreateInfo.subresourceRange.baseMipLevel = 0; imageViewCreateInfo.subresourceRange.baseMipLevel = 0;
imageViewCreateInfo.subresourceRange.levelCount = 1; imageViewCreateInfo.subresourceRange.levelCount = 1;
imageViewCreateInfo.subresourceRange.baseArrayLayer = 0; imageViewCreateInfo.subresourceRange.baseArrayLayer = 0;
if (colorTarget->texture->is3D) if (renderTarget->texture->is3D)
{ {
imageViewCreateInfo.subresourceRange.baseArrayLayer = textureSlice->depth; imageViewCreateInfo.subresourceRange.baseArrayLayer = textureSlice->depth;
} }
else if (colorTarget->texture->isCube) else if (renderTarget->texture->isCube)
{ {
imageViewCreateInfo.subresourceRange.baseArrayLayer = textureSlice->layer; imageViewCreateInfo.subresourceRange.baseArrayLayer = textureSlice->layer;
} }
@ -5677,7 +5658,7 @@ static Refresh_ColorTarget* VULKAN_CreateColorTarget(
renderer->logicalDevice, renderer->logicalDevice,
&imageViewCreateInfo, &imageViewCreateInfo,
NULL, NULL,
&colorTarget->view &renderTarget->view
); );
if (vulkanResult != VK_SUCCESS) if (vulkanResult != VK_SUCCESS)
@ -5690,59 +5671,7 @@ static Refresh_ColorTarget* VULKAN_CreateColorTarget(
return NULL; return NULL;
} }
return (Refresh_ColorTarget*) colorTarget; return (Refresh_RenderTarget*) renderTarget;
}
static Refresh_DepthStencilTarget* VULKAN_CreateDepthStencilTarget(
Refresh_Renderer *driverData,
uint32_t width,
uint32_t height,
Refresh_DepthFormat format
) {
VulkanRenderer *renderer = (VulkanRenderer*) driverData;
VulkanDepthStencilTarget *depthStencilTarget =
(VulkanDepthStencilTarget*) SDL_malloc(
sizeof(VulkanDepthStencilTarget)
);
VulkanTexture *texture =
(VulkanTexture*) SDL_malloc(sizeof(VulkanTexture));
VkImageAspectFlags imageAspectFlags = VK_IMAGE_ASPECT_DEPTH_BIT;
VkImageUsageFlags imageUsageFlags =
VK_IMAGE_USAGE_SAMPLED_BIT |
VK_IMAGE_USAGE_TRANSFER_DST_BIT |
VK_IMAGE_USAGE_TRANSFER_SRC_BIT |
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
if (DepthFormatContainsStencil(RefreshToVK_DepthFormat[format]))
{
imageAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
}
VULKAN_INTERNAL_CreateTexture(
renderer,
width,
height,
1,
0,
VK_SAMPLE_COUNT_1_BIT,
1,
RefreshToVK_DepthFormat[format],
imageAspectFlags,
VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_TYPE_2D,
imageUsageFlags,
0,
texture
);
texture->depthStencilFormat = format;
depthStencilTarget->texture = texture;
depthStencilTarget->view = texture->view;
return (Refresh_DepthStencilTarget*) depthStencilTarget;
} }
static Refresh_Buffer* VULKAN_CreateBuffer( static Refresh_Buffer* VULKAN_CreateBuffer(
@ -5998,7 +5927,7 @@ static void VULKAN_SetTextureData(
renderer->textureStagingBufferOffset += dataLengthInBytes; renderer->textureStagingBufferOffset += dataLengthInBytes;
if (vulkanTexture->usageFlags & REFRESH_TEXTUREUSAGE_SAMPLER_BIT) if (vulkanTexture->usageFlags & VK_IMAGE_USAGE_SAMPLED_BIT)
{ {
VULKAN_INTERNAL_ImageMemoryBarrier( VULKAN_INTERNAL_ImageMemoryBarrier(
renderer, renderer,
@ -6035,8 +5964,8 @@ static void VULKAN_SetTextureDataYUV(
VkCommandBuffer commandBuffer = renderer->transferCommandBuffers[renderer->frameIndex]; VkCommandBuffer commandBuffer = renderer->transferCommandBuffers[renderer->frameIndex];
uint8_t *dataPtr = (uint8_t*) data; uint8_t *dataPtr = (uint8_t*) data;
int32_t yDataLength = BytesPerImage(yWidth, yHeight, REFRESH_COLORFORMAT_R8); int32_t yDataLength = BytesPerImage(yWidth, yHeight, REFRESH_TEXTUREFORMAT_R8);
int32_t uvDataLength = BytesPerImage(uvWidth, uvHeight, REFRESH_COLORFORMAT_R8); int32_t uvDataLength = BytesPerImage(uvWidth, uvHeight, REFRESH_TEXTUREFORMAT_R8);
VkBufferImageCopy imageCopy; VkBufferImageCopy imageCopy;
uint8_t * stagingBufferPointer; uint8_t * stagingBufferPointer;
@ -6180,7 +6109,7 @@ static void VULKAN_SetTextureDataYUV(
renderer->textureStagingBufferOffset += dataLength; renderer->textureStagingBufferOffset += dataLength;
if (tex->usageFlags & REFRESH_TEXTUREUSAGE_SAMPLER_BIT) if (tex->usageFlags & VK_IMAGE_USAGE_SAMPLED_BIT)
{ {
VULKAN_INTERNAL_ImageMemoryBarrier( VULKAN_INTERNAL_ImageMemoryBarrier(
renderer, renderer,
@ -7033,48 +6962,25 @@ static void VULKAN_QueueDestroyBuffer(
SDL_UnlockMutex(renderer->disposeLock); SDL_UnlockMutex(renderer->disposeLock);
} }
static void VULKAN_QueueDestroyColorTarget( static void VULKAN_QueueDestroyRenderTarget(
Refresh_Renderer *driverData, Refresh_Renderer *driverData,
Refresh_ColorTarget *colorTarget Refresh_RenderTarget *renderTarget
) { ) {
VulkanRenderer *renderer = (VulkanRenderer*) driverData; VulkanRenderer *renderer = (VulkanRenderer*) driverData;
VulkanColorTarget *vulkanColorTarget = (VulkanColorTarget*) colorTarget; VulkanRenderTarget *vulkanRenderTarget = (VulkanRenderTarget*) renderTarget;
SDL_LockMutex(renderer->disposeLock); SDL_LockMutex(renderer->disposeLock);
EXPAND_ARRAY_IF_NEEDED( EXPAND_ARRAY_IF_NEEDED(
renderer->colorTargetsToDestroy, renderer->renderTargetsToDestroy,
VulkanColorTarget*, VulkanRenderTarget*,
renderer->colorTargetsToDestroyCount + 1, renderer->renderTargetsToDestroyCount + 1,
renderer->colorTargetsToDestroyCapacity, renderer->renderTargetsToDestroyCapacity,
renderer->colorTargetsToDestroyCapacity * 2 renderer->renderTargetsToDestroyCapacity * 2
) )
renderer->colorTargetsToDestroy[renderer->colorTargetsToDestroyCount] = vulkanColorTarget; renderer->renderTargetsToDestroy[renderer->renderTargetsToDestroyCount] = vulkanRenderTarget;
renderer->colorTargetsToDestroyCount += 1; renderer->renderTargetsToDestroyCount += 1;
SDL_UnlockMutex(renderer->disposeLock);
}
static void VULKAN_QueueDestroyDepthStencilTarget(
Refresh_Renderer *driverData,
Refresh_DepthStencilTarget *depthStencilTarget
) {
VulkanRenderer *renderer = (VulkanRenderer*) driverData;
VulkanDepthStencilTarget *vulkanDepthStencilTarget = (VulkanDepthStencilTarget*) depthStencilTarget;
SDL_LockMutex(renderer->disposeLock);
EXPAND_ARRAY_IF_NEEDED(
renderer->depthStencilTargetsToDestroy,
VulkanDepthStencilTarget*,
renderer->depthStencilTargetsToDestroyCount + 1,
renderer->depthStencilTargetsToDestroyCapacity,
renderer->depthStencilTargetsToDestroyCapacity * 2
)
renderer->depthStencilTargetsToDestroy[renderer->depthStencilTargetsToDestroyCount] = vulkanDepthStencilTarget;
renderer->depthStencilTargetsToDestroyCount += 1;
SDL_UnlockMutex(renderer->disposeLock); SDL_UnlockMutex(renderer->disposeLock);
} }
@ -7235,8 +7141,8 @@ static void VULKAN_BeginRenderPass(
if (depthStencilClearValue != NULL) if (depthStencilClearValue != NULL)
{ {
depthAspectFlags = VK_IMAGE_ASPECT_DEPTH_BIT; depthAspectFlags = VK_IMAGE_ASPECT_DEPTH_BIT;
if (DepthFormatContainsStencil( if (IsStencilFormat(
vulkanFramebuffer->depthStencilTarget->texture->format vulkanFramebuffer->depthStencilTarget->texture->refreshFormat
)) { )) {
depthAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT; depthAspectFlags |= VK_IMAGE_ASPECT_STENCIL_BIT;
} }
@ -7317,7 +7223,8 @@ static void VULKAN_EndRenderPass(
for (i = 0; i < vulkanCommandBuffer->currentFramebuffer->colorTargetCount; i += 1) for (i = 0; i < vulkanCommandBuffer->currentFramebuffer->colorTargetCount; i += 1)
{ {
currentTexture = vulkanCommandBuffer->currentFramebuffer->colorTargets[i]->texture; currentTexture = vulkanCommandBuffer->currentFramebuffer->colorTargets[i]->texture;
if (currentTexture->usageFlags & REFRESH_TEXTUREUSAGE_SAMPLER_BIT)
if (currentTexture->usageFlags & VK_IMAGE_USAGE_SAMPLED_BIT)
{ {
VULKAN_INTERNAL_ImageMemoryBarrier( VULKAN_INTERNAL_ImageMemoryBarrier(
renderer, renderer,
@ -8612,7 +8519,7 @@ static uint8_t VULKAN_INTERNAL_IsDeviceSuitable(
return 0; return 0;
} }
static VULKAN_INTERNAL_GetPhysicalDeviceProperties( static void VULKAN_INTERNAL_GetPhysicalDeviceProperties(
VulkanRenderer *renderer VulkanRenderer *renderer
) { ) {
renderer->physicalDeviceDriverProperties.sType = renderer->physicalDeviceDriverProperties.sType =
@ -9420,36 +9327,20 @@ static Refresh_Device* VULKAN_INTERNAL_CreateDevice(
/* Deferred destroy storage */ /* Deferred destroy storage */
renderer->colorTargetsToDestroyCapacity = 16; renderer->renderTargetsToDestroyCapacity = 16;
renderer->colorTargetsToDestroyCount = 0; renderer->renderTargetsToDestroyCount = 0;
renderer->colorTargetsToDestroy = (VulkanColorTarget**) SDL_malloc( renderer->renderTargetsToDestroy = (VulkanRenderTarget**) SDL_malloc(
sizeof(VulkanColorTarget*) * sizeof(VulkanRenderTarget*) *
renderer->colorTargetsToDestroyCapacity renderer->renderTargetsToDestroyCapacity
); );
renderer->submittedColorTargetsToDestroyCapacity = 16; renderer->submittedRenderTargetsToDestroyCapacity = 16;
renderer->submittedColorTargetsToDestroyCount = 0; renderer->submittedRenderTargetsToDestroyCount = 0;
renderer->submittedColorTargetsToDestroy = (VulkanColorTarget**) SDL_malloc( renderer->submittedRenderTargetsToDestroy = (VulkanRenderTarget**) SDL_malloc(
sizeof(VulkanColorTarget*) * sizeof(VulkanRenderTarget*) *
renderer->submittedColorTargetsToDestroyCapacity renderer->submittedRenderTargetsToDestroyCapacity
);
renderer->depthStencilTargetsToDestroyCapacity = 16;
renderer->depthStencilTargetsToDestroyCount = 0;
renderer->depthStencilTargetsToDestroy = (VulkanDepthStencilTarget**) SDL_malloc(
sizeof(VulkanDepthStencilTarget*) *
renderer->depthStencilTargetsToDestroyCapacity
);
renderer->submittedDepthStencilTargetsToDestroyCapacity = 16;
renderer->submittedDepthStencilTargetsToDestroyCount = 0;
renderer->submittedDepthStencilTargetsToDestroy = (VulkanDepthStencilTarget**) SDL_malloc(
sizeof(VulkanDepthStencilTarget*) *
renderer->submittedDepthStencilTargetsToDestroyCapacity
); );
renderer->texturesToDestroyCapacity = 16; renderer->texturesToDestroyCapacity = 16;