From 0afe0d2330e7cb6cc0d33e4043e567aac7f653cb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=91=D1=80=D0=B0=D0=BD=D0=B8=D0=BC=D0=B8=D1=80=20=D0=9A?= =?UTF-8?q?=D0=B0=D1=80=D0=B0=D1=9F=D0=B8=D1=9B?= Date: Wed, 24 Feb 2021 00:09:34 -0800 Subject: [PATCH] Cleanup. --- src/renderer_vk.cpp | 369 +++++++++++++++++++++++--------------------- src/renderer_vk.h | 26 ++-- 2 files changed, 204 insertions(+), 191 deletions(-) diff --git a/src/renderer_vk.cpp b/src/renderer_vk.cpp index aa29cbaab..f74bc6642 100644 --- a/src/renderer_vk.cpp +++ b/src/renderer_vk.cpp @@ -1690,33 +1690,43 @@ VK_IMPORT_INSTANCE m_deviceFeatures.robustBufferAccess = VK_FALSE; { + const VkSampleCountFlags fbColorSampleCounts = m_deviceProperties.limits.framebufferColorSampleCounts; + const VkSampleCountFlags fbDepthSampleCounts = m_deviceProperties.limits.framebufferDepthSampleCounts; + for (uint16_t ii = 0, last = 0; ii < BX_COUNTOF(s_msaa); ii++) { - if ( (m_deviceProperties.limits.framebufferColorSampleCounts >= s_msaa[ii].Count) && (m_deviceProperties.limits.framebufferDepthSampleCounts >= s_msaa[ii].Count) ) + const VkSampleCountFlags msaaCount = s_msaa[ii].Count; + + if (fbColorSampleCounts >= msaaCount + && fbDepthSampleCounts >= msaaCount) + { last = ii; + } else + { s_msaa[ii] = s_msaa[last]; + } } } { struct ImageTest { - VkImageType type; - VkImageUsageFlags usage; + VkImageType type; + VkImageUsageFlags usage; VkImageCreateFlags flags; - uint32_t formatCaps[2]; + uint32_t formatCaps[2]; }; const ImageTest imageTest[] = { - { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_2D, BGFX_CAPS_FORMAT_TEXTURE_2D_SRGB } }, - { VK_IMAGE_TYPE_3D, VK_IMAGE_USAGE_SAMPLED_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_3D, BGFX_CAPS_FORMAT_TEXTURE_3D_SRGB } }, - { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, { BGFX_CAPS_FORMAT_TEXTURE_CUBE, BGFX_CAPS_FORMAT_TEXTURE_CUBE_SRGB } }, - { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER, BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER } }, - { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER, BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER } }, - { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_STORAGE_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_IMAGE_READ, BGFX_CAPS_FORMAT_TEXTURE_IMAGE_READ } }, - { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_STORAGE_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_IMAGE_WRITE, BGFX_CAPS_FORMAT_TEXTURE_IMAGE_WRITE } }, + { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_2D, BGFX_CAPS_FORMAT_TEXTURE_2D_SRGB } }, + { VK_IMAGE_TYPE_3D, VK_IMAGE_USAGE_SAMPLED_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_3D, BGFX_CAPS_FORMAT_TEXTURE_3D_SRGB } }, + { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT, { BGFX_CAPS_FORMAT_TEXTURE_CUBE, BGFX_CAPS_FORMAT_TEXTURE_CUBE_SRGB } }, + { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER, BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER } }, + { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER, BGFX_CAPS_FORMAT_TEXTURE_FRAMEBUFFER } }, + { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_STORAGE_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_IMAGE_READ, BGFX_CAPS_FORMAT_TEXTURE_IMAGE_READ } }, + { VK_IMAGE_TYPE_2D, VK_IMAGE_USAGE_STORAGE_BIT, 0, { BGFX_CAPS_FORMAT_TEXTURE_IMAGE_WRITE, BGFX_CAPS_FORMAT_TEXTURE_IMAGE_WRITE } }, }; for (uint32_t ii = 0; ii < TextureFormat::Count; ++ii) @@ -1772,14 +1782,16 @@ VK_IMPORT_INSTANCE BX_TRACE("---"); uint32_t queueFamilyPropertyCount = 0; - vkGetPhysicalDeviceQueueFamilyProperties(m_physicalDevice + vkGetPhysicalDeviceQueueFamilyProperties( + m_physicalDevice , &queueFamilyPropertyCount , NULL ); VkQueueFamilyProperties queueFamilyPropertices[10]; queueFamilyPropertyCount = bx::min(queueFamilyPropertyCount, BX_COUNTOF(queueFamilyPropertices) ); - vkGetPhysicalDeviceQueueFamilyProperties(m_physicalDevice + vkGetPhysicalDeviceQueueFamilyProperties( + m_physicalDevice , &queueFamilyPropertyCount , queueFamilyPropertices ); @@ -1793,10 +1805,10 @@ VK_IMPORT_INSTANCE BX_TRACE("\t Queue count: %d", qfp.queueCount); BX_TRACE("\tTS valid bits: 0x%08x", qfp.timestampValidBits); BX_TRACE("\t Min image: %d x %d x %d" - , qfp.minImageTransferGranularity.width - , qfp.minImageTransferGranularity.height - , qfp.minImageTransferGranularity.depth - ); + , qfp.minImageTransferGranularity.width + , qfp.minImageTransferGranularity.height + , qfp.minImageTransferGranularity.depth + ); } for (uint32_t ii = 0; ii < queueFamilyPropertyCount; ++ii) @@ -2140,8 +2152,11 @@ VK_IMPORT_DEVICE BX_ASSERT(surfaceFormatIdx < numSurfaceFormats, "Cannot find preferred surface format from supported surface formats"); BX_WARN(surfaceFormatSrgbIdx < numSurfaceFormats, "Cannot find preferred sRGB surface format from supported surface formats"); - m_backBufferColorFormat = surfaceFormats[surfaceFormatIdx]; - m_backBufferColorFormatSrgb = surfaceFormatSrgbIdx < numSurfaceFormats ? surfaceFormats[surfaceFormatSrgbIdx] : m_backBufferColorFormat; + m_backBufferColorFormat = surfaceFormats[surfaceFormatIdx]; + m_backBufferColorFormatSrgb = surfaceFormatSrgbIdx < numSurfaceFormats + ? surfaceFormats[surfaceFormatSrgbIdx] + : m_backBufferColorFormat + ; // find the best match... uint32_t presentModeIdx = findPresentMode(false); @@ -2157,6 +2172,7 @@ VK_IMPORT_DEVICE ; VkCompositeAlphaFlagBitsKHR compositeAlpha = (VkCompositeAlphaFlagBitsKHR)0; + if (surfaceCapabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) { compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; @@ -2175,15 +2191,17 @@ VK_IMPORT_DEVICE } VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + if (surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) { imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; } - uint32_t minSwapBufferCount = bx::max(surfaceCapabilities.minImageCount, 2); - uint32_t maxSwapBufferCount = surfaceCapabilities.maxImageCount == 0 + const uint32_t minSwapBufferCount = bx::max(surfaceCapabilities.minImageCount, 2); + const uint32_t maxSwapBufferCount = surfaceCapabilities.maxImageCount == 0 ? BGFX_CONFIG_MAX_BACK_BUFFERS - : bx::min(surfaceCapabilities.maxImageCount, BGFX_CONFIG_MAX_BACK_BUFFERS); + : bx::min(surfaceCapabilities.maxImageCount, BGFX_CONFIG_MAX_BACK_BUFFERS) + ; BX_ASSERT(minSwapBufferCount <= maxSwapBufferCount, "Incompatible swapchain image count"); uint32_t swapBufferCount = bx::clamp(_init.resolution.numBackBuffers, minSwapBufferCount, maxSwapBufferCount); @@ -2926,10 +2944,12 @@ VK_IMPORT_DEVICE setShaderUniform(flags, predefined.m_loc, proj, 4); UniformBuffer* vcb = program.m_vsh->m_constantBuffer; + if (NULL != vcb) { commit(*vcb); } + ScratchBufferVK& scratchBuffer = m_scratchBuffer[m_cmd.m_currentFrameInFlight]; VkDescriptorSetLayout dsl = m_descriptorSetLayoutCache.find(program.m_descriptorSetLayoutHash); VkDescriptorSetAllocateInfo dsai; @@ -2995,7 +3015,7 @@ VK_IMPORT_DEVICE vkUpdateDescriptorSets(m_device, 3, wds, 0, NULL); vkCmdBindDescriptorSets( - m_commandBuffer + m_commandBuffer , VK_PIPELINE_BIND_POINT_GRAPHICS , program.m_pipelineLayout , 0 @@ -3009,15 +3029,11 @@ VK_IMPORT_DEVICE VertexBufferVK& vb = m_vertexBuffers[_blitter.m_vb->handle.idx]; VkDeviceSize offset = 0; - vkCmdBindVertexBuffers(m_commandBuffer - , 0 - , 1 - , &vb.m_buffer - , &offset - ); + vkCmdBindVertexBuffers(m_commandBuffer, 0, 1, &vb.m_buffer, &offset); BufferVK& ib = m_indexBuffers[_blitter.m_ib->handle.idx]; - vkCmdBindIndexBuffer(m_commandBuffer + vkCmdBindIndexBuffer( + m_commandBuffer , ib.m_buffer , 0 , VK_INDEX_TYPE_UINT16 @@ -3044,14 +3060,7 @@ VK_IMPORT_DEVICE rpbi.pClearValues = NULL; vkCmdBeginRenderPass(m_commandBuffer, &rpbi, VK_SUBPASS_CONTENTS_INLINE); - - vkCmdDrawIndexed(m_commandBuffer - , _numIndices - , 1 - , 0 - , 0 - , 0 - ); + vkCmdDrawIndexed(m_commandBuffer, _numIndices, 1, 0, 0, 0); vkCmdEndRenderPass(m_commandBuffer); } @@ -3061,19 +3070,39 @@ VK_IMPORT_DEVICE { VkResult result; uint32_t numPresentModes; - result = vkGetPhysicalDeviceSurfacePresentModesKHR(m_physicalDevice, m_surface, &numPresentModes, NULL); + result = vkGetPhysicalDeviceSurfacePresentModesKHR( + m_physicalDevice + , m_surface + , &numPresentModes + , NULL + ); + if (VK_SUCCESS != result) { - BX_TRACE("findPresentMode error: vkGetPhysicalDeviceSurfacePresentModesKHR failed %d: %s.", result, getName(result) ); + BX_TRACE( + "findPresentMode error: vkGetPhysicalDeviceSurfacePresentModesKHR failed %d: %s." + , result + , getName(result) + ); return UINT32_MAX; } VkPresentModeKHR presentModes[16]; numPresentModes = bx::min(numPresentModes, BX_COUNTOF(presentModes) ); - result = vkGetPhysicalDeviceSurfacePresentModesKHR(m_physicalDevice, m_surface, &numPresentModes, presentModes); + result = vkGetPhysicalDeviceSurfacePresentModesKHR( + m_physicalDevice + , m_surface + , &numPresentModes + , presentModes + ); + if (VK_SUCCESS != result) { - BX_TRACE("Init error: vkGetPhysicalDeviceSurfacePresentModesKHR failed %d: %s.", result, getName(result) ); + BX_TRACE( + "Init error: vkGetPhysicalDeviceSurfacePresentModesKHR failed %d: %s." + , result + , getName(result) + ); return UINT32_MAX; } @@ -3170,7 +3199,8 @@ VK_IMPORT_DEVICE const bool vsync = !!(flags & BGFX_RESET_VSYNC); const uint32_t presentModeIdx = findPresentMode(vsync); - BGFX_FATAL(UINT32_MAX != presentModeIdx + BGFX_FATAL( + UINT32_MAX != presentModeIdx , bgfx::Fatal::DeviceLost , "Unable to find present mode." ); @@ -3180,19 +3210,22 @@ VK_IMPORT_DEVICE VkSurfaceCapabilitiesKHR surfaceCapabilities; VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(m_physicalDevice, m_surface, &surfaceCapabilities) ); - m_sci.imageExtent.width = bx::clamp(m_resolution.width + m_sci.imageExtent.width = bx::clamp( + m_resolution.width , surfaceCapabilities.minImageExtent.width , surfaceCapabilities.maxImageExtent.width ); - m_sci.imageExtent.height = bx::clamp(m_resolution.height + m_sci.imageExtent.height = bx::clamp( + m_resolution.height , surfaceCapabilities.minImageExtent.height , surfaceCapabilities.maxImageExtent.height ); // Prevent validation error when minimizing a window - if (m_sci.imageExtent.width == 0 || m_sci.imageExtent.height == 0) + if (m_sci.imageExtent.width == 0 + || m_sci.imageExtent.height == 0) { - m_resolution.width = 0; + m_resolution.width = 0; m_resolution.height = 0; return true; } @@ -3253,42 +3286,6 @@ VK_IMPORT_DEVICE setShaderUniform(_flags, _regIndex, _val, _numRegs); } -// void commitShaderUniforms(VkCommandBuffer _commandBuffer, ProgramHandle _program) -// { -// ProgramVK& program = m_program[_program.idx]; -// -// const uint32_t align = uint32_t(m_deviceProperties.limits.minUniformBufferOffsetAlignment); -// const uint32_t vsize = bx::strideAlign(program.m_vsh->m_size, align); -// const uint32_t fsize = bx::strideAlign( (NULL != program.m_fsh ? program.m_fsh->m_size : 0), align); -// const uint32_t total = vsize + fsize; -// -// if (0 < total) -// { -// ScratchBufferVK& sb = m_scratchBuffer[m_currentFrameInFlight]; -// -// uint8_t* data = (uint8_t*)sb.allocUbv(vsize, fsize); -// -// bx::memCopy(data, m_vsScratch, program.m_vsh->m_size); -// data += vsize; -// -// if (0 != fsize) -// { -// bx::memCopy(data, m_fsScratch, program.m_fsh->m_size); -// } -// -// vkCmdBindDescriptorSets(_commandBuffer -// , VK_PIPELINE_BIND_POINT_GRAPHICS -// , m_pipelineLayout -// , program.m_pipelineLayout -// , 0 -// , 1 -// , &sb.m_descriptorSet[sb.m_currentDs - 1] -// , 0 -// , NULL -// ); -// } -// } - void setFrameBuffer(FrameBufferHandle _fbh, bool _msaa = true) { if (isValid(m_fbh) @@ -3296,21 +3293,31 @@ VK_IMPORT_DEVICE { FrameBufferVK& frameBuffer = m_frameBuffers[m_fbh.idx]; - if (m_rtMsaa) frameBuffer.resolve(); + if (m_rtMsaa) + { + frameBuffer.resolve(); + } for (uint8_t ii = 0, num = frameBuffer.m_num; ii < num; ++ii) { TextureVK& texture = m_textures[frameBuffer.m_texture[ii].idx]; - texture.setImageMemoryBarrier(m_commandBuffer, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + texture.setImageMemoryBarrier( + m_commandBuffer + , VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL + ); } if (isValid(frameBuffer.m_depth) ) { TextureVK& texture = m_textures[frameBuffer.m_depth.idx]; const bool writeOnly = 0 != (texture.m_flags&BGFX_TEXTURE_RT_WRITE_ONLY); + if (!writeOnly) { - texture.setImageMemoryBarrier(m_commandBuffer, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + texture.setImageMemoryBarrier( + m_commandBuffer + , VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL + ); } } } @@ -3322,13 +3329,19 @@ VK_IMPORT_DEVICE for (uint8_t ii = 0, num = frameBuffer.m_num; ii < num; ++ii) { TextureVK& texture = m_textures[frameBuffer.m_texture[ii].idx]; - texture.setImageMemoryBarrier(m_commandBuffer, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + texture.setImageMemoryBarrier( + m_commandBuffer + , VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL + ); } if (isValid(frameBuffer.m_depth) ) { TextureVK& texture = m_textures[frameBuffer.m_depth.idx]; - texture.setImageMemoryBarrier(m_commandBuffer, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL); + texture.setImageMemoryBarrier( + m_commandBuffer + , VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL + ); } } @@ -3372,13 +3385,15 @@ VK_IMPORT_DEVICE } uint32_t numAttachments = 1; + if (isValid(m_fbh) ) { const FrameBufferVK& frameBuffer = m_frameBuffers[m_fbh.idx]; numAttachments = frameBuffer.m_num; } - if (!!(BGFX_STATE_BLEND_INDEPENDENT & _state) && m_deviceFeatures.independentBlend ) + if (!!(BGFX_STATE_BLEND_INDEPENDENT & _state) + && m_deviceFeatures.independentBlend ) { for (uint32_t ii = 1, rgba = _rgba; ii < numAttachments; ++ii, rgba >>= 11) { @@ -3492,6 +3507,7 @@ VK_IMPORT_DEVICE uint16_t unsettedAttr[Attrib::Count]; bx::memCopy(unsettedAttr, _program.m_vsh->m_attrMask, sizeof(uint16_t) * Attrib::Count); + for (uint8_t stream = 0; stream < _numStream; ++stream) { VertexLayout layout; @@ -3503,6 +3519,7 @@ VK_IMPORT_DEVICE uint16_t mask = attrMask[ii]; uint16_t attr = (layout.m_attributes[ii] & mask); layout.m_attributes[ii] = attr == 0 || attr == UINT16_MAX ? UINT16_MAX : attr; + if (unsettedAttr[ii] && attr != UINT16_MAX) { unsettedAttr[ii] = 0; @@ -3569,8 +3586,8 @@ VK_IMPORT_DEVICE VkAttachmentReference depthAr; uint32_t numColorAr = 0; - depthAr.attachment = VK_ATTACHMENT_UNUSED; - depthAr.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + depthAr.attachment = VK_ATTACHMENT_UNUSED; + depthAr.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; for (uint8_t ii = 0; ii < _num; ++ii) { @@ -3666,6 +3683,7 @@ VK_IMPORT_DEVICE VK_CHECK( vkCreateRenderPass(m_device, &rpi, m_allocatorCb, &renderPass) ); m_renderPassCache.add(hashKey, renderPass); + return renderPass; } @@ -3719,6 +3737,7 @@ VK_IMPORT_DEVICE } uint32_t borderColor = ( (_samplerFlags & BGFX_SAMPLER_BORDER_COLOR_MASK) >> BGFX_SAMPLER_BORDER_COLOR_SHIFT); + if (borderColor > 0) { sci.borderColor = VK_BORDER_COLOR_INT_OPAQUE_WHITE; @@ -3812,14 +3831,17 @@ VK_IMPORT_DEVICE murmur.add(_stencil); murmur.add(program.m_vsh->m_hash); murmur.add(program.m_vsh->m_attrMask, sizeof(program.m_vsh->m_attrMask) ); + if (NULL != program.m_fsh) { murmur.add(program.m_fsh->m_hash); } + for (uint8_t ii = 0; ii < _numStreams; ++ii) { murmur.add(_layouts[ii]->m_hash); } + murmur.add(layout.m_attributes, sizeof(layout.m_attributes) ); murmur.add(m_fbh.idx); murmur.add(_numInstanceData); @@ -3930,7 +3952,6 @@ VK_IMPORT_DEVICE graphicsPipeline.pDepthStencilState = &depthStencilState; graphicsPipeline.pColorBlendState = &colorBlendState; graphicsPipeline.pDynamicState = &dynamicState; -// graphicsPipeline.layout = m_pipelineLayout; graphicsPipeline.layout = program.m_pipelineLayout; graphicsPipeline.renderPass = isValid(m_fbh) ? m_frameBuffers[m_fbh.idx].m_renderPass : m_renderPass; graphicsPipeline.subpass = 0; @@ -3965,7 +3986,8 @@ VK_IMPORT_DEVICE VkPipelineCache cache; VK_CHECK(vkCreatePipelineCache(m_device, &pcci, m_allocatorCb, &cache) ); - VK_CHECK(vkCreateGraphicsPipelines(m_device + VK_CHECK(vkCreateGraphicsPipelines( + m_device , cache , 1 , &graphicsPipeline @@ -3983,6 +4005,7 @@ VK_IMPORT_DEVICE { cachedData = BX_REALLOC(g_allocator, cachedData, dataSize); } + VK_CHECK(vkGetPipelineCacheData(m_device, cache, &dataSize, cachedData) ); g_callback->cacheWrite(hash, cachedData, (uint32_t)dataSize); } @@ -4360,12 +4383,7 @@ VK_IMPORT_DEVICE if (mrt > 0) { - vkCmdClearAttachments(m_commandBuffer - , mrt - , attachments - , BX_COUNTOF(rect) - , rect - ); + vkCmdClearAttachments(m_commandBuffer, mrt, attachments, BX_COUNTOF(rect), rect); } } @@ -4416,8 +4434,9 @@ VK_IMPORT_DEVICE void kick(bool _wait = false) { const bool acquired = VK_NULL_HANDLE != m_lastImageAcquiredSemaphore; - const VkSemaphore waitSemaphore = m_lastImageAcquiredSemaphore; + const VkSemaphore waitSemaphore = m_lastImageAcquiredSemaphore; const VkSemaphore signalSemaphore = acquired ? m_lastImageRenderedSemaphore : VK_NULL_HANDLE; + m_lastImageAcquiredSemaphore = VK_NULL_HANDLE; if (acquired) @@ -4472,13 +4491,15 @@ VK_IMPORT_DEVICE { searchIndex++; searchIndex = selectMemoryType(requirements->memoryTypeBits, propertyFlags, searchIndex); + if (searchIndex >= 0) { ma.memoryTypeIndex = searchIndex; result = vkAllocateMemory(m_device, &ma, m_allocatorCb, memory); } } - while (result != VK_SUCCESS && searchIndex >= 0); + while (result != VK_SUCCESS + && searchIndex >= 0); return result; } @@ -4560,22 +4581,23 @@ VK_IMPORT_DEVICE VkDevice m_device; VkQueue m_queueGraphics; VkQueue m_queueCompute; - VkRenderPass m_renderPass; + VkRenderPass m_renderPass; VkDescriptorPool m_descriptorPool; - VkPipelineCache m_pipelineCache; + VkPipelineCache m_pipelineCache; TimerQueryVK m_gpuTimer; void* m_renderDocDll; void* m_vulkan1Dll; - IndexBufferVK m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS]; + IndexBufferVK m_indexBuffers[BGFX_CONFIG_MAX_INDEX_BUFFERS]; VertexBufferVK m_vertexBuffers[BGFX_CONFIG_MAX_VERTEX_BUFFERS]; - ShaderVK m_shaders[BGFX_CONFIG_MAX_SHADERS]; - ProgramVK m_program[BGFX_CONFIG_MAX_PROGRAMS]; - TextureVK m_textures[BGFX_CONFIG_MAX_TEXTURES]; - VertexLayout m_vertexLayouts[BGFX_CONFIG_MAX_VERTEX_LAYOUTS]; - FrameBufferVK m_frameBuffers[BGFX_CONFIG_MAX_FRAME_BUFFERS]; + ShaderVK m_shaders[BGFX_CONFIG_MAX_SHADERS]; + ProgramVK m_program[BGFX_CONFIG_MAX_PROGRAMS]; + TextureVK m_textures[BGFX_CONFIG_MAX_TEXTURES]; + VertexLayout m_vertexLayouts[BGFX_CONFIG_MAX_VERTEX_LAYOUTS]; + FrameBufferVK m_frameBuffers[BGFX_CONFIG_MAX_FRAME_BUFFERS]; + void* m_uniforms[BGFX_CONFIG_MAX_UNIFORMS]; Matrix4 m_predefinedUniforms[PredefinedUniform::Count]; UniformRegistry m_uniformReg; @@ -5259,7 +5281,8 @@ VK_DESTROY { m_bindInfo[stage] = m_vsh->m_bindInfo[stage]; } - else if (NULL != m_fsh && isValid(m_fsh->m_bindInfo[stage].uniformHandle) ) + else if (NULL != m_fsh + && isValid(m_fsh->m_bindInfo[stage].uniformHandle) ) { m_bindInfo[stage] = m_fsh->m_bindInfo[stage]; } @@ -5578,25 +5601,27 @@ VK_DESTROY uint32_t pitch; uint32_t slice; uint32_t size; - uint8_t mipLevel; - uint8_t layer; + uint8_t mipLevel; + uint8_t layer; }; ImageInfo* imageInfos = (ImageInfo*)BX_ALLOC(g_allocator, sizeof(ImageInfo) * numSrd); bx::memSet(imageInfos, 0, sizeof(ImageInfo) * numSrd); uint32_t alignment = 1; // tightly aligned buffer + for (uint8_t side = 0; side < numSides; ++side) { for (uint8_t lod = 0; lod < ti.numMips; ++lod) { bimg::ImageMip mip; + if (bimg::imageGetRawData(imageContainer, side, lod + startLod, _mem->data, _mem->size, mip) ) { if (convert) { const uint32_t pitch = bx::strideAlign(bx::max(mip.m_width, 4) * bpp / 8, alignment); const uint32_t slice = bx::strideAlign(bx::max(mip.m_height, 4) * pitch, alignment); - const uint32_t size = slice * mip.m_depth; + const uint32_t size = slice * mip.m_depth; uint8_t* temp = (uint8_t*)BX_ALLOC(g_allocator, size); bimg::imageDecodeToBgra8( @@ -5609,21 +5634,21 @@ VK_DESTROY , mip.m_format ); - imageInfos[kk].data = temp; - imageInfos[kk].width = mip.m_width; - imageInfos[kk].height = mip.m_height; - imageInfos[kk].depth = mip.m_depth; - imageInfos[kk].pitch = pitch; - imageInfos[kk].slice = slice; - imageInfos[kk].size = size; + imageInfos[kk].data = temp; + imageInfos[kk].width = mip.m_width; + imageInfos[kk].height = mip.m_height; + imageInfos[kk].depth = mip.m_depth; + imageInfos[kk].pitch = pitch; + imageInfos[kk].slice = slice; + imageInfos[kk].size = size; imageInfos[kk].mipLevel = lod; - imageInfos[kk].layer = side; + imageInfos[kk].layer = side; } else if (compressed) { const uint32_t pitch = bx::strideAlign( (mip.m_width / blockInfo.blockWidth) * mip.m_blockSize, alignment); const uint32_t slice = bx::strideAlign( (mip.m_height / blockInfo.blockHeight) * pitch, alignment); - const uint32_t size = slice * mip.m_depth; + const uint32_t size = slice * mip.m_depth; uint8_t* temp = (uint8_t*)BX_ALLOC(g_allocator, size); bimg::imageCopy( @@ -5635,21 +5660,21 @@ VK_DESTROY , pitch ); - imageInfos[kk].data = temp; - imageInfos[kk].width = mip.m_width; - imageInfos[kk].height = mip.m_height; - imageInfos[kk].depth = mip.m_depth; - imageInfos[kk].pitch = pitch; - imageInfos[kk].slice = slice; - imageInfos[kk].size = size; + imageInfos[kk].data = temp; + imageInfos[kk].width = mip.m_width; + imageInfos[kk].height = mip.m_height; + imageInfos[kk].depth = mip.m_depth; + imageInfos[kk].pitch = pitch; + imageInfos[kk].slice = slice; + imageInfos[kk].size = size; imageInfos[kk].mipLevel = lod; - imageInfos[kk].layer = side; + imageInfos[kk].layer = side; } else { const uint32_t pitch = bx::strideAlign(mip.m_width * mip.m_bpp / 8, alignment); const uint32_t slice = bx::strideAlign(mip.m_height * pitch, alignment); - const uint32_t size = slice * mip.m_depth; + const uint32_t size = slice * mip.m_depth; uint8_t* temp = (uint8_t*)BX_ALLOC(g_allocator, size); bimg::imageCopy( @@ -5661,15 +5686,15 @@ VK_DESTROY , pitch ); - imageInfos[kk].data = temp; - imageInfos[kk].width = mip.m_width; - imageInfos[kk].height = mip.m_height; - imageInfos[kk].depth = mip.m_depth; - imageInfos[kk].pitch = pitch; - imageInfos[kk].slice = slice; - imageInfos[kk].size = size; + imageInfos[kk].data = temp; + imageInfos[kk].width = mip.m_width; + imageInfos[kk].height = mip.m_height; + imageInfos[kk].depth = mip.m_depth; + imageInfos[kk].pitch = pitch; + imageInfos[kk].slice = slice; + imageInfos[kk].size = size; imageInfos[kk].mipLevel = lod; - imageInfos[kk].layer = side; + imageInfos[kk].layer = side; } } ++kk; @@ -5887,7 +5912,7 @@ VK_DESTROY } { - bgfx::vk::setImageMemoryBarrier( + vk::setImageMemoryBarrier( _commandBuffer , m_singleMsaaImage , m_aspectMask @@ -6066,7 +6091,7 @@ VK_DESTROY for (uint32_t i = 1; i < m_numMips; i++) { - bgfx::vk::setImageMemoryBarrier( + vk::setImageMemoryBarrier( _commandBuffer , needResolve ? m_singleMsaaImage : m_textureImage , m_aspectMask @@ -6103,7 +6128,7 @@ VK_DESTROY , VK_FILTER_LINEAR ); - bgfx::vk::setImageMemoryBarrier( + vk::setImageMemoryBarrier( _commandBuffer , needResolve ? m_singleMsaaImage : m_textureImage , m_aspectMask @@ -6119,7 +6144,7 @@ VK_DESTROY mipHeight = bx::max(1, mipHeight >> 1); } - bgfx::vk::setImageMemoryBarrier( + vk::setImageMemoryBarrier( _commandBuffer , needResolve ? m_singleMsaaImage : m_textureImage , m_aspectMask @@ -6158,7 +6183,7 @@ VK_DESTROY return; } - bgfx::vk::setImageMemoryBarrier( + vk::setImageMemoryBarrier( _commandBuffer , m_textureImage , m_aspectMask @@ -6301,11 +6326,13 @@ VK_DESTROY { vkDestroy(m_commandList[ii].m_fence); vkDestroy(m_commandList[ii].m_semaphore); + if (VK_NULL_HANDLE != m_commandList[ii].m_commandBuffer) { vkFreeCommandBuffers(s_renderVK->m_device, m_commandList[ii].m_commandPool, 1, &m_commandList[ii].m_commandBuffer); m_commandList[ii].m_commandBuffer = VK_NULL_HANDLE; } + vkDestroy(m_commandList[ii].m_commandPool); } } @@ -6397,6 +6424,7 @@ VK_DESTROY { consume(); } + m_consumeIndex = m_currentFrameInFlight; } else @@ -6424,36 +6452,17 @@ VK_DESTROY switch (resource.m_type) { - case VK_OBJECT_TYPE_BUFFER: - vkDestroyBuffer(device, ::VkBuffer(resource.m_handle), allocatorCb); - break; - case VK_OBJECT_TYPE_IMAGE_VIEW: - vkDestroyImageView(device, ::VkImageView(resource.m_handle), allocatorCb); - break; - case VK_OBJECT_TYPE_IMAGE: - vkDestroyImage(device, ::VkImage(resource.m_handle), allocatorCb); - break; - case VK_OBJECT_TYPE_FRAMEBUFFER: - vkDestroyFramebuffer(device, ::VkFramebuffer(resource.m_handle), allocatorCb); - break; - case VK_OBJECT_TYPE_PIPELINE_LAYOUT: - vkDestroyPipelineLayout(device, ::VkPipelineLayout(resource.m_handle), allocatorCb); - break; - case VK_OBJECT_TYPE_PIPELINE: - vkDestroyPipeline(device, ::VkPipeline(resource.m_handle), allocatorCb); - break; - case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: - vkDestroyDescriptorSetLayout(device, ::VkDescriptorSetLayout(resource.m_handle), allocatorCb); - break; - case VK_OBJECT_TYPE_RENDER_PASS: - vkDestroyRenderPass(device, ::VkRenderPass(resource.m_handle), allocatorCb); - break; - case VK_OBJECT_TYPE_SAMPLER: - vkDestroySampler(device, ::VkSampler(resource.m_handle), allocatorCb); - break; - case VK_OBJECT_TYPE_DEVICE_MEMORY: - vkFreeMemory(device, ::VkDeviceMemory(resource.m_handle), allocatorCb); - break; + case VK_OBJECT_TYPE_BUFFER: vkDestroyBuffer (device, ::VkBuffer(resource.m_handle), allocatorCb); break; + case VK_OBJECT_TYPE_IMAGE_VIEW: vkDestroyImageView (device, ::VkImageView(resource.m_handle), allocatorCb); break; + case VK_OBJECT_TYPE_IMAGE: vkDestroyImage (device, ::VkImage(resource.m_handle), allocatorCb); break; + case VK_OBJECT_TYPE_FRAMEBUFFER: vkDestroyFramebuffer (device, ::VkFramebuffer(resource.m_handle), allocatorCb); break; + case VK_OBJECT_TYPE_PIPELINE_LAYOUT: vkDestroyPipelineLayout (device, ::VkPipelineLayout(resource.m_handle), allocatorCb); break; + case VK_OBJECT_TYPE_PIPELINE: vkDestroyPipeline (device, ::VkPipeline(resource.m_handle), allocatorCb); break; + case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: vkDestroyDescriptorSetLayout(device, ::VkDescriptorSetLayout(resource.m_handle), allocatorCb); break; + case VK_OBJECT_TYPE_RENDER_PASS: vkDestroyRenderPass (device, ::VkRenderPass(resource.m_handle), allocatorCb); break; + case VK_OBJECT_TYPE_SAMPLER: vkDestroySampler (device, ::VkSampler(resource.m_handle), allocatorCb); break; + case VK_OBJECT_TYPE_DEVICE_MEMORY: vkFreeMemory (device, ::VkDeviceMemory(resource.m_handle), allocatorCb); break; + default: BX_ASSERT(false, "Invalid resource type: %d", resource.m_type); break; @@ -6663,7 +6672,9 @@ VK_DESTROY if (needAcquire) { if (!acquireImage() ) + { return; + } } const uint64_t f0 = BGFX_STATE_BLEND_FACTOR; @@ -6906,7 +6917,7 @@ VK_DESTROY } vkCmdBindDescriptorSets( - m_commandBuffer + m_commandBuffer , VK_PIPELINE_BIND_POINT_COMPUTE , program.m_pipelineLayout , 0 @@ -7205,7 +7216,7 @@ VK_DESTROY } vkCmdBindDescriptorSets( - m_commandBuffer + m_commandBuffer , VK_PIPELINE_BIND_POINT_GRAPHICS , program.m_pipelineLayout , 0 @@ -7220,7 +7231,8 @@ VK_DESTROY for (uint32_t ii = 0; ii < numStreams; ++ii) { VkDeviceSize offset = 0; - vkCmdBindVertexBuffers(m_commandBuffer + vkCmdBindVertexBuffers( + m_commandBuffer , ii , 1 , &m_vertexBuffers[draw.m_stream[ii].m_handle.idx].m_buffer @@ -7232,7 +7244,8 @@ VK_DESTROY { VkDeviceSize instanceOffset = draw.m_instanceDataOffset; VertexBufferVK& instanceBuffer = m_vertexBuffers[draw.m_instanceDataBuffer.idx]; - vkCmdBindVertexBuffers(m_commandBuffer + vkCmdBindVertexBuffers( + m_commandBuffer , numStreams , 1 , &instanceBuffer.m_buffer diff --git a/src/renderer_vk.h b/src/renderer_vk.h index c400887e5..77175d981 100644 --- a/src/renderer_vk.h +++ b/src/renderer_vk.h @@ -276,19 +276,19 @@ namespace bgfx { namespace vk { -#define VK_DESTROY_FUNC(_name) \ - struct Vk##_name \ - { \ - ::Vk##_name vk; \ - Vk##_name() {} \ - Vk##_name(::Vk##_name _vk) : vk(_vk) {} \ - operator ::Vk##_name() { return vk; } \ - operator ::Vk##_name() const { return vk; } \ - ::Vk##_name* operator &() { return &vk; } \ - const ::Vk##_name* operator &() const { return &vk; } \ - }; \ - BX_STATIC_ASSERT(sizeof(::Vk##_name) == sizeof(Vk##_name) ); \ - void vkDestroy(Vk##_name&) +#define VK_DESTROY_FUNC(_name) \ + struct Vk##_name \ + { \ + ::Vk##_name vk; \ + Vk##_name() {} \ + Vk##_name(::Vk##_name _vk) : vk(_vk) {} \ + operator ::Vk##_name() { return vk; } \ + operator ::Vk##_name() const { return vk; } \ + ::Vk##_name* operator &() { return &vk; } \ + const ::Vk##_name* operator &() const { return &vk; } \ + }; \ + BX_STATIC_ASSERT(sizeof(::Vk##_name) == sizeof(Vk##_name) ); \ + void vkDestroy(Vk##_name&) VK_DESTROY #undef VK_DESTROY_FUNC