/******************************************************************************

* The MIT License (MIT)

*

* Copyright (c) 2015-2017 Baldur Karlsson

*

* Permission is hereby granted, free of charge, to any person obtaining a copy

* of this software and associated documentation files (the "Software"), to deal

* in the Software without restriction, including without limitation the rights

* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

* copies of the Software, and to permit persons to whom the Software is

* furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

* THE SOFTWARE.

******************************************************************************/

#include "vk_debug.h"

#include <float.h>

#include "3rdparty/glslang/SPIRV/spirv.hpp"

#include "3rdparty/stb/stb_truetype.h"

#include "common/shader_cache.h"

#include "data/glsl_shaders.h"

#include "driver/shaders/spirv/spirv_common.h"

#include "maths/camera.h"

#include "maths/formatpacking.h"

#include "maths/matrix.h"

#include "serialise/string_utils.h"

#include "vk_core.h"

#define VULKAN 1

#include "data/glsl/debuguniforms.h"

const VkDeviceSize STAGE_BUFFER_BYTE_SIZE = 16 * 1024 * 1024ULL;

void VulkanDebugManager::GPUBuffer::Create(WrappedVulkan *driver, VkDevice dev, VkDeviceSize size,

uint32_t ringSize, uint32_t flags)

{

m_pDriver = driver;

device = dev;

align = (VkDeviceSize)driver->GetDeviceProps().limits.minUniformBufferOffsetAlignment;

sz = size;

// offset must be aligned, so ensure we have at least ringSize

// copies accounting for that

totalsize = ringSize == 1 ? size : AlignUp(size, align) * ringSize;

curoffset = 0;

ringCount = ringSize;

VkBufferCreateInfo bufInfo = {

VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, NULL, 0, totalsize, 0,

};

bufInfo.usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;

bufInfo.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;

bufInfo.usage |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;

if(flags & eGPUBufferVBuffer)

bufInfo.usage |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;

if(flags & eGPUBufferSSBO)

bufInfo.usage |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;

VkResult vkr = driver->vkCreateBuffer(dev, &bufInfo, NULL, &buf);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

VkMemoryRequirements mrq = {};

driver->vkGetBufferMemoryRequirements(dev, buf, &mrq);

VkMemoryAllocateInfo allocInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, NULL, mrq.size, 0};

if(flags & eGPUBufferReadback)

allocInfo.memoryTypeIndex = driver->GetReadbackMemoryIndex(mrq.memoryTypeBits);

else if(flags & eGPUBufferGPULocal)

allocInfo.memoryTypeIndex = driver->GetGPULocalMemoryIndex(mrq.memoryTypeBits);

else

allocInfo.memoryTypeIndex = driver->GetUploadMemoryIndex(mrq.memoryTypeBits);

vkr = driver->vkAllocateMemory(dev, &allocInfo, NULL, &mem);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

vkr = driver->vkBindBufferMemory(dev, buf, mem, 0);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

}

void VulkanDebugManager::GPUBuffer::FillDescriptor(VkDescriptorBufferInfo &desc)

{

desc.buffer = Unwrap(buf);

desc.offset = 0;

desc.range = sz;

}

void VulkanDebugManager::GPUBuffer::Destroy()

{

m_pDriver->vkDestroyBuffer(device, buf, NULL);

m_pDriver->vkFreeMemory(device, mem, NULL);

}

void *VulkanDebugManager::GPUBuffer::Map(uint32_t *bindoffset, VkDeviceSize usedsize)

{

VkDeviceSize offset = bindoffset ? curoffset : 0;

VkDeviceSize size = usedsize > 0 ? usedsize : sz;

// wrap around the ring, assuming the ring is large enough

// that this memory is now free

if(offset + sz > totalsize)

offset = 0;

RDCASSERT(offset + sz <= totalsize);

// offset must be aligned

curoffset = AlignUp(offset + size, align);

if(bindoffset)

*bindoffset = (uint32_t)offset;

void *ptr = NULL;

VkResult vkr = m_pDriver->vkMapMemory(device, mem, offset, size, 0, (void **)&ptr);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

return ptr;

}

void *VulkanDebugManager::GPUBuffer::Map(VkDeviceSize &bindoffset, VkDeviceSize usedsize)

{

uint32_t offs = 0;

void *ret = Map(&offs, usedsize);

bindoffset = offs;

return ret;

}

void VulkanDebugManager::GPUBuffer::Unmap()

{

m_pDriver->vkUnmapMemory(device, mem);

}

struct VulkanBlobShaderCallbacks

{

bool Create(uint32_t size, byte *data, vector<uint32_t> **ret) const

{

RDCASSERT(ret);

vector<uint32_t> *blob = new vector<uint32_t>();

blob->resize(size / sizeof(uint32_t));

memcpy(&(*blob)[0], data, size);

*ret = blob;

return true;

}

void Destroy(vector<uint32_t> *blob) const { delete blob; }

uint32_t GetSize(vector<uint32_t> *blob) const

{

return (uint32_t)(blob->size() * sizeof(uint32_t));

}

byte *GetData(vector<uint32_t> *blob) const { return (byte *)&(*blob)[0]; }

} ShaderCacheCallbacks;

string VulkanDebugManager::GetSPIRVBlob(SPIRVShaderStage shadType,

const std::vector<std::string> &sources,

vector<uint32_t> **outBlob)

{

RDCASSERT(sources.size() > 0);

uint32_t hash = strhash(sources[0].c_str());

for(size_t i = 1; i < sources.size(); i++)

hash = strhash(sources[i].c_str(), hash);

char typestr[2] = {'a', 0};

typestr[0] += (char)shadType;

hash = strhash(typestr, hash);

if(m_ShaderCache.find(hash) != m_ShaderCache.end())

{

*outBlob = m_ShaderCache[hash];

return "";

}

vector<uint32_t> *spirv = new vector<uint32_t>();

string errors = CompileSPIRV(shadType, sources, *spirv);

if(!errors.empty())

{

string logerror = errors;

if(logerror.length() > 1024)

logerror = logerror.substr(0, 1024) + "...";

RDCWARN("Shader compile error:\n%s", logerror.c_str());

delete spirv;

*outBlob = NULL;

return errors;

}

*outBlob = spirv;

if(m_CacheShaders)

{

m_ShaderCache[hash] = spirv;

m_ShaderCacheDirty = true;

}

return errors;

}

VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver, VkDevice dev)

{

m_pDriver = driver;

m_State = m_pDriver->GetState();

driver->GetReplay()->PostDeviceInitCounters();

m_ResourceManager = m_pDriver->GetResourceManager();

//////////////////////////////////////////////////////////////////////////////////////////////////

// Zero initialise all of the members so that when deleting we can just destroy everything and let

// objects that weren't created just silently be skipped

m_DescriptorPool = VK_NULL_HANDLE;

m_LinearSampler = VK_NULL_HANDLE;

m_PointSampler = VK_NULL_HANDLE;

m_CheckerboardDescSetLayout = VK_NULL_HANDLE;

m_CheckerboardPipeLayout = VK_NULL_HANDLE;

m_CheckerboardDescSet = VK_NULL_HANDLE;

m_CheckerboardPipeline = VK_NULL_HANDLE;

m_CheckerboardMSAAPipeline = VK_NULL_HANDLE;

RDCEraseEl(m_CheckerboardUBO);

m_TexDisplayDescSetLayout = VK_NULL_HANDLE;

m_TexDisplayPipeLayout = VK_NULL_HANDLE;

RDCEraseEl(m_TexDisplayDescSet);

m_TexDisplayNextSet = 0;

m_TexDisplayPipeline = VK_NULL_HANDLE;

m_TexDisplayBlendPipeline = VK_NULL_HANDLE;

m_TexDisplayF32Pipeline = VK_NULL_HANDLE;

RDCEraseEl(m_TexDisplayUBO);

RDCEraseEl(m_TexDisplayDummyImages);

RDCEraseEl(m_TexDisplayDummyImageViews);

RDCEraseEl(m_TexDisplayDummyWrites);

RDCEraseEl(m_TexDisplayDummyInfos);

m_TexDisplayDummyMemory = VK_NULL_HANDLE;

m_CustomTexWidth = m_CustomTexHeight = 0;

m_CustomTexImg = VK_NULL_HANDLE;

RDCEraseEl(m_CustomTexImgView);

m_CustomTexMemSize = 0;

m_CustomTexMem = VK_NULL_HANDLE;

m_CustomTexFB = VK_NULL_HANDLE;

m_CustomTexRP = VK_NULL_HANDLE;

m_CustomTexPipeline = VK_NULL_HANDLE;

m_PickPixelImageMem = VK_NULL_HANDLE;

m_PickPixelImage = VK_NULL_HANDLE;

m_PickPixelImageView = VK_NULL_HANDLE;

m_PickPixelFB = VK_NULL_HANDLE;

m_PickPixelRP = VK_NULL_HANDLE;

m_ArrayMSDescSetLayout = VK_NULL_HANDLE;

m_ArrayMSPipeLayout = VK_NULL_HANDLE;

m_ArrayMSDescSet = VK_NULL_HANDLE;

m_Array2MSPipe = VK_NULL_HANDLE;

m_MS2ArrayPipe = VK_NULL_HANDLE;

m_TextDescSetLayout = VK_NULL_HANDLE;

m_TextPipeLayout = VK_NULL_HANDLE;

m_TextDescSet = VK_NULL_HANDLE;

RDCEraseEl(m_TextPipeline);

RDCEraseEl(m_TextGeneralUBO);

RDCEraseEl(m_TextGlyphUBO);

RDCEraseEl(m_TextStringUBO);

m_TextAtlas = VK_NULL_HANDLE;

m_TextAtlasMem = VK_NULL_HANDLE;

m_TextAtlasView = VK_NULL_HANDLE;

m_OverlayImageMem = VK_NULL_HANDLE;

m_OverlayImage = VK_NULL_HANDLE;

m_OverlayImageView = VK_NULL_HANDLE;

m_OverlayNoDepthFB = VK_NULL_HANDLE;

m_OverlayNoDepthRP = VK_NULL_HANDLE;

RDCEraseEl(m_OverlayDim);

m_OverlayMemSize = 0;

m_QuadDescSetLayout = VK_NULL_HANDLE;

m_QuadResolvePipeLayout = VK_NULL_HANDLE;

m_QuadDescSet = VK_NULL_HANDLE;

RDCEraseEl(m_QuadResolvePipeline);

m_QuadSPIRV = NULL;

m_TriSizeDescSetLayout = VK_NULL_HANDLE;

m_TriSizeDescSet = VK_NULL_HANDLE;

m_TriSizePipeLayout = VK_NULL_HANDLE;

m_TriSizeGSModule = VK_NULL_HANDLE;

m_TriSizeFSModule = VK_NULL_HANDLE;

m_MeshDescSetLayout = VK_NULL_HANDLE;

m_MeshPipeLayout = VK_NULL_HANDLE;

m_MeshDescSet = VK_NULL_HANDLE;

RDCEraseEl(m_MeshModules);

m_HistogramDescSetLayout = VK_NULL_HANDLE;

m_HistogramPipeLayout = VK_NULL_HANDLE;

RDCEraseEl(m_HistogramDescSet);

RDCEraseEl(m_MinMaxResultPipe);

RDCEraseEl(m_MinMaxTilePipe);

RDCEraseEl(m_HistogramPipe);

m_OutlineDescSetLayout = VK_NULL_HANDLE;

m_OutlinePipeLayout = VK_NULL_HANDLE;

m_OutlineDescSet = VK_NULL_HANDLE;

RDCEraseEl(m_OutlinePipeline);

m_MeshFetchDescSetLayout = VK_NULL_HANDLE;

m_MeshFetchDescSet = VK_NULL_HANDLE;

m_MeshPickDescSetLayout = VK_NULL_HANDLE;

m_MeshPickDescSet = VK_NULL_HANDLE;

m_MeshPickLayout = VK_NULL_HANDLE;

m_MeshPickPipeline = VK_NULL_HANDLE;

m_FontCharSize = 1.0f;

m_FontCharAspect = 1.0f;

m_FixedColSPIRV = NULL;

m_Device = dev;

//////////////////////////////////////////////////////////////////////////////////////////////////

// Do some work that's needed both during capture and during replay

// Load shader cache, if present

bool success = LoadShaderCache("vkshaders.cache", m_ShaderCacheMagic, m_ShaderCacheVersion,

m_ShaderCache, ShaderCacheCallbacks);

// if we failed to load from the cache

m_ShaderCacheDirty = !success;

VkResult vkr = VK_SUCCESS;

// create linear sampler

VkSamplerCreateInfo sampInfo = {

VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,

NULL,

0,

VK_FILTER_LINEAR,

VK_FILTER_LINEAR,

VK_SAMPLER_MIPMAP_MODE_NEAREST,

VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,

VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,

VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,

0.0f, // lod bias

false, // enable aniso

1.0f, // max aniso

false,

VK_COMPARE_OP_NEVER,

0.0f,

128.0f, // min/max lod

VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE,

false, // unnormalized

};

vkr = m_pDriver->vkCreateSampler(dev, &sampInfo, NULL, &m_LinearSampler);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

VkDescriptorPoolSize captureDescPoolTypes[] = {

{

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1,

},

{

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 3,

},

{

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 3,

},

{

VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1,

},

};

VkDescriptorPoolSize replayDescPoolTypes[] = {

{

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 128,

},

{

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 128,

},

{

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 320,

},

{

VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 32,

},

{

VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 32,

},

};

VkDescriptorPoolCreateInfo descpoolInfo = {

VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,

NULL,

0,

10 + ARRAY_COUNT(m_TexDisplayDescSet),

ARRAY_COUNT(replayDescPoolTypes),

&replayDescPoolTypes[0],

};

// during capture we only need one text descriptor set, so rather than

// trying to wait and steal descriptors from a user-side pool, we just

// create our own very small pool.

if(m_State >= WRITING)

{

descpoolInfo.maxSets = 2;

descpoolInfo.poolSizeCount = ARRAY_COUNT(captureDescPoolTypes);

descpoolInfo.pPoolSizes = &captureDescPoolTypes[0];

}

// create descriptor pool

vkr = m_pDriver->vkCreateDescriptorPool(dev, &descpoolInfo, NULL, &m_DescriptorPool);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

// declare some common creation info structs

VkPipelineLayoutCreateInfo pipeLayoutInfo = {

VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,

NULL,

0,

1,

NULL,

0,

NULL, // push constant ranges

};

VkDescriptorSetAllocateInfo descSetAllocInfo = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,

NULL, m_DescriptorPool, 1, NULL};

// compatible render passes for creating pipelines.

// Only one of these is needed during capture for the pipeline create, but

// they are short-lived so just create all of them and share creation code

VkRenderPass RGBA32RP = VK_NULL_HANDLE;

VkRenderPass RGBA8sRGBRP = VK_NULL_HANDLE;

VkRenderPass RGBA16RP = VK_NULL_HANDLE;

VkRenderPass RGBA8MSRP = VK_NULL_HANDLE;

VkRenderPass RGBA16MSRP[8] = {0};

VkRenderPass RGBA8LinearRP = VK_NULL_HANDLE;

VkRenderPass BGRA8sRGBRP = VK_NULL_HANDLE;

VkRenderPass BGRA8LinearRP = VK_NULL_HANDLE;

RDCCOMPILE_ASSERT(ARRAY_COUNT(RGBA16MSRP) == ARRAY_COUNT(m_OutlinePipeline),

"Arrays are mismatched in size!");

RDCCOMPILE_ASSERT(ARRAY_COUNT(RGBA16MSRP) == ARRAY_COUNT(m_QuadResolvePipeline),

"Arrays are mismatched in size!");

{

VkAttachmentDescription attDesc = {0,

VK_FORMAT_R8G8B8A8_SRGB,

VK_SAMPLE_COUNT_1_BIT,

VK_ATTACHMENT_LOAD_OP_LOAD,

VK_ATTACHMENT_STORE_OP_STORE,

VK_ATTACHMENT_LOAD_OP_DONT_CARE,

VK_ATTACHMENT_STORE_OP_DONT_CARE,

VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,

VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};

VkAttachmentReference attRef = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};

VkSubpassDescription sub = {

0, VK_PIPELINE_BIND_POINT_GRAPHICS,

0, NULL, // inputs

1, &attRef, // color

NULL, // resolve

NULL, // depth-stencil

0, NULL, // preserve

};

VkRenderPassCreateInfo rpinfo = {

VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,

NULL,

0,

1,

&attDesc,

1,

&sub,

0,

NULL, // dependencies

};

m_pDriver->vkCreateRenderPass(dev, &rpinfo, NULL, &RGBA8sRGBRP);

attDesc.format = VK_FORMAT_R8G8B8A8_UNORM;

m_pDriver->vkCreateRenderPass(dev, &rpinfo, NULL, &RGBA8LinearRP);

attDesc.format = VK_FORMAT_B8G8R8A8_SRGB;

m_pDriver->vkCreateRenderPass(dev, &rpinfo, NULL, &BGRA8sRGBRP);

attDesc.format = VK_FORMAT_B8G8R8A8_UNORM;

m_pDriver->vkCreateRenderPass(dev, &rpinfo, NULL, &BGRA8LinearRP);

attDesc.format = VK_FORMAT_R32G32B32A32_SFLOAT;

m_pDriver->vkCreateRenderPass(dev, &rpinfo, NULL, &RGBA32RP);

attDesc.format = VK_FORMAT_R16G16B16A16_SFLOAT;

m_pDriver->vkCreateRenderPass(dev, &rpinfo, NULL, &RGBA16RP);

attDesc.samples = VULKAN_MESH_VIEW_SAMPLES;

attDesc.format = VK_FORMAT_R8G8B8A8_SRGB;

m_pDriver->vkCreateRenderPass(dev, &rpinfo, NULL, &RGBA8MSRP);

attDesc.format = VK_FORMAT_R16G16B16A16_SFLOAT;

uint32_t samplesHandled = 0;

// create a 16F multisampled renderpass for each possible multisample size

for(size_t i = 0; i < ARRAY_COUNT(RGBA16MSRP); i++)

{

attDesc.samples = VkSampleCountFlagBits(1 << i);

if(m_pDriver->GetDeviceProps().limits.framebufferColorSampleCounts & (uint32_t)attDesc.samples)

{

m_pDriver->vkCreateRenderPass(dev, &rpinfo, NULL, &RGBA16MSRP[i]);

samplesHandled |= (uint32_t)attDesc.samples;

}

}

RDCASSERTEQUAL((uint32_t)m_pDriver->GetDeviceProps().limits.framebufferColorSampleCounts,

samplesHandled);

}

// declare the pipeline creation info and all of its sub-structures

// these are modified as appropriate for each pipeline we create

VkPipelineShaderStageCreateInfo stages[2] = {

{VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0, VK_SHADER_STAGE_VERTEX_BIT,

VK_NULL_HANDLE, "main", NULL},

{VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0, VK_SHADER_STAGE_FRAGMENT_BIT,

VK_NULL_HANDLE, "main", NULL},

};

VkPipelineVertexInputStateCreateInfo vi = {

VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,

NULL,

0,

0,

NULL, // vertex bindings

0,

NULL, // vertex attributes

};

VkPipelineInputAssemblyStateCreateInfo ia = {

VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,

NULL,

0,

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,

false,

};

VkRect2D scissor = {{0, 0}, {16384, 16384}};

VkPipelineViewportStateCreateInfo vp = {

VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, NULL, 0, 1, NULL, 1, &scissor};

VkPipelineRasterizationStateCreateInfo rs = {

VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,

NULL,

0,

true,

false,

VK_POLYGON_MODE_FILL,

VK_CULL_MODE_NONE,

VK_FRONT_FACE_CLOCKWISE,

false,

0.0f,

0.0f,

0.0f,

1.0f,

};

VkPipelineMultisampleStateCreateInfo msaa = {

VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,

NULL,

0,

VK_SAMPLE_COUNT_1_BIT,

false,

0.0f,

NULL,

false,

false,

};

VkPipelineDepthStencilStateCreateInfo ds = {

VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,

NULL,

0,

false,

false,

VK_COMPARE_OP_ALWAYS,

false,

false,

{VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_ALWAYS, 0, 0, 0},

{VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_STENCIL_OP_KEEP, VK_COMPARE_OP_ALWAYS, 0, 0, 0},

0.0f,

1.0f,

};

VkPipelineColorBlendAttachmentState attState = {

false,

VK_BLEND_FACTOR_ONE,

VK_BLEND_FACTOR_ZERO,

VK_BLEND_OP_ADD,

VK_BLEND_FACTOR_ONE,

VK_BLEND_FACTOR_ZERO,

VK_BLEND_OP_ADD,

0xf,

};

VkPipelineColorBlendStateCreateInfo cb = {

VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,

NULL,

0,

false,

VK_LOGIC_OP_NO_OP,

1,

&attState,

{1.0f, 1.0f, 1.0f, 1.0f}};

VkDynamicState dynstates[] = {VK_DYNAMIC_STATE_VIEWPORT};

VkPipelineDynamicStateCreateInfo dyn = {

VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,

NULL,

0,

ARRAY_COUNT(dynstates),

dynstates,

};

VkGraphicsPipelineCreateInfo pipeInfo = {

VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,

NULL,

0,

2,

stages,

&vi,

&ia,

NULL, // tess

&vp,

&rs,

&msaa,

&ds,

&cb,

&dyn,

VK_NULL_HANDLE,

RGBA8sRGBRP,

0, // sub pass

VK_NULL_HANDLE, // base pipeline handle

-1, // base pipeline index

};

VkComputePipelineCreateInfo compPipeInfo = {

VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,

NULL,

0,

{VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, NULL, 0, VK_SHADER_STAGE_COMPUTE_BIT,

VK_NULL_HANDLE, "main", NULL},

VK_NULL_HANDLE,

VK_NULL_HANDLE,

0, // base pipeline VkPipeline

};

// declare a few more misc things that are needed on both paths

VkDescriptorBufferInfo bufInfo[8];

RDCEraseEl(bufInfo);

vector<string> sources;

VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL,

VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT};

// A workaround for a couple of bugs, removing texelFetch use from shaders.

// It means broken functionality but at least no instant crashes

bool texelFetchBrokenDriver = false;

VkDriverInfo driverVersion = m_pDriver->GetDriverVersion();

if(driverVersion.IsNV())

{

// drivers before 372.54 did not handle a glslang bugfix about separated samplers,

// and disabling texelFetch works as a workaround.

if(driverVersion.Major() < 372 || (driverVersion.Major() == 372 && driverVersion.Minor() < 54))

texelFetchBrokenDriver = true;

}

// only check this on windows. This is a bit of a hack, as really we want to check if we're

// using the AMD official driver, but there's not a great other way to distinguish it from

// the RADV open source driver.

#if ENABLED(RDOC_WIN32)

if(driverVersion.IsAMD())

{

// for AMD the bugfix version isn't clear as version numbering wasn't strong for a while, but

// any driver that reports a version of >= 1.0.0 is fine, as previous versions all reported

// 0.9.0 as the version.

if(driverVersion.Major() < 1)

texelFetchBrokenDriver = true;

}

#endif

if(texelFetchBrokenDriver)

{

RDCWARN(

"Detected an older driver, enabling texelFetch workaround - try updating to the latest "

"version");

}

// needed in both replay and capture, create depth MS->array pipelines

{

{

VkDescriptorSetLayoutBinding layoutBinding[] = {

{

0, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_ALL, NULL,

},

{

1, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_ALL, NULL,

},

{

2, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, VK_SHADER_STAGE_ALL, NULL,

},

};

VkDescriptorSetLayoutCreateInfo descsetLayoutInfo = {

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,

NULL,

0,

ARRAY_COUNT(layoutBinding),

&layoutBinding[0],

};

vkr = m_pDriver->vkCreateDescriptorSetLayout(dev, &descsetLayoutInfo, NULL,

&m_ArrayMSDescSetLayout);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

}

pipeLayoutInfo.pSetLayouts = &m_ArrayMSDescSetLayout;

VkPushConstantRange push = {VK_SHADER_STAGE_ALL, 0, sizeof(Vec4u)};

pipeLayoutInfo.pushConstantRangeCount = 1;

pipeLayoutInfo.pPushConstantRanges = &push;

vkr = m_pDriver->vkCreatePipelineLayout(dev, &pipeLayoutInfo, NULL, &m_ArrayMSPipeLayout);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

pipeLayoutInfo.pushConstantRangeCount = 0;

pipeLayoutInfo.pPushConstantRanges = NULL;

descSetAllocInfo.pSetLayouts = &m_ArrayMSDescSetLayout;

vkr = m_pDriver->vkAllocateDescriptorSets(dev, &descSetAllocInfo, &m_ArrayMSDescSet);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

enum

{

VS,

MS2ARR,

ARR2MS

};

std::string srcs[] = {

GetEmbeddedResource(glsl_blit_vert), GetEmbeddedResource(glsl_depthms2arr_frag),

GetEmbeddedResource(glsl_deptharr2ms_frag),

};

VkShaderModule modules[3];

for(size_t i = 0; i < ARRAY_COUNT(srcs); i++)

{

GenerateGLSLShader(sources, eShaderVulkan, "", srcs[i], 430);

vector<uint32_t> *spirv;

string err = GetSPIRVBlob(i == 0 ? eSPIRVVertex : eSPIRVFragment, sources, &spirv);

RDCASSERT(err.empty() && spirv);

VkShaderModuleCreateInfo modinfo = {

VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,

NULL,

0,

spirv->size() * sizeof(uint32_t),

&(*spirv)[0],

};

vkr = m_pDriver->vkCreateShaderModule(dev, &modinfo, NULL, &modules[i]);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

}

stages[0].module = modules[VS];

stages[1].module = modules[MS2ARR];

VkFormat formats[] = {

VK_FORMAT_D16_UNORM, VK_FORMAT_D16_UNORM_S8_UINT, VK_FORMAT_X8_D24_UNORM_PACK32,

VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT,

};

VkSampleCountFlagBits sampleCounts[] = {

VK_SAMPLE_COUNT_2_BIT, VK_SAMPLE_COUNT_4_BIT, VK_SAMPLE_COUNT_8_BIT, VK_SAMPLE_COUNT_16_BIT,

};

// we use VK_IMAGE_LAYOUT_GENERAL here because it matches the expected layout for the

// non-depth copy, which uses a storage image.

VkAttachmentDescription attDesc = {0,

VK_FORMAT_UNDEFINED,

VK_SAMPLE_COUNT_1_BIT,

VK_ATTACHMENT_LOAD_OP_CLEAR,

VK_ATTACHMENT_STORE_OP_STORE,

VK_ATTACHMENT_LOAD_OP_CLEAR,

VK_ATTACHMENT_STORE_OP_STORE,

VK_IMAGE_LAYOUT_GENERAL,

VK_IMAGE_LAYOUT_GENERAL};

VkAttachmentReference attRef = {0, VK_IMAGE_LAYOUT_GENERAL};

VkSubpassDescription sub = {

0, VK_PIPELINE_BIND_POINT_GRAPHICS,

0, NULL, // inputs

0, NULL, // color

NULL, // resolve

&attRef, // depth-stencil

0, NULL, // preserve

};

VkRenderPassCreateInfo rpinfo = {

VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,

NULL,

0,

1,

&attDesc,

1,

&sub,

0,

NULL, // dependencies

};

VkDynamicState depthcopy_dyn[] = {VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_STENCIL_REFERENCE};

VkPipelineDepthStencilStateCreateInfo depthcopy_ds = {

VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,

NULL,

0,

true,

true,

VK_COMPARE_OP_ALWAYS,

false,

true,

{VK_STENCIL_OP_REPLACE, VK_STENCIL_OP_REPLACE, VK_STENCIL_OP_REPLACE, VK_COMPARE_OP_ALWAYS,

0xff, 0xff, 0},

{VK_STENCIL_OP_REPLACE, VK_STENCIL_OP_REPLACE, VK_STENCIL_OP_REPLACE, VK_COMPARE_OP_ALWAYS,

0xff, 0xff, 0},

0.0f,

1.0f,

};

pipeInfo.layout = m_ArrayMSPipeLayout;

dyn.dynamicStateCount = ARRAY_COUNT(depthcopy_dyn);

dyn.pDynamicStates = depthcopy_dyn;

pipeInfo.pDepthStencilState = &depthcopy_ds;

cb.attachmentCount = 0;

RDCCOMPILE_ASSERT(ARRAY_COUNT(m_DepthMS2ArrayPipe) == ARRAY_COUNT(formats),

"Array count mismatch");

RDCCOMPILE_ASSERT(ARRAY_COUNT(m_DepthArray2MSPipe) == ARRAY_COUNT(formats),

"Array count mismatch");

RDCCOMPILE_ASSERT(ARRAY_COUNT(m_DepthArray2MSPipe[0]) == ARRAY_COUNT(sampleCounts),

"Array count mismatch");

for(size_t f = 0; f < ARRAY_COUNT(formats); f++)

{

attDesc.format = formats[f];

stages[1].module = modules[MS2ARR];

VkRenderPass rp;

vkr = m_pDriver->vkCreateRenderPass(dev, &rpinfo, NULL, &rp);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

pipeInfo.renderPass = rp;

vkr = m_pDriver->vkCreateGraphicsPipelines(dev, VK_NULL_HANDLE, 1, &pipeInfo, NULL,

&m_DepthMS2ArrayPipe[f]);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

m_pDriver->vkDestroyRenderPass(dev, rp, NULL);

stages[1].module = modules[ARR2MS];

for(size_t s = 0; s < ARRAY_COUNT(sampleCounts); s++)

{

attDesc.samples = sampleCounts[s];

msaa.rasterizationSamples = sampleCounts[s];

msaa.sampleShadingEnable = true;

msaa.minSampleShading = 1.0f;

vkr = m_pDriver->vkCreateRenderPass(dev, &rpinfo, NULL, &rp);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

pipeInfo.renderPass = rp;

vkr = m_pDriver->vkCreateGraphicsPipelines(dev, VK_NULL_HANDLE, 1, &pipeInfo, NULL,

&m_DepthArray2MSPipe[f][s]);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

m_pDriver->vkDestroyRenderPass(dev, rp, NULL);

attDesc.samples = VK_SAMPLE_COUNT_1_BIT;

msaa.sampleShadingEnable = false;

msaa.minSampleShading = 0.0f;

msaa.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;

}

}

// restore pipeline state to normal

cb.attachmentCount = 1;

pipeInfo.renderPass = RGBA8sRGBRP;

dyn.dynamicStateCount = ARRAY_COUNT(dynstates);

dyn.pDynamicStates = dynstates;

pipeInfo.pDepthStencilState = &ds;

for(size_t i = 0; i < ARRAY_COUNT(modules); i++)

m_pDriver->vkDestroyShaderModule(dev, modules[i], NULL);

}

//////////////////////////////////////////////////////////////////////////////////////

// if we're writing, only create text-rendering related resources,

// then tidy up early and return

if(m_State >= WRITING)

{

{

VkDescriptorSetLayoutBinding layoutBinding[] = {

{

0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_ALL, NULL,

},

{

1, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1, VK_SHADER_STAGE_ALL, NULL,

},

{

2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_ALL, NULL,

},

{

3, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_ALL, NULL,

}};

VkDescriptorSetLayoutCreateInfo descsetLayoutInfo = {

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,

NULL,

0,

ARRAY_COUNT(layoutBinding),

&layoutBinding[0],

};

vkr = m_pDriver->vkCreateDescriptorSetLayout(dev, &descsetLayoutInfo, NULL,

&m_TextDescSetLayout);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

}

pipeLayoutInfo.pSetLayouts = &m_TextDescSetLayout;

vkr = m_pDriver->vkCreatePipelineLayout(dev, &pipeLayoutInfo, NULL, &m_TextPipeLayout);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

descSetAllocInfo.pSetLayouts = &m_TextDescSetLayout;

vkr = m_pDriver->vkAllocateDescriptorSets(dev, &descSetAllocInfo, &m_TextDescSet);

RDCASSERTEQUAL(vkr, VK_SUCCESS);

m_TextGeneralUBO.Create(

driver, dev, 128, 100,

0); // make the ring conservatively large to handle many lines of text * several frames

RDCCOMPILE_ASSERT(sizeof(FontUBOData) <= 128, "font uniforms size");

m_TextStringUBO.Create(driver, dev, 4096, 10, 0); // we only use a subset of the

// [MAX_SINGLE_LINE_LENGTH] array needed

// for each line, so this ring can be