From 7bacb7fb5cb31701e36d485ea6683bc8d7a2f83d Mon Sep 17 00:00:00 2001 From: Yun Hsiao Wu Date: Tue, 9 Jun 2020 09:45:27 +0800 Subject: [PATCH] vk: clang format (#2535) --- native/cocos/renderer/core/gfx/GFXDef.h | 1 + .../renderer/gfx-vulkan/VKBindingLayout.cc | 107 ++- .../renderer/gfx-vulkan/VKBindingLayout.h | 11 +- native/cocos/renderer/gfx-vulkan/VKBuffer.cc | 58 +- native/cocos/renderer/gfx-vulkan/VKBuffer.h | 13 +- .../renderer/gfx-vulkan/VKCommandAllocator.cc | 29 +- .../renderer/gfx-vulkan/VKCommandAllocator.h | 8 +- .../renderer/gfx-vulkan/VKCommandBuffer.cc | 283 +++---- .../renderer/gfx-vulkan/VKCommandBuffer.h | 43 +- .../cocos/renderer/gfx-vulkan/VKCommands.cc | 653 +++++++--------- native/cocos/renderer/gfx-vulkan/VKCommands.h | 74 +- native/cocos/renderer/gfx-vulkan/VKContext.cc | 318 +++----- native/cocos/renderer/gfx-vulkan/VKContext.h | 20 +- native/cocos/renderer/gfx-vulkan/VKDevice.cc | 325 ++++---- native/cocos/renderer/gfx-vulkan/VKDevice.h | 82 +- native/cocos/renderer/gfx-vulkan/VKFence.cc | 39 +- native/cocos/renderer/gfx-vulkan/VKFence.h | 8 +- .../renderer/gfx-vulkan/VKFramebuffer.cc | 45 +- .../cocos/renderer/gfx-vulkan/VKFramebuffer.h | 24 +- .../cocos/renderer/gfx-vulkan/VKGPUObjects.h | 165 ++-- .../renderer/gfx-vulkan/VKInputAssembler.cc | 48 +- .../renderer/gfx-vulkan/VKInputAssembler.h | 11 +- .../renderer/gfx-vulkan/VKPipelineLayout.cc | 31 +- .../renderer/gfx-vulkan/VKPipelineLayout.h | 12 +- .../renderer/gfx-vulkan/VKPipelineState.cc | 40 +- .../renderer/gfx-vulkan/VKPipelineState.h | 11 +- native/cocos/renderer/gfx-vulkan/VKQueue.cc | 43 +- native/cocos/renderer/gfx-vulkan/VKQueue.h | 10 +- .../cocos/renderer/gfx-vulkan/VKRenderPass.cc | 24 +- .../cocos/renderer/gfx-vulkan/VKRenderPass.h | 11 +- native/cocos/renderer/gfx-vulkan/VKSPIRV.h | 314 ++++---- native/cocos/renderer/gfx-vulkan/VKSampler.cc | 24 +- native/cocos/renderer/gfx-vulkan/VKSampler.h | 18 +- native/cocos/renderer/gfx-vulkan/VKShader.cc | 29 +- native/cocos/renderer/gfx-vulkan/VKShader.h | 23 +- native/cocos/renderer/gfx-vulkan/VKStd.h | 38 +- native/cocos/renderer/gfx-vulkan/VKTexture.cc | 118 ++- native/cocos/renderer/gfx-vulkan/VKTexture.h | 24 +- .../renderer/gfx-vulkan/VKTextureView.cc | 31 +- .../cocos/renderer/gfx-vulkan/VKTextureView.h | 18 +- native/cocos/renderer/gfx-vulkan/VKUtils.h | 713 ++++++++---------- native/cocos/renderer/gfx-vulkan/VKWindow.cc | 87 +-- native/cocos/renderer/gfx-vulkan/VKWindow.h | 7 +- .../js-bindings/auto/jsb_gfx_auto.cpp | 82 +- 44 files changed, 1799 insertions(+), 2274 deletions(-) diff --git a/native/cocos/renderer/core/gfx/GFXDef.h b/native/cocos/renderer/core/gfx/GFXDef.h index bb8502f0ae..cf8dc3a210 100755 --- a/native/cocos/renderer/core/gfx/GFXDef.h +++ b/native/cocos/renderer/core/gfx/GFXDef.h @@ -676,6 +676,7 @@ struct GFXWindowInfo { bool isFullscreen = false; GFXVsyncMode vsyncMode = GFXVsyncMode::OFF; uintptr_t windowHandle = 0; + GFXRenderPass *renderPass = nullptr; }; struct GFXContextInfo { diff --git a/native/cocos/renderer/gfx-vulkan/VKBindingLayout.cc b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.cc index 4915b2992f..297d45fb10 100644 --- a/native/cocos/renderer/gfx-vulkan/VKBindingLayout.cc +++ b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.cc @@ -1,31 +1,27 @@ #include "VKStd.h" + #include "VKBindingLayout.h" -#include "VKCommands.h" #include "VKBuffer.h" -#include "VKTextureView.h" -#include "VKSampler.h" +#include "VKCommands.h" #include "VKDevice.h" +#include "VKSampler.h" +#include "VKTextureView.h" NS_CC_BEGIN -CCVKBindingLayout::CCVKBindingLayout(GFXDevice* device) - : GFXBindingLayout(device) -{ +CCVKBindingLayout::CCVKBindingLayout(GFXDevice *device) +: GFXBindingLayout(device) { } -CCVKBindingLayout::~CCVKBindingLayout() -{ +CCVKBindingLayout::~CCVKBindingLayout() { } -bool CCVKBindingLayout::initialize(const GFXBindingLayoutInfo &info) -{ - if (info.bindings.size()) - { +bool CCVKBindingLayout::initialize(const GFXBindingLayoutInfo &info) { + if (info.bindings.size()) { _bindingUnits.resize(info.bindings.size()); - for (size_t i = 0; i < _bindingUnits.size(); ++i) - { - GFXBindingUnit& bindingUnit = _bindingUnits[i]; - const GFXBinding& binding = info.bindings[i]; + for (size_t i = 0; i < _bindingUnits.size(); ++i) { + GFXBindingUnit &bindingUnit = _bindingUnits[i]; + const GFXBinding &binding = info.bindings[i]; bindingUnit.binding = binding.binding; bindingUnit.type = binding.type; bindingUnit.name = binding.name; @@ -35,18 +31,16 @@ bool CCVKBindingLayout::initialize(const GFXBindingLayoutInfo &info) } _gpuBindingLayout = CC_NEW(CCVKGPUBindingLayout); - CCVKCmdFuncCreateBindingLayout((CCVKDevice*)_device, _gpuBindingLayout, _bindingUnits); + CCVKCmdFuncCreateBindingLayout((CCVKDevice *)_device, _gpuBindingLayout, _bindingUnits); _status = GFXStatus::SUCCESS; return true; } -void CCVKBindingLayout::destroy() -{ - if (_gpuBindingLayout) - { - CCVKCmdFuncDestroyBindingLayout((CCVKDevice*)_device, _gpuBindingLayout); +void CCVKBindingLayout::destroy() { + if (_gpuBindingLayout) { + CCVKCmdFuncDestroyBindingLayout((CCVKDevice *)_device, _gpuBindingLayout); CC_DELETE(_gpuBindingLayout); _gpuBindingLayout = nullptr; } @@ -54,53 +48,46 @@ void CCVKBindingLayout::destroy() _status = GFXStatus::UNREADY; } -void CCVKBindingLayout::update() -{ - if (_isDirty && _gpuBindingLayout) - { - for (size_t i = 0; i < _bindingUnits.size(); ++i) - { - GFXBindingUnit& bindingUnit = _bindingUnits[i]; - auto &binding = _gpuBindingLayout->bindings[i]; +void CCVKBindingLayout::update() { + if (_isDirty && _gpuBindingLayout) { + for (size_t i = 0; i < _bindingUnits.size(); ++i) { + GFXBindingUnit &bindingUnit = _bindingUnits[i]; + VkWriteDescriptorSet &binding = _gpuBindingLayout->bindings[i]; - switch (bindingUnit.type) - { - case GFXBindingType::UNIFORM_BUFFER: - { - if (bindingUnit.buffer) - { - auto buffer = ((CCVKBuffer*)bindingUnit.buffer)->gpuBuffer(); - auto info = (VkDescriptorBufferInfo*)binding.pBufferInfo; + switch (bindingUnit.type) { + case GFXBindingType::UNIFORM_BUFFER: { + if (bindingUnit.buffer) { + CCVKGPUBuffer *buffer = ((CCVKBuffer *)bindingUnit.buffer)->gpuBuffer(); + VkDescriptorBufferInfo *info = (VkDescriptorBufferInfo *)binding.pBufferInfo; - info->buffer = buffer->vkBuffer; - info->offset = 0; - info->range = buffer->size; + info->buffer = buffer->vkBuffer; + info->offset = 0; + info->range = buffer->size; + } + + break; } + case GFXBindingType::SAMPLER: { + VkDescriptorImageInfo *info = (VkDescriptorImageInfo *)binding.pImageInfo; + info->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - break; - } - case GFXBindingType::SAMPLER: - { - auto info = (VkDescriptorImageInfo*)binding.pImageInfo; - info->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; + if (bindingUnit.texView) { + info->imageView = ((CCVKTextureView *)bindingUnit.texView)->gpuTexView()->vkImageView; + } else { + info->imageView = ((CCVKDevice *)_device)->nullTexView2D->gpuTexView()->vkImageView; + } - if (bindingUnit.texView) - { - info->imageView = ((CCVKTextureView*)bindingUnit.texView)->gpuTexView()->vkImageView; + if (bindingUnit.sampler) { + info->sampler = ((CCVKSampler *)bindingUnit.sampler)->gpuSampler()->vkSampler; + } + + break; } - - if (bindingUnit.sampler) - { - info->sampler = ((CCVKSampler*)bindingUnit.sampler)->gpuSampler()->vkSampler; - } - - break; - } } } - vkUpdateDescriptorSets(((CCVKDevice*)_device)->gpuDevice()->vkDevice, - _gpuBindingLayout->bindings.size(), _gpuBindingLayout->bindings.data(), 0, nullptr); + vkUpdateDescriptorSets(((CCVKDevice *)_device)->gpuDevice()->vkDevice, + _gpuBindingLayout->bindings.size(), _gpuBindingLayout->bindings.data(), 0, nullptr); _isDirty = false; } diff --git a/native/cocos/renderer/gfx-vulkan/VKBindingLayout.h b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.h index ffe7b9f34f..17b2a97a39 100644 --- a/native/cocos/renderer/gfx-vulkan/VKBindingLayout.h +++ b/native/cocos/renderer/gfx-vulkan/VKBindingLayout.h @@ -5,21 +5,20 @@ NS_CC_BEGIN class CCVKGPUBindingLayout; -class CC_VULKAN_API CCVKBindingLayout : public GFXBindingLayout -{ +class CC_VULKAN_API CCVKBindingLayout : public GFXBindingLayout { public: - CCVKBindingLayout(GFXDevice* device); + CCVKBindingLayout(GFXDevice *device); ~CCVKBindingLayout(); public: - bool initialize(const GFXBindingLayoutInfo& info); + bool initialize(const GFXBindingLayoutInfo &info); void destroy(); void update(); - CC_INLINE CCVKGPUBindingLayout* gpuBindingLayout() const { return _gpuBindingLayout; } + CC_INLINE CCVKGPUBindingLayout *gpuBindingLayout() const { return _gpuBindingLayout; } private: - CCVKGPUBindingLayout* _gpuBindingLayout = nullptr; + CCVKGPUBindingLayout *_gpuBindingLayout = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKBuffer.cc b/native/cocos/renderer/gfx-vulkan/VKBuffer.cc index 22efca1888..8be04b29ce 100644 --- a/native/cocos/renderer/gfx-vulkan/VKBuffer.cc +++ b/native/cocos/renderer/gfx-vulkan/VKBuffer.cc @@ -1,20 +1,18 @@ #include "VKStd.h" + #include "VKBuffer.h" #include "VKCommands.h" NS_CC_BEGIN -CCVKBuffer::CCVKBuffer(GFXDevice* device) - : GFXBuffer(device) -{ +CCVKBuffer::CCVKBuffer(GFXDevice *device) +: GFXBuffer(device) { } -CCVKBuffer::~CCVKBuffer() -{ +CCVKBuffer::~CCVKBuffer() { } -bool CCVKBuffer::initialize(const GFXBufferInfo& info) -{ +bool CCVKBuffer::initialize(const GFXBufferInfo &info) { _usage = info.usage; _memUsage = info.memUsage; _size = info.size; @@ -22,9 +20,8 @@ bool CCVKBuffer::initialize(const GFXBufferInfo& info) _count = _size / _stride; _flags = info.flags; - if ((_flags & GFXBufferFlagBit::BAKUP_BUFFER) && _size > 0) - { - _buffer = (uint8_t*)CC_MALLOC(_size); + if ((_flags & GFXBufferFlagBit::BAKUP_BUFFER) && _size > 0) { + _buffer = (uint8_t *)CC_MALLOC(_size); _device->getMemoryStatus().bufferSize += _size; } @@ -35,30 +32,26 @@ bool CCVKBuffer::initialize(const GFXBufferInfo& info) _gpuBuffer->stride = _stride; _gpuBuffer->count = _count; - if (!(_usage & GFXBufferUsageBit::INDIRECT)) - { + if (!(_usage & GFXBufferUsageBit::INDIRECT)) { _gpuBuffer->buffer = _buffer; } - CCVKCmdFuncCreateBuffer((CCVKDevice*)_device, _gpuBuffer); + CCVKCmdFuncCreateBuffer((CCVKDevice *)_device, _gpuBuffer); _device->getMemoryStatus().bufferSize += _size; _status = GFXStatus::SUCCESS; return true; } -void CCVKBuffer::destroy() -{ - if (_gpuBuffer) - { - CCVKCmdFuncDestroyBuffer((CCVKDevice*)_device, _gpuBuffer); +void CCVKBuffer::destroy() { + if (_gpuBuffer) { + CCVKCmdFuncDestroyBuffer((CCVKDevice *)_device, _gpuBuffer); _device->getMemoryStatus().bufferSize -= _size; CC_DELETE(_gpuBuffer); _gpuBuffer = nullptr; } - if (_buffer) - { + if (_buffer) { CC_FREE(_buffer); _device->getMemoryStatus().bufferSize -= _size; _buffer = nullptr; @@ -67,25 +60,22 @@ void CCVKBuffer::destroy() _status = GFXStatus::UNREADY; } -void CCVKBuffer::resize(uint size) -{ - if (_size != size) - { +void CCVKBuffer::resize(uint size) { + if (_size != size) { const uint old_size = _size; _size = size; _count = _size / _stride; - GFXMemoryStatus& status = _device->getMemoryStatus(); + GFXMemoryStatus &status = _device->getMemoryStatus(); _gpuBuffer->size = _size; _gpuBuffer->count = _count; - CCVKCmdFuncResizeBuffer((CCVKDevice*)_device, _gpuBuffer); + CCVKCmdFuncResizeBuffer((CCVKDevice *)_device, _gpuBuffer); status.bufferSize -= old_size; status.bufferSize += _size; - if (_buffer) - { - const uint8_t* old_buff = _buffer; - _buffer = (uint8_t*)CC_MALLOC(_size); + if (_buffer) { + const uint8_t *old_buff = _buffer; + _buffer = (uint8_t *)CC_MALLOC(_size); memcpy(_buffer, old_buff, old_size); CC_FREE(_buffer); status.bufferSize -= old_size; @@ -94,13 +84,11 @@ void CCVKBuffer::resize(uint size) } } -void CCVKBuffer::update(void* buffer, uint offset, uint size) -{ - if (_buffer) - { +void CCVKBuffer::update(void *buffer, uint offset, uint size) { + if (_buffer) { memcpy(_buffer + offset, buffer, size); } - CCVKCmdFuncUpdateBuffer((CCVKDevice*)_device, _gpuBuffer, buffer, offset, size); + CCVKCmdFuncUpdateBuffer((CCVKDevice *)_device, _gpuBuffer, buffer, offset, size); } NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKBuffer.h b/native/cocos/renderer/gfx-vulkan/VKBuffer.h index 61a9eb187a..50aef8e116 100644 --- a/native/cocos/renderer/gfx-vulkan/VKBuffer.h +++ b/native/cocos/renderer/gfx-vulkan/VKBuffer.h @@ -5,22 +5,21 @@ NS_CC_BEGIN class CCVKGPUBuffer; -class CC_VULKAN_API CCVKBuffer : public GFXBuffer -{ +class CC_VULKAN_API CCVKBuffer : public GFXBuffer { public: - CCVKBuffer(GFXDevice* device); + CCVKBuffer(GFXDevice *device); ~CCVKBuffer(); public: - bool initialize(const GFXBufferInfo& info); + bool initialize(const GFXBufferInfo &info); void destroy(); void resize(uint size); - void update(void* buffer, uint offset, uint size); + void update(void *buffer, uint offset, uint size); - CC_INLINE CCVKGPUBuffer* gpuBuffer() const { return _gpuBuffer; } + CC_INLINE CCVKGPUBuffer *gpuBuffer() const { return _gpuBuffer; } private: - CCVKGPUBuffer* _gpuBuffer = nullptr; + CCVKGPUBuffer *_gpuBuffer = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.cc b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.cc index 63260438fa..2cf02df346 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.cc +++ b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.cc @@ -1,43 +1,38 @@ #include "VKStd.h" + #include "VKCommandAllocator.h" #include "VKCommands.h" #include "VKDevice.h" NS_CC_BEGIN -CCVKCommandAllocator::CCVKCommandAllocator(GFXDevice* device) - : GFXCommandAllocator(device) -{ +CCVKCommandAllocator::CCVKCommandAllocator(GFXDevice *device) +: GFXCommandAllocator(device) { } -CCVKCommandAllocator::~CCVKCommandAllocator() -{ +CCVKCommandAllocator::~CCVKCommandAllocator() { } -bool CCVKCommandAllocator::initialize(const GFXCommandAllocatorInfo& info) -{ +bool CCVKCommandAllocator::initialize(const GFXCommandAllocatorInfo &info) { _gpuCommandPool = CC_NEW(CCVKGPUCommandPool); - CCVKCmdFuncCreateCommandPool((CCVKDevice*)_device, _gpuCommandPool); + CCVKCmdFuncCreateCommandPool((CCVKDevice *)_device, _gpuCommandPool); _status = GFXStatus::SUCCESS; return true; } -void CCVKCommandAllocator::destroy() -{ - CCVKCmdFuncDestroyCommandPool((CCVKDevice*)_device, _gpuCommandPool); +void CCVKCommandAllocator::destroy() { + CCVKCmdFuncDestroyCommandPool((CCVKDevice *)_device, _gpuCommandPool); _status = GFXStatus::UNREADY; } -void CCVKCommandAllocator::reset() -{ - VK_CHECK(vkResetCommandPool(((CCVKDevice*)_device)->gpuDevice()->vkDevice, _gpuCommandPool->vkCommandPool, 0)); +void CCVKCommandAllocator::reset() { + VK_CHECK(vkResetCommandPool(((CCVKDevice *)_device)->gpuDevice()->vkDevice, _gpuCommandPool->vkCommandPool, 0)); - for (uint i = 0u; i < 2u; i++) - { - auto &usedList = _gpuCommandPool->usedCommandBuffers[i]; + for (uint i = 0u; i < 2u; i++) { + CachedArray &usedList = _gpuCommandPool->usedCommandBuffers[i]; _gpuCommandPool->commandBuffers[i].concat(usedList); usedList.clear(); } diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.h b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.h index e73065da4f..de714cbfc4 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.h +++ b/native/cocos/renderer/gfx-vulkan/VKCommandAllocator.h @@ -7,18 +7,18 @@ class CCVKGPUCommandPool; class CC_VULKAN_API CCVKCommandAllocator : public GFXCommandAllocator { public: - CCVKCommandAllocator(GFXDevice* device); + CCVKCommandAllocator(GFXDevice *device); ~CCVKCommandAllocator(); public: - bool initialize(const GFXCommandAllocatorInfo& info); + bool initialize(const GFXCommandAllocatorInfo &info); void destroy(); - CC_INLINE CCVKGPUCommandPool* gpuCommandPool() { return _gpuCommandPool; } + CC_INLINE CCVKGPUCommandPool *gpuCommandPool() { return _gpuCommandPool; } void reset(); private: - CCVKGPUCommandPool* _gpuCommandPool; + CCVKGPUCommandPool *_gpuCommandPool; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cc b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cc index 235e7afe20..436e2e5424 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cc +++ b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cc @@ -1,31 +1,27 @@ #include "VKStd.h" + +#include "VKBindingLayout.h" +#include "VKBuffer.h" +#include "VKCommandAllocator.h" #include "VKCommandBuffer.h" #include "VKCommands.h" -#include "VKCommandAllocator.h" #include "VKFramebuffer.h" - -#include "VKBuffer.h" -#include "VKTexture.h" -#include "VKRenderPass.h" -#include "VKPipelineState.h" -#include "VKBindingLayout.h" #include "VKInputAssembler.h" +#include "VKPipelineState.h" +#include "VKRenderPass.h" +#include "VKTexture.h" NS_CC_BEGIN -CCVKCommandBuffer::CCVKCommandBuffer(GFXDevice* device) - : GFXCommandBuffer(device) -{ +CCVKCommandBuffer::CCVKCommandBuffer(GFXDevice *device) +: GFXCommandBuffer(device) { } -CCVKCommandBuffer::~CCVKCommandBuffer() -{ +CCVKCommandBuffer::~CCVKCommandBuffer() { } -bool CCVKCommandBuffer::initialize(const GFXCommandBufferInfo& info) -{ - if (!info.allocator) - { +bool CCVKCommandBuffer::initialize(const GFXCommandBufferInfo &info) { + if (!info.allocator) { return false; } @@ -34,18 +30,16 @@ bool CCVKCommandBuffer::initialize(const GFXCommandBufferInfo& info) _gpuCommandBuffer = CC_NEW(CCVKGPUCommandBuffer); _gpuCommandBuffer->type = _type; - _gpuCommandBuffer->commandPool = ((CCVKCommandAllocator*)_allocator)->gpuCommandPool(); - CCVKCmdFuncAllocateCommandBuffer((CCVKDevice*)_device, _gpuCommandBuffer); + _gpuCommandBuffer->commandPool = ((CCVKCommandAllocator *)_allocator)->gpuCommandPool(); + CCVKCmdFuncAllocateCommandBuffer((CCVKDevice *)_device, _gpuCommandBuffer); _status = GFXStatus::SUCCESS; return true; } -void CCVKCommandBuffer::destroy() -{ - if (_gpuCommandBuffer) - { - CCVKCmdFuncFreeCommandBuffer((CCVKDevice*)_device, _gpuCommandBuffer); +void CCVKCommandBuffer::destroy() { + if (_gpuCommandBuffer) { + CCVKCmdFuncFreeCommandBuffer((CCVKDevice *)_device, _gpuCommandBuffer); CC_DELETE(_gpuCommandBuffer); _gpuCommandBuffer = nullptr; } @@ -54,8 +48,7 @@ void CCVKCommandBuffer::destroy() _status = GFXStatus::UNREADY; } -void CCVKCommandBuffer::begin(GFXRenderPass* renderPass, uint subpass, GFXFramebuffer* frameBuffer) -{ +void CCVKCommandBuffer::begin(GFXRenderPass *renderPass, uint subpass, GFXFramebuffer *frameBuffer) { _curGPUPipelineState = nullptr; _curGPUBindingLayout = nullptr; _curGPUInputAssember = nullptr; @@ -63,39 +56,34 @@ void CCVKCommandBuffer::begin(GFXRenderPass* renderPass, uint subpass, GFXFrameb _numInstances = 0; _numTriangles = 0; - VkCommandBufferBeginInfo beginInfo{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; + VkCommandBufferBeginInfo beginInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; - if (_type == GFXCommandBufferType::SECONDARY) - { - if (!renderPass) - { + if (_type == GFXCommandBufferType::SECONDARY) { + if (!renderPass) { CC_LOG_ERROR("RenderPass has to be specified when beginning secondary command buffers."); return; } - VkCommandBufferInheritanceInfo inheritanceInfo{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO }; - inheritanceInfo.renderPass = ((CCVKRenderPass*)renderPass)->gpuRenderPass()->vkRenderPass; + VkCommandBufferInheritanceInfo inheritanceInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO}; + inheritanceInfo.renderPass = ((CCVKRenderPass *)renderPass)->gpuRenderPass()->vkRenderPass; inheritanceInfo.subpass = subpass; - if (frameBuffer) inheritanceInfo.framebuffer = ((CCVKFramebuffer*)frameBuffer)->gpuFBO()->vkFramebuffer; + if (frameBuffer) inheritanceInfo.framebuffer = ((CCVKFramebuffer *)frameBuffer)->gpuFBO()->vkFramebuffer; beginInfo.pInheritanceInfo = &inheritanceInfo; } VK_CHECK(vkBeginCommandBuffer(_gpuCommandBuffer->vkCommandBuffer, &beginInfo)); } -void CCVKCommandBuffer::end() -{ +void CCVKCommandBuffer::end() { _curGPUFBO = nullptr; VK_CHECK(vkEndCommandBuffer(_gpuCommandBuffer->vkCommandBuffer)); } -void CCVKCommandBuffer::beginRenderPass(GFXFramebuffer* fbo, const GFXRect& renderArea, - GFXClearFlags clearFlags, const std::vector& colors, float depth, int stencil) -{ - _curGPUFBO = ((CCVKFramebuffer*)fbo)->gpuFBO(); +void CCVKCommandBuffer::beginRenderPass(GFXFramebuffer *fbo, const GFXRect &renderArea, + GFXClearFlags clearFlags, const std::vector &colors, float depth, int stencil) { + _curGPUFBO = ((CCVKFramebuffer *)fbo)->gpuFBO(); CCVKGPURenderPass *renderPass = _curGPUFBO->gpuRenderPass; VkFramebuffer framebuffer = _curGPUFBO->vkFramebuffer; - if (!_curGPUFBO->isOffscreen) - { + if (!_curGPUFBO->isOffscreen) { renderPass = _curGPUFBO->swapchain->renderPass; framebuffer = _curGPUFBO->swapchain->vkSwapchainFramebuffers[_curGPUFBO->swapchain->curImageIndex]; } @@ -104,25 +92,21 @@ void CCVKCommandBuffer::beginRenderPass(GFXFramebuffer* fbo, const GFXRect& rend vector::type &clearValues = renderPass->clearValues; size_t attachmentCount = barriers.size(); - if (attachmentCount) - { - for (size_t i = 0u; i < attachmentCount - 1; i++) - { - barriers[i].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuColorViews[i]->gpuTexture->vkImage : - _curGPUFBO->swapchain->swapchainImages[_curGPUFBO->swapchain->curImageIndex]; - clearValues[i].color = { colors[i].r, colors[i].g, colors[i].b, colors[i].a }; + if (attachmentCount) { + for (size_t i = 0u; i < attachmentCount - 1; i++) { + barriers[i].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuColorViews[i]->gpuTexture->vkImage : _curGPUFBO->swapchain->swapchainImages[_curGPUFBO->swapchain->curImageIndex]; + clearValues[i].color = {colors[i].r, colors[i].g, colors[i].b, colors[i].a}; } - barriers[attachmentCount - 1].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuDepthStencilView->gpuTexture->vkImage : - _curGPUFBO->swapchain->depthStencilImages[_curGPUFBO->swapchain->curImageIndex]; - clearValues[attachmentCount - 1].depthStencil = { depth, (uint)stencil }; + barriers[attachmentCount - 1].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuDepthStencilView->gpuTexture->vkImage : _curGPUFBO->swapchain->depthStencilImages[_curGPUFBO->swapchain->curImageIndex]; + clearValues[attachmentCount - 1].depthStencil = {depth, (uint)stencil}; // transition to COLOR_ATTACHMENT_OPTIMAL vkCmdPipelineBarrier(_gpuCommandBuffer->vkCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, - VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, attachmentCount, barriers.data()); + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, + VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, attachmentCount, barriers.data()); } - VkRenderPassBeginInfo passBeginInfo{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO }; + VkRenderPassBeginInfo passBeginInfo{VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO}; passBeginInfo.renderPass = renderPass->vkRenderPass; passBeginInfo.framebuffer = framebuffer; passBeginInfo.renderArea.offset.x = renderArea.x; @@ -134,15 +118,14 @@ void CCVKCommandBuffer::beginRenderPass(GFXFramebuffer* fbo, const GFXRect& rend vkCmdBeginRenderPass(_gpuCommandBuffer->vkCommandBuffer, &passBeginInfo, VK_SUBPASS_CONTENTS_INLINE); - VkViewport viewport{ (float)renderArea.x, (float)renderArea.y, (float)renderArea.width, (float)renderArea.height, 0, 1 }; + VkViewport viewport{(float)renderArea.x, (float)renderArea.y, (float)renderArea.width, (float)renderArea.height, 0, 1}; vkCmdSetViewport(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &viewport); - VkRect2D scissor{ { renderArea.x, renderArea.y }, { renderArea.width, renderArea.height } }; + VkRect2D scissor{{renderArea.x, renderArea.y}, {renderArea.width, renderArea.height}}; vkCmdSetScissor(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &scissor); } -void CCVKCommandBuffer::endRenderPass() -{ +void CCVKCommandBuffer::endRenderPass() { vkCmdEndRenderPass(_gpuCommandBuffer->vkCommandBuffer); //CCVKGPURenderPass *renderPass = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuRenderPass : _curGPUFBO->swapchain->renderPass; @@ -168,102 +151,84 @@ void CCVKCommandBuffer::endRenderPass() _curGPUFBO = nullptr; } -void CCVKCommandBuffer::bindPipelineState(GFXPipelineState* pso) -{ - CCVKGPUPipelineState* gpuPipelineState = ((CCVKPipelineState*)pso)->gpuPipelineState(); +void CCVKCommandBuffer::bindPipelineState(GFXPipelineState *pso) { + CCVKGPUPipelineState *gpuPipelineState = ((CCVKPipelineState *)pso)->gpuPipelineState(); - if (_curGPUPipelineState != gpuPipelineState) - { + if (_curGPUPipelineState != gpuPipelineState) { vkCmdBindPipeline(_gpuCommandBuffer->vkCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, gpuPipelineState->vkPipeline); _curGPUPipelineState = gpuPipelineState; } } -void CCVKCommandBuffer::bindBindingLayout(GFXBindingLayout* layout) -{ - if (!_curGPUPipelineState) - { +void CCVKCommandBuffer::bindBindingLayout(GFXBindingLayout *layout) { + if (!_curGPUPipelineState) { CC_LOG_ERROR("Command 'bindBindingLayout' must be recorded after 'bindPipelineState'."); return; } - CCVKGPUBindingLayout* gpuBindingLayout = ((CCVKBindingLayout*)layout)->gpuBindingLayout(); + CCVKGPUBindingLayout *gpuBindingLayout = ((CCVKBindingLayout *)layout)->gpuBindingLayout(); - if (_curGPUBindingLayout != gpuBindingLayout) - { + if (_curGPUBindingLayout != gpuBindingLayout) { vkCmdBindDescriptorSets(_gpuCommandBuffer->vkCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, - _curGPUPipelineState->gpuLayout->vkPipelineLayout, 0, 1, &gpuBindingLayout->vkDescriptorSet, 0, nullptr); + _curGPUPipelineState->gpuLayout->vkPipelineLayout, 0, 1, &gpuBindingLayout->vkDescriptorSet, 0, nullptr); _curGPUBindingLayout = gpuBindingLayout; } } -void CCVKCommandBuffer::bindInputAssembler(GFXInputAssembler* ia) -{ - CCVKGPUInputAssembler* gpuInputAssembler = ((CCVKInputAssembler*)ia)->gpuInputAssembler(); +void CCVKCommandBuffer::bindInputAssembler(GFXInputAssembler *ia) { + CCVKGPUInputAssembler *gpuInputAssembler = ((CCVKInputAssembler *)ia)->gpuInputAssembler(); - if (_curGPUInputAssember != gpuInputAssembler) - { + if (_curGPUInputAssember != gpuInputAssembler) { // buffers may be rebuilt(e.g. resize event) without IA's acknowledge size_t vbCount = gpuInputAssembler->gpuVertexBuffers.size(); - if (gpuInputAssembler->vertexBuffers.size() < vbCount) - { + if (gpuInputAssembler->vertexBuffers.size() < vbCount) { gpuInputAssembler->vertexBuffers.resize(vbCount); gpuInputAssembler->vertexBufferOffsets.resize(vbCount); } - for (size_t i = 0; i < vbCount; i++) - { + for (size_t i = 0; i < vbCount; i++) { gpuInputAssembler->vertexBuffers[i] = gpuInputAssembler->gpuVertexBuffers[i]->vkBuffer; gpuInputAssembler->vertexBufferOffsets[i] = gpuInputAssembler->gpuVertexBuffers[i]->startOffset; } vkCmdBindVertexBuffers(_gpuCommandBuffer->vkCommandBuffer, 0, vbCount, - gpuInputAssembler->vertexBuffers.data(), gpuInputAssembler->vertexBufferOffsets.data()); + gpuInputAssembler->vertexBuffers.data(), gpuInputAssembler->vertexBufferOffsets.data()); - if (gpuInputAssembler->gpuIndexBuffer) - { + if (gpuInputAssembler->gpuIndexBuffer) { vkCmdBindIndexBuffer(_gpuCommandBuffer->vkCommandBuffer, gpuInputAssembler->gpuIndexBuffer->vkBuffer, 0, - gpuInputAssembler->gpuIndexBuffer->stride == 32 ? VK_INDEX_TYPE_UINT32 : VK_INDEX_TYPE_UINT16); + gpuInputAssembler->gpuIndexBuffer->stride == 32 ? VK_INDEX_TYPE_UINT32 : VK_INDEX_TYPE_UINT16); } _curGPUInputAssember = gpuInputAssembler; } } -void CCVKCommandBuffer::setViewport(const GFXViewport& vp) -{ - if (_curViewport != vp) - { +void CCVKCommandBuffer::setViewport(const GFXViewport &vp) { + if (_curViewport != vp) { _curViewport = vp; - VkViewport viewport{ (float)vp.left, (float)vp.top, (float)vp.width, (float)vp.height, vp.minDepth, vp.maxDepth }; + VkViewport viewport{(float)vp.left, (float)vp.top, (float)vp.width, (float)vp.height, vp.minDepth, vp.maxDepth}; vkCmdSetViewport(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &viewport); } } -void CCVKCommandBuffer::setScissor(const GFXRect& rect) -{ - if (_curScissor != rect) - { +void CCVKCommandBuffer::setScissor(const GFXRect &rect) { + if (_curScissor != rect) { _curScissor = rect; - VkRect2D scissor{ { rect.x, rect.y }, { rect.width, rect.height } }; + VkRect2D scissor{{rect.x, rect.y}, {rect.width, rect.height}}; vkCmdSetScissor(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &scissor); } } -void CCVKCommandBuffer::setLineWidth(const float width) -{ - if (math::IsNotEqualF(_curLineWidth, width)) - { +void CCVKCommandBuffer::setLineWidth(const float width) { + if (math::IsNotEqualF(_curLineWidth, width)) { _curLineWidth = width; vkCmdSetLineWidth(_gpuCommandBuffer->vkCommandBuffer, width); } } -void CCVKCommandBuffer::setDepthBias(float constant, float clamp, float slope) -{ +void CCVKCommandBuffer::setDepthBias(float constant, float clamp, float slope) { if (math::IsNotEqualF(_curDepthBias.constant, constant) || math::IsNotEqualF(_curDepthBias.clamp, clamp) || - math::IsNotEqualF(_curDepthBias.slope, slope)) - { + math::IsNotEqualF(_curDepthBias.slope, slope)) { _curDepthBias.constant = constant; _curDepthBias.clamp = clamp; _curDepthBias.slope = slope; @@ -271,50 +236,42 @@ void CCVKCommandBuffer::setDepthBias(float constant, float clamp, float slope) } } -void CCVKCommandBuffer::setBlendConstants(const GFXColor& constants) -{ +void CCVKCommandBuffer::setBlendConstants(const GFXColor &constants) { if (math::IsNotEqualF(_curBlendConstants.r, constants.r) || math::IsNotEqualF(_curBlendConstants.g, constants.g) || math::IsNotEqualF(_curBlendConstants.b, constants.b) || - math::IsNotEqualF(_curBlendConstants.a, constants.a)) - { + math::IsNotEqualF(_curBlendConstants.a, constants.a)) { _curBlendConstants.r = constants.r; _curBlendConstants.g = constants.g; _curBlendConstants.b = constants.b; _curBlendConstants.a = constants.a; - vkCmdSetBlendConstants(_gpuCommandBuffer->vkCommandBuffer, reinterpret_cast(&constants)); + vkCmdSetBlendConstants(_gpuCommandBuffer->vkCommandBuffer, reinterpret_cast(&constants)); } } -void CCVKCommandBuffer::setDepthBound(float minBounds, float maxBounds) -{ +void CCVKCommandBuffer::setDepthBound(float minBounds, float maxBounds) { if (math::IsNotEqualF(_curDepthBounds.minBounds, minBounds) || - math::IsNotEqualF(_curDepthBounds.maxBounds, maxBounds)) - { + math::IsNotEqualF(_curDepthBounds.maxBounds, maxBounds)) { _curDepthBounds.minBounds = minBounds; _curDepthBounds.maxBounds = maxBounds; vkCmdSetDepthBounds(_gpuCommandBuffer->vkCommandBuffer, minBounds, maxBounds); } } -void CCVKCommandBuffer::setStencilWriteMask(GFXStencilFace face, uint mask) -{ +void CCVKCommandBuffer::setStencilWriteMask(GFXStencilFace face, uint mask) { if ((_curStencilWriteMask.face != face) || - (_curStencilWriteMask.write_mask != mask)) - { + (_curStencilWriteMask.write_mask != mask)) { _curStencilWriteMask.face = face; _curStencilWriteMask.write_mask = mask; vkCmdSetStencilWriteMask(_gpuCommandBuffer->vkCommandBuffer, - face == GFXStencilFace::FRONT ? VK_STENCIL_FACE_FRONT_BIT : VK_STENCIL_FACE_BACK_BIT, mask); + face == GFXStencilFace::FRONT ? VK_STENCIL_FACE_FRONT_BIT : VK_STENCIL_FACE_BACK_BIT, mask); } } -void CCVKCommandBuffer::setStencilCompareMask(GFXStencilFace face, int reference, uint mask) -{ +void CCVKCommandBuffer::setStencilCompareMask(GFXStencilFace face, int reference, uint mask) { if ((_curStencilCompareMask.face != face) || (_curStencilCompareMask.reference != reference) || - (_curStencilCompareMask.compareMask != mask)) - { + (_curStencilCompareMask.compareMask != mask)) { _curStencilCompareMask.face = face; _curStencilCompareMask.reference = reference; _curStencilCompareMask.compareMask = mask; @@ -325,68 +282,56 @@ void CCVKCommandBuffer::setStencilCompareMask(GFXStencilFace face, int reference } } -void CCVKCommandBuffer::draw(GFXInputAssembler* ia) -{ +void CCVKCommandBuffer::draw(GFXInputAssembler *ia) { if ((_type == GFXCommandBufferType::PRIMARY && _curGPUFBO) || - (_type == GFXCommandBufferType::SECONDARY)) - { - CCVKGPUInputAssembler* gpuInputAssembler = ((CCVKInputAssembler*)ia)->gpuInputAssembler(); + (_type == GFXCommandBufferType::SECONDARY)) { + CCVKGPUInputAssembler *gpuInputAssembler = ((CCVKInputAssembler *)ia)->gpuInputAssembler(); GFXDrawInfo drawInfo; - if (gpuInputAssembler->gpuIndirectBuffer) - { + if (gpuInputAssembler->gpuIndirectBuffer) { // TODO - } - else - { - ((CCVKInputAssembler*)ia)->extractDrawInfo(drawInfo); + } else { + ((CCVKInputAssembler *)ia)->extractDrawInfo(drawInfo); uint instanceCount = std::max(drawInfo.instanceCount, 1u); bool hasIndexBuffer = gpuInputAssembler->gpuIndexBuffer && drawInfo.indexCount >= 0; - if (hasIndexBuffer) - { + if (hasIndexBuffer) { vkCmdDrawIndexed(_gpuCommandBuffer->vkCommandBuffer, drawInfo.indexCount, instanceCount, - drawInfo.firstIndex, drawInfo.vertexOffset, drawInfo.firstInstance); - } - else - { + drawInfo.firstIndex, drawInfo.vertexOffset, drawInfo.firstInstance); + } else { vkCmdDraw(_gpuCommandBuffer->vkCommandBuffer, drawInfo.vertexCount, instanceCount, - drawInfo.firstVertex, drawInfo.firstInstance); + drawInfo.firstVertex, drawInfo.firstInstance); } ++_numDrawCalls; _numInstances += drawInfo.instanceCount; - if (_curGPUPipelineState) - { + if (_curGPUPipelineState) { uint indexCount = hasIndexBuffer ? drawInfo.indexCount : drawInfo.vertexCount; - switch (_curGPUPipelineState->primitive) - { - case GFXPrimitiveMode::TRIANGLE_LIST: - _numTriangles += indexCount / 3 * instanceCount; - break; - case GFXPrimitiveMode::TRIANGLE_STRIP: - case GFXPrimitiveMode::TRIANGLE_FAN: - _numTriangles += (indexCount - 2) * instanceCount; - break; + switch (_curGPUPipelineState->primitive) { + case GFXPrimitiveMode::TRIANGLE_LIST: + _numTriangles += indexCount / 3 * instanceCount; + break; + case GFXPrimitiveMode::TRIANGLE_STRIP: + case GFXPrimitiveMode::TRIANGLE_FAN: + _numTriangles += (indexCount - 2) * instanceCount; + break; } } } - } - else - { + } else { CC_LOG_ERROR("Command 'draw' must be recorded inside a render pass."); } } -void CCVKCommandBuffer::execute(const std::vector& cmdBuffs, uint count) -{ - if (!count) { return; } +void CCVKCommandBuffer::execute(const std::vector &cmdBuffs, uint count) { + if (!count) { + return; + } vector::type vkCmdBuffs(count); - for (uint i = 0; i < count; ++i) - { - CCVKCommandBuffer* cmdBuff = (CCVKCommandBuffer*)cmdBuffs[i]; + for (uint i = 0; i < count; ++i) { + CCVKCommandBuffer *cmdBuff = (CCVKCommandBuffer *)cmdBuffs[i]; vkCmdBuffs[i] = cmdBuff->_gpuCommandBuffer->vkCommandBuffer; _numDrawCalls += cmdBuff->getNumDrawCalls(); @@ -397,31 +342,23 @@ void CCVKCommandBuffer::execute(const std::vector& cmdBuffs, vkCmdExecuteCommands(_gpuCommandBuffer->vkCommandBuffer, count, vkCmdBuffs.data()); } -void CCVKCommandBuffer::updateBuffer(GFXBuffer* buff, void* data, uint size, uint offset) -{ +void CCVKCommandBuffer::updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset) { if ((_type == GFXCommandBufferType::PRIMARY && !_curGPUFBO) || - (_type == GFXCommandBufferType::SECONDARY)) - { - CCVKCmdFuncUpdateBuffer((CCVKDevice*)_device, ((CCVKBuffer*)buff)->gpuBuffer(), data, offset, size); - } - else - { + (_type == GFXCommandBufferType::SECONDARY)) { + CCVKCmdFuncUpdateBuffer((CCVKDevice *)_device, ((CCVKBuffer *)buff)->gpuBuffer(), data, offset, size); + } else { CC_LOG_ERROR("Command 'updateBuffer' must be recorded outside a render pass."); } } -void CCVKCommandBuffer::copyBufferToTexture(GFXBuffer* src, GFXTexture* dst, GFXTextureLayout layout, const GFXBufferTextureCopyList& regions) -{ +void CCVKCommandBuffer::copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions) { if ((_type == GFXCommandBufferType::PRIMARY && !_curGPUFBO) || - (_type == GFXCommandBufferType::SECONDARY)) - { + (_type == GFXCommandBufferType::SECONDARY)) { //const CCVKGPUBuffer* gpuBuffer = ((CCVKBuffer*)src)->gpuBuffer(); //const CCVKGPUTexture* gpuTexture = ((CCVKTexture*)dst)->gpuTexture(); //vkCmdCopyBufferToImage(_gpuCommandBuffer->vkCommandBuffer, gpuBuffer->vkBuffer, gpuTexture->vkImage, MapVkImageLayout(layout), // regions.size(), regions.data()); - } - else - { + } else { CC_LOG_ERROR("Command 'copyBufferToTexture' must be recorded outside a render pass."); } } diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.h b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.h index adcb9ceec1..f5760ac1d7 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.h +++ b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.h @@ -5,47 +5,46 @@ NS_CC_BEGIN -class CC_VULKAN_API CCVKCommandBuffer : public GFXCommandBuffer -{ +class CC_VULKAN_API CCVKCommandBuffer : public GFXCommandBuffer { public: - CCVKCommandBuffer(GFXDevice* device); + CCVKCommandBuffer(GFXDevice *device); ~CCVKCommandBuffer(); friend class CCVKQueue; public: - bool initialize(const GFXCommandBufferInfo& info); + bool initialize(const GFXCommandBufferInfo &info); void destroy(); - void begin(GFXRenderPass* renderPass = nullptr, uint subpass = 0, GFXFramebuffer* frameBuffer = nullptr); + void begin(GFXRenderPass *renderPass = nullptr, uint subpass = 0, GFXFramebuffer *frameBuffer = nullptr); void end(); - void beginRenderPass(GFXFramebuffer* fbo, const GFXRect& render_area, GFXClearFlags clear_flags, const std::vector& colors, float depth, int stencil); + void beginRenderPass(GFXFramebuffer *fbo, const GFXRect &render_area, GFXClearFlags clear_flags, const std::vector &colors, float depth, int stencil); void endRenderPass(); - void bindPipelineState(GFXPipelineState* pso); - void bindBindingLayout(GFXBindingLayout* layout); - void bindInputAssembler(GFXInputAssembler* ia); - void setViewport(const GFXViewport& vp); - void setScissor(const GFXRect& rect); + void bindPipelineState(GFXPipelineState *pso); + void bindBindingLayout(GFXBindingLayout *layout); + void bindInputAssembler(GFXInputAssembler *ia); + void setViewport(const GFXViewport &vp); + void setScissor(const GFXRect &rect); void setLineWidth(const float width); void setDepthBias(float constant, float clamp, float slope); - void setBlendConstants(const GFXColor& constants); + void setBlendConstants(const GFXColor &constants); void setDepthBound(float min_bounds, float max_bounds); void setStencilWriteMask(GFXStencilFace face, uint mask); void setStencilCompareMask(GFXStencilFace face, int reference, uint mask); - void draw(GFXInputAssembler* ia); - void updateBuffer(GFXBuffer* buff, void* data, uint size, uint offset); - void copyBufferToTexture(GFXBuffer* src, GFXTexture* dst, GFXTextureLayout layout, const GFXBufferTextureCopyList& regions); - void execute(const std::vector& cmd_buffs, uint count); + void draw(GFXInputAssembler *ia); + void updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset); + void copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions); + void execute(const std::vector &cmd_buffs, uint count); - CCVKGPUCommandBuffer* gpuCommandBuffer() const { return _gpuCommandBuffer; } + CCVKGPUCommandBuffer *gpuCommandBuffer() const { return _gpuCommandBuffer; } private: - CCVKGPUCommandBuffer* _gpuCommandBuffer = nullptr; + CCVKGPUCommandBuffer *_gpuCommandBuffer = nullptr; - CCVKGPUPipelineState* _curGPUPipelineState = nullptr; - CCVKGPUBindingLayout* _curGPUBindingLayout = nullptr; - CCVKGPUInputAssembler* _curGPUInputAssember = nullptr; - CCVKGPUFramebuffer* _curGPUFBO = nullptr; + CCVKGPUPipelineState *_curGPUPipelineState = nullptr; + CCVKGPUBindingLayout *_curGPUBindingLayout = nullptr; + CCVKGPUInputAssembler *_curGPUInputAssember = nullptr; + CCVKGPUFramebuffer *_curGPUFBO = nullptr; GFXViewport _curViewport; GFXRect _curScissor; diff --git a/native/cocos/renderer/gfx-vulkan/VKCommands.cc b/native/cocos/renderer/gfx-vulkan/VKCommands.cc index 3ecc4a7add..2be77a25a7 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommands.cc +++ b/native/cocos/renderer/gfx-vulkan/VKCommands.cc @@ -1,60 +1,55 @@ #include "VKStd.h" + +#include "VKBuffer.h" +#include "VKCommandAllocator.h" #include "VKCommands.h" +#include "VKContext.h" #include "VKDevice.h" #include "VKQueue.h" -#include "VKContext.h" -#include "VKCommandAllocator.h" #include "VKSPIRV.h" -#include "VKBuffer.h" -#define BUFFER_OFFSET(idx) (static_cast(0) + (idx)) +#define BUFFER_OFFSET(idx) (static_cast(0) + (idx)) NS_CC_BEGIN -void InsertVkDynamicStates(vector::type& out, const vector::type& dynamicStates) -{ - for (GFXDynamicState dynamicState : dynamicStates) - { - switch (dynamicState) - { - case GFXDynamicState::VIEWPORT: break; // we make this dynamic by default - case GFXDynamicState::SCISSOR: break; // we make this dynamic by default - case GFXDynamicState::LINE_WIDTH: out.push_back(VK_DYNAMIC_STATE_LINE_WIDTH); break; - case GFXDynamicState::DEPTH_BIAS: out.push_back(VK_DYNAMIC_STATE_DEPTH_BIAS); break; - case GFXDynamicState::BLEND_CONSTANTS: out.push_back(VK_DYNAMIC_STATE_BLEND_CONSTANTS); break; - case GFXDynamicState::DEPTH_BOUNDS: out.push_back(VK_DYNAMIC_STATE_DEPTH_BOUNDS); break; - case GFXDynamicState::STENCIL_WRITE_MASK: out.push_back(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK); break; - case GFXDynamicState::STENCIL_COMPARE_MASK: - out.push_back(VK_DYNAMIC_STATE_STENCIL_REFERENCE); - out.push_back(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK); - break; - default: - { - CCASSERT(false, "Unsupported GFXPrimitiveMode, convert to VkPrimitiveTopology failed."); - break; - } +void InsertVkDynamicStates(vector::type &out, const vector::type &dynamicStates) { + for (GFXDynamicState dynamicState : dynamicStates) { + switch (dynamicState) { + case GFXDynamicState::VIEWPORT: break; // we make this dynamic by default + case GFXDynamicState::SCISSOR: break; // we make this dynamic by default + case GFXDynamicState::LINE_WIDTH: out.push_back(VK_DYNAMIC_STATE_LINE_WIDTH); break; + case GFXDynamicState::DEPTH_BIAS: out.push_back(VK_DYNAMIC_STATE_DEPTH_BIAS); break; + case GFXDynamicState::BLEND_CONSTANTS: out.push_back(VK_DYNAMIC_STATE_BLEND_CONSTANTS); break; + case GFXDynamicState::DEPTH_BOUNDS: out.push_back(VK_DYNAMIC_STATE_DEPTH_BOUNDS); break; + case GFXDynamicState::STENCIL_WRITE_MASK: out.push_back(VK_DYNAMIC_STATE_STENCIL_WRITE_MASK); break; + case GFXDynamicState::STENCIL_COMPARE_MASK: + out.push_back(VK_DYNAMIC_STATE_STENCIL_REFERENCE); + out.push_back(VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK); + break; + default: { + CCASSERT(false, "Unsupported GFXPrimitiveMode, convert to VkPrimitiveTopology failed."); + break; + } } } } -void beginOneTimeCommands(CCVKDevice* device, CCVKGPUCommandBuffer* cmdBuff) -{ - cmdBuff->commandPool = ((CCVKCommandAllocator*)device->getCommandAllocator())->gpuCommandPool(); +void beginOneTimeCommands(CCVKDevice *device, CCVKGPUCommandBuffer *cmdBuff) { + cmdBuff->commandPool = ((CCVKCommandAllocator *)device->getCommandAllocator())->gpuCommandPool(); cmdBuff->type = GFXCommandBufferType::PRIMARY; CCVKCmdFuncAllocateCommandBuffer(device, cmdBuff); - VkCommandBufferBeginInfo beginInfo{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO }; + VkCommandBufferBeginInfo beginInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO}; beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; VK_CHECK(vkBeginCommandBuffer(cmdBuff->vkCommandBuffer, &beginInfo)); } -void endOneTimeCommands(CCVKDevice* device, CCVKGPUCommandBuffer* cmdBuff) -{ +void endOneTimeCommands(CCVKDevice *device, CCVKGPUCommandBuffer *cmdBuff) { VK_CHECK(vkEndCommandBuffer(cmdBuff->vkCommandBuffer)); VkFence fence = device->gpuFencePool()->alloc(); - const CCVKGPUQueue* queue = ((CCVKQueue*)device->getQueue())->gpuQueue(); - VkSubmitInfo submitInfo{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; + const CCVKGPUQueue *queue = ((CCVKQueue *)device->getQueue())->gpuQueue(); + VkSubmitInfo submitInfo{VK_STRUCTURE_TYPE_SUBMIT_INFO}; submitInfo.commandBufferCount = 1; submitInfo.pCommandBuffers = &cmdBuff->vkCommandBuffer; VK_CHECK(vkQueueSubmit(queue->vkQueue, 1, &submitInfo, fence)); @@ -72,9 +67,8 @@ void insertImageMemoryBarrior( VkImageLayout newImageLayout, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, - VkImageSubresourceRange subresourceRange) -{ - VkImageMemoryBarrier barrier{ VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER }; + VkImageSubresourceRange subresourceRange) { + VkImageMemoryBarrier barrier{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER}; barrier.image = image; barrier.srcAccessMask = srcAccessMask; barrier.dstAccessMask = dstAccessMask; @@ -85,21 +79,19 @@ void insertImageMemoryBarrior( barrier.subresourceRange = subresourceRange; vkCmdPipelineBarrier(cmdBuffer, - srcStageMask, dstStageMask, 0, - 0, nullptr, - 0, nullptr, - 1, &barrier); + srcStageMask, dstStageMask, 0, + 0, nullptr, + 0, nullptr, + 1, &barrier); } -void CCVKCmdFuncCreateRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRenderPass) -{ +void CCVKCmdFuncCreateRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRenderPass) { size_t colorAttachmentCount = gpuRenderPass->colorAttachments.size(); vector::type attachmentDescriptions(colorAttachmentCount + 1); gpuRenderPass->clearValues.resize(colorAttachmentCount + 1); - gpuRenderPass->beginBarriers.resize(colorAttachmentCount + 1, { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER }); - gpuRenderPass->endBarriers.resize(colorAttachmentCount + 1, { VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER }); - for (size_t i = 0u; i < colorAttachmentCount; i++) - { + gpuRenderPass->beginBarriers.resize(colorAttachmentCount + 1, {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER}); + gpuRenderPass->endBarriers.resize(colorAttachmentCount + 1, {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER}); + for (size_t i = 0u; i < colorAttachmentCount; i++) { const GFXColorAttachment &attachment = gpuRenderPass->colorAttachments[i]; const VkImageLayout beginLayout = MapVkImageLayout(attachment.beginLayout); const VkImageLayout endLayout = MapVkImageLayout(attachment.endLayout); @@ -141,8 +133,7 @@ void CCVKCmdFuncCreateRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRende const VkImageLayout endLayout = MapVkImageLayout(depthStencilAttachment.endLayout); const VkAccessFlags beginAccessMask = MapVkAccessFlags(depthStencilAttachment.beginLayout); const VkAccessFlags endAccessMask = MapVkAccessFlags(depthStencilAttachment.endLayout); - const VkImageAspectFlags aspectMask = GFX_FORMAT_INFOS[(uint)depthStencilAttachment.format].hasStencil ? - VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT; + const VkImageAspectFlags aspectMask = GFX_FORMAT_INFOS[(uint)depthStencilAttachment.format].hasStencil ? VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT; attachmentDescriptions[colorAttachmentCount].format = MapVkFormat(depthStencilAttachment.format); attachmentDescriptions[colorAttachmentCount].samples = MapVkSampleCount(depthStencilAttachment.sampleCount); attachmentDescriptions[colorAttachmentCount].loadOp = MapVkLoadOp(depthStencilAttachment.depthLoadOp); @@ -175,31 +166,28 @@ void CCVKCmdFuncCreateRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRende endBarrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; size_t subpassCount = gpuRenderPass->subPasses.size(); - vector::type subpassDescriptions(1, { VK_PIPELINE_BIND_POINT_GRAPHICS }); + vector::type subpassDescriptions(1, {VK_PIPELINE_BIND_POINT_GRAPHICS}); vector::type attachmentReferences; if (subpassCount) // pass on user-specified subpasses { subpassDescriptions.resize(subpassCount); - for (size_t i = 0u; i < subpassCount; i++) - { + for (size_t i = 0u; i < subpassCount; i++) { const GFXSubPass &subpass = gpuRenderPass->subPasses[i]; subpassDescriptions[i].pipelineBindPoint = MapVkPipelineBindPoint(subpass.bindPoint); // TODO } - } - else // generate a default subpass from attachment info + } else // generate a default subpass from attachment info { - for (size_t i = 0u; i < colorAttachmentCount; i++) - { - attachmentReferences.push_back({ i, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL }); + for (size_t i = 0u; i < colorAttachmentCount; i++) { + attachmentReferences.push_back({i, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL}); } - attachmentReferences.push_back({ colorAttachmentCount, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL }); + attachmentReferences.push_back({colorAttachmentCount, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL}); subpassDescriptions[0].colorAttachmentCount = attachmentReferences.size() - 1; subpassDescriptions[0].pColorAttachments = attachmentReferences.data(); subpassDescriptions[0].pDepthStencilAttachment = &attachmentReferences.back(); } - VkRenderPassCreateInfo renderPassCreateInfo{ VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO }; + VkRenderPassCreateInfo renderPassCreateInfo{VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO}; renderPassCreateInfo.attachmentCount = attachmentDescriptions.size(); renderPassCreateInfo.pAttachments = attachmentDescriptions.data(); renderPassCreateInfo.subpassCount = subpassDescriptions.size(); @@ -208,35 +196,32 @@ void CCVKCmdFuncCreateRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRende VK_CHECK(vkCreateRenderPass(device->gpuDevice()->vkDevice, &renderPassCreateInfo, nullptr, &gpuRenderPass->vkRenderPass)); } -void CCVKCmdFuncDestroyRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRenderPass) -{ - if (gpuRenderPass->vkRenderPass != VK_NULL_HANDLE) - { +void CCVKCmdFuncDestroyRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRenderPass) { + if (gpuRenderPass->vkRenderPass != VK_NULL_HANDLE) { vkDestroyRenderPass(device->gpuDevice()->vkDevice, gpuRenderPass->vkRenderPass, nullptr); gpuRenderPass->vkRenderPass = VK_NULL_HANDLE; } } -void CCVKCmdFuncGetDeviceQueue(CCVKDevice* device, CCVKGPUQueue* gpuQueue) -{ +void CCVKCmdFuncGetDeviceQueue(CCVKDevice *device, CCVKGPUQueue *gpuQueue) { uint queueType = 0u; VkBool32 needPresentable = VK_FALSE; - switch (gpuQueue->type) - { - case GFXQueueType::GRAPHICS: queueType = VK_QUEUE_GRAPHICS_BIT; needPresentable = VK_TRUE; break; - case GFXQueueType::COMPUTE: queueType = VK_QUEUE_COMPUTE_BIT; break; - case GFXQueueType::TRANSFER: queueType = VK_QUEUE_TRANSFER_BIT; break; + switch (gpuQueue->type) { + case GFXQueueType::GRAPHICS: + queueType = VK_QUEUE_GRAPHICS_BIT; + needPresentable = VK_TRUE; + break; + case GFXQueueType::COMPUTE: queueType = VK_QUEUE_COMPUTE_BIT; break; + case GFXQueueType::TRANSFER: queueType = VK_QUEUE_TRANSFER_BIT; break; } - const CCVKGPUContext* context = ((CCVKContext*)device->getContext())->gpuContext(); + const CCVKGPUContext *context = ((CCVKContext *)device->getContext())->gpuContext(); size_t queueCount = context->queueFamilyProperties.size(); - for (size_t i = 0u; i < queueCount; ++i) - { + for (size_t i = 0u; i < queueCount; ++i) { const VkQueueFamilyProperties &properties = context->queueFamilyProperties[i]; const VkBool32 isPresentable = context->queueFamilyPresentables[i]; - if (properties.queueCount > 0 && (properties.queueFlags & queueType) && (!needPresentable || isPresentable)) - { + if (properties.queueCount > 0 && (properties.queueFlags & queueType) && (!needPresentable || isPresentable)) { vkGetDeviceQueue(device->gpuDevice()->vkDevice, i, 0, &gpuQueue->vkQueue); gpuQueue->queueFamilyIndex = i; break; @@ -244,36 +229,29 @@ void CCVKCmdFuncGetDeviceQueue(CCVKDevice* device, CCVKGPUQueue* gpuQueue) } } -void CCVKCmdFuncCreateCommandPool(CCVKDevice* device, CCVKGPUCommandPool* gpuCommandPool) -{ - VkCommandPoolCreateInfo createInfo{ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO }; - createInfo.queueFamilyIndex = ((CCVKQueue*)device->getQueue())->gpuQueue()->queueFamilyIndex; +void CCVKCmdFuncCreateCommandPool(CCVKDevice *device, CCVKGPUCommandPool *gpuCommandPool) { + VkCommandPoolCreateInfo createInfo{VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO}; + createInfo.queueFamilyIndex = ((CCVKQueue *)device->getQueue())->gpuQueue()->queueFamilyIndex; createInfo.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; VK_CHECK(vkCreateCommandPool(device->gpuDevice()->vkDevice, &createInfo, nullptr, &gpuCommandPool->vkCommandPool)); } -void CCVKCmdFuncDestroyCommandPool(CCVKDevice* device, CCVKGPUCommandPool* gpuCommandPool) -{ - if (gpuCommandPool->vkCommandPool != VK_NULL_HANDLE) - { +void CCVKCmdFuncDestroyCommandPool(CCVKDevice *device, CCVKGPUCommandPool *gpuCommandPool) { + if (gpuCommandPool->vkCommandPool != VK_NULL_HANDLE) { vkDestroyCommandPool(device->gpuDevice()->vkDevice, gpuCommandPool->vkCommandPool, nullptr); gpuCommandPool->vkCommandPool = VK_NULL_HANDLE; } } -void CCVKCmdFuncAllocateCommandBuffer(CCVKDevice* device, CCVKGPUCommandBuffer* gpuCommandBuffer) -{ - CCVKGPUCommandPool* commandPool = gpuCommandBuffer->commandPool; +void CCVKCmdFuncAllocateCommandBuffer(CCVKDevice *device, CCVKGPUCommandBuffer *gpuCommandBuffer) { + CCVKGPUCommandPool *commandPool = gpuCommandBuffer->commandPool; CachedArray &availableList = commandPool->commandBuffers[(uint)gpuCommandBuffer->type]; - if (availableList.size()) - { + if (availableList.size()) { gpuCommandBuffer->vkCommandBuffer = availableList.pop(); - } - else - { - VkCommandBufferAllocateInfo allocateInfo{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO }; + } else { + VkCommandBufferAllocateInfo allocateInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO}; allocateInfo.commandPool = commandPool->vkCommandPool; allocateInfo.commandBufferCount = 1; allocateInfo.level = MapVkCommandBufferLevel(gpuCommandBuffer->type); @@ -282,72 +260,59 @@ void CCVKCmdFuncAllocateCommandBuffer(CCVKDevice* device, CCVKGPUCommandBuffer* } } -void CCVKCmdFuncFreeCommandBuffer(CCVKDevice* device, CCVKGPUCommandBuffer* gpuCommandBuffer) -{ - if (gpuCommandBuffer->vkCommandBuffer) - { +void CCVKCmdFuncFreeCommandBuffer(CCVKDevice *device, CCVKGPUCommandBuffer *gpuCommandBuffer) { + if (gpuCommandBuffer->vkCommandBuffer) { gpuCommandBuffer->commandPool->usedCommandBuffers[(uint)gpuCommandBuffer->type].push(gpuCommandBuffer->vkCommandBuffer); gpuCommandBuffer->vkCommandBuffer = VK_NULL_HANDLE; } } -void CCVKCmdFuncCreateBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer) -{ - if (!gpuBuffer->size) { return; } +void CCVKCmdFuncCreateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer) { + if (!gpuBuffer->size) { + return; + } - VkBufferCreateInfo bufferInfo{ VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO }; + VkBufferCreateInfo bufferInfo{VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO}; bufferInfo.size = gpuBuffer->size; bufferInfo.usage = MapVkBufferUsageFlagBits(gpuBuffer->usage); VmaAllocationCreateInfo allocInfo{}; allocInfo.flags = VMA_ALLOCATION_CREATE_MAPPED_BIT; - if (gpuBuffer->memUsage == GFXMemoryUsage::HOST) - { + if (gpuBuffer->memUsage == GFXMemoryUsage::HOST) { bufferInfo.usage |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT; allocInfo.usage = VMA_MEMORY_USAGE_CPU_ONLY; - } - else if (gpuBuffer->memUsage == GFXMemoryUsage::DEVICE) - { + } else if (gpuBuffer->memUsage == GFXMemoryUsage::DEVICE) { bufferInfo.usage |= VK_BUFFER_USAGE_TRANSFER_DST_BIT; allocInfo.usage = VMA_MEMORY_USAGE_GPU_ONLY; - } - else if (gpuBuffer->memUsage == (GFXMemoryUsage::HOST | GFXMemoryUsage::DEVICE)) - { + } else if (gpuBuffer->memUsage == (GFXMemoryUsage::HOST | GFXMemoryUsage::DEVICE)) { allocInfo.usage = VMA_MEMORY_USAGE_CPU_TO_GPU; } VmaAllocationInfo res; VK_CHECK(vmaCreateBuffer(device->gpuDevice()->memoryAllocator, &bufferInfo, &allocInfo, &gpuBuffer->vkBuffer, &gpuBuffer->vmaAllocation, &res)); //CC_LOG_DEBUG("Allocated buffer: %llu, %llx %llx %llu", res.size, gpuBuffer->vkBuffer, res.deviceMemory, res.offset); - gpuBuffer->mappedData = (uint8_t*)res.pMappedData; + gpuBuffer->mappedData = (uint8_t *)res.pMappedData; } -void CCVKCmdFuncDestroyBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer) -{ - if (gpuBuffer->vmaAllocation) - { +void CCVKCmdFuncDestroyBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer) { + if (gpuBuffer->vmaAllocation) { vmaDestroyBuffer(device->gpuDevice()->memoryAllocator, gpuBuffer->vkBuffer, gpuBuffer->vmaAllocation); gpuBuffer->buffer = VK_NULL_HANDLE; gpuBuffer->vmaAllocation = VK_NULL_HANDLE; } } -void CCVKCmdFuncResizeBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer) -{ +void CCVKCmdFuncResizeBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer) { CCVKCmdFuncDestroyBuffer(device, gpuBuffer); CCVKCmdFuncCreateBuffer(device, gpuBuffer); } -void CCVKCmdFuncUpdateBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer, void* buffer, uint offset, uint size) -{ - if (gpuBuffer->mappedData) - { +void CCVKCmdFuncUpdateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer, void *buffer, uint offset, uint size) { + if (gpuBuffer->mappedData) { memcpy(gpuBuffer->mappedData + offset, buffer, size); - } - else if (gpuBuffer->memUsage == GFXMemoryUsage::DEVICE) - { - const CCVKGPUBuffer* stagingBuffer = device->stagingBuffer()->gpuBuffer(); + } else if (gpuBuffer->memUsage == GFXMemoryUsage::DEVICE) { + const CCVKGPUBuffer *stagingBuffer = device->stagingBuffer()->gpuBuffer(); if (stagingBuffer->size < size) device->stagingBuffer()->resize(nextPowerOf2(size)); memcpy(stagingBuffer->mappedData, buffer, size); @@ -355,16 +320,17 @@ void CCVKCmdFuncUpdateBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer, void* CCVKGPUCommandBuffer cmdBuff; beginOneTimeCommands(device, &cmdBuff); - VkBufferCopy region{ 0, gpuBuffer->startOffset + offset, size }; + VkBufferCopy region{0, gpuBuffer->startOffset + offset, size}; vkCmdCopyBuffer(cmdBuff.vkCommandBuffer, stagingBuffer->vkBuffer, gpuBuffer->vkBuffer, 1, ®ion); endOneTimeCommands(device, &cmdBuff); } } -bool CCVKCmdFuncCreateTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture) -{ - if (!gpuTexture->width || !gpuTexture->height) { return true; } +bool CCVKCmdFuncCreateTexture(CCVKDevice *device, CCVKGPUTexture *gpuTexture) { + if (!gpuTexture->width || !gpuTexture->height) { + return true; + } VkFormat format = MapVkFormat(gpuTexture->format); VkFormatFeatureFlags features = MapVkFormatFeatureFlags(gpuTexture->usage); @@ -372,22 +338,20 @@ bool CCVKCmdFuncCreateTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture) VkImageUsageFlags usageFlags = MapVkImageUsageFlagBits(gpuTexture->usage) | VK_IMAGE_USAGE_TRANSFER_DST_BIT; VkFormatProperties formatProperties; vkGetPhysicalDeviceFormatProperties(device->gpuContext()->physicalDevice, format, &formatProperties); - - if (!(formatProperties.optimalTilingFeatures & features)) - { + + if (!(formatProperties.optimalTilingFeatures & features)) { CC_LOG_ERROR("CCVKCmdFuncCreateTexture: unsupported feature set in optimalTilingFeatures."); return false; } - if (gpuTexture->flags & GFXTextureFlags::GEN_MIPMAP) - { + if (gpuTexture->flags & GFXTextureFlags::GEN_MIPMAP) { usageFlags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; } - VkImageCreateInfo createInfo{ VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO }; + VkImageCreateInfo createInfo{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO}; createInfo.flags = MapVkImageCreateFlags(gpuTexture->viewType); createInfo.imageType = MapVkImageType(gpuTexture->type); createInfo.format = format; - createInfo.extent = { gpuTexture->width, gpuTexture->height, gpuTexture->depth }; + createInfo.extent = {gpuTexture->width, gpuTexture->height, gpuTexture->depth}; createInfo.mipLevels = gpuTexture->mipLevel; createInfo.arrayLayers = gpuTexture->arrayLayer; createInfo.samples = MapVkSampleCount(gpuTexture->samples); @@ -407,8 +371,7 @@ bool CCVKCmdFuncCreateTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture) gpuTexture->aspectMask = MapVkImageAspectFlags(gpuTexture->format); gpuTexture->targetStage = MapVkPipelineStageFlags(gpuTexture->usage); - if(gpuTexture->currentLayout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) - { + if (gpuTexture->currentLayout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) { CCVKGPUCommandBuffer cmfBuff; beginOneTimeCommands(device, &cmfBuff); @@ -417,39 +380,35 @@ bool CCVKCmdFuncCreateTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture) subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; insertImageMemoryBarrior(cmfBuff.vkCommandBuffer, - gpuTexture->vkImage, - 0, - gpuTexture->accessMask, - VK_IMAGE_LAYOUT_UNDEFINED, - gpuTexture->currentLayout, - VK_PIPELINE_STAGE_HOST_BIT, - gpuTexture->targetStage, - subresourceRange); + gpuTexture->vkImage, + 0, + gpuTexture->accessMask, + VK_IMAGE_LAYOUT_UNDEFINED, + gpuTexture->currentLayout, + VK_PIPELINE_STAGE_HOST_BIT, + gpuTexture->targetStage, + subresourceRange); endOneTimeCommands(device, &cmfBuff); } return true; } -void CCVKCmdFuncDestroyTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture) -{ - if (gpuTexture->vmaAllocation) - { +void CCVKCmdFuncDestroyTexture(CCVKDevice *device, CCVKGPUTexture *gpuTexture) { + if (gpuTexture->vmaAllocation) { vmaDestroyImage(device->gpuDevice()->memoryAllocator, gpuTexture->vkImage, gpuTexture->vmaAllocation); gpuTexture->vkImage = VK_NULL_HANDLE; gpuTexture->vmaAllocation = VK_NULL_HANDLE; } } -void CCVKCmdFuncResizeTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture) -{ +void CCVKCmdFuncResizeTexture(CCVKDevice *device, CCVKGPUTexture *gpuTexture) { CCVKCmdFuncDestroyTexture(device, gpuTexture); CCVKCmdFuncCreateTexture(device, gpuTexture); } -void CCVKCmdFuncCreateTextureView(CCVKDevice* device, CCVKGPUTextureView* gpuTextureView) -{ - VkImageViewCreateInfo createInfo{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO }; +void CCVKCmdFuncCreateTextureView(CCVKDevice *device, CCVKGPUTextureView *gpuTextureView) { + VkImageViewCreateInfo createInfo{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO}; createInfo.image = gpuTextureView->gpuTexture->vkImage; createInfo.viewType = MapVkImageViewType(gpuTextureView->type); createInfo.format = MapVkFormat(gpuTextureView->format); @@ -462,18 +421,15 @@ void CCVKCmdFuncCreateTextureView(CCVKDevice* device, CCVKGPUTextureView* gpuTex VK_CHECK(vkCreateImageView(device->gpuDevice()->vkDevice, &createInfo, nullptr, &gpuTextureView->vkImageView)); } -void CCVKCmdFuncDestroyTextureView(CCVKDevice* device, CCVKGPUTextureView* gpuTextureView) -{ - if (gpuTextureView->vkImageView != VK_NULL_HANDLE) - { +void CCVKCmdFuncDestroyTextureView(CCVKDevice *device, CCVKGPUTextureView *gpuTextureView) { + if (gpuTextureView->vkImageView != VK_NULL_HANDLE) { vkDestroyImageView(device->gpuDevice()->vkDevice, gpuTextureView->vkImageView, nullptr); gpuTextureView->vkImageView = VK_NULL_HANDLE; } } -void CCVKCmdFuncCreateSampler(CCVKDevice* device, CCVKGPUSampler* gpuSampler) -{ - VkSamplerCreateInfo createInfo{ VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO }; +void CCVKCmdFuncCreateSampler(CCVKDevice *device, CCVKGPUSampler *gpuSampler) { + VkSamplerCreateInfo createInfo{VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO}; createInfo.magFilter = VK_FILTERS[(uint)gpuSampler->magFilter]; createInfo.minFilter = VK_FILTERS[(uint)gpuSampler->minFilter]; @@ -493,21 +449,17 @@ void CCVKCmdFuncCreateSampler(CCVKDevice* device, CCVKGPUSampler* gpuSampler) VK_CHECK(vkCreateSampler(device->gpuDevice()->vkDevice, &createInfo, nullptr, &gpuSampler->vkSampler)); } -void CCVKCmdFuncDestroySampler(CCVKDevice* device, CCVKGPUSampler* gpuSampler) -{ - if (gpuSampler->vkSampler!= VK_NULL_HANDLE) - { +void CCVKCmdFuncDestroySampler(CCVKDevice *device, CCVKGPUSampler *gpuSampler) { + if (gpuSampler->vkSampler != VK_NULL_HANDLE) { vkDestroySampler(device->gpuDevice()->vkDevice, gpuSampler->vkSampler, nullptr); gpuSampler->vkSampler = VK_NULL_HANDLE; } } -void CCVKCmdFuncCreateShader(CCVKDevice* device, CCVKGPUShader* gpuShader) -{ - for (CCVKGPUShaderStage &stage : gpuShader->gpuStages) - { - vector::type spirv = GLSL2SPIRV(stage.type, "#version 450\n" + stage.source, ((CCVKContext*)device->getContext())->minorVersion()); - VkShaderModuleCreateInfo createInfo{ VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO }; +void CCVKCmdFuncCreateShader(CCVKDevice *device, CCVKGPUShader *gpuShader) { + for (CCVKGPUShaderStage &stage : gpuShader->gpuStages) { + vector::type spirv = GLSL2SPIRV(stage.type, "#version 450\n" + stage.source, ((CCVKContext *)device->getContext())->minorVersion()); + VkShaderModuleCreateInfo createInfo{VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO}; createInfo.codeSize = spirv.size() * sizeof(unsigned int); createInfo.pCode = spirv.data(); VK_CHECK(vkCreateShaderModule(device->gpuDevice()->vkDevice, &createInfo, nullptr, &stage.vkShader)); @@ -515,54 +467,45 @@ void CCVKCmdFuncCreateShader(CCVKDevice* device, CCVKGPUShader* gpuShader) CC_LOG_INFO("Shader '%s' compilation succeeded.", gpuShader->name.c_str()); } -void CCVKCmdFuncDestroyShader(CCVKDevice* device, CCVKGPUShader* gpuShader) -{ - for (CCVKGPUShaderStage &stage : gpuShader->gpuStages) - { +void CCVKCmdFuncDestroyShader(CCVKDevice *device, CCVKGPUShader *gpuShader) { + for (CCVKGPUShaderStage &stage : gpuShader->gpuStages) { vkDestroyShaderModule(device->gpuDevice()->vkDevice, stage.vkShader, nullptr); stage.vkShader = VK_NULL_HANDLE; } } -void CCVKCmdFuncCreateInputAssembler(CCVKDevice* device, CCVKGPUInputAssembler* gpuInputAssembler) -{ +void CCVKCmdFuncCreateInputAssembler(CCVKDevice *device, CCVKGPUInputAssembler *gpuInputAssembler) { size_t vbCount = gpuInputAssembler->gpuVertexBuffers.size(); gpuInputAssembler->vertexBuffers.resize(vbCount); gpuInputAssembler->vertexBufferOffsets.resize(vbCount); - for (size_t i = 0; i < vbCount; i++) - { + for (size_t i = 0; i < vbCount; i++) { gpuInputAssembler->vertexBuffers[i] = gpuInputAssembler->gpuVertexBuffers[i]->vkBuffer; gpuInputAssembler->vertexBufferOffsets[i] = gpuInputAssembler->gpuVertexBuffers[i]->startOffset; } } -void CCVKCmdFuncDestroyInputAssembler(CCVKDevice* device, CCVKGPUInputAssembler* gpuInputAssembler) -{ +void CCVKCmdFuncDestroyInputAssembler(CCVKDevice *device, CCVKGPUInputAssembler *gpuInputAssembler) { gpuInputAssembler->vertexBuffers.clear(); gpuInputAssembler->vertexBufferOffsets.clear(); } -void CCVKCmdFuncCreateFramebuffer(CCVKDevice* device, CCVKGPUFramebuffer* gpuFramebuffer) -{ - if (!gpuFramebuffer->isOffscreen) - { +void CCVKCmdFuncCreateFramebuffer(CCVKDevice *device, CCVKGPUFramebuffer *gpuFramebuffer) { + if (!gpuFramebuffer->isOffscreen) { gpuFramebuffer->swapchain = device->gpuSwapchain(); return; } size_t colorViewCount = gpuFramebuffer->gpuColorViews.size(); vector::type attachments(colorViewCount + (gpuFramebuffer->gpuDepthStencilView ? 1 : 0)); - for (size_t i = 0u; i < colorViewCount; i++) - { + for (size_t i = 0u; i < colorViewCount; i++) { attachments[i] = gpuFramebuffer->gpuColorViews[i]->vkImageView; } - if (gpuFramebuffer->gpuDepthStencilView) - { + if (gpuFramebuffer->gpuDepthStencilView) { attachments[colorViewCount] = gpuFramebuffer->gpuDepthStencilView->vkImageView; } - VkFramebufferCreateInfo createInfo{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO }; + VkFramebufferCreateInfo createInfo{VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO}; createInfo.renderPass = gpuFramebuffer->gpuRenderPass->vkRenderPass; createInfo.attachmentCount = attachments.size(); createInfo.pAttachments = attachments.data(); @@ -573,22 +516,18 @@ void CCVKCmdFuncCreateFramebuffer(CCVKDevice* device, CCVKGPUFramebuffer* gpuFra VK_CHECK(vkCreateFramebuffer(device->gpuDevice()->vkDevice, &createInfo, nullptr, &gpuFramebuffer->vkFramebuffer)); } -void CCVKCmdFuncDestroyFramebuffer(CCVKDevice* device, CCVKGPUFramebuffer* gpuFramebuffer) -{ - if (gpuFramebuffer->vkFramebuffer != VK_NULL_HANDLE) - { +void CCVKCmdFuncDestroyFramebuffer(CCVKDevice *device, CCVKGPUFramebuffer *gpuFramebuffer) { + if (gpuFramebuffer->vkFramebuffer != VK_NULL_HANDLE) { vkDestroyFramebuffer(device->gpuDevice()->vkDevice, gpuFramebuffer->vkFramebuffer, nullptr); gpuFramebuffer->vkFramebuffer = VK_NULL_HANDLE; } } -void CCVKCmdFuncCreateBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* gpuBindingLayout, GFXBindingUnitList bindings) -{ +void CCVKCmdFuncCreateBindingLayout(CCVKDevice *device, CCVKGPUBindingLayout *gpuBindingLayout, GFXBindingUnitList bindings) { size_t count = bindings.size(); vector::type setBindings(count); - for (size_t i = 0u; i < count; i++) - { + for (size_t i = 0u; i < count; i++) { const GFXBindingUnit &binding = bindings[i]; setBindings[i].binding = binding.binding; setBindings[i].descriptorType = MapVkDescriptorType(binding.type); @@ -596,81 +535,73 @@ void CCVKCmdFuncCreateBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* gp setBindings[i].stageFlags = MapVkShaderStageFlags(binding.shaderStages); } - VkDescriptorSetLayoutCreateInfo setCreateInfo{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO }; + VkDescriptorSetLayoutCreateInfo setCreateInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO}; setCreateInfo.bindingCount = count; setCreateInfo.pBindings = setBindings.data(); VK_CHECK(vkCreateDescriptorSetLayout(device->gpuDevice()->vkDevice, &setCreateInfo, nullptr, &gpuBindingLayout->vkDescriptorSetLayout)); vector::type poolSizes; - for (const VkDescriptorSetLayoutBinding &binding : setBindings) - { + for (const VkDescriptorSetLayoutBinding &binding : setBindings) { bool found = false; - for (VkDescriptorPoolSize &poolSize : poolSizes) - { - if (poolSize.type == binding.descriptorType) - { + for (VkDescriptorPoolSize &poolSize : poolSizes) { + if (poolSize.type == binding.descriptorType) { poolSize.descriptorCount++; found = true; break; } } - if (!found) - { - poolSizes.push_back({ binding.descriptorType, 1 }); + if (!found) { + poolSizes.push_back({binding.descriptorType, 1}); } } - VkDescriptorPoolCreateInfo poolInfo{ VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO }; + VkDescriptorPoolCreateInfo poolInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO}; poolInfo.poolSizeCount = poolSizes.size(); poolInfo.pPoolSizes = poolSizes.data(); poolInfo.maxSets = 1; VK_CHECK(vkCreateDescriptorPool(device->gpuDevice()->vkDevice, &poolInfo, nullptr, &gpuBindingLayout->vkDescriptorPool)); - VkDescriptorSetAllocateInfo allocInfo{ VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO }; + VkDescriptorSetAllocateInfo allocInfo{VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO}; allocInfo.descriptorPool = gpuBindingLayout->vkDescriptorPool; allocInfo.descriptorSetCount = 1; allocInfo.pSetLayouts = &gpuBindingLayout->vkDescriptorSetLayout; VK_CHECK(vkAllocateDescriptorSets(device->gpuDevice()->vkDevice, &allocInfo, &gpuBindingLayout->vkDescriptorSet)); - gpuBindingLayout->bindings.resize(bindings.size(), { VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET }); - for (size_t i = 0u; i < count; i++) - { + gpuBindingLayout->bindings.resize(bindings.size(), {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET}); + for (size_t i = 0u; i < count; i++) { VkWriteDescriptorSet &binding = gpuBindingLayout->bindings[i]; binding.dstSet = gpuBindingLayout->vkDescriptorSet; binding.dstBinding = setBindings[i].binding; binding.dstArrayElement = 0; binding.descriptorCount = 1; binding.descriptorType = setBindings[i].descriptorType; - switch (binding.descriptorType) - { - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: - case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: - case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: - binding.pBufferInfo = CC_NEW(VkDescriptorBufferInfo); - break; - case VK_DESCRIPTOR_TYPE_SAMPLER: - case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: - case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: - case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: - case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: - binding.pImageInfo = CC_NEW(VkDescriptorImageInfo); - break; - case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: - case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: - binding.pTexelBufferView = CC_NEW(VkBufferView); - break; + switch (binding.descriptorType) { + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: + case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: + case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: + binding.pBufferInfo = CC_NEW(VkDescriptorBufferInfo); + break; + case VK_DESCRIPTOR_TYPE_SAMPLER: + case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: + case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: + binding.pImageInfo = CC_NEW(VkDescriptorImageInfo); + break; + case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: + binding.pTexelBufferView = CC_NEW(VkBufferView); + break; } } } -void CCVKCmdFuncDestroyBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* gpuBindingLayout) -{ - for (VkWriteDescriptorSet &binding : gpuBindingLayout->bindings) - { +void CCVKCmdFuncDestroyBindingLayout(CCVKDevice *device, CCVKGPUBindingLayout *gpuBindingLayout) { + for (VkWriteDescriptorSet &binding : gpuBindingLayout->bindings) { CC_SAFE_DELETE(binding.pBufferInfo); CC_SAFE_DELETE(binding.pImageInfo); CC_SAFE_DELETE(binding.pTexelBufferView); @@ -679,56 +610,48 @@ void CCVKCmdFuncDestroyBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* g gpuBindingLayout->vkDescriptorSet = VK_NULL_HANDLE; - if (gpuBindingLayout->vkDescriptorPool != VK_NULL_HANDLE) - { + if (gpuBindingLayout->vkDescriptorPool != VK_NULL_HANDLE) { vkDestroyDescriptorPool(device->gpuDevice()->vkDevice, gpuBindingLayout->vkDescriptorPool, nullptr); gpuBindingLayout->vkDescriptorPool = VK_NULL_HANDLE; } - if (gpuBindingLayout->vkDescriptorSetLayout != VK_NULL_HANDLE) - { + if (gpuBindingLayout->vkDescriptorSetLayout != VK_NULL_HANDLE) { vkDestroyDescriptorSetLayout(device->gpuDevice()->vkDevice, gpuBindingLayout->vkDescriptorSetLayout, nullptr); gpuBindingLayout->vkDescriptorSetLayout = VK_NULL_HANDLE; } } -void CCVKCmdFuncCreatePipelineLayout(CCVKDevice* device, CCVKGPUPipelineLayout* gpuPipelineLayout) -{ +void CCVKCmdFuncCreatePipelineLayout(CCVKDevice *device, CCVKGPUPipelineLayout *gpuPipelineLayout) { size_t count = gpuPipelineLayout->gpuBindingLayouts.size(); vector::type descriptorSetLayouts(count); - for (size_t i = 0u; i < count; i++) - { - const CCVKGPUBindingLayout* layout = gpuPipelineLayout->gpuBindingLayouts[i]; + for (size_t i = 0u; i < count; i++) { + const CCVKGPUBindingLayout *layout = gpuPipelineLayout->gpuBindingLayouts[i]; descriptorSetLayouts[i] = layout->vkDescriptorSetLayout; } - VkPipelineLayoutCreateInfo createInfo{ VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO }; + VkPipelineLayoutCreateInfo createInfo{VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO}; createInfo.setLayoutCount = count; createInfo.pSetLayouts = descriptorSetLayouts.data(); VK_CHECK(vkCreatePipelineLayout(device->gpuDevice()->vkDevice, &createInfo, nullptr, &gpuPipelineLayout->vkPipelineLayout)); } -void CCVKCmdFuncDestroyPipelineLayout(CCVKDevice* device, CCVKGPUPipelineLayout* gpuPipelineLayout) -{ - if (gpuPipelineLayout->vkPipelineLayout != VK_NULL_HANDLE) - { +void CCVKCmdFuncDestroyPipelineLayout(CCVKDevice *device, CCVKGPUPipelineLayout *gpuPipelineLayout) { + if (gpuPipelineLayout->vkPipelineLayout != VK_NULL_HANDLE) { vkDestroyPipelineLayout(device->gpuDevice()->vkDevice, gpuPipelineLayout->vkPipelineLayout, nullptr); gpuPipelineLayout->vkPipelineLayout = VK_NULL_HANDLE; } } -void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gpuPipelineState) -{ - VkGraphicsPipelineCreateInfo createInfo{ VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO }; +void CCVKCmdFuncCreatePipelineState(CCVKDevice *device, CCVKGPUPipelineState *gpuPipelineState) { + VkGraphicsPipelineCreateInfo createInfo{VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO}; ///////////////////// Shader Stage ///////////////////// const CCVKGPUShaderStageList &stages = gpuPipelineState->gpuShader->gpuStages; size_t stageCount = stages.size(); - vector::type stageInfos(stageCount, { VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO }); - for (size_t i = 0u; i < stageCount; i++) - { + vector::type stageInfos(stageCount, {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO}); + for (size_t i = 0u; i < stageCount; i++) { stageInfos[i].stage = MapVkShaderStageFlagBits(stages[i].type); stageInfos[i].module = stages[i].vkShader; stageInfos[i].pName = "main"; @@ -741,42 +664,38 @@ void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gp const GFXAttributeList &attributes = gpuPipelineState->inputState.attributes; size_t attributeCount = attributes.size(); size_t bindingCount = 1u; - for (size_t i = 0u; i < attributeCount; i++) - { + for (size_t i = 0u; i < attributeCount; i++) { const GFXAttribute &attr = attributes[i]; bindingCount = std::max(bindingCount, attr.stream + 1); } vector::type bindingDescriptions(bindingCount); - for (size_t i = 0u; i < bindingCount; i++) - { + for (size_t i = 0u; i < bindingCount; i++) { bindingDescriptions[i].binding = i; bindingDescriptions[i].stride = 0; bindingDescriptions[i].inputRate = VK_VERTEX_INPUT_RATE_VERTEX; } - for (size_t i = 0u; i < attributeCount; i++) - { + for (size_t i = 0u; i < attributeCount; i++) { const GFXAttribute &attr = attributes[i]; bindingDescriptions[attr.stream].stride += GFX_FORMAT_INFOS[(uint)attr.format].size; - if (attr.isInstanced) - { + if (attr.isInstanced) { bindingDescriptions[attr.stream].inputRate = VK_VERTEX_INPUT_RATE_INSTANCE; } } vector::type offsets(bindingCount, 0); + vector::type locations(bindingCount, 0); vector::type attributeDescriptions(attributeCount); - for (size_t i = 0u; i < attributeCount; i++) - { + for (size_t i = 0u; i < attributeCount; i++) { const GFXAttribute &attr = attributes[i]; - attributeDescriptions[i].location = attr.location; + attributeDescriptions[i].location = locations[attr.stream]++; attributeDescriptions[i].binding = attr.stream; attributeDescriptions[i].format = MapVkFormat(attr.format); attributeDescriptions[i].offset = offsets[attr.stream]; offsets[attr.stream] += GFX_FORMAT_INFOS[(uint)attr.format].size; } - VkPipelineVertexInputStateCreateInfo vertexInput{ VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO }; + VkPipelineVertexInputStateCreateInfo vertexInput{VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO}; vertexInput.vertexBindingDescriptionCount = bindingCount; vertexInput.pVertexBindingDescriptions = bindingDescriptions.data(); vertexInput.vertexAttributeDescriptionCount = attributeCount; @@ -785,30 +704,30 @@ void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gp ///////////////////// Input Asembly State ///////////////////// - VkPipelineInputAssemblyStateCreateInfo inputAssembly{ VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO }; + VkPipelineInputAssemblyStateCreateInfo inputAssembly{VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO}; inputAssembly.topology = VK_PRIMITIVE_MODES[(uint)gpuPipelineState->primitive]; createInfo.pInputAssemblyState = &inputAssembly; ///////////////////// Dynamic State ///////////////////// - vector::type dynamicStates{ VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR }; + vector::type dynamicStates{VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR}; InsertVkDynamicStates(dynamicStates, gpuPipelineState->dynamicStates); - VkPipelineDynamicStateCreateInfo dynamicState{ VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO }; + VkPipelineDynamicStateCreateInfo dynamicState{VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO}; dynamicState.dynamicStateCount = dynamicStates.size(); dynamicState.pDynamicStates = dynamicStates.data(); createInfo.pDynamicState = &dynamicState; ///////////////////// Viewport State ///////////////////// - VkPipelineViewportStateCreateInfo viewportState{ VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO }; + VkPipelineViewportStateCreateInfo viewportState{VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO}; viewportState.viewportCount = 1; // dynamic by default - viewportState.scissorCount = 1; // dynamic by default + viewportState.scissorCount = 1; // dynamic by default createInfo.pViewportState = &viewportState; ///////////////////// Rasterization State ///////////////////// - VkPipelineRasterizationStateCreateInfo rasterizationState{ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO }; + VkPipelineRasterizationStateCreateInfo rasterizationState{VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO}; //rasterizationState.depthClampEnable; rasterizationState.rasterizerDiscardEnable = gpuPipelineState->rs.isDiscard; @@ -824,7 +743,7 @@ void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gp ///////////////////// Multisample State ///////////////////// - VkPipelineMultisampleStateCreateInfo multisampleState{ VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO }; + VkPipelineMultisampleStateCreateInfo multisampleState{VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO}; multisampleState.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT; multisampleState.alphaToCoverageEnable = gpuPipelineState->bs.isA2C; //multisampleState.sampleShadingEnable; @@ -835,31 +754,31 @@ void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gp ///////////////////// Depth Stencil State ///////////////////// - VkPipelineDepthStencilStateCreateInfo depthStencilState = { VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO }; + VkPipelineDepthStencilStateCreateInfo depthStencilState = {VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO}; depthStencilState.depthTestEnable = gpuPipelineState->dss.depthTest; depthStencilState.depthWriteEnable = gpuPipelineState->dss.depthWrite; depthStencilState.depthCompareOp = VK_CMP_FUNCS[(uint)gpuPipelineState->dss.depthFunc]; depthStencilState.stencilTestEnable = gpuPipelineState->dss.stencilTestFront; depthStencilState.front = - { - VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilFailOpFront], - VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilPassOpFront], - VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilZFailOpFront], - VK_CMP_FUNCS[(uint)gpuPipelineState->dss.stencilFuncFront], - gpuPipelineState->dss.stencilReadMaskFront, - gpuPipelineState->dss.stencilWriteMaskFront, - gpuPipelineState->dss.stencilRefFront, - }; + { + VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilFailOpFront], + VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilPassOpFront], + VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilZFailOpFront], + VK_CMP_FUNCS[(uint)gpuPipelineState->dss.stencilFuncFront], + gpuPipelineState->dss.stencilReadMaskFront, + gpuPipelineState->dss.stencilWriteMaskFront, + gpuPipelineState->dss.stencilRefFront, + }; depthStencilState.back = - { - VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilFailOpBack], - VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilPassOpBack], - VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilZFailOpBack], - VK_CMP_FUNCS[(uint)gpuPipelineState->dss.stencilFuncBack], - gpuPipelineState->dss.stencilReadMaskBack, - gpuPipelineState->dss.stencilWriteMaskBack, - gpuPipelineState->dss.stencilRefBack, - }; + { + VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilFailOpBack], + VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilPassOpBack], + VK_STENCIL_OPS[(uint)gpuPipelineState->dss.stencilZFailOpBack], + VK_CMP_FUNCS[(uint)gpuPipelineState->dss.stencilFuncBack], + gpuPipelineState->dss.stencilReadMaskBack, + gpuPipelineState->dss.stencilWriteMaskBack, + gpuPipelineState->dss.stencilRefBack, + }; //depthStencilState.depthBoundsTestEnable; //depthStencilState.minDepthBounds; //depthStencilState.maxDepthBounds; @@ -869,8 +788,7 @@ void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gp size_t blendTargetCount = gpuPipelineState->bs.targets.size(); vector::type blendTargets(blendTargetCount); - for (size_t i = 0u; i < blendTargetCount; i++) - { + for (size_t i = 0u; i < blendTargetCount; i++) { GFXBlendTarget &target = gpuPipelineState->bs.targets[i]; blendTargets[i].blendEnable = target.blend; blendTargets[i].srcColorBlendFactor = VK_BLEND_FACTORS[(uint)target.blendSrc]; @@ -883,7 +801,7 @@ void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gp } GFXColor &blendColor = gpuPipelineState->bs.blendColor; - VkPipelineColorBlendStateCreateInfo colorBlendState{ VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO }; + VkPipelineColorBlendStateCreateInfo colorBlendState{VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO}; //colorBlendState.logicOpEnable; //colorBlendState.logicOp; colorBlendState.attachmentCount = blendTargetCount; @@ -902,20 +820,17 @@ void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gp ///////////////////// Creation ///////////////////// VK_CHECK(vkCreateGraphicsPipelines(device->gpuDevice()->vkDevice, gpuPipelineState->vkPipelineCache, - 1, &createInfo, nullptr, &gpuPipelineState->vkPipeline)); + 1, &createInfo, nullptr, &gpuPipelineState->vkPipeline)); } -void CCVKCmdFuncDestroyPipelineState(CCVKDevice* device, CCVKGPUPipelineState* gpuPipelineState) -{ - if (gpuPipelineState->vkPipeline != VK_NULL_HANDLE) - { +void CCVKCmdFuncDestroyPipelineState(CCVKDevice *device, CCVKGPUPipelineState *gpuPipelineState) { + if (gpuPipelineState->vkPipeline != VK_NULL_HANDLE) { vkDestroyPipeline(device->gpuDevice()->vkDevice, gpuPipelineState->vkPipeline, nullptr); gpuPipelineState->vkPipeline = VK_NULL_HANDLE; } } -void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice* device, uint8_t* const* buffers, CCVKGPUTexture* gpuTexture, const GFXBufferTextureCopyList& regions) -{ +void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, uint8_t *const *buffers, CCVKGPUTexture *gpuTexture, const GFXBufferTextureCopyList ®ions) { //bool isCompressed = GFX_FORMAT_INFOS[(int)gpuTexture->format].isCompressed; CCVKGPUCommandBuffer cmdBuff; beginOneTimeCommands(device, &cmdBuff); @@ -926,108 +841,104 @@ void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice* device, uint8_t* const* buffers subresoureceRange.levelCount = VK_REMAINING_MIP_LEVELS; subresoureceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; insertImageMemoryBarrior(cmdBuff.vkCommandBuffer, - gpuTexture->vkImage, - gpuTexture->accessMask, - VK_ACCESS_TRANSFER_WRITE_BIT, - gpuTexture->currentLayout, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - gpuTexture->targetStage, - VK_PIPELINE_STAGE_TRANSFER_BIT, - subresoureceRange); + gpuTexture->vkImage, + gpuTexture->accessMask, + VK_ACCESS_TRANSFER_WRITE_BIT, + gpuTexture->currentLayout, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + gpuTexture->targetStage, + VK_PIPELINE_STAGE_TRANSFER_BIT, + subresoureceRange); uint regionCount = regions.size(), totalSize = 0u; vector::type regionSizes(regionCount); - for (size_t i = 0u; i < regionCount; ++i) - { + for (size_t i = 0u; i < regionCount; ++i) { const GFXBufferTextureCopy ®ion = regions[i]; uint w = region.buffStride > 0 ? region.buffStride : region.texExtent.width; uint h = region.buffTexHeight > 0 ? region.buffTexHeight : region.texExtent.height; totalSize += regionSizes[i] = GFXFormatSize(gpuTexture->format, w, h, region.texExtent.depth); } - CCVKGPUBuffer* stagingBuffer = device->stagingBuffer()->gpuBuffer(); + CCVKGPUBuffer *stagingBuffer = device->stagingBuffer()->gpuBuffer(); if (stagingBuffer->size < totalSize) device->stagingBuffer()->resize(nextPowerOf2(totalSize)); vector::type stagingRegions(regionCount); VkDeviceSize offset = stagingBuffer->startOffset; - for (size_t i = 0u; i < regionCount; ++i) - { + for (size_t i = 0u; i < regionCount; ++i) { const GFXBufferTextureCopy ®ion = regions[i]; VkBufferImageCopy &stagingRegion = stagingRegions[i]; stagingRegion.bufferOffset = offset; stagingRegion.bufferRowLength = region.buffStride; stagingRegion.bufferImageHeight = region.buffTexHeight; - stagingRegion.imageSubresource = { gpuTexture->aspectMask, region.texSubres.mipLevel, region.texSubres.baseArrayLayer, region.texSubres.layerCount }; - stagingRegion.imageOffset = { region.texOffset.x, region.texOffset.y, region.texOffset.z }; - stagingRegion.imageExtent = { region.texExtent.width, region.texExtent.height, region.texExtent.depth }; + stagingRegion.imageSubresource = {gpuTexture->aspectMask, region.texSubres.mipLevel, region.texSubres.baseArrayLayer, region.texSubres.layerCount}; + stagingRegion.imageOffset = {region.texOffset.x, region.texOffset.y, region.texOffset.z}; + stagingRegion.imageExtent = {region.texExtent.width, region.texExtent.height, region.texExtent.depth}; memcpy(stagingBuffer->mappedData + offset, buffers[i], regionSizes[i]); offset += regionSizes[i]; } vkCmdCopyBufferToImage(cmdBuff.vkCommandBuffer, stagingBuffer->vkBuffer, gpuTexture->vkImage, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, stagingRegions.size(), stagingRegions.data()); + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, stagingRegions.size(), stagingRegions.data()); - if (gpuTexture->flags & GFXTextureFlags::GEN_MIPMAP) - { + if (gpuTexture->flags & GFXTextureFlags::GEN_MIPMAP) { VkFormatProperties formatProperties; vkGetPhysicalDeviceFormatProperties(device->gpuContext()->physicalDevice, MapVkFormat(gpuTexture->format), &formatProperties); - VkFormatFeatureFlags mipmapFeatures; + VkFormatFeatureFlags mipmapFeatures = 0; mipmapFeatures |= VK_FORMAT_FEATURE_BLIT_SRC_BIT; mipmapFeatures |= VK_FORMAT_FEATURE_BLIT_DST_BIT; mipmapFeatures |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT; - if (formatProperties.optimalTilingFeatures & mipmapFeatures) - { + + if (formatProperties.optimalTilingFeatures & mipmapFeatures) { VkImageSubresourceRange mipSubRange{}; mipSubRange.aspectMask = gpuTexture->aspectMask; - mipSubRange.levelCount = VK_REMAINING_MIP_LEVELS; + mipSubRange.levelCount = 1; mipSubRange.layerCount = VK_REMAINING_ARRAY_LAYERS; int32_t mipWidth = gpuTexture->width; int32_t mipHeight = gpuTexture->height; - for (auto i = 1; i < gpuTexture->mipLevel; i++) - { + for (uint i = 1u; i < gpuTexture->mipLevel; i++) { mipSubRange.baseMipLevel = i - 1; insertImageMemoryBarrior(cmdBuff.vkCommandBuffer, - gpuTexture->vkImage, - VK_ACCESS_TRANSFER_WRITE_BIT, - VK_ACCESS_TRANSFER_READ_BIT, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - VK_PIPELINE_STAGE_TRANSFER_BIT, - VK_PIPELINE_STAGE_TRANSFER_BIT, - mipSubRange); + gpuTexture->vkImage, + VK_ACCESS_TRANSFER_WRITE_BIT, + VK_ACCESS_TRANSFER_READ_BIT, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + VK_PIPELINE_STAGE_TRANSFER_BIT, + VK_PIPELINE_STAGE_TRANSFER_BIT, + mipSubRange); VkImageBlit blit{}; //Source - blit.srcOffsets[1] = { mipWidth, mipHeight, 1 }; + blit.srcOffsets[1] = {mipWidth, mipHeight, 1}; blit.srcSubresource.aspectMask = gpuTexture->aspectMask; blit.srcSubresource.mipLevel = i - 1; blit.srcSubresource.layerCount = 1; //Destination - blit.dstOffsets[1] = { mipWidth > 1 ? mipWidth >> 1 : 1, mipHeight > 1 ? mipHeight >> 1 : 1, 1 }; + blit.dstOffsets[1] = {mipWidth > 1 ? mipWidth >> 1 : 1, mipHeight > 1 ? mipHeight >> 1 : 1, 1}; blit.dstSubresource.aspectMask = gpuTexture->aspectMask; blit.dstSubresource.mipLevel = i; blit.dstSubresource.layerCount = 1; vkCmdBlitImage(cmdBuff.vkCommandBuffer, - gpuTexture->vkImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - gpuTexture->vkImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - 1, &blit, - VK_FILTER_LINEAR); + gpuTexture->vkImage, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + gpuTexture->vkImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + 1, &blit, + VK_FILTER_LINEAR); insertImageMemoryBarrior(cmdBuff.vkCommandBuffer, - gpuTexture->vkImage, - VK_ACCESS_TRANSFER_READ_BIT, - gpuTexture->accessMask, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - gpuTexture->currentLayout, - VK_PIPELINE_STAGE_TRANSFER_BIT, - gpuTexture->targetStage, - mipSubRange); + gpuTexture->vkImage, + VK_ACCESS_TRANSFER_READ_BIT, + gpuTexture->accessMask, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + gpuTexture->currentLayout, + VK_PIPELINE_STAGE_TRANSFER_BIT, + gpuTexture->targetStage, + mipSubRange); if (mipWidth > 1) mipWidth = mipWidth >> 1; if (mipHeight > 1) mipHeight = mipHeight >> 1; @@ -1035,33 +946,29 @@ void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice* device, uint8_t* const* buffers mipSubRange.baseMipLevel = gpuTexture->mipLevel - 1; insertImageMemoryBarrior(cmdBuff.vkCommandBuffer, - gpuTexture->vkImage, - VK_ACCESS_TRANSFER_WRITE_BIT, - gpuTexture->accessMask, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - gpuTexture->currentLayout, - VK_PIPELINE_STAGE_TRANSFER_BIT, - gpuTexture->targetStage, - mipSubRange); - } - else - { + gpuTexture->vkImage, + VK_ACCESS_TRANSFER_WRITE_BIT, + gpuTexture->accessMask, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + gpuTexture->currentLayout, + VK_PIPELINE_STAGE_TRANSFER_BIT, + gpuTexture->targetStage, + mipSubRange); + } else { CC_LOG_WARNING("CCVKCmdFuncCopyBuffersToTexture: unsupported mipmap feature in optimal tiling."); } - } - else - { + } else { insertImageMemoryBarrior(cmdBuff.vkCommandBuffer, - gpuTexture->vkImage, - VK_ACCESS_TRANSFER_WRITE_BIT, - gpuTexture->accessMask, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - gpuTexture->currentLayout, - VK_PIPELINE_STAGE_TRANSFER_BIT, - gpuTexture->targetStage, - subresoureceRange); + gpuTexture->vkImage, + VK_ACCESS_TRANSFER_WRITE_BIT, + gpuTexture->accessMask, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + gpuTexture->currentLayout, + VK_PIPELINE_STAGE_TRANSFER_BIT, + gpuTexture->targetStage, + subresoureceRange); } - + endOneTimeCommands(device, &cmdBuff); } diff --git a/native/cocos/renderer/gfx-vulkan/VKCommands.h b/native/cocos/renderer/gfx-vulkan/VKCommands.h index fadc82cdb7..db04185102 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommands.h +++ b/native/cocos/renderer/gfx-vulkan/VKCommands.h @@ -7,65 +7,61 @@ NS_CC_BEGIN class CCVKDevice; -struct CCVKDepthBias -{ +struct CCVKDepthBias { float constant = 0.0f; float clamp = 0.0f; float slope = 0.0f; }; -struct CCVKDepthBounds -{ +struct CCVKDepthBounds { float minBounds = 0.0f; float maxBounds = 0.0f; }; -struct CCVKStencilWriteMask -{ +struct CCVKStencilWriteMask { GFXStencilFace face = GFXStencilFace::FRONT; uint32_t write_mask = 0; }; -struct CCVKStencilCompareMask -{ +struct CCVKStencilCompareMask { GFXStencilFace face = GFXStencilFace::FRONT; int reference = 0; uint32_t compareMask = 0; }; -CC_VULKAN_API void CCVKCmdFuncCreateRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRenderPass); -CC_VULKAN_API void CCVKCmdFuncDestroyRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRenderPass); -CC_VULKAN_API void CCVKCmdFuncGetDeviceQueue(CCVKDevice* device, CCVKGPUQueue* gpuQueue); -CC_VULKAN_API void CCVKCmdFuncCreateCommandPool(CCVKDevice* device, CCVKGPUCommandPool* gpuCommandPool); -CC_VULKAN_API void CCVKCmdFuncDestroyCommandPool(CCVKDevice* device, CCVKGPUCommandPool* gpuCommandPool); -CC_VULKAN_API void CCVKCmdFuncAllocateCommandBuffer(CCVKDevice* device, CCVKGPUCommandBuffer* gpuCommandBuffer); -CC_VULKAN_API void CCVKCmdFuncFreeCommandBuffer(CCVKDevice* device, CCVKGPUCommandBuffer* gpuCommandBuffer); +CC_VULKAN_API void CCVKCmdFuncCreateRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRenderPass); +CC_VULKAN_API void CCVKCmdFuncDestroyRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRenderPass); +CC_VULKAN_API void CCVKCmdFuncGetDeviceQueue(CCVKDevice *device, CCVKGPUQueue *gpuQueue); +CC_VULKAN_API void CCVKCmdFuncCreateCommandPool(CCVKDevice *device, CCVKGPUCommandPool *gpuCommandPool); +CC_VULKAN_API void CCVKCmdFuncDestroyCommandPool(CCVKDevice *device, CCVKGPUCommandPool *gpuCommandPool); +CC_VULKAN_API void CCVKCmdFuncAllocateCommandBuffer(CCVKDevice *device, CCVKGPUCommandBuffer *gpuCommandBuffer); +CC_VULKAN_API void CCVKCmdFuncFreeCommandBuffer(CCVKDevice *device, CCVKGPUCommandBuffer *gpuCommandBuffer); -CC_VULKAN_API void CCVKCmdFuncCreateBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer); -CC_VULKAN_API void CCVKCmdFuncDestroyBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer); -CC_VULKAN_API void CCVKCmdFuncResizeBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer); -CC_VULKAN_API void CCVKCmdFuncUpdateBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer, void* buffer, uint offset, uint size); -CC_VULKAN_API bool CCVKCmdFuncCreateTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture); -CC_VULKAN_API void CCVKCmdFuncDestroyTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture); -CC_VULKAN_API void CCVKCmdFuncCreateTextureView(CCVKDevice* device, CCVKGPUTextureView* gpuTextureView); -CC_VULKAN_API void CCVKCmdFuncDestroyTextureView(CCVKDevice* device, CCVKGPUTextureView* gpuTextureView); -CC_VULKAN_API void CCVKCmdFuncResizeTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture); -CC_VULKAN_API void CCVKCmdFuncCreateSampler(CCVKDevice* device, CCVKGPUSampler* gpuSampler); -CC_VULKAN_API void CCVKCmdFuncDestroySampler(CCVKDevice* device, CCVKGPUSampler* gpuSampler); -CC_VULKAN_API void CCVKCmdFuncCreateShader(CCVKDevice* device, CCVKGPUShader* gpuShader); -CC_VULKAN_API void CCVKCmdFuncDestroyShader(CCVKDevice* device, CCVKGPUShader* gpuShader); -CC_VULKAN_API void CCVKCmdFuncCreateInputAssembler(CCVKDevice* device, CCVKGPUInputAssembler* gpuInputAssembler); -CC_VULKAN_API void CCVKCmdFuncDestroyInputAssembler(CCVKDevice* device, CCVKGPUInputAssembler* gpuInputAssembler); -CC_VULKAN_API void CCVKCmdFuncCreateFramebuffer(CCVKDevice* device, CCVKGPUFramebuffer* gpuFramebuffer); -CC_VULKAN_API void CCVKCmdFuncDestroyFramebuffer(CCVKDevice* device, CCVKGPUFramebuffer* gpuFramebuffer); -CC_VULKAN_API void CCVKCmdFuncCreateBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* gpuBindingLayout, GFXBindingUnitList bindings); -CC_VULKAN_API void CCVKCmdFuncDestroyBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* gpuBindingLayout); -CC_VULKAN_API void CCVKCmdFuncCreatePipelineLayout(CCVKDevice* device, CCVKGPUPipelineLayout* gpuPipelineLayout); -CC_VULKAN_API void CCVKCmdFuncDestroyPipelineLayout(CCVKDevice* device, CCVKGPUPipelineLayout* gpuPipelineLayout); -CC_VULKAN_API void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gpuPipelineState); -CC_VULKAN_API void CCVKCmdFuncDestroyPipelineState(CCVKDevice* device, CCVKGPUPipelineState* gpuPipelineState); +CC_VULKAN_API void CCVKCmdFuncCreateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer); +CC_VULKAN_API void CCVKCmdFuncDestroyBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer); +CC_VULKAN_API void CCVKCmdFuncResizeBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer); +CC_VULKAN_API void CCVKCmdFuncUpdateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer, void *buffer, uint offset, uint size); +CC_VULKAN_API bool CCVKCmdFuncCreateTexture(CCVKDevice *device, CCVKGPUTexture *gpuTexture); +CC_VULKAN_API void CCVKCmdFuncDestroyTexture(CCVKDevice *device, CCVKGPUTexture *gpuTexture); +CC_VULKAN_API void CCVKCmdFuncCreateTextureView(CCVKDevice *device, CCVKGPUTextureView *gpuTextureView); +CC_VULKAN_API void CCVKCmdFuncDestroyTextureView(CCVKDevice *device, CCVKGPUTextureView *gpuTextureView); +CC_VULKAN_API void CCVKCmdFuncResizeTexture(CCVKDevice *device, CCVKGPUTexture *gpuTexture); +CC_VULKAN_API void CCVKCmdFuncCreateSampler(CCVKDevice *device, CCVKGPUSampler *gpuSampler); +CC_VULKAN_API void CCVKCmdFuncDestroySampler(CCVKDevice *device, CCVKGPUSampler *gpuSampler); +CC_VULKAN_API void CCVKCmdFuncCreateShader(CCVKDevice *device, CCVKGPUShader *gpuShader); +CC_VULKAN_API void CCVKCmdFuncDestroyShader(CCVKDevice *device, CCVKGPUShader *gpuShader); +CC_VULKAN_API void CCVKCmdFuncCreateInputAssembler(CCVKDevice *device, CCVKGPUInputAssembler *gpuInputAssembler); +CC_VULKAN_API void CCVKCmdFuncDestroyInputAssembler(CCVKDevice *device, CCVKGPUInputAssembler *gpuInputAssembler); +CC_VULKAN_API void CCVKCmdFuncCreateFramebuffer(CCVKDevice *device, CCVKGPUFramebuffer *gpuFramebuffer); +CC_VULKAN_API void CCVKCmdFuncDestroyFramebuffer(CCVKDevice *device, CCVKGPUFramebuffer *gpuFramebuffer); +CC_VULKAN_API void CCVKCmdFuncCreateBindingLayout(CCVKDevice *device, CCVKGPUBindingLayout *gpuBindingLayout, GFXBindingUnitList bindings); +CC_VULKAN_API void CCVKCmdFuncDestroyBindingLayout(CCVKDevice *device, CCVKGPUBindingLayout *gpuBindingLayout); +CC_VULKAN_API void CCVKCmdFuncCreatePipelineLayout(CCVKDevice *device, CCVKGPUPipelineLayout *gpuPipelineLayout); +CC_VULKAN_API void CCVKCmdFuncDestroyPipelineLayout(CCVKDevice *device, CCVKGPUPipelineLayout *gpuPipelineLayout); +CC_VULKAN_API void CCVKCmdFuncCreatePipelineState(CCVKDevice *device, CCVKGPUPipelineState *gpuPipelineState); +CC_VULKAN_API void CCVKCmdFuncDestroyPipelineState(CCVKDevice *device, CCVKGPUPipelineState *gpuPipelineState); -CC_VULKAN_API void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice* device, uint8_t* const* buffers, CCVKGPUTexture* gpuTexture, const GFXBufferTextureCopyList& regions); +CC_VULKAN_API void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, uint8_t *const *buffers, CCVKGPUTexture *gpuTexture, const GFXBufferTextureCopyList ®ions); NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKContext.cc b/native/cocos/renderer/gfx-vulkan/VKContext.cc index d5d711f70a..7a75375d53 100644 --- a/native/cocos/renderer/gfx-vulkan/VKContext.cc +++ b/native/cocos/renderer/gfx-vulkan/VKContext.cc @@ -1,73 +1,59 @@ #include "VKStd.h" + #include "VKContext.h" -#include "VKUtils.h" -#include "VKGPUObjects.h" #include "VKDevice.h" +#include "VKGPUObjects.h" #include "VKRenderPass.h" #include "VKTexture.h" #include "VKTextureView.h" +#include "VKUtils.h" #define CC_GFX_DEBUG NS_CC_BEGIN -namespace -{ +namespace { #ifdef CC_GFX_DEBUG - VKAPI_ATTR VkBool32 VKAPI_CALL debugUtilsMessengerCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT *callbackData, void * user_data) - { - // https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/1818 - if (!strcmp(callbackData->pMessageIdName, "VUID-vkQueuePresentKHR-pWaitSemaphores-03268")) - { - return VK_FALSE; - } - // TODO: handle the few frames with no command submission at start up - if (!strcmp(callbackData->pMessageIdName, "VUID-VkPresentInfoKHR-pImageIndices-01296")) - { - return VK_FALSE; - } - - // Log debug messge - if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) - { - CC_LOG_WARNING("%s: %s", callbackData->pMessageIdName, callbackData->pMessage); - } - else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) - { - CC_LOG_ERROR("%s: %s", callbackData->pMessageIdName, callbackData->pMessage); - CCASSERT(0, "Validation Error"); - } +VKAPI_ATTR VkBool32 VKAPI_CALL debugUtilsMessengerCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT *callbackData, void *user_data) { + // https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/1818 + if (!strcmp(callbackData->pMessageIdName, "VUID-vkQueuePresentKHR-pWaitSemaphores-03268")) { + return VK_FALSE; + } + // TODO: handle the few frames with no command submission at start up + if (!strcmp(callbackData->pMessageIdName, "VUID-VkPresentInfoKHR-pImageIndices-01296")) { return VK_FALSE; } - VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallback(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT type, - uint64_t object, size_t location, int32_t messageCode, const char *layerPrefix, const char *message, void *userData) - { - if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) - { - CC_LOG_ERROR("VError: %s: %s", layerPrefix, message); - CCASSERT(0, "Validation Error"); - } - else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) - { - CC_LOG_ERROR("VWarning: %s: %s", layerPrefix, message); - } - else if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) - { - CC_LOG_INFO("VPerfWarning: %s: %s", layerPrefix, message); - } - else - { - CC_LOG_INFO("VInfo: %s: %s", layerPrefix, message); - } - return VK_FALSE; + // Log debug messge + if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) { + CC_LOG_WARNING("%s: %s", callbackData->pMessageIdName, callbackData->pMessage); + } else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) { + CC_LOG_ERROR("%s: %s", callbackData->pMessageIdName, callbackData->pMessage); + CCASSERT(0, "Validation Error"); } -#endif + return VK_FALSE; } -CCVKContext::CCVKContext(GFXDevice* device) - : GFXContext(device){ +VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallback(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT type, + uint64_t object, size_t location, int32_t messageCode, const char *layerPrefix, const char *message, void *userData) { + if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) { + CC_LOG_ERROR("VError: %s: %s", layerPrefix, message); + CCASSERT(0, "Validation Error"); + } else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) { + CC_LOG_ERROR("VWarning: %s: %s", layerPrefix, message); + } else if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) { + CC_LOG_INFO("VPerfWarning: %s: %s", layerPrefix, message); + } else { + CC_LOG_INFO("VInfo: %s: %s", layerPrefix, message); + } + return VK_FALSE; +} +#endif +} // namespace + +CCVKContext::CCVKContext(GFXDevice *device) +: GFXContext(device) { } CCVKContext::~CCVKContext() { @@ -78,28 +64,24 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { _vsyncMode = info.vsyncMode; _windowHandle = info.windowHandle; - if (!info.sharedCtx) - { + if (!info.sharedCtx) { _isPrimaryContex = true; _windowHandle = info.windowHandle; _gpuContext = CC_NEW(CCVKGPUContext); // only enable the absolute essentials for now - vector::type requestedLayers - { + vector::type requestedLayers{ }; - vector::type requestedExtensions - { + vector::type requestedExtensions{ VK_KHR_SURFACE_EXTENSION_NAME, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, }; ///////////////////// Instance Creation ///////////////////// - if (volkInitialize()) - { + if (volkInitialize()) { return false; } @@ -126,13 +108,12 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { #elif defined(VK_USE_PLATFORM_XCB_KHR) requestedExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME); #else -# pragma error Platform not supported + #pragma error Platform not supported #endif #ifdef CC_GFX_DEBUG // Determine the optimal validation layers to enable that are necessary for useful debugging - vector::type>::type validationLayerPriorityList - { + vector::type>::type validationLayerPriorityList{ // The preferred validation layer is "VK_LAYER_KHRONOS_validation" {"VK_LAYER_KHRONOS_validation"}, @@ -149,21 +130,16 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { }, // Otherwise as a last resort we fallback to attempting to enable the LunarG core layer - {"VK_LAYER_LUNARG_core_validation"} - }; - for (vector::type &validationLayers : validationLayerPriorityList) - { + {"VK_LAYER_LUNARG_core_validation"}}; + for (vector::type &validationLayers : validationLayerPriorityList) { bool found = true; - for (const char* layer : validationLayers) - { - if (!isLayerSupported(layer, supportedLayers)) - { + for (const char *layer : validationLayers) { + if (!isLayerSupported(layer, supportedLayers)) { found = false; break; } } - if (found) - { + if (found) { requestedLayers.insert(requestedLayers.end(), validationLayers.begin(), validationLayers.end()); break; } @@ -171,29 +147,22 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { // Check if VK_EXT_debug_utils is supported, which supersedes VK_EXT_Debug_Report bool debugUtils = false; - if (isExtensionSupported(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, supportedExtensions)) - { + if (isExtensionSupported(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, supportedExtensions)) { debugUtils = true; requestedExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); - } - else - { + } else { requestedExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME); } #endif // just filter out the unsupported layers & extensions - for (const char* layer : requestedLayers) - { - if (isLayerSupported(layer, supportedLayers)) - { + for (const char *layer : requestedLayers) { + if (isLayerSupported(layer, supportedLayers)) { _layers.push_back(layer); } } - for (const char* extension : requestedExtensions) - { - if (isExtensionSupported(extension, supportedExtensions)) - { + for (const char *extension : requestedExtensions) { + if (isExtensionSupported(extension, supportedExtensions)) { _extensions.push_back(extension); } } @@ -205,11 +174,11 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { _majorVersion = VK_VERSION_MAJOR(apiVersion); _minorVersion = VK_VERSION_MINOR(apiVersion); - VkApplicationInfo app{ VK_STRUCTURE_TYPE_APPLICATION_INFO }; + VkApplicationInfo app{VK_STRUCTURE_TYPE_APPLICATION_INFO}; app.pEngineName = "Cocos Creator"; app.apiVersion = apiVersion; - VkInstanceCreateInfo instanceInfo{ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO }; + VkInstanceCreateInfo instanceInfo{VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO}; instanceInfo.pApplicationInfo = &app; instanceInfo.enabledExtensionCount = toUint(_extensions.size()); instanceInfo.ppEnabledExtensionNames = _extensions.data(); @@ -217,18 +186,15 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { instanceInfo.ppEnabledLayerNames = _layers.data(); #ifdef CC_GFX_DEBUG - VkDebugUtilsMessengerCreateInfoEXT debugUtilsCreateInfo{ VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT }; - VkDebugReportCallbackCreateInfoEXT debugReportCreateInfo{ VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT }; - if (debugUtils) - { + VkDebugUtilsMessengerCreateInfoEXT debugUtilsCreateInfo{VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT}; + VkDebugReportCallbackCreateInfoEXT debugReportCreateInfo{VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT}; + if (debugUtils) { debugUtilsCreateInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT; debugUtilsCreateInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT; debugUtilsCreateInfo.pfnUserCallback = debugUtilsMessengerCallback; instanceInfo.pNext = &debugUtilsCreateInfo; - } - else - { + } else { debugReportCreateInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT; debugReportCreateInfo.pfnCallback = debugReportCallback; @@ -242,12 +208,9 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { volkLoadInstance(_gpuContext->vkInstance); #ifdef CC_GFX_DEBUG - if (debugUtils) - { + if (debugUtils) { VK_CHECK(vkCreateDebugUtilsMessengerEXT(_gpuContext->vkInstance, &debugUtilsCreateInfo, nullptr, &_gpuContext->vkDebugUtilsMessenger)); - } - else - { + } else { VK_CHECK(vkCreateDebugReportCallbackEXT(_gpuContext->vkInstance, &debugReportCreateInfo, nullptr, &_gpuContext->vkDebugReport)); } #endif @@ -255,44 +218,43 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { ///////////////////// Surface Creation ///////////////////// #if defined(VK_USE_PLATFORM_ANDROID_KHR) - VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR }; - surfaceCreateInfo.window = (ANativeWindow*)_windowHandle; + VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo{VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR}; + surfaceCreateInfo.window = (ANativeWindow *)_windowHandle; VK_CHECK(vkCreateAndroidSurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface)); #elif defined(VK_USE_PLATFORM_WIN32_KHR) - VkWin32SurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR }; + VkWin32SurfaceCreateInfoKHR surfaceCreateInfo{VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR}; surfaceCreateInfo.hinstance = (HINSTANCE)GetModuleHandle(0); surfaceCreateInfo.hwnd = (HWND)_windowHandle; VK_CHECK(vkCreateWin32SurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface)); #elif defined(VK_USE_PLATFORM_IOS_MVK) - VkIOSSurfaceCreateInfoMVK surfaceCreateInfo{ VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK }; - surfaceCreateInfo.pView = (void*)_windowHandle; + VkIOSSurfaceCreateInfoMVK surfaceCreateInfo{VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK}; + surfaceCreateInfo.pView = (void *)_windowHandle; VK_CHECK(vkCreateIOSSurfaceMVK(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface)); #elif defined(VK_USE_PLATFORM_MACOS_MVK) - VkMacOSSurfaceCreateInfoMVK surfaceCreateInfo{ VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK }; - surfaceCreateInfo.pView = (void*)_windowHandle; + VkMacOSSurfaceCreateInfoMVK surfaceCreateInfo{VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK}; + surfaceCreateInfo.pView = (void *)_windowHandle; VK_CHECK(vkCreateMacOSSurfaceMVK(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface)); #elif defined(VK_USE_PLATFORM_WAYLAND_KHR) - VkWaylandSurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR }; + VkWaylandSurfaceCreateInfoKHR surfaceCreateInfo{VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR}; surfaceCreateInfo.display = nullptr; // TODO - surfaceCreateInfo.surface = (wl_surface*)_windowHandle; + surfaceCreateInfo.surface = (wl_surface *)_windowHandle; VK_CHECK(vkCreateWaylandSurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface)); #elif defined(VK_USE_PLATFORM_XCB_KHR) - VkXcbSurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR }; + VkXcbSurfaceCreateInfoKHR surfaceCreateInfo{VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR}; surfaceCreateInfo.connection = nullptr; // TODO surfaceCreateInfo.window = (xcb_window_t)_windowHandle; VK_CHECK(vkCreateXcbSurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface)); #else -# pragma error Platform not supported + #pragma error Platform not supported #endif ///////////////////// Physical Device Selection ///////////////////// // Querying valid physical devices on the machine - uint physicalDeviceCount{ 0 }; + uint physicalDeviceCount{0}; VK_CHECK(vkEnumeratePhysicalDevices(_gpuContext->vkInstance, &physicalDeviceCount, nullptr)); - if (physicalDeviceCount < 1) - { + if (physicalDeviceCount < 1) { return false; } @@ -302,17 +264,14 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { vector::type physicalDeviceProperties(physicalDeviceCount); uint deviceIndex; - for (deviceIndex = 0u; deviceIndex < physicalDeviceCount; ++deviceIndex) - { - VkPhysicalDeviceProperties& properties = physicalDeviceProperties[deviceIndex]; + for (deviceIndex = 0u; deviceIndex < physicalDeviceCount; ++deviceIndex) { + VkPhysicalDeviceProperties &properties = physicalDeviceProperties[deviceIndex]; vkGetPhysicalDeviceProperties(physicalDeviceHandles[deviceIndex], &properties); } - for (deviceIndex = 0u; deviceIndex < physicalDeviceCount; ++deviceIndex) - { - VkPhysicalDeviceProperties& properties = physicalDeviceProperties[deviceIndex]; - if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) - { + for (deviceIndex = 0u; deviceIndex < physicalDeviceCount; ++deviceIndex) { + VkPhysicalDeviceProperties &properties = physicalDeviceProperties[deviceIndex]; + if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) { break; } } @@ -322,8 +281,7 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { vkGetPhysicalDeviceFeatures(_gpuContext->physicalDevice, &_gpuContext->physicalDeviceFeatures); _gpuContext->physicalDeviceFeatures2.pNext = &_gpuContext->physicalDeviceVulkan11Features; _gpuContext->physicalDeviceVulkan11Features.pNext = &_gpuContext->physicalDeviceVulkan12Features; - if (_minorVersion >= 1 || checkExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) - { + if (_minorVersion >= 1 || checkExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { vkGetPhysicalDeviceFeatures2(_gpuContext->physicalDevice, &_gpuContext->physicalDeviceFeatures2); } @@ -333,10 +291,9 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { _gpuContext->queueFamilyProperties.resize(queueFamilyPropertiesCount); vkGetPhysicalDeviceQueueFamilyProperties(_gpuContext->physicalDevice, &queueFamilyPropertiesCount, _gpuContext->queueFamilyProperties.data()); _gpuContext->queueFamilyPresentables.resize(queueFamilyPropertiesCount); - for (uint propertyIndex = 0U; propertyIndex < queueFamilyPropertiesCount; propertyIndex++) - { + for (uint propertyIndex = 0U; propertyIndex < queueFamilyPropertiesCount; propertyIndex++) { vkGetPhysicalDeviceSurfaceSupportKHR(_gpuContext->physicalDevice, propertyIndex, - _gpuContext->vkSurface, &_gpuContext->queueFamilyPresentables[propertyIndex]); + _gpuContext->vkSurface, &_gpuContext->queueFamilyPresentables[propertyIndex]); } ///////////////////// Swapchain Preperation ///////////////////// @@ -357,26 +314,21 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { vector::type presentModes(presentModeCount); VK_CHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(_gpuContext->physicalDevice, _gpuContext->vkSurface, &presentModeCount, presentModes.data())); - VkExtent2D imageExtent{ 1u, 1u }; + VkExtent2D imageExtent{1u, 1u}; VkFormat colorFormat = VK_FORMAT_B8G8R8A8_UNORM; VkColorSpaceKHR colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; // If the surface format list only includes one entry with VK_FORMAT_UNDEFINED, // there is no preferered format, so we assume VK_FORMAT_B8G8R8A8_UNORM - if ((surfaceFormatCount == 1) && (surfaceFormats[0].format == VK_FORMAT_UNDEFINED)) - { + if ((surfaceFormatCount == 1) && (surfaceFormats[0].format == VK_FORMAT_UNDEFINED)) { colorFormat = VK_FORMAT_B8G8R8A8_UNORM; colorSpace = surfaceFormats[0].colorSpace; - } - else - { + } else { // iterate over the list of available surface format and // check for the presence of VK_FORMAT_B8G8R8A8_UNORM bool imageFormatFound = false; - for (VkSurfaceFormatKHR &surfaceFormat : surfaceFormats) - { - if (surfaceFormat.format == VK_FORMAT_B8G8R8A8_UNORM) - { + for (VkSurfaceFormatKHR &surfaceFormat : surfaceFormats) { + if (surfaceFormat.format == VK_FORMAT_B8G8R8A8_UNORM) { colorFormat = surfaceFormat.format; colorSpace = surfaceFormat.colorSpace; imageFormatFound = true; @@ -386,30 +338,25 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { // in case VK_FORMAT_B8G8R8A8_UNORM is not available // select the first available color format - if (!imageFormatFound) - { + if (!imageFormatFound) { colorFormat = surfaceFormats[0].format; colorSpace = surfaceFormats[0].colorSpace; } } vector>::type depthFormatPriorityList = - { - { GFXFormat::D32F_S8, VK_FORMAT_D32_SFLOAT_S8_UINT }, - { GFXFormat::D24S8, VK_FORMAT_D24_UNORM_S8_UINT }, - { GFXFormat::D16S8, VK_FORMAT_D16_UNORM_S8_UINT }, - { GFXFormat::D32F, VK_FORMAT_D32_SFLOAT }, - { GFXFormat::D16, VK_FORMAT_D16_UNORM } - }; - for (std::pair &format : depthFormatPriorityList) - { + { + {GFXFormat::D32F_S8, VK_FORMAT_D32_SFLOAT_S8_UINT}, + {GFXFormat::D24S8, VK_FORMAT_D24_UNORM_S8_UINT}, + {GFXFormat::D16S8, VK_FORMAT_D16_UNORM_S8_UINT}, + {GFXFormat::D32F, VK_FORMAT_D32_SFLOAT}, + {GFXFormat::D16, VK_FORMAT_D16_UNORM}}; + for (std::pair &format : depthFormatPriorityList) { VkFormatProperties formatProperties; vkGetPhysicalDeviceFormatProperties(_gpuContext->physicalDevice, format.second, &formatProperties); // Format must support depth stencil attachment for optimal tiling - if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) - { - if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) - { + if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) { + if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) { _depthStencilFmt = format.first; break; } @@ -420,41 +367,34 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { vector::type presentModePriorityList; - switch (_vsyncMode) - { - case GFXVsyncMode::OFF: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR }); break; - case GFXVsyncMode::ON: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_FIFO_KHR }); break; - case GFXVsyncMode::RELAXED: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_FIFO_RELAXED_KHR, VK_PRESENT_MODE_FIFO_KHR }); break; - case GFXVsyncMode::MAILBOX: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR }); break; - case GFXVsyncMode::HALF: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_FIFO_KHR }); break; // TODO + switch (_vsyncMode) { + case GFXVsyncMode::OFF: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR}); break; + case GFXVsyncMode::ON: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_KHR}); break; + case GFXVsyncMode::RELAXED: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_RELAXED_KHR, VK_PRESENT_MODE_FIFO_KHR}); break; + case GFXVsyncMode::MAILBOX: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR}); break; + case GFXVsyncMode::HALF: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_KHR}); break; // TODO } VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR; - for (VkPresentModeKHR presentMode : presentModePriorityList) - { - if (std::find(presentModes.begin(), presentModes.end(), presentMode) != presentModes.end()) - { + for (VkPresentModeKHR presentMode : presentModePriorityList) { + if (std::find(presentModes.begin(), presentModes.end(), presentMode) != presentModes.end()) { swapchainPresentMode = presentMode; } } // Determine the number of images uint desiredNumberOfSwapchainImages = surfaceCapabilities.minImageCount + 1; - if ((surfaceCapabilities.maxImageCount > 0) && (desiredNumberOfSwapchainImages > surfaceCapabilities.maxImageCount)) - { + if ((surfaceCapabilities.maxImageCount > 0) && (desiredNumberOfSwapchainImages > surfaceCapabilities.maxImageCount)) { desiredNumberOfSwapchainImages = surfaceCapabilities.maxImageCount; } // Find the transformation of the surface VkSurfaceTransformFlagBitsKHR preTransform; - if (surfaceCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) - { + if (surfaceCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) { // We prefer a non-rotated transform preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; - } - else - { + } else { preTransform = surfaceCapabilities.currentTransform; } @@ -467,24 +407,20 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR, VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR, }; - for (VkCompositeAlphaFlagBitsKHR compositeAlphaFlag : compositeAlphaFlags) - { - if (surfaceCapabilities.supportedCompositeAlpha & compositeAlphaFlag) - { + for (VkCompositeAlphaFlagBitsKHR compositeAlphaFlag : compositeAlphaFlags) { + if (surfaceCapabilities.supportedCompositeAlpha & compositeAlphaFlag) { compositeAlpha = compositeAlphaFlag; break; }; } VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; // Enable transfer source on swap chain images if supported - if (surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) - { + if (surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) { imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; } // Enable transfer destination on swap chain images if supported - if (surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT) - { + if (surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT) { imageUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; } @@ -501,42 +437,36 @@ bool CCVKContext::initialize(const GFXContextInfo &info) { _gpuContext->swapchainCreateInfo.clipped = VK_TRUE; // Setting clipped to VK_TRUE allows the implementation to discard rendering outside of the surface area } else { - CCVKContext* sharedCtx = (CCVKContext*)info.sharedCtx; + CCVKContext *sharedCtx = (CCVKContext *)info.sharedCtx; - _majorVersion = sharedCtx->majorVersion(); - _minorVersion = sharedCtx->minorVersion(); + _majorVersion = sharedCtx->majorVersion(); + _minorVersion = sharedCtx->minorVersion(); - // TODO + // TODO } return true; } -void CCVKContext::destroy() -{ - if (_gpuContext) - { - if (_gpuContext->vkSurface != VK_NULL_HANDLE) - { +void CCVKContext::destroy() { + if (_gpuContext) { + if (_gpuContext->vkSurface != VK_NULL_HANDLE) { vkDestroySurfaceKHR(_gpuContext->vkInstance, _gpuContext->vkSurface, nullptr); _gpuContext->vkSurface = VK_NULL_HANDLE; } #ifdef CC_GFX_DEBUG - if (_gpuContext->vkDebugUtilsMessenger != VK_NULL_HANDLE) - { + if (_gpuContext->vkDebugUtilsMessenger != VK_NULL_HANDLE) { vkDestroyDebugUtilsMessengerEXT(_gpuContext->vkInstance, _gpuContext->vkDebugUtilsMessenger, nullptr); _gpuContext->vkDebugUtilsMessenger = VK_NULL_HANDLE; } - if (_gpuContext->vkDebugReport != VK_NULL_HANDLE) - { + if (_gpuContext->vkDebugReport != VK_NULL_HANDLE) { vkDestroyDebugReportCallbackEXT(_gpuContext->vkInstance, _gpuContext->vkDebugReport, nullptr); _gpuContext->vkDebugReport = VK_NULL_HANDLE; } #endif - if (_gpuContext->vkInstance != VK_NULL_HANDLE) - { + if (_gpuContext->vkInstance != VK_NULL_HANDLE) { vkDestroyInstance(_gpuContext->vkInstance, nullptr); _gpuContext->vkInstance = VK_NULL_HANDLE; } diff --git a/native/cocos/renderer/gfx-vulkan/VKContext.h b/native/cocos/renderer/gfx-vulkan/VKContext.h index a64eae38a2..c540f303af 100644 --- a/native/cocos/renderer/gfx-vulkan/VKContext.h +++ b/native/cocos/renderer/gfx-vulkan/VKContext.h @@ -11,7 +11,7 @@ class CCVKGPUSemaphorePool; class CC_VULKAN_API CCVKContext : public GFXContext { public: - CCVKContext(GFXDevice* device); + CCVKContext(GFXDevice *device); ~CCVKContext(); public: @@ -19,23 +19,21 @@ public: void destroy(); void present() {} - CC_INLINE bool checkExtension(const String &extension) const - { + CC_INLINE bool checkExtension(const String &extension) const { return std::find_if(_extensions.begin(), _extensions.end(), - [extension](const char* device_extension) - { - return std::strcmp(device_extension, extension.c_str()) == 0; - }) != _extensions.end(); + [extension](const char *device_extension) { + return std::strcmp(device_extension, extension.c_str()) == 0; + }) != _extensions.end(); } CC_INLINE int majorVersion() const { return _majorVersion; } CC_INLINE int minorVersion() const { return _minorVersion; } - CC_INLINE CCVKGPUContext* gpuContext() { return _gpuContext; } - CC_INLINE const vector::type& getLayers() const { return _layers; } - CC_INLINE const vector::type& getExtensions() const { return _extensions; } + CC_INLINE CCVKGPUContext *gpuContext() { return _gpuContext; } + CC_INLINE const vector::type &getLayers() const { return _layers; } + CC_INLINE const vector::type &getExtensions() const { return _extensions; } private: - CCVKGPUContext* _gpuContext = nullptr; + CCVKGPUContext *_gpuContext = nullptr; bool _isPrimaryContex = false; int _majorVersion = 0; int _minorVersion = 0; diff --git a/native/cocos/renderer/gfx-vulkan/VKDevice.cc b/native/cocos/renderer/gfx-vulkan/VKDevice.cc index d3a62f772a..8ca443ec64 100644 --- a/native/cocos/renderer/gfx-vulkan/VKDevice.cc +++ b/native/cocos/renderer/gfx-vulkan/VKDevice.cc @@ -1,23 +1,24 @@ #include "VKStd.h" -#include "VKDevice.h" -#include "VKUtils.h" -#include "VKContext.h" -#include "VKWindow.h" -#include "VKFence.h" -#include "VKQueue.h" + +#include "VKBindingLayout.h" +#include "VKBuffer.h" #include "VKCommandAllocator.h" #include "VKCommandBuffer.h" -#include "VKBuffer.h" -#include "VKTexture.h" -#include "VKTextureView.h" -#include "VKSampler.h" -#include "VKShader.h" -#include "VKInputAssembler.h" -#include "VKRenderPass.h" +#include "VKContext.h" +#include "VKDevice.h" +#include "VKFence.h" #include "VKFramebuffer.h" -#include "VKBindingLayout.h" +#include "VKInputAssembler.h" #include "VKPipelineLayout.h" #include "VKPipelineState.h" +#include "VKQueue.h" +#include "VKRenderPass.h" +#include "VKSampler.h" +#include "VKShader.h" +#include "VKTexture.h" +#include "VKTextureView.h" +#include "VKUtils.h" +#include "VKWindow.h" CC_DISABLE_WARNINGS() #define VMA_IMPLEMENTATION @@ -26,23 +27,19 @@ CC_ENABLE_WARNINGS() NS_CC_BEGIN -CCVKDevice::CCVKDevice() -{ +CCVKDevice::CCVKDevice() { _minClipZ = 0.0f; _projectionSignY = -1.0f; } -CCVKDevice::~CCVKDevice() -{ +CCVKDevice::~CCVKDevice() { } -CCVKGPUContext* CCVKDevice::gpuContext() const -{ - return ((CCVKContext*)_context)->gpuContext(); +CCVKGPUContext *CCVKDevice::gpuContext() const { + return ((CCVKContext *)_context)->gpuContext(); } -bool CCVKDevice::initialize(const GFXDeviceInfo& info) -{ +bool CCVKDevice::initialize(const GFXDeviceInfo &info) { _gfxAPI = GFXAPI::VULKAN; _deviceName = "Vulkan"; _width = info.width; @@ -56,32 +53,29 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) contextCreateInfo.sharedCtx = info.sharedCtx; _context = CC_NEW(CCVKContext(this)); - if (!_context->initialize(contextCreateInfo)) - { + if (!_context->initialize(contextCreateInfo)) { destroy(); return false; } - const CCVKContext* context = (CCVKContext*)_context; - const CCVKGPUContext* gpuContext = ((CCVKContext*)_context)->gpuContext(); + const CCVKContext *context = (CCVKContext *)_context; + const CCVKGPUContext *gpuContext = ((CCVKContext *)_context)->gpuContext(); const VkPhysicalDeviceFeatures &deviceFeatures = gpuContext->physicalDeviceFeatures; const VkPhysicalDeviceFeatures2 &deviceFeatures2 = gpuContext->physicalDeviceFeatures2; const VkPhysicalDeviceVulkan11Features &deviceVulkan11Features = gpuContext->physicalDeviceVulkan11Features; const VkPhysicalDeviceVulkan12Features &deviceVulkan12Features = gpuContext->physicalDeviceVulkan12Features; // only enable the absolute essentials for now - std::vector requestedValidationLayers - { + std::vector requestedValidationLayers{ "VK_LAYER_KHRONOS_validation", }; - std::vector requestedExtensions - { + std::vector requestedExtensions{ VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, }; - VkPhysicalDeviceFeatures2 requestedFeatures2{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 }; - VkPhysicalDeviceVulkan11Features requestedVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES }; - VkPhysicalDeviceVulkan12Features requestedVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES }; + VkPhysicalDeviceFeatures2 requestedFeatures2{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2}; + VkPhysicalDeviceVulkan11Features requestedVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES}; + VkPhysicalDeviceVulkan12Features requestedVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES}; // features should be enabled like this: requestedFeatures2.features.textureCompressionASTC_LDR = deviceFeatures2.features.textureCompressionASTC_LDR; requestedFeatures2.features.textureCompressionBC = deviceFeatures2.features.textureCompressionBC; @@ -104,28 +98,23 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) VK_CHECK(vkEnumerateDeviceExtensionProperties(gpuContext->physicalDevice, nullptr, &availableExtensionCount, _gpuDevice->extensions.data())); // just filter out the unsupported layers & extensions - for (const char* layer : requestedValidationLayers) - { - if (isLayerSupported(layer, _gpuDevice->layers)) - { + for (const char *layer : requestedValidationLayers) { + if (isLayerSupported(layer, _gpuDevice->layers)) { _layers.push_back(layer); } } - for (const char* extension : requestedExtensions) - { - if (isExtensionSupported(extension, _gpuDevice->extensions)) - { + for (const char *extension : requestedExtensions) { + if (isExtensionSupported(extension, _gpuDevice->extensions)) { _extensions.push_back(extension); } } // prepare the device queues - uint queueFamilyPropertiesCount = toUint(gpuContext->queueFamilyProperties.size()); - std::vector queueCreateInfos(queueFamilyPropertiesCount, { VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO }); - std::vector> queuePriorities(queueFamilyPropertiesCount); + uint queueFamilyPropertiesCount = toUint(gpuContext->queueFamilyProperties.size()); + std::vector queueCreateInfos(queueFamilyPropertiesCount, {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO}); + std::vector> queuePriorities(queueFamilyPropertiesCount); - for (uint queueFamilyIndex = 0u; queueFamilyIndex < queueFamilyPropertiesCount; ++queueFamilyIndex) - { + for (uint queueFamilyIndex = 0u; queueFamilyIndex < queueFamilyPropertiesCount; ++queueFamilyIndex) { const VkQueueFamilyProperties &queueFamilyProperty = gpuContext->queueFamilyProperties[queueFamilyIndex]; queuePriorities[queueFamilyIndex].resize(queueFamilyProperty.queueCount, 1.0f); @@ -137,7 +126,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) queueCreateInfo.pQueuePriorities = queuePriorities[queueFamilyIndex].data(); } - VkDeviceCreateInfo deviceCreateInfo{ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO }; + VkDeviceCreateInfo deviceCreateInfo{VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO}; deviceCreateInfo.queueCreateInfoCount = toUint(queueCreateInfos.size()); deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data(); @@ -146,12 +135,9 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) deviceCreateInfo.enabledExtensionCount = toUint(_extensions.size()); deviceCreateInfo.ppEnabledExtensionNames = _extensions.data(); if (context->minorVersion() < 1 && - !context->checkExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) - { + !context->checkExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { deviceCreateInfo.pEnabledFeatures = &requestedFeatures2.features; - } - else - { + } else { deviceCreateInfo.pNext = &requestedFeatures2; if (context->minorVersion() >= 1) requestedFeatures2.pNext = &requestedVulkan11Features; if (context->minorVersion() >= 2) requestedVulkan11Features.pNext = &requestedVulkan12Features; @@ -178,15 +164,14 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) vmaVulkanFunc.vkInvalidateMappedMemoryRanges = vkInvalidateMappedMemoryRanges; vmaVulkanFunc.vkMapMemory = vkMapMemory; vmaVulkanFunc.vkUnmapMemory = vkUnmapMemory; - + VmaAllocatorCreateInfo allocatorInfo{}; allocatorInfo.physicalDevice = gpuContext->physicalDevice; allocatorInfo.device = _gpuDevice->vkDevice; allocatorInfo.instance = gpuContext->vkInstance; - if (checkExtension(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME) && - checkExtension(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME)) - { + if (checkExtension(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME) && + checkExtension(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME)) { allocatorInfo.flags |= VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT; vmaVulkanFunc.vkGetBufferMemoryRequirements2KHR = vkGetBufferMemoryRequirements2KHR; vmaVulkanFunc.vkGetImageMemoryRequirements2KHR = vkGetImageMemoryRequirements2KHR; @@ -204,7 +189,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) stagingBufferInfo.memUsage = GFXMemoryUsage::HOST; stagingBufferInfo.stride = _defaultStagingBufferSize; stagingBufferInfo.size = _defaultStagingBufferSize; - _stagingBuffer = (CCVKBuffer*)createBuffer(stagingBufferInfo); + _stagingBuffer = (CCVKBuffer *)createBuffer(stagingBufferInfo); GFXQueueInfo queueInfo; queueInfo.type = GFXQueueType::GRAPHICS; @@ -213,22 +198,21 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) GFXCommandAllocatorInfo cmdAllocInfo; _cmdAllocator = createCommandAllocator(cmdAllocInfo); - for (uint i = 0; i < gpuContext->swapchainCreateInfo.minImageCount; i++) - { + for (uint i = 0; i < gpuContext->swapchainCreateInfo.minImageCount; i++) { GFXTextureInfo depthStecnilTexInfo; depthStecnilTexInfo.type = GFXTextureType::TEX2D; depthStecnilTexInfo.usage = GFXTextureUsageBit::DEPTH_STENCIL_ATTACHMENT | GFXTextureUsageBit::SAMPLED; depthStecnilTexInfo.format = _context->getDepthStencilFormat(); depthStecnilTexInfo.width = 1; depthStecnilTexInfo.height = 1; - CCVKTexture* texture = (CCVKTexture*)createTexture(depthStecnilTexInfo); + CCVKTexture *texture = (CCVKTexture *)createTexture(depthStecnilTexInfo); _depthStencilTextures.push_back(texture); GFXTextureViewInfo depthStecnilTexViewInfo; depthStecnilTexViewInfo.texture = texture; depthStecnilTexViewInfo.type = GFXTextureViewType::TV2D; depthStecnilTexViewInfo.format = _context->getDepthStencilFormat(); - CCVKTextureView* textureView = (CCVKTextureView*)createTextureView(depthStecnilTexViewInfo); + CCVKTextureView *textureView = (CCVKTextureView *)createTextureView(depthStecnilTexViewInfo); _depthStencilTextureViews.push_back(textureView); } @@ -242,7 +226,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) colorAttachment.endLayout = GFXTextureLayout::PRESENT_SRC; renderPassInfo.colorAttachments.emplace_back(colorAttachment); - GFXDepthStencilAttachment& depthStencilAttachment = renderPassInfo.depthStencilAttachment; + GFXDepthStencilAttachment &depthStencilAttachment = renderPassInfo.depthStencilAttachment; depthStencilAttachment.format = _context->getDepthStencilFormat(); depthStencilAttachment.depthLoadOp = GFXLoadOp::CLEAR; depthStencilAttachment.depthStoreOp = GFXStoreOp::STORE; @@ -252,7 +236,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) depthStencilAttachment.beginLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL; depthStencilAttachment.endLayout = GFXTextureLayout::PRESENT_SRC; - _renderPass = (CCVKRenderPass*)createRenderPass(renderPassInfo); + _renderPass = (CCVKRenderPass *)createRenderPass(renderPassInfo); _gpuSwapchain = CC_NEW(CCVKGPUSwapchain); _gpuSwapchain->renderPass = _renderPass->gpuRenderPass(); @@ -264,21 +248,38 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) windowInfo.isOffscreen = false; _window = createWindow(windowInfo); + GFXTextureInfo textureInfo; + GFXTextureViewInfo texViewInfo; + + textureInfo.usage = GFXTextureUsageBit::SAMPLED; + textureInfo.format = GFXFormat::RGBA8; + textureInfo.width = 2; + textureInfo.height = 2; + GFXTexture *nullTexture2D = createTexture(textureInfo); + + texViewInfo.texture = nullTexture2D; + texViewInfo.format = GFXFormat::RGBA8; + nullTexView2D = (CCVKTextureView *)createTextureView(texViewInfo); + + textureInfo.arrayLayer = 6; + textureInfo.flags = GFXTextureFlagBit::CUBEMAP; + GFXTexture *nullTextureCube = createTexture(textureInfo); + + texViewInfo.texture = nullTextureCube; + texViewInfo.layerCount = 6; + nullTexViewCube = (CCVKTextureView *)createTextureView(texViewInfo); + String instanceLayers, instanceExtensions, deviceLayers, deviceExtensions; - for (const char* layer : ((CCVKContext*)_context)->getLayers()) - { + for (const char *layer : ((CCVKContext *)_context)->getLayers()) { instanceLayers += layer + String(" "); } - for (const char* extension : ((CCVKContext*)_context)->getExtensions()) - { + for (const char *extension : ((CCVKContext *)_context)->getExtensions()) { instanceExtensions += extension + String(" "); } - for (const char* layer : _layers) - { + for (const char *layer : _layers) { deviceLayers += layer + String(" "); } - for (const char* extension : _extensions) - { + for (const char *extension : _extensions) { deviceExtensions += extension + String(" "); } @@ -295,13 +296,11 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) _features[(int)GFXFeature::INSTANCED_ARRAYS] = true; String compressedFmts; - if (deviceFeatures.textureCompressionETC2) - { + if (deviceFeatures.textureCompressionETC2) { _features[(int)GFXFeature::FORMAT_ETC2] = true; compressedFmts += "etc2 "; } - if (deviceFeatures.textureCompressionASTC_LDR) - { + if (deviceFeatures.textureCompressionASTC_LDR) { _features[(int)GFXFeature::FORMAT_ASTC] = true; compressedFmts += "astc "; } @@ -310,7 +309,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) _renderer = gpuContext->physicalDeviceProperties.deviceName; _vendor = MapVendorName(gpuContext->physicalDeviceProperties.vendorID); _version = StringUtil::Format("%d.%d.%d", VK_VERSION_MAJOR(apiVersion), - VK_VERSION_MINOR(apiVersion), VK_VERSION_PATCH(apiVersion)); + VK_VERSION_MINOR(apiVersion), VK_VERSION_PATCH(apiVersion)); CC_LOG_INFO("Vulkan device initialized."); CC_LOG_INFO("RENDERER: %s", _renderer.c_str()); @@ -327,8 +326,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info) return true; } -void CCVKDevice::destroy() -{ +void CCVKDevice::destroy() { CC_SAFE_DESTROY(_cmdAllocator); CC_SAFE_DESTROY(_queue); CC_SAFE_DESTROY(_stagingBuffer); @@ -337,32 +335,26 @@ void CCVKDevice::destroy() CC_SAFE_DELETE(_gpuSemaphorePool); CC_SAFE_DELETE(_gpuFencePool); - for (CCVKTextureView* textureView : _depthStencilTextureViews) - { + for (CCVKTextureView *textureView : _depthStencilTextureViews) { CC_SAFE_DESTROY(textureView); } _depthStencilTextureViews.clear(); - for (CCVKTexture* texture : _depthStencilTextures) - { + for (CCVKTexture *texture : _depthStencilTextures) { CC_SAFE_DESTROY(texture); } _depthStencilTextures.clear(); - if (_gpuSwapchain) - { - if (_gpuSwapchain->vkSwapchain != VK_NULL_HANDLE) - { + if (_gpuSwapchain) { + if (_gpuSwapchain->vkSwapchain != VK_NULL_HANDLE) { _gpuSwapchain->depthStencilImageViews.clear(); _gpuSwapchain->depthStencilImages.clear(); - for (VkFramebuffer framebuffer : _gpuSwapchain->vkSwapchainFramebuffers) - { + for (VkFramebuffer framebuffer : _gpuSwapchain->vkSwapchainFramebuffers) { vkDestroyFramebuffer(_gpuDevice->vkDevice, framebuffer, nullptr); } _gpuSwapchain->vkSwapchainFramebuffers.clear(); - for (VkImageView imageView : _gpuSwapchain->vkSwapchainImageViews) - { + for (VkImageView imageView : _gpuSwapchain->vkSwapchainImageViews) { vkDestroyImageView(_gpuDevice->vkDevice, imageView, nullptr); } _gpuSwapchain->vkSwapchainImageViews.clear(); @@ -376,10 +368,8 @@ void CCVKDevice::destroy() _gpuSwapchain = nullptr; } - if (_gpuDevice) - { - if (_gpuDevice->memoryAllocator != VK_NULL_HANDLE) - { + if (_gpuDevice) { + if (_gpuDevice->memoryAllocator != VK_NULL_HANDLE) { VmaStats stats; vmaCalculateStats(_gpuDevice->memoryAllocator, &stats); CC_LOG_INFO("Total device memory leaked: %d bytes.", stats.total.usedBytes); @@ -388,8 +378,7 @@ void CCVKDevice::destroy() _gpuDevice->memoryAllocator = VK_NULL_HANDLE; } - if (_gpuDevice->vkDevice != VK_NULL_HANDLE) - { + if (_gpuDevice->vkDevice != VK_NULL_HANDLE) { vkDestroyDevice(_gpuDevice->vkDevice, nullptr); _gpuDevice->vkDevice = VK_NULL_HANDLE; } @@ -401,17 +390,15 @@ void CCVKDevice::destroy() CC_SAFE_DESTROY(_context); } -void CCVKDevice::resize(uint width, uint height) -{ +void CCVKDevice::resize(uint width, uint height) { _width = width; _height = height; buildSwapchain(); _window->resize(_width, _height); } -void CCVKDevice::buildSwapchain() -{ - CCVKGPUContext* context = ((CCVKContext*)_context)->gpuContext(); +void CCVKDevice::buildSwapchain() { + CCVKGPUContext *context = ((CCVKContext *)_context)->gpuContext(); context->swapchainCreateInfo.oldSwapchain = _gpuSwapchain->vkSwapchain; _gpuSwapchain->curImageIndex = 0; @@ -419,36 +406,29 @@ void CCVKDevice::buildSwapchain() VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(context->physicalDevice, context->vkSurface, &surfaceCapabilities)); if (context->swapchainCreateInfo.imageExtent.width == surfaceCapabilities.currentExtent.width && - context->swapchainCreateInfo.imageExtent.height == surfaceCapabilities.currentExtent.height) - { + context->swapchainCreateInfo.imageExtent.height == surfaceCapabilities.currentExtent.height) { return; } - if (surfaceCapabilities.currentExtent.width == (uint)-1) - { + if (surfaceCapabilities.currentExtent.width == (uint)-1) { context->swapchainCreateInfo.imageExtent.width = _width; context->swapchainCreateInfo.imageExtent.height = _height; - } - else - { + } else { _width = context->swapchainCreateInfo.imageExtent.width = surfaceCapabilities.currentExtent.width; _height = context->swapchainCreateInfo.imageExtent.height = surfaceCapabilities.currentExtent.height; } VK_CHECK(vkCreateSwapchainKHR(_gpuDevice->vkDevice, &context->swapchainCreateInfo, nullptr, &_gpuSwapchain->vkSwapchain)); - if (context->swapchainCreateInfo.oldSwapchain != VK_NULL_HANDLE) - { + if (context->swapchainCreateInfo.oldSwapchain != VK_NULL_HANDLE) { _gpuSwapchain->depthStencilImageViews.clear(); _gpuSwapchain->depthStencilImages.clear(); - for (VkFramebuffer framebuffer : _gpuSwapchain->vkSwapchainFramebuffers) - { + for (VkFramebuffer framebuffer : _gpuSwapchain->vkSwapchainFramebuffers) { vkDestroyFramebuffer(_gpuDevice->vkDevice, framebuffer, nullptr); } _gpuSwapchain->vkSwapchainFramebuffers.clear(); - for (VkImageView imageView : _gpuSwapchain->vkSwapchainImageViews) - { + for (VkImageView imageView : _gpuSwapchain->vkSwapchainImageViews) { vkDestroyImageView(_gpuDevice->vkDevice, imageView, nullptr); } _gpuSwapchain->vkSwapchainImageViews.clear(); @@ -465,10 +445,9 @@ void CCVKDevice::buildSwapchain() _gpuSwapchain->vkSwapchainImageViews.resize(imageCount); _gpuSwapchain->vkSwapchainFramebuffers.resize(imageCount); - for (uint i = 0; i < imageCount; i++) - { + for (uint i = 0; i < imageCount; i++) { _depthStencilTextures[i]->resize(_width, _height); - _gpuSwapchain->depthStencilImages.push_back(((CCVKTexture*)_depthStencilTextures[i])->gpuTexture()->vkImage); + _gpuSwapchain->depthStencilImages.push_back(((CCVKTexture *)_depthStencilTextures[i])->gpuTexture()->vkImage); _depthStencilTextureViews[i]->destroy(); GFXTextureViewInfo textureViewInfo; @@ -476,9 +455,9 @@ void CCVKDevice::buildSwapchain() textureViewInfo.type = GFXTextureViewType::TV2D; textureViewInfo.format = _context->getDepthStencilFormat(); _depthStencilTextureViews[i]->initialize(textureViewInfo); - _gpuSwapchain->depthStencilImageViews.push_back(((CCVKTextureView*)_depthStencilTextureViews[i])->gpuTexView()->vkImageView); + _gpuSwapchain->depthStencilImageViews.push_back(((CCVKTextureView *)_depthStencilTextureViews[i])->gpuTexView()->vkImageView); - VkImageViewCreateInfo imageViewCreateInfo{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO }; + VkImageViewCreateInfo imageViewCreateInfo{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO}; imageViewCreateInfo.image = _gpuSwapchain->swapchainImages[i]; imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; imageViewCreateInfo.format = context->swapchainCreateInfo.imageFormat; @@ -488,9 +467,9 @@ void CCVKDevice::buildSwapchain() VK_CHECK(vkCreateImageView(_gpuDevice->vkDevice, &imageViewCreateInfo, nullptr, &_gpuSwapchain->vkSwapchainImageViews[i])); - VkImageView attachments[] = { _gpuSwapchain->vkSwapchainImageViews[i], _depthStencilTextureViews[i]->gpuTexView()->vkImageView }; + VkImageView attachments[] = {_gpuSwapchain->vkSwapchainImageViews[i], _depthStencilTextureViews[i]->gpuTexView()->vkImageView}; - VkFramebufferCreateInfo framebufferCreateInfo{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO }; + VkFramebufferCreateInfo framebufferCreateInfo{VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO}; framebufferCreateInfo.renderPass = _renderPass->gpuRenderPass()->vkRenderPass; framebufferCreateInfo.attachmentCount = COUNTOF(attachments); framebufferCreateInfo.pAttachments = attachments; @@ -502,19 +481,18 @@ void CCVKDevice::buildSwapchain() } } -void CCVKDevice::acquire() -{ +void CCVKDevice::acquire() { VK_CHECK(vkDeviceWaitIdle(_gpuDevice->vkDevice)); _gpuSemaphorePool->reset(); _gpuFencePool->reset(); - ((CCVKCommandAllocator*)_cmdAllocator)->reset(); + ((CCVKCommandAllocator *)_cmdAllocator)->reset(); VkSemaphore acquireSemaphore = _gpuSemaphorePool->alloc(); VK_CHECK(vkAcquireNextImageKHR(_gpuDevice->vkDevice, _gpuSwapchain->vkSwapchain, - ~0ull, acquireSemaphore, VK_NULL_HANDLE, &_gpuSwapchain->curImageIndex)); + ~0ull, acquireSemaphore, VK_NULL_HANDLE, &_gpuSwapchain->curImageIndex)); // Clear queue stats - CCVKQueue* queue = (CCVKQueue*)_queue; + CCVKQueue *queue = (CCVKQueue *)_queue; queue->_numDrawCalls = 0; queue->_numInstances = 0; queue->_numTriangles = 0; @@ -522,14 +500,13 @@ void CCVKDevice::acquire() queue->gpuQueue()->nextSignalSemaphore = _gpuSemaphorePool->alloc(); } -void CCVKDevice::present() -{ - CCVKQueue* queue = (CCVKQueue*)_queue; +void CCVKDevice::present() { + CCVKQueue *queue = (CCVKQueue *)_queue; _numDrawCalls = queue->_numDrawCalls; _numInstances = queue->_numInstances; _numTriangles = queue->_numTriangles; - VkPresentInfoKHR presentInfo{ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR }; + VkPresentInfoKHR presentInfo{VK_STRUCTURE_TYPE_PRESENT_INFO_KHR}; presentInfo.waitSemaphoreCount = 1; presentInfo.pWaitSemaphores = &queue->gpuQueue()->nextWaitSemaphore; presentInfo.swapchainCount = 1; @@ -539,9 +516,8 @@ void CCVKDevice::present() VK_CHECK(vkQueuePresentKHR(queue->gpuQueue()->vkQueue, &presentInfo)); } -GFXWindow* CCVKDevice::createWindow(const GFXWindowInfo& info) -{ - GFXWindow* window = CC_NEW(CCVKWindow(this)); +GFXWindow *CCVKDevice::createWindow(const GFXWindowInfo &info) { + GFXWindow *window = CC_NEW(CCVKWindow(this)); if (window->initialize(info)) return window; @@ -549,9 +525,8 @@ GFXWindow* CCVKDevice::createWindow(const GFXWindowInfo& info) return nullptr; } -GFXFence* CCVKDevice::createFence(const GFXFenceInfo& info) -{ - GFXFence* fence = CC_NEW(CCVKFence(this)); +GFXFence *CCVKDevice::createFence(const GFXFenceInfo &info) { + GFXFence *fence = CC_NEW(CCVKFence(this)); if (fence->initialize(info)) return fence; @@ -559,9 +534,8 @@ GFXFence* CCVKDevice::createFence(const GFXFenceInfo& info) return nullptr; } -GFXQueue* CCVKDevice::createQueue(const GFXQueueInfo& info) -{ - GFXQueue* queue = CC_NEW(CCVKQueue(this)); +GFXQueue *CCVKDevice::createQueue(const GFXQueueInfo &info) { + GFXQueue *queue = CC_NEW(CCVKQueue(this)); if (queue->initialize(info)) return queue; @@ -569,9 +543,8 @@ GFXQueue* CCVKDevice::createQueue(const GFXQueueInfo& info) return nullptr; } -GFXCommandAllocator* CCVKDevice::createCommandAllocator(const GFXCommandAllocatorInfo& info) -{ - GFXCommandAllocator* cmdAllocator = CC_NEW(CCVKCommandAllocator(this)); +GFXCommandAllocator *CCVKDevice::createCommandAllocator(const GFXCommandAllocatorInfo &info) { + GFXCommandAllocator *cmdAllocator = CC_NEW(CCVKCommandAllocator(this)); if (cmdAllocator->initialize(info)) return cmdAllocator; @@ -579,9 +552,8 @@ GFXCommandAllocator* CCVKDevice::createCommandAllocator(const GFXCommandAllocato return nullptr; } -GFXCommandBuffer* CCVKDevice::createCommandBuffer(const GFXCommandBufferInfo& info) -{ - GFXCommandBuffer* gfx_cmd_buff = CC_NEW(CCVKCommandBuffer(this)); +GFXCommandBuffer *CCVKDevice::createCommandBuffer(const GFXCommandBufferInfo &info) { + GFXCommandBuffer *gfx_cmd_buff = CC_NEW(CCVKCommandBuffer(this)); if (gfx_cmd_buff->initialize(info)) return gfx_cmd_buff; @@ -589,9 +561,8 @@ GFXCommandBuffer* CCVKDevice::createCommandBuffer(const GFXCommandBufferInfo& in return nullptr; } -GFXBuffer* CCVKDevice::createBuffer(const GFXBufferInfo& info) -{ - GFXBuffer* buffer = CC_NEW(CCVKBuffer(this)); +GFXBuffer *CCVKDevice::createBuffer(const GFXBufferInfo &info) { + GFXBuffer *buffer = CC_NEW(CCVKBuffer(this)); if (buffer->initialize(info)) return buffer; @@ -599,9 +570,8 @@ GFXBuffer* CCVKDevice::createBuffer(const GFXBufferInfo& info) return nullptr; } -GFXTexture* CCVKDevice::createTexture(const GFXTextureInfo& info) -{ - GFXTexture* texture = CC_NEW(CCVKTexture(this)); +GFXTexture *CCVKDevice::createTexture(const GFXTextureInfo &info) { + GFXTexture *texture = CC_NEW(CCVKTexture(this)); if (texture->initialize(info)) return texture; @@ -609,9 +579,8 @@ GFXTexture* CCVKDevice::createTexture(const GFXTextureInfo& info) return nullptr; } -GFXTextureView* CCVKDevice::createTextureView(const GFXTextureViewInfo& info) -{ - GFXTextureView* texView = CC_NEW(CCVKTextureView(this)); +GFXTextureView *CCVKDevice::createTextureView(const GFXTextureViewInfo &info) { + GFXTextureView *texView = CC_NEW(CCVKTextureView(this)); if (texView->initialize(info)) return texView; @@ -619,9 +588,8 @@ GFXTextureView* CCVKDevice::createTextureView(const GFXTextureViewInfo& info) return nullptr; } -GFXSampler* CCVKDevice::createSampler(const GFXSamplerInfo& info) -{ - GFXSampler* sampler = CC_NEW(CCVKSampler(this)); +GFXSampler *CCVKDevice::createSampler(const GFXSamplerInfo &info) { + GFXSampler *sampler = CC_NEW(CCVKSampler(this)); if (sampler->initialize(info)) return sampler; @@ -629,9 +597,8 @@ GFXSampler* CCVKDevice::createSampler(const GFXSamplerInfo& info) return nullptr; } -GFXShader* CCVKDevice::createShader(const GFXShaderInfo& info) -{ - GFXShader* shader = CC_NEW(CCVKShader(this)); +GFXShader *CCVKDevice::createShader(const GFXShaderInfo &info) { + GFXShader *shader = CC_NEW(CCVKShader(this)); if (shader->initialize(info)) return shader; @@ -639,9 +606,8 @@ GFXShader* CCVKDevice::createShader(const GFXShaderInfo& info) return nullptr; } -GFXInputAssembler* CCVKDevice::createInputAssembler(const GFXInputAssemblerInfo& info) -{ - GFXInputAssembler* inputAssembler = CC_NEW(CCVKInputAssembler(this)); +GFXInputAssembler *CCVKDevice::createInputAssembler(const GFXInputAssemblerInfo &info) { + GFXInputAssembler *inputAssembler = CC_NEW(CCVKInputAssembler(this)); if (inputAssembler->initialize(info)) return inputAssembler; @@ -649,9 +615,8 @@ GFXInputAssembler* CCVKDevice::createInputAssembler(const GFXInputAssemblerInfo& return nullptr; } -GFXRenderPass* CCVKDevice::createRenderPass(const GFXRenderPassInfo& info) -{ - GFXRenderPass* renderPass = CC_NEW(CCVKRenderPass(this)); +GFXRenderPass *CCVKDevice::createRenderPass(const GFXRenderPassInfo &info) { + GFXRenderPass *renderPass = CC_NEW(CCVKRenderPass(this)); if (renderPass->initialize(info)) return renderPass; @@ -659,9 +624,8 @@ GFXRenderPass* CCVKDevice::createRenderPass(const GFXRenderPassInfo& info) return nullptr; } -GFXFramebuffer* CCVKDevice::createFramebuffer(const GFXFramebufferInfo& info) -{ - GFXFramebuffer* framebuffer = CC_NEW(CCVKFramebuffer(this)); +GFXFramebuffer *CCVKDevice::createFramebuffer(const GFXFramebufferInfo &info) { + GFXFramebuffer *framebuffer = CC_NEW(CCVKFramebuffer(this)); if (framebuffer->initialize(info)) return framebuffer; @@ -669,9 +633,8 @@ GFXFramebuffer* CCVKDevice::createFramebuffer(const GFXFramebufferInfo& info) return nullptr; } -GFXBindingLayout* CCVKDevice::createBindingLayout(const GFXBindingLayoutInfo& info) -{ - GFXBindingLayout* bindingLayout = CC_NEW(CCVKBindingLayout(this)); +GFXBindingLayout *CCVKDevice::createBindingLayout(const GFXBindingLayoutInfo &info) { + GFXBindingLayout *bindingLayout = CC_NEW(CCVKBindingLayout(this)); if (bindingLayout->initialize(info)) return bindingLayout; @@ -679,10 +642,8 @@ GFXBindingLayout* CCVKDevice::createBindingLayout(const GFXBindingLayoutInfo& in return nullptr; } - -GFXPipelineState* CCVKDevice::createPipelineState(const GFXPipelineStateInfo& info) -{ - GFXPipelineState* pipelineState = CC_NEW(CCVKPipelineState(this)); +GFXPipelineState *CCVKDevice::createPipelineState(const GFXPipelineStateInfo &info) { + GFXPipelineState *pipelineState = CC_NEW(CCVKPipelineState(this)); if (pipelineState->initialize(info)) return pipelineState; @@ -690,9 +651,8 @@ GFXPipelineState* CCVKDevice::createPipelineState(const GFXPipelineStateInfo& in return nullptr; } -GFXPipelineLayout* CCVKDevice::createPipelineLayout(const GFXPipelineLayoutInfo& info) -{ - GFXPipelineLayout* layout = CC_NEW(CCVKPipelineLayout(this)); +GFXPipelineLayout *CCVKDevice::createPipelineLayout(const GFXPipelineLayoutInfo &info) { + GFXPipelineLayout *layout = CC_NEW(CCVKPipelineLayout(this)); if (layout->initialize(info)) return layout; @@ -700,9 +660,8 @@ GFXPipelineLayout* CCVKDevice::createPipelineLayout(const GFXPipelineLayoutInfo& return nullptr; } -void CCVKDevice::copyBuffersToTexture(const GFXDataArray& buffers, GFXTexture* dst, const GFXBufferTextureCopyList& regions) -{ - CCVKCmdFuncCopyBuffersToTexture(this, buffers.datas.data(), ((CCVKTexture*)dst)->gpuTexture(), regions); +void CCVKDevice::copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) { + CCVKCmdFuncCopyBuffersToTexture(this, buffers.datas.data(), ((CCVKTexture *)dst)->gpuTexture(), regions); } NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKDevice.h b/native/cocos/renderer/gfx-vulkan/VKDevice.h index 2f5c5005f8..cff4e29ad3 100644 --- a/native/cocos/renderer/gfx-vulkan/VKDevice.h +++ b/native/cocos/renderer/gfx-vulkan/VKDevice.h @@ -13,63 +13,65 @@ class CCVKTextureView; class CCVKRenderPass; class CCVKBuffer; -class CC_VULKAN_API CCVKDevice : public GFXDevice -{ +class CC_VULKAN_API CCVKDevice : public GFXDevice { public: CCVKDevice(); ~CCVKDevice(); public: - bool initialize(const GFXDeviceInfo& info) override; + bool initialize(const GFXDeviceInfo &info) override; void destroy() override; void resize(uint width, uint height) override; void acquire() override; void present() override; - GFXWindow* createWindow(const GFXWindowInfo& info) override; - GFXFence* createFence(const GFXFenceInfo& info) override; - GFXQueue* createQueue(const GFXQueueInfo& info) override; - GFXCommandAllocator* createCommandAllocator(const GFXCommandAllocatorInfo& info) override; - GFXCommandBuffer* createCommandBuffer(const GFXCommandBufferInfo& info) override; - GFXBuffer* createBuffer(const GFXBufferInfo& info) override; - GFXTexture* createTexture(const GFXTextureInfo& info) override; - GFXTextureView* createTextureView(const GFXTextureViewInfo& info) override; - GFXSampler* createSampler(const GFXSamplerInfo& info) override; - GFXShader* createShader(const GFXShaderInfo& info) override; - GFXInputAssembler* createInputAssembler(const GFXInputAssemblerInfo& info) override; - GFXRenderPass* createRenderPass(const GFXRenderPassInfo& info) override; - GFXFramebuffer* createFramebuffer(const GFXFramebufferInfo& info) override; - GFXBindingLayout* createBindingLayout(const GFXBindingLayoutInfo& info) override; - virtual GFXPipelineState* createPipelineState(const GFXPipelineStateInfo& info) override; - virtual GFXPipelineLayout* createPipelineLayout(const GFXPipelineLayoutInfo& info) override; - virtual void copyBuffersToTexture(const GFXDataArray& buffers, GFXTexture* dst, const GFXBufferTextureCopyList& regions) override; + GFXWindow *createWindow(const GFXWindowInfo &info) override; + GFXFence *createFence(const GFXFenceInfo &info) override; + GFXQueue *createQueue(const GFXQueueInfo &info) override; + GFXCommandAllocator *createCommandAllocator(const GFXCommandAllocatorInfo &info) override; + GFXCommandBuffer *createCommandBuffer(const GFXCommandBufferInfo &info) override; + GFXBuffer *createBuffer(const GFXBufferInfo &info) override; + GFXTexture *createTexture(const GFXTextureInfo &info) override; + GFXTextureView *createTextureView(const GFXTextureViewInfo &info) override; + GFXSampler *createSampler(const GFXSamplerInfo &info) override; + GFXShader *createShader(const GFXShaderInfo &info) override; + GFXInputAssembler *createInputAssembler(const GFXInputAssemblerInfo &info) override; + GFXRenderPass *createRenderPass(const GFXRenderPassInfo &info) override; + GFXFramebuffer *createFramebuffer(const GFXFramebufferInfo &info) override; + GFXBindingLayout *createBindingLayout(const GFXBindingLayoutInfo &info) override; + virtual GFXPipelineState *createPipelineState(const GFXPipelineStateInfo &info) override; + virtual GFXPipelineLayout *createPipelineLayout(const GFXPipelineLayoutInfo &info) override; + virtual void copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) override; - CC_INLINE bool checkExtension(const String& extension) const { + CC_INLINE bool checkExtension(const String &extension) const { return std::find_if(_extensions.begin(), _extensions.end(), - [extension](const char* device_extension) { - return std::strcmp(device_extension, extension.c_str()) == 0; - }) != _extensions.end(); + [extension](const char *device_extension) { + return std::strcmp(device_extension, extension.c_str()) == 0; + }) != _extensions.end(); } - CCVKGPUContext* gpuContext() const; - CC_INLINE CCVKGPUDevice* gpuDevice() const { return _gpuDevice; } - CC_INLINE CCVKGPUSwapchain* gpuSwapchain() { return _gpuSwapchain; } - CC_INLINE CCVKGPUSemaphorePool* gpuSemaphorePool() { return _gpuSemaphorePool; } - CC_INLINE CCVKGPUFencePool* gpuFencePool() { return _gpuFencePool; } - CC_INLINE CCVKBuffer* stagingBuffer() { return _stagingBuffer; } - CC_INLINE const std::vector& getLayers() const { return _layers; } - CC_INLINE const std::vector& getExtensions() const { return _extensions; } + CCVKGPUContext *gpuContext() const; + CC_INLINE CCVKGPUDevice *gpuDevice() const { return _gpuDevice; } + CC_INLINE CCVKGPUSwapchain *gpuSwapchain() { return _gpuSwapchain; } + CC_INLINE CCVKGPUSemaphorePool *gpuSemaphorePool() { return _gpuSemaphorePool; } + CC_INLINE CCVKGPUFencePool *gpuFencePool() { return _gpuFencePool; } + CC_INLINE CCVKBuffer *stagingBuffer() { return _stagingBuffer; } + CC_INLINE const std::vector &getLayers() const { return _layers; } + CC_INLINE const std::vector &getExtensions() const { return _extensions; } + + CCVKTextureView *nullTexView2D = nullptr; + CCVKTextureView *nullTexViewCube = nullptr; private: void buildSwapchain(); - CCVKGPUDevice* _gpuDevice = nullptr; - CCVKGPUSemaphorePool* _gpuSemaphorePool = nullptr; - CCVKGPUFencePool* _gpuFencePool = nullptr; - CCVKGPUSwapchain* _gpuSwapchain = nullptr; - std::vector _depthStencilTextureViews; - std::vector _depthStencilTextures; - CCVKRenderPass* _renderPass = nullptr; - CCVKBuffer* _stagingBuffer = nullptr; + CCVKGPUDevice *_gpuDevice = nullptr; + CCVKGPUSemaphorePool *_gpuSemaphorePool = nullptr; + CCVKGPUFencePool *_gpuFencePool = nullptr; + CCVKGPUSwapchain *_gpuSwapchain = nullptr; + std::vector _depthStencilTextureViews; + std::vector _depthStencilTextures; + CCVKRenderPass *_renderPass = nullptr; + CCVKBuffer *_stagingBuffer = nullptr; uint32_t _defaultStagingBufferSize = 1024; diff --git a/native/cocos/renderer/gfx-vulkan/VKFence.cc b/native/cocos/renderer/gfx-vulkan/VKFence.cc index 37f6cd883e..62ef317a1c 100644 --- a/native/cocos/renderer/gfx-vulkan/VKFence.cc +++ b/native/cocos/renderer/gfx-vulkan/VKFence.cc @@ -1,40 +1,35 @@ #include "VKStd.h" -#include "VKFence.h" + #include "VKDevice.h" +#include "VKFence.h" #include "VKGPUObjects.h" NS_CC_BEGIN -CCVKFence::CCVKFence(GFXDevice* device) - : GFXFence(device) -{ +CCVKFence::CCVKFence(GFXDevice *device) +: GFXFence(device) { } -CCVKFence::~CCVKFence() -{ +CCVKFence::~CCVKFence() { } -bool CCVKFence::initialize(const GFXFenceInfo &info) -{ +bool CCVKFence::initialize(const GFXFenceInfo &info) { _gpuFence = CC_NEW(CCVKGPUFence); - if (!_gpuFence) - { + if (!_gpuFence) { CC_LOG_ERROR("GLES2Fence: CC_NEW CCVKGPUFence failed."); return false; } - VkFenceCreateInfo createInfo{ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO }; - VK_CHECK(vkCreateFence(((CCVKDevice*)_device)->gpuDevice()->vkDevice, &createInfo, nullptr, &_gpuFence->vkFence)); + VkFenceCreateInfo createInfo{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; + VK_CHECK(vkCreateFence(((CCVKDevice *)_device)->gpuDevice()->vkDevice, &createInfo, nullptr, &_gpuFence->vkFence)); _status = GFXStatus::SUCCESS; return true; } -void CCVKFence::destroy() -{ - if (_gpuFence) - { - vkDestroyFence(((CCVKDevice*)_device)->gpuDevice()->vkDevice, _gpuFence->vkFence, nullptr); +void CCVKFence::destroy() { + if (_gpuFence) { + vkDestroyFence(((CCVKDevice *)_device)->gpuDevice()->vkDevice, _gpuFence->vkFence, nullptr); CC_DELETE(_gpuFence); _gpuFence = nullptr; @@ -42,14 +37,12 @@ void CCVKFence::destroy() _status = GFXStatus::UNREADY; } -void CCVKFence::wait() -{ - VK_CHECK(vkWaitForFences(((CCVKDevice*)_device)->gpuDevice()->vkDevice, 1, &_gpuFence->vkFence, VK_TRUE, DEFAULT_FENCE_TIMEOUT)); +void CCVKFence::wait() { + VK_CHECK(vkWaitForFences(((CCVKDevice *)_device)->gpuDevice()->vkDevice, 1, &_gpuFence->vkFence, VK_TRUE, DEFAULT_FENCE_TIMEOUT)); } -void CCVKFence::reset() -{ - VK_CHECK(vkResetFences(((CCVKDevice*)_device)->gpuDevice()->vkDevice, 1, &_gpuFence->vkFence)); +void CCVKFence::reset() { + VK_CHECK(vkResetFences(((CCVKDevice *)_device)->gpuDevice()->vkDevice, 1, &_gpuFence->vkFence)); } NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKFence.h b/native/cocos/renderer/gfx-vulkan/VKFence.h index 54720e7d8d..a8ad09f2ec 100644 --- a/native/cocos/renderer/gfx-vulkan/VKFence.h +++ b/native/cocos/renderer/gfx-vulkan/VKFence.h @@ -7,19 +7,19 @@ class CCVKGPUFence; class CC_VULKAN_API CCVKFence : public GFXFence { public: - CCVKFence(GFXDevice* device); + CCVKFence(GFXDevice *device); virtual ~CCVKFence() override; public: - virtual bool initialize(const GFXFenceInfo& info) override; + virtual bool initialize(const GFXFenceInfo &info) override; virtual void destroy() override; virtual void wait() override; virtual void reset() override; - CC_INLINE CCVKGPUFence* gpuFence() { return _gpuFence; } + CC_INLINE CCVKGPUFence *gpuFence() { return _gpuFence; } private: - CCVKGPUFence* _gpuFence = nullptr; + CCVKGPUFence *_gpuFence = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKFramebuffer.cc b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.cc index a86d32f07d..0dc0813ee6 100644 --- a/native/cocos/renderer/gfx-vulkan/VKFramebuffer.cc +++ b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.cc @@ -1,63 +1,54 @@ #include "VKStd.h" + +#include "VKCommands.h" +#include "VKDevice.h" #include "VKFramebuffer.h" #include "VKRenderPass.h" -#include "VKCommands.h" #include "VKTextureView.h" -#include "VKDevice.h" NS_CC_BEGIN -CCVKFramebuffer::CCVKFramebuffer(GFXDevice* device) - : GFXFramebuffer(device) -{ +CCVKFramebuffer::CCVKFramebuffer(GFXDevice *device) +: GFXFramebuffer(device) { } -CCVKFramebuffer::~CCVKFramebuffer() -{ +CCVKFramebuffer::~CCVKFramebuffer() { } -bool CCVKFramebuffer::initialize(const GFXFramebufferInfo &info) -{ +bool CCVKFramebuffer::initialize(const GFXFramebufferInfo &info) { _renderPass = info.renderPass; _colorViews = info.colorViews; _depthStencilView = info.depthStencilView; _isOffscreen = info.isOffscreen; _gpuFBO = CC_NEW(CCVKGPUFramebuffer); - _gpuFBO->gpuRenderPass = ((CCVKRenderPass*)_renderPass)->gpuRenderPass(); + _gpuFBO->gpuRenderPass = ((CCVKRenderPass *)_renderPass)->gpuRenderPass(); - if (_isOffscreen) - { + if (_isOffscreen) { _gpuFBO->gpuColorViews.resize(_colorViews.size()); - for (size_t i = 0; i < _colorViews.size(); ++i) - { - CCVKTextureView* colorview = (CCVKTextureView*)_colorViews[i]; + for (size_t i = 0; i < _colorViews.size(); ++i) { + CCVKTextureView *colorview = (CCVKTextureView *)_colorViews[i]; _gpuFBO->gpuColorViews[i] = colorview->gpuTexView(); } - if (_depthStencilView) - { - _gpuFBO->gpuDepthStencilView = ((CCVKTextureView*)_depthStencilView)->gpuTexView(); + if (_depthStencilView) { + _gpuFBO->gpuDepthStencilView = ((CCVKTextureView *)_depthStencilView)->gpuTexView(); } _gpuFBO->isOffscreen = _isOffscreen; - } - CCVKCmdFuncCreateFramebuffer((CCVKDevice*)_device, _gpuFBO); + CCVKCmdFuncCreateFramebuffer((CCVKDevice *)_device, _gpuFBO); _status = GFXStatus::SUCCESS; return true; } -void CCVKFramebuffer::destroy() -{ - if (_gpuFBO) - { - if (_isOffscreen) - { - CCVKCmdFuncDestroyFramebuffer((CCVKDevice*)_device, _gpuFBO); +void CCVKFramebuffer::destroy() { + if (_gpuFBO) { + if (_isOffscreen) { + CCVKCmdFuncDestroyFramebuffer((CCVKDevice *)_device, _gpuFBO); } CC_DELETE(_gpuFBO); _gpuFBO = nullptr; diff --git a/native/cocos/renderer/gfx-vulkan/VKFramebuffer.h b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.h index b6569c29de..8c85a49de7 100644 --- a/native/cocos/renderer/gfx-vulkan/VKFramebuffer.h +++ b/native/cocos/renderer/gfx-vulkan/VKFramebuffer.h @@ -6,18 +6,18 @@ NS_CC_BEGIN class CCVKGPUFramebuffer; class CC_VULKAN_API CCVKFramebuffer : public GFXFramebuffer { - public: - CCVKFramebuffer(GFXDevice* device); - ~CCVKFramebuffer(); - - public: - bool initialize(const GFXFramebufferInfo& info); - void destroy(); - - CC_INLINE CCVKGPUFramebuffer* gpuFBO() const { return _gpuFBO; } - - private: - CCVKGPUFramebuffer* _gpuFBO = nullptr; +public: + CCVKFramebuffer(GFXDevice *device); + ~CCVKFramebuffer(); + +public: + bool initialize(const GFXFramebufferInfo &info); + void destroy(); + + CC_INLINE CCVKGPUFramebuffer *gpuFBO() const { return _gpuFBO; } + +private: + CCVKGPUFramebuffer *_gpuFBO = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h b/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h index 8a4a3a80cc..7d2e216608 100644 --- a/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h +++ b/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h @@ -5,8 +5,7 @@ NS_CC_BEGIN -class CCVKGPUContext : public Object -{ +class CCVKGPUContext : public Object { public: VkInstance vkInstance = VK_NULL_HANDLE; VkDebugUtilsMessengerEXT vkDebugUtilsMessenger = VK_NULL_HANDLE; @@ -14,9 +13,9 @@ public: VkPhysicalDevice physicalDevice = VK_NULL_HANDLE; VkPhysicalDeviceFeatures physicalDeviceFeatures{}; - VkPhysicalDeviceFeatures2 physicalDeviceFeatures2{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 }; - VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES}; - VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES }; + VkPhysicalDeviceFeatures2 physicalDeviceFeatures2{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2}; + VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES}; + VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES}; VkPhysicalDeviceProperties physicalDeviceProperties{}; VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties{}; vector::type queueFamilyProperties; @@ -24,11 +23,10 @@ public: VkSurfaceKHR vkSurface = VK_NULL_HANDLE; - VkSwapchainCreateInfoKHR swapchainCreateInfo{ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR }; + VkSwapchainCreateInfoKHR swapchainCreateInfo{VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR}; }; -class CCVKGPUDevice : public Object -{ +class CCVKGPUDevice : public Object { public: VkDevice vkDevice = VK_NULL_HANDLE; vector::type layers; @@ -36,8 +34,7 @@ public: VmaAllocator memoryAllocator = VK_NULL_HANDLE; }; -class CCVKGPURenderPass : public Object -{ +class CCVKGPURenderPass : public Object { public: GFXColorAttachmentList colorAttachments; GFXDepthStencilAttachment depthStencilAttachment; @@ -48,8 +45,7 @@ public: vector::type endBarriers; }; -class CCVKGPUSwapchain : public Object -{ +class CCVKGPUSwapchain : public Object { public: uint curImageIndex = 0; VkSwapchainKHR vkSwapchain = VK_NULL_HANDLE; @@ -59,27 +55,24 @@ public: vector::type swapchainImages; vector::type depthStencilImages; vector::type depthStencilImageViews; - CCVKGPURenderPass* renderPass; + CCVKGPURenderPass *renderPass; }; -class CCVKGPUCommandPool : public Object -{ +class CCVKGPUCommandPool : public Object { public: VkCommandPool vkCommandPool = VK_NULL_HANDLE; CachedArray commandBuffers[2]; CachedArray usedCommandBuffers[2]; }; -class CCVKGPUCommandBuffer : public Object -{ +class CCVKGPUCommandBuffer : public Object { public: GFXCommandBufferType type; - CCVKGPUCommandPool* commandPool = nullptr; + CCVKGPUCommandPool *commandPool = nullptr; VkCommandBuffer vkCommandBuffer = VK_NULL_HANDLE; }; -class CCVKGPUQueue : public Object -{ +class CCVKGPUQueue : public Object { public: GFXQueueType type; VkQueue vkQueue; @@ -90,26 +83,24 @@ public: CachedArray commandBuffers; }; -class CCVKGPUBuffer : public Object -{ +class CCVKGPUBuffer : public Object { public: GFXBufferUsage usage = GFXBufferUsage::NONE; GFXMemoryUsage memUsage = GFXMemoryUsage::NONE; uint size = 0; uint stride = 0; uint count = 0; - void* buffer = nullptr; + void *buffer = nullptr; GFXDrawInfoList indirects; VkBuffer vkBuffer = VK_NULL_HANDLE; VkDeviceSize startOffset = 0u; - uint8_t* mappedData = nullptr; + uint8_t *mappedData = nullptr; VmaAllocation vmaAllocation = VK_NULL_HANDLE; }; -typedef vector::type CCVKGPUBufferList; +typedef vector::type CCVKGPUBufferList; -class CCVKGPUTexture : public Object -{ +class CCVKGPUTexture : public Object { public: GFXTextureType type = GFXTextureType::TEX2D; GFXTextureViewType viewType = GFXTextureViewType::TV2D; @@ -133,10 +124,9 @@ public: VkPipelineStageFlags targetStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; }; -class CCVKGPUTextureView : public Object -{ +class CCVKGPUTextureView : public Object { public: - CCVKGPUTexture* gpuTexture = nullptr; + CCVKGPUTexture *gpuTexture = nullptr; GFXTextureViewType type = GFXTextureViewType::TV2D; GFXFormat format = GFXFormat::UNKNOWN; uint baseLevel = 0; @@ -144,10 +134,9 @@ public: VkImageView vkImageView = VK_NULL_HANDLE; }; -typedef vector::type CCVKGPUTextureViewList; +typedef vector::type CCVKGPUTextureViewList; -class CCVKGPUSampler : public Object -{ +class CCVKGPUSampler : public Object { public: GFXFilter minFilter = GFXFilter::LINEAR; GFXFilter magFilter = GFXFilter::LINEAR; @@ -164,13 +153,9 @@ public: VkSampler vkSampler; }; -struct CCVKGPUShaderStage -{ +struct CCVKGPUShaderStage { CCVKGPUShaderStage(GFXShaderType t, String s, GFXShaderMacroList m) - : type(t) - , source(s) - , macros(m) - { + : type(t), source(s), macros(m) { } GFXShaderType type; String source; @@ -179,8 +164,7 @@ struct CCVKGPUShaderStage }; typedef vector::type CCVKGPUShaderStageList; -class CCVKGPUShader : public Object -{ +class CCVKGPUShader : public Object { public: String name; GFXUniformBlockList blocks; @@ -188,30 +172,27 @@ public: CCVKGPUShaderStageList gpuStages; }; -class CCVKGPUInputAssembler : public Object -{ +class CCVKGPUInputAssembler : public Object { public: GFXAttributeList attributes; CCVKGPUBufferList gpuVertexBuffers; - CCVKGPUBuffer* gpuIndexBuffer = nullptr; - CCVKGPUBuffer* gpuIndirectBuffer = nullptr; + CCVKGPUBuffer *gpuIndexBuffer = nullptr; + CCVKGPUBuffer *gpuIndirectBuffer = nullptr; vector::type vertexBuffers; vector::type vertexBufferOffsets; }; -class CCVKGPUFramebuffer : public Object -{ +class CCVKGPUFramebuffer : public Object { public: - CCVKGPURenderPass* gpuRenderPass = nullptr; + CCVKGPURenderPass *gpuRenderPass = nullptr; CCVKGPUTextureViewList gpuColorViews; - CCVKGPUTextureView* gpuDepthStencilView = nullptr; + CCVKGPUTextureView *gpuDepthStencilView = nullptr; VkFramebuffer vkFramebuffer = VK_NULL_HANDLE; bool isOffscreen = false; - CCVKGPUSwapchain* swapchain = nullptr; + CCVKGPUSwapchain *swapchain = nullptr; }; -class CCVKGPUBindingLayout : public Object -{ +class CCVKGPUBindingLayout : public Object { public: vector::type bindings; VkDescriptorSetLayout vkDescriptorSetLayout = VK_NULL_HANDLE; @@ -219,63 +200,54 @@ public: VkDescriptorSet vkDescriptorSet = VK_NULL_HANDLE; }; -class CCVKGPUPipelineLayout : public Object -{ +class CCVKGPUPipelineLayout : public Object { public: GFXPushConstantRangeList pushConstantRanges; - vector::type gpuBindingLayouts; + vector::type gpuBindingLayouts; VkPipelineLayout vkPipelineLayout; }; -class CCVKGPUPipelineState : public Object -{ +class CCVKGPUPipelineState : public Object { public: GFXPrimitiveMode primitive = GFXPrimitiveMode::TRIANGLE_LIST; - CCVKGPUShader* gpuShader = nullptr; + CCVKGPUShader *gpuShader = nullptr; GFXInputState inputState; GFXRasterizerState rs; GFXDepthStencilState dss; GFXBlendState bs; GFXDynamicStateList dynamicStates; - CCVKGPUPipelineLayout* gpuLayout = nullptr; - CCVKGPURenderPass* gpuRenderPass = nullptr; + CCVKGPUPipelineLayout *gpuLayout = nullptr; + CCVKGPURenderPass *gpuRenderPass = nullptr; VkPipeline vkPipeline = VK_NULL_HANDLE; VkPipelineCache vkPipelineCache = VK_NULL_HANDLE; }; -class CCVKGPUFence : public Object -{ +class CCVKGPUFence : public Object { public: VkFence vkFence; }; -class CCVKGPUSemaphorePool : public Object -{ +class CCVKGPUSemaphorePool : public Object { public: - CCVKGPUSemaphorePool(CCVKGPUDevice* device) - : _device(device) - { + CCVKGPUSemaphorePool(CCVKGPUDevice *device) + : _device(device) { } - ~CCVKGPUSemaphorePool() - { - for (VkBuffer semaphore : _semaphores) - { + ~CCVKGPUSemaphorePool() { + for (VkBuffer semaphore : _semaphores) { vkDestroySemaphore(_device->vkDevice, semaphore, nullptr); } _semaphores.clear(); _count = 0; } - VkSemaphore alloc() - { - if (_count < _semaphores.size()) - { + VkSemaphore alloc() { + if (_count < _semaphores.size()) { return _semaphores[_count++]; } VkSemaphore semaphore = VK_NULL_HANDLE; - VkSemaphoreCreateInfo createInfo{ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO }; + VkSemaphoreCreateInfo createInfo{VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO}; VK_CHECK(vkCreateSemaphore(_device->vkDevice, &createInfo, nullptr, &semaphore)); _semaphores.push_back(semaphore); _count++; @@ -283,49 +255,41 @@ public: return semaphore; } - void reset() - { + void reset() { _count = 0; } - uint size() - { + uint size() { return _count; } private: - CCVKGPUDevice* _device; + CCVKGPUDevice *_device; uint _count = 0; vector::type _semaphores; }; -class CCVKGPUFencePool : public Object -{ +class CCVKGPUFencePool : public Object { public: - CCVKGPUFencePool(CCVKGPUDevice* device) - : _device(device) - { + CCVKGPUFencePool(CCVKGPUDevice *device) + : _device(device) { } - ~CCVKGPUFencePool() - { - for (VkFence fence : _fences) - { + ~CCVKGPUFencePool() { + for (VkFence fence : _fences) { vkDestroyFence(_device->vkDevice, fence, nullptr); } _fences.clear(); _count = 0; } - VkFence alloc() - { - if (_count < _fences.size()) - { + VkFence alloc() { + if (_count < _fences.size()) { return _fences[_count++]; } VkFence fence = VK_NULL_HANDLE; - VkFenceCreateInfo createInfo{ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO }; + VkFenceCreateInfo createInfo{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; VK_CHECK(vkCreateFence(_device->vkDevice, &createInfo, nullptr, &fence)); _fences.push_back(fence); _count++; @@ -333,22 +297,19 @@ public: return fence; } - void reset() - { - if (_count) - { + void reset() { + if (_count) { VK_CHECK(vkResetFences(_device->vkDevice, _count, _fences.data())); _count = 0; } } - uint size() - { + uint size() { return _count; } private: - CCVKGPUDevice* _device; + CCVKGPUDevice *_device; uint _count = 0; vector::type _fences; }; diff --git a/native/cocos/renderer/gfx-vulkan/VKInputAssembler.cc b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.cc index 4bffff59d9..c77e2441e1 100644 --- a/native/cocos/renderer/gfx-vulkan/VKInputAssembler.cc +++ b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.cc @@ -1,32 +1,27 @@ #include "VKStd.h" -#include "VKInputAssembler.h" -#include "VKCommands.h" + #include "VKBuffer.h" +#include "VKCommands.h" +#include "VKInputAssembler.h" NS_CC_BEGIN -CCVKInputAssembler::CCVKInputAssembler(GFXDevice* device) - : GFXInputAssembler(device) -{ +CCVKInputAssembler::CCVKInputAssembler(GFXDevice *device) +: GFXInputAssembler(device) { } -CCVKInputAssembler::~CCVKInputAssembler() -{ +CCVKInputAssembler::~CCVKInputAssembler() { } -bool CCVKInputAssembler::initialize(const GFXInputAssemblerInfo &info) -{ +bool CCVKInputAssembler::initialize(const GFXInputAssemblerInfo &info) { _attributes = info.attributes; _vertexBuffers = info.vertexBuffers; _indexBuffer = info.indexBuffer; _indirectBuffer = info.indirectBuffer; - if (_indexBuffer) - { + if (_indexBuffer) { _indexCount = _indexBuffer->getCount(); - } - else if (_vertexBuffers.size()) - { + } else if (_vertexBuffers.size()) { _vertexCount = _vertexBuffers[0]->getCount(); } @@ -34,34 +29,29 @@ bool CCVKInputAssembler::initialize(const GFXInputAssemblerInfo &info) _gpuInputAssembler->attributes = _attributes; _gpuInputAssembler->gpuVertexBuffers.resize(_vertexBuffers.size()); - for (size_t i = 0; i < _gpuInputAssembler->gpuVertexBuffers.size(); ++i) - { - CCVKBuffer* vb = (CCVKBuffer*)_vertexBuffers[i]; + for (size_t i = 0; i < _gpuInputAssembler->gpuVertexBuffers.size(); ++i) { + CCVKBuffer *vb = (CCVKBuffer *)_vertexBuffers[i]; _gpuInputAssembler->gpuVertexBuffers[i] = vb->gpuBuffer(); } - if (info.indexBuffer) - { - _gpuInputAssembler->gpuIndexBuffer = static_cast(info.indexBuffer)->gpuBuffer(); + if (info.indexBuffer) { + _gpuInputAssembler->gpuIndexBuffer = static_cast(info.indexBuffer)->gpuBuffer(); } - if (info.indirectBuffer) - { - _gpuInputAssembler->gpuIndirectBuffer = static_cast(info.indirectBuffer)->gpuBuffer(); + if (info.indirectBuffer) { + _gpuInputAssembler->gpuIndirectBuffer = static_cast(info.indirectBuffer)->gpuBuffer(); } - CCVKCmdFuncCreateInputAssembler((CCVKDevice*)_device, _gpuInputAssembler); + CCVKCmdFuncCreateInputAssembler((CCVKDevice *)_device, _gpuInputAssembler); _attributesHash = computeAttributesHash(); _status = GFXStatus::SUCCESS; return true; } -void CCVKInputAssembler::destroy() -{ - if (_gpuInputAssembler) - { - CCVKCmdFuncDestroyInputAssembler((CCVKDevice*)_device, _gpuInputAssembler); +void CCVKInputAssembler::destroy() { + if (_gpuInputAssembler) { + CCVKCmdFuncDestroyInputAssembler((CCVKDevice *)_device, _gpuInputAssembler); CC_DELETE(_gpuInputAssembler); _gpuInputAssembler = nullptr; } diff --git a/native/cocos/renderer/gfx-vulkan/VKInputAssembler.h b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.h index ff8a1fb2de..99c2810ac5 100644 --- a/native/cocos/renderer/gfx-vulkan/VKInputAssembler.h +++ b/native/cocos/renderer/gfx-vulkan/VKInputAssembler.h @@ -5,20 +5,19 @@ NS_CC_BEGIN class CCVKGPUInputAssembler; -class CC_VULKAN_API CCVKInputAssembler : public GFXInputAssembler -{ +class CC_VULKAN_API CCVKInputAssembler : public GFXInputAssembler { public: - CCVKInputAssembler(GFXDevice* device); + CCVKInputAssembler(GFXDevice *device); ~CCVKInputAssembler(); public: - bool initialize(const GFXInputAssemblerInfo& info); + bool initialize(const GFXInputAssemblerInfo &info); void destroy(); - CC_INLINE CCVKGPUInputAssembler* gpuInputAssembler() const { return _gpuInputAssembler; } + CC_INLINE CCVKGPUInputAssembler *gpuInputAssembler() const { return _gpuInputAssembler; } private: - CCVKGPUInputAssembler* _gpuInputAssembler = nullptr; + CCVKGPUInputAssembler *_gpuInputAssembler = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.cc b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.cc index 2f784c4ea5..6f0d9b6b37 100644 --- a/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.cc +++ b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.cc @@ -1,21 +1,19 @@ #include "VKStd.h" -#include "VKPipelineLayout.h" -#include "VKCommands.h" + #include "VKBindingLayout.h" +#include "VKCommands.h" +#include "VKPipelineLayout.h" NS_CC_BEGIN -CCVKPipelineLayout::CCVKPipelineLayout(GFXDevice* device) - : GFXPipelineLayout(device) -{ +CCVKPipelineLayout::CCVKPipelineLayout(GFXDevice *device) +: GFXPipelineLayout(device) { } -CCVKPipelineLayout::~CCVKPipelineLayout() -{ +CCVKPipelineLayout::~CCVKPipelineLayout() { } -bool CCVKPipelineLayout::initialize(const GFXPipelineLayoutInfo &info) -{ +bool CCVKPipelineLayout::initialize(const GFXPipelineLayoutInfo &info) { _layouts = info.layouts; _pushConstantsRanges = info.pushConstantsRanges; @@ -24,22 +22,19 @@ bool CCVKPipelineLayout::initialize(const GFXPipelineLayoutInfo &info) _gpuPipelineLayout->pushConstantRanges = _pushConstantsRanges; uint layoutCount = _layouts.size(); _gpuPipelineLayout->gpuBindingLayouts.resize(layoutCount); - for (uint i = 0u; i < layoutCount; i++) - { - _gpuPipelineLayout->gpuBindingLayouts[i] = ((CCVKBindingLayout*)_layouts[i])->gpuBindingLayout(); + for (uint i = 0u; i < layoutCount; i++) { + _gpuPipelineLayout->gpuBindingLayouts[i] = ((CCVKBindingLayout *)_layouts[i])->gpuBindingLayout(); } - CCVKCmdFuncCreatePipelineLayout((CCVKDevice*)_device, _gpuPipelineLayout); + CCVKCmdFuncCreatePipelineLayout((CCVKDevice *)_device, _gpuPipelineLayout); _status = GFXStatus::SUCCESS; return true; } -void CCVKPipelineLayout::destroy() -{ - if (_gpuPipelineLayout) - { - CCVKCmdFuncDestroyPipelineLayout((CCVKDevice*)_device, _gpuPipelineLayout); +void CCVKPipelineLayout::destroy() { + if (_gpuPipelineLayout) { + CCVKCmdFuncDestroyPipelineLayout((CCVKDevice *)_device, _gpuPipelineLayout); CC_DELETE(_gpuPipelineLayout); _gpuPipelineLayout = nullptr; } diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.h b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.h index be186238a4..a2b4d71ebf 100644 --- a/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.h +++ b/native/cocos/renderer/gfx-vulkan/VKPipelineLayout.h @@ -5,19 +5,19 @@ NS_CC_BEGIN class CCVKGPUPipelineLayout; -class CC_VULKAN_API CCVKPipelineLayout : public GFXPipelineLayout -{ +class CC_VULKAN_API CCVKPipelineLayout : public GFXPipelineLayout { public: - CCVKPipelineLayout(GFXDevice* device); + CCVKPipelineLayout(GFXDevice *device); ~CCVKPipelineLayout(); public: - bool initialize(const GFXPipelineLayoutInfo& info); + bool initialize(const GFXPipelineLayoutInfo &info); void destroy(); - CC_INLINE CCVKGPUPipelineLayout* gpuPipelineLayout() const { return _gpuPipelineLayout; } + CC_INLINE CCVKGPUPipelineLayout *gpuPipelineLayout() const { return _gpuPipelineLayout; } + private: - CCVKGPUPipelineLayout* _gpuPipelineLayout = nullptr; + CCVKGPUPipelineLayout *_gpuPipelineLayout = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineState.cc b/native/cocos/renderer/gfx-vulkan/VKPipelineState.cc index 0822a78e40..4d639796ca 100644 --- a/native/cocos/renderer/gfx-vulkan/VKPipelineState.cc +++ b/native/cocos/renderer/gfx-vulkan/VKPipelineState.cc @@ -1,23 +1,21 @@ #include "VKStd.h" -#include "VKPipelineState.h" + #include "VKCommands.h" -#include "VKShader.h" -#include "VKRenderPass.h" #include "VKPipelineLayout.h" +#include "VKPipelineState.h" +#include "VKRenderPass.h" +#include "VKShader.h" NS_CC_BEGIN -CCVKPipelineState::CCVKPipelineState(GFXDevice* device) - : GFXPipelineState(device) -{ +CCVKPipelineState::CCVKPipelineState(GFXDevice *device) +: GFXPipelineState(device) { } -CCVKPipelineState::~CCVKPipelineState() -{ +CCVKPipelineState::~CCVKPipelineState() { } -bool CCVKPipelineState::initialize(const GFXPipelineStateInfo &info) -{ +bool CCVKPipelineState::initialize(const GFXPipelineStateInfo &info) { _primitive = info.primitive; _shader = info.shader; _inputState = info.inputState; @@ -27,30 +25,28 @@ bool CCVKPipelineState::initialize(const GFXPipelineStateInfo &info) _dynamicStates = info.dynamicStates; _layout = info.layout; _renderPass = info.renderPass; - + _gpuPipelineState = CC_NEW(CCVKGPUPipelineState); _gpuPipelineState->primitive = _primitive; - _gpuPipelineState->gpuShader = ((CCVKShader*)_shader)->gpuShader(); + _gpuPipelineState->gpuShader = ((CCVKShader *)_shader)->gpuShader(); _gpuPipelineState->inputState = _inputState; _gpuPipelineState->rs = _rasterizerState; _gpuPipelineState->dss = _depthStencilState; _gpuPipelineState->bs = _blendState; _gpuPipelineState->dynamicStates = _dynamicStates; - _gpuPipelineState->gpuLayout = ((CCVKPipelineLayout*)_layout)->gpuPipelineLayout(); - _gpuPipelineState->gpuRenderPass = ((CCVKRenderPass*)_renderPass)->gpuRenderPass(); + _gpuPipelineState->gpuLayout = ((CCVKPipelineLayout *)_layout)->gpuPipelineLayout(); + _gpuPipelineState->gpuRenderPass = ((CCVKRenderPass *)_renderPass)->gpuRenderPass(); + + CCVKCmdFuncCreatePipelineState((CCVKDevice *)_device, _gpuPipelineState); - CCVKCmdFuncCreatePipelineState((CCVKDevice*)_device, _gpuPipelineState); - _status = GFXStatus::SUCCESS; - + return true; } -void CCVKPipelineState::destroy() -{ - if (_gpuPipelineState) - { - CCVKCmdFuncDestroyPipelineState((CCVKDevice*)_device, _gpuPipelineState); +void CCVKPipelineState::destroy() { + if (_gpuPipelineState) { + CCVKCmdFuncDestroyPipelineState((CCVKDevice *)_device, _gpuPipelineState); CC_DELETE(_gpuPipelineState); _gpuPipelineState = nullptr; } diff --git a/native/cocos/renderer/gfx-vulkan/VKPipelineState.h b/native/cocos/renderer/gfx-vulkan/VKPipelineState.h index 656fec9c7f..fe0978cab5 100644 --- a/native/cocos/renderer/gfx-vulkan/VKPipelineState.h +++ b/native/cocos/renderer/gfx-vulkan/VKPipelineState.h @@ -5,20 +5,19 @@ NS_CC_BEGIN class CCVKGPUPipelineState; -class CC_VULKAN_API CCVKPipelineState : public GFXPipelineState -{ +class CC_VULKAN_API CCVKPipelineState : public GFXPipelineState { public: - CCVKPipelineState(GFXDevice* device); + CCVKPipelineState(GFXDevice *device); ~CCVKPipelineState(); public: - bool initialize(const GFXPipelineStateInfo& info); + bool initialize(const GFXPipelineStateInfo &info); void destroy(); - CC_INLINE CCVKGPUPipelineState* gpuPipelineState() const { return _gpuPipelineState; } + CC_INLINE CCVKGPUPipelineState *gpuPipelineState() const { return _gpuPipelineState; } private: - CCVKGPUPipelineState* _gpuPipelineState = nullptr; + CCVKGPUPipelineState *_gpuPipelineState = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKQueue.cc b/native/cocos/renderer/gfx-vulkan/VKQueue.cc index 859e1e2e77..dd858f50f3 100644 --- a/native/cocos/renderer/gfx-vulkan/VKQueue.cc +++ b/native/cocos/renderer/gfx-vulkan/VKQueue.cc @@ -1,37 +1,33 @@ #include "VKStd.h" -#include "VKQueue.h" + +#include "VKCommandBuffer.h" +#include "VKCommands.h" #include "VKDevice.h" #include "VKFence.h" -#include "VKCommands.h" -#include "VKCommandBuffer.h" +#include "VKQueue.h" NS_CC_BEGIN -CCVKQueue::CCVKQueue(GFXDevice* device) - : GFXQueue(device) -{ +CCVKQueue::CCVKQueue(GFXDevice *device) +: GFXQueue(device) { } -CCVKQueue::~CCVKQueue() -{ +CCVKQueue::~CCVKQueue() { } -bool CCVKQueue::initialize(const GFXQueueInfo &info) -{ +bool CCVKQueue::initialize(const GFXQueueInfo &info) { _type = info.type; _gpuQueue = CC_NEW(CCVKGPUQueue); _gpuQueue->type = _type; - CCVKCmdFuncGetDeviceQueue((CCVKDevice*)_device, _gpuQueue); + CCVKCmdFuncGetDeviceQueue((CCVKDevice *)_device, _gpuQueue); _status = GFXStatus::SUCCESS; return true; } -void CCVKQueue::destroy() -{ - if (_gpuQueue) - { +void CCVKQueue::destroy() { + if (_gpuQueue) { _gpuQueue->vkQueue = VK_NULL_HANDLE; CC_DELETE(_gpuQueue); _gpuQueue = nullptr; @@ -39,22 +35,19 @@ void CCVKQueue::destroy() _status = GFXStatus::UNREADY; } -void CCVKQueue::submit(const std::vector& cmdBuffs, GFXFence* fence) -{ - if (!_isAsync) - { +void CCVKQueue::submit(const std::vector &cmdBuffs, GFXFence *fence) { + if (!_isAsync) { _gpuQueue->commandBuffers.clear(); uint count = cmdBuffs.size(); - for (uint i = 0u; i < count; ++i) - { - CCVKCommandBuffer* cmdBuffer = (CCVKCommandBuffer*)cmdBuffs[i]; + for (uint i = 0u; i < count; ++i) { + CCVKCommandBuffer *cmdBuffer = (CCVKCommandBuffer *)cmdBuffs[i]; _gpuQueue->commandBuffers.push(cmdBuffer->_gpuCommandBuffer->vkCommandBuffer); _numDrawCalls += cmdBuffer->_numDrawCalls; _numInstances += cmdBuffer->_numInstances; _numTriangles += cmdBuffer->_numTriangles; } - VkSubmitInfo submitInfo{ VK_STRUCTURE_TYPE_SUBMIT_INFO }; + VkSubmitInfo submitInfo{VK_STRUCTURE_TYPE_SUBMIT_INFO}; submitInfo.waitSemaphoreCount = 1; submitInfo.pWaitSemaphores = &_gpuQueue->nextWaitSemaphore; submitInfo.pWaitDstStageMask = &_gpuQueue->submitStageMask; @@ -63,11 +56,11 @@ void CCVKQueue::submit(const std::vector& cmdBuffs, GFXFence* submitInfo.signalSemaphoreCount = 1; submitInfo.pSignalSemaphores = &_gpuQueue->nextSignalSemaphore; - VkFence vkFence = fence ? ((CCVKFence*)fence)->gpuFence()->vkFence : VK_NULL_HANDLE; + VkFence vkFence = fence ? ((CCVKFence *)fence)->gpuFence()->vkFence : VK_NULL_HANDLE; VK_CHECK(vkQueueSubmit(_gpuQueue->vkQueue, 1, &submitInfo, vkFence)); _gpuQueue->nextWaitSemaphore = _gpuQueue->nextSignalSemaphore; - _gpuQueue->nextSignalSemaphore = ((CCVKDevice*)_device)->gpuSemaphorePool()->alloc(); + _gpuQueue->nextSignalSemaphore = ((CCVKDevice *)_device)->gpuSemaphorePool()->alloc(); } } diff --git a/native/cocos/renderer/gfx-vulkan/VKQueue.h b/native/cocos/renderer/gfx-vulkan/VKQueue.h index ac079a8134..4c811615b7 100644 --- a/native/cocos/renderer/gfx-vulkan/VKQueue.h +++ b/native/cocos/renderer/gfx-vulkan/VKQueue.h @@ -7,21 +7,21 @@ class CCVKGPUQueue; class CC_VULKAN_API CCVKQueue : public GFXQueue { public: - CCVKQueue(GFXDevice* device); + CCVKQueue(GFXDevice *device); ~CCVKQueue(); friend class CCVKDevice; public: - bool initialize(const GFXQueueInfo& info); + bool initialize(const GFXQueueInfo &info); void destroy(); - void submit(const std::vector& cmd_buffs, GFXFence* fence); + void submit(const std::vector &cmd_buffs, GFXFence *fence); CC_INLINE bool isAsync() const { return _isAsync; } - CC_INLINE CCVKGPUQueue* gpuQueue() const { return _gpuQueue; } + CC_INLINE CCVKGPUQueue *gpuQueue() const { return _gpuQueue; } private: - CCVKGPUQueue* _gpuQueue; + CCVKGPUQueue *_gpuQueue; bool _isAsync = false; uint _numDrawCalls = 0; uint _numInstances = 0; diff --git a/native/cocos/renderer/gfx-vulkan/VKRenderPass.cc b/native/cocos/renderer/gfx-vulkan/VKRenderPass.cc index 772f6a9e38..a13168db85 100644 --- a/native/cocos/renderer/gfx-vulkan/VKRenderPass.cc +++ b/native/cocos/renderer/gfx-vulkan/VKRenderPass.cc @@ -1,20 +1,18 @@ #include "VKStd.h" -#include "VKRenderPass.h" + #include "VKCommands.h" +#include "VKRenderPass.h" NS_CC_BEGIN -CCVKRenderPass::CCVKRenderPass(GFXDevice* device) - : GFXRenderPass(device) -{ +CCVKRenderPass::CCVKRenderPass(GFXDevice *device) +: GFXRenderPass(device) { } -CCVKRenderPass::~CCVKRenderPass() -{ +CCVKRenderPass::~CCVKRenderPass() { } -bool CCVKRenderPass::initialize(const GFXRenderPassInfo &info) -{ +bool CCVKRenderPass::initialize(const GFXRenderPassInfo &info) { _colorAttachments = info.colorAttachments; _depthStencilAttachment = info.depthStencilAttachment; _subPasses = info.subPasses; @@ -23,7 +21,7 @@ bool CCVKRenderPass::initialize(const GFXRenderPassInfo &info) _gpuRenderPass->colorAttachments = _colorAttachments; _gpuRenderPass->depthStencilAttachment = _depthStencilAttachment; _gpuRenderPass->subPasses = _subPasses; - CCVKCmdFuncCreateRenderPass((CCVKDevice*)_device, _gpuRenderPass); + CCVKCmdFuncCreateRenderPass((CCVKDevice *)_device, _gpuRenderPass); _hash = computeHash(); _status = GFXStatus::SUCCESS; @@ -31,11 +29,9 @@ bool CCVKRenderPass::initialize(const GFXRenderPassInfo &info) return true; } -void CCVKRenderPass::destroy() -{ - if (_gpuRenderPass) - { - CCVKCmdFuncDestroyRenderPass((CCVKDevice*)_device, _gpuRenderPass); +void CCVKRenderPass::destroy() { + if (_gpuRenderPass) { + CCVKCmdFuncDestroyRenderPass((CCVKDevice *)_device, _gpuRenderPass); CC_DELETE(_gpuRenderPass); _gpuRenderPass = nullptr; } diff --git a/native/cocos/renderer/gfx-vulkan/VKRenderPass.h b/native/cocos/renderer/gfx-vulkan/VKRenderPass.h index 5c6bf62f9c..b217f9e706 100644 --- a/native/cocos/renderer/gfx-vulkan/VKRenderPass.h +++ b/native/cocos/renderer/gfx-vulkan/VKRenderPass.h @@ -5,20 +5,19 @@ NS_CC_BEGIN class CCVKGPURenderPass; -class CC_VULKAN_API CCVKRenderPass : public GFXRenderPass -{ +class CC_VULKAN_API CCVKRenderPass : public GFXRenderPass { public: - CCVKRenderPass(GFXDevice* device); + CCVKRenderPass(GFXDevice *device); ~CCVKRenderPass(); public: - bool initialize(const GFXRenderPassInfo& info); + bool initialize(const GFXRenderPassInfo &info); void destroy(); - CC_INLINE CCVKGPURenderPass* gpuRenderPass() const { return _gpuRenderPass; } + CC_INLINE CCVKGPURenderPass *gpuRenderPass() const { return _gpuRenderPass; } private: - CCVKGPURenderPass* _gpuRenderPass = nullptr; + CCVKGPURenderPass *_gpuRenderPass = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKSPIRV.h b/native/cocos/renderer/gfx-vulkan/VKSPIRV.h index 0f3ae537e7..89330255b2 100644 --- a/native/cocos/renderer/gfx-vulkan/VKSPIRV.h +++ b/native/cocos/renderer/gfx-vulkan/VKSPIRV.h @@ -1,158 +1,148 @@ #ifndef CC_GFXVULKAN_SPIRV_H_ -#define CC_GFXVULKAN_SPIRV_H_ + #define CC_GFXVULKAN_SPIRV_H_ -#include "SPIRV/GlslangToSpv.h" -#include "glslang/Public/ShaderLang.h" + #include "SPIRV/GlslangToSpv.h" + #include "glslang/Public/ShaderLang.h" NS_CC_BEGIN -namespace -{ - EShLanguage getShaderStage(GFXShaderType type) - { - switch (type) - { +namespace { +EShLanguage getShaderStage(GFXShaderType type) { + switch (type) { case GFXShaderType::VERTEX: return EShLangVertex; case GFXShaderType::CONTROL: return EShLangTessControl; case GFXShaderType::EVALUATION: return EShLangTessEvaluation; case GFXShaderType::GEOMETRY: return EShLangGeometry; case GFXShaderType::FRAGMENT: return EShLangFragment; case GFXShaderType::COMPUTE: return EShLangCompute; - default: - { + default: { CCASSERT(false, "Unsupported GFXShaderType, convert to EShLanguage failed."); return EShLangVertex; } - } } +} - glslang::EShTargetClientVersion getClientVersion(int vulkanMinorVersion) - { - switch (vulkanMinorVersion) - { +glslang::EShTargetClientVersion getClientVersion(int vulkanMinorVersion) { + switch (vulkanMinorVersion) { case 0: return glslang::EShTargetVulkan_1_0; case 1: return glslang::EShTargetVulkan_1_1; case 2: return glslang::EShTargetVulkan_1_2; - default: - { + default: { CCASSERT(false, "Unsupported vulkan version, convert to EShTargetClientVersion failed."); return glslang::EShTargetVulkan_1_0; } - } } +} - glslang::EShTargetLanguageVersion getTargetVersion(int vulkanMinorVersion) - { - switch (vulkanMinorVersion) - { +glslang::EShTargetLanguageVersion getTargetVersion(int vulkanMinorVersion) { + switch (vulkanMinorVersion) { case 0: return glslang::EShTargetSpv_1_0; case 1: return glslang::EShTargetSpv_1_3; case 2: return glslang::EShTargetSpv_1_5; - default: - { + default: { CCASSERT(false, "Unsupported vulkan version, convert to EShTargetLanguageVersion failed."); return glslang::EShTargetSpv_1_0; } - } } +} - bool glslangInitialized = false; +bool glslangInitialized = false; - const TBuiltInResource defaultTBuiltInResource{ - /* .MaxLights = */ 32, - /* .MaxClipPlanes = */ 6, - /* .MaxTextureUnits = */ 32, - /* .MaxTextureCoords = */ 32, - /* .MaxVertexAttribs = */ 64, - /* .MaxVertexUniformComponents = */ 4096, - /* .MaxVaryingFloats = */ 64, - /* .MaxVertexTextureImageUnits = */ 32, - /* .MaxCombinedTextureImageUnits = */ 80, - /* .MaxTextureImageUnits = */ 32, - /* .MaxFragmentUniformComponents = */ 4096, - /* .MaxDrawBuffers = */ 32, - /* .MaxVertexUniformVectors = */ 128, - /* .MaxVaryingVectors = */ 8, - /* .MaxFragmentUniformVectors = */ 16, - /* .MaxVertexOutputVectors = */ 16, - /* .MaxFragmentInputVectors = */ 15, - /* .MinProgramTexelOffset = */ -8, - /* .MaxProgramTexelOffset = */ 7, - /* .MaxClipDistances = */ 8, - /* .MaxComputeWorkGroupCountX = */ 65535, - /* .MaxComputeWorkGroupCountY = */ 65535, - /* .MaxComputeWorkGroupCountZ = */ 65535, - /* .MaxComputeWorkGroupSizeX = */ 1024, - /* .MaxComputeWorkGroupSizeY = */ 1024, - /* .MaxComputeWorkGroupSizeZ = */ 64, - /* .MaxComputeUniformComponents = */ 1024, - /* .MaxComputeTextureImageUnits = */ 16, - /* .MaxComputeImageUniforms = */ 8, - /* .MaxComputeAtomicCounters = */ 8, - /* .MaxComputeAtomicCounterBuffers = */ 1, - /* .MaxVaryingComponents = */ 60, - /* .MaxVertexOutputComponents = */ 64, - /* .MaxGeometryInputComponents = */ 64, - /* .MaxGeometryOutputComponents = */ 128, - /* .MaxFragmentInputComponents = */ 128, - /* .MaxImageUnits = */ 8, - /* .MaxCombinedImageUnitsAndFragmentOutputs = */ 8, - /* .MaxCombinedShaderOutputResources = */ 8, - /* .MaxImageSamples = */ 0, - /* .MaxVertexImageUniforms = */ 0, - /* .MaxTessControlImageUniforms = */ 0, - /* .MaxTessEvaluationImageUniforms = */ 0, - /* .MaxGeometryImageUniforms = */ 0, - /* .MaxFragmentImageUniforms = */ 8, - /* .MaxCombinedImageUniforms = */ 8, - /* .MaxGeometryTextureImageUnits = */ 16, - /* .MaxGeometryOutputVertices = */ 256, - /* .MaxGeometryTotalOutputComponents = */ 1024, - /* .MaxGeometryUniformComponents = */ 1024, - /* .MaxGeometryVaryingComponents = */ 64, - /* .MaxTessControlInputComponents = */ 128, - /* .MaxTessControlOutputComponents = */ 128, - /* .MaxTessControlTextureImageUnits = */ 16, - /* .MaxTessControlUniformComponents = */ 1024, - /* .MaxTessControlTotalOutputComponents = */ 4096, - /* .MaxTessEvaluationInputComponents = */ 128, - /* .MaxTessEvaluationOutputComponents = */ 128, - /* .MaxTessEvaluationTextureImageUnits = */ 16, - /* .MaxTessEvaluationUniformComponents = */ 1024, - /* .MaxTessPatchComponents = */ 120, - /* .MaxPatchVertices = */ 32, - /* .MaxTessGenLevel = */ 64, - /* .MaxViewports = */ 16, - /* .MaxVertexAtomicCounters = */ 0, - /* .MaxTessControlAtomicCounters = */ 0, - /* .MaxTessEvaluationAtomicCounters = */ 0, - /* .MaxGeometryAtomicCounters = */ 0, - /* .MaxFragmentAtomicCounters = */ 8, - /* .MaxCombinedAtomicCounters = */ 8, - /* .MaxAtomicCounterBindings = */ 1, - /* .MaxVertexAtomicCounterBuffers = */ 0, - /* .MaxTessControlAtomicCounterBuffers = */ 0, - /* .MaxTessEvaluationAtomicCounterBuffers = */ 0, - /* .MaxGeometryAtomicCounterBuffers = */ 0, - /* .MaxFragmentAtomicCounterBuffers = */ 1, - /* .MaxCombinedAtomicCounterBuffers = */ 1, - /* .MaxAtomicCounterBufferSize = */ 16384, - /* .MaxTransformFeedbackBuffers = */ 4, - /* .MaxTransformFeedbackInterleavedComponents = */ 64, - /* .MaxCullDistances = */ 8, - /* .MaxCombinedClipAndCullDistances = */ 8, - /* .MaxSamples = */ 4, - /* .maxMeshOutputVerticesNV = */ 256, - /* .maxMeshOutputPrimitivesNV = */ 512, - /* .maxMeshWorkGroupSizeX_NV = */ 32, - /* .maxMeshWorkGroupSizeY_NV = */ 1, - /* .maxMeshWorkGroupSizeZ_NV = */ 1, - /* .maxTaskWorkGroupSizeX_NV = */ 32, - /* .maxTaskWorkGroupSizeY_NV = */ 1, - /* .maxTaskWorkGroupSizeZ_NV = */ 1, - /* .maxMeshViewCountNV = */ 4, +const TBuiltInResource defaultTBuiltInResource{ + /* .MaxLights = */ 32, + /* .MaxClipPlanes = */ 6, + /* .MaxTextureUnits = */ 32, + /* .MaxTextureCoords = */ 32, + /* .MaxVertexAttribs = */ 64, + /* .MaxVertexUniformComponents = */ 4096, + /* .MaxVaryingFloats = */ 64, + /* .MaxVertexTextureImageUnits = */ 32, + /* .MaxCombinedTextureImageUnits = */ 80, + /* .MaxTextureImageUnits = */ 32, + /* .MaxFragmentUniformComponents = */ 4096, + /* .MaxDrawBuffers = */ 32, + /* .MaxVertexUniformVectors = */ 128, + /* .MaxVaryingVectors = */ 8, + /* .MaxFragmentUniformVectors = */ 16, + /* .MaxVertexOutputVectors = */ 16, + /* .MaxFragmentInputVectors = */ 15, + /* .MinProgramTexelOffset = */ -8, + /* .MaxProgramTexelOffset = */ 7, + /* .MaxClipDistances = */ 8, + /* .MaxComputeWorkGroupCountX = */ 65535, + /* .MaxComputeWorkGroupCountY = */ 65535, + /* .MaxComputeWorkGroupCountZ = */ 65535, + /* .MaxComputeWorkGroupSizeX = */ 1024, + /* .MaxComputeWorkGroupSizeY = */ 1024, + /* .MaxComputeWorkGroupSizeZ = */ 64, + /* .MaxComputeUniformComponents = */ 1024, + /* .MaxComputeTextureImageUnits = */ 16, + /* .MaxComputeImageUniforms = */ 8, + /* .MaxComputeAtomicCounters = */ 8, + /* .MaxComputeAtomicCounterBuffers = */ 1, + /* .MaxVaryingComponents = */ 60, + /* .MaxVertexOutputComponents = */ 64, + /* .MaxGeometryInputComponents = */ 64, + /* .MaxGeometryOutputComponents = */ 128, + /* .MaxFragmentInputComponents = */ 128, + /* .MaxImageUnits = */ 8, + /* .MaxCombinedImageUnitsAndFragmentOutputs = */ 8, + /* .MaxCombinedShaderOutputResources = */ 8, + /* .MaxImageSamples = */ 0, + /* .MaxVertexImageUniforms = */ 0, + /* .MaxTessControlImageUniforms = */ 0, + /* .MaxTessEvaluationImageUniforms = */ 0, + /* .MaxGeometryImageUniforms = */ 0, + /* .MaxFragmentImageUniforms = */ 8, + /* .MaxCombinedImageUniforms = */ 8, + /* .MaxGeometryTextureImageUnits = */ 16, + /* .MaxGeometryOutputVertices = */ 256, + /* .MaxGeometryTotalOutputComponents = */ 1024, + /* .MaxGeometryUniformComponents = */ 1024, + /* .MaxGeometryVaryingComponents = */ 64, + /* .MaxTessControlInputComponents = */ 128, + /* .MaxTessControlOutputComponents = */ 128, + /* .MaxTessControlTextureImageUnits = */ 16, + /* .MaxTessControlUniformComponents = */ 1024, + /* .MaxTessControlTotalOutputComponents = */ 4096, + /* .MaxTessEvaluationInputComponents = */ 128, + /* .MaxTessEvaluationOutputComponents = */ 128, + /* .MaxTessEvaluationTextureImageUnits = */ 16, + /* .MaxTessEvaluationUniformComponents = */ 1024, + /* .MaxTessPatchComponents = */ 120, + /* .MaxPatchVertices = */ 32, + /* .MaxTessGenLevel = */ 64, + /* .MaxViewports = */ 16, + /* .MaxVertexAtomicCounters = */ 0, + /* .MaxTessControlAtomicCounters = */ 0, + /* .MaxTessEvaluationAtomicCounters = */ 0, + /* .MaxGeometryAtomicCounters = */ 0, + /* .MaxFragmentAtomicCounters = */ 8, + /* .MaxCombinedAtomicCounters = */ 8, + /* .MaxAtomicCounterBindings = */ 1, + /* .MaxVertexAtomicCounterBuffers = */ 0, + /* .MaxTessControlAtomicCounterBuffers = */ 0, + /* .MaxTessEvaluationAtomicCounterBuffers = */ 0, + /* .MaxGeometryAtomicCounterBuffers = */ 0, + /* .MaxFragmentAtomicCounterBuffers = */ 1, + /* .MaxCombinedAtomicCounterBuffers = */ 1, + /* .MaxAtomicCounterBufferSize = */ 16384, + /* .MaxTransformFeedbackBuffers = */ 4, + /* .MaxTransformFeedbackInterleavedComponents = */ 64, + /* .MaxCullDistances = */ 8, + /* .MaxCombinedClipAndCullDistances = */ 8, + /* .MaxSamples = */ 4, + /* .maxMeshOutputVerticesNV = */ 256, + /* .maxMeshOutputPrimitivesNV = */ 512, + /* .maxMeshWorkGroupSizeX_NV = */ 32, + /* .maxMeshWorkGroupSizeY_NV = */ 1, + /* .maxMeshWorkGroupSizeZ_NV = */ 1, + /* .maxTaskWorkGroupSizeX_NV = */ 32, + /* .maxTaskWorkGroupSizeY_NV = */ 1, + /* .maxTaskWorkGroupSizeZ_NV = */ 1, + /* .maxMeshViewCountNV = */ 4, - /* .limits = */ { + /* .limits = */ { /* .nonInductiveForLoops = */ 1, /* .whileLoops = */ 1, /* .doWhileLoops = */ 1, @@ -162,52 +152,48 @@ namespace /* .generalSamplerIndexing = */ 1, /* .generalVariableIndexing = */ 1, /* .generalConstantMatrixVectorIndexing = */ 1, - } }; + }}; - const vector::type GLSL2SPIRV(GFXShaderType type, const String &source, int vulkanMinorVersion = 2) - { - if (!glslangInitialized) - { - glslang::InitializeProcess(); - glslangInitialized = true; - } - - EShLanguage stage = getShaderStage(type); - const char* string = source.c_str(); - glslang::TShader shader(stage); - shader.setStrings(&string, 1); - - int clientInputSemanticsVersion = 100 + vulkanMinorVersion * 10; - glslang::EShTargetClientVersion clientVersion = getClientVersion(vulkanMinorVersion); - glslang::EShTargetLanguageVersion targetVersion = getTargetVersion(vulkanMinorVersion); - - shader.setEnvInput(glslang::EShSourceGlsl, stage, glslang::EShClientVulkan, clientInputSemanticsVersion); - shader.setEnvClient(glslang::EShClientVulkan, clientVersion); - shader.setEnvTarget(glslang::EShTargetSpv, targetVersion); - - EShMessages messages = (EShMessages)(EShMsgSpvRules | EShMsgVulkanRules); - - if (!shader.parse(&defaultTBuiltInResource, clientInputSemanticsVersion, false, messages)) - { - CC_LOG_ERROR("GLSL Parsing Failed:\n%s\n%s", shader.getInfoLog(), shader.getInfoDebugLog()); - } - - glslang::TProgram program; - program.addShader(&shader); - - if (!program.link(messages)) - { - CC_LOG_ERROR("GLSL Linking Failed:\n%s\n%s", program.getInfoLog(), program.getInfoDebugLog()); - } - - std::vector spirv; - spv::SpvBuildLogger logger; - glslang::SpvOptions spvOptions; - glslang::GlslangToSpv(*program.getIntermediate(stage), spirv, &logger, &spvOptions); - - return std::move(spirv); +const vector::type GLSL2SPIRV(GFXShaderType type, const String &source, int vulkanMinorVersion = 2) { + if (!glslangInitialized) { + glslang::InitializeProcess(); + glslangInitialized = true; } + + EShLanguage stage = getShaderStage(type); + const char *string = source.c_str(); + glslang::TShader shader(stage); + shader.setStrings(&string, 1); + + int clientInputSemanticsVersion = 100 + vulkanMinorVersion * 10; + glslang::EShTargetClientVersion clientVersion = getClientVersion(vulkanMinorVersion); + glslang::EShTargetLanguageVersion targetVersion = getTargetVersion(vulkanMinorVersion); + + shader.setEnvInput(glslang::EShSourceGlsl, stage, glslang::EShClientVulkan, clientInputSemanticsVersion); + shader.setEnvClient(glslang::EShClientVulkan, clientVersion); + shader.setEnvTarget(glslang::EShTargetSpv, targetVersion); + + EShMessages messages = (EShMessages)(EShMsgSpvRules | EShMsgVulkanRules); + + if (!shader.parse(&defaultTBuiltInResource, clientInputSemanticsVersion, false, messages)) { + CC_LOG_ERROR("GLSL Parsing Failed:\n%s\n%s", shader.getInfoLog(), shader.getInfoDebugLog()); + } + + glslang::TProgram program; + program.addShader(&shader); + + if (!program.link(messages)) { + CC_LOG_ERROR("GLSL Linking Failed:\n%s\n%s", program.getInfoLog(), program.getInfoDebugLog()); + } + + std::vector spirv; + spv::SpvBuildLogger logger; + glslang::SpvOptions spvOptions; + glslang::GlslangToSpv(*program.getIntermediate(stage), spirv, &logger, &spvOptions); + + return std::move(spirv); } +} // namespace #endif diff --git a/native/cocos/renderer/gfx-vulkan/VKSampler.cc b/native/cocos/renderer/gfx-vulkan/VKSampler.cc index 1debe35296..8f5e3b9e11 100644 --- a/native/cocos/renderer/gfx-vulkan/VKSampler.cc +++ b/native/cocos/renderer/gfx-vulkan/VKSampler.cc @@ -1,20 +1,18 @@ #include "VKStd.h" -#include "VKSampler.h" + #include "VKCommands.h" +#include "VKSampler.h" NS_CC_BEGIN -CCVKSampler::CCVKSampler(GFXDevice* device) - : GFXSampler(device) -{ +CCVKSampler::CCVKSampler(GFXDevice *device) +: GFXSampler(device) { } -CCVKSampler::~CCVKSampler() -{ +CCVKSampler::~CCVKSampler() { } -bool CCVKSampler::initialize(const GFXSamplerInfo &info) -{ +bool CCVKSampler::initialize(const GFXSamplerInfo &info) { _name = info.name; _minFilter = info.minFilter; _magFilter = info.magFilter; @@ -43,18 +41,16 @@ bool CCVKSampler::initialize(const GFXSamplerInfo &info) _gpuSampler->maxLOD = _maxLOD; _gpuSampler->mipLODBias = _mipLODBias; - CCVKCmdFuncCreateSampler((CCVKDevice*)_device, _gpuSampler); + CCVKCmdFuncCreateSampler((CCVKDevice *)_device, _gpuSampler); _status = GFXStatus::SUCCESS; return true; } -void CCVKSampler::destroy() -{ - if (_gpuSampler) - { - CCVKCmdFuncDestroySampler((CCVKDevice*)_device, _gpuSampler); +void CCVKSampler::destroy() { + if (_gpuSampler) { + CCVKCmdFuncDestroySampler((CCVKDevice *)_device, _gpuSampler); CC_DELETE(_gpuSampler); _gpuSampler = nullptr; } diff --git a/native/cocos/renderer/gfx-vulkan/VKSampler.h b/native/cocos/renderer/gfx-vulkan/VKSampler.h index f4d4d69364..18811371fa 100644 --- a/native/cocos/renderer/gfx-vulkan/VKSampler.h +++ b/native/cocos/renderer/gfx-vulkan/VKSampler.h @@ -7,17 +7,17 @@ class CCVKGPUSampler; class CC_VULKAN_API CCVKSampler : public GFXSampler { public: - CCVKSampler(GFXDevice* device); - ~CCVKSampler(); - + CCVKSampler(GFXDevice *device); + ~CCVKSampler(); + public: - bool initialize(const GFXSamplerInfo& info); - void destroy(); - - CC_INLINE CCVKGPUSampler* gpuSampler() const { return _gpuSampler; } - + bool initialize(const GFXSamplerInfo &info); + void destroy(); + + CC_INLINE CCVKGPUSampler *gpuSampler() const { return _gpuSampler; } + private: - CCVKGPUSampler* _gpuSampler = nullptr; + CCVKGPUSampler *_gpuSampler = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKShader.cc b/native/cocos/renderer/gfx-vulkan/VKShader.cc index 2c996d9fd7..ef3270ce57 100644 --- a/native/cocos/renderer/gfx-vulkan/VKShader.cc +++ b/native/cocos/renderer/gfx-vulkan/VKShader.cc @@ -1,20 +1,18 @@ #include "VKStd.h" -#include "VKShader.h" + #include "VKCommands.h" +#include "VKShader.h" NS_CC_BEGIN -CCVKShader::CCVKShader(GFXDevice* device) - : GFXShader(device) -{ +CCVKShader::CCVKShader(GFXDevice *device) +: GFXShader(device) { } -CCVKShader::~CCVKShader() -{ +CCVKShader::~CCVKShader() { } -bool CCVKShader::initialize(const GFXShaderInfo &info) -{ +bool CCVKShader::initialize(const GFXShaderInfo &info) { _name = info.name; _stages = info.stages; _blocks = info.blocks; @@ -24,23 +22,20 @@ bool CCVKShader::initialize(const GFXShaderInfo &info) _gpuShader->name = _name; _gpuShader->blocks = _blocks; _gpuShader->samplers = _samplers; - for (const auto& stage : _stages) - { - _gpuShader->gpuStages.push_back({ stage.type, stage.source, stage.macros }); + for (GFXShaderStage &stage : _stages) { + _gpuShader->gpuStages.push_back({stage.type, stage.source, stage.macros}); } - CCVKCmdFuncCreateShader((CCVKDevice*)_device, _gpuShader); + CCVKCmdFuncCreateShader((CCVKDevice *)_device, _gpuShader); _status = GFXStatus::SUCCESS; return true; } -void CCVKShader::destroy() -{ - if (_gpuShader) - { - CCVKCmdFuncDestroyShader((CCVKDevice*)_device, _gpuShader); +void CCVKShader::destroy() { + if (_gpuShader) { + CCVKCmdFuncDestroyShader((CCVKDevice *)_device, _gpuShader); CC_DELETE(_gpuShader); _gpuShader = nullptr; } diff --git a/native/cocos/renderer/gfx-vulkan/VKShader.h b/native/cocos/renderer/gfx-vulkan/VKShader.h index b89b3dbe40..c37f09e7c3 100644 --- a/native/cocos/renderer/gfx-vulkan/VKShader.h +++ b/native/cocos/renderer/gfx-vulkan/VKShader.h @@ -6,17 +6,18 @@ NS_CC_BEGIN class CCVKGPUShader; class CC_VULKAN_API CCVKShader : public GFXShader { - public: - CCVKShader(GFXDevice* device); - ~CCVKShader(); - - public: - bool initialize(const GFXShaderInfo& info); - void destroy(); - - CC_INLINE CCVKGPUShader* gpuShader() const { return _gpuShader; } - private: - CCVKGPUShader* _gpuShader = nullptr; +public: + CCVKShader(GFXDevice *device); + ~CCVKShader(); + +public: + bool initialize(const GFXShaderInfo &info); + void destroy(); + + CC_INLINE CCVKGPUShader *gpuShader() const { return _gpuShader; } + +private: + CCVKGPUShader *_gpuShader = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKStd.h b/native/cocos/renderer/gfx-vulkan/VKStd.h index 818fe8ec7e..115a004aef 100644 --- a/native/cocos/renderer/gfx-vulkan/VKStd.h +++ b/native/cocos/renderer/gfx-vulkan/VKStd.h @@ -4,38 +4,34 @@ #include #if (CC_PLATFORM == CC_PLATFORM_WINDOWS) -# if defined(CC_STATIC) -# define CC_VULKAN_API -# else -# ifdef CC_VK_EXPORTS -# define CC_VULKAN_API __declspec(dllexport) -# else -# define CC_VULKAN_API __declspec(dllimport) -# endif -# endif + #if defined(CC_STATIC) + #define CC_VULKAN_API + #else + #ifdef CC_VK_EXPORTS + #define CC_VULKAN_API __declspec(dllexport) + #else + #define CC_VULKAN_API __declspec(dllimport) + #endif + #endif #else -# define CC_VULKAN_API + #define CC_VULKAN_API #endif #define VK_CHECK(x) \ - do \ - { \ + do { \ VkResult err = x; \ - if (err) \ - { \ + if (err) { \ CC_LOG_ERROR("Detected Vulkan error: %d", err); \ CCASSERT(0, "Vulkan Error"); \ } \ } while (0) #define ASSERT_VK_HANDLE(handle) \ - do \ - { \ - if ((handle) == VK_NULL_HANDLE) \ - { \ - CC_LOG_ERROR("Handle is NULL"); \ - CCASSERT(0); \ - } \ + do { \ + if ((handle) == VK_NULL_HANDLE) { \ + CC_LOG_ERROR("Handle is NULL"); \ + CCASSERT(0); \ + } \ } while (0) #endif diff --git a/native/cocos/renderer/gfx-vulkan/VKTexture.cc b/native/cocos/renderer/gfx-vulkan/VKTexture.cc index 2f2bde6d1c..dcf0e44200 100644 --- a/native/cocos/renderer/gfx-vulkan/VKTexture.cc +++ b/native/cocos/renderer/gfx-vulkan/VKTexture.cc @@ -1,20 +1,18 @@ #include "VKStd.h" -#include "VKTexture.h" + #include "VKCommands.h" +#include "VKTexture.h" NS_CC_BEGIN -CCVKTexture::CCVKTexture(GFXDevice* device) - : GFXTexture(device) -{ +CCVKTexture::CCVKTexture(GFXDevice *device) +: GFXTexture(device) { } -CCVKTexture::~CCVKTexture() -{ +CCVKTexture::~CCVKTexture() { } -bool CCVKTexture::initialize(const GFXTextureInfo &info) -{ +bool CCVKTexture::initialize(const GFXTextureInfo &info) { _type = info.type; _usage = info.usage; _format = info.format; @@ -27,61 +25,44 @@ bool CCVKTexture::initialize(const GFXTextureInfo &info) _flags = info.flags; _size = GFXFormatSize(_format, _width, _height, _depth); - if (_flags & GFXTextureFlags::BAKUP_BUFFER) - { - _buffer = (uint8_t*)CC_MALLOC(_size); + if (_flags & GFXTextureFlags::BAKUP_BUFFER) { + _buffer = (uint8_t *)CC_MALLOC(_size); _device->getMemoryStatus().textureSize += _size; } _gpuTexture = CC_NEW(CCVKGPUTexture); _gpuTexture->type = _type; - switch (_type) - { - case GFXTextureType::TEX1D: - { - if (_arrayLayer) - { - _gpuTexture->viewType = _arrayLayer <= 1 ? GFXTextureViewType::TV1D : GFXTextureViewType::TV1D_ARRAY; + switch (_type) { + case GFXTextureType::TEX1D: { + if (_arrayLayer) { + _gpuTexture->viewType = _arrayLayer <= 1 ? GFXTextureViewType::TV1D : GFXTextureViewType::TV1D_ARRAY; + } else { + _gpuTexture->viewType = GFXTextureViewType::TV1D; + } + break; } - else - { - _gpuTexture->viewType = GFXTextureViewType::TV1D; - } - break; - } - case GFXTextureType::TEX2D: - { - if (_arrayLayer) - { - if (_arrayLayer <= 1) - { + case GFXTextureType::TEX2D: { + if (_arrayLayer) { + if (_arrayLayer <= 1) { + _gpuTexture->viewType = GFXTextureViewType::TV2D; + } else if (_flags & GFXTextureFlagBit::CUBEMAP) { + _gpuTexture->viewType = GFXTextureViewType::CUBE; + } else { + _gpuTexture->viewType = GFXTextureViewType::TV2D_ARRAY; + } + } else { _gpuTexture->viewType = GFXTextureViewType::TV2D; } - else if (_flags & GFXTextureFlagBit::CUBEMAP) - { - _gpuTexture->viewType = GFXTextureViewType::CUBE; - } - else - { - _gpuTexture->viewType = GFXTextureViewType::TV2D_ARRAY; - } + break; } - else - { + case GFXTextureType::TEX3D: { + _gpuTexture->viewType = GFXTextureViewType::TV3D; + break; + } + default: { _gpuTexture->viewType = GFXTextureViewType::TV2D; } - break; - } - case GFXTextureType::TEX3D: - { - _gpuTexture->viewType = GFXTextureViewType::TV3D; - break; - } - default: - { - _gpuTexture->viewType = GFXTextureViewType::TV2D; - } } _gpuTexture->format = _format; @@ -96,13 +77,10 @@ bool CCVKTexture::initialize(const GFXTextureInfo &info) _gpuTexture->flags = _flags; _gpuTexture->isPowerOf2 = math::IsPowerOfTwo(_width) && math::IsPowerOfTwo(_height); - if (CCVKCmdFuncCreateTexture((CCVKDevice*)_device, _gpuTexture)) - { + if (CCVKCmdFuncCreateTexture((CCVKDevice *)_device, _gpuTexture)) { _device->getMemoryStatus().textureSize += _size; _status = GFXStatus::SUCCESS; - } - else - { + } else { CC_DELETE(_gpuTexture); _gpuTexture = nullptr; _status = GFXStatus::FAILED; @@ -112,18 +90,15 @@ bool CCVKTexture::initialize(const GFXTextureInfo &info) return true; } -void CCVKTexture::destroy() -{ - if (_gpuTexture) - { - CCVKCmdFuncDestroyTexture((CCVKDevice*)_device, _gpuTexture); +void CCVKTexture::destroy() { + if (_gpuTexture) { + CCVKCmdFuncDestroyTexture((CCVKDevice *)_device, _gpuTexture); _device->getMemoryStatus().textureSize -= _size; CC_DELETE(_gpuTexture); _gpuTexture = nullptr; } - if (_buffer) - { + if (_buffer) { CC_FREE(_buffer); _device->getMemoryStatus().textureSize -= _size; _buffer = nullptr; @@ -132,28 +107,25 @@ void CCVKTexture::destroy() _status = GFXStatus::UNREADY; } -void CCVKTexture::resize(uint width, uint height) -{ +void CCVKTexture::resize(uint width, uint height) { uint size = GFXFormatSize(_format, width, height, _depth); - if (_size != size) - { + if (_size != size) { const uint old_size = _size; _width = width; _height = height; _size = size; - GFXMemoryStatus& status = _device->getMemoryStatus(); + GFXMemoryStatus &status = _device->getMemoryStatus(); _gpuTexture->width = _width; _gpuTexture->height = _height; _gpuTexture->size = _size; - CCVKCmdFuncResizeTexture((CCVKDevice*)_device, _gpuTexture); + CCVKCmdFuncResizeTexture((CCVKDevice *)_device, _gpuTexture); status.bufferSize -= old_size; status.bufferSize += _size; - if (_buffer) - { - const uint8_t* old_buff = _buffer; - _buffer = (uint8_t*)CC_MALLOC(_size); + if (_buffer) { + const uint8_t *old_buff = _buffer; + _buffer = (uint8_t *)CC_MALLOC(_size); memcpy(_buffer, old_buff, old_size); CC_FREE(_buffer); status.bufferSize -= old_size; diff --git a/native/cocos/renderer/gfx-vulkan/VKTexture.h b/native/cocos/renderer/gfx-vulkan/VKTexture.h index e515273b67..6f412261aa 100644 --- a/native/cocos/renderer/gfx-vulkan/VKTexture.h +++ b/native/cocos/renderer/gfx-vulkan/VKTexture.h @@ -6,19 +6,19 @@ NS_CC_BEGIN class CCVKGPUTexture; class CC_VULKAN_API CCVKTexture : public GFXTexture { - public: - CCVKTexture(GFXDevice* device); - ~CCVKTexture(); - - public: - bool initialize(const GFXTextureInfo& info); - void destroy(); - void resize(uint width, uint height); - - CC_INLINE CCVKGPUTexture* gpuTexture() const { return _gpuTexture; } +public: + CCVKTexture(GFXDevice *device); + ~CCVKTexture(); - private: - CCVKGPUTexture* _gpuTexture = nullptr; +public: + bool initialize(const GFXTextureInfo &info); + void destroy(); + void resize(uint width, uint height); + + CC_INLINE CCVKGPUTexture *gpuTexture() const { return _gpuTexture; } + +private: + CCVKGPUTexture *_gpuTexture = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKTextureView.cc b/native/cocos/renderer/gfx-vulkan/VKTextureView.cc index 780a75505a..3520050bbe 100644 --- a/native/cocos/renderer/gfx-vulkan/VKTextureView.cc +++ b/native/cocos/renderer/gfx-vulkan/VKTextureView.cc @@ -1,21 +1,19 @@ #include "VKStd.h" -#include "VKTextureView.h" -#include "VKTexture.h" + #include "VKCommands.h" +#include "VKTexture.h" +#include "VKTextureView.h" NS_CC_BEGIN -CCVKTextureView::CCVKTextureView(GFXDevice* device) - : GFXTextureView(device) -{ +CCVKTextureView::CCVKTextureView(GFXDevice *device) +: GFXTextureView(device) { } -CCVKTextureView::~CCVKTextureView() -{ +CCVKTextureView::~CCVKTextureView() { } -bool CCVKTextureView::initialize(const GFXTextureViewInfo &info) -{ +bool CCVKTextureView::initialize(const GFXTextureViewInfo &info) { _texture = info.texture; _type = info.type; _format = info.format; @@ -23,31 +21,28 @@ bool CCVKTextureView::initialize(const GFXTextureViewInfo &info) _levelCount = info.levelCount; _baseLayer = info.baseLayer; _layerCount = info.layerCount; - if(_texture == nullptr) - { + if (_texture == nullptr) { CC_LOG_ERROR("CCVKTextureView: texture should not be nullptr."); _status = GFXStatus::FAILED; return false; } _gpuTexView = CC_NEW(CCVKGPUTextureView); - _gpuTexView->gpuTexture = static_cast(_texture)->gpuTexture(); + _gpuTexView->gpuTexture = static_cast(_texture)->gpuTexture(); _gpuTexView->type = _type; _gpuTexView->format = _format; _gpuTexView->baseLevel = info.baseLevel; _gpuTexView->levelCount = info.levelCount; - CCVKCmdFuncCreateTextureView((CCVKDevice*)_device, _gpuTexView); + CCVKCmdFuncCreateTextureView((CCVKDevice *)_device, _gpuTexView); _status = GFXStatus::SUCCESS; return true; } -void CCVKTextureView::destroy() -{ - if (_gpuTexView) - { - CCVKCmdFuncDestroyTextureView((CCVKDevice*)_device, _gpuTexView); +void CCVKTextureView::destroy() { + if (_gpuTexView) { + CCVKCmdFuncDestroyTextureView((CCVKDevice *)_device, _gpuTexView); CC_DELETE(_gpuTexView); _gpuTexView = nullptr; } diff --git a/native/cocos/renderer/gfx-vulkan/VKTextureView.h b/native/cocos/renderer/gfx-vulkan/VKTextureView.h index bc30b4c9fd..29502c6019 100644 --- a/native/cocos/renderer/gfx-vulkan/VKTextureView.h +++ b/native/cocos/renderer/gfx-vulkan/VKTextureView.h @@ -7,17 +7,17 @@ class CCVKGPUTextureView; class CC_VULKAN_API CCVKTextureView : public GFXTextureView { public: - CCVKTextureView(GFXDevice* device); - ~CCVKTextureView(); - + CCVKTextureView(GFXDevice *device); + ~CCVKTextureView(); + public: - bool initialize(const GFXTextureViewInfo& info); - void destroy(); - - CC_INLINE CCVKGPUTextureView* gpuTexView() const { return _gpuTexView; } - + bool initialize(const GFXTextureViewInfo &info); + void destroy(); + + CC_INLINE CCVKGPUTextureView *gpuTexView() const { return _gpuTexView; } + private: - CCVKGPUTextureView* _gpuTexView = nullptr; + CCVKGPUTextureView *_gpuTexView = nullptr; }; NS_CC_END diff --git a/native/cocos/renderer/gfx-vulkan/VKUtils.h b/native/cocos/renderer/gfx-vulkan/VKUtils.h index 67a591742d..39aebf572c 100644 --- a/native/cocos/renderer/gfx-vulkan/VKUtils.h +++ b/native/cocos/renderer/gfx-vulkan/VKUtils.h @@ -10,12 +10,9 @@ NS_CC_BEGIN -namespace -{ - VkFormat MapVkFormat(GFXFormat format) - { - switch (format) - { +namespace { +VkFormat MapVkFormat(GFXFormat format) { + switch (format) { case GFXFormat::R8: return VK_FORMAT_R8_UNORM; case GFXFormat::R8SN: return VK_FORMAT_R8_SNORM; case GFXFormat::R8UI: return VK_FORMAT_R8_UINT; @@ -106,59 +103,57 @@ namespace case GFXFormat::PVRTC_RGBA4: return VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG; case GFXFormat::PVRTC2_2BPP: return VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG; case GFXFormat::PVRTC2_4BPP: return VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG; - default: - { + default: { CCASSERT(false, "Unsupported GFXFormat, convert to VkFormat failed."); return VK_FORMAT_B8G8R8A8_UNORM; } - } } +} - VkSampleCountFlagBits MapVkSampleCount(uint sampleCount) - { - if (sampleCount == 1) return VK_SAMPLE_COUNT_1_BIT; - else if (sampleCount == 2) return VK_SAMPLE_COUNT_2_BIT; - else if (sampleCount == 4) return VK_SAMPLE_COUNT_4_BIT; - else if (sampleCount == 8) return VK_SAMPLE_COUNT_8_BIT; - else if (sampleCount == 16) return VK_SAMPLE_COUNT_16_BIT; - else if (sampleCount == 32) return VK_SAMPLE_COUNT_32_BIT; - else if (sampleCount == 64) return VK_SAMPLE_COUNT_64_BIT; - else return VK_SAMPLE_COUNT_1_BIT; - } +VkSampleCountFlagBits MapVkSampleCount(uint sampleCount) { + if (sampleCount == 1) + return VK_SAMPLE_COUNT_1_BIT; + else if (sampleCount == 2) + return VK_SAMPLE_COUNT_2_BIT; + else if (sampleCount == 4) + return VK_SAMPLE_COUNT_4_BIT; + else if (sampleCount == 8) + return VK_SAMPLE_COUNT_8_BIT; + else if (sampleCount == 16) + return VK_SAMPLE_COUNT_16_BIT; + else if (sampleCount == 32) + return VK_SAMPLE_COUNT_32_BIT; + else if (sampleCount == 64) + return VK_SAMPLE_COUNT_64_BIT; + else + return VK_SAMPLE_COUNT_1_BIT; +} - VkAttachmentLoadOp MapVkLoadOp(GFXLoadOp loadOp) - { - switch (loadOp) - { +VkAttachmentLoadOp MapVkLoadOp(GFXLoadOp loadOp) { + switch (loadOp) { case GFXLoadOp::CLEAR: return VK_ATTACHMENT_LOAD_OP_CLEAR; case GFXLoadOp::LOAD: return VK_ATTACHMENT_LOAD_OP_LOAD; case GFXLoadOp::DISCARD: return VK_ATTACHMENT_LOAD_OP_DONT_CARE; - default: - { + default: { CCASSERT(false, "Unsupported GFXLoadOp, convert to VkLoadOp failed."); return VK_ATTACHMENT_LOAD_OP_LOAD; } - } } +} - VkAttachmentStoreOp MapVkStoreOp(GFXStoreOp storeOp) - { - switch (storeOp) - { +VkAttachmentStoreOp MapVkStoreOp(GFXStoreOp storeOp) { + switch (storeOp) { case GFXStoreOp::STORE: return VK_ATTACHMENT_STORE_OP_STORE; case GFXStoreOp::DISCARD: return VK_ATTACHMENT_STORE_OP_DONT_CARE; - default: - { + default: { CCASSERT(false, "Unsupported GFXStoreOp, convert to VkStoreOp failed."); return VK_ATTACHMENT_STORE_OP_STORE; } - } } +} - VkImageLayout MapVkImageLayout(GFXTextureLayout layout) - { - switch (layout) - { +VkImageLayout MapVkImageLayout(GFXTextureLayout layout) { + switch (layout) { case GFXTextureLayout::UNDEFINED: return VK_IMAGE_LAYOUT_UNDEFINED; case GFXTextureLayout::GENERAL: return VK_IMAGE_LAYOUT_GENERAL; case GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL: return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; @@ -169,18 +164,15 @@ namespace case GFXTextureLayout::TRANSFER_DST_OPTIMAL: return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; case GFXTextureLayout::PREINITIALIZED: return VK_IMAGE_LAYOUT_PREINITIALIZED; case GFXTextureLayout::PRESENT_SRC: return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; - default: - { + default: { CCASSERT(false, "Unsupported GFXTextureLayout, convert to VkImageLayout failed."); return VK_IMAGE_LAYOUT_GENERAL; } - } } +} - VkAccessFlags MapVkAccessFlags(GFXTextureLayout layout) - { - switch (layout) - { +VkAccessFlags MapVkAccessFlags(GFXTextureLayout layout) { + switch (layout) { case GFXTextureLayout::UNDEFINED: return 0; case GFXTextureLayout::GENERAL: return 0; case GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL: return VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; @@ -191,442 +183,395 @@ namespace case GFXTextureLayout::TRANSFER_DST_OPTIMAL: return VK_ACCESS_TRANSFER_WRITE_BIT; case GFXTextureLayout::PREINITIALIZED: return 0; case GFXTextureLayout::PRESENT_SRC: return 0; - default: - { + default: { CCASSERT(false, "Unsupported GFXTextureLayout, convert to VkImageLayout failed."); return 0; } - } } +} - VkAccessFlags MapVkAccessFlags(GFXTextureUsage usage, GFXFormat format) - { - if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; - if (usage & GFXTextureUsage::INPUT_ATTACHMENT) return VK_ACCESS_INPUT_ATTACHMENT_READ_BIT; - if (usage & GFXTextureUsage::SAMPLED) - { - if (GFX_FORMAT_INFOS[(uint)format].hasDepth) return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; - else return VK_ACCESS_SHADER_READ_BIT; - } - if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_ACCESS_TRANSFER_READ_BIT; - if (usage & GFXTextureUsage::TRANSFER_DST) return VK_ACCESS_TRANSFER_WRITE_BIT; - return VK_ACCESS_SHADER_READ_BIT; +VkAccessFlags MapVkAccessFlags(GFXTextureUsage usage, GFXFormat format) { + if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + if (usage & GFXTextureUsage::INPUT_ATTACHMENT) return VK_ACCESS_INPUT_ATTACHMENT_READ_BIT; + if (usage & GFXTextureUsage::SAMPLED) { + if (GFX_FORMAT_INFOS[(uint)format].hasDepth) + return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; + else + return VK_ACCESS_SHADER_READ_BIT; } + if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_ACCESS_TRANSFER_READ_BIT; + if (usage & GFXTextureUsage::TRANSFER_DST) return VK_ACCESS_TRANSFER_WRITE_BIT; + return VK_ACCESS_SHADER_READ_BIT; +} - VkPipelineBindPoint MapVkPipelineBindPoint(GFXPipelineBindPoint bindPoint) - { - switch (bindPoint) - { +VkPipelineBindPoint MapVkPipelineBindPoint(GFXPipelineBindPoint bindPoint) { + switch (bindPoint) { case GFXPipelineBindPoint::GRAPHICS: return VK_PIPELINE_BIND_POINT_GRAPHICS; case GFXPipelineBindPoint::COMPUTE: return VK_PIPELINE_BIND_POINT_COMPUTE; case GFXPipelineBindPoint::RAY_TRACING: return VK_PIPELINE_BIND_POINT_RAY_TRACING_NV; - default: - { + default: { CCASSERT(false, "Unsupported GFXPipelineBindPoint, convert to VkPipelineBindPoint failed."); return VK_PIPELINE_BIND_POINT_GRAPHICS; } - } } +} - VkBufferUsageFlagBits MapVkBufferUsageFlagBits(GFXBufferUsage usage) - { - uint flags = 0u; - if (usage & GFXBufferUsage::TRANSFER_SRC) flags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT; - if (usage & GFXBufferUsage::TRANSFER_DST) flags |= VK_BUFFER_USAGE_TRANSFER_DST_BIT; - if (usage & GFXBufferUsage::INDEX) flags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT; - if (usage & GFXBufferUsage::VERTEX) flags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; - if (usage & GFXBufferUsage::UNIFORM) flags |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; - if (usage & GFXBufferUsage::STORAGE) flags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; - if (usage & GFXBufferUsage::INDIRECT) flags |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; - return (VkBufferUsageFlagBits)flags; - } +VkBufferUsageFlagBits MapVkBufferUsageFlagBits(GFXBufferUsage usage) { + uint flags = 0u; + if (usage & GFXBufferUsage::TRANSFER_SRC) flags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT; + if (usage & GFXBufferUsage::TRANSFER_DST) flags |= VK_BUFFER_USAGE_TRANSFER_DST_BIT; + if (usage & GFXBufferUsage::INDEX) flags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT; + if (usage & GFXBufferUsage::VERTEX) flags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; + if (usage & GFXBufferUsage::UNIFORM) flags |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; + if (usage & GFXBufferUsage::STORAGE) flags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; + if (usage & GFXBufferUsage::INDIRECT) flags |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; + return (VkBufferUsageFlagBits)flags; +} - VkImageType MapVkImageType(GFXTextureType type) - { - switch (type) - { +VkImageType MapVkImageType(GFXTextureType type) { + switch (type) { case GFXTextureType::TEX1D: return VK_IMAGE_TYPE_1D; case GFXTextureType::TEX2D: return VK_IMAGE_TYPE_2D; case GFXTextureType::TEX3D: return VK_IMAGE_TYPE_3D; - default: - { + default: { CCASSERT(false, "Unsupported GFXTextureType, convert to VkImageType failed."); return VK_IMAGE_TYPE_2D; } - } } +} - VkSampleCountFlagBits MapVkSampleCount(GFXSampleCount count) - { - switch (count) - { +VkSampleCountFlagBits MapVkSampleCount(GFXSampleCount count) { + switch (count) { case GFXSampleCount::X1: return VK_SAMPLE_COUNT_1_BIT; case GFXSampleCount::X2: return VK_SAMPLE_COUNT_2_BIT; case GFXSampleCount::X4: return VK_SAMPLE_COUNT_4_BIT; case GFXSampleCount::X8: return VK_SAMPLE_COUNT_8_BIT; case GFXSampleCount::X16: return VK_SAMPLE_COUNT_16_BIT; case GFXSampleCount::X32: return VK_SAMPLE_COUNT_32_BIT; - default: - { + default: { CCASSERT(false, "Unsupported GFXTextureType, convert to VkImageType failed."); return VK_SAMPLE_COUNT_1_BIT; } - } } +} - VkFormatFeatureFlags MapVkFormatFeatureFlags(GFXTextureUsage usage) - { - uint flags = 0u; - if (usage & GFXTextureUsage::TRANSFER_SRC) flags |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT; - if (usage & GFXTextureUsage::TRANSFER_DST) flags |= VK_FORMAT_FEATURE_TRANSFER_DST_BIT; - if (usage & GFXTextureUsage::SAMPLED) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; - if (usage & GFXTextureUsage::STORAGE) flags |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT; - if (usage & GFXTextureUsage::COLOR_ATTACHMENT) flags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; - if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; - if (usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; - if (usage & GFXTextureUsage::INPUT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; - return (VkFormatFeatureFlags)flags; +VkFormatFeatureFlags MapVkFormatFeatureFlags(GFXTextureUsage usage) { + uint flags = 0u; + if (usage & GFXTextureUsage::TRANSFER_SRC) flags |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT; + if (usage & GFXTextureUsage::TRANSFER_DST) flags |= VK_FORMAT_FEATURE_TRANSFER_DST_BIT; + if (usage & GFXTextureUsage::SAMPLED) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; + if (usage & GFXTextureUsage::STORAGE) flags |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT; + if (usage & GFXTextureUsage::COLOR_ATTACHMENT) flags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; + if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; + if (usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; + if (usage & GFXTextureUsage::INPUT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; + return (VkFormatFeatureFlags)flags; +} + +VkImageUsageFlagBits MapVkImageUsageFlagBits(GFXTextureUsage usage) { + uint flags = 0u; + if (usage & GFXTextureUsage::TRANSFER_SRC) flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; + if (usage & GFXTextureUsage::TRANSFER_DST) flags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; + if (usage & GFXTextureUsage::SAMPLED) flags |= VK_IMAGE_USAGE_SAMPLED_BIT; + if (usage & GFXTextureUsage::STORAGE) flags |= VK_IMAGE_USAGE_STORAGE_BIT; + if (usage & GFXTextureUsage::COLOR_ATTACHMENT) flags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; + if (usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; + if (usage & GFXTextureUsage::INPUT_ATTACHMENT) flags |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; + return (VkImageUsageFlagBits)flags; +} + +VkImageLayout MapVkImageLayout(GFXTextureUsage usage, GFXFormat format) { + const GFXFormatInfo &info = GFX_FORMAT_INFOS[(uint)format]; + if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) { + if (info.hasStencil) + return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + else + return VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL; } - - VkImageUsageFlagBits MapVkImageUsageFlagBits(GFXTextureUsage usage) - { - uint flags = 0u; - if (usage & GFXTextureUsage::TRANSFER_SRC) flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; - if (usage & GFXTextureUsage::TRANSFER_DST) flags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT; - if (usage & GFXTextureUsage::SAMPLED) flags |= VK_IMAGE_USAGE_SAMPLED_BIT; - if (usage & GFXTextureUsage::STORAGE) flags |= VK_IMAGE_USAGE_STORAGE_BIT; - if (usage & GFXTextureUsage::COLOR_ATTACHMENT) flags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; - if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; - if (usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; - if (usage & GFXTextureUsage::INPUT_ATTACHMENT) flags |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; - return (VkImageUsageFlagBits)flags; + if (usage & GFXTextureUsage::SAMPLED) { + if (info.hasDepth && info.hasStencil) + return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; + else if (info.hasDepth) + return VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL; + else + return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; } + if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + if (usage & GFXTextureUsage::TRANSFER_DST) return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + return VK_IMAGE_LAYOUT_UNDEFINED; +} - VkImageLayout MapVkImageLayout(GFXTextureUsage usage, GFXFormat format) - { - const GFXFormatInfo &info = GFX_FORMAT_INFOS[(uint)format]; - if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) - { - if (info.hasStencil) return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - else return VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL; - } - if (usage & GFXTextureUsage::SAMPLED) - { - if (info.hasDepth && info.hasStencil) return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; - else if (info.hasDepth) return VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL; - else return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; - } - if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - if (usage & GFXTextureUsage::TRANSFER_DST) return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; - return VK_IMAGE_LAYOUT_UNDEFINED; +VkImageAspectFlags MapVkImageAspectFlags(GFXFormat format) { + VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + const GFXFormatInfo &info = GFX_FORMAT_INFOS[(uint)format]; + if (info.hasDepth) { + aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; } - - VkImageAspectFlags MapVkImageAspectFlags(GFXFormat format) - { - VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - const GFXFormatInfo &info = GFX_FORMAT_INFOS[(uint)format]; - if (info.hasDepth) { aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; } - if (info.hasStencil) { aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT; } - return aspectMask; + if (info.hasStencil) { + aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT; } + return aspectMask; +} - VkPipelineStageFlags MapVkPipelineStageFlags(GFXTextureUsage usage) - { - if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; - if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; - if (usage & GFXTextureUsage::SAMPLED) return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; - if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_PIPELINE_STAGE_TRANSFER_BIT; - if (usage & GFXTextureUsage::TRANSFER_DST) return VK_PIPELINE_STAGE_TRANSFER_BIT; - return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; - } +VkPipelineStageFlags MapVkPipelineStageFlags(GFXTextureUsage usage) { + if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; + if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; + if (usage & GFXTextureUsage::SAMPLED) return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; + if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_PIPELINE_STAGE_TRANSFER_BIT; + if (usage & GFXTextureUsage::TRANSFER_DST) return VK_PIPELINE_STAGE_TRANSFER_BIT; + return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; +} - uint selectMemoryType(const VkPhysicalDeviceMemoryProperties& memoryProperties, uint memoryTypeBits, VkMemoryPropertyFlags flags) - { - for (uint i = 0; i < memoryProperties.memoryTypeCount; ++i) - if ((memoryTypeBits & (1 << i)) != 0 && (memoryProperties.memoryTypes[i].propertyFlags & flags) == flags) - return i; +uint selectMemoryType(const VkPhysicalDeviceMemoryProperties &memoryProperties, uint memoryTypeBits, VkMemoryPropertyFlags flags) { + for (uint i = 0; i < memoryProperties.memoryTypeCount; ++i) + if ((memoryTypeBits & (1 << i)) != 0 && (memoryProperties.memoryTypes[i].propertyFlags & flags) == flags) + return i; - CCASSERT(false, "No compatible memory type found."); - return ~0u; - } + CCASSERT(false, "No compatible memory type found."); + return ~0u; +} - VkImageCreateFlags MapVkImageCreateFlags(GFXTextureViewType type) - { - uint res = 0u; - switch (type) - { +VkImageCreateFlags MapVkImageCreateFlags(GFXTextureViewType type) { + uint res = 0u; + switch (type) { case cocos2d::GFXTextureViewType::CUBE: res |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; break; case cocos2d::GFXTextureViewType::TV2D_ARRAY: res |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT; break; - } - return (VkImageCreateFlags)res; } + return (VkImageCreateFlags)res; +} - VkImageViewType MapVkImageViewType(GFXTextureViewType viewType) - { - switch (viewType) - { +VkImageViewType MapVkImageViewType(GFXTextureViewType viewType) { + switch (viewType) { case GFXTextureViewType::TV1D: return VK_IMAGE_VIEW_TYPE_1D; case GFXTextureViewType::TV1D_ARRAY: return VK_IMAGE_VIEW_TYPE_1D_ARRAY; case GFXTextureViewType::TV2D: return VK_IMAGE_VIEW_TYPE_2D; case GFXTextureViewType::TV2D_ARRAY: return VK_IMAGE_VIEW_TYPE_2D_ARRAY; case GFXTextureViewType::TV3D: return VK_IMAGE_VIEW_TYPE_3D; case GFXTextureViewType::CUBE: return VK_IMAGE_VIEW_TYPE_CUBE; - default: - { + default: { CCASSERT(false, "Unsupported GFXTextureViewType, convert to VkImageViewType failed."); return VK_IMAGE_VIEW_TYPE_2D; } - } } +} - VkCommandBufferLevel MapVkCommandBufferLevel(GFXCommandBufferType type) - { - switch (type) - { +VkCommandBufferLevel MapVkCommandBufferLevel(GFXCommandBufferType type) { + switch (type) { case GFXCommandBufferType::PRIMARY: return VK_COMMAND_BUFFER_LEVEL_PRIMARY; case GFXCommandBufferType::SECONDARY: return VK_COMMAND_BUFFER_LEVEL_SECONDARY; - default: - { + default: { CCASSERT(false, "Unsupported GFXCommandBufferType, convert to VkCommandBufferLevel failed."); return VK_COMMAND_BUFFER_LEVEL_SECONDARY; } - } } +} - VkDescriptorType MapVkDescriptorType(GFXBindingType type) - { - switch (type) - { +VkDescriptorType MapVkDescriptorType(GFXBindingType type) { + switch (type) { case cocos2d::GFXBindingType::UNIFORM_BUFFER: return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; case cocos2d::GFXBindingType::SAMPLER: return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; case cocos2d::GFXBindingType::STORAGE_BUFFER: return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; - default: - { + default: { CCASSERT(false, "Unsupported GFXBindingType, convert to VkDescriptorType failed."); return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; } - } } +} - VkColorComponentFlags MapVkColorComponentFlags(GFXColorMask colorMask) - { - uint flags = 0u; - if (colorMask & GFXColorMask::R) flags |= VK_COLOR_COMPONENT_R_BIT; - if (colorMask & GFXColorMask::G) flags |= VK_COLOR_COMPONENT_G_BIT; - if (colorMask & GFXColorMask::B) flags |= VK_COLOR_COMPONENT_B_BIT; - if (colorMask & GFXColorMask::A) flags |= VK_COLOR_COMPONENT_A_BIT; - if (colorMask & GFXColorMask::ALL) flags |= VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; - return (VkColorComponentFlags)flags; - } +VkColorComponentFlags MapVkColorComponentFlags(GFXColorMask colorMask) { + uint flags = 0u; + if (colorMask & GFXColorMask::R) flags |= VK_COLOR_COMPONENT_R_BIT; + if (colorMask & GFXColorMask::G) flags |= VK_COLOR_COMPONENT_G_BIT; + if (colorMask & GFXColorMask::B) flags |= VK_COLOR_COMPONENT_B_BIT; + if (colorMask & GFXColorMask::A) flags |= VK_COLOR_COMPONENT_A_BIT; + if (colorMask & GFXColorMask::ALL) flags |= VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT; + return (VkColorComponentFlags)flags; +} - VkShaderStageFlagBits MapVkShaderStageFlagBits(GFXShaderType stage) - { - switch (stage) - { +VkShaderStageFlagBits MapVkShaderStageFlagBits(GFXShaderType stage) { + switch (stage) { case GFXShaderType::VERTEX: return VK_SHADER_STAGE_VERTEX_BIT; case GFXShaderType::CONTROL: return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; case GFXShaderType::EVALUATION: return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; case GFXShaderType::GEOMETRY: return VK_SHADER_STAGE_GEOMETRY_BIT; case GFXShaderType::FRAGMENT: return VK_SHADER_STAGE_FRAGMENT_BIT; case GFXShaderType::COMPUTE: return VK_SHADER_STAGE_COMPUTE_BIT; - default: - { + default: { CCASSERT(false, "Unsupported GFXShaderType, convert to VkShaderStageFlagBits failed."); return VK_SHADER_STAGE_VERTEX_BIT; } - } + } +} + +VkShaderStageFlags MapVkShaderStageFlags(GFXShaderType stages) { + uint flags = 0u; + if (stages & GFXShaderType::VERTEX) flags |= VK_SHADER_STAGE_VERTEX_BIT; + if (stages & GFXShaderType::CONTROL) flags |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; + if (stages & GFXShaderType::EVALUATION) flags |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; + if (stages & GFXShaderType::GEOMETRY) flags |= VK_SHADER_STAGE_GEOMETRY_BIT; + if (stages & GFXShaderType::FRAGMENT) flags |= VK_SHADER_STAGE_FRAGMENT_BIT; + if (stages & GFXShaderType::COMPUTE) flags |= VK_SHADER_STAGE_COMPUTE_BIT; + return (VkShaderStageFlags)flags; +} + +const VkPrimitiveTopology VK_PRIMITIVE_MODES[] = { + VK_PRIMITIVE_TOPOLOGY_POINT_LIST, // POINT_LIST + VK_PRIMITIVE_TOPOLOGY_LINE_LIST, // LINE_LIST + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, // LINE_STRIP + (VkPrimitiveTopology)0, // LINE_LOOP + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, // LINE_LIST_ADJACENCY + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, // LINE_STRIP_ADJACENCY + (VkPrimitiveTopology)0, // ISO_LINE_LIST + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // TRIANGLE_LIST + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // TRIANGLE_STRIP + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, // TRIANGLE_FAN + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, // TRIANGLE_LIST_ADJACENCY + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, // TRIANGLE_STRIP_ADJACENCY, + (VkPrimitiveTopology)0, // TRIANGLE_PATCH_ADJACENCY, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, // QUAD_PATCH_LIST, +}; + +const VkCullModeFlags VK_CULL_MODES[] = { + VK_CULL_MODE_NONE, + VK_CULL_MODE_FRONT_BIT, + VK_CULL_MODE_BACK_BIT, +}; + +const VkPolygonMode VK_POLYGON_MODES[] = { + VK_POLYGON_MODE_FILL, + VK_POLYGON_MODE_LINE, + VK_POLYGON_MODE_POINT, +}; + +const VkCompareOp VK_CMP_FUNCS[] = { + VK_COMPARE_OP_NEVER, + VK_COMPARE_OP_LESS, + VK_COMPARE_OP_EQUAL, + VK_COMPARE_OP_LESS_OR_EQUAL, + VK_COMPARE_OP_GREATER, + VK_COMPARE_OP_NOT_EQUAL, + VK_COMPARE_OP_GREATER_OR_EQUAL, + VK_COMPARE_OP_ALWAYS, +}; + +const VkStencilOp VK_STENCIL_OPS[] = { + VK_STENCIL_OP_ZERO, + VK_STENCIL_OP_KEEP, + VK_STENCIL_OP_REPLACE, + VK_STENCIL_OP_INCREMENT_AND_CLAMP, + VK_STENCIL_OP_DECREMENT_AND_CLAMP, + VK_STENCIL_OP_INVERT, + VK_STENCIL_OP_INCREMENT_AND_WRAP, + VK_STENCIL_OP_DECREMENT_AND_WRAP, +}; + +const VkBlendOp VK_BLEND_OPS[] = { + VK_BLEND_OP_ADD, + VK_BLEND_OP_SUBTRACT, + VK_BLEND_OP_REVERSE_SUBTRACT, + VK_BLEND_OP_ADD, + VK_BLEND_OP_ADD, +}; + +const VkBlendFactor VK_BLEND_FACTORS[] = { + VK_BLEND_FACTOR_ZERO, + VK_BLEND_FACTOR_ONE, + VK_BLEND_FACTOR_SRC_ALPHA, + VK_BLEND_FACTOR_DST_ALPHA, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, + VK_BLEND_FACTOR_SRC_COLOR, + VK_BLEND_FACTOR_DST_COLOR, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, + VK_BLEND_FACTOR_CONSTANT_COLOR, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, + VK_BLEND_FACTOR_CONSTANT_ALPHA, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, +}; + +const VkFilter VK_FILTERS[] = { + (VkFilter)0, // NONE + VK_FILTER_NEAREST, // POINT + VK_FILTER_LINEAR, // LINEAR + (VkFilter)0, // ANISOTROPIC +}; + +const VkSamplerMipmapMode VK_SAMPLER_MIPMAP_MODES[] = { + (VkSamplerMipmapMode)0, // NONE + VK_SAMPLER_MIPMAP_MODE_NEAREST, // POINT + VK_SAMPLER_MIPMAP_MODE_LINEAR, // LINEAR + VK_SAMPLER_MIPMAP_MODE_LINEAR, // ANISOTROPIC +}; + +const VkSamplerAddressMode VK_SAMPLER_ADDRESS_MODES[] = { + VK_SAMPLER_ADDRESS_MODE_REPEAT, // WRAP + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, // MIRROR + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // CLAMP + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, // BORDER +}; + +template +char (*countofHelper(T (&_Array)[Size]))[Size]; + +#define COUNTOF(array) (sizeof(*countofHelper(array)) + 0) + +template +uint toUint(T value) { + static_assert(std::is_arithmetic::value, "T must be numeric"); + + if (static_cast(value) > static_cast(std::numeric_limits::max())) { + throw std::runtime_error("to_u32() failed, value is too big to be converted to uint"); } - VkShaderStageFlags MapVkShaderStageFlags(GFXShaderType stages) - { - uint flags = 0u; - if (stages & GFXShaderType::VERTEX) flags |= VK_SHADER_STAGE_VERTEX_BIT; - if (stages & GFXShaderType::CONTROL) flags |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; - if (stages & GFXShaderType::EVALUATION) flags |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; - if (stages & GFXShaderType::GEOMETRY) flags |= VK_SHADER_STAGE_GEOMETRY_BIT; - if (stages & GFXShaderType::FRAGMENT) flags |= VK_SHADER_STAGE_FRAGMENT_BIT; - if (stages & GFXShaderType::COMPUTE) flags |= VK_SHADER_STAGE_COMPUTE_BIT; - return (VkShaderStageFlags)flags; - } + return static_cast(value); +} - const VkPrimitiveTopology VK_PRIMITIVE_MODES[] = - { - VK_PRIMITIVE_TOPOLOGY_POINT_LIST, // POINT_LIST - VK_PRIMITIVE_TOPOLOGY_LINE_LIST, // LINE_LIST - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, // LINE_STRIP - (VkPrimitiveTopology)0, // LINE_LOOP - VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, // LINE_LIST_ADJACENCY - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, // LINE_STRIP_ADJACENCY - (VkPrimitiveTopology)0, // ISO_LINE_LIST - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // TRIANGLE_LIST - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // TRIANGLE_STRIP - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, // TRIANGLE_FAN - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, // TRIANGLE_LIST_ADJACENCY - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, // TRIANGLE_STRIP_ADJACENCY, - (VkPrimitiveTopology)0, // TRIANGLE_PATCH_ADJACENCY, - VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, // QUAD_PATCH_LIST, - }; +uint nextPowerOf2(uint v) { + v--; + v |= v >> 1; + v |= v >> 2; + v |= v >> 4; + v |= v >> 8; + v |= v >> 16; + return ++v; +} - const VkCullModeFlags VK_CULL_MODES[] = - { - VK_CULL_MODE_NONE, - VK_CULL_MODE_FRONT_BIT, - VK_CULL_MODE_BACK_BIT, - }; - - const VkPolygonMode VK_POLYGON_MODES[] = - { - VK_POLYGON_MODE_FILL, - VK_POLYGON_MODE_LINE, - VK_POLYGON_MODE_POINT, - }; - - const VkCompareOp VK_CMP_FUNCS[] = - { - VK_COMPARE_OP_NEVER, - VK_COMPARE_OP_LESS, - VK_COMPARE_OP_EQUAL, - VK_COMPARE_OP_LESS_OR_EQUAL, - VK_COMPARE_OP_GREATER, - VK_COMPARE_OP_NOT_EQUAL, - VK_COMPARE_OP_GREATER_OR_EQUAL, - VK_COMPARE_OP_ALWAYS, - }; - - const VkStencilOp VK_STENCIL_OPS[] = - { - VK_STENCIL_OP_ZERO, - VK_STENCIL_OP_KEEP, - VK_STENCIL_OP_REPLACE, - VK_STENCIL_OP_INCREMENT_AND_CLAMP, - VK_STENCIL_OP_DECREMENT_AND_CLAMP, - VK_STENCIL_OP_INVERT, - VK_STENCIL_OP_INCREMENT_AND_WRAP, - VK_STENCIL_OP_DECREMENT_AND_WRAP, - }; - - const VkBlendOp VK_BLEND_OPS[] = - { - VK_BLEND_OP_ADD, - VK_BLEND_OP_SUBTRACT, - VK_BLEND_OP_REVERSE_SUBTRACT, - VK_BLEND_OP_ADD, - VK_BLEND_OP_ADD, - }; - - const VkBlendFactor VK_BLEND_FACTORS[] = - { - VK_BLEND_FACTOR_ZERO, - VK_BLEND_FACTOR_ONE, - VK_BLEND_FACTOR_SRC_ALPHA, - VK_BLEND_FACTOR_DST_ALPHA, - VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, - VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA, - VK_BLEND_FACTOR_SRC_COLOR, - VK_BLEND_FACTOR_DST_COLOR, - VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR, - VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR, - VK_BLEND_FACTOR_SRC_ALPHA_SATURATE, - VK_BLEND_FACTOR_CONSTANT_COLOR, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR, - VK_BLEND_FACTOR_CONSTANT_ALPHA, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA, - }; - - const VkFilter VK_FILTERS[] = - { - (VkFilter)0, // NONE - VK_FILTER_NEAREST, // POINT - VK_FILTER_LINEAR, // LINEAR - (VkFilter)0, // ANISOTROPIC - }; - - const VkSamplerMipmapMode VK_SAMPLER_MIPMAP_MODES[] = - { - (VkSamplerMipmapMode)0, // NONE - VK_SAMPLER_MIPMAP_MODE_NEAREST, // POINT - VK_SAMPLER_MIPMAP_MODE_LINEAR, // LINEAR - VK_SAMPLER_MIPMAP_MODE_LINEAR, // ANISOTROPIC - }; - - const VkSamplerAddressMode VK_SAMPLER_ADDRESS_MODES[] = - { - VK_SAMPLER_ADDRESS_MODE_REPEAT, // WRAP - VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, // MIRROR - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // CLAMP - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, // BORDER - }; - - template - char(*countof_helper(T(&_Array)[Size]))[Size]; - - #define COUNTOF(array) (sizeof(*countof_helper(array)) + 0) - - template - uint toUint(T value) - { - static_assert(std::is_arithmetic::value, "T must be numeric"); - - if (static_cast(value) > static_cast(std::numeric_limits::max())) - { - throw std::runtime_error("to_u32() failed, value is too big to be converted to uint"); - } - - return static_cast(value); - } - - uint nextPowerOf2(uint v) - { - v--; - v |= v >> 1; - v |= v >> 2; - v |= v >> 4; - v |= v >> 8; - v |= v >> 16; - return ++v; - } - - const char* MapVendorName(uint32_t vendorID) - { - switch (vendorID) - { +const char *MapVendorName(uint32_t vendorID) { + switch (vendorID) { case 0x1002: return "Advanced Micro Devices, Inc."; case 0x1010: return "Imagination Technologies"; case 0x10DE: return "Nvidia Corporation"; case 0x13B5: return "Arm Limited"; case 0x5143: return "Qualcomm Incorporated"; case 0x8086: return "Intel Corporation"; - } - return "Unknown"; - } - - bool isLayerSupported(const char * required, const std::vector &available) - { - for (const VkLayerProperties &availableLayer : available) - { - if (strcmp(availableLayer.layerName, required) == 0) - { - return true; - } - } - return false; - } - - bool isExtensionSupported(const char * required, const std::vector &available) - { - for (const VkExtensionProperties &availableExtension : available) - { - if (strcmp(availableExtension.extensionName, required) == 0) - { - return true; - } - } - return false; } + return "Unknown"; } +bool isLayerSupported(const char *required, const std::vector &available) { + for (const VkLayerProperties &availableLayer : available) { + if (strcmp(availableLayer.layerName, required) == 0) { + return true; + } + } + return false; +} + +bool isExtensionSupported(const char *required, const std::vector &available) { + for (const VkExtensionProperties &availableExtension : available) { + if (strcmp(availableExtension.extensionName, required) == 0) { + return true; + } + } + return false; +} +} // namespace + NS_CC_END #endif // CC_GFXVULKAN_CCVK_UTILS_H_ diff --git a/native/cocos/renderer/gfx-vulkan/VKWindow.cc b/native/cocos/renderer/gfx-vulkan/VKWindow.cc index dfd6edcf49..bf38f2c55e 100644 --- a/native/cocos/renderer/gfx-vulkan/VKWindow.cc +++ b/native/cocos/renderer/gfx-vulkan/VKWindow.cc @@ -1,20 +1,18 @@ #include "VKStd.h" -#include "VKWindow.h" + #include "VKCommands.h" +#include "VKWindow.h" NS_CC_BEGIN -CCVKWindow::CCVKWindow(GFXDevice* device) - : GFXWindow(device) -{ +CCVKWindow::CCVKWindow(GFXDevice *device) +: GFXWindow(device) { } -CCVKWindow::~CCVKWindow() -{ +CCVKWindow::~CCVKWindow() { } -bool CCVKWindow::initialize(const GFXWindowInfo &info) -{ +bool CCVKWindow::initialize(const GFXWindowInfo &info) { _title = info.title; _left = info.left; _top = info.top; @@ -28,35 +26,36 @@ bool CCVKWindow::initialize(const GFXWindowInfo &info) _isFullscreen = info.isFullscreen; // Create render pass + if (info.renderPass) { + _renderPass = info.renderPass; + } else { + GFXRenderPassInfo renderPassInfo; - GFXRenderPassInfo renderPassInfo; + GFXColorAttachment colorAttachment; + colorAttachment.format = _colorFmt; + colorAttachment.loadOp = GFXLoadOp::CLEAR; + colorAttachment.storeOp = GFXStoreOp::STORE; + colorAttachment.sampleCount = 1; + colorAttachment.beginLayout = GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL; + colorAttachment.endLayout = _isOffscreen ? GFXTextureLayout::SHADER_READONLY_OPTIMAL : GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL; + renderPassInfo.colorAttachments.emplace_back(colorAttachment); - GFXColorAttachment colorAttachment; - colorAttachment.format = _colorFmt; - colorAttachment.loadOp = GFXLoadOp::CLEAR; - colorAttachment.storeOp = GFXStoreOp::STORE; - colorAttachment.sampleCount = 1; - colorAttachment.beginLayout = GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL; - colorAttachment.endLayout = GFXTextureLayout::PRESENT_SRC; - renderPassInfo.colorAttachments.emplace_back(colorAttachment); + GFXDepthStencilAttachment &depthStencilAttachment = renderPassInfo.depthStencilAttachment; + depthStencilAttachment.format = _depthStencilFmt; + depthStencilAttachment.depthLoadOp = GFXLoadOp::CLEAR; + depthStencilAttachment.depthStoreOp = GFXStoreOp::STORE; + depthStencilAttachment.stencilLoadOp = GFXLoadOp::CLEAR; + depthStencilAttachment.stencilStoreOp = GFXStoreOp::STORE; + depthStencilAttachment.sampleCount = 1; + depthStencilAttachment.beginLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + depthStencilAttachment.endLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - GFXDepthStencilAttachment& depthStencilAttachment = renderPassInfo.depthStencilAttachment; - depthStencilAttachment.format = _depthStencilFmt; - depthStencilAttachment.depthLoadOp = GFXLoadOp::CLEAR; - depthStencilAttachment.depthStoreOp = GFXStoreOp::STORE; - depthStencilAttachment.stencilLoadOp = GFXLoadOp::CLEAR; - depthStencilAttachment.stencilStoreOp = GFXStoreOp::STORE; - depthStencilAttachment.sampleCount = 1; - depthStencilAttachment.beginLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - depthStencilAttachment.endLayout = GFXTextureLayout::PRESENT_SRC; - - _renderPass = _device->createRenderPass(renderPassInfo); + _renderPass = _device->createRenderPass(renderPassInfo); + } // Create texture & texture views - if (_isOffscreen) - { - if (_colorFmt != GFXFormat::UNKNOWN) - { + if (_isOffscreen) { + if (_colorFmt != GFXFormat::UNKNOWN) { GFXTextureInfo colorTexInfo; colorTexInfo.type = GFXTextureType::TEX2D; colorTexInfo.usage = GFXTextureUsageBit::COLOR_ATTACHMENT | GFXTextureUsageBit::SAMPLED; @@ -78,8 +77,7 @@ bool CCVKWindow::initialize(const GFXWindowInfo &info) colorTexViewInfo.layerCount = 1; _colorTexView = _device->createTextureView(colorTexViewInfo); } - if (_depthStencilFmt != GFXFormat::UNKNOWN) - { + if (_depthStencilFmt != GFXFormat::UNKNOWN) { GFXTextureInfo depthStecnilTexInfo; depthStecnilTexInfo.type = GFXTextureType::TEX2D; depthStecnilTexInfo.usage = GFXTextureUsageBit::DEPTH_STENCIL_ATTACHMENT | GFXTextureUsageBit::SAMPLED; @@ -105,8 +103,7 @@ bool CCVKWindow::initialize(const GFXWindowInfo &info) GFXFramebufferInfo fboInfo; fboInfo.renderPass = _renderPass; - if (_colorTexView) - { + if (_colorTexView) { fboInfo.colorViews.push_back(_colorTexView); } fboInfo.depthStencilView = _depthStencilTexView; @@ -117,8 +114,7 @@ bool CCVKWindow::initialize(const GFXWindowInfo &info) return true; } -void CCVKWindow::destroy() -{ +void CCVKWindow::destroy() { CC_SAFE_DESTROY(_renderPass); CC_SAFE_DESTROY(_colorTexView); CC_SAFE_DESTROY(_colorTex); @@ -129,18 +125,15 @@ void CCVKWindow::destroy() _status = GFXStatus::UNREADY; } -void CCVKWindow::resize(uint width, uint height) -{ +void CCVKWindow::resize(uint width, uint height) { _width = width; _height = height; - if (width > _nativeWidth || height > _nativeHeight) - { + if (width > _nativeWidth || height > _nativeHeight) { _nativeWidth = width; _nativeHeight = height; - if (_colorTex) - { + if (_colorTex) { _colorTex->resize(width, height); _colorTexView->destroy(); @@ -150,8 +143,7 @@ void CCVKWindow::resize(uint width, uint height) _colorTexView->initialize(colorTexViewInfo); } - if (_depthStencilTex) - { + if (_depthStencilTex) { _depthStencilTex->resize(width, height); _depthStencilTexView->destroy(); @@ -161,8 +153,7 @@ void CCVKWindow::resize(uint width, uint height) _depthStencilTexView->initialize(depth_stencil_tex_view__info); } - if (_framebuffer) - { + if (_framebuffer) { _framebuffer->destroy(); GFXFramebufferInfo fboInfo; diff --git a/native/cocos/renderer/gfx-vulkan/VKWindow.h b/native/cocos/renderer/gfx-vulkan/VKWindow.h index 4fae893dec..7dc7576ec9 100644 --- a/native/cocos/renderer/gfx-vulkan/VKWindow.h +++ b/native/cocos/renderer/gfx-vulkan/VKWindow.h @@ -3,14 +3,13 @@ NS_CC_BEGIN -class CC_VULKAN_API CCVKWindow : public GFXWindow -{ +class CC_VULKAN_API CCVKWindow : public GFXWindow { public: - CCVKWindow(GFXDevice* device); + CCVKWindow(GFXDevice *device); ~CCVKWindow(); public: - bool initialize(const GFXWindowInfo& info); + bool initialize(const GFXWindowInfo &info); void destroy(); void resize(uint width, uint height); }; diff --git a/native/cocos/scripting/js-bindings/auto/jsb_gfx_auto.cpp b/native/cocos/scripting/js-bindings/auto/jsb_gfx_auto.cpp index db17b7c699..d284555c31 100644 --- a/native/cocos/scripting/js-bindings/auto/jsb_gfx_auto.cpp +++ b/native/cocos/scripting/js-bindings/auto/jsb_gfx_auto.cpp @@ -2664,6 +2664,34 @@ static bool js_gfx_GFXWindowInfo_set_windowHandle(se::State& s) } SE_BIND_PROP_SET(js_gfx_GFXWindowInfo_set_windowHandle) +static bool js_gfx_GFXWindowInfo_get_renderPass(se::State& s) +{ + cocos2d::GFXWindowInfo* cobj = (cocos2d::GFXWindowInfo*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_GFXWindowInfo_get_renderPass : Invalid Native Object"); + + CC_UNUSED bool ok = true; + se::Value jsret; + ok &= native_ptr_to_seval(cobj->renderPass, &jsret); + s.rval() = jsret; + return true; +} +SE_BIND_PROP_GET(js_gfx_GFXWindowInfo_get_renderPass) + +static bool js_gfx_GFXWindowInfo_set_renderPass(se::State& s) +{ + const auto& args = s.args(); + cocos2d::GFXWindowInfo* cobj = (cocos2d::GFXWindowInfo*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_GFXWindowInfo_set_renderPass : Invalid Native Object"); + + CC_UNUSED bool ok = true; + cocos2d::GFXRenderPass* arg0 = nullptr; + ok &= seval_to_native_ptr(args[0], &arg0); + SE_PRECONDITION2(ok, false, "js_gfx_GFXWindowInfo_set_renderPass : Error processing new value"); + cobj->renderPass = arg0; + return true; +} +SE_BIND_PROP_SET(js_gfx_GFXWindowInfo_set_renderPass) + SE_DECLARE_FINALIZE_FUNC(js_cocos2d_GFXWindowInfo_finalize) static bool js_gfx_GFXWindowInfo_constructor(se::State& s) @@ -2751,6 +2779,12 @@ static bool js_gfx_GFXWindowInfo_constructor(se::State& s) ok &= seval_to_uintptr_t(field, &arg10); cobj->windowHandle = arg10; } + cocos2d::GFXRenderPass* arg11 = nullptr; + json->getProperty("renderPass", &field); + if(!field.isUndefined()) { + ok &= seval_to_native_ptr(field, &arg11); + cobj->renderPass = arg11; + } if(!ok) { JSB_FREE(cobj); @@ -2762,7 +2796,7 @@ static bool js_gfx_GFXWindowInfo_constructor(se::State& s) se::NonRefNativePtrCreatedByCtorMap::emplace(cobj); return true; } - else if(argc == 11) + else if(argc == 12) { cocos2d::GFXWindowInfo* cobj = JSB_ALLOC(cocos2d::GFXWindowInfo); cocos2d::String arg0; @@ -2820,6 +2854,11 @@ static bool js_gfx_GFXWindowInfo_constructor(se::State& s) ok &= seval_to_uintptr_t(args[10], &arg10); cobj->windowHandle = arg10; } + cocos2d::GFXRenderPass* arg11 = nullptr; + if (!args[11].isUndefined()) { + ok &= seval_to_native_ptr(args[11], &arg11); + cobj->renderPass = arg11; + } if(!ok) { JSB_FREE(cobj); @@ -2869,6 +2908,7 @@ bool js_register_gfx_GFXWindowInfo(se::Object* obj) cls->defineProperty("isFullscreen", _SE(js_gfx_GFXWindowInfo_get_isFullscreen), _SE(js_gfx_GFXWindowInfo_set_isFullscreen)); cls->defineProperty("vsyncMode", _SE(js_gfx_GFXWindowInfo_get_vsyncMode), _SE(js_gfx_GFXWindowInfo_set_vsyncMode)); cls->defineProperty("windowHandle", _SE(js_gfx_GFXWindowInfo_get_windowHandle), _SE(js_gfx_GFXWindowInfo_set_windowHandle)); + cls->defineProperty("renderPass", _SE(js_gfx_GFXWindowInfo_get_renderPass), _SE(js_gfx_GFXWindowInfo_set_renderPass)); cls->defineFinalizeFunction(_SE(js_cocos2d_GFXWindowInfo_finalize)); cls->install(); JSBClassType::registerClass(cls); @@ -14337,24 +14377,6 @@ static bool js_gfx_GFXWindow_getDepthStencilFormat(se::State& s) } SE_BIND_FUNC(js_gfx_GFXWindow_getDepthStencilFormat) -static bool js_gfx_GFXWindow_getFramebuffer(se::State& s) -{ - cocos2d::GFXWindow* cobj = (cocos2d::GFXWindow*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_gfx_GFXWindow_getFramebuffer : Invalid Native Object"); - const auto& args = s.args(); - size_t argc = args.size(); - CC_UNUSED bool ok = true; - if (argc == 0) { - cocos2d::GFXFramebuffer* result = cobj->getFramebuffer(); - ok &= native_ptr_to_seval(result, &s.rval()); - SE_PRECONDITION2(ok, false, "js_gfx_GFXWindow_getFramebuffer : Error processing arguments"); - return true; - } - SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); - return false; -} -SE_BIND_PROP_GET(js_gfx_GFXWindow_getFramebuffer) - static bool js_gfx_GFXWindow_getLeft(se::State& s) { cocos2d::GFXWindow* cobj = (cocos2d::GFXWindow*)s.nativeThisObject(); @@ -14499,6 +14521,24 @@ static bool js_gfx_GFXWindow_isOffscreen(se::State& s) } SE_BIND_PROP_GET(js_gfx_GFXWindow_isOffscreen) +static bool js_gfx_GFXWindow_getFramebuffer(se::State& s) +{ + cocos2d::GFXWindow* cobj = (cocos2d::GFXWindow*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_gfx_GFXWindow_getFramebuffer : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 0) { + cocos2d::GFXFramebuffer* result = cobj->getFramebuffer(); + ok &= native_ptr_to_seval(result, &s.rval()); + SE_PRECONDITION2(ok, false, "js_gfx_GFXWindow_getFramebuffer : Error processing arguments"); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; +} +SE_BIND_PROP_GET(js_gfx_GFXWindow_getFramebuffer) + static bool js_gfx_GFXWindow_getTitle(se::State& s) { cocos2d::GFXWindow* cobj = (cocos2d::GFXWindow*)s.nativeThisObject(); @@ -18574,7 +18614,7 @@ bool register_all_gfx(se::Object* obj) js_register_gfx_GFXInputAssembler(ns); js_register_gfx_GFXContextInfo(ns); js_register_gfx_GFXShader(ns); - js_register_gfx_GFXDeviceInfo(ns); + js_register_gfx_GFXShaderStage(ns); js_register_gfx_GFXTextureView(ns); js_register_gfx_GFXPipelineLayout(ns); js_register_gfx_GFXFramebufferInfo(ns); @@ -18583,7 +18623,7 @@ bool register_all_gfx(se::Object* obj) js_register_gfx_GFXRasterizerState(ns); js_register_gfx_GFXTextureInfo(ns); js_register_gfx_GFXQueueInfo(ns); - js_register_gfx_GFXShaderStage(ns); + js_register_gfx_GFXDeviceInfo(ns); js_register_gfx_GFXShaderInfo(ns); js_register_gfx_GFXOffset(ns); js_register_gfx_GFXPushConstantRange(ns);