{

switch (errorCode)

{

#define STR(r) case VK_ ##r: return #r

STR(NOT_READY);

STR(TIMEOUT);

STR(EVENT_SET);

STR(EVENT_RESET);

STR(INCOMPLETE);

STR(ERROR_OUT_OF_HOST_MEMORY);

STR(ERROR_OUT_OF_DEVICE_MEMORY);

STR(ERROR_INITIALIZATION_FAILED);

STR(ERROR_DEVICE_LOST);

STR(ERROR_MEMORY_MAP_FAILED);

STR(ERROR_LAYER_NOT_PRESENT);

STR(ERROR_EXTENSION_NOT_PRESENT);

STR(ERROR_FEATURE_NOT_PRESENT);

STR(ERROR_INCOMPATIBLE_DRIVER);

STR(ERROR_TOO_MANY_OBJECTS);

STR(ERROR_FORMAT_NOT_SUPPORTED);

STR(ERROR_SURFACE_LOST_KHR);

STR(ERROR_NATIVE_WINDOW_IN_USE_KHR);

STR(SUBOPTIMAL_KHR);

STR(ERROR_OUT_OF_DATE_KHR);

STR(ERROR_INCOMPATIBLE_DISPLAY_KHR);

STR(ERROR_VALIDATION_FAILED_EXT);

STR(ERROR_INVALID_SHADER_NV);

#undef STR

default:

return "UNKNOWN_ERROR";

}

{

switch (type)

{

#define STR(r) case VK_PHYSICAL_DEVICE_TYPE_ ##r: return #r

STR(OTHER);

STR(INTEGRATED_GPU);

STR(DISCRETE_GPU);

STR(VIRTUAL_GPU);

#undef STR

default: return "UNKNOWN_DEVICE_TYPE";

}

{

// Since all depth formats may be optional, we need to find a suitable depth format to use

// Start with the highest precision packed format

std::vector<VkFormat> depthFormats = {

VK_FORMAT_D32_SFLOAT_S8_UINT,

VK_FORMAT_D32_SFLOAT,

VK_FORMAT_D24_UNORM_S8_UINT,

VK_FORMAT_D16_UNORM_S8_UINT,

VK_FORMAT_D16_UNORM

};

for (auto& format : depthFormats)

{

VkFormatProperties formatProps;

vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &formatProps);

// Format must support depth stencil attachment for optimal tiling

if (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)

{

*depthFormat = format;

return true;

}

}

return false;

VkCommandBuffer cmdbuffer,

VkImage image,

VkImageLayout oldImageLayout,

VkImageLayout newImageLayout,

VkImageSubresourceRange subresourceRange,

VkPipelineStageFlags srcStageMask,

VkPipelineStageFlags dstStageMask)

{

// Create an image barrier object

VkImageMemoryBarrier imageMemoryBarrier = vks::initializers::imageMemoryBarrier();

imageMemoryBarrier.oldLayout = oldImageLayout;

imageMemoryBarrier.newLayout = newImageLayout;

imageMemoryBarrier.image = image;

imageMemoryBarrier.subresourceRange = subresourceRange;

// Source layouts (old)

// Source access mask controls actions that have to be finished on the old layout

// before it will be transitioned to the new layout

switch (oldImageLayout)

{

case VK_IMAGE_LAYOUT_UNDEFINED:

// Image layout is undefined (or does not matter)

// Only valid as initial layout

// No flags required, listed only for completeness

imageMemoryBarrier.srcAccessMask = 0;

break;

case VK_IMAGE_LAYOUT_PREINITIALIZED:

// Image is preinitialized

// Only valid as initial layout for linear images, preserves memory contents

// Make sure host writes have been finished

imageMemoryBarrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;

break;

case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:

// Image is a color attachment

// Make sure any writes to the color buffer have been finished

imageMemoryBarrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;

break;

case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:

// Image is a depth/stencil attachment

// Make sure any writes to the depth/stencil buffer have been finished

imageMemoryBarrier.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;

break;

case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:

// Image is a transfer source

// Make sure any reads from the image have been finished

imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;

break;

case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:

// Image is a transfer destination

// Make sure any writes to the image have been finished

imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;

break;

case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:

// Image is read by a shader

// Make sure any shader reads from the image have been finished

imageMemoryBarrier.srcAccessMask = VK_ACCESS_SHADER_READ_BIT;

break;

default:

// Other source layouts aren't handled (yet)

break;

}

// Target layouts (new)

// Destination access mask controls the dependency for the new image layout

switch (newImageLayout)

{

case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:

// Image will be used as a transfer destination

// Make sure any writes to the image have been finished

imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;

break;

case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:

// Image will be used as a transfer source

// Make sure any reads from the image have been finished

imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;

break;

case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL:

// Image will be used as a color attachment

// Make sure any writes to the color buffer have been finished

imageMemoryBarrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;

break;

case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL:

// Image layout will be used as a depth/stencil attachment

// Make sure any writes to depth/stencil buffer have been finished

imageMemoryBarrier.dstAccessMask = imageMemoryBarrier.dstAccessMask | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;

break;

case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:

// Image will be read in a shader (sampler, input attachment)

// Make sure any writes to the image have been finished

if (imageMemoryBarrier.srcAccessMask == 0)

{

imageMemoryBarrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;

}

imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;

break;

default:

// Other source layouts aren't handled (yet)

break;

}

// Put barrier inside setup command buffer

vkCmdPipelineBarrier(

cmdbuffer,

srcStageMask,

dstStageMask,

0,

0, nullptr,

0, nullptr,

1, &imageMemoryBarrier);

VkCommandBuffer cmdbuffer,

VkImage image,

VkImageAspectFlags aspectMask,

VkImageLayout oldImageLayout,

VkImageLayout newImageLayout,

VkPipelineStageFlags srcStageMask,

VkPipelineStageFlags dstStageMask)

{

VkImageSubresourceRange subresourceRange = {};

subresourceRange.aspectMask = aspectMask;

subresourceRange.baseMipLevel = 0;

subresourceRange.levelCount = 1;

subresourceRange.layerCount = 1;

setImageLayout(cmdbuffer, image, oldImageLayout, newImageLayout, subresourceRange, srcStageMask, dstStageMask);

VkCommandBuffer cmdbuffer,

VkImage image,

VkAccessFlags srcAccessMask,

VkAccessFlags dstAccessMask,

VkImageLayout oldImageLayout,

VkImageLayout newImageLayout,

VkPipelineStageFlags srcStageMask,

VkPipelineStageFlags dstStageMask,

VkImageSubresourceRange subresourceRange)

{

VkImageMemoryBarrier imageMemoryBarrier = vks::initializers::imageMemoryBarrier();

imageMemoryBarrier.srcAccessMask = srcAccessMask;

imageMemoryBarrier.dstAccessMask = dstAccessMask;

imageMemoryBarrier.oldLayout = oldImageLayout;

imageMemoryBarrier.newLayout = newImageLayout;

imageMemoryBarrier.image = image;

imageMemoryBarrier.subresourceRange = subresourceRange;

vkCmdPipelineBarrier(

cmdbuffer,

srcStageMask,

dstStageMask,

0,

0, nullptr,

0, nullptr,

1, &imageMemoryBarrier);

{

#if defined(_WIN32)

MessageBox(NULL, message.c_str(), caption.c_str(), MB_OK | MB_ICONERROR);

#elif defined(__ANDROID__)

LOGE("Fatal error: %s", message.c_str());

#else

std::cerr << message << "\n";

#endif

exit(1);

{

std::string fileContent;

std::ifstream fileStream(fileName, std::ios::in);

if (!fileStream.is_open()) {

printf("File %s not found\n", fileName);

return "";

}

std::string line = "";

while (!fileStream.eof()) {

getline(fileStream, line);

fileContent.append(line + "\n");

}

fileStream.close();

return fileContent;

{

// Load shader from compressed asset

AAsset* asset = AAssetManager_open(assetManager, fileName, AASSET_MODE_STREAMING);

assert(asset);

size_t size = AAsset_getLength(asset);

assert(size > 0);

char *shaderCode = new char[size];

AAsset_read(asset, shaderCode, size);

AAsset_close(asset);

VkShaderModule shaderModule;

VkShaderModuleCreateInfo moduleCreateInfo;

moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;

moduleCreateInfo.pNext = NULL;

moduleCreateInfo.codeSize = size;

moduleCreateInfo.pCode = (uint32_t*)shaderCode;

moduleCreateInfo.flags = 0;

VK_CHECK_RESULT(vkCreateShaderModule(device, &moduleCreateInfo, NULL, &shaderModule));

delete[] shaderCode;

return shaderModule;

{

std::ifstream is(fileName, std::ios::binary | std::ios::in | std::ios::ate);

if (is.is_open())

{

size_t size = is.tellg();

is.seekg(0, std::ios::beg);

char* shaderCode = new char[size];

is.read(shaderCode, size);

is.close();

assert(size > 0);

VkShaderModule shaderModule;

VkShaderModuleCreateInfo moduleCreateInfo{};

moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;

moduleCreateInfo.codeSize = size;

moduleCreateInfo.pCode = (uint32_t*)shaderCode;

VK_CHECK_RESULT(vkCreateShaderModule(device, &moduleCreateInfo, NULL, &shaderModule));

delete[] shaderCode;

return shaderModule;

}

else

{

std::cerr << "Error: Could not open shader file \"" << fileName << "\"" << std::endl;

return VK_NULL_HANDLE;

}

{

std::string shaderSrc = readTextFile(fileName);

const char *shaderCode = shaderSrc.c_str();

size_t size = strlen(shaderCode);

assert(size > 0);

VkShaderModule shaderModule;

VkShaderModuleCreateInfo moduleCreateInfo;

moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;

moduleCreateInfo.pNext = NULL;

moduleCreateInfo.codeSize = 3 * sizeof(uint32_t) + size + 1;

moduleCreateInfo.pCode = (uint32_t*)malloc(moduleCreateInfo.codeSize);

moduleCreateInfo.flags = 0;

// Magic SPV number

((uint32_t *)moduleCreateInfo.pCode)[0] = 0x07230203;

((uint32_t *)moduleCreateInfo.pCode)[1] = 0;

((uint32_t *)moduleCreateInfo.pCode)[2] = stage;

memcpy(((uint32_t *)moduleCreateInfo.pCode + 3), shaderCode, size + 1);

VK_CHECK_RESULT(vkCreateShaderModule(device, &moduleCreateInfo, NULL, &shaderModule));

return shaderModule;

{

std::ifstream f(filename.c_str());

return !f.fail();