blob: 637d332c33fc24dbd7883f7b0cc6c15fcfbb1c29 [file]
/*
Simple DirectMedia Layer
Copyright (C) 1997-2026 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_internal.h"
#ifdef SDL_VIDEO_RENDER_VULKAN
#define SDL_VULKAN_FRAME_QUEUE_DEPTH 2
#define SDL_VULKAN_NUM_VERTEX_BUFFERS 256
#define SDL_VULKAN_VERTEX_BUFFER_DEFAULT_SIZE 65536
#define SDL_VULKAN_CONSTANT_BUFFER_DEFAULT_SIZE 65536
#define SDL_VULKAN_NUM_UPLOAD_BUFFERS 32
#define SDL_VULKAN_MAX_DESCRIPTOR_SETS 4096
#define SDL_VULKAN_NUM_TEXTURE_BINDINGS 3
#define SDL_VULKAN_VALIDATION_LAYER_NAME "VK_LAYER_KHRONOS_validation"
#define VK_NO_PROTOTYPES
#include "../../video/SDL_vulkan_internal.h"
#include "../../video/SDL_sysvideo.h"
#include "../SDL_sysrender.h"
#include "../SDL_d3dmath.h"
#include "../../video/SDL_pixels_c.h"
#include "../../video/SDL_yuv_c.h"
#include "SDL_shaders_vulkan.h"
#ifdef SDL_PLATFORM_ANDROID
#include <dlfcn.h>
#include <android/hardware_buffer.h>
typedef void (*pfnAHardwareBuffer_describe)(const AHardwareBuffer *, AHardwareBuffer_Desc *);
#endif
#define SET_ERROR_CODE(message, rc) \
if (SDL_GetHintBoolean(SDL_HINT_RENDER_VULKAN_DEBUG, false)) { \
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s: %s", message, SDL_Vulkan_GetResultString(rc)); \
SDL_TriggerBreakpoint(); \
} \
SDL_SetError("%s: %s", message, SDL_Vulkan_GetResultString(rc)) \
#define SET_ERROR_MESSAGE(message) \
if (SDL_GetHintBoolean(SDL_HINT_RENDER_VULKAN_DEBUG, false)) { \
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "%s", message); \
SDL_TriggerBreakpoint(); \
} \
SDL_SetError("%s", message) \
#ifdef SDL_PLATFORM_ANDROID
#define ANDROID_OPTIONAL_DEVICE_FUNCTION(X) VULKAN_OPTIONAL_DEVICE_FUNCTION(X)
#else
#define ANDROID_OPTIONAL_DEVICE_FUNCTION(X)
#endif
#define VULKAN_FUNCTIONS() \
VULKAN_DEVICE_FUNCTION(vkAcquireNextImageKHR) \
VULKAN_DEVICE_FUNCTION(vkAllocateCommandBuffers) \
VULKAN_DEVICE_FUNCTION(vkAllocateDescriptorSets) \
VULKAN_DEVICE_FUNCTION(vkAllocateMemory) \
VULKAN_DEVICE_FUNCTION(vkBeginCommandBuffer) \
VULKAN_DEVICE_FUNCTION(vkBindBufferMemory) \
VULKAN_DEVICE_FUNCTION(vkBindImageMemory) \
VULKAN_DEVICE_FUNCTION(vkCmdBeginRenderPass) \
VULKAN_DEVICE_FUNCTION(vkCmdBindDescriptorSets) \
VULKAN_DEVICE_FUNCTION(vkCmdBindPipeline) \
VULKAN_DEVICE_FUNCTION(vkCmdBindVertexBuffers) \
VULKAN_DEVICE_FUNCTION(vkCmdClearColorImage) \
VULKAN_DEVICE_FUNCTION(vkCmdCopyBufferToImage) \
VULKAN_DEVICE_FUNCTION(vkCmdCopyImageToBuffer) \
VULKAN_DEVICE_FUNCTION(vkCmdDraw) \
VULKAN_DEVICE_FUNCTION(vkCmdEndRenderPass) \
VULKAN_DEVICE_FUNCTION(vkCmdPipelineBarrier) \
VULKAN_DEVICE_FUNCTION(vkCmdPushConstants) \
VULKAN_DEVICE_FUNCTION(vkCmdSetScissor) \
VULKAN_DEVICE_FUNCTION(vkCmdSetViewport) \
VULKAN_DEVICE_FUNCTION(vkCreateBuffer) \
VULKAN_DEVICE_FUNCTION(vkCreateCommandPool) \
VULKAN_DEVICE_FUNCTION(vkCreateDescriptorPool) \
VULKAN_DEVICE_FUNCTION(vkCreateDescriptorSetLayout) \
VULKAN_DEVICE_FUNCTION(vkCreateFence) \
VULKAN_DEVICE_FUNCTION(vkCreateFramebuffer) \
VULKAN_DEVICE_FUNCTION(vkCreateGraphicsPipelines) \
VULKAN_DEVICE_FUNCTION(vkCreateImage) \
VULKAN_DEVICE_FUNCTION(vkCreateImageView) \
VULKAN_DEVICE_FUNCTION(vkCreatePipelineLayout) \
VULKAN_DEVICE_FUNCTION(vkCreateRenderPass) \
VULKAN_DEVICE_FUNCTION(vkCreateSampler) \
VULKAN_DEVICE_FUNCTION(vkCreateSemaphore) \
VULKAN_DEVICE_FUNCTION(vkCreateShaderModule) \
VULKAN_DEVICE_FUNCTION(vkCreateSwapchainKHR) \
VULKAN_DEVICE_FUNCTION(vkDestroyBuffer) \
VULKAN_DEVICE_FUNCTION(vkDestroyCommandPool) \
VULKAN_DEVICE_FUNCTION(vkDestroyDevice) \
VULKAN_DEVICE_FUNCTION(vkDestroyDescriptorPool) \
VULKAN_DEVICE_FUNCTION(vkDestroyDescriptorSetLayout) \
VULKAN_DEVICE_FUNCTION(vkDestroyFence) \
VULKAN_DEVICE_FUNCTION(vkDestroyFramebuffer) \
VULKAN_DEVICE_FUNCTION(vkDestroyImage) \
VULKAN_DEVICE_FUNCTION(vkDestroyImageView) \
VULKAN_DEVICE_FUNCTION(vkDestroyPipeline) \
VULKAN_DEVICE_FUNCTION(vkDestroyPipelineLayout) \
VULKAN_DEVICE_FUNCTION(vkDestroyRenderPass) \
VULKAN_DEVICE_FUNCTION(vkDestroySampler) \
VULKAN_DEVICE_FUNCTION(vkDestroySemaphore) \
VULKAN_DEVICE_FUNCTION(vkDestroyShaderModule) \
VULKAN_DEVICE_FUNCTION(vkDestroySwapchainKHR) \
VULKAN_DEVICE_FUNCTION(vkDeviceWaitIdle) \
VULKAN_DEVICE_FUNCTION(vkEndCommandBuffer) \
VULKAN_DEVICE_FUNCTION(vkFreeCommandBuffers) \
VULKAN_DEVICE_FUNCTION(vkFreeMemory) \
VULKAN_DEVICE_FUNCTION(vkGetBufferMemoryRequirements) \
VULKAN_DEVICE_FUNCTION(vkGetImageMemoryRequirements) \
VULKAN_DEVICE_FUNCTION(vkGetDeviceQueue) \
VULKAN_DEVICE_FUNCTION(vkGetFenceStatus) \
VULKAN_DEVICE_FUNCTION(vkGetSwapchainImagesKHR) \
VULKAN_DEVICE_FUNCTION(vkMapMemory) \
VULKAN_DEVICE_FUNCTION(vkQueuePresentKHR) \
VULKAN_DEVICE_FUNCTION(vkQueueSubmit) \
VULKAN_DEVICE_FUNCTION(vkResetCommandBuffer) \
VULKAN_DEVICE_FUNCTION(vkResetCommandPool) \
VULKAN_DEVICE_FUNCTION(vkResetDescriptorPool) \
VULKAN_DEVICE_FUNCTION(vkResetFences) \
VULKAN_DEVICE_FUNCTION(vkUnmapMemory) \
VULKAN_DEVICE_FUNCTION(vkUpdateDescriptorSets) \
VULKAN_DEVICE_FUNCTION(vkWaitForFences) \
VULKAN_GLOBAL_FUNCTION(vkCreateInstance) \
VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceExtensionProperties) \
VULKAN_GLOBAL_FUNCTION(vkEnumerateInstanceLayerProperties) \
VULKAN_INSTANCE_FUNCTION(vkCreateDevice) \
VULKAN_INSTANCE_FUNCTION(vkDestroyInstance) \
VULKAN_INSTANCE_FUNCTION(vkDestroySurfaceKHR) \
VULKAN_INSTANCE_FUNCTION(vkEnumerateDeviceExtensionProperties) \
VULKAN_INSTANCE_FUNCTION(vkEnumeratePhysicalDevices) \
VULKAN_INSTANCE_FUNCTION(vkGetDeviceProcAddr) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceImageFormatProperties) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceMemoryProperties) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceQueueFamilyProperties) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceCapabilitiesKHR) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceFormatsKHR) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfacePresentModesKHR) \
VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceSurfaceSupportKHR) \
VULKAN_INSTANCE_FUNCTION(vkQueueWaitIdle) \
VULKAN_OPTIONAL_INSTANCE_FUNCTION(vkGetPhysicalDeviceFeatures2KHR) \
VULKAN_OPTIONAL_INSTANCE_FUNCTION(vkGetPhysicalDeviceMemoryProperties2KHR) \
VULKAN_OPTIONAL_INSTANCE_FUNCTION(vkGetPhysicalDeviceProperties2KHR) \
VULKAN_OPTIONAL_DEVICE_FUNCTION(vkCreateSamplerYcbcrConversionKHR) \
VULKAN_OPTIONAL_DEVICE_FUNCTION(vkDestroySamplerYcbcrConversionKHR) \
VULKAN_OPTIONAL_DEVICE_FUNCTION(vkSetHdrMetadataEXT) \
ANDROID_OPTIONAL_DEVICE_FUNCTION(vkGetAndroidHardwareBufferPropertiesANDROID) \
#define VULKAN_DEVICE_FUNCTION(name) static PFN_##name name = NULL;
#define VULKAN_GLOBAL_FUNCTION(name) static PFN_##name name = NULL;
#define VULKAN_INSTANCE_FUNCTION(name) static PFN_##name name = NULL;
#define VULKAN_OPTIONAL_INSTANCE_FUNCTION(name) static PFN_##name name = NULL;
#define VULKAN_OPTIONAL_DEVICE_FUNCTION(name) static PFN_##name name = NULL;
VULKAN_FUNCTIONS()
#undef VULKAN_DEVICE_FUNCTION
#undef VULKAN_GLOBAL_FUNCTION
#undef VULKAN_INSTANCE_FUNCTION
#undef VULKAN_OPTIONAL_INSTANCE_FUNCTION
#undef VULKAN_OPTIONAL_DEVICE_FUNCTION
// Renderpass types
typedef enum {
VULKAN_RENDERPASS_LOAD = 0,
VULKAN_RENDERPASS_CLEAR = 1,
VULKAN_RENDERPASS_COUNT
} VULKAN_RenderPass;
// Vertex shader, common values
typedef struct
{
Float4X4 model;
Float4X4 projectionAndView;
} VULKAN_VertexShaderConstants;
// These should mirror the definitions in VULKAN_PixelShader_Common.hlsli
static const float TONEMAP_NONE = 0;
//static const float TONEMAP_LINEAR = 1;
static const float TONEMAP_CHROME = 2;
//static const float TEXTURETYPE_NONE = 0;
static const float TEXTURETYPE_RGB = 1;
static const float TEXTURETYPE_RGB_PIXELART = 2;
static const float TEXTURETYPE_PALETTE_NEAREST = 3;
static const float TEXTURETYPE_PALETTE_LINEAR = 4;
static const float TEXTURETYPE_PALETTE_PIXELART = 5;
static const float TEXTURETYPE_NV12 = 6;
static const float TEXTURETYPE_NV21 = 7;
static const float TEXTURETYPE_YUV = 8;
static const float INPUTTYPE_UNSPECIFIED = 0;
static const float INPUTTYPE_SRGB = 1;
static const float INPUTTYPE_SCRGB = 2;
static const float INPUTTYPE_HDR10 = 3;
static const float OUTPUTTYPE_SRGB = 1;
static const float OUTPUTTYPE_SCRGB = 2;
static const float OUTPUTTYPE_HDR10 = 3;
// Pixel shader constants, common values
typedef struct
{
float output_type;
float texture_type;
float input_type;
float color_scale;
float texel_width;
float texel_height;
float texture_width;
float texture_height;
float tonemap_method;
float tonemap_factor1;
float tonemap_factor2;
float sdr_white_point;
float YCbCr_matrix[16];
} VULKAN_PixelShaderConstants;
// Per-vertex data
typedef struct
{
float pos[2];
float tex[2];
SDL_FColor color;
} VULKAN_VertexPositionColor;
// Vulkan OES buffer info
typedef struct
{
#ifdef SDL_PLATFORM_ANDROID
struct AHardwareBuffer *buffer;
VkAndroidHardwareBufferPropertiesANDROID properties;
VkAndroidHardwareBufferFormatPropertiesANDROID formatProperties;
VkExternalFormatANDROID externalFormat;
#else
int dummy;
#endif
} VULKAN_ExternalBufferInfo;
// Vulkan Buffer
typedef struct
{
VkDeviceMemory deviceMemory;
VkBuffer buffer;
VkDeviceSize size;
void *mappedBufferPtr;
} VULKAN_Buffer;
// Vulkan image
typedef struct
{
bool allocatedImage;
VkImage image;
VkDeviceMemory deviceMemory;
VkImageLayout imageLayout;
VkFormat format;
} VULKAN_Image;
// Per-palette data
typedef struct
{
VULKAN_Image image;
VkImageView imageView;
} VULKAN_PaletteData;
// YUV conversion data
typedef struct
{
Uint64 externalFormat;
VkFilter filter;
VkSamplerYcbcrConversionCreateInfoKHR samplerYcbcrConversionCreateInfo;
} VULKAN_YUVPipelineCreateInfo;
typedef struct VULKAN_YUVPipeline
{
// The information used to create this entry
VULKAN_YUVPipelineCreateInfo createInfo;
// Object passed to VkImageView and VkSampler for doing Ycbcr -> RGB conversion
VkSamplerYcbcrConversion samplerYcbcrConversion;
// Sampler created with samplerYcbcrConversion, passed to PSO as immutable sampler
VkSampler samplerYcbcr;
// Descriptor set layout with samplerYcbcr baked as immutable sampler
VkDescriptorSetLayout descriptorSetLayoutYcbcr;
// Pipeline layout with immutable sampler descriptor set layout
VkPipelineLayout pipelineLayoutYcbcr;
// The next entry in the cache
struct VULKAN_YUVPipeline *next;
} VULKAN_YUVPipeline;
// Per-texture data
typedef struct
{
int numImages;
VULKAN_Image images[SDL_VULKAN_NUM_TEXTURE_BINDINGS];
int numImageViews;
VkImageView imageViews[SDL_VULKAN_NUM_TEXTURE_BINDINGS];
VkRenderPass mainRenderpasses[VULKAN_RENDERPASS_COUNT];
VkFramebuffer mainFramebuffer;
VULKAN_Buffer stagingBuffer;
int width;
int height;
bool srgb_view;
const float *YCbCr_matrix;
// YCbCr conversion support
VULKAN_YUVPipeline *yuvPipeline;
Uint8 *pixels;
int pitch;
SDL_Rect lockedRect;
} VULKAN_TextureData;
// Pipeline State Object data
typedef struct
{
VULKAN_Shader shader;
VULKAN_PixelShaderConstants shader_constants;
SDL_BlendMode blendMode;
VkPrimitiveTopology topology;
VkFormat format;
VkPipelineLayout pipelineLayout;
VkDescriptorSetLayout descriptorSetLayout;
VkPipeline pipeline;
} VULKAN_PipelineState;
typedef struct
{
VkBuffer vertexBuffer;
} VULKAN_DrawStateCache;
// Private renderer data
typedef struct
{
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
VkInstance instance;
bool instance_external;
VkSurfaceKHR surface;
bool surface_external;
VkPhysicalDevice physicalDevice;
VkPhysicalDeviceProperties physicalDeviceProperties;
VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties;
VkPhysicalDeviceFeatures physicalDeviceFeatures;
VkQueue graphicsQueue;
VkQueue presentQueue;
VkDevice device;
bool device_external;
uint32_t graphicsQueueFamilyIndex;
uint32_t presentQueueFamilyIndex;
VkSwapchainKHR swapchain;
VkCommandPool commandPool;
VkCommandBuffer *commandBuffers;
uint32_t currentCommandBufferIndex;
VkCommandBuffer currentCommandBuffer;
VkFence *fences;
VkSurfaceCapabilitiesKHR surfaceCapabilities;
VkSurfaceFormatKHR *surfaceFormats;
bool recreateSwapchain;
int vsync;
SDL_PropertiesID create_props;
VkFramebuffer *framebuffers;
VkRenderPass renderPasses[VULKAN_RENDERPASS_COUNT];
VkRenderPass currentRenderPass;
VkShaderModule vertexShaderModules[NUM_SHADERS];
VkShaderModule fragmentShaderModules[NUM_SHADERS];
VkDescriptorSetLayout descriptorSetLayout;
VkPipelineLayout pipelineLayout;
// Vertex buffer data
VULKAN_Buffer vertexBuffers[SDL_VULKAN_NUM_VERTEX_BUFFERS];
VULKAN_VertexShaderConstants vertexShaderConstantsData;
// Data for staging/allocating textures
VULKAN_Buffer **uploadBuffers;
int *currentUploadBuffer;
// Data for updating constants
VULKAN_Buffer **constantBuffers;
uint32_t *numConstantBuffers;
uint32_t currentConstantBufferIndex;
int32_t currentConstantBufferOffset;
VkSampler samplers[RENDER_SAMPLER_COUNT];
VkDescriptorPool **descriptorPools;
uint32_t *numDescriptorPools;
uint32_t currentDescriptorPoolIndex;
uint32_t currentDescriptorSetIndex;
int pipelineStateCount;
VULKAN_PipelineState *pipelineStates;
VULKAN_PipelineState *currentPipelineState;
VULKAN_YUVPipeline *yuvPipelineCache;
bool supportsEXTSwapchainColorspace;
bool supportsEXTHdrMetadata;
bool supportsKHRGetPhysicalDeviceProperties2;
bool supportsKHRSamplerYCbCrConversion;
bool supportsKHRExternalMemoryCapabilities;
bool supportsANDROIDExternalMemoryAndroidHardwareBuffer;
uint32_t surfaceFormatsAllocatedCount;
uint32_t surfaceFormatsCount;
uint32_t swapchainDesiredImageCount;
VkSurfaceFormatKHR surfaceFormat;
VkExtent2D swapchainSize;
VkSurfaceTransformFlagBitsKHR swapChainPreTransform;
uint32_t swapchainImageCount;
VkImage *swapchainImages;
VkImageView *swapchainImageViews;
VkImageLayout *swapchainImageLayouts;
VkSemaphore *imageAvailableSemaphores;
VkSemaphore *renderingFinishedSemaphores;
VkSemaphore currentImageAvailableSemaphore;
uint32_t currentSwapchainImageIndex;
VkPipelineStageFlags *waitDestStageMasks;
VkSemaphore *waitRenderSemaphores;
uint32_t waitRenderSemaphoreCount;
uint32_t waitRenderSemaphoreMax;
VkSemaphore *signalRenderSemaphores;
uint32_t signalRenderSemaphoreCount;
uint32_t signalRenderSemaphoreMax;
// Cached renderer properties
VULKAN_TextureData *textureRenderTarget;
bool cliprectDirty;
bool currentCliprectEnabled;
SDL_Rect currentCliprect;
SDL_Rect currentViewport;
int currentViewportRotation;
bool viewportDirty;
Float4X4 identity;
VkComponentMapping identitySwizzle;
int currentVertexBuffer;
bool issueBatch;
} VULKAN_RenderData;
static bool VULKAN_UpdateTextureInternal(VULKAN_RenderData *rendererData, VkImage image, VkFormat format, int plane, int x, int y, int w, int h, const void *pixels, int pitch, VkImageLayout *imageLayout);
// TODO: Sort this list based on what the Vulkan driver prefers?
static const struct
{
SDL_PixelFormat sdl;
VkFormat unorm;
VkFormat srgb;
} vk_format_map[] = {
{ SDL_PIXELFORMAT_BGRA32, VK_FORMAT_B8G8R8A8_UNORM, VK_FORMAT_B8G8R8A8_SRGB }, // SDL_PIXELFORMAT_ARGB8888 on little endian systems
{ SDL_PIXELFORMAT_RGBA32, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_SRGB },
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
{ SDL_PIXELFORMAT_ABGR8888, VK_FORMAT_A8B8G8R8_UNORM_PACK32, VK_FORMAT_A8B8G8R8_SRGB_PACK32 },
#endif
{ SDL_PIXELFORMAT_ABGR2101010, VK_FORMAT_A2B10G10R10_UNORM_PACK32, VK_FORMAT_A2B10G10R10_UNORM_PACK32 },
{ SDL_PIXELFORMAT_RGBA64_FLOAT, VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R16G16B16A16_SFLOAT },
{ SDL_PIXELFORMAT_RGB565, VK_FORMAT_R5G6B5_UNORM_PACK16, VK_FORMAT_R5G6B5_UNORM_PACK16 },
{ SDL_PIXELFORMAT_BGR565, VK_FORMAT_B5G6R5_UNORM_PACK16, VK_FORMAT_B5G6R5_UNORM_PACK16 },
{ SDL_PIXELFORMAT_RGBA5551, VK_FORMAT_R5G5B5A1_UNORM_PACK16, VK_FORMAT_R5G5B5A1_UNORM_PACK16 },
{ SDL_PIXELFORMAT_BGRA5551, VK_FORMAT_B5G5R5A1_UNORM_PACK16, VK_FORMAT_B5G5R5A1_UNORM_PACK16 },
{ SDL_PIXELFORMAT_ARGB1555, VK_FORMAT_A1R5G5B5_UNORM_PACK16, VK_FORMAT_A1R5G5B5_UNORM_PACK16 },
{ SDL_PIXELFORMAT_RGBA4444, VK_FORMAT_R4G4B4A4_UNORM_PACK16, VK_FORMAT_R4G4B4A4_UNORM_PACK16 },
{ SDL_PIXELFORMAT_BGRA4444, VK_FORMAT_B4G4R4A4_UNORM_PACK16, VK_FORMAT_B4G4R4A4_UNORM_PACK16 },
{ SDL_PIXELFORMAT_ARGB4444, VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT, VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT },
{ SDL_PIXELFORMAT_ABGR4444, VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT, VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT }
};
static SDL_PixelFormat VULKAN_VkFormatToSDLPixelFormat(VkFormat vkFormat)
{
for (int i = 0; i < SDL_arraysize(vk_format_map); i++) {
if (vk_format_map[i].unorm == vkFormat ||
vk_format_map[i].srgb == vkFormat) {
return vk_format_map[i].sdl;
}
}
return SDL_PIXELFORMAT_UNKNOWN;
}
static int VULKAN_GetFormatImageCount(SDL_PixelFormat format)
{
switch (format) {
case SDL_PIXELFORMAT_YV12:
case SDL_PIXELFORMAT_IYUV:
case SDL_PIXELFORMAT_I444:
case SDL_PIXELFORMAT_I0FL:
case SDL_PIXELFORMAT_I4FL:
return 3;
default:
return 1;
}
}
static int VULKAN_GetFormatImageViewCount(SDL_PixelFormat format)
{
switch (format) {
case SDL_PIXELFORMAT_NV12:
case SDL_PIXELFORMAT_NV21:
case SDL_PIXELFORMAT_P010:
return 2;
case SDL_PIXELFORMAT_YV12:
case SDL_PIXELFORMAT_IYUV:
case SDL_PIXELFORMAT_I444:
case SDL_PIXELFORMAT_I0FL:
case SDL_PIXELFORMAT_I4FL:
return 3;
default:
return 1;
}
}
static int VULKAN_VkFormatGetNumPlanes(VkFormat vkFormat)
{
switch (vkFormat) {
case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
return 3;
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
return 2;
default:
return 1;
}
}
static VkDeviceSize VULKAN_GetBytesPerPixel(VkFormat vkFormat, int plane)
{
switch (vkFormat) {
case VK_FORMAT_R8_UNORM:
return 1;
case VK_FORMAT_R8G8_UNORM:
return 2;
case VK_FORMAT_R16_UNORM:
return 2;
case VK_FORMAT_R16G16_UNORM:
return 4;
case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
return 1;
case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
return 2;
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
return (plane == 0) ? 1 : 2;
case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
return (plane == 0) ? 2 : 4;
default:
return SDL_BYTESPERPIXEL(VULKAN_VkFormatToSDLPixelFormat(vkFormat));
}
}
static VkFormat VULKAN_GetVkImageFormat(SDL_PixelFormat format, Uint32 output_colorspace)
{
switch (format) {
case SDL_PIXELFORMAT_INDEX8:
case SDL_PIXELFORMAT_YV12:
case SDL_PIXELFORMAT_IYUV:
case SDL_PIXELFORMAT_I444:
return VK_FORMAT_R8_UNORM;
case SDL_PIXELFORMAT_NV12:
case SDL_PIXELFORMAT_NV21:
return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
case SDL_PIXELFORMAT_P010:
return VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
case SDL_PIXELFORMAT_I0FL:
case SDL_PIXELFORMAT_I4FL:
return VK_FORMAT_R16_UNORM;
default:
for (int i = 0; i < SDL_arraysize(vk_format_map); i++) {
if (vk_format_map[i].sdl == format) {
if (output_colorspace == SDL_COLORSPACE_SRGB_LINEAR ||
output_colorspace == SDL_COLORSPACE_HDR10) {
return vk_format_map[i].srgb;
} else {
return vk_format_map[i].unorm;
}
}
}
return VK_FORMAT_UNDEFINED;
}
}
static bool VkFormatIsSRGB(VkFormat format)
{
switch (format) {
case VK_FORMAT_B8G8R8A8_SRGB:
case VK_FORMAT_R8G8B8A8_SRGB:
case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
return true;
default:
return false;
}
}
static VkFormat VULKAN_GetVkImageViewFormat(SDL_PixelFormat format, int plane, Uint32 output_colorspace)
{
switch (format) {
case SDL_PIXELFORMAT_NV12:
case SDL_PIXELFORMAT_NV21:
if (plane == 0) {
return VK_FORMAT_R8_UNORM;
} else {
return VK_FORMAT_R8G8_UNORM;
}
case SDL_PIXELFORMAT_P010:
if (plane == 0) {
return VK_FORMAT_R16_UNORM;
} else {
return VK_FORMAT_R16G16_UNORM;
}
default:
return VULKAN_GetVkImageFormat(format, output_colorspace);
}
}
static void VULKAN_DestroyTexture(SDL_Renderer *renderer, SDL_Texture *texture);
static bool SDLCALL VULKAN_ReleasePalette(void *userdata, const SDL_HashTable *table, const void *key, const void *value);
static void VULKAN_DestroyBuffer(VULKAN_RenderData *rendererData, VULKAN_Buffer *vulkanBuffer);
static void VULKAN_DestroyImage(VULKAN_RenderData *rendererData, VULKAN_Image *vulkanImage);
static void VULKAN_ResetCommandList(VULKAN_RenderData *rendererData);
static bool VULKAN_EnsureCommandBuffer(VULKAN_RenderData *rendererData);
static void VULKAN_RecordExternalImageBarrier(VULKAN_RenderData *rendererData, VkAccessFlags sourceAccessMask, VkAccessFlags destAccessMask, VkPipelineStageFlags srcStageFlags, VkPipelineStageFlags dstStageFlags, VkImageLayout destLayout, VkImage image, VkImageLayout *imageLayout);
static void VULKAN_RecordPipelineImageBarrier(VULKAN_RenderData *rendererData, VkAccessFlags sourceAccessMask, VkAccessFlags destAccessMask, VkPipelineStageFlags srcStageFlags, VkPipelineStageFlags dstStageFlags, VkImageLayout destLayout, VkImage image, VkImageLayout *imageLayout);
static bool VULKAN_FindMemoryTypeIndex(VULKAN_RenderData *rendererData, uint32_t typeBits, VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags desiredFlags, uint32_t *memoryTypeIndexOut);
static VkResult VULKAN_CreateWindowSizeDependentResources(SDL_Renderer *renderer);
static VkDescriptorPool VULKAN_AllocateDescriptorPool(VULKAN_RenderData *rendererData);
static VkResult VULKAN_CreateDescriptorSetAndPipelineLayout(VULKAN_RenderData *rendererData, VkSampler samplerYcbcr, VkDescriptorSetLayout *descriptorSetLayoutOut, VkPipelineLayout *pipelineLayoutOut);
#ifdef SDL_PLATFORM_ANDROID
static VULKAN_YUVPipeline *VULKAN_GetYUVPipeline(VULKAN_RenderData *rendererData, const VULKAN_YUVPipelineCreateInfo *createInfo);
#endif
static void VULKAN_CleanupYUVPipeline(VULKAN_RenderData *rendererData, VULKAN_YUVPipeline *pipeline);
static VkSurfaceTransformFlagBitsKHR VULKAN_GetRotationForCurrentRenderTarget(VULKAN_RenderData *rendererData);
static bool VULKAN_IsDisplayRotated90Degrees(VkSurfaceTransformFlagBitsKHR rotation);
static void VULKAN_UpdateHDRMetadata(SDL_Renderer *renderer);
static void VULKAN_DestroyAll(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData;
if (renderer == NULL) {
return;
}
rendererData = (VULKAN_RenderData *)renderer->internal;
if (rendererData == NULL) {
return;
}
// Release all textures
for (SDL_Texture *texture = renderer->textures; texture; texture = texture->next) {
VULKAN_DestroyTexture(renderer, texture);
}
// Release all palettes, they'll be recreated the next time they're used
if (renderer->palettes) {
SDL_IterateHashTable(renderer->palettes, VULKAN_ReleasePalette, rendererData);
}
for (VULKAN_YUVPipeline *pipeline = rendererData->yuvPipelineCache; pipeline;) {
VULKAN_YUVPipeline *next = pipeline->next;
VULKAN_CleanupYUVPipeline(rendererData, pipeline);
pipeline = next;
}
rendererData->yuvPipelineCache = NULL;
if (rendererData->waitDestStageMasks) {
SDL_free(rendererData->waitDestStageMasks);
rendererData->waitDestStageMasks = NULL;
}
if (rendererData->waitRenderSemaphores) {
SDL_free(rendererData->waitRenderSemaphores);
rendererData->waitRenderSemaphores = NULL;
}
if (rendererData->signalRenderSemaphores) {
SDL_free(rendererData->signalRenderSemaphores);
rendererData->signalRenderSemaphores = NULL;
}
if (rendererData->surfaceFormats != NULL) {
SDL_free(rendererData->surfaceFormats);
rendererData->surfaceFormats = NULL;
rendererData->surfaceFormatsAllocatedCount = 0;
}
if (rendererData->swapchainImages != NULL) {
SDL_free(rendererData->swapchainImages);
rendererData->swapchainImages = NULL;
}
if (rendererData->swapchain) {
vkDestroySwapchainKHR(rendererData->device, rendererData->swapchain, NULL);
rendererData->swapchain = VK_NULL_HANDLE;
}
if (rendererData->fences != NULL) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
if (rendererData->fences[i] != VK_NULL_HANDLE) {
vkDestroyFence(rendererData->device, rendererData->fences[i], NULL);
rendererData->fences[i] = VK_NULL_HANDLE;
}
}
SDL_free(rendererData->fences);
rendererData->fences = NULL;
}
if (rendererData->swapchainImageViews) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
if (rendererData->swapchainImageViews[i] != VK_NULL_HANDLE) {
vkDestroyImageView(rendererData->device, rendererData->swapchainImageViews[i], NULL);
}
}
SDL_free(rendererData->swapchainImageViews);
rendererData->swapchainImageViews = NULL;
}
if (rendererData->swapchainImageLayouts) {
SDL_free(rendererData->swapchainImageLayouts);
rendererData->swapchainImageLayouts = NULL;
}
if (rendererData->framebuffers) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
if (rendererData->framebuffers[i] != VK_NULL_HANDLE) {
vkDestroyFramebuffer(rendererData->device, rendererData->framebuffers[i], NULL);
}
}
SDL_free(rendererData->framebuffers);
rendererData->framebuffers = NULL;
}
for (uint32_t i = 0; i < SDL_arraysize(rendererData->samplers); i++) {
if (rendererData->samplers[i] != VK_NULL_HANDLE) {
vkDestroySampler(rendererData->device, rendererData->samplers[i], NULL);
rendererData->samplers[i] = VK_NULL_HANDLE;
}
}
for (uint32_t i = 0; i < SDL_arraysize(rendererData->vertexBuffers); i++ ) {
VULKAN_DestroyBuffer(rendererData, &rendererData->vertexBuffers[i]);
}
SDL_zeroa(rendererData->vertexBuffers);
for (uint32_t i = 0; i < VULKAN_RENDERPASS_COUNT; i++) {
if (rendererData->renderPasses[i] != VK_NULL_HANDLE) {
vkDestroyRenderPass(rendererData->device, rendererData->renderPasses[i], NULL);
rendererData->renderPasses[i] = VK_NULL_HANDLE;
}
}
if (rendererData->imageAvailableSemaphores) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
if (rendererData->imageAvailableSemaphores[i] != VK_NULL_HANDLE) {
vkDestroySemaphore(rendererData->device, rendererData->imageAvailableSemaphores[i], NULL);
}
}
SDL_free(rendererData->imageAvailableSemaphores);
rendererData->imageAvailableSemaphores = NULL;
}
if (rendererData->renderingFinishedSemaphores) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
if (rendererData->renderingFinishedSemaphores[i] != VK_NULL_HANDLE) {
vkDestroySemaphore(rendererData->device, rendererData->renderingFinishedSemaphores[i], NULL);
}
}
SDL_free(rendererData->renderingFinishedSemaphores);
rendererData->renderingFinishedSemaphores = NULL;
}
if (rendererData->commandBuffers) {
vkFreeCommandBuffers(rendererData->device, rendererData->commandPool, rendererData->swapchainImageCount, rendererData->commandBuffers);
SDL_free(rendererData->commandBuffers);
rendererData->commandBuffers = NULL;
rendererData->currentCommandBuffer = VK_NULL_HANDLE;
rendererData->currentCommandBufferIndex = 0;
}
if (rendererData->commandPool) {
vkDestroyCommandPool(rendererData->device, rendererData->commandPool, NULL);
rendererData->commandPool = VK_NULL_HANDLE;
}
if (rendererData->descriptorPools) {
SDL_assert(rendererData->numDescriptorPools);
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
for (uint32_t j = 0; j < rendererData->numDescriptorPools[i]; j++) {
if (rendererData->descriptorPools[i][j] != VK_NULL_HANDLE) {
vkDestroyDescriptorPool(rendererData->device, rendererData->descriptorPools[i][j], NULL);
}
}
SDL_free(rendererData->descriptorPools[i]);
}
SDL_free(rendererData->descriptorPools);
rendererData->descriptorPools = NULL;
SDL_free(rendererData->numDescriptorPools);
rendererData->numDescriptorPools = NULL;
}
for (uint32_t i = 0; i < NUM_SHADERS; i++) {
if (rendererData->vertexShaderModules[i] != VK_NULL_HANDLE) {
vkDestroyShaderModule(rendererData->device, rendererData->vertexShaderModules[i], NULL);
rendererData->vertexShaderModules[i] = VK_NULL_HANDLE;
}
if (rendererData->fragmentShaderModules[i] != VK_NULL_HANDLE) {
vkDestroyShaderModule(rendererData->device, rendererData->fragmentShaderModules[i], NULL);
rendererData->fragmentShaderModules[i] = VK_NULL_HANDLE;
}
}
if (rendererData->descriptorSetLayout != VK_NULL_HANDLE) {
vkDestroyDescriptorSetLayout(rendererData->device, rendererData->descriptorSetLayout, NULL);
rendererData->descriptorSetLayout = VK_NULL_HANDLE;
}
if (rendererData->pipelineLayout != VK_NULL_HANDLE) {
vkDestroyPipelineLayout(rendererData->device, rendererData->pipelineLayout, NULL);
rendererData->pipelineLayout = VK_NULL_HANDLE;
}
for (int i = 0; i < rendererData->pipelineStateCount; i++) {
vkDestroyPipeline(rendererData->device, rendererData->pipelineStates[i].pipeline, NULL);
}
SDL_free(rendererData->pipelineStates);
rendererData->pipelineStates = NULL;
rendererData->pipelineStateCount = 0;
if (rendererData->currentUploadBuffer) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
for (int j = 0; j < rendererData->currentUploadBuffer[i]; ++j) {
VULKAN_DestroyBuffer(rendererData, &rendererData->uploadBuffers[i][j]);
}
SDL_free(rendererData->uploadBuffers[i]);
}
SDL_free(rendererData->uploadBuffers);
rendererData->uploadBuffers = NULL;
SDL_free(rendererData->currentUploadBuffer);
rendererData->currentUploadBuffer = NULL;
}
if (rendererData->constantBuffers) {
SDL_assert(rendererData->numConstantBuffers);
for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
for (uint32_t j = 0; j < rendererData->numConstantBuffers[i]; j++) {
VULKAN_DestroyBuffer(rendererData, &rendererData->constantBuffers[i][j]);
}
SDL_free(rendererData->constantBuffers[i]);
}
SDL_free(rendererData->constantBuffers);
rendererData->constantBuffers = NULL;
SDL_free(rendererData->numConstantBuffers);
rendererData->numConstantBuffers = NULL;
}
if (rendererData->device != VK_NULL_HANDLE) {
if (!rendererData->device_external) {
vkDestroyDevice(rendererData->device, NULL);
}
rendererData->device = VK_NULL_HANDLE;
}
if (rendererData->surface != VK_NULL_HANDLE) {
if (!rendererData->surface_external) {
vkDestroySurfaceKHR(rendererData->instance, rendererData->surface, NULL);
}
rendererData->surface = VK_NULL_HANDLE;
}
if (rendererData->instance != VK_NULL_HANDLE) {
if (!rendererData->instance_external) {
vkDestroyInstance(rendererData->instance, NULL);
}
rendererData->instance = VK_NULL_HANDLE;
}
}
static void VULKAN_DestroyBuffer(VULKAN_RenderData *rendererData, VULKAN_Buffer *vulkanBuffer)
{
if (vulkanBuffer->buffer != VK_NULL_HANDLE) {
vkDestroyBuffer(rendererData->device, vulkanBuffer->buffer, NULL);
vulkanBuffer->buffer = VK_NULL_HANDLE;
}
if (vulkanBuffer->deviceMemory != VK_NULL_HANDLE) {
vkFreeMemory(rendererData->device, vulkanBuffer->deviceMemory, NULL);
vulkanBuffer->deviceMemory = VK_NULL_HANDLE;
}
SDL_zerop(vulkanBuffer);
}
static VkResult VULKAN_AllocateBuffer(VULKAN_RenderData *rendererData, VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags requiredMemoryProps, VkMemoryPropertyFlags desiredMemoryProps, VULKAN_Buffer *bufferOut)
{
VkResult result;
VkBufferCreateInfo bufferCreateInfo = { 0 };
bufferCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
bufferCreateInfo.size = size;
bufferCreateInfo.usage = usage;
result = vkCreateBuffer(rendererData->device, &bufferCreateInfo, NULL, &bufferOut->buffer);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateBuffer()", result);
return result;
}
VkMemoryRequirements memoryRequirements = { 0 };
vkGetBufferMemoryRequirements(rendererData->device, bufferOut->buffer, &memoryRequirements);
if (result != VK_SUCCESS) {
VULKAN_DestroyBuffer(rendererData, bufferOut);
SET_ERROR_CODE("vkGetBufferMemoryRequirements()", result);
return result;
}
uint32_t memoryTypeIndex = 0;
if (!VULKAN_FindMemoryTypeIndex(rendererData, memoryRequirements.memoryTypeBits, requiredMemoryProps, desiredMemoryProps, &memoryTypeIndex)) {
VULKAN_DestroyBuffer(rendererData, bufferOut);
return VK_ERROR_UNKNOWN;
}
VkMemoryAllocateInfo memoryAllocateInfo = { 0 };
memoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
memoryAllocateInfo.allocationSize = memoryRequirements.size;
memoryAllocateInfo.memoryTypeIndex = memoryTypeIndex;
result = vkAllocateMemory(rendererData->device, &memoryAllocateInfo, NULL, &bufferOut->deviceMemory);
if (result != VK_SUCCESS) {
VULKAN_DestroyBuffer(rendererData, bufferOut);
SET_ERROR_CODE("vkAllocateMemory()", result);
return result;
}
result = vkBindBufferMemory(rendererData->device, bufferOut->buffer, bufferOut->deviceMemory, 0);
if (result != VK_SUCCESS) {
VULKAN_DestroyBuffer(rendererData, bufferOut);
SET_ERROR_CODE("vkBindBufferMemory()", result);
return result;
}
result = vkMapMemory(rendererData->device, bufferOut->deviceMemory, 0, size, 0, &bufferOut->mappedBufferPtr);
if (result != VK_SUCCESS) {
VULKAN_DestroyBuffer(rendererData, bufferOut);
SET_ERROR_CODE("vkMapMemory()", result);
return result;
}
bufferOut->size = size;
return result;
}
static void VULKAN_DestroyImage(VULKAN_RenderData *rendererData, VULKAN_Image *vulkanImage)
{
if (vulkanImage->image != VK_NULL_HANDLE) {
if (vulkanImage->allocatedImage) {
vkDestroyImage(rendererData->device, vulkanImage->image, NULL);
}
vulkanImage->image = VK_NULL_HANDLE;
}
if (vulkanImage->deviceMemory != VK_NULL_HANDLE) {
if (vulkanImage->allocatedImage) {
vkFreeMemory(rendererData->device, vulkanImage->deviceMemory, NULL);
}
vulkanImage->deviceMemory = VK_NULL_HANDLE;
}
}
static VkResult VULKAN_AllocateImage(VULKAN_RenderData *rendererData, SDL_PropertiesID create_props, const char *property, uint32_t width, uint32_t height, VkFormat format, VkImageUsageFlags imageUsage, VkSamplerYcbcrConversionKHR samplerYcbcrConversion, VULKAN_ExternalBufferInfo *external, VULKAN_Image *imageOut)
{
VkResult result;
SDL_zerop(imageOut);
imageOut->format = format;
imageOut->image = (VkImage)SDL_GetNumberProperty(create_props, property, 0);
if (imageOut->image == VK_NULL_HANDLE) {
imageOut->allocatedImage = VK_TRUE;
VkImageCreateInfo imageCreateInfo = { 0 };
imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageCreateInfo.flags = 0;
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
imageCreateInfo.format = format;
imageCreateInfo.extent.width = width;
imageCreateInfo.extent.height = height;
imageCreateInfo.extent.depth = 1;
imageCreateInfo.mipLevels = 1;
imageCreateInfo.arrayLayers = 1;
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
imageCreateInfo.usage = imageUsage;
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
imageCreateInfo.queueFamilyIndexCount = 0;
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
if (VULKAN_VkFormatGetNumPlanes(format) > 1) {
// We'll take image views with a different format
imageCreateInfo.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
}
#ifdef SDL_PLATFORM_ANDROID
VkExternalMemoryImageCreateInfoKHR externalMemoryImageCreateInfo = { 0 };
if (external) {
externalMemoryImageCreateInfo.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR;
externalMemoryImageCreateInfo.pNext = &external->externalFormat;
externalMemoryImageCreateInfo.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
imageCreateInfo.pNext = &externalMemoryImageCreateInfo;
}
#endif
result = vkCreateImage(rendererData->device, &imageCreateInfo, NULL, &imageOut->image);
if (result != VK_SUCCESS) {
VULKAN_DestroyImage(rendererData, imageOut);
SET_ERROR_CODE("vkCreateImage()", result);
return result;
}
VkMemoryRequirements memoryRequirements = { 0 };
#ifdef SDL_PLATFORM_ANDROID
if (external) {
memoryRequirements.memoryTypeBits = external->properties.memoryTypeBits;
memoryRequirements.size = external->properties.allocationSize;
} else
#endif
{
vkGetImageMemoryRequirements(rendererData->device, imageOut->image, &memoryRequirements);
if (result != VK_SUCCESS) {
VULKAN_DestroyImage(rendererData, imageOut);
SET_ERROR_CODE("vkGetImageMemoryRequirements()", result);
return result;
}
}
uint32_t memoryTypeIndex = 0;
if (!VULKAN_FindMemoryTypeIndex(rendererData, memoryRequirements.memoryTypeBits, 0, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memoryTypeIndex)) {
VULKAN_DestroyImage(rendererData, imageOut);
return VK_ERROR_UNKNOWN;
}
VkMemoryAllocateInfo memoryAllocateInfo = { 0 };
memoryAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
memoryAllocateInfo.allocationSize = memoryRequirements.size;
memoryAllocateInfo.memoryTypeIndex = memoryTypeIndex;
#ifdef SDL_PLATFORM_ANDROID
VkImportAndroidHardwareBufferInfoANDROID importHardwareBufferInfo = { 0 };
VkMemoryDedicatedAllocateInfoKHR dedicatedAllocateInfo = { 0 };
if (external) {
importHardwareBufferInfo.sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID;
importHardwareBufferInfo.buffer = external->buffer;
dedicatedAllocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR;
dedicatedAllocateInfo.pNext = &importHardwareBufferInfo;
dedicatedAllocateInfo.image = imageOut->image;
memoryAllocateInfo.pNext = &dedicatedAllocateInfo;
}
#endif
result = vkAllocateMemory(rendererData->device, &memoryAllocateInfo, NULL, &imageOut->deviceMemory);
if (result != VK_SUCCESS) {
VULKAN_DestroyImage(rendererData, imageOut);
SET_ERROR_CODE("vkAllocateMemory()", result);
return result;
}
result = vkBindImageMemory(rendererData->device, imageOut->image, imageOut->deviceMemory, 0);
if (result != VK_SUCCESS) {
VULKAN_DestroyImage(rendererData, imageOut);
SET_ERROR_CODE("vkBindImageMemory()", result);
return result;
}
} else {
imageOut->imageLayout = (VkImageLayout)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_VULKAN_LAYOUT_NUMBER, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
}
if (imageOut->imageLayout != VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
if (!VULKAN_EnsureCommandBuffer(rendererData)) {
VULKAN_DestroyImage(rendererData, imageOut);
return VK_ERROR_OUT_OF_DATE_KHR;
}
if (external) {
VULKAN_RecordExternalImageBarrier(rendererData,
VK_ACCESS_NONE,
VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
imageOut->image,
&imageOut->imageLayout);
} else {
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_NONE,
VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
imageOut->image,
&imageOut->imageLayout);
}
}
return VK_SUCCESS;
}
static VkResult VULKAN_AllocateImageView(VULKAN_RenderData *rendererData, VkImage image, int plane, VkFormat format, VkImageUsageFlags imageUsage, VkComponentMapping swizzle, VkSamplerYcbcrConversionKHR samplerYcbcrConversion, VkImageView *imageViewOut)
{
VkResult result;
VkSamplerYcbcrConversionInfoKHR samplerYcbcrConversionInfo = { 0 };
VkImageAspectFlags aspectMask;
if (plane < 0) {
aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
} else {
aspectMask = (VkImageAspectFlags)(VK_IMAGE_ASPECT_PLANE_0_BIT << plane);
}
// We're only going to use image views for sampling and rendering
imageUsage &= (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);
VkImageViewCreateInfo imageViewCreateInfo = { 0 };
imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCreateInfo.image = image;
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
imageViewCreateInfo.format = format;
imageViewCreateInfo.components = swizzle;
imageViewCreateInfo.subresourceRange.aspectMask = aspectMask;
imageViewCreateInfo.subresourceRange.baseMipLevel = 0;
imageViewCreateInfo.subresourceRange.levelCount = 1;
imageViewCreateInfo.subresourceRange.baseArrayLayer = 0;
imageViewCreateInfo.subresourceRange.layerCount = 1;
VkImageViewUsageCreateInfo imageViewUsageCreateInfo = { 0 };
imageViewUsageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
imageViewUsageCreateInfo.usage = imageUsage;
imageViewCreateInfo.pNext = &imageViewUsageCreateInfo;
// If it's a YCbCr image, we need to pass the conversion info to the VkImageView
if (samplerYcbcrConversion != VK_NULL_HANDLE) {
samplerYcbcrConversionInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR;
samplerYcbcrConversionInfo.conversion = samplerYcbcrConversion;
imageViewUsageCreateInfo.pNext = &samplerYcbcrConversionInfo;
}
result = vkCreateImageView(rendererData->device, &imageViewCreateInfo, NULL, imageViewOut);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateImageView()", result);
return result;
}
return VK_SUCCESS;
}
static void VULKAN_RecordExternalImageBarrier(VULKAN_RenderData *rendererData, VkAccessFlags sourceAccessMask, VkAccessFlags destAccessMask,
VkPipelineStageFlags srcStageFlags, VkPipelineStageFlags dstStageFlags, VkImageLayout destLayout, VkImage image, VkImageLayout *imageLayout)
{
// Stop any outstanding renderpass if open
if (rendererData->currentRenderPass != VK_NULL_HANDLE) {
vkCmdEndRenderPass(rendererData->currentCommandBuffer);
rendererData->currentRenderPass = VK_NULL_HANDLE;
}
VkImageMemoryBarrier barrier = { 0 };
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
barrier.srcAccessMask = sourceAccessMask;
barrier.dstAccessMask = destAccessMask;
barrier.oldLayout = *imageLayout;
barrier.newLayout = destLayout;
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT;
barrier.dstQueueFamilyIndex = rendererData->graphicsQueueFamilyIndex;
barrier.image = image;
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
barrier.subresourceRange.baseMipLevel = 0;
barrier.subresourceRange.levelCount = 1;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = 1;
vkCmdPipelineBarrier(rendererData->currentCommandBuffer, srcStageFlags, dstStageFlags, 0, 0, NULL, 0, NULL, 1, &barrier);
*imageLayout = destLayout;
}
static void VULKAN_RecordPipelineImageBarrier(VULKAN_RenderData *rendererData, VkAccessFlags sourceAccessMask, VkAccessFlags destAccessMask,
VkPipelineStageFlags srcStageFlags, VkPipelineStageFlags dstStageFlags, VkImageLayout destLayout, VkImage image, VkImageLayout *imageLayout)
{
// Stop any outstanding renderpass if open
if (rendererData->currentRenderPass != VK_NULL_HANDLE) {
vkCmdEndRenderPass(rendererData->currentCommandBuffer);
rendererData->currentRenderPass = VK_NULL_HANDLE;
}
VkImageMemoryBarrier barrier = { 0 };
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
barrier.srcAccessMask = sourceAccessMask;
barrier.dstAccessMask = destAccessMask;
barrier.oldLayout = *imageLayout;
barrier.newLayout = destLayout;
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.image = image;
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
barrier.subresourceRange.baseMipLevel = 0;
barrier.subresourceRange.levelCount = 1;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = 1;
vkCmdPipelineBarrier(rendererData->currentCommandBuffer, srcStageFlags, dstStageFlags, 0, 0, NULL, 0, NULL, 1, &barrier);
*imageLayout = destLayout;
}
static VkResult VULKAN_AcquireNextSwapchainImage(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VkResult result;
rendererData->currentImageAvailableSemaphore = VK_NULL_HANDLE;
result = vkAcquireNextImageKHR(rendererData->device, rendererData->swapchain, UINT64_MAX,
rendererData->imageAvailableSemaphores[rendererData->currentCommandBufferIndex], VK_NULL_HANDLE, &rendererData->currentSwapchainImageIndex);
if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_ERROR_SURFACE_LOST_KHR) {
if (!(renderer->window->flags & SDL_WINDOW_MINIMIZED)) {
result = VULKAN_CreateWindowSizeDependentResources(renderer);
}
return result;
} else if(result == VK_SUBOPTIMAL_KHR) {
// Suboptimal, but we can continue
} else if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkAcquireNextImageKHR()", result);
return result;
}
rendererData->currentImageAvailableSemaphore = rendererData->imageAvailableSemaphores[rendererData->currentCommandBufferIndex];
return result;
}
static void VULKAN_BeginRenderPass(VULKAN_RenderData *rendererData, VkAttachmentLoadOp loadOp, VkClearColorValue *clearColor)
{
int width = rendererData->swapchainSize.width;
int height = rendererData->swapchainSize.height;
if (rendererData->textureRenderTarget) {
width = rendererData->textureRenderTarget->width;
height = rendererData->textureRenderTarget->height;
}
switch (loadOp) {
case VK_ATTACHMENT_LOAD_OP_CLEAR:
rendererData->currentRenderPass = rendererData->textureRenderTarget ?
rendererData->textureRenderTarget->mainRenderpasses[VULKAN_RENDERPASS_CLEAR] :
rendererData->renderPasses[VULKAN_RENDERPASS_CLEAR];
break;
case VK_ATTACHMENT_LOAD_OP_LOAD:
default:
rendererData->currentRenderPass = rendererData->textureRenderTarget ?
rendererData->textureRenderTarget->mainRenderpasses[VULKAN_RENDERPASS_LOAD] :
rendererData->renderPasses[VULKAN_RENDERPASS_LOAD];
break;
}
VkFramebuffer framebuffer = rendererData->textureRenderTarget ?
rendererData->textureRenderTarget->mainFramebuffer :
rendererData->framebuffers[rendererData->currentSwapchainImageIndex];
VkRenderPassBeginInfo renderPassBeginInfo = { 0 };
renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
renderPassBeginInfo.pNext = NULL;
renderPassBeginInfo.renderPass = rendererData->currentRenderPass;
renderPassBeginInfo.framebuffer = framebuffer;
renderPassBeginInfo.renderArea.offset.x = 0;
renderPassBeginInfo.renderArea.offset.y = 0;
renderPassBeginInfo.renderArea.extent.width = width;
renderPassBeginInfo.renderArea.extent.height = height;
renderPassBeginInfo.clearValueCount = (clearColor == NULL) ? 0 : 1;
VkClearValue clearValue;
if (clearColor != NULL) {
clearValue.color = *clearColor;
renderPassBeginInfo.pClearValues = &clearValue;
}
vkCmdBeginRenderPass(rendererData->currentCommandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
}
static bool VULKAN_EnsureCommandBuffer(VULKAN_RenderData *rendererData)
{
if (rendererData->currentCommandBuffer == VK_NULL_HANDLE) {
if (!rendererData->commandBuffers) {
// The swapchain couldn't be created, e.g. the window surface isn't available
return SDL_SetError("Vulkan swapchain isn't available");
}
rendererData->currentCommandBuffer = rendererData->commandBuffers[rendererData->currentCommandBufferIndex];
VULKAN_ResetCommandList(rendererData);
// Ensure the swapchain is in the correct layout
if (rendererData->swapchainImageLayouts[rendererData->currentSwapchainImageIndex] == VK_IMAGE_LAYOUT_UNDEFINED) {
VULKAN_RecordPipelineImageBarrier(rendererData,
0,
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
rendererData->swapchainImages[rendererData->currentSwapchainImageIndex],
&rendererData->swapchainImageLayouts[rendererData->currentSwapchainImageIndex]);
}
else if (rendererData->swapchainImageLayouts[rendererData->currentCommandBufferIndex] != VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL) {
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT,
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
rendererData->swapchainImages[rendererData->currentSwapchainImageIndex],
&rendererData->swapchainImageLayouts[rendererData->currentSwapchainImageIndex]);
}
}
return true;
}
static bool VULKAN_ActivateCommandBuffer(SDL_Renderer *renderer, VkAttachmentLoadOp loadOp, VkClearColorValue *clearColor, VULKAN_DrawStateCache *stateCache)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
if (!VULKAN_EnsureCommandBuffer(rendererData)) {
return false;
}
if (rendererData->currentRenderPass == VK_NULL_HANDLE || loadOp == VK_ATTACHMENT_LOAD_OP_CLEAR) {
if (rendererData->currentRenderPass != VK_NULL_HANDLE) {
vkCmdEndRenderPass(rendererData->currentCommandBuffer);
rendererData->currentRenderPass = VK_NULL_HANDLE;
}
VULKAN_BeginRenderPass(rendererData, loadOp, clearColor);
}
// Bind cached VB now
if (stateCache->vertexBuffer != VK_NULL_HANDLE) {
VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(rendererData->currentCommandBuffer, 0, 1, &stateCache->vertexBuffer, &offset);
}
return true;
}
static void VULKAN_WaitForGPU(VULKAN_RenderData *rendererData)
{
vkQueueWaitIdle(rendererData->graphicsQueue);
}
static void VULKAN_ResetCommandList(VULKAN_RenderData *rendererData)
{
vkResetCommandBuffer(rendererData->currentCommandBuffer, 0);
for (uint32_t i = 0; i < rendererData->numDescriptorPools[rendererData->currentCommandBufferIndex]; i++) {
vkResetDescriptorPool(rendererData->device, rendererData->descriptorPools[rendererData->currentCommandBufferIndex][i], 0);
}
VkCommandBufferBeginInfo beginInfo = { 0 };
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.flags = 0;
vkBeginCommandBuffer(rendererData->currentCommandBuffer, &beginInfo);
rendererData->currentPipelineState = NULL;
rendererData->currentVertexBuffer = 0;
rendererData->issueBatch = false;
rendererData->cliprectDirty = true;
rendererData->currentDescriptorSetIndex = 0;
rendererData->currentDescriptorPoolIndex = 0;
rendererData->currentConstantBufferOffset = -1;
rendererData->currentConstantBufferIndex = 0;
// Release any upload buffers that were inflight
for (int i = 0; i < rendererData->currentUploadBuffer[rendererData->currentCommandBufferIndex]; ++i) {
VULKAN_DestroyBuffer(rendererData, &rendererData->uploadBuffers[rendererData->currentCommandBufferIndex][i]);
}
rendererData->currentUploadBuffer[rendererData->currentCommandBufferIndex] = 0;
}
static VkResult VULKAN_IssueBatch(VULKAN_RenderData *rendererData)
{
VkResult result;
if (rendererData->currentCommandBuffer == VK_NULL_HANDLE) {
return VK_SUCCESS;
}
if (rendererData->currentRenderPass) {
vkCmdEndRenderPass(rendererData->currentCommandBuffer);
rendererData->currentRenderPass = VK_NULL_HANDLE;
}
rendererData->currentPipelineState = VK_NULL_HANDLE;
rendererData->viewportDirty = true;
vkEndCommandBuffer(rendererData->currentCommandBuffer);
VkSubmitInfo submitInfo = { 0 };
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &rendererData->currentCommandBuffer;
if (rendererData->waitRenderSemaphoreCount > 0) {
Uint32 additionalSemaphoreCount = (rendererData->currentImageAvailableSemaphore != VK_NULL_HANDLE) ? 1 : 0;
submitInfo.waitSemaphoreCount = rendererData->waitRenderSemaphoreCount + additionalSemaphoreCount;
if (additionalSemaphoreCount > 0) {
rendererData->waitRenderSemaphores[rendererData->waitRenderSemaphoreCount] = rendererData->currentImageAvailableSemaphore;
rendererData->waitDestStageMasks[rendererData->waitRenderSemaphoreCount] = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
}
submitInfo.pWaitSemaphores = rendererData->waitRenderSemaphores;
submitInfo.pWaitDstStageMask = rendererData->waitDestStageMasks;
rendererData->waitRenderSemaphoreCount = 0;
} else if (rendererData->currentImageAvailableSemaphore != VK_NULL_HANDLE) {
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &rendererData->currentImageAvailableSemaphore;
submitInfo.pWaitDstStageMask = &waitDestStageMask;
}
result = vkQueueSubmit(rendererData->graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
rendererData->currentImageAvailableSemaphore = VK_NULL_HANDLE;
VULKAN_WaitForGPU(rendererData);
VULKAN_ResetCommandList(rendererData);
return result;
}
static void VULKAN_DestroyRenderer(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
if (rendererData) {
if (rendererData->device != VK_NULL_HANDLE) {
vkDeviceWaitIdle(rendererData->device);
VULKAN_DestroyAll(renderer);
}
SDL_free(rendererData);
}
}
static VkBlendFactor GetBlendFactor(SDL_BlendFactor factor)
{
switch (factor) {
case SDL_BLENDFACTOR_ZERO:
return VK_BLEND_FACTOR_ZERO;
case SDL_BLENDFACTOR_ONE:
return VK_BLEND_FACTOR_ONE;
case SDL_BLENDFACTOR_SRC_COLOR:
return VK_BLEND_FACTOR_SRC_COLOR;
case SDL_BLENDFACTOR_ONE_MINUS_SRC_COLOR:
return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
case SDL_BLENDFACTOR_SRC_ALPHA:
return VK_BLEND_FACTOR_SRC_ALPHA;
case SDL_BLENDFACTOR_ONE_MINUS_SRC_ALPHA:
return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
case SDL_BLENDFACTOR_DST_COLOR:
return VK_BLEND_FACTOR_DST_COLOR;
case SDL_BLENDFACTOR_ONE_MINUS_DST_COLOR:
return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
case SDL_BLENDFACTOR_DST_ALPHA:
return VK_BLEND_FACTOR_DST_ALPHA;
case SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA:
return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
default:
return VK_BLEND_FACTOR_MAX_ENUM;
}
}
static VkBlendOp GetBlendOp(SDL_BlendOperation operation)
{
switch (operation) {
case SDL_BLENDOPERATION_ADD:
return VK_BLEND_OP_ADD;
case SDL_BLENDOPERATION_SUBTRACT:
return VK_BLEND_OP_SUBTRACT;
case SDL_BLENDOPERATION_REV_SUBTRACT:
return VK_BLEND_OP_REVERSE_SUBTRACT;
case SDL_BLENDOPERATION_MINIMUM:
return VK_BLEND_OP_MIN;
case SDL_BLENDOPERATION_MAXIMUM:
return VK_BLEND_OP_MAX;
default:
return VK_BLEND_OP_MAX_ENUM;
}
}
static VULKAN_PipelineState *VULKAN_CreatePipelineState(SDL_Renderer *renderer,
VULKAN_Shader shader, VkPipelineLayout pipelineLayout, VkDescriptorSetLayout descriptorSetLayout, SDL_BlendMode blendMode, VkPrimitiveTopology topology, VkFormat format)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VULKAN_PipelineState *pipelineStates;
VkPipeline pipeline = VK_NULL_HANDLE;
VkResult result = VK_SUCCESS;
VkPipelineVertexInputStateCreateInfo vertexInputCreateInfo = { 0 };
VkPipelineInputAssemblyStateCreateInfo inputAssemblyStateCreateInfo = { 0 };
VkVertexInputAttributeDescription attributeDescriptions[3];
VkVertexInputBindingDescription bindingDescriptions[1];
VkPipelineShaderStageCreateInfo shaderStageCreateInfo[2];
VkPipelineDynamicStateCreateInfo dynamicStateCreateInfo = { 0 };
VkPipelineViewportStateCreateInfo viewportStateCreateInfo = { 0 };
VkPipelineRasterizationStateCreateInfo rasterizationStateCreateInfo = { 0 };
VkPipelineMultisampleStateCreateInfo multisampleStateCreateInfo = { 0 };
VkPipelineDepthStencilStateCreateInfo depthStencilStateCreateInfo = { 0 };
VkPipelineColorBlendStateCreateInfo colorBlendStateCreateInfo = { 0 };
VkGraphicsPipelineCreateInfo pipelineCreateInfo = { 0 };
pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
pipelineCreateInfo.flags = 0;
pipelineCreateInfo.pStages = shaderStageCreateInfo;
pipelineCreateInfo.pVertexInputState = &vertexInputCreateInfo;
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyStateCreateInfo;
pipelineCreateInfo.pViewportState = &viewportStateCreateInfo;
pipelineCreateInfo.pRasterizationState = &rasterizationStateCreateInfo;
pipelineCreateInfo.pMultisampleState = &multisampleStateCreateInfo;
pipelineCreateInfo.pDepthStencilState = &depthStencilStateCreateInfo;
pipelineCreateInfo.pColorBlendState = &colorBlendStateCreateInfo;
pipelineCreateInfo.pDynamicState = &dynamicStateCreateInfo;
// Shaders
const char *name = "main";
for (uint32_t i = 0; i < 2; i++) {
SDL_zero(shaderStageCreateInfo[i]);
shaderStageCreateInfo[i].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
shaderStageCreateInfo[i].module = (i == 0) ? rendererData->vertexShaderModules[shader] : rendererData->fragmentShaderModules[shader];
shaderStageCreateInfo[i].stage = (i == 0) ? VK_SHADER_STAGE_VERTEX_BIT : VK_SHADER_STAGE_FRAGMENT_BIT;
shaderStageCreateInfo[i].pName = name;
}
pipelineCreateInfo.stageCount = 2;
pipelineCreateInfo.pStages = &shaderStageCreateInfo[0];
// Vertex input
vertexInputCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vertexInputCreateInfo.vertexAttributeDescriptionCount = 3;
vertexInputCreateInfo.pVertexAttributeDescriptions = &attributeDescriptions[0];
vertexInputCreateInfo.vertexBindingDescriptionCount = 1;
vertexInputCreateInfo.pVertexBindingDescriptions = &bindingDescriptions[0];
attributeDescriptions[ 0 ].binding = 0;
attributeDescriptions[ 0 ].format = VK_FORMAT_R32G32_SFLOAT;
attributeDescriptions[ 0 ].location = 0;
attributeDescriptions[ 0 ].offset = 0;
attributeDescriptions[ 1 ].binding = 0;
attributeDescriptions[ 1 ].format = VK_FORMAT_R32G32_SFLOAT;
attributeDescriptions[ 1 ].location = 1;
attributeDescriptions[ 1 ].offset = 8;
attributeDescriptions[ 2 ].binding = 0;
attributeDescriptions[ 2 ].format = VK_FORMAT_R32G32B32A32_SFLOAT;
attributeDescriptions[ 2 ].location = 2;
attributeDescriptions[ 2 ].offset = 16;
bindingDescriptions[ 0 ].binding = 0;
bindingDescriptions[ 0 ].inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
bindingDescriptions[ 0 ].stride = 32;
// Input assembly
inputAssemblyStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
inputAssemblyStateCreateInfo.topology = topology;
inputAssemblyStateCreateInfo.primitiveRestartEnable = VK_FALSE;
viewportStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
viewportStateCreateInfo.scissorCount = 1;
viewportStateCreateInfo.viewportCount = 1;
// Dynamic states
dynamicStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
VkDynamicState dynamicStates[2] = {
VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_SCISSOR
};
dynamicStateCreateInfo.dynamicStateCount = SDL_arraysize(dynamicStates);
dynamicStateCreateInfo.pDynamicStates = dynamicStates;
// Rasterization state
rasterizationStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rasterizationStateCreateInfo.depthClampEnable = VK_FALSE;
rasterizationStateCreateInfo.rasterizerDiscardEnable = VK_FALSE;
rasterizationStateCreateInfo.cullMode = VK_CULL_MODE_NONE;
rasterizationStateCreateInfo.polygonMode = VK_POLYGON_MODE_FILL;
rasterizationStateCreateInfo.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
rasterizationStateCreateInfo.depthBiasEnable = VK_FALSE;
rasterizationStateCreateInfo.depthBiasConstantFactor = 0.0f;
rasterizationStateCreateInfo.depthBiasClamp = 0.0f;
rasterizationStateCreateInfo.depthBiasSlopeFactor = 0.0f;
rasterizationStateCreateInfo.lineWidth = 1.0f;
// MSAA state
multisampleStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
VkSampleMask multiSampleMask = 0xFFFFFFFF;
multisampleStateCreateInfo.pSampleMask = &multiSampleMask;
multisampleStateCreateInfo.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
// Depth Stencil
depthStencilStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
// Color blend
VkPipelineColorBlendAttachmentState colorBlendAttachment = { 0 };
colorBlendStateCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
colorBlendStateCreateInfo.attachmentCount = 1;
colorBlendStateCreateInfo.pAttachments = &colorBlendAttachment;
colorBlendAttachment.blendEnable = VK_TRUE;
colorBlendAttachment.srcColorBlendFactor = GetBlendFactor(SDL_GetBlendModeSrcColorFactor(blendMode));
colorBlendAttachment.srcAlphaBlendFactor = GetBlendFactor(SDL_GetBlendModeSrcAlphaFactor(blendMode));
colorBlendAttachment.colorBlendOp = GetBlendOp(SDL_GetBlendModeColorOperation(blendMode));
colorBlendAttachment.dstColorBlendFactor = GetBlendFactor(SDL_GetBlendModeDstColorFactor(blendMode));
colorBlendAttachment.dstAlphaBlendFactor = GetBlendFactor(SDL_GetBlendModeDstAlphaFactor(blendMode));
colorBlendAttachment.alphaBlendOp = GetBlendOp(SDL_GetBlendModeAlphaOperation(blendMode));
colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
// Renderpass / layout
pipelineCreateInfo.renderPass = rendererData->currentRenderPass;
pipelineCreateInfo.subpass = 0;
pipelineCreateInfo.layout = pipelineLayout;
result = vkCreateGraphicsPipelines(rendererData->device, VK_NULL_HANDLE, 1, &pipelineCreateInfo, NULL, &pipeline);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateGraphicsPipelines()", result);
return NULL;
}
pipelineStates = (VULKAN_PipelineState *)SDL_realloc(rendererData->pipelineStates, (rendererData->pipelineStateCount + 1) * sizeof(*pipelineStates));
if (!pipelineStates) {
return NULL;
}
pipelineStates[rendererData->pipelineStateCount].shader = shader;
pipelineStates[rendererData->pipelineStateCount].blendMode = blendMode;
pipelineStates[rendererData->pipelineStateCount].topology = topology;
pipelineStates[rendererData->pipelineStateCount].format = format;
pipelineStates[rendererData->pipelineStateCount].pipeline = pipeline;
pipelineStates[rendererData->pipelineStateCount].descriptorSetLayout = descriptorSetLayout;
pipelineStates[rendererData->pipelineStateCount].pipelineLayout = pipelineCreateInfo.layout;
rendererData->pipelineStates = pipelineStates;
++rendererData->pipelineStateCount;
return &pipelineStates[rendererData->pipelineStateCount - 1];
}
static bool VULKAN_FindMemoryTypeIndex(VULKAN_RenderData *rendererData, uint32_t typeBits, VkMemoryPropertyFlags requiredFlags, VkMemoryPropertyFlags desiredFlags, uint32_t *memoryTypeIndexOut)
{
uint32_t memoryTypeIndex = 0;
bool foundExactMatch = false;
// Desired flags must be a superset of required flags.
desiredFlags |= requiredFlags;
for (memoryTypeIndex = 0; memoryTypeIndex < rendererData->physicalDeviceMemoryProperties.memoryTypeCount; memoryTypeIndex++) {
if (typeBits & (1 << memoryTypeIndex)) {
if (rendererData->physicalDeviceMemoryProperties.memoryTypes[memoryTypeIndex].propertyFlags == desiredFlags) {
foundExactMatch = true;
break;
}
}
}
if (!foundExactMatch) {
for (memoryTypeIndex = 0; memoryTypeIndex < rendererData->physicalDeviceMemoryProperties.memoryTypeCount; memoryTypeIndex++) {
if (typeBits & (1 << memoryTypeIndex)) {
if ((rendererData->physicalDeviceMemoryProperties.memoryTypes[memoryTypeIndex].propertyFlags & requiredFlags) == requiredFlags) {
break;
}
}
}
}
if (memoryTypeIndex >= rendererData->physicalDeviceMemoryProperties.memoryTypeCount) {
SET_ERROR_MESSAGE("Unable to find memory type for allocation");
return false;
}
*memoryTypeIndexOut = memoryTypeIndex;
return true;
}
static VkResult VULKAN_CreateVertexBuffer(VULKAN_RenderData *rendererData, size_t vbidx, size_t size)
{
VkResult result;
VULKAN_DestroyBuffer(rendererData, &rendererData->vertexBuffers[vbidx]);
result = VULKAN_AllocateBuffer(rendererData, size,
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&rendererData->vertexBuffers[vbidx]);
if (result != VK_SUCCESS) {
return result;
}
return result;
}
static bool VULKAN_LoadGlobalFunctions(VULKAN_RenderData *rendererData)
{
#define VULKAN_DEVICE_FUNCTION(name)
#define VULKAN_GLOBAL_FUNCTION(name) \
name = (PFN_##name)rendererData->vkGetInstanceProcAddr(VK_NULL_HANDLE, #name); \
if (!name) { \
SET_ERROR_MESSAGE("vkGetInstanceProcAddr(VK_NULL_HANDLE, \"" #name "\") failed"); \
return false; \
}
#define VULKAN_INSTANCE_FUNCTION(name)
#define VULKAN_OPTIONAL_INSTANCE_FUNCTION(name)
#define VULKAN_OPTIONAL_DEVICE_FUNCTION(name)
VULKAN_FUNCTIONS()
#undef VULKAN_DEVICE_FUNCTION
#undef VULKAN_GLOBAL_FUNCTION
#undef VULKAN_INSTANCE_FUNCTION
#undef VULKAN_OPTIONAL_INSTANCE_FUNCTION
#undef VULKAN_OPTIONAL_DEVICE_FUNCTION
return true;
}
static bool VULKAN_LoadInstanceFunctions(VULKAN_RenderData *rendererData)
{
#define VULKAN_DEVICE_FUNCTION(name)
#define VULKAN_GLOBAL_FUNCTION(name)
#define VULKAN_INSTANCE_FUNCTION(name) \
name = (PFN_##name)rendererData->vkGetInstanceProcAddr(rendererData->instance, #name); \
if (!name) { \
SET_ERROR_MESSAGE("vkGetInstanceProcAddr(instance, \"" #name "\") failed"); \
return false; \
}
#define VULKAN_OPTIONAL_INSTANCE_FUNCTION(name) \
name = (PFN_##name)rendererData->vkGetInstanceProcAddr(rendererData->instance, #name);
#define VULKAN_OPTIONAL_DEVICE_FUNCTION(name)
VULKAN_FUNCTIONS()
#undef VULKAN_DEVICE_FUNCTION
#undef VULKAN_GLOBAL_FUNCTION
#undef VULKAN_INSTANCE_FUNCTION
#undef VULKAN_OPTIONAL_INSTANCE_FUNCTION
#undef VULKAN_OPTIONAL_DEVICE_FUNCTION
return true;
}
static bool VULKAN_LoadDeviceFunctions(VULKAN_RenderData *rendererData)
{
#define VULKAN_DEVICE_FUNCTION(name) \
name = (PFN_##name)vkGetDeviceProcAddr(rendererData->device, #name); \
if (!name) { \
SET_ERROR_MESSAGE("vkGetDeviceProcAddr(device, \"" #name "\") failed"); \
return false; \
}
#define VULKAN_GLOBAL_FUNCTION(name)
#define VULKAN_OPTIONAL_DEVICE_FUNCTION(name) \
name = (PFN_##name)vkGetDeviceProcAddr(rendererData->device, #name);
#define VULKAN_INSTANCE_FUNCTION(name)
#define VULKAN_OPTIONAL_INSTANCE_FUNCTION(name)
VULKAN_FUNCTIONS()
#undef VULKAN_DEVICE_FUNCTION
#undef VULKAN_GLOBAL_FUNCTION
#undef VULKAN_INSTANCE_FUNCTION
#undef VULKAN_OPTIONAL_INSTANCE_FUNCTION
#undef VULKAN_OPTIONAL_DEVICE_FUNCTION
return true;
}
static VkResult VULKAN_FindPhysicalDevice(VULKAN_RenderData *rendererData)
{
uint32_t physicalDeviceCount = 0;
VkPhysicalDevice *physicalDevices;
VkQueueFamilyProperties *queueFamiliesProperties = NULL;
uint32_t queueFamiliesPropertiesAllocatedSize = 0;
VkExtensionProperties *deviceExtensions = NULL;
uint32_t deviceExtensionsAllocatedSize = 0;
uint32_t physicalDeviceIndex;
VkResult result;
result = vkEnumeratePhysicalDevices(rendererData->instance, &physicalDeviceCount, NULL);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkEnumeratePhysicalDevices()", result);
return result;
}
if (physicalDeviceCount == 0) {
SET_ERROR_MESSAGE("vkEnumeratePhysicalDevices(): no physical devices");
return VK_ERROR_UNKNOWN;
}
physicalDevices = (VkPhysicalDevice *)SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
result = vkEnumeratePhysicalDevices(rendererData->instance, &physicalDeviceCount, physicalDevices);
if (result != VK_SUCCESS) {
SDL_free(physicalDevices);
SET_ERROR_CODE("vkEnumeratePhysicalDevices()", result);
return result;
}
rendererData->physicalDevice = NULL;
for (physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount; physicalDeviceIndex++) {
uint32_t queueFamiliesCount = 0;
uint32_t queueFamilyIndex;
uint32_t deviceExtensionCount = 0;
bool hasSwapchainExtension = false;
uint32_t i;
VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
vkGetPhysicalDeviceProperties(physicalDevice, &rendererData->physicalDeviceProperties);
if (VK_VERSION_MAJOR(rendererData->physicalDeviceProperties.apiVersion) < 1) {
continue;
}
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &rendererData->physicalDeviceMemoryProperties);
vkGetPhysicalDeviceFeatures(physicalDevice, &rendererData->physicalDeviceFeatures);
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, NULL);
if (queueFamiliesCount == 0) {
continue;
}
if (queueFamiliesPropertiesAllocatedSize < queueFamiliesCount) {
SDL_free(queueFamiliesProperties);
queueFamiliesPropertiesAllocatedSize = queueFamiliesCount;
queueFamiliesProperties = (VkQueueFamilyProperties *)SDL_malloc(sizeof(VkQueueFamilyProperties) * queueFamiliesPropertiesAllocatedSize);
if (!queueFamiliesProperties) {
SDL_free(physicalDevices);
SDL_free(deviceExtensions);
return VK_ERROR_UNKNOWN;
}
}
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueFamiliesCount, queueFamiliesProperties);
rendererData->graphicsQueueFamilyIndex = queueFamiliesCount;
rendererData->presentQueueFamilyIndex = queueFamiliesCount;
for (queueFamilyIndex = 0; queueFamilyIndex < queueFamiliesCount; queueFamilyIndex++) {
VkBool32 supported = 0;
if (queueFamiliesProperties[queueFamilyIndex].queueCount == 0) {
continue;
}
if (queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
rendererData->graphicsQueueFamilyIndex = queueFamilyIndex;
}
result = vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, rendererData->surface, &supported);
if (result != VK_SUCCESS) {
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_free(deviceExtensions);
SET_ERROR_CODE("vkGetPhysicalDeviceSurfaceSupportKHR()", result);
return VK_ERROR_UNKNOWN;
}
if (supported) {
rendererData->presentQueueFamilyIndex = queueFamilyIndex;
if (queueFamiliesProperties[queueFamilyIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
break; // use this queue because it can present and do graphics
}
}
}
if (rendererData->graphicsQueueFamilyIndex == queueFamiliesCount) { // no good queues found
continue;
}
if (rendererData->presentQueueFamilyIndex == queueFamiliesCount) { // no good queues found
continue;
}
result = vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, NULL);
if (result != VK_SUCCESS) {
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_free(deviceExtensions);
SET_ERROR_CODE("vkEnumerateDeviceExtensionProperties()", result);
return VK_ERROR_UNKNOWN;
}
if (deviceExtensionCount == 0) {
continue;
}
if (deviceExtensionsAllocatedSize < deviceExtensionCount) {
SDL_free(deviceExtensions);
deviceExtensionsAllocatedSize = deviceExtensionCount;
deviceExtensions = (VkExtensionProperties *)SDL_malloc(sizeof(VkExtensionProperties) * deviceExtensionsAllocatedSize);
if (!deviceExtensions) {
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
return VK_ERROR_UNKNOWN;
}
}
result = vkEnumerateDeviceExtensionProperties(physicalDevice, NULL, &deviceExtensionCount, deviceExtensions);
if (result != VK_SUCCESS) {
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_free(deviceExtensions);
SET_ERROR_CODE("vkEnumerateDeviceExtensionProperties()", result);
return result;
}
for (i = 0; i < deviceExtensionCount; i++) {
if (SDL_strcmp(deviceExtensions[i].extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0) {
hasSwapchainExtension = true;
break;
}
}
if (!hasSwapchainExtension) {
continue;
}
rendererData->physicalDevice = physicalDevice;
break;
}
SDL_free(physicalDevices);
SDL_free(queueFamiliesProperties);
SDL_free(deviceExtensions);
if (!rendererData->physicalDevice) {
SET_ERROR_MESSAGE("No viable physical devices found");
return VK_ERROR_UNKNOWN;
}
return VK_SUCCESS;
}
static VkResult VULKAN_GetSurfaceFormats(VULKAN_RenderData *rendererData)
{
VkResult result = vkGetPhysicalDeviceSurfaceFormatsKHR(rendererData->physicalDevice,
rendererData->surface,
&rendererData->surfaceFormatsCount,
NULL);
if (result != VK_SUCCESS) {
rendererData->surfaceFormatsCount = 0;
SET_ERROR_CODE("vkGetPhysicalDeviceSurfaceFormatsKHR()", result);
return result;
}
if (rendererData->surfaceFormatsCount > rendererData->surfaceFormatsAllocatedCount) {
rendererData->surfaceFormatsAllocatedCount = rendererData->surfaceFormatsCount;
SDL_free(rendererData->surfaceFormats);
rendererData->surfaceFormats = (VkSurfaceFormatKHR *)SDL_malloc(sizeof(VkSurfaceFormatKHR) * rendererData->surfaceFormatsAllocatedCount);
}
result = vkGetPhysicalDeviceSurfaceFormatsKHR(rendererData->physicalDevice,
rendererData->surface,
&rendererData->surfaceFormatsCount,
rendererData->surfaceFormats);
if (result != VK_SUCCESS) {
rendererData->surfaceFormatsCount = 0;
SET_ERROR_CODE("vkGetPhysicalDeviceSurfaceFormatsKHR()", result);
return result;
}
return VK_SUCCESS;
}
static VkSemaphore VULKAN_CreateSemaphore(VULKAN_RenderData *rendererData)
{
VkResult result;
VkSemaphore semaphore = VK_NULL_HANDLE;
VkSemaphoreCreateInfo semaphoreCreateInfo = { 0 };
semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
result = vkCreateSemaphore(rendererData->device, &semaphoreCreateInfo, NULL, &semaphore);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateSemaphore()", result);
return VK_NULL_HANDLE;
}
return semaphore;
}
static bool VULKAN_DeviceExtensionsFound(VULKAN_RenderData *rendererData, int extensionsToCheck, const char * const *extNames)
{
uint32_t extensionCount;
bool foundExtensions = true;
VkResult result = vkEnumerateDeviceExtensionProperties(rendererData->physicalDevice, NULL, &extensionCount, NULL);
if (result != VK_SUCCESS ) {
SET_ERROR_CODE("vkEnumerateDeviceExtensionProperties()", result);
return false;
}
if (extensionCount > 0 ) {
VkExtensionProperties *extensionProperties = (VkExtensionProperties *)SDL_calloc(extensionCount, sizeof(VkExtensionProperties));
result = vkEnumerateDeviceExtensionProperties(rendererData->physicalDevice, NULL, &extensionCount, extensionProperties);
if (result != VK_SUCCESS ) {
SET_ERROR_CODE("vkEnumerateDeviceExtensionProperties()", result);
SDL_free(extensionProperties);
return false;
}
for (int ext = 0; ext < extensionsToCheck && foundExtensions; ext++) {
bool foundExtension = false;
for (uint32_t i = 0; i < extensionCount; i++) {
if (SDL_strcmp(extensionProperties[i].extensionName, extNames[ext]) == 0) {
foundExtension = true;
break;
}
}
foundExtensions &= foundExtension;
}
SDL_free(extensionProperties);
}
return foundExtensions;
}
static bool VULKAN_InstanceExtensionFound(VULKAN_RenderData *rendererData, const char *extName)
{
uint32_t extensionCount;
VkResult result = vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, NULL);
if (result != VK_SUCCESS ) {
SET_ERROR_CODE("vkEnumerateInstanceExtensionProperties()", result);
return false;
}
if (extensionCount > 0 ) {
VkExtensionProperties *extensionProperties = (VkExtensionProperties *)SDL_calloc(extensionCount, sizeof(VkExtensionProperties));
result = vkEnumerateInstanceExtensionProperties(NULL, &extensionCount, extensionProperties);
if (result != VK_SUCCESS ) {
SET_ERROR_CODE("vkEnumerateInstanceExtensionProperties()", result);
SDL_free(extensionProperties);
return false;
}
for (uint32_t i = 0; i< extensionCount; i++) {
if (SDL_strcmp(extensionProperties[i].extensionName, extName) == 0) {
SDL_free(extensionProperties);
return true;
}
}
SDL_free(extensionProperties);
}
return false;
}
static bool VULKAN_ValidationLayersFound(void)
{
uint32_t instanceLayerCount = 0;
uint32_t i;
bool foundValidation = false;
vkEnumerateInstanceLayerProperties(&instanceLayerCount, NULL);
if (instanceLayerCount > 0) {
VkLayerProperties *instanceLayers = (VkLayerProperties *)SDL_calloc(instanceLayerCount, sizeof(VkLayerProperties));
vkEnumerateInstanceLayerProperties(&instanceLayerCount, instanceLayers);
for (i = 0; i < instanceLayerCount; i++) {
if (!SDL_strcmp(SDL_VULKAN_VALIDATION_LAYER_NAME, instanceLayers[i].layerName)) {
foundValidation = true;
break;
}
}
SDL_free(instanceLayers);
}
return foundValidation;
}
// Create resources that depend on the device.
static VkResult VULKAN_CreateDeviceResources(SDL_Renderer *renderer, SDL_PropertiesID create_props)
{
static const char *const YCbCrDeviceExtensionNames[] = {
// VK_KHR_sampler_ycbcr_conversion + dependent extensions
VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME,
VK_KHR_MAINTENANCE1_EXTENSION_NAME,
VK_KHR_MAINTENANCE2_EXTENSION_NAME,
VK_KHR_BIND_MEMORY_2_EXTENSION_NAME,
VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME,
};
#ifdef SDL_PLATFORM_ANDROID
static const char *const AndroidMemoryDeviceExtensionNames[] = {
// VK_ANDROID_external_memory_android_hardware_buffer + dependent extensions
VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME,
VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME,
VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME,
VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME,
};
#define ANDROID_EXTENSION_COUNT SDL_arraysize(AndroidMemoryDeviceExtensionNames)
#else
#define ANDROID_EXTENSION_COUNT 0
#endif
static const char *const HdrMetadataExtensionNames[] = {
VK_EXT_HDR_METADATA_EXTENSION_NAME
};
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VkResult result = VK_SUCCESS;
PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL;
bool createDebug = SDL_GetHintBoolean(SDL_HINT_RENDER_VULKAN_DEBUG, false);
const char *validationLayerName[] = { SDL_VULKAN_VALIDATION_LAYER_NAME };
if (!SDL_Vulkan_LoadLibrary(NULL)) {
SDL_LogDebug(SDL_LOG_CATEGORY_RENDER, "SDL_Vulkan_LoadLibrary failed" );
return VK_ERROR_UNKNOWN;
}
vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)SDL_Vulkan_GetVkGetInstanceProcAddr();
if(!vkGetInstanceProcAddr) {
SDL_LogDebug(SDL_LOG_CATEGORY_RENDER, "vkGetInstanceProcAddr is NULL" );
return VK_ERROR_UNKNOWN;
}
// Load global Vulkan functions
rendererData->vkGetInstanceProcAddr = vkGetInstanceProcAddr;
if (!VULKAN_LoadGlobalFunctions(rendererData)) {
return VK_ERROR_UNKNOWN;
}
// Check for colorspace extension
if (renderer->output_colorspace == SDL_COLORSPACE_SRGB_LINEAR ||
renderer->output_colorspace == SDL_COLORSPACE_HDR10) {
rendererData->supportsEXTSwapchainColorspace = VULKAN_InstanceExtensionFound(rendererData, VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME);
if (!rendererData->supportsEXTSwapchainColorspace) {
SDL_SetError("Using HDR output but %s not supported", VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME);
return VK_ERROR_UNKNOWN;
}
}
// Check for VK_KHR_get_physical_device_properties2
rendererData->supportsKHRGetPhysicalDeviceProperties2 = VULKAN_InstanceExtensionFound(rendererData, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME);
// Check for VK_KHR_external_memory_capabilities, which we need to import hardware buffers
rendererData->supportsKHRExternalMemoryCapabilities = VULKAN_InstanceExtensionFound(rendererData, VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME);
// Create VkInstance
rendererData->instance = (VkInstance)SDL_GetPointerProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_INSTANCE_POINTER, NULL);
if (rendererData->instance) {
rendererData->instance_external = true;
} else {
VkInstanceCreateInfo instanceCreateInfo = { 0 };
VkApplicationInfo appInfo = { 0 };
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.apiVersion = VK_API_VERSION_1_0;
instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
instanceCreateInfo.pApplicationInfo = &appInfo;
char const *const *instanceExtensions = SDL_Vulkan_GetInstanceExtensions(&instanceCreateInfo.enabledExtensionCount);
const char **instanceExtensionsCopy = (const char **)SDL_calloc(instanceCreateInfo.enabledExtensionCount + 3, sizeof(const char *));
for (uint32_t i = 0; i < instanceCreateInfo.enabledExtensionCount; i++) {
instanceExtensionsCopy[i] = instanceExtensions[i];
}
if (rendererData->supportsEXTSwapchainColorspace) {
instanceExtensionsCopy[instanceCreateInfo.enabledExtensionCount] = VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME;
instanceCreateInfo.enabledExtensionCount++;
}
if (rendererData->supportsKHRGetPhysicalDeviceProperties2) {
instanceExtensionsCopy[instanceCreateInfo.enabledExtensionCount] = VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME;
instanceCreateInfo.enabledExtensionCount++;
}
if (rendererData->supportsKHRExternalMemoryCapabilities) {
instanceExtensionsCopy[instanceCreateInfo.enabledExtensionCount] = VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME;
instanceCreateInfo.enabledExtensionCount++;
}
instanceCreateInfo.ppEnabledExtensionNames = (const char *const *)instanceExtensionsCopy;
if (createDebug && VULKAN_ValidationLayersFound()) {
instanceCreateInfo.ppEnabledLayerNames = validationLayerName;
instanceCreateInfo.enabledLayerCount = 1;
}
result = vkCreateInstance(&instanceCreateInfo, NULL, &rendererData->instance);
SDL_free((void *)instanceExtensionsCopy);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateInstance()", result);
return result;
}
}
// Load instance Vulkan functions
if (!VULKAN_LoadInstanceFunctions(rendererData)) {
VULKAN_DestroyAll(renderer);
return VK_ERROR_UNKNOWN;
}
// Create Vulkan surface
rendererData->surface = (VkSurfaceKHR)SDL_GetNumberProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_SURFACE_NUMBER, 0);
if (rendererData->surface) {
rendererData->surface_external = true;
} else {
if (!SDL_Vulkan_CreateSurface(renderer->window, rendererData->instance, NULL, &rendererData->surface)) {
VULKAN_DestroyAll(renderer);
return VK_ERROR_UNKNOWN;
}
}
// Choose Vulkan physical device
rendererData->physicalDevice = (VkPhysicalDevice)SDL_GetPointerProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_PHYSICAL_DEVICE_POINTER, NULL);
if (rendererData->physicalDevice) {
vkGetPhysicalDeviceProperties(rendererData->physicalDevice, &rendererData->physicalDeviceProperties);
vkGetPhysicalDeviceMemoryProperties(rendererData->physicalDevice, &rendererData->physicalDeviceMemoryProperties);
vkGetPhysicalDeviceFeatures(rendererData->physicalDevice, &rendererData->physicalDeviceFeatures);
} else {
if (VULKAN_FindPhysicalDevice(rendererData) != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
return VK_ERROR_UNKNOWN;
}
}
if (SDL_HasProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER)) {
rendererData->graphicsQueueFamilyIndex = (uint32_t)SDL_GetNumberProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER, 0);
}
if (SDL_HasProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER)) {
rendererData->presentQueueFamilyIndex = (uint32_t)SDL_GetNumberProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER, 0);
}
if (rendererData->supportsKHRGetPhysicalDeviceProperties2 &&
VULKAN_DeviceExtensionsFound(rendererData, SDL_arraysize(YCbCrDeviceExtensionNames), YCbCrDeviceExtensionNames)) {
rendererData->supportsKHRSamplerYCbCrConversion = true;
}
#ifdef SDL_PLATFORM_ANDROID
if (rendererData->supportsKHRSamplerYCbCrConversion &&
rendererData->supportsKHRExternalMemoryCapabilities &&
VULKAN_DeviceExtensionsFound(rendererData, SDL_arraysize(AndroidMemoryDeviceExtensionNames), AndroidMemoryDeviceExtensionNames)) {
rendererData->supportsANDROIDExternalMemoryAndroidHardwareBuffer = true;
}
#endif
// Check for HDR metadata extension
if (renderer->output_colorspace == SDL_COLORSPACE_HDR10 &&
VULKAN_DeviceExtensionsFound(rendererData, SDL_arraysize(HdrMetadataExtensionNames), HdrMetadataExtensionNames)) {
rendererData->supportsEXTHdrMetadata = true;
}
// Create Vulkan device
rendererData->device = (VkDevice)SDL_GetPointerProperty(create_props, SDL_PROP_RENDERER_CREATE_VULKAN_DEVICE_POINTER, NULL);
if (rendererData->device) {
rendererData->device_external = true;
} else {
VkPhysicalDeviceSamplerYcbcrConversionFeatures deviceSamplerYcbcrConversionFeatures = { 0 };
VkDeviceQueueCreateInfo deviceQueueCreateInfo[2] = { { 0 }, { 0 } };
static const float queuePriority[] = { 1.0f };
VkDeviceCreateInfo deviceCreateInfo = { 0 };
deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
deviceCreateInfo.queueCreateInfoCount = 0;
deviceCreateInfo.pQueueCreateInfos = deviceQueueCreateInfo;
deviceCreateInfo.pEnabledFeatures = NULL;
uint32_t enabledExtensionCount = 0;
const char *enabledExtensionNames[1 + SDL_arraysize(YCbCrDeviceExtensionNames) + ANDROID_EXTENSION_COUNT + SDL_arraysize(HdrMetadataExtensionNames)];
enabledExtensionNames[enabledExtensionCount++] = VK_KHR_SWAPCHAIN_EXTENSION_NAME;
if (rendererData->supportsKHRSamplerYCbCrConversion) {
for (int i = 0; i < SDL_arraysize(YCbCrDeviceExtensionNames); ++i) {
enabledExtensionNames[enabledExtensionCount++] = YCbCrDeviceExtensionNames[i];
}
}
#ifdef SDL_PLATFORM_ANDROID
if (rendererData->supportsANDROIDExternalMemoryAndroidHardwareBuffer) {
for (int i = 0; i < SDL_arraysize(AndroidMemoryDeviceExtensionNames); ++i) {
enabledExtensionNames[enabledExtensionCount++] = AndroidMemoryDeviceExtensionNames[i];
}
}
#endif
if (rendererData->supportsEXTHdrMetadata) {
for (int i = 0; i < SDL_arraysize(HdrMetadataExtensionNames); ++i) {
enabledExtensionNames[enabledExtensionCount++] = HdrMetadataExtensionNames[i];
}
}
SDL_assert(enabledExtensionCount <= SDL_arraysize(enabledExtensionNames));
deviceCreateInfo.enabledExtensionCount = enabledExtensionCount;
deviceCreateInfo.ppEnabledExtensionNames = enabledExtensionNames;
deviceQueueCreateInfo[0].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
deviceQueueCreateInfo[0].queueFamilyIndex = rendererData->graphicsQueueFamilyIndex;
deviceQueueCreateInfo[0].queueCount = 1;
deviceQueueCreateInfo[0].pQueuePriorities = queuePriority;
++deviceCreateInfo.queueCreateInfoCount;
if (rendererData->presentQueueFamilyIndex != rendererData->graphicsQueueFamilyIndex) {
deviceQueueCreateInfo[1].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
deviceQueueCreateInfo[1].queueFamilyIndex = rendererData->presentQueueFamilyIndex;
deviceQueueCreateInfo[1].queueCount = 1;
deviceQueueCreateInfo[1].pQueuePriorities = queuePriority;
++deviceCreateInfo.queueCreateInfoCount;
}
if (rendererData->supportsKHRSamplerYCbCrConversion) {
deviceSamplerYcbcrConversionFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
deviceSamplerYcbcrConversionFeatures.samplerYcbcrConversion = VK_TRUE;
deviceSamplerYcbcrConversionFeatures.pNext = (void *)deviceCreateInfo.pNext;
deviceCreateInfo.pNext = &deviceSamplerYcbcrConversionFeatures;
}
result = vkCreateDevice(rendererData->physicalDevice, &deviceCreateInfo, NULL, &rendererData->device);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateDevice()", result);
VULKAN_DestroyAll(renderer);
return result;
}
}
if (!VULKAN_LoadDeviceFunctions(rendererData)) {
VULKAN_DestroyAll(renderer);
return VK_ERROR_UNKNOWN;
}
#ifdef SDL_PLATFORM_ANDROID
if (!vkGetAndroidHardwareBufferPropertiesANDROID) {
rendererData->supportsANDROIDExternalMemoryAndroidHardwareBuffer = false;
}
#endif
// Get graphics/present queues
vkGetDeviceQueue(rendererData->device, rendererData->graphicsQueueFamilyIndex, 0, &rendererData->graphicsQueue);
if (rendererData->graphicsQueueFamilyIndex != rendererData->presentQueueFamilyIndex) {
vkGetDeviceQueue(rendererData->device, rendererData->presentQueueFamilyIndex, 0, &rendererData->presentQueue);
} else {
rendererData->presentQueue = rendererData->graphicsQueue;
}
// Create command pool/command buffers
VkCommandPoolCreateInfo commandPoolCreateInfo = { 0 };
commandPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
commandPoolCreateInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
commandPoolCreateInfo.queueFamilyIndex = rendererData->graphicsQueueFamilyIndex;
result = vkCreateCommandPool(rendererData->device, &commandPoolCreateInfo, NULL, &rendererData->commandPool);
if (result != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
SET_ERROR_CODE("vkCreateCommandPool()", result);
return result;
}
if (VULKAN_GetSurfaceFormats(rendererData) != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
return result;
}
// Create shaders / layouts
for (uint32_t i = 0; i < NUM_SHADERS; i++) {
VULKAN_Shader shader = (VULKAN_Shader)i;
VkShaderModuleCreateInfo shaderModuleCreateInfo = { 0 };
shaderModuleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
VULKAN_GetVertexShader(shader, &shaderModuleCreateInfo.pCode, &shaderModuleCreateInfo.codeSize);
result = vkCreateShaderModule(rendererData->device, &shaderModuleCreateInfo, NULL, &rendererData->vertexShaderModules[i]);
if (result != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
SET_ERROR_CODE("vkCreateShaderModule()", result);
return result;
}
VULKAN_GetPixelShader(shader, &shaderModuleCreateInfo.pCode, &shaderModuleCreateInfo.codeSize);
result = vkCreateShaderModule(rendererData->device, &shaderModuleCreateInfo, NULL, &rendererData->fragmentShaderModules[i]);
if (result != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
SET_ERROR_CODE("vkCreateShaderModule()", result);
return result;
}
}
// Descriptor set layout / pipeline layout
result = VULKAN_CreateDescriptorSetAndPipelineLayout(rendererData, VK_NULL_HANDLE, &rendererData->descriptorSetLayout, &rendererData->pipelineLayout);
if (result != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
return result;
}
// Create default vertex buffers
for (uint32_t i = 0; i < SDL_VULKAN_NUM_VERTEX_BUFFERS; ++i) {
VULKAN_CreateVertexBuffer(rendererData, i, SDL_VULKAN_VERTEX_BUFFER_DEFAULT_SIZE);
}
SDL_PropertiesID props = SDL_GetRendererProperties(renderer);
SDL_SetPointerProperty(props, SDL_PROP_RENDERER_VULKAN_INSTANCE_POINTER, rendererData->instance);
SDL_SetNumberProperty(props, SDL_PROP_RENDERER_VULKAN_SURFACE_NUMBER, (Sint64)rendererData->surface);
SDL_SetPointerProperty(props, SDL_PROP_RENDERER_VULKAN_PHYSICAL_DEVICE_POINTER, rendererData->physicalDevice);
SDL_SetPointerProperty(props, SDL_PROP_RENDERER_VULKAN_DEVICE_POINTER, rendererData->device);
SDL_SetNumberProperty(props, SDL_PROP_RENDERER_VULKAN_GRAPHICS_QUEUE_FAMILY_INDEX_NUMBER, rendererData->graphicsQueueFamilyIndex);
SDL_SetNumberProperty(props, SDL_PROP_RENDERER_VULKAN_PRESENT_QUEUE_FAMILY_INDEX_NUMBER, rendererData->presentQueueFamilyIndex);
return VK_SUCCESS;
}
static VkResult VULKAN_CreateFramebuffersAndRenderPasses(SDL_Renderer *renderer, int w, int h,
VkFormat format, int imageViewCount, VkImageView *imageViews, VkFramebuffer *framebuffers, VkRenderPass renderPasses[VULKAN_RENDERPASS_COUNT])
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *) renderer->internal;
VkResult result;
VkAttachmentDescription attachmentDescription = { 0 };
attachmentDescription.format = format;
attachmentDescription.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
attachmentDescription.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
attachmentDescription.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
attachmentDescription.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
attachmentDescription.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
attachmentDescription.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
attachmentDescription.samples = VK_SAMPLE_COUNT_1_BIT;
attachmentDescription.flags = 0;
VkAttachmentReference colorAttachmentReference = { 0 };
colorAttachmentReference.attachment = 0;
colorAttachmentReference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription subpassDescription = { 0 };
subpassDescription.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
subpassDescription.flags = 0;
subpassDescription.inputAttachmentCount = 0;
subpassDescription.pInputAttachments = NULL;
subpassDescription.colorAttachmentCount = 1;
subpassDescription.pColorAttachments = &colorAttachmentReference;
subpassDescription.pResolveAttachments = NULL;
subpassDescription.pDepthStencilAttachment = NULL;
subpassDescription.preserveAttachmentCount = 0;
subpassDescription.pPreserveAttachments = NULL;
VkSubpassDependency subPassDependency = { 0 };
subPassDependency.srcSubpass = VK_SUBPASS_EXTERNAL;
subPassDependency.dstSubpass = 0;
subPassDependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
subPassDependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
subPassDependency.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
subPassDependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
subPassDependency.dependencyFlags = VK_DEPENDENCY_BY_REGION_BIT;
VkRenderPassCreateInfo renderPassCreateInfo = { 0 };
renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
renderPassCreateInfo.flags = 0;
renderPassCreateInfo.attachmentCount = 1;
renderPassCreateInfo.pAttachments = &attachmentDescription;
renderPassCreateInfo.subpassCount = 1;
renderPassCreateInfo.pSubpasses = &subpassDescription;
renderPassCreateInfo.dependencyCount = 1;
renderPassCreateInfo.pDependencies = &subPassDependency;
result = vkCreateRenderPass(rendererData->device, &renderPassCreateInfo, NULL, &renderPasses[VULKAN_RENDERPASS_LOAD]);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateRenderPass()", result);
return result;
}
attachmentDescription.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
result = vkCreateRenderPass(rendererData->device, &renderPassCreateInfo, NULL, &renderPasses[VULKAN_RENDERPASS_CLEAR]);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateRenderPass()", result);
return result;
}
VkFramebufferCreateInfo framebufferCreateInfo = { 0 };
framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
framebufferCreateInfo.pNext = NULL;
framebufferCreateInfo.renderPass = renderPasses[VULKAN_RENDERPASS_LOAD];
framebufferCreateInfo.attachmentCount = 1;
framebufferCreateInfo.width = w;
framebufferCreateInfo.height = h;
framebufferCreateInfo.layers = 1;
for (int i = 0; i < imageViewCount; i++) {
framebufferCreateInfo.pAttachments = &imageViews[i];
result = vkCreateFramebuffer(rendererData->device, &framebufferCreateInfo, NULL, &framebuffers[i]);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateFramebuffer()", result);
return result;
}
}
return result;
}
static VkResult VULKAN_CreateSwapChain(SDL_Renderer *renderer, int w, int h)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VkResult result = vkGetPhysicalDeviceSurfaceCapabilitiesKHR(rendererData->physicalDevice, rendererData->surface, &rendererData->surfaceCapabilities);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkGetPhysicalDeviceSurfaceCapabilitiesKHR()", result);
return result;
}
// clean up previous swapchain resources
if (rendererData->swapchainImageViews) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
vkDestroyImageView(rendererData->device, rendererData->swapchainImageViews[i], NULL);
}
SDL_free(rendererData->swapchainImageViews);
rendererData->swapchainImageViews = NULL;
}
if (rendererData->fences) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
if (rendererData->fences[i] != VK_NULL_HANDLE) {
vkDestroyFence(rendererData->device, rendererData->fences[i], NULL);
}
}
SDL_free(rendererData->fences);
rendererData->fences = NULL;
}
if (rendererData->commandBuffers) {
vkFreeCommandBuffers(rendererData->device, rendererData->commandPool, rendererData->swapchainImageCount, rendererData->commandBuffers);
SDL_free(rendererData->commandBuffers);
rendererData->commandBuffers = NULL;
rendererData->currentCommandBuffer = VK_NULL_HANDLE;
rendererData->currentCommandBufferIndex = 0;
}
if (rendererData->framebuffers) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
if (rendererData->framebuffers[i] != VK_NULL_HANDLE) {
vkDestroyFramebuffer(rendererData->device, rendererData->framebuffers[i], NULL);
}
}
SDL_free(rendererData->framebuffers);
rendererData->framebuffers = NULL;
}
if (rendererData->descriptorPools) {
SDL_assert(rendererData->numDescriptorPools);
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
for (uint32_t j = 0; j < rendererData->numDescriptorPools[i]; j++) {
if (rendererData->descriptorPools[i][j] != VK_NULL_HANDLE) {
vkDestroyDescriptorPool(rendererData->device, rendererData->descriptorPools[i][j], NULL);
}
}
SDL_free(rendererData->descriptorPools[i]);
}
SDL_free(rendererData->descriptorPools);
rendererData->descriptorPools = NULL;
SDL_free(rendererData->numDescriptorPools);
rendererData->numDescriptorPools = NULL;
}
if (rendererData->imageAvailableSemaphores) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
if (rendererData->imageAvailableSemaphores[i] != VK_NULL_HANDLE) {
vkDestroySemaphore(rendererData->device, rendererData->imageAvailableSemaphores[i], NULL);
}
}
SDL_free(rendererData->imageAvailableSemaphores);
rendererData->imageAvailableSemaphores = NULL;
}
if (rendererData->renderingFinishedSemaphores) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
if (rendererData->renderingFinishedSemaphores[i] != VK_NULL_HANDLE) {
vkDestroySemaphore(rendererData->device, rendererData->renderingFinishedSemaphores[i], NULL);
}
}
SDL_free(rendererData->renderingFinishedSemaphores);
rendererData->renderingFinishedSemaphores = NULL;
}
if (rendererData->currentUploadBuffer) {
for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
for (int j = 0; j < rendererData->currentUploadBuffer[i]; ++j) {
VULKAN_DestroyBuffer(rendererData, &rendererData->uploadBuffers[i][j]);
}
SDL_free(rendererData->uploadBuffers[i]);
}
SDL_free(rendererData->uploadBuffers);
rendererData->uploadBuffers = NULL;
SDL_free(rendererData->currentUploadBuffer);
rendererData->currentUploadBuffer = NULL;
}
if (rendererData->constantBuffers) {
SDL_assert(rendererData->numConstantBuffers);
for (uint32_t i = 0; i < rendererData->swapchainImageCount; ++i) {
for (uint32_t j = 0; j < rendererData->numConstantBuffers[i]; j++) {
VULKAN_DestroyBuffer(rendererData, &rendererData->constantBuffers[i][j]);
}
SDL_free(rendererData->constantBuffers[i]);
}
SDL_free(rendererData->constantBuffers);
rendererData->constantBuffers = NULL;
SDL_free(rendererData->numConstantBuffers);
rendererData->numConstantBuffers = NULL;
}
// pick an image count
rendererData->swapchainDesiredImageCount = rendererData->surfaceCapabilities.minImageCount + SDL_VULKAN_FRAME_QUEUE_DEPTH;
if ((rendererData->swapchainDesiredImageCount > rendererData->surfaceCapabilities.maxImageCount) &&
(rendererData->surfaceCapabilities.maxImageCount > 0)) {
rendererData->swapchainDesiredImageCount = rendererData->surfaceCapabilities.maxImageCount;
}
VkFormat desiredFormat = VK_FORMAT_B8G8R8A8_UNORM;
VkColorSpaceKHR desiredColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
if (renderer->output_colorspace == SDL_COLORSPACE_SRGB_LINEAR) {
desiredFormat = VK_FORMAT_R16G16B16A16_SFLOAT;
desiredColorSpace = VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT;
} else if (renderer->output_colorspace == SDL_COLORSPACE_HDR10) {
desiredFormat = VK_FORMAT_A2B10G10R10_UNORM_PACK32;
desiredColorSpace = VK_COLOR_SPACE_HDR10_ST2084_EXT;
}
bool foundDesiredFormat = false;
if ((rendererData->surfaceFormatsCount == 1) &&
(rendererData->surfaceFormats[0].format == VK_FORMAT_UNDEFINED)) {
// aren't any preferred formats, so we pick
rendererData->surfaceFormat.colorSpace = VK_COLORSPACE_SRGB_NONLINEAR_KHR;
rendererData->surfaceFormat.format = desiredFormat;
foundDesiredFormat = (desiredColorSpace == VK_COLORSPACE_SRGB_NONLINEAR_KHR);
} else {
rendererData->surfaceFormat = rendererData->surfaceFormats[0];
rendererData->surfaceFormat.colorSpace = rendererData->surfaceFormats[0].colorSpace;
for (uint32_t i = 0; i < rendererData->surfaceFormatsCount; i++) {
if (rendererData->surfaceFormats[i].format == desiredFormat &&
rendererData->surfaceFormats[i].colorSpace == desiredColorSpace) {
rendererData->surfaceFormat = rendererData->surfaceFormats[i];
foundDesiredFormat = true;
break;
}
}
}
if (!foundDesiredFormat &&
renderer->output_colorspace != SDL_COLORSPACE_SRGB) {
SET_ERROR_MESSAGE("Unsupported output colorspace");
return VK_ERROR_FORMAT_NOT_SUPPORTED;
}
rendererData->swapchainSize.width = SDL_clamp((uint32_t)w,
rendererData->surfaceCapabilities.minImageExtent.width,
rendererData->surfaceCapabilities.maxImageExtent.width);
rendererData->swapchainSize.height = SDL_clamp((uint32_t)h,
rendererData->surfaceCapabilities.minImageExtent.height,
rendererData->surfaceCapabilities.maxImageExtent.height);
// Handle rotation
rendererData->swapChainPreTransform = rendererData->surfaceCapabilities.currentTransform;
if (rendererData->swapChainPreTransform == VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR ||
rendererData->swapChainPreTransform == VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR) {
uint32_t tempWidth = rendererData->swapchainSize.width;
rendererData->swapchainSize.width = rendererData->swapchainSize.height;
rendererData->swapchainSize.height = tempWidth;
}
if (rendererData->swapchainSize.width == 0 && rendererData->swapchainSize.height == 0) {
// Don't recreate the swapchain if size is (0,0), just fail and continue attempting creation
return VK_ERROR_OUT_OF_DATE_KHR;
}
// Choose a present mode. If vsync is requested, then use VK_PRESENT_MODE_FIFO_KHR which is guaranteed to be supported
VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
if (rendererData->vsync <= 0) {
uint32_t presentModeCount = 0;
result = vkGetPhysicalDeviceSurfacePresentModesKHR(rendererData->physicalDevice, rendererData->surface, &presentModeCount, NULL);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkGetPhysicalDeviceSurfacePresentModesKHR()", result);
return result;
}
if (presentModeCount > 0) {
VkPresentModeKHR *presentModes = (VkPresentModeKHR *)SDL_calloc(presentModeCount, sizeof(VkPresentModeKHR));
result = vkGetPhysicalDeviceSurfacePresentModesKHR(rendererData->physicalDevice, rendererData->surface, &presentModeCount, presentModes);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkGetPhysicalDeviceSurfacePresentModesKHR()", result);
SDL_free(presentModes);
return result;
}
if (rendererData->vsync == 0) {
/* If vsync is not requested, in favor these options in order:
VK_PRESENT_MODE_IMMEDIATE_KHR - no v-sync with tearing
VK_PRESENT_MODE_MAILBOX_KHR - no v-sync without tearing
VK_PRESENT_MODE_FIFO_RELAXED_KHR - no v-sync, may tear */
for (uint32_t i = 0; i < presentModeCount; i++) {
if (presentModes[i] == VK_PRESENT_MODE_IMMEDIATE_KHR) {
presentMode = VK_PRESENT_MODE_IMMEDIATE_KHR;
break;
}
else if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
}
else if ((presentMode != VK_PRESENT_MODE_MAILBOX_KHR) &&
(presentModes[i] == VK_PRESENT_MODE_FIFO_RELAXED_KHR)) {
presentMode = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
}
}
} else if (rendererData->vsync == -1) {
for (uint32_t i = 0; i < presentModeCount; i++) {
if (presentModes[i] == VK_PRESENT_MODE_FIFO_RELAXED_KHR) {
presentMode = VK_PRESENT_MODE_FIFO_RELAXED_KHR;
break;
}
}
}
SDL_free(presentModes);
}
}
VkCompositeAlphaFlagsKHR compositeAlphaFlag = 0;
// Default to opaque, if available, followed by inherit, and overwrite with a value that supports transparency, if necessary.
if (rendererData->surfaceCapabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR) {
compositeAlphaFlag = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;
} else if (rendererData->surfaceCapabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) {
compositeAlphaFlag = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
}
if ((renderer->window->flags & SDL_WINDOW_TRANSPARENT) || !compositeAlphaFlag) {
if (rendererData->surfaceCapabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR) {
compositeAlphaFlag = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR;
} else if (rendererData->surfaceCapabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR) {
compositeAlphaFlag = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR;
} else if (rendererData->surfaceCapabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) {
compositeAlphaFlag = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
} else {
SDL_LogWarn(SDL_LOG_CATEGORY_RENDER, "SDL_WINDOW_TRANSPARENT flag set, but no suitable swapchain composite alpha value supported!");
}
}
VkSwapchainCreateInfoKHR swapchainCreateInfo = { 0 };
swapchainCreateInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
swapchainCreateInfo.surface = rendererData->surface;
swapchainCreateInfo.minImageCount = rendererData->swapchainDesiredImageCount;
swapchainCreateInfo.imageFormat = rendererData->surfaceFormat.format;
swapchainCreateInfo.imageColorSpace = rendererData->surfaceFormat.colorSpace;
swapchainCreateInfo.imageExtent = rendererData->swapchainSize;
swapchainCreateInfo.imageArrayLayers = 1;
swapchainCreateInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
// SDL_RenderReadPixels() copies from the swapchain image, which requires TRANSFER_SRC
if (rendererData->surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) {
swapchainCreateInfo.imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
}
swapchainCreateInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
swapchainCreateInfo.preTransform = rendererData->swapChainPreTransform;
swapchainCreateInfo.compositeAlpha = compositeAlphaFlag;
swapchainCreateInfo.presentMode = presentMode;
swapchainCreateInfo.clipped = VK_TRUE;
swapchainCreateInfo.oldSwapchain = rendererData->swapchain;
result = vkCreateSwapchainKHR(rendererData->device, &swapchainCreateInfo, NULL, &rendererData->swapchain);
if (swapchainCreateInfo.oldSwapchain != VK_NULL_HANDLE) {
vkDestroySwapchainKHR(rendererData->device, swapchainCreateInfo.oldSwapchain, NULL);
}
if (result != VK_SUCCESS) {
rendererData->swapchain = VK_NULL_HANDLE;
SET_ERROR_CODE("vkCreateSwapchainKHR()", result);
return result;
}
SDL_free(rendererData->swapchainImages);
rendererData->swapchainImages = NULL;
result = vkGetSwapchainImagesKHR(rendererData->device, rendererData->swapchain, &rendererData->swapchainImageCount, NULL);
if (result != VK_SUCCESS) {
rendererData->swapchainImageCount = 0;
SET_ERROR_CODE("vkGetSwapchainImagesKHR()", result);
return result;
}
rendererData->swapchainImages = (VkImage *)SDL_malloc(sizeof(VkImage) * rendererData->swapchainImageCount);
result = vkGetSwapchainImagesKHR(rendererData->device,
rendererData->swapchain,
&rendererData->swapchainImageCount,
rendererData->swapchainImages);
if (result != VK_SUCCESS) {
SDL_free(rendererData->swapchainImages);
rendererData->swapchainImages = NULL;
rendererData->swapchainImageCount = 0;
SET_ERROR_CODE("vkGetSwapchainImagesKHR()", result);
return result;
}
// Create VkImageView's for swapchain images
{
VkImageViewCreateInfo imageViewCreateInfo = { 0 };
imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
imageViewCreateInfo.flags = 0;
imageViewCreateInfo.format = rendererData->surfaceFormat.format;
imageViewCreateInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
imageViewCreateInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
imageViewCreateInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
imageViewCreateInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;
imageViewCreateInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imageViewCreateInfo.subresourceRange.baseArrayLayer = 0;
imageViewCreateInfo.subresourceRange.baseMipLevel = 0;
imageViewCreateInfo.subresourceRange.layerCount = 1;
imageViewCreateInfo.subresourceRange.levelCount = 1;
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
rendererData->swapchainImageViews = (VkImageView *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkImageView));
SDL_free(rendererData->swapchainImageLayouts);
rendererData->swapchainImageLayouts = (VkImageLayout *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkImageLayout));
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
imageViewCreateInfo.image = rendererData->swapchainImages[i];
result = vkCreateImageView(rendererData->device, &imageViewCreateInfo, NULL, &rendererData->swapchainImageViews[i]);
if (result != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
SET_ERROR_CODE("vkCreateImageView()", result);
return result;
}
rendererData->swapchainImageLayouts[i] = VK_IMAGE_LAYOUT_UNDEFINED;
}
}
VkCommandBufferAllocateInfo commandBufferAllocateInfo = { 0 };
commandBufferAllocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
commandBufferAllocateInfo.commandPool = rendererData->commandPool;
commandBufferAllocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
commandBufferAllocateInfo.commandBufferCount = rendererData->swapchainImageCount;
rendererData->commandBuffers = (VkCommandBuffer *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkCommandBuffer));
result = vkAllocateCommandBuffers(rendererData->device, &commandBufferAllocateInfo, rendererData->commandBuffers);
if (result != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
SET_ERROR_CODE("vkAllocateCommandBuffers()", result);
return result;
}
// Create fences
rendererData->fences = (VkFence *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkFence));
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
VkFenceCreateInfo fenceCreateInfo = { 0 };
fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
fenceCreateInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;
result = vkCreateFence(rendererData->device, &fenceCreateInfo, NULL, &rendererData->fences[i]);
if (result != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
SET_ERROR_CODE("vkCreateFence()", result);
return result;
}
}
// Create renderpasses and framebuffer
for (uint32_t i = 0; i < SDL_arraysize(rendererData->renderPasses); i++) {
if (rendererData->renderPasses[i] != VK_NULL_HANDLE) {
vkDestroyRenderPass(rendererData->device, rendererData->renderPasses[i], NULL);
rendererData->renderPasses[i] = VK_NULL_HANDLE;
}
}
rendererData->framebuffers = (VkFramebuffer *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkFramebuffer));
result = VULKAN_CreateFramebuffersAndRenderPasses(renderer,
rendererData->swapchainSize.width,
rendererData->swapchainSize.height,
rendererData->surfaceFormat.format,
rendererData->swapchainImageCount,
rendererData->swapchainImageViews,
rendererData->framebuffers,
rendererData->renderPasses);
if (result != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
SET_ERROR_CODE("VULKAN_CreateFramebuffersAndRenderPasses()", result);
return result;
}
// Create descriptor pools - start by allocating one per swapchain image, let it grow if more are needed
rendererData->descriptorPools = (VkDescriptorPool **)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkDescriptorPool *));
rendererData->numDescriptorPools = (uint32_t *)SDL_calloc(rendererData->swapchainImageCount, sizeof(uint32_t));
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
// Start by just allocating one pool, it will grow if needed
rendererData->numDescriptorPools[i] = 1;
rendererData->descriptorPools[i] = (VkDescriptorPool *)SDL_calloc(1, sizeof(VkDescriptorPool));
rendererData->descriptorPools[i][0] = VULKAN_AllocateDescriptorPool(rendererData);
if (result != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
return result;
}
}
// Create semaphores
rendererData->imageAvailableSemaphores = (VkSemaphore *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkSemaphore));
rendererData->renderingFinishedSemaphores = (VkSemaphore *)SDL_calloc(rendererData->swapchainImageCount, sizeof(VkSemaphore));
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
rendererData->imageAvailableSemaphores[i] = VULKAN_CreateSemaphore(rendererData);
if (rendererData->imageAvailableSemaphores[i] == VK_NULL_HANDLE) {
VULKAN_DestroyAll(renderer);
return VK_ERROR_UNKNOWN;
}
rendererData->renderingFinishedSemaphores[i] = VULKAN_CreateSemaphore(rendererData);
if (rendererData->renderingFinishedSemaphores[i] == VK_NULL_HANDLE) {
VULKAN_DestroyAll(renderer);
return VK_ERROR_UNKNOWN;
}
}
// Upload buffers
rendererData->uploadBuffers = (VULKAN_Buffer **)SDL_calloc(rendererData->swapchainImageCount, sizeof(VULKAN_Buffer *));
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
rendererData->uploadBuffers[i] = (VULKAN_Buffer *)SDL_calloc(SDL_VULKAN_NUM_UPLOAD_BUFFERS, sizeof(VULKAN_Buffer));
}
rendererData->currentUploadBuffer = (int *)SDL_calloc(rendererData->swapchainImageCount, sizeof(int));
// Constant buffers
rendererData->constantBuffers = (VULKAN_Buffer **)SDL_calloc(rendererData->swapchainImageCount, sizeof(VULKAN_Buffer *));
rendererData->numConstantBuffers = (uint32_t *)SDL_calloc(rendererData->swapchainImageCount, sizeof(uint32_t));
for (uint32_t i = 0; i < rendererData->swapchainImageCount; i++) {
// Start with just allocating one, will grow if needed
rendererData->numConstantBuffers[i] = 1;
rendererData->constantBuffers[i] = (VULKAN_Buffer *)SDL_calloc(1, sizeof(VULKAN_Buffer));
result = VULKAN_AllocateBuffer(rendererData,
SDL_VULKAN_CONSTANT_BUFFER_DEFAULT_SIZE,
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&rendererData->constantBuffers[i][0]);
if (result != VK_SUCCESS) {
VULKAN_DestroyAll(renderer);
return result;
}
}
rendererData->currentConstantBufferOffset = -1;
rendererData->currentConstantBufferIndex = 0;
VULKAN_AcquireNextSwapchainImage(renderer);
VULKAN_UpdateHDRMetadata(renderer);
SDL_PropertiesID props = SDL_GetRendererProperties(renderer);
SDL_SetNumberProperty(props, SDL_PROP_RENDERER_VULKAN_SWAPCHAIN_IMAGE_COUNT_NUMBER, rendererData->swapchainImageCount);
return result;
}
// Initialize all resources that change when the window's size changes.
static VkResult VULKAN_CreateWindowSizeDependentResources(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VkResult result = VK_SUCCESS;
int w, h;
// Release resources in the current command list
VULKAN_IssueBatch(rendererData);
VULKAN_WaitForGPU(rendererData);
/* The width and height of the swap chain must be based on the display's
* non-rotated size.
*/
SDL_GetWindowSizeInPixels(renderer->window, &w, &h);
result = VULKAN_CreateSwapChain(renderer, w, h);
if (result != VK_SUCCESS) {
rendererData->recreateSwapchain = true;
}
rendererData->viewportDirty = true;
return result;
}
static bool VULKAN_HandleDeviceLost(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
bool recovered = false;
VULKAN_DestroyAll(renderer);
if (VULKAN_CreateDeviceResources(renderer, rendererData->create_props) == VK_SUCCESS &&
VULKAN_CreateWindowSizeDependentResources(renderer) == VK_SUCCESS) {
recovered = true;
} else {
SDL_LogError(SDL_LOG_CATEGORY_RENDER, "Renderer couldn't recover from device lost: %s", SDL_GetError());
VULKAN_DestroyAll(renderer);
}
// Let the application know that the device has been reset or lost
SDL_Event event;
SDL_zero(event);
event.type = recovered ? SDL_EVENT_RENDER_DEVICE_RESET : SDL_EVENT_RENDER_DEVICE_LOST;
event.render.windowID = SDL_GetWindowID(SDL_GetRenderWindow(renderer));
SDL_PushEvent(&event);
return recovered;
}
// This method is called when the window's size changes.
static VkResult VULKAN_UpdateForWindowSizeChange(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
// If the GPU has previous work, wait for it to be done first
VULKAN_WaitForGPU(rendererData);
return VULKAN_CreateWindowSizeDependentResources(renderer);
}
#ifdef SDL_PLATFORM_ANDROID
static bool VULKAN_HandleWindowRestored(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
if (!rendererData->device) {
return false;
}
if (rendererData->surface_external) {
// We can't recreate external surfaces, fall back to device lost handling
return false;
}
VULKAN_IssueBatch(rendererData);
VULKAN_WaitForGPU(rendererData);
if (rendererData->swapchain != VK_NULL_HANDLE) {
vkDestroySwapchainKHR(rendererData->device, rendererData->swapchain, NULL);
rendererData->swapchain = VK_NULL_HANDLE;
}
if (rendererData->surface != VK_NULL_HANDLE) {
vkDestroySurfaceKHR(rendererData->instance, rendererData->surface, NULL);
rendererData->surface = VK_NULL_HANDLE;
}
if (!SDL_Vulkan_CreateSurface(renderer->window, rendererData->instance, NULL, &rendererData->surface)) {
return false;
}
// The formats we cached were queried against the old surface
VkResult result = VULKAN_GetSurfaceFormats(rendererData);
if (result != VK_SUCCESS) {
return false;
}
result = VULKAN_CreateWindowSizeDependentResources(renderer);
if (result != VK_SUCCESS) {
return false;
}
return true;
}
#endif // SDL_PLATFORM_ANDROID
static void VULKAN_WindowEvent(SDL_Renderer *renderer, const SDL_WindowEvent *event)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
if (event->type == SDL_EVENT_WINDOW_PIXEL_SIZE_CHANGED) {
rendererData->recreateSwapchain = true;
}
#ifdef SDL_PLATFORM_ANDROID
// Prevent black screen when app returns from background
if (event->type == SDL_EVENT_WINDOW_RESTORED) {
// Try to just recreate the surface and swap chain
if (!VULKAN_HandleWindowRestored(renderer)) {
// We're fully lost, notify the application
VULKAN_HandleDeviceLost(renderer);
}
}
#endif
}
static bool VULKAN_SupportsBlendMode(SDL_Renderer *renderer, SDL_BlendMode blendMode)
{
SDL_BlendFactor srcColorFactor = SDL_GetBlendModeSrcColorFactor(blendMode);
SDL_BlendFactor srcAlphaFactor = SDL_GetBlendModeSrcAlphaFactor(blendMode);
SDL_BlendOperation colorOperation = SDL_GetBlendModeColorOperation(blendMode);
SDL_BlendFactor dstColorFactor = SDL_GetBlendModeDstColorFactor(blendMode);
SDL_BlendFactor dstAlphaFactor = SDL_GetBlendModeDstAlphaFactor(blendMode);
SDL_BlendOperation alphaOperation = SDL_GetBlendModeAlphaOperation(blendMode);
if (GetBlendFactor(srcColorFactor) == VK_BLEND_FACTOR_MAX_ENUM ||
GetBlendFactor(srcAlphaFactor) == VK_BLEND_FACTOR_MAX_ENUM ||
GetBlendOp(colorOperation) == VK_BLEND_OP_MAX_ENUM ||
GetBlendFactor(dstColorFactor) == VK_BLEND_FACTOR_MAX_ENUM ||
GetBlendFactor(dstAlphaFactor) == VK_BLEND_FACTOR_MAX_ENUM ||
GetBlendOp(alphaOperation) == VK_BLEND_OP_MAX_ENUM) {
return false;
}
return true;
}
static bool VULKAN_CreatePaletteResources(SDL_Renderer *renderer, VULKAN_PaletteData *palettedata)
{
VULKAN_RenderData *data = (VULKAN_RenderData *)renderer->internal;
VkFormat format = VULKAN_GetVkImageFormat(SDL_PIXELFORMAT_RGBA32, renderer->output_colorspace);
VkImageUsageFlags usage = (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
VkComponentMapping imageViewSwizzle = data->identitySwizzle;
VkResult result = VULKAN_AllocateImage(data, 0, NULL, 256, 1, format, usage, VK_NULL_HANDLE, NULL, &palettedata->image);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("VULKAN_AllocateImage()", result);
return false;
}
result = VULKAN_AllocateImageView(data, palettedata->image.image, -1, format, usage, imageViewSwizzle, VK_NULL_HANDLE, &palettedata->imageView);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("VULKAN_AllocateImage()", result);
return false;
}
return true;
}
static void VULKAN_DestroyPaletteResources(VULKAN_RenderData *rendererData, VULKAN_PaletteData *palettedata)
{
VULKAN_DestroyImage(rendererData, &palettedata->image);
if (palettedata->imageView != VK_NULL_HANDLE) {
vkDestroyImageView(rendererData->device, palettedata->imageView, NULL);
palettedata->imageView = VK_NULL_HANDLE;
}
}
static bool SDLCALL VULKAN_ReleasePalette(void *userdata, const SDL_HashTable *table, const void *key, const void *value)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)userdata;
SDL_TexturePalette *palette = (SDL_TexturePalette *)value;
VULKAN_PaletteData *palettedata = (VULKAN_PaletteData *)palette->internal;
if (palettedata) {
VULKAN_DestroyPaletteResources(rendererData, palettedata);
}
// Make sure UpdatePalette() is called before the palette is used again
palette->version = 0;
return true;
}
static bool VULKAN_CreatePalette(SDL_Renderer *renderer, SDL_TexturePalette *palette)
{
VULKAN_PaletteData *palettedata = (VULKAN_PaletteData *)SDL_calloc(1, sizeof(*palettedata));
if (!palettedata) {
return false;
}
palette->internal = palettedata;
return VULKAN_CreatePaletteResources(renderer, palettedata);
}
static bool VULKAN_UpdatePalette(SDL_Renderer *renderer, SDL_TexturePalette *palette, int ncolors, SDL_Color *colors)
{
VULKAN_RenderData *data = (VULKAN_RenderData *)renderer->internal;
VULKAN_PaletteData *palettedata = (VULKAN_PaletteData *)palette->internal;
if (palettedata->image.image == VK_NULL_HANDLE) {
if (!data->device) {
return SDL_SetError("Device lost and couldn't be recovered");
}
if (!VULKAN_CreatePaletteResources(renderer, palettedata)) {
return false;
}
}
return VULKAN_UpdateTextureInternal(data, palettedata->image.image, palettedata->image.format, 0, 0, 0, ncolors, 1, colors, ncolors * sizeof(*colors), &palettedata->image.imageLayout);
}
static void VULKAN_DestroyPalette(SDL_Renderer *renderer, SDL_TexturePalette *palette)
{
VULKAN_RenderData *data = (VULKAN_RenderData *)renderer->internal;
VULKAN_PaletteData *palettedata = (VULKAN_PaletteData *)palette->internal;
if (!palettedata) {
return;
}
if (palettedata->image.image != VK_NULL_HANDLE || palettedata->imageView != VK_NULL_HANDLE) {
// Because SDL_DestroyPalette might be called while the data is in-flight,
// we need to issue the batch first, which may cause performance issues
VULKAN_IssueBatch(data);
VULKAN_WaitForGPU(data);
VULKAN_DestroyPaletteResources(data, palettedata);
}
SDL_free(palettedata);
}
#ifdef SDL_PLATFORM_ANDROID
static void ANDROID_GetBufferSize(struct AHardwareBuffer *buffer, uint32_t *width, uint32_t *height)
{
static pfnAHardwareBuffer_describe AHardwareBuffer_describeFunc;
if (!AHardwareBuffer_describeFunc) {
void *lib = dlopen("libandroid.so", RTLD_NOW | RTLD_LOCAL);
if (lib) {
AHardwareBuffer_describeFunc = (pfnAHardwareBuffer_describe)dlsym(lib, "AHardwareBuffer_describe");
// Leaving the library loaded so we can use the function again without another dlopen()
}
}
if (AHardwareBuffer_describeFunc) {
AHardwareBuffer_Desc desc;
SDL_zero(desc);
AHardwareBuffer_describeFunc(buffer, &desc);
if (desc.width > 0 && desc.height > 0) {
*width = desc.width;
*height = desc.height;
}
}
}
#endif // SDL_PLATFORM_ANDROID
static bool VULKAN_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture, SDL_PropertiesID create_props)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VULKAN_TextureData *textureData;
VkResult result;
int numImages = VULKAN_GetFormatImageCount(texture->format);
int numImageViews = VULKAN_GetFormatImageViewCount(texture->format);
// Render targets use formats matching their own colorspace, so an sRGB target behaves like an sRGB swap chain
const Uint32 format_colorspace = (texture->access == SDL_TEXTUREACCESS_TARGET) ? texture->colorspace : renderer->output_colorspace;
VkFormat textureFormat = VULKAN_GetVkImageFormat(texture->format, format_colorspace);
VkFormat chromaFormat = textureFormat;
uint32_t width = texture->w;
uint32_t height = texture->h;
uint32_t chromaWidth = width;
uint32_t chromaHeight = height;
VkComponentMapping imageViewSwizzle = rendererData->identitySwizzle;
VULKAN_ExternalBufferInfo externalBufferInfo;
VULKAN_ExternalBufferInfo *external = NULL;
if (!rendererData->device) {
return SDL_SetError("Device lost and couldn't be recovered");
}
textureData = (VULKAN_TextureData *)SDL_calloc(1, sizeof(*textureData));
if (!textureData) {
return false;
}
texture->internal = textureData;
textureData->srgb_view = VkFormatIsSRGB(textureFormat);
if (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES) {
SDL_zero(externalBufferInfo);
external = &externalBufferInfo;
#ifdef SDL_PLATFORM_ANDROID
external->buffer = (struct AHardwareBuffer *)SDL_GetPointerProperty(create_props, SDL_PROP_TEXTURE_CREATE_VULKAN_ANDROID_HARDWARE_BUFFER_POINTER, NULL);
if (!external->buffer) {
return SDL_SetError("SDL_PIXELFORMAT_EXTERNAL_OES texture requires a hardware buffer");
}
// Get the real buffer width and height
ANDROID_GetBufferSize(external->buffer, &width, &height);
VkAndroidHardwareBufferFormatPropertiesANDROID *formatProperties = &external->formatProperties;
formatProperties->sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID;
VkAndroidHardwareBufferPropertiesANDROID *properties = &external->properties;
properties->sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID;
properties->pNext = formatProperties;
result = vkGetAndroidHardwareBufferPropertiesANDROID(rendererData->device, external->buffer, properties);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkGetAndroidHardwareBufferPropertiesANDROID()", result);
return false;
}
VkExternalFormatANDROID *externalFormat = &external->externalFormat;
externalFormat->sType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID;
externalFormat->externalFormat = formatProperties->externalFormat;
textureFormat = formatProperties->format;
if (textureFormat == VK_FORMAT_UNDEFINED ||
formatProperties->suggestedYcbcrModel != VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR) {
VkFilter chromaFilter = VK_FILTER_LINEAR;
VkFilter lumaFilter = VK_FILTER_LINEAR;
if (!(formatProperties->formatFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT)) {
chromaFilter = VK_FILTER_NEAREST;
}
if (!(formatProperties->formatFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)) {
lumaFilter = VK_FILTER_NEAREST;
}
if (!(formatProperties->formatFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT)) {
lumaFilter = chromaFilter;
}
VULKAN_YUVPipelineCreateInfo createInfo;
SDL_zero(createInfo); // Must zero padding bytes for cache
createInfo.externalFormat = formatProperties->externalFormat;
createInfo.filter = lumaFilter;
VkSamplerYcbcrConversionCreateInfoKHR *samplerYcbcrConversionCreateInfo = &createInfo.samplerYcbcrConversionCreateInfo;
samplerYcbcrConversionCreateInfo->sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR;
samplerYcbcrConversionCreateInfo->pNext = externalFormat;
samplerYcbcrConversionCreateInfo->format = formatProperties->format;
samplerYcbcrConversionCreateInfo->ycbcrModel = formatProperties->suggestedYcbcrModel;
samplerYcbcrConversionCreateInfo->ycbcrRange = formatProperties->suggestedYcbcrRange;
samplerYcbcrConversionCreateInfo->components = formatProperties->samplerYcbcrConversionComponents;
samplerYcbcrConversionCreateInfo->xChromaOffset = formatProperties->suggestedXChromaOffset;
samplerYcbcrConversionCreateInfo->yChromaOffset = formatProperties->suggestedYChromaOffset;
samplerYcbcrConversionCreateInfo->chromaFilter = chromaFilter;
if (texture->colorspace != SDL_COLORSPACE_UNKNOWN) {
switch (SDL_COLORSPACEMATRIX(texture->colorspace)) {
case SDL_MATRIX_COEFFICIENTS_BT470BG:
case SDL_MATRIX_COEFFICIENTS_BT601:
samplerYcbcrConversionCreateInfo->ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR;
break;
case SDL_MATRIX_COEFFICIENTS_BT709:
samplerYcbcrConversionCreateInfo->ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR;
break;
case SDL_MATRIX_COEFFICIENTS_BT2020_NCL:
samplerYcbcrConversionCreateInfo->ycbcrModel = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR;
break;
default:
break;
}
switch (SDL_COLORSPACERANGE(texture->colorspace)) {
case SDL_COLOR_RANGE_LIMITED:
samplerYcbcrConversionCreateInfo->ycbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR;
break;
case SDL_COLOR_RANGE_FULL:
samplerYcbcrConversionCreateInfo->ycbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR;
break;
default:
break;
}
switch (SDL_COLORSPACECHROMA(texture->colorspace)) {
case SDL_CHROMA_LOCATION_LEFT:
samplerYcbcrConversionCreateInfo->xChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN_KHR;
samplerYcbcrConversionCreateInfo->yChromaOffset = VK_CHROMA_LOCATION_MIDPOINT_KHR;
break;
case SDL_CHROMA_LOCATION_TOPLEFT:
samplerYcbcrConversionCreateInfo->xChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN_KHR;
samplerYcbcrConversionCreateInfo->yChromaOffset = VK_CHROMA_LOCATION_COSITED_EVEN_KHR;
break;
case SDL_CHROMA_LOCATION_CENTER:
samplerYcbcrConversionCreateInfo->xChromaOffset = VK_CHROMA_LOCATION_MIDPOINT_KHR;
samplerYcbcrConversionCreateInfo->yChromaOffset = VK_CHROMA_LOCATION_MIDPOINT_KHR;
break;
default:
break;
}
}
textureData->yuvPipeline = VULKAN_GetYUVPipeline(rendererData, &createInfo);
if (!textureData->yuvPipeline) {
return false;
}
}
#endif // SDL_PLATFORM_ANDROID
} else if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
if (texture->format == SDL_PIXELFORMAT_YV12 ||
texture->format == SDL_PIXELFORMAT_IYUV ||
texture->format == SDL_PIXELFORMAT_NV12 ||
texture->format == SDL_PIXELFORMAT_NV21 ||
texture->format == SDL_PIXELFORMAT_P010 ||
texture->format == SDL_PIXELFORMAT_I0FL) {
// Pad width/height to multiple of 2
width = (width + 1) & ~1;
height = (height + 1) & ~1;
}
if (texture->format == SDL_PIXELFORMAT_YV12 ||
texture->format == SDL_PIXELFORMAT_IYUV ||
texture->format == SDL_PIXELFORMAT_I0FL) {
// YUV 4:2:0 formats
chromaWidth = (width / 2);
chromaHeight = (height / 2);
}
int bits_per_pixel;
switch (texture->format) {
case SDL_PIXELFORMAT_I0FL:
case SDL_PIXELFORMAT_I4FL:
bits_per_pixel = 16;
break;
case SDL_PIXELFORMAT_P010:
bits_per_pixel = 10;
break;
default:
bits_per_pixel = 8;
break;
}
textureData->YCbCr_matrix = SDL_GetYCbCRtoRGBConversionMatrix(texture->colorspace, texture->w, texture->h, bits_per_pixel);
if (!textureData->YCbCr_matrix) {
return SDL_SetError("Unsupported YUV colorspace");
}
}
textureData->width = width;
textureData->height = height;
VkImageUsageFlags usage = (VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
if (texture->access == SDL_TEXTUREACCESS_TARGET) {
usage |= (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
}
usage |= (VkImageUsageFlags)SDL_GetNumberProperty(create_props, SDL_PROP_TEXTURE_CREATE_VULKAN_USAGE_NUMBER, 0);
const char *imageCreateProperties[] = {
SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_NUMBER,
SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_U_NUMBER,
SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_V_NUMBER
};
SDL_COMPILE_TIME_ASSERT(imageCreateProperties, SDL_arraysize(imageCreateProperties) == SDL_VULKAN_NUM_TEXTURE_BINDINGS);
if (numImageViews == 2 &&
SDL_HasProperty(create_props, SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_UV_NUMBER)) {
numImages = 2;
chromaWidth = (width / 2);
chromaHeight = (height / 2);
textureFormat = VULKAN_GetVkImageViewFormat(texture->format, 0, format_colorspace);
chromaFormat = VULKAN_GetVkImageViewFormat(texture->format, 1, format_colorspace);
imageCreateProperties[1] = SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_UV_NUMBER;
}
VkSamplerYcbcrConversionKHR samplerYcbcrConversion = (textureData->yuvPipeline ? textureData->yuvPipeline->samplerYcbcrConversion : VK_NULL_HANDLE);
for (int i = 0; i < numImages; ++i) {
uint32_t imageWidth = (i == 0 ? width : chromaWidth);
uint32_t imageHeight = (i == 0 ? height : chromaHeight);
VkFormat imageFormat = (i == 0 ? textureFormat : chromaFormat);
result = VULKAN_AllocateImage(rendererData, create_props, imageCreateProperties[i], imageWidth, imageHeight, imageFormat, usage, samplerYcbcrConversion, external, &textureData->images[i]);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("VULKAN_AllocateImage()", result);
return false;
}
++textureData->numImages;
}
bool usePlaneViews = (numImageViews > numImages);
int imageIndex = 0;
for (int i = 0; i < numImageViews; ++i) {
VkFormat imageViewFormat = VULKAN_GetVkImageViewFormat(texture->format, i, format_colorspace);
int imagePlane = usePlaneViews ? i : -1;
result = VULKAN_AllocateImageView(rendererData, textureData->images[imageIndex].image, imagePlane, imageViewFormat, usage, imageViewSwizzle, samplerYcbcrConversion, &textureData->imageViews[i]);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("VULKAN_AllocateImageView()", result);
return false;
}
++textureData->numImageViews;
if (imageIndex < (numImages - 1)) {
++imageIndex;
}
}
if (texture->access == SDL_TEXTUREACCESS_TARGET) {
result = VULKAN_CreateFramebuffersAndRenderPasses(renderer,
texture->w,
texture->h,
textureFormat,
textureData->numImageViews,
textureData->imageViews,
&textureData->mainFramebuffer,
textureData->mainRenderpasses);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("VULKAN_CreateFramebuffersAndRenderPasses()", result);
return false;
}
}
const char *imageProperties[] = {
SDL_PROP_TEXTURE_VULKAN_TEXTURE_NUMBER,
SDL_PROP_TEXTURE_VULKAN_TEXTURE_U_NUMBER,
SDL_PROP_TEXTURE_VULKAN_TEXTURE_V_NUMBER
};
SDL_COMPILE_TIME_ASSERT(imageProperties, SDL_arraysize(imageProperties) == SDL_VULKAN_NUM_TEXTURE_BINDINGS);
if (numImageViews == 2 &&
SDL_HasProperty(create_props, SDL_PROP_TEXTURE_CREATE_VULKAN_TEXTURE_UV_NUMBER)) {
imageProperties[1] = SDL_PROP_TEXTURE_VULKAN_TEXTURE_UV_NUMBER;
}
SDL_PropertiesID props = SDL_GetTextureProperties(texture);
for (int i = 0; i < numImages; ++i) {
SDL_SetNumberProperty(props, imageProperties[i], (Sint64)textureData->images[i].image);
}
return true;
}
static void VULKAN_DestroyTexture(SDL_Renderer *renderer,
SDL_Texture *texture)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
if (!textureData) {
return;
}
// Because SDL_DestroyTexture might be called while the data is in-flight,
// we need to issue the batch first, which may cause performance issues
VULKAN_IssueBatch(rendererData);
VULKAN_WaitForGPU(rendererData);
for (int i = 0; i < textureData->numImageViews; ++i) {
if (textureData->imageViews[i] != VK_NULL_HANDLE) {
vkDestroyImageView(rendererData->device, textureData->imageViews[i], NULL);
textureData->imageViews[i] = VK_NULL_HANDLE;
}
}
for (int i = 0; i < textureData->numImages; ++i) {
VULKAN_DestroyImage(rendererData, &textureData->images[i]);
}
VULKAN_DestroyBuffer(rendererData, &textureData->stagingBuffer);
if (textureData->mainFramebuffer != VK_NULL_HANDLE) {
vkDestroyFramebuffer(rendererData->device, textureData->mainFramebuffer, NULL);
textureData->mainFramebuffer = VK_NULL_HANDLE;
}
for (uint32_t i = 0; i < SDL_arraysize(textureData->mainRenderpasses); i++) {
if (textureData->mainRenderpasses[i] != VK_NULL_HANDLE) {
vkDestroyRenderPass(rendererData->device, textureData->mainRenderpasses[i], NULL);
textureData->mainRenderpasses[i] = VK_NULL_HANDLE;
}
}
SDL_free(textureData->pixels);
SDL_free(textureData);
texture->internal = NULL;
}
static bool VULKAN_UpdateTextureInternal(VULKAN_RenderData *rendererData, VkImage image, VkFormat format, int plane, int x, int y, int w, int h, const void *pixels, int pitch, VkImageLayout *imageLayout)
{
VkDeviceSize pixelSize = VULKAN_GetBytesPerPixel(format, plane);
VkDeviceSize length = w * pixelSize;
VkDeviceSize uploadBufferSize = length * h;
const Uint8 *src;
Uint8 *dst;
VkResult rc;
int planeCount = VULKAN_VkFormatGetNumPlanes(format);
if (!VULKAN_EnsureCommandBuffer(rendererData)) {
return false;
}
int currentUploadBufferIndex = rendererData->currentUploadBuffer[rendererData->currentCommandBufferIndex];
VULKAN_Buffer *uploadBuffer = &rendererData->uploadBuffers[rendererData->currentCommandBufferIndex][currentUploadBufferIndex];
rc = VULKAN_AllocateBuffer(rendererData, uploadBufferSize,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
uploadBuffer);
if (rc != VK_SUCCESS) {
return false;
}
src = (const Uint8 *)pixels;
dst = (Uint8 *)uploadBuffer->mappedBufferPtr;
if (length == (VkDeviceSize)pitch) {
SDL_memcpy(dst, src, (size_t)length * h);
} else {
if (length > (VkDeviceSize)pitch) {
length = pitch;
}
for (VkDeviceSize row = h; row--; ) {
SDL_memcpy(dst, src, (size_t)length);
src += pitch;
dst += length;
}
}
// Make sure the destination is in the correct resource state
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
VK_ACCESS_TRANSFER_WRITE_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
image,
imageLayout);
VkBufferImageCopy region;
region.bufferOffset = 0;
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1;
region.imageSubresource.mipLevel = 0;
if (planeCount <= 1) {
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
} else {
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT << plane;
}
region.imageOffset.x = x;
region.imageOffset.y = y;
region.imageOffset.z = 0;
region.imageExtent.width = w;
region.imageExtent.height = h;
region.imageExtent.depth = 1;
vkCmdCopyBufferToImage(rendererData->currentCommandBuffer, uploadBuffer->buffer, image, *imageLayout, 1, &region);
// Transition the texture to be shader accessible
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_TRANSFER_WRITE_BIT,
VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
image,
imageLayout);
rendererData->currentUploadBuffer[rendererData->currentCommandBufferIndex]++;
// If we've used up all the upload buffers, we need to issue the batch
if (rendererData->currentUploadBuffer[rendererData->currentCommandBufferIndex] == SDL_VULKAN_NUM_UPLOAD_BUFFERS) {
VULKAN_IssueBatch(rendererData);
}
return true;
}
static bool VULKAN_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
const SDL_Rect *rect,
const Uint8 *Yplane, int Ypitch,
const Uint8 *UVplane, int UVpitch);
static bool VULKAN_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
const SDL_Rect *rect,
const Uint8 *Yplane, int Ypitch,
const Uint8 *Uplane, int Upitch,
const Uint8 *Vplane, int Vpitch);
static bool VULKAN_UpdateTexture(SDL_Renderer *renderer, SDL_Texture *texture,
const SDL_Rect *rect, const void *srcPixels,
int srcPitch)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
if (!textureData) {
return SDL_SetError("Texture is not currently available");
}
if (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES) {
return SDL_Unsupported();
}
if (textureData->numImageViews == 2) {
// NV12/NV21 data
int UVbpp = (int)VULKAN_GetBytesPerPixel(textureData->images[textureData->numImages - 1].format, 1);
int Ypitch = srcPitch;
int UVpitch = (srcPitch + (UVbpp - 1)) & ~(UVbpp - 1);
const Uint8 *plane0 = (const Uint8 *)srcPixels;
const Uint8 *plane1 = plane0 + rect->h * srcPitch;
return VULKAN_UpdateTextureNV(renderer, texture, rect, plane0, Ypitch, plane1, UVpitch);
} else if (textureData->numImageViews == 3) {
// YUV data
if (texture->format == SDL_PIXELFORMAT_I444 || texture->format == SDL_PIXELFORMAT_I4FL) {
const Uint8 *plane0 = (const Uint8 *)srcPixels;
const Uint8 *plane1 = plane0 + rect->h * srcPitch;
const Uint8 *plane2 = plane1 + rect->h * srcPitch;
return VULKAN_UpdateTextureYUV(renderer, texture, rect, plane0, srcPitch, plane1, srcPitch, plane2, srcPitch);
} else {
int Ypitch = srcPitch;
int UVpitch = ((Ypitch + 1 * SDL_BYTESPERPIXEL(texture->format)) / 2);
const Uint8 *plane0 = (const Uint8 *)srcPixels;
const Uint8 *plane1 = plane0 + rect->h * Ypitch;
const Uint8 *plane2 = plane1 + ((rect->h + 1) / 2) * UVpitch;
if (texture->format == SDL_PIXELFORMAT_YV12) {
return VULKAN_UpdateTextureYUV(renderer, texture, rect, plane0, Ypitch, plane2, UVpitch, plane1, UVpitch);
} else {
return VULKAN_UpdateTextureYUV(renderer, texture, rect, plane0, Ypitch, plane1, UVpitch, plane2, UVpitch);
}
}
}
if (!VULKAN_UpdateTextureInternal(rendererData, textureData->images[0].image, textureData->images[0].format, 0, rect->x, rect->y, rect->w, rect->h, srcPixels, srcPitch, &textureData->images[0].imageLayout)) {
return false;
}
return true;
}
static bool VULKAN_UpdateTextureYUV(SDL_Renderer *renderer, SDL_Texture *texture,
const SDL_Rect *rect,
const Uint8 *Yplane, int Ypitch,
const Uint8 *Uplane, int Upitch,
const Uint8 *Vplane, int Vpitch)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
if (!textureData) {
return SDL_SetError("Texture is not currently available");
}
if (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES) {
return SDL_Unsupported();
}
if (!VULKAN_UpdateTextureInternal(rendererData, textureData->images[0].image, textureData->images[0].format, 0, rect->x, rect->y, rect->w, rect->h, Yplane, Ypitch, &textureData->images[0].imageLayout)) {
return false;
}
if (texture->format == SDL_PIXELFORMAT_I444 || texture->format == SDL_PIXELFORMAT_I4FL) {
if (!VULKAN_UpdateTextureInternal(rendererData, textureData->images[1].image, textureData->images[1].format, 0, rect->x, rect->y, rect->w, rect->h, Uplane, Upitch, &textureData->images[1].imageLayout)) {
return false;
}
if (!VULKAN_UpdateTextureInternal(rendererData, textureData->images[2].image, textureData->images[2].format, 0, rect->x, rect->y, rect->w, rect->h, Vplane, Vpitch, &textureData->images[2].imageLayout)) {
return false;
}
} else if (texture->format == SDL_PIXELFORMAT_YV12) {
if (!VULKAN_UpdateTextureInternal(rendererData, textureData->images[2].image, textureData->images[2].format, 1, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, Vplane, Vpitch, &textureData->images[2].imageLayout)) {
return false;
}
if (!VULKAN_UpdateTextureInternal(rendererData, textureData->images[1].image, textureData->images[1].format, 2, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, Uplane, Upitch, &textureData->images[1].imageLayout)) {
return false;
}
} else {
if (!VULKAN_UpdateTextureInternal(rendererData, textureData->images[1].image, textureData->images[1].format, 1, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, Uplane, Upitch, &textureData->images[1].imageLayout)) {
return false;
}
if (!VULKAN_UpdateTextureInternal(rendererData, textureData->images[2].image, textureData->images[2].format, 2, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, Vplane, Vpitch, &textureData->images[2].imageLayout)) {
return false;
}
}
return true;
}
static bool VULKAN_UpdateTextureNV(SDL_Renderer *renderer, SDL_Texture *texture,
const SDL_Rect *rect,
const Uint8 *Yplane, int Ypitch,
const Uint8 *UVplane, int UVpitch)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
if (!textureData) {
return SDL_SetError("Texture is not currently available");
}
if (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES) {
return SDL_Unsupported();
}
if (!VULKAN_UpdateTextureInternal(rendererData, textureData->images[0].image, textureData->images[0].format, 0, rect->x, rect->y, rect->w, rect->h, Yplane, Ypitch, &textureData->images[0].imageLayout)) {
return false;
}
if (textureData->numImages == 2) {
if (!VULKAN_UpdateTextureInternal(rendererData, textureData->images[1].image, textureData->images[1].format, 0, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, UVplane, UVpitch, &textureData->images[1].imageLayout)) {
return false;
}
} else {
if (!VULKAN_UpdateTextureInternal(rendererData, textureData->images[0].image, textureData->images[0].format, 1, rect->x / 2, rect->y / 2, (rect->w + 1) / 2, (rect->h + 1) / 2, UVplane, UVpitch, &textureData->images[0].imageLayout)) {
return false;
}
}
return true;
}
static bool VULKAN_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
const SDL_Rect *rect, void **pixels, int *pitch)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
VkResult rc;
if (!textureData) {
return SDL_SetError("Texture is not currently available");
}
if (textureData->stagingBuffer.buffer != VK_NULL_HANDLE) {
return SDL_SetError("texture is already locked");
}
if (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES) {
return SDL_Unsupported();
}
if (textureData->numImageViews > 1) {
// It's more efficient to upload directly...
if (!textureData->pixels) {
size_t size, calculated_pitch;
if (!SDL_CalculateYUVSize(texture->format, texture->w, texture->h, &size, &calculated_pitch)) {
return false;
}
textureData->pitch = (int)calculated_pitch;
textureData->pixels = (Uint8 *)SDL_malloc(size);
if (!textureData->pixels) {
return false;
}
}
textureData->lockedRect = *rect;
*pixels =
(void *)(textureData->pixels + rect->y * textureData->pitch +
rect->x * SDL_BYTESPERPIXEL(texture->format));
*pitch = textureData->pitch;
return true;
}
VkDeviceSize pixelSize = VULKAN_GetBytesPerPixel(textureData->images[0].format, 0);
VkDeviceSize length = rect->w * pixelSize;
VkDeviceSize stagingBufferSize = length * rect->h;
rc = VULKAN_AllocateBuffer(rendererData,
stagingBufferSize,
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&textureData->stagingBuffer);
if (rc != VK_SUCCESS) {
return false;
}
/* Make note of where the staging texture will be written to
* (on a call to SDL_UnlockTexture):
*/
textureData->lockedRect = *rect;
/* Make sure the caller has information on the texture's pixel buffer,
* then return:
*/
*pixels = textureData->stagingBuffer.mappedBufferPtr;
*pitch = (int)length;
return true;
}
static void VULKAN_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
if (!textureData) {
return;
}
if (texture->format == SDL_PIXELFORMAT_EXTERNAL_OES) {
return;
}
if (textureData->numImageViews > 1) {
const SDL_Rect *rect = &textureData->lockedRect;
const Uint8 *pixels = textureData->pixels + rect->y * textureData->pitch + rect->x * SDL_BYTESPERPIXEL(texture->format);
VULKAN_UpdateTexture(renderer, texture, rect, pixels, textureData->pitch);
return;
}
if (!VULKAN_EnsureCommandBuffer(rendererData)) {
VULKAN_DestroyBuffer(rendererData, &textureData->stagingBuffer);
return;
}
// Make sure the destination is in the correct resource state
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
VK_ACCESS_TRANSFER_WRITE_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
textureData->images[0].image,
&textureData->images[0].imageLayout);
VkBufferImageCopy region;
region.bufferOffset = 0;
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1;
region.imageSubresource.mipLevel = 0;
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageOffset.x = textureData->lockedRect.x;
region.imageOffset.y = textureData->lockedRect.y;
region.imageOffset.z = 0;
region.imageExtent.width = textureData->lockedRect.w;
region.imageExtent.height = textureData->lockedRect.h;
region.imageExtent.depth = 1;
vkCmdCopyBufferToImage(rendererData->currentCommandBuffer, textureData->stagingBuffer.buffer, textureData->images[0].image, textureData->images[0].imageLayout, 1, &region);
// Transition the texture to be shader accessible
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_TRANSFER_WRITE_BIT,
VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
textureData->images[0].image,
&textureData->images[0].imageLayout);
// Execute the command list before releasing the staging buffer
VULKAN_IssueBatch(rendererData);
VULKAN_DestroyBuffer(rendererData, &textureData->stagingBuffer);
}
static bool VULKAN_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VULKAN_TextureData *textureData = NULL;
if (!VULKAN_EnsureCommandBuffer(rendererData)) {
return false;
}
if (texture) {
textureData = (VULKAN_TextureData *)texture->internal;
if (textureData->imageViews[0] == VK_NULL_HANDLE) {
return SDL_SetError("specified texture is not a render target");
}
rendererData->textureRenderTarget = textureData;
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
rendererData->textureRenderTarget->images[0].image,
&rendererData->textureRenderTarget->images[0].imageLayout);
} else {
if (rendererData->textureRenderTarget) {
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
rendererData->textureRenderTarget->images[0].image,
&rendererData->textureRenderTarget->images[0].imageLayout);
}
rendererData->textureRenderTarget = NULL;
}
VULKAN_IssueBatch(rendererData);
return true;
}
static bool VULKAN_QueueNoOp(SDL_Renderer *renderer, SDL_RenderCommand *cmd)
{
return true; // nothing to do in this backend.
}
static bool VULKAN_QueueDrawPoints(SDL_Renderer *renderer, SDL_RenderCommand *cmd, const SDL_FPoint *points, int count)
{
VULKAN_VertexPositionColor *verts = (VULKAN_VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(VULKAN_VertexPositionColor), 0, &cmd->data.draw.first);
int i;
SDL_FColor color = cmd->data.draw.color;
bool convert_color = SDL_RenderingLinearSpace(renderer);
if (!verts) {
return false;
}
cmd->data.draw.count = count;
if (convert_color) {
SDL_ConvertToLinear(renderer, &color);
}
for (i = 0; i < count; i++) {
verts->pos[0] = points[i].x + 0.5f;
verts->pos[1] = points[i].y + 0.5f;
verts->tex[0] = 0.0f;
verts->tex[1] = 0.0f;
verts->color = color;
verts++;
}
return true;
}
static bool VULKAN_QueueGeometry(SDL_Renderer *renderer, SDL_RenderCommand *cmd, SDL_Texture *texture,
const float *xy, int xy_stride, const SDL_FColor *color, int color_stride, const float *uv, int uv_stride,
int num_vertices, const void *indices, int num_indices, int size_indices,
float scale_x, float scale_y)
{
int i;
int count = indices ? num_indices : num_vertices;
VULKAN_VertexPositionColor *verts = (VULKAN_VertexPositionColor *)SDL_AllocateRenderVertices(renderer, count * sizeof(VULKAN_VertexPositionColor), 0, &cmd->data.draw.first);
bool convert_color = SDL_RenderingLinearSpace(renderer);
VULKAN_TextureData *textureData = texture ? (VULKAN_TextureData *)texture->internal : NULL;
float u_scale = textureData ? (float)texture->w / textureData->width : 0.0f;
float v_scale = textureData ? (float)texture->h / textureData->height : 0.0f;
if (!verts) {
return false;
}
cmd->data.draw.count = count;
size_indices = indices ? size_indices : 0;
for (i = 0; i < count; i++) {
int j;
float *xy_;
if (size_indices == 4) {
j = ((const Uint32 *)indices)[i];
} else if (size_indices == 2) {
j = ((const Uint16 *)indices)[i];
} else if (size_indices == 1) {
j = ((const Uint8 *)indices)[i];
} else {
j = i;
}
xy_ = (float *)((char *)xy + j * xy_stride);
verts->pos[0] = xy_[0] * scale_x;
verts->pos[1] = xy_[1] * scale_y;
verts->color = *(SDL_FColor *)((char *)color + j * color_stride);
if (convert_color) {
SDL_ConvertToLinear(renderer, &verts->color);
}
if (texture) {
float *uv_ = (float *)((char *)uv + j * uv_stride);
verts->tex[0] = uv_[0] * u_scale;
verts->tex[1] = uv_[1] * v_scale;
} else {
verts->tex[0] = 0.0f;
verts->tex[1] = 0.0f;
}
verts += 1;
}
return true;
}
static bool VULKAN_UpdateVertexBuffer(SDL_Renderer *renderer,
const void *vertexData, size_t dataSizeInBytes, VULKAN_DrawStateCache *stateCache)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
const int vbidx = rendererData->currentVertexBuffer;
VULKAN_Buffer *vertexBuffer;
if (dataSizeInBytes == 0) {
return true; // nothing to do.
}
if (rendererData->issueBatch) {
if (VULKAN_IssueBatch(rendererData) != VK_SUCCESS) {
return SDL_SetError("Failed to issue intermediate batch");
}
}
// If the existing vertex buffer isn't big enough, we need to recreate a big enough one
if (dataSizeInBytes > rendererData->vertexBuffers[vbidx].size) {
VULKAN_IssueBatch(rendererData);
VULKAN_WaitForGPU(rendererData);
VULKAN_CreateVertexBuffer(rendererData, vbidx, dataSizeInBytes);
}
vertexBuffer = &rendererData->vertexBuffers[vbidx];
SDL_memcpy(vertexBuffer->mappedBufferPtr, vertexData, dataSizeInBytes);
stateCache->vertexBuffer = vertexBuffer->buffer;
rendererData->currentVertexBuffer = vbidx + 1;
if (rendererData->currentVertexBuffer >= SDL_VULKAN_NUM_VERTEX_BUFFERS) {
rendererData->currentVertexBuffer = 0;
rendererData->issueBatch = true;
}
return true;
}
static VkSurfaceTransformFlagBitsKHR VULKAN_GetRotationForCurrentRenderTarget(VULKAN_RenderData *rendererData)
{
if (rendererData->textureRenderTarget) {
return VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
} else {
return rendererData->swapChainPreTransform;
}
}
static bool VULKAN_IsDisplayRotated90Degrees(VkSurfaceTransformFlagBitsKHR rotation)
{
switch (rotation) {
case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
return true;
default:
return false;
}
}
static bool VULKAN_UpdateViewport(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
const SDL_Rect *viewport = &rendererData->currentViewport;
Float4X4 projection;
Float4X4 view;
VkSurfaceTransformFlagBitsKHR rotation = VULKAN_GetRotationForCurrentRenderTarget(rendererData);
bool swapDimensions;
if (viewport->w == 0 || viewport->h == 0) {
/* If the viewport is empty, assume that it is because
* SDL_CreateRenderer is calling it, and will call it again later
* with a non-empty viewport.
*/
// SDL_Log("%s, no viewport was set!", SDL_FUNCTION);
return false;
}
switch (rotation) {
case VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR:
projection = MatrixRotationZ(SDL_PI_F * 0.5f);
break;
case VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR:
projection = MatrixRotationZ(SDL_PI_F);
break;
case VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR:
projection = MatrixRotationZ(-SDL_PI_F * 0.5f);
break;
case VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR:
default:
projection = MatrixIdentity();
break;
}
// Update the view matrix
SDL_zero(view);
view.m[0][0] = 2.0f / viewport->w;
view.m[1][1] = -2.0f / viewport->h;
view.m[2][2] = 1.0f;
view.m[3][0] = -1.0f;
view.m[3][1] = 1.0f;
view.m[3][3] = 1.0f;
rendererData->vertexShaderConstantsData.projectionAndView = MatrixMultiply(
view,
projection);
VkViewport vkViewport;
swapDimensions = VULKAN_IsDisplayRotated90Degrees(rotation);
if (swapDimensions) {
vkViewport.x = viewport->y;
vkViewport.y = viewport->x;
vkViewport.width = viewport->h;
vkViewport.height = viewport->w;
}
else {
vkViewport.x = viewport->x;
vkViewport.y = viewport->y;
vkViewport.width = viewport->w;
vkViewport.height = viewport->h;
}
vkViewport.minDepth = 0.0f;
vkViewport.maxDepth = 1.0f;
vkCmdSetViewport(rendererData->currentCommandBuffer, 0, 1, &vkViewport);
rendererData->viewportDirty = false;
return true;
}
static bool VULKAN_UpdateClipRect(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
const SDL_Rect *viewport = &rendererData->currentViewport;
VkSurfaceTransformFlagBitsKHR rotation = VULKAN_GetRotationForCurrentRenderTarget(rendererData);
bool swapDimensions = VULKAN_IsDisplayRotated90Degrees(rotation);
VkRect2D scissor;
if (rendererData->currentCliprectEnabled) {
scissor.offset.x = viewport->x + rendererData->currentCliprect.x;
scissor.offset.y = viewport->y + rendererData->currentCliprect.y;
scissor.extent.width = rendererData->currentCliprect.w;
scissor.extent.height = rendererData->currentCliprect.h;
} else {
scissor.offset.x = viewport->x;
scissor.offset.y = viewport->y;
scissor.extent.width = viewport->w;
scissor.extent.height = viewport->h;
}
if (swapDimensions) {
VkRect2D scissorTemp = scissor;
scissor.offset.x = scissorTemp.offset.y;
scissor.offset.y = scissorTemp.offset.x;
scissor.extent.width = scissorTemp.extent.height;
scissor.extent.height = scissorTemp.extent.width;
}
vkCmdSetScissor(rendererData->currentCommandBuffer, 0, 1, &scissor);
rendererData->cliprectDirty = false;
return true;
}
// Returns the input type for sRGB textures, based on whether the sampler converts them to linear
static float GetSRGBInputType(SDL_Renderer *renderer, bool srgb_view)
{
if (SDL_RenderingLinearSpace(renderer)) {
if (!srgb_view) {
// The shader needs to convert from sRGB to linear
return INPUTTYPE_SRGB;
}
} else {
if (srgb_view) {
// The sampler converts to linear, so the shader needs to convert back to sRGB
return INPUTTYPE_SCRGB;
}
}
// The texture is already in the colorspace we're rendering in
return INPUTTYPE_UNSPECIFIED;
}
static void VULKAN_SetupShaderConstants(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const SDL_Texture *texture, VULKAN_PixelShaderConstants *constants)
{
float output_headroom;
SDL_zerop(constants);
switch (renderer->current_colorspace) {
case SDL_COLORSPACE_SRGB_LINEAR:
constants->output_type = OUTPUTTYPE_SCRGB;
break;
case SDL_COLORSPACE_HDR10:
constants->output_type = OUTPUTTYPE_HDR10;
break;
default:
constants->output_type = OUTPUTTYPE_SRGB;
break;
}
constants->color_scale = cmd->data.draw.color_scale;
if (texture) {
VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
switch (texture->format) {
case SDL_PIXELFORMAT_INDEX8:
switch (cmd->data.draw.texture_scale_mode) {
case SDL_SCALEMODE_NEAREST:
constants->texture_type = TEXTURETYPE_PALETTE_NEAREST;
break;
case SDL_SCALEMODE_LINEAR:
constants->texture_type = TEXTURETYPE_PALETTE_LINEAR;
break;
case SDL_SCALEMODE_PIXELART:
constants->texture_type = TEXTURETYPE_PALETTE_PIXELART;
break;
default:
SDL_assert(!"Unknown scale mode");
break;
}
{
// The palette is stored in an RGBA32 texture
const VkFormat paletteFormat = VULKAN_GetVkImageFormat(SDL_PIXELFORMAT_RGBA32, renderer->output_colorspace);
constants->input_type = GetSRGBInputType(renderer, VkFormatIsSRGB(paletteFormat));
}
break;
case SDL_PIXELFORMAT_YV12:
case SDL_PIXELFORMAT_IYUV:
case SDL_PIXELFORMAT_I444:
case SDL_PIXELFORMAT_I0FL:
case SDL_PIXELFORMAT_I4FL:
constants->texture_type = TEXTURETYPE_YUV;
break;
case SDL_PIXELFORMAT_NV12:
case SDL_PIXELFORMAT_P010:
constants->texture_type = TEXTURETYPE_NV12;
break;
case SDL_PIXELFORMAT_NV21:
constants->texture_type = TEXTURETYPE_NV21;
break;
default:
if (cmd->data.draw.texture_scale_mode == SDL_SCALEMODE_PIXELART) {
constants->texture_type = TEXTURETYPE_RGB_PIXELART;
} else {
constants->texture_type = TEXTURETYPE_RGB;
}
switch (SDL_COLORSPACETRANSFER(texture->colorspace)) {
case SDL_TRANSFER_CHARACTERISTICS_LINEAR:
constants->input_type = INPUTTYPE_SCRGB;
break;
case SDL_TRANSFER_CHARACTERISTICS_PQ:
constants->input_type = INPUTTYPE_HDR10;
break;
default:
constants->input_type = GetSRGBInputType(renderer, textureData->srgb_view);
break;
}
break;
}
if (constants->texture_type == TEXTURETYPE_YUV ||
constants->texture_type == TEXTURETYPE_NV12 ||
constants->texture_type == TEXTURETYPE_NV21) {
if (SDL_COLORSPACETRANSFER(texture->colorspace) == SDL_TRANSFER_CHARACTERISTICS_PQ) {
constants->input_type = INPUTTYPE_HDR10;
} else {
constants->input_type = INPUTTYPE_SRGB;
}
}
if (constants->texture_type == TEXTURETYPE_PALETTE_LINEAR ||
constants->texture_type == TEXTURETYPE_PALETTE_PIXELART ||
constants->texture_type == TEXTURETYPE_RGB_PIXELART) {
constants->texture_width = texture->w;
constants->texture_height = texture->h;
constants->texel_width = 1.0f / constants->texture_width;
constants->texel_height = 1.0f / constants->texture_height;
}
constants->sdr_white_point = texture->SDR_white_point;
if (renderer->target) {
output_headroom = renderer->target->HDR_headroom;
} else {
output_headroom = renderer->HDR_headroom;
}
if (texture->HDR_headroom > output_headroom && output_headroom > 0.0f) {
constants->tonemap_method = TONEMAP_CHROME;
constants->tonemap_factor1 = (output_headroom / (texture->HDR_headroom * texture->HDR_headroom));
constants->tonemap_factor2 = (1.0f / output_headroom);
}
if (textureData->YCbCr_matrix) {
SDL_memcpy(constants->YCbCr_matrix, textureData->YCbCr_matrix, sizeof(constants->YCbCr_matrix));
}
}
}
static VULKAN_Shader SelectShader(SDL_Renderer *renderer, const VULKAN_PixelShaderConstants *shader_constants)
{
if (shader_constants) {
if (renderer->current_colorspace == SDL_COLORSPACE_HDR10) {
// The advanced shader handles PQ output
return SHADER_ADVANCED;
}
if (shader_constants->texture_type == TEXTURETYPE_RGB &&
shader_constants->input_type == INPUTTYPE_UNSPECIFIED &&
shader_constants->tonemap_method == TONEMAP_NONE) {
return SHADER_RGB;
}
return SHADER_ADVANCED;
} else {
if (renderer->current_colorspace == SDL_COLORSPACE_HDR10) {
return SHADER_SOLID_PQ;
}
return SHADER_SOLID;
}
}
static VkDescriptorPool VULKAN_AllocateDescriptorPool(VULKAN_RenderData *rendererData)
{
VkDescriptorPool descriptorPool = VK_NULL_HANDLE;
VkDescriptorPoolSize descriptorPoolSizes[3];
VkResult result;
descriptorPoolSizes[0].descriptorCount = SDL_VULKAN_MAX_DESCRIPTOR_SETS;
descriptorPoolSizes[0].type = VK_DESCRIPTOR_TYPE_SAMPLER;
descriptorPoolSizes[1].descriptorCount = SDL_VULKAN_NUM_TEXTURE_BINDINGS * SDL_VULKAN_MAX_DESCRIPTOR_SETS;
descriptorPoolSizes[1].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
descriptorPoolSizes[2].descriptorCount = SDL_VULKAN_MAX_DESCRIPTOR_SETS;
descriptorPoolSizes[2].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = { 0 };
descriptorPoolCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
descriptorPoolCreateInfo.poolSizeCount = SDL_arraysize(descriptorPoolSizes);
descriptorPoolCreateInfo.pPoolSizes = descriptorPoolSizes;
descriptorPoolCreateInfo.maxSets = SDL_VULKAN_MAX_DESCRIPTOR_SETS;
result = vkCreateDescriptorPool(rendererData->device, &descriptorPoolCreateInfo, NULL, &descriptorPool);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateDescrptorPool()", result);
return VK_NULL_HANDLE;
}
return descriptorPool;
}
static VkResult VULKAN_CreateDescriptorSetAndPipelineLayout(VULKAN_RenderData *rendererData, VkSampler samplerYcbcr, VkDescriptorSetLayout *descriptorSetLayoutOut,
VkPipelineLayout *pipelineLayoutOut)
{
VkResult result;
// Descriptor set layout
VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = { 0 };
descriptorSetLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
descriptorSetLayoutCreateInfo.flags = 0;
VkDescriptorSetLayoutBinding layoutBindings[1 + SDL_VULKAN_NUM_TEXTURE_BINDINGS];
// PixelShaderConstants
layoutBindings[0].binding = 0;
layoutBindings[0].descriptorCount = 1;
layoutBindings[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
layoutBindings[0].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
layoutBindings[0].pImmutableSamplers = NULL;
for (uint32_t i = 1; i < SDL_arraysize(layoutBindings); ++i)
{
layoutBindings[i].binding = i;
layoutBindings[i].descriptorCount = 1;
layoutBindings[i].descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
layoutBindings[i].stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;
layoutBindings[i].pImmutableSamplers = (samplerYcbcr != VK_NULL_HANDLE) ? &samplerYcbcr : NULL;
}
descriptorSetLayoutCreateInfo.bindingCount = SDL_arraysize(layoutBindings);
descriptorSetLayoutCreateInfo.pBindings = layoutBindings;
result = vkCreateDescriptorSetLayout(rendererData->device, &descriptorSetLayoutCreateInfo, NULL, descriptorSetLayoutOut);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateDescriptorSetLayout()", result);
return result;
}
// Pipeline layout
VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo = { 0 };
VkPushConstantRange pushConstantRange;
pushConstantRange.size = sizeof( VULKAN_VertexShaderConstants );
pushConstantRange.offset = 0;
pushConstantRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
pipelineLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
pipelineLayoutCreateInfo.setLayoutCount = 1;
pipelineLayoutCreateInfo.pSetLayouts = descriptorSetLayoutOut;
pipelineLayoutCreateInfo.pushConstantRangeCount = 1;
pipelineLayoutCreateInfo.pPushConstantRanges = &pushConstantRange;
result = vkCreatePipelineLayout(rendererData->device, &pipelineLayoutCreateInfo, NULL, pipelineLayoutOut);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreatePipelineLayout()", result);
return result;
}
return result;
}
static VkDescriptorSet VULKAN_AllocateDescriptorSet(SDL_Renderer *renderer, VULKAN_Shader shader, VkDescriptorSetLayout descriptorSetLayout,
VkBuffer constantBuffer, VkDeviceSize constantBufferOffset, int numImages, VkImageView *imageViews, int numSamplers, VkSampler *samplers)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
uint32_t currentDescriptorPoolIndex = rendererData->currentDescriptorPoolIndex;
VkDescriptorPool descriptorPool = rendererData->descriptorPools[rendererData->currentCommandBufferIndex][currentDescriptorPoolIndex];
VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = { 0 };
descriptorSetAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
descriptorSetAllocateInfo.descriptorSetCount = 1;
descriptorSetAllocateInfo.descriptorPool = descriptorPool;
descriptorSetAllocateInfo.pSetLayouts = &descriptorSetLayout;
VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
VkResult result = (rendererData->currentDescriptorSetIndex >= SDL_VULKAN_MAX_DESCRIPTOR_SETS) ? VK_ERROR_OUT_OF_DEVICE_MEMORY : VK_SUCCESS;
if (result == VK_SUCCESS) {
result = vkAllocateDescriptorSets(rendererData->device, &descriptorSetAllocateInfo, &descriptorSet);
}
if (result != VK_SUCCESS) {
// Out of descriptor sets in this pool - see if we have more pools allocated
currentDescriptorPoolIndex++;
if (currentDescriptorPoolIndex < rendererData->numDescriptorPools[rendererData->currentCommandBufferIndex]) {
descriptorPool = rendererData->descriptorPools[rendererData->currentCommandBufferIndex][currentDescriptorPoolIndex];
descriptorSetAllocateInfo.descriptorPool = descriptorPool;
result = vkAllocateDescriptorSets(rendererData->device, &descriptorSetAllocateInfo, &descriptorSet);
if (result != VK_SUCCESS) {
// This should not fail - we are allocating from the front of the descriptor set
SDL_SetError("Unable to allocate descriptor set");
return VK_NULL_HANDLE;
}
rendererData->currentDescriptorPoolIndex = currentDescriptorPoolIndex;
rendererData->currentDescriptorSetIndex = 0;
}
// We are out of pools, create a new one
else {
descriptorPool = VULKAN_AllocateDescriptorPool(rendererData);
if (descriptorPool == VK_NULL_HANDLE) {
// SDL_SetError called in VULKAN_AllocateDescriptorPool if we failed to allocate a new pool
return VK_NULL_HANDLE;
}
rendererData->numDescriptorPools[rendererData->currentCommandBufferIndex]++;
VkDescriptorPool *descriptorPools = (VkDescriptorPool *)SDL_realloc(rendererData->descriptorPools[rendererData->currentCommandBufferIndex],
sizeof(VkDescriptorPool) * rendererData->numDescriptorPools[rendererData->currentCommandBufferIndex]);
descriptorPools[rendererData->numDescriptorPools[rendererData->currentCommandBufferIndex] - 1] = descriptorPool;
rendererData->descriptorPools[rendererData->currentCommandBufferIndex] = descriptorPools;
rendererData->currentDescriptorPoolIndex = currentDescriptorPoolIndex;
rendererData->currentDescriptorSetIndex = 0;
// Call recursively to allocate from the new pool
return VULKAN_AllocateDescriptorSet(renderer, shader, descriptorSetLayout, constantBuffer, constantBufferOffset, numImages, imageViews, numSamplers, samplers);
}
}
rendererData->currentDescriptorSetIndex++;
VkDescriptorImageInfo combinedImageSamplerDescriptor[SDL_VULKAN_NUM_TEXTURE_BINDINGS];
VkDescriptorBufferInfo bufferDescriptor = { 0 };
bufferDescriptor.buffer = constantBuffer;
bufferDescriptor.offset = constantBufferOffset;
bufferDescriptor.range = sizeof(VULKAN_PixelShaderConstants);
VkWriteDescriptorSet descriptorWrites[1 + SDL_arraysize(combinedImageSamplerDescriptor)];
SDL_zero(descriptorWrites);
uint32_t descriptorCount = 1; // Always have the uniform buffer
descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
descriptorWrites[0].dstSet = descriptorSet;
descriptorWrites[0].dstBinding = 0;
descriptorWrites[0].dstArrayElement = 0;
descriptorWrites[0].descriptorCount = 1;
descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
descriptorWrites[0].pBufferInfo = &bufferDescriptor;
SDL_assert(numSamplers == numImages);
for (int i = 0; i < numImages; ++i) {
SDL_assert(i < SDL_arraysize(combinedImageSamplerDescriptor));
VkDescriptorImageInfo *pImageInfo = &combinedImageSamplerDescriptor[i];
SDL_zerop(pImageInfo);
if (descriptorSetLayout == rendererData->descriptorSetLayout) {
pImageInfo->sampler = samplers[i];
} else {
// Ignore the sampler if we're using YcBcCr data since it will be baked in the descriptor set layout
}
pImageInfo->imageView = imageViews[i];
pImageInfo->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
SDL_assert(descriptorCount < SDL_arraysize(descriptorWrites));
VkWriteDescriptorSet *pDescriptorSet = &descriptorWrites[descriptorCount++];
pDescriptorSet->sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
pDescriptorSet->dstSet = descriptorSet;
pDescriptorSet->dstBinding = 1 + i;
pDescriptorSet->dstArrayElement = 0;
pDescriptorSet->descriptorCount = 1;
pDescriptorSet->descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
pDescriptorSet->pImageInfo = pImageInfo;
}
vkUpdateDescriptorSets(rendererData->device, descriptorCount, descriptorWrites, 0, NULL);
return descriptorSet;
}
#ifdef SDL_PLATFORM_ANDROID
static VULKAN_YUVPipeline *VULKAN_GetYUVPipeline(VULKAN_RenderData *rendererData, const VULKAN_YUVPipelineCreateInfo *createInfo)
{
VULKAN_YUVPipeline *pipeline;
VkResult result;
VULKAN_YUVPipelineCreateInfo cacheKey;
SDL_memcpy(&cacheKey, createInfo, sizeof(cacheKey));
cacheKey.samplerYcbcrConversionCreateInfo.pNext = NULL;
for (pipeline = rendererData->yuvPipelineCache; pipeline; pipeline = pipeline->next) {
if (SDL_memcmp(&pipeline->createInfo, &cacheKey, sizeof(cacheKey)) == 0) {
return pipeline;
}
}
pipeline = (VULKAN_YUVPipeline *)SDL_calloc(1, sizeof(*pipeline));
if (!pipeline) {
return NULL;
}
SDL_memcpy(&pipeline->createInfo, &cacheKey, sizeof(cacheKey));
result = vkCreateSamplerYcbcrConversionKHR(rendererData->device, &createInfo->samplerYcbcrConversionCreateInfo, NULL, &pipeline->samplerYcbcrConversion);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateSamplerYcbcrConversionKHR()", result);
VULKAN_CleanupYUVPipeline(rendererData, pipeline);
return NULL;
}
// Also create VkSampler object which we will need to pass to the PSO as an immutable sampler
VkSamplerCreateInfo samplerCreateInfo = { 0 };
samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
samplerCreateInfo.magFilter = createInfo->filter;
samplerCreateInfo.minFilter = createInfo->filter;
samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.mipLodBias = 0.0f;
samplerCreateInfo.anisotropyEnable = VK_FALSE;
samplerCreateInfo.maxAnisotropy = 1.0f;
samplerCreateInfo.minLod = 0.0f;
samplerCreateInfo.maxLod = 1000.0f;
VkSamplerYcbcrConversionInfoKHR samplerYcbcrConversionInfo = { 0 };
samplerYcbcrConversionInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR;
samplerYcbcrConversionInfo.conversion = pipeline->samplerYcbcrConversion;
samplerCreateInfo.pNext = &samplerYcbcrConversionInfo;
result = vkCreateSampler(rendererData->device, &samplerCreateInfo, NULL, &pipeline->samplerYcbcr);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateSampler()", result);
VULKAN_CleanupYUVPipeline(rendererData, pipeline);
return NULL;
}
// Allocate special descriptor set layout with samplerYcbcr baked as an immutable sampler
result = VULKAN_CreateDescriptorSetAndPipelineLayout(rendererData, pipeline->samplerYcbcr, &pipeline->descriptorSetLayoutYcbcr, &pipeline->pipelineLayoutYcbcr);
if (result != VK_SUCCESS) {
VULKAN_CleanupYUVPipeline(rendererData, pipeline);
return NULL;
}
// Link it into our cache!
pipeline->next = rendererData->yuvPipelineCache;
rendererData->yuvPipelineCache = pipeline;
return pipeline;
}
#endif // SDL_PLATFORM_ANDROID
static void VULKAN_CleanupYUVPipeline(VULKAN_RenderData *rendererData, VULKAN_YUVPipeline *pipeline)
{
if (pipeline->samplerYcbcrConversion != VK_NULL_HANDLE) {
vkDestroySamplerYcbcrConversionKHR(rendererData->device, pipeline->samplerYcbcrConversion, NULL);
}
if (pipeline->samplerYcbcr != VK_NULL_HANDLE) {
vkDestroySampler(rendererData->device, pipeline->samplerYcbcr, NULL);
}
if (pipeline->pipelineLayoutYcbcr != VK_NULL_HANDLE) {
vkDestroyPipelineLayout(rendererData->device, pipeline->pipelineLayoutYcbcr, NULL);
}
if (pipeline->descriptorSetLayoutYcbcr != VK_NULL_HANDLE) {
vkDestroyDescriptorSetLayout(rendererData->device, pipeline->descriptorSetLayoutYcbcr, NULL);
}
SDL_free(pipeline);
}
static bool VULKAN_SetDrawState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, VkPipelineLayout pipelineLayout, VkDescriptorSetLayout descriptorSetLayout, const VULKAN_PixelShaderConstants *shader_constants, VkPrimitiveTopology topology, int numImages, VkImageView *imageViews, int numSamplers, VkSampler *samplers, const Float4X4 *matrix, VULKAN_DrawStateCache *stateCache)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
const SDL_BlendMode blendMode = cmd->data.draw.blend;
VkFormat format;
const Float4X4 *newmatrix = matrix ? matrix : &rendererData->identity;
bool updateConstants = false;
VULKAN_Shader shader = SelectShader(renderer, shader_constants);
VULKAN_PixelShaderConstants solid_constants;
VkDescriptorSet descriptorSet;
VkBuffer constantBuffer;
VkDeviceSize constantBufferOffset;
int i;
if (!VULKAN_ActivateCommandBuffer(renderer, VK_ATTACHMENT_LOAD_OP_LOAD, NULL, stateCache)) {
return false;
}
if (rendererData->textureRenderTarget) {
format = rendererData->textureRenderTarget->images[0].format;
} else {
format = rendererData->surfaceFormat.format;
}
// See if we need to change the pipeline state
if (!rendererData->currentPipelineState ||
rendererData->currentPipelineState->shader != shader ||
rendererData->currentPipelineState->blendMode != blendMode ||
rendererData->currentPipelineState->topology != topology ||
rendererData->currentPipelineState->format != format ||
rendererData->currentPipelineState->pipelineLayout != pipelineLayout ||
rendererData->currentPipelineState->descriptorSetLayout != descriptorSetLayout) {
rendererData->currentPipelineState = NULL;
for (i = 0; i < rendererData->pipelineStateCount; ++i) {
VULKAN_PipelineState *candidatePiplineState = &rendererData->pipelineStates[i];
if (candidatePiplineState->shader == shader &&
candidatePiplineState->blendMode == blendMode &&
candidatePiplineState->topology == topology &&
candidatePiplineState->format == format &&
candidatePiplineState->pipelineLayout == pipelineLayout &&
candidatePiplineState->descriptorSetLayout == descriptorSetLayout) {
rendererData->currentPipelineState = candidatePiplineState;
break;
}
}
// If we didn't find a match, create a new one -- it must mean the blend mode is non-standard
if (!rendererData->currentPipelineState) {
rendererData->currentPipelineState = VULKAN_CreatePipelineState(renderer, shader, pipelineLayout, descriptorSetLayout, blendMode, topology, format);
}
if (!rendererData->currentPipelineState) {
return SDL_SetError("Unable to create required pipeline state");
}
vkCmdBindPipeline(rendererData->currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, rendererData->currentPipelineState->pipeline);
updateConstants = true;
}
if (rendererData->viewportDirty) {
if (VULKAN_UpdateViewport(renderer)) {
// vertexShaderConstantsData.projectionAndView has changed
updateConstants = true;
}
}
if (rendererData->cliprectDirty) {
VULKAN_UpdateClipRect(renderer);
}
if (updateConstants == true || SDL_memcmp(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix)) != 0) {
SDL_memcpy(&rendererData->vertexShaderConstantsData.model, newmatrix, sizeof(*newmatrix));
vkCmdPushConstants(rendererData->currentCommandBuffer, rendererData->currentPipelineState->pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0,
sizeof(rendererData->vertexShaderConstantsData),
&rendererData->vertexShaderConstantsData);
}
if (!shader_constants) {
VULKAN_SetupShaderConstants(renderer, cmd, NULL, &solid_constants);
shader_constants = &solid_constants;
}
constantBuffer = rendererData->constantBuffers[rendererData->currentCommandBufferIndex][rendererData->currentConstantBufferIndex].buffer;
constantBufferOffset = (rendererData->currentConstantBufferOffset < 0) ? 0 : rendererData->currentConstantBufferOffset;
if (updateConstants ||
SDL_memcmp(shader_constants, &rendererData->currentPipelineState->shader_constants, sizeof(*shader_constants)) != 0) {
if (rendererData->currentConstantBufferOffset == -1) {
// First time, grab offset 0
rendererData->currentConstantBufferOffset = 0;
constantBufferOffset = 0;
} else {
// Align the next address to the minUniformBufferOffsetAlignment
VkDeviceSize alignment = rendererData->physicalDeviceProperties.limits.minUniformBufferOffsetAlignment;
SDL_assert(rendererData->currentConstantBufferOffset >= 0);
rendererData->currentConstantBufferOffset += (int32_t)(sizeof(VULKAN_PixelShaderConstants) + alignment - 1) & ~(alignment - 1);
constantBufferOffset = rendererData->currentConstantBufferOffset;
}
// If we have run out of size in this constant buffer, create another if needed
if (rendererData->currentConstantBufferOffset >= SDL_VULKAN_CONSTANT_BUFFER_DEFAULT_SIZE) {
uint32_t newConstantBufferIndex = (rendererData->currentConstantBufferIndex + 1);
// We need a new constant buffer
if (newConstantBufferIndex >= rendererData->numConstantBuffers[rendererData->currentCommandBufferIndex]) {
VULKAN_Buffer newConstantBuffer;
VkResult result = VULKAN_AllocateBuffer(rendererData,
SDL_VULKAN_CONSTANT_BUFFER_DEFAULT_SIZE,
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&newConstantBuffer);
if (result != VK_SUCCESS) {
return false;
}
rendererData->numConstantBuffers[rendererData->currentCommandBufferIndex]++;
VULKAN_Buffer *newConstantBuffers = (VULKAN_Buffer *)SDL_realloc(rendererData->constantBuffers[rendererData->currentCommandBufferIndex],
sizeof(VULKAN_Buffer) * rendererData->numConstantBuffers[rendererData->currentCommandBufferIndex]);
newConstantBuffers[rendererData->numConstantBuffers[rendererData->currentCommandBufferIndex] - 1] = newConstantBuffer;
rendererData->constantBuffers[rendererData->currentCommandBufferIndex] = newConstantBuffers;
}
rendererData->currentConstantBufferIndex = newConstantBufferIndex;
rendererData->currentConstantBufferOffset = 0;
constantBufferOffset = 0;
constantBuffer = rendererData->constantBuffers[rendererData->currentCommandBufferIndex][rendererData->currentConstantBufferIndex].buffer;
}
SDL_memcpy(&rendererData->currentPipelineState->shader_constants, shader_constants, sizeof(*shader_constants));
// Upload constants to persistently mapped buffer
uint8_t *dst = (uint8_t *)rendererData->constantBuffers[rendererData->currentCommandBufferIndex][rendererData->currentConstantBufferIndex].mappedBufferPtr;
dst += constantBufferOffset;
SDL_memcpy(dst, &rendererData->currentPipelineState->shader_constants, sizeof(VULKAN_PixelShaderConstants));
}
// Allocate/update descriptor set with the bindings
descriptorSet = VULKAN_AllocateDescriptorSet(renderer, shader, descriptorSetLayout, constantBuffer, constantBufferOffset, numImages, imageViews, numSamplers, samplers);
if (descriptorSet == VK_NULL_HANDLE) {
return false;
}
// Bind the descriptor set with the sampler/UBO/image views
vkCmdBindDescriptorSets(rendererData->currentCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, rendererData->currentPipelineState->pipelineLayout,
0, 1, &descriptorSet, 0, NULL);
return true;
}
static VkSampler VULKAN_GetSampler(VULKAN_RenderData *data, SDL_PixelFormat format, SDL_ScaleMode scale_mode, SDL_TextureAddressMode address_u, SDL_TextureAddressMode address_v)
{
if (format == SDL_PIXELFORMAT_INDEX8) {
// We'll do linear sampling in the shader if needed
scale_mode = SDL_SCALEMODE_NEAREST;
}
Uint32 key = RENDER_SAMPLER_HASHKEY(scale_mode, address_u, address_v);
SDL_assert(key < SDL_arraysize(data->samplers));
if (!data->samplers[key]) {
VkSamplerCreateInfo samplerCreateInfo = { 0 };
samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
samplerCreateInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
samplerCreateInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
samplerCreateInfo.mipLodBias = 0.0f;
samplerCreateInfo.anisotropyEnable = VK_FALSE;
samplerCreateInfo.maxAnisotropy = 1.0f;
samplerCreateInfo.minLod = 0.0f;
samplerCreateInfo.maxLod = 1000.0f;
switch (scale_mode) {
case SDL_SCALEMODE_NEAREST:
samplerCreateInfo.magFilter = VK_FILTER_NEAREST;
samplerCreateInfo.minFilter = VK_FILTER_NEAREST;
break;
case SDL_SCALEMODE_PIXELART: // Uses linear sampling
case SDL_SCALEMODE_LINEAR:
samplerCreateInfo.magFilter = VK_FILTER_LINEAR;
samplerCreateInfo.minFilter = VK_FILTER_LINEAR;
break;
default:
SDL_SetError("Unknown scale mode: %d", scale_mode);
return VK_NULL_HANDLE;
}
switch (address_u) {
case SDL_TEXTURE_ADDRESS_CLAMP:
samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
break;
case SDL_TEXTURE_ADDRESS_WRAP:
samplerCreateInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
break;
default:
SDL_SetError("Unknown texture address mode: %d", address_u);
return VK_NULL_HANDLE;
}
switch (address_v) {
case SDL_TEXTURE_ADDRESS_CLAMP:
samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
break;
case SDL_TEXTURE_ADDRESS_WRAP:
samplerCreateInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
break;
default:
SDL_SetError("Unknown texture address mode: %d", address_v);
return VK_NULL_HANDLE;
}
VkResult result = vkCreateSampler(data->device, &samplerCreateInfo, NULL, &data->samplers[key]);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkCreateSampler()", result);
return VK_NULL_HANDLE;
}
}
return data->samplers[key];
}
static bool VULKAN_SetCopyState(SDL_Renderer *renderer, const SDL_RenderCommand *cmd, const Float4X4 *matrix, VULKAN_DrawStateCache *stateCache)
{
SDL_Texture *texture = cmd->data.draw.texture;
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VULKAN_TextureData *textureData = (VULKAN_TextureData *)texture->internal;
int numImageViews = 0;
VkImageView imageViews[SDL_VULKAN_NUM_TEXTURE_BINDINGS];
int numSamplers = 0;
VkSampler samplers[SDL_VULKAN_NUM_TEXTURE_BINDINGS];
VULKAN_PixelShaderConstants constants;
VkDescriptorSetLayout descriptorSetLayout;
VkPipelineLayout pipelineLayout;
if (!textureData) {
return SDL_SetError("Texture is not currently available");
}
VULKAN_SetupShaderConstants(renderer, cmd, texture, &constants);
for (int i = 0; i < textureData->numImages; ++i) {
if (textureData->images[i].imageLayout != VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
bool stoppedRenderPass = false;
if (rendererData->currentRenderPass != VK_NULL_HANDLE) {
vkCmdEndRenderPass(rendererData->currentCommandBuffer);
rendererData->currentRenderPass = VK_NULL_HANDLE;
stoppedRenderPass = true;
}
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
textureData->images[i].image,
&textureData->images[i].imageLayout);
if (stoppedRenderPass) {
VULKAN_BeginRenderPass(rendererData, VK_ATTACHMENT_LOAD_OP_LOAD, NULL);
}
}
}
for (int i = 0; i < textureData->numImageViews; ++i) {
imageViews[numImageViews++] = textureData->imageViews[i];
}
samplers[numSamplers] = VULKAN_GetSampler(rendererData, texture->format, cmd->data.draw.texture_scale_mode, cmd->data.draw.texture_address_mode_u, cmd->data.draw.texture_address_mode_v);
if (samplers[numSamplers] == VK_NULL_HANDLE) {
return false;
}
++numSamplers;
if (texture->palette) {
VULKAN_PaletteData *palette = (VULKAN_PaletteData *)texture->palette->internal;
if (palette->image.imageLayout != VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
bool stoppedRenderPass = false;
if (rendererData->currentRenderPass != VK_NULL_HANDLE) {
vkCmdEndRenderPass(rendererData->currentCommandBuffer);
rendererData->currentRenderPass = VK_NULL_HANDLE;
stoppedRenderPass = true;
}
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_ACCESS_SHADER_READ_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
palette->image.image,
&palette->image.imageLayout);
if (stoppedRenderPass) {
VULKAN_BeginRenderPass(rendererData, VK_ATTACHMENT_LOAD_OP_LOAD, NULL);
}
}
imageViews[numImageViews++] = palette->imageView;
samplers[numSamplers] = VULKAN_GetSampler(rendererData, SDL_PIXELFORMAT_UNKNOWN, SDL_SCALEMODE_NEAREST, SDL_TEXTURE_ADDRESS_CLAMP, SDL_TEXTURE_ADDRESS_CLAMP);
if (samplers[numSamplers] == VK_NULL_HANDLE) {
return false;
}
++numSamplers;
}
// Fill out the rest of the image views and samplers
while (numImageViews < SDL_arraysize(imageViews)) {
imageViews[numImageViews++] = imageViews[0];
}
while (numSamplers < SDL_arraysize(samplers)) {
samplers[numSamplers++] = samplers[0];
}
if (textureData->yuvPipeline) {
descriptorSetLayout = textureData->yuvPipeline->descriptorSetLayoutYcbcr;
pipelineLayout = textureData->yuvPipeline->pipelineLayoutYcbcr;
} else {
descriptorSetLayout = rendererData->descriptorSetLayout;
pipelineLayout = rendererData->pipelineLayout;
}
return VULKAN_SetDrawState(renderer, cmd, pipelineLayout, descriptorSetLayout, &constants, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, numImageViews, imageViews, numSamplers, samplers, matrix, stateCache);
}
static void VULKAN_DrawPrimitives(SDL_Renderer *renderer, VkPrimitiveTopology primitiveTopology, const size_t vertexStart, const size_t vertexCount)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
vkCmdDraw(rendererData->currentCommandBuffer, (uint32_t)vertexCount, 1, (uint32_t)vertexStart, 0);
}
static void VULKAN_InvalidateCachedState(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
rendererData->currentPipelineState = NULL;
rendererData->cliprectDirty = true;
// Make sure pending drawing is submitted to the GPU
VULKAN_IssueBatch(rendererData);
}
static bool VULKAN_RunCommandQueue(SDL_Renderer *renderer, SDL_RenderCommand *cmd, void *vertices, size_t vertsize)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VkSurfaceTransformFlagBitsKHR currentRotation = VULKAN_GetRotationForCurrentRenderTarget(rendererData);
VULKAN_DrawStateCache stateCache;
SDL_zero(stateCache);
if (!rendererData->device) {
return SDL_SetError("Device lost and couldn't be recovered");
}
if(rendererData->currentViewportRotation != currentRotation) {
rendererData->currentViewportRotation = currentRotation;
rendererData->viewportDirty = true;
rendererData->cliprectDirty = true;
}
if (rendererData->recreateSwapchain) {
if (VULKAN_UpdateForWindowSizeChange(renderer) != VK_SUCCESS) {
return false;
}
rendererData->recreateSwapchain = false;
}
if (!VULKAN_UpdateVertexBuffer(renderer, vertices, vertsize, &stateCache)) {
return false;
}
while (cmd) {
switch (cmd->command) {
case SDL_RENDERCMD_SETDRAWCOLOR:
{
break; // this isn't currently used in this render backend.
}
case SDL_RENDERCMD_SETVIEWPORT:
{
SDL_Rect *viewport = &rendererData->currentViewport;
if (SDL_memcmp(viewport, &cmd->data.viewport.rect, sizeof(cmd->data.viewport.rect)) != 0) {
SDL_copyp(viewport, &cmd->data.viewport.rect);
rendererData->viewportDirty = true;
rendererData->cliprectDirty = true;
}
break;
}
case SDL_RENDERCMD_SETCLIPRECT:
{
const SDL_Rect *rect = &cmd->data.cliprect.rect;
if (rendererData->currentCliprectEnabled != cmd->data.cliprect.enabled) {
rendererData->currentCliprectEnabled = cmd->data.cliprect.enabled;
rendererData->cliprectDirty = true;
}
if (SDL_memcmp(&rendererData->currentCliprect, rect, sizeof(*rect)) != 0) {
SDL_copyp(&rendererData->currentCliprect, rect);
rendererData->cliprectDirty = true;
}
break;
}
case SDL_RENDERCMD_CLEAR:
{
SDL_FColor color = cmd->data.color.color;
if (SDL_RenderingLinearSpace(renderer)) {
SDL_ConvertToLinear(renderer, &color);
}
color.r *= cmd->data.color.color_scale;
color.g *= cmd->data.color.color_scale;
color.b *= cmd->data.color.color_scale;
if (renderer->current_colorspace == SDL_COLORSPACE_HDR10) {
color.r = SDL_PQfromNits(color.r * SCRGB_NITS);
color.g = SDL_PQfromNits(color.g * SCRGB_NITS);
color.b = SDL_PQfromNits(color.b * SCRGB_NITS);
}
VkClearColorValue clearColor;
clearColor.float32[0] = color.r;
clearColor.float32[1] = color.g;
clearColor.float32[2] = color.b;
clearColor.float32[3] = color.a;
VULKAN_ActivateCommandBuffer(renderer, VK_ATTACHMENT_LOAD_OP_CLEAR, &clearColor, &stateCache);
break;
}
case SDL_RENDERCMD_DRAW_LINES:
{
size_t count = cmd->data.draw.count;
const size_t first = cmd->data.draw.first;
const size_t start = first / sizeof(VULKAN_VertexPositionColor);
const VULKAN_VertexPositionColor *verts = (VULKAN_VertexPositionColor *)(((Uint8 *)vertices) + first);
bool have_point_draw_state = false;
// Add the final point in the line
size_t line_start = 0;
size_t line_end = line_start + count - 1;
if (verts[line_start].pos[0] != verts[line_end].pos[0] || verts[line_start].pos[1] != verts[line_end].pos[1]) {
if (VULKAN_SetDrawState(renderer, cmd, rendererData->pipelineLayout, rendererData->descriptorSetLayout, NULL, VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 0, NULL, 0, NULL, NULL, &stateCache)) {
VULKAN_DrawPrimitives(renderer, VK_PRIMITIVE_TOPOLOGY_POINT_LIST, start + line_end, 1);
have_point_draw_state = true;
}
}
if (count > 2) {
// joined lines cannot be grouped
if (VULKAN_SetDrawState(renderer, cmd, rendererData->pipelineLayout, rendererData->descriptorSetLayout, NULL, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, 0, NULL, 0, NULL, NULL, &stateCache)) {
VULKAN_DrawPrimitives(renderer, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, start, count);
}
} else {
// let's group non joined lines
SDL_RenderCommand *finalcmd = cmd;
SDL_RenderCommand *nextcmd;
float thiscolorscale = cmd->data.draw.color_scale;
SDL_BlendMode thisblend = cmd->data.draw.blend;
for (nextcmd = cmd->next; nextcmd; nextcmd = nextcmd->next) {
const SDL_RenderCommandType nextcmdtype = nextcmd->command;
if (nextcmdtype != SDL_RENDERCMD_DRAW_LINES) {
if (nextcmdtype == SDL_RENDERCMD_SETDRAWCOLOR) {
// The vertex data has the draw color built in, ignore this
continue;
}
break; // can't go any further on this draw call, different render command up next.
} else if (nextcmd->data.draw.count != 2) {
break; // can't go any further on this draw call, those are joined lines
} else if (nextcmd->data.draw.blend != thisblend ||
nextcmd->data.draw.color_scale != thiscolorscale) {
break; // can't go any further on this draw call, different blendmode copy up next.
} else {
finalcmd = nextcmd; // we can combine copy operations here. Mark this one as the furthest okay command.
// Add the final point in the line
line_start = count;
line_end = line_start + nextcmd->data.draw.count - 1;
if (verts[line_start].pos[0] != verts[line_end].pos[0] || verts[line_start].pos[1] != verts[line_end].pos[1]) {
if (!have_point_draw_state) {
have_point_draw_state = VULKAN_SetDrawState(renderer, cmd, rendererData->pipelineLayout, rendererData->descriptorSetLayout, NULL, VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 0, NULL, 0, NULL, NULL, &stateCache);
}
if (have_point_draw_state) {
VULKAN_DrawPrimitives(renderer, VK_PRIMITIVE_TOPOLOGY_POINT_LIST, start + line_end, 1);
}
}
count += nextcmd->data.draw.count;
}
}
if (VULKAN_SetDrawState(renderer, cmd, rendererData->pipelineLayout, rendererData->descriptorSetLayout, NULL, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, 0, NULL, 0, NULL, NULL, &stateCache)) {
VULKAN_DrawPrimitives(renderer, VK_PRIMITIVE_TOPOLOGY_LINE_LIST, start, count);
}
cmd = finalcmd; // skip any copy commands we just combined in here.
}
break;
}
case SDL_RENDERCMD_FILL_RECTS: // unused
break;
case SDL_RENDERCMD_COPY: // unused
break;
case SDL_RENDERCMD_COPY_EX: // unused
break;
case SDL_RENDERCMD_DRAW_POINTS:
case SDL_RENDERCMD_GEOMETRY:
{
/* as long as we have the same copy command in a row, with the
same texture, we can combine them all into a single draw call. */
float thiscolorscale = cmd->data.draw.color_scale;
SDL_Texture *thistexture = cmd->data.draw.texture;
SDL_BlendMode thisblend = cmd->data.draw.blend;
SDL_ScaleMode thisscalemode = cmd->data.draw.texture_scale_mode;
SDL_TextureAddressMode thisaddressmode_u = cmd->data.draw.texture_address_mode_u;
SDL_TextureAddressMode thisaddressmode_v = cmd->data.draw.texture_address_mode_v;
const SDL_RenderCommandType thiscmdtype = cmd->command;
SDL_RenderCommand *finalcmd = cmd;
SDL_RenderCommand *nextcmd;
size_t count = cmd->data.draw.count;
const size_t first = cmd->data.draw.first;
const size_t start = first / sizeof(VULKAN_VertexPositionColor);
for (nextcmd = cmd->next; nextcmd; nextcmd = nextcmd->next) {
const SDL_RenderCommandType nextcmdtype = nextcmd->command;
if (nextcmdtype != thiscmdtype) {
if (nextcmdtype == SDL_RENDERCMD_SETDRAWCOLOR) {
// The vertex data has the draw color built in, ignore this
continue;
}
break; // can't go any further on this draw call, different render command up next.
} else if (nextcmd->data.draw.texture != thistexture ||
nextcmd->data.draw.texture_scale_mode != thisscalemode ||
nextcmd->data.draw.texture_address_mode_u != thisaddressmode_u ||
nextcmd->data.draw.texture_address_mode_v != thisaddressmode_v ||
nextcmd->data.draw.blend != thisblend ||
nextcmd->data.draw.color_scale != thiscolorscale) {
break; // can't go any further on this draw call, different texture/blendmode copy up next.
} else {
finalcmd = nextcmd; // we can combine copy operations here. Mark this one as the furthest okay command.
count += nextcmd->data.draw.count;
}
}
if (thiscmdtype == SDL_RENDERCMD_GEOMETRY) {
bool setState;
if (thistexture) {
setState = VULKAN_SetCopyState(renderer, cmd, NULL, &stateCache);
} else {
setState = VULKAN_SetDrawState(renderer, cmd, rendererData->pipelineLayout, rendererData->descriptorSetLayout, NULL, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, NULL, 0, NULL, NULL, &stateCache);
}
if (setState) {
VULKAN_DrawPrimitives(renderer, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, start, count);
}
} else {
if (VULKAN_SetDrawState(renderer, cmd, rendererData->pipelineLayout, rendererData->descriptorSetLayout, NULL, VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 0, NULL, 0, NULL, NULL, &stateCache)) {
VULKAN_DrawPrimitives(renderer, VK_PRIMITIVE_TOPOLOGY_POINT_LIST, start, count);
}
}
cmd = finalcmd; // skip any copy commands we just combined in here.
break;
}
case SDL_RENDERCMD_NO_OP:
break;
}
cmd = cmd->next;
}
return true;
}
static SDL_Surface *VULKAN_RenderReadPixels(SDL_Renderer *renderer, const SDL_Rect *rect)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VkImage backBuffer;
VkImageLayout *imageLayout;
VULKAN_Buffer readbackBuffer;
VkDeviceSize pixelSize;
VkDeviceSize length;
VkDeviceSize readbackBufferSize;
VkFormat vkFormat;
SDL_Surface *output;
if (!VULKAN_EnsureCommandBuffer(rendererData)) {
return NULL;
}
// Stop any outstanding renderpass if open
if (rendererData->currentRenderPass != VK_NULL_HANDLE) {
vkCmdEndRenderPass(rendererData->currentCommandBuffer);
rendererData->currentRenderPass = VK_NULL_HANDLE;
}
if (rendererData->textureRenderTarget) {
backBuffer = rendererData->textureRenderTarget->images[0].image;
imageLayout = &rendererData->textureRenderTarget->images[0].imageLayout;
vkFormat = rendererData->textureRenderTarget->images[0].format;
} else {
backBuffer = rendererData->swapchainImages[rendererData->currentSwapchainImageIndex];
imageLayout = &rendererData->swapchainImageLayouts[rendererData->currentSwapchainImageIndex];
vkFormat = rendererData->surfaceFormat.format;
}
pixelSize = VULKAN_GetBytesPerPixel(vkFormat, 0);
length = rect->w * pixelSize;
readbackBufferSize = length * rect->h;
if (VULKAN_AllocateBuffer(rendererData, readbackBufferSize,
VK_BUFFER_USAGE_TRANSFER_DST_BIT,
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
&readbackBuffer) != VK_SUCCESS) {
return NULL;
}
// Make sure the source is in the correct resource state
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
VK_ACCESS_TRANSFER_READ_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
backBuffer,
imageLayout);
// Copy the image to the readback buffer
VkBufferImageCopy region;
region.bufferOffset = 0;
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1;
region.imageSubresource.mipLevel = 0;
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageOffset.x = rect->x;
region.imageOffset.y = rect->y;
region.imageOffset.z = 0;
region.imageExtent.width = rect->w;
region.imageExtent.height = rect->h;
region.imageExtent.depth = 1;
vkCmdCopyImageToBuffer(rendererData->currentCommandBuffer, backBuffer, *imageLayout, readbackBuffer.buffer, 1, &region);
// We need to issue the command list for the copy to finish
VULKAN_IssueBatch(rendererData);
// Transition the render target back to a render target
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_TRANSFER_WRITE_BIT,
VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT,
VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
backBuffer,
imageLayout);
output = SDL_DuplicatePixels(
rect->w, rect->h,
VULKAN_VkFormatToSDLPixelFormat(vkFormat),
renderer->current_colorspace,
readbackBuffer.mappedBufferPtr,
(int)length);
VULKAN_DestroyBuffer(rendererData, &readbackBuffer);
return output;
}
static bool VULKAN_AddVulkanRenderSemaphores(SDL_Renderer *renderer, Uint32 wait_stage_mask, Sint64 wait_semaphore, Sint64 signal_semaphore)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
if (wait_semaphore) {
if (rendererData->waitRenderSemaphoreCount == rendererData->waitRenderSemaphoreMax) {
// Allocate an additional one at the end for the normal present wait
VkPipelineStageFlags *waitDestStageMasks = (VkPipelineStageFlags *)SDL_realloc(rendererData->waitDestStageMasks, (rendererData->waitRenderSemaphoreMax + 2) * sizeof(*waitDestStageMasks));
if (!waitDestStageMasks) {
return false;
}
rendererData->waitDestStageMasks = waitDestStageMasks;
VkSemaphore *semaphores = (VkSemaphore *)SDL_realloc(rendererData->waitRenderSemaphores, (rendererData->waitRenderSemaphoreMax + 2) * sizeof(*semaphores));
if (!semaphores) {
return false;
}
rendererData->waitRenderSemaphores = semaphores;
++rendererData->waitRenderSemaphoreMax;
}
rendererData->waitDestStageMasks[rendererData->waitRenderSemaphoreCount] = wait_stage_mask;
rendererData->waitRenderSemaphores[rendererData->waitRenderSemaphoreCount] = (VkSemaphore)wait_semaphore;
++rendererData->waitRenderSemaphoreCount;
}
if (signal_semaphore) {
if (rendererData->signalRenderSemaphoreCount == rendererData->signalRenderSemaphoreMax) {
// Allocate an additional one at the end for the normal present signal
VkSemaphore *semaphores = (VkSemaphore *)SDL_realloc(rendererData->signalRenderSemaphores, (rendererData->signalRenderSemaphoreMax + 2) * sizeof(*semaphores));
if (!semaphores) {
return false;
}
rendererData->signalRenderSemaphores = semaphores;
++rendererData->signalRenderSemaphoreMax;
}
rendererData->signalRenderSemaphores[rendererData->signalRenderSemaphoreCount] = (VkSemaphore)signal_semaphore;
++rendererData->signalRenderSemaphoreCount;
}
return true;
}
static bool VULKAN_RenderPresent(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
VkResult result = VK_SUCCESS;
if (!rendererData->device) {
return SDL_SetError("Device lost and couldn't be recovered");
}
if (rendererData->currentCommandBuffer) {
rendererData->currentPipelineState = VK_NULL_HANDLE;
rendererData->viewportDirty = true;
VULKAN_RecordPipelineImageBarrier(rendererData,
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
rendererData->swapchainImages[rendererData->currentSwapchainImageIndex],
&rendererData->swapchainImageLayouts[rendererData->currentSwapchainImageIndex]);
vkEndCommandBuffer(rendererData->currentCommandBuffer);
result = vkResetFences(rendererData->device, 1, &rendererData->fences[rendererData->currentCommandBufferIndex]);
if (result != VK_SUCCESS) {
SET_ERROR_CODE("vkResetFences()", result);
return false;
}
VkPipelineStageFlags waitDestStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
VkSubmitInfo submitInfo = { 0 };
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
if (rendererData->waitRenderSemaphoreCount > 0) {
Uint32 additionalSemaphoreCount = (rendererData->currentImageAvailableSemaphore != VK_NULL_HANDLE) ? 1 : 0;
submitInfo.waitSemaphoreCount = rendererData->waitRenderSemaphoreCount + additionalSemaphoreCount;
if (additionalSemaphoreCount > 0) {
rendererData->waitRenderSemaphores[rendererData->waitRenderSemaphoreCount] = rendererData->currentImageAvailableSemaphore;
rendererData->waitDestStageMasks[rendererData->waitRenderSemaphoreCount] = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT;
}
submitInfo.pWaitSemaphores = rendererData->waitRenderSemaphores;
submitInfo.pWaitDstStageMask = rendererData->waitDestStageMasks;
rendererData->waitRenderSemaphoreCount = 0;
} else if (rendererData->currentImageAvailableSemaphore != VK_NULL_HANDLE) {
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &rendererData->currentImageAvailableSemaphore;
submitInfo.pWaitDstStageMask = &waitDestStageMask;
}
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &rendererData->currentCommandBuffer;
if (rendererData->signalRenderSemaphoreCount > 0) {
submitInfo.signalSemaphoreCount = rendererData->signalRenderSemaphoreCount + 1;
rendererData->signalRenderSemaphores[rendererData->signalRenderSemaphoreCount] = rendererData->renderingFinishedSemaphores[rendererData->currentCommandBufferIndex];
submitInfo.pSignalSemaphores = rendererData->signalRenderSemaphores;
rendererData->signalRenderSemaphoreCount = 0;
} else {
submitInfo.signalSemaphoreCount = 1;
submitInfo.pSignalSemaphores = &rendererData->renderingFinishedSemaphores[rendererData->currentCommandBufferIndex];
}
result = vkQueueSubmit(rendererData->graphicsQueue, 1, &submitInfo, rendererData->fences[rendererData->currentCommandBufferIndex]);
if (result != VK_SUCCESS) {
if (result == VK_ERROR_DEVICE_LOST) {
if (VULKAN_HandleDeviceLost(renderer)) {
SDL_SetError("Present failed, device lost");
} else {
// Recovering from device lost failed, error is already set
}
} else {
SET_ERROR_CODE("vkQueueSubmit()", result);
}
return false;
}
rendererData->currentCommandBuffer = VK_NULL_HANDLE;
rendererData->currentImageAvailableSemaphore = VK_NULL_HANDLE;
VkPresentInfoKHR presentInfo = { 0 };
presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
presentInfo.waitSemaphoreCount = 1;
presentInfo.pWaitSemaphores = &rendererData->renderingFinishedSemaphores[rendererData->currentCommandBufferIndex];
presentInfo.swapchainCount = 1;
presentInfo.pSwapchains = &rendererData->swapchain;
presentInfo.pImageIndices = &rendererData->currentSwapchainImageIndex;
result = vkQueuePresentKHR(rendererData->presentQueue, &presentInfo);
if ((result != VK_SUCCESS) && (result != VK_ERROR_OUT_OF_DATE_KHR) && (result != VK_ERROR_SURFACE_LOST_KHR) && (result != VK_SUBOPTIMAL_KHR )) {
SET_ERROR_CODE("vkQueuePresentKHR()", result);
return false;
}
rendererData->currentCommandBufferIndex = ( rendererData->currentCommandBufferIndex + 1 ) % rendererData->swapchainImageCount;
// Wait for previous time this command buffer was submitted, will be N frames ago
result = vkWaitForFences(rendererData->device, 1, &rendererData->fences[rendererData->currentCommandBufferIndex], VK_TRUE, UINT64_MAX);
if (result != VK_SUCCESS) {
if (result == VK_ERROR_DEVICE_LOST) {
if (VULKAN_HandleDeviceLost(renderer)) {
SDL_SetError("Present failed, device lost");
} else {
// Recovering from device lost failed, error is already set
}
} else {
SET_ERROR_CODE("vkWaitForFences()", result);
}
return false;
}
VULKAN_AcquireNextSwapchainImage(renderer);
}
return true;
}
static bool VULKAN_SetVSync(SDL_Renderer *renderer, const int vsync)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
switch (vsync) {
case -1:
case 0:
case 1:
// Supported
break;
default:
return SDL_Unsupported();
}
if (vsync != rendererData->vsync) {
rendererData->vsync = vsync;
rendererData->recreateSwapchain = true;
}
return true;
}
static void VULKAN_UpdateHDRMetadata(SDL_Renderer *renderer)
{
VULKAN_RenderData *rendererData = (VULKAN_RenderData *)renderer->internal;
if (renderer->output_colorspace != SDL_COLORSPACE_HDR10 ||
!rendererData->supportsEXTHdrMetadata || !vkSetHdrMetadataEXT ||
rendererData->swapchain == VK_NULL_HANDLE) {
return;
}
// Set BT.2020 primaries with a D65 white point and our max content luminance
float maxLuminance = SDL_GetRendererMaxLuminance(renderer);
if (maxLuminance <= 0.0f) {
return;
}
VkHdrMetadataEXT metadata;
SDL_zero(metadata);
metadata.sType = VK_STRUCTURE_TYPE_HDR_METADATA_EXT;
metadata.displayPrimaryRed.x = 0.708f;
metadata.displayPrimaryRed.y = 0.292f;
metadata.displayPrimaryGreen.x = 0.170f;
metadata.displayPrimaryGreen.y = 0.797f;
metadata.displayPrimaryBlue.x = 0.131f;
metadata.displayPrimaryBlue.y = 0.046f;
metadata.whitePoint.x = 0.3127f;
metadata.whitePoint.y = 0.3290f;
metadata.maxLuminance = maxLuminance;
metadata.minLuminance = 0.0f;
metadata.maxContentLightLevel = maxLuminance;
metadata.maxFrameAverageLightLevel = 0.0f;
vkSetHdrMetadataEXT(rendererData->device, 1, &rendererData->swapchain, &metadata);
}
static bool VULKAN_TextureFormatSupported(VkPhysicalDevice physicalDevice, VkFormat format)
{
VkImageFormatProperties properties;
if (vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format,
VK_IMAGE_TYPE_2D,
VK_IMAGE_TILING_OPTIMAL,
(VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT),
0, &properties) == VK_SUCCESS) {
return true;
}
return false;
}
static bool VULKAN_CreateRenderer(SDL_Renderer *renderer, SDL_Window *window, SDL_PropertiesID create_props)
{
VULKAN_RenderData *rendererData;
// Clear any OpenGL properties on the window to avoid potential driver conflicts.
SDL_WindowFlags flags = SDL_GetWindowFlags(window);
if (flags & SDL_WINDOW_OPENGL) {
flags &= ~SDL_WINDOW_OPENGL;
SDL_ReconfigureWindow(window, flags);
}
SDL_SetupRendererColorspace(renderer, create_props);
if (renderer->output_colorspace != SDL_COLORSPACE_SRGB &&
renderer->output_colorspace != SDL_COLORSPACE_SRGB_LINEAR &&
renderer->output_colorspace != SDL_COLORSPACE_HDR10) {
return SDL_SetError("Unsupported output colorspace");
}
rendererData = (VULKAN_RenderData *)SDL_calloc(1, sizeof(*rendererData));
if (!rendererData) {
return false;
}
rendererData->identity = MatrixIdentity();
rendererData->identitySwizzle.r = VK_COMPONENT_SWIZZLE_IDENTITY;
rendererData->identitySwizzle.g = VK_COMPONENT_SWIZZLE_IDENTITY;
rendererData->identitySwizzle.b = VK_COMPONENT_SWIZZLE_IDENTITY;
rendererData->identitySwizzle.a = VK_COMPONENT_SWIZZLE_IDENTITY;
// Save the create props in case we need to recreate on device lost
rendererData->create_props = SDL_CreateProperties();
if (!SDL_CopyProperties(create_props, rendererData->create_props)) {
SDL_free(rendererData);
return false;
}
renderer->WindowEvent = VULKAN_WindowEvent;
renderer->SupportsBlendMode = VULKAN_SupportsBlendMode;
renderer->CreatePalette = VULKAN_CreatePalette;
renderer->UpdatePalette = VULKAN_UpdatePalette;
renderer->DestroyPalette = VULKAN_DestroyPalette;
renderer->CreateTexture = VULKAN_CreateTexture;
renderer->UpdateTexture = VULKAN_UpdateTexture;
renderer->UpdateTextureYUV = VULKAN_UpdateTextureYUV;
renderer->UpdateTextureNV = VULKAN_UpdateTextureNV;
renderer->LockTexture = VULKAN_LockTexture;
renderer->UnlockTexture = VULKAN_UnlockTexture;
renderer->SetRenderTarget = VULKAN_SetRenderTarget;
renderer->QueueSetViewport = VULKAN_QueueNoOp;
renderer->QueueSetDrawColor = VULKAN_QueueNoOp;
renderer->QueueDrawPoints = VULKAN_QueueDrawPoints;
renderer->QueueDrawLines = VULKAN_QueueDrawPoints; // lines and points queue vertices the same way.
renderer->QueueGeometry = VULKAN_QueueGeometry;
renderer->InvalidateCachedState = VULKAN_InvalidateCachedState;
renderer->RunCommandQueue = VULKAN_RunCommandQueue;
renderer->RenderReadPixels = VULKAN_RenderReadPixels;
renderer->AddVulkanRenderSemaphores = VULKAN_AddVulkanRenderSemaphores;
renderer->RenderPresent = VULKAN_RenderPresent;
renderer->DestroyTexture = VULKAN_DestroyTexture;
renderer->DestroyRenderer = VULKAN_DestroyRenderer;
renderer->SetVSync = VULKAN_SetVSync;
renderer->UpdateHDRMetadata = VULKAN_UpdateHDRMetadata;
renderer->internal = rendererData;
VULKAN_InvalidateCachedState(renderer);
renderer->name = VULKAN_RenderDriver.name;
SDL_SetNumberProperty(SDL_GetRendererProperties(renderer), SDL_PROP_RENDERER_MAX_TEXTURE_SIZE_NUMBER, 16384);
/* HACK: make sure the SDL_Renderer references the SDL_Window data now, in
* order to give init functions access to the underlying window handle:
*/
renderer->window = window;
// Initialize Vulkan resources
if (VULKAN_CreateDeviceResources(renderer, create_props) != VK_SUCCESS) {
return false;
}
if (VULKAN_CreateWindowSizeDependentResources(renderer) != VK_SUCCESS) {
return false;
}
for (int i = 0; i < SDL_arraysize(vk_format_map); i++) {
if (!VULKAN_TextureFormatSupported(rendererData->physicalDevice, vk_format_map[i].unorm)) {
continue;
}
if (!VULKAN_TextureFormatSupported(rendererData->physicalDevice, vk_format_map[i].srgb)) {
continue;
}
SDL_AddSupportedTextureFormat(renderer, vk_format_map[i].sdl);
}
if (VULKAN_TextureFormatSupported(rendererData->physicalDevice,
VULKAN_GetVkImageFormat(SDL_PIXELFORMAT_INDEX8, renderer->output_colorspace)) &&
VULKAN_TextureFormatSupported(rendererData->physicalDevice,
VULKAN_GetVkImageFormat(SDL_PIXELFORMAT_RGBA32, renderer->output_colorspace))) {
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_INDEX8);
}
static const SDL_PixelFormat yuvFormats[] = {
SDL_PIXELFORMAT_YV12,
SDL_PIXELFORMAT_IYUV,
SDL_PIXELFORMAT_I444,
SDL_PIXELFORMAT_NV12,
SDL_PIXELFORMAT_NV21,
SDL_PIXELFORMAT_P010,
SDL_PIXELFORMAT_I0FL,
SDL_PIXELFORMAT_I4FL
};
for (int i = 0; i < SDL_arraysize(yuvFormats); ++i) {
VkFormat format = VULKAN_GetVkImageFormat(yuvFormats[i], renderer->output_colorspace);
if (VULKAN_TextureFormatSupported(rendererData->physicalDevice, format)) {
SDL_AddSupportedTextureFormat(renderer, yuvFormats[i]);
}
}
if (rendererData->supportsANDROIDExternalMemoryAndroidHardwareBuffer) {
SDL_AddSupportedTextureFormat(renderer, SDL_PIXELFORMAT_EXTERNAL_OES);
}
return true;
}
SDL_RenderDriver VULKAN_RenderDriver = {
VULKAN_CreateRenderer, "vulkan"
};
#endif // SDL_VIDEO_RENDER_VULKAN