diff --git a/native/cocos/base/Macros.h b/native/cocos/base/Macros.h index 5bbe8141d8..88fea54b20 100644 --- a/native/cocos/base/Macros.h +++ b/native/cocos/base/Macros.h @@ -320,7 +320,7 @@ It should work same as apples CFSwapInt32LittleToHost(..) #elif CC_PLATFORM == CC_PLATFORM_MAC_OSX && CC_ENDIAN == CC_ENDIAN_BIG #define CC_CPU CC_CPU_PPC #elif CC_PLATFORM == CC_PLATFORM_MAC_OSX - #define COCOS_CPU CC_CPU_X86 + #define CC_CPU CC_CPU_X86 #elif CC_PLATFORM == CC_PLATFORM_MAC_IOS && (defined(__i386__) || defined(__x86_64__)) #define CC_CPU CC_CPU_X86 #elif defined(__arm__) || defined(_M_ARM) || defined(__arm64__) || defined(_aarch64_) diff --git a/native/cocos/renderer/core/gfx/GFXCommandBuffer.h b/native/cocos/renderer/core/gfx/GFXCommandBuffer.h index bcdf491408..6698161c20 100755 --- a/native/cocos/renderer/core/gfx/GFXCommandBuffer.h +++ b/native/cocos/renderer/core/gfx/GFXCommandBuffer.h @@ -65,7 +65,7 @@ public: blitTexture(srcTexture, dstTexture, regions.data(), regions.size(), filter); } CC_INLINE void pipelineBarrier(const GlobalBarrier *barrier) { pipelineBarrier(barrier, nullptr, 0u); } - CC_INLINE void pipelineBarrier(const GlobalBarrier *barrier, const ImageBarrierList &textureBarriers) { pipelineBarrier(barrier, textureBarriers.data(), textureBarriers.size()); } + CC_INLINE void pipelineBarrier(const GlobalBarrier *barrier, const TextureBarrierList &textureBarriers) { pipelineBarrier(barrier, textureBarriers.data(), textureBarriers.size()); } CC_INLINE void bindDescriptorSetForJS(uint set, DescriptorSet *descriptorSet) { bindDescriptorSet(set, descriptorSet, 0, nullptr); diff --git a/native/cocos/renderer/core/gfx/GFXDef.cpp b/native/cocos/renderer/core/gfx/GFXDef.cpp index 1f576e4d91..799e51afc8 100644 --- a/native/cocos/renderer/core/gfx/GFXDef.cpp +++ b/native/cocos/renderer/core/gfx/GFXDef.cpp @@ -10,6 +10,34 @@ const DescriptorType DESCRIPTOR_BUFFER_TYPE = DescriptorType::STORAGE_BUFFER | D const DescriptorType DESCRIPTOR_TEXTURE_TYPE = DescriptorType::SAMPLER_TEXTURE | DescriptorType::SAMPLER | DescriptorType::TEXTURE | DescriptorType::STORAGE_IMAGE | DescriptorType::INPUT_ATTACHMENT; const DescriptorType DESCRIPTOR_DYNAMIC_TYPE = DescriptorType::DYNAMIC_STORAGE_BUFFER | DescriptorType::DYNAMIC_UNIFORM_BUFFER; +const AccessType AccessTypeV::INDIRECT_BUFFER = AccessType::INDIRECT_BUFFER; +const AccessType AccessTypeV::INDEX_BUFFER = AccessType::INDEX_BUFFER; +const AccessType AccessTypeV::VERTEX_BUFFER = AccessType::VERTEX_BUFFER; +const AccessType AccessTypeV::VERTEX_SHADER_READ_UNIFORM_BUFFER = AccessType::VERTEX_SHADER_READ_UNIFORM_BUFFER; +const AccessType AccessTypeV::VERTEX_SHADER_READ_TEXTURE = AccessType::VERTEX_SHADER_READ_TEXTURE; +const AccessType AccessTypeV::VERTEX_SHADER_READ_OTHER = AccessType::VERTEX_SHADER_READ_OTHER; +const AccessType AccessTypeV::FRAGMENT_SHADER_READ_UNIFORM_BUFFER = AccessType::FRAGMENT_SHADER_READ_UNIFORM_BUFFER; +const AccessType AccessTypeV::FRAGMENT_SHADER_READ_TEXTURE = AccessType::FRAGMENT_SHADER_READ_TEXTURE; +const AccessType AccessTypeV::FRAGMENT_SHADER_READ_COLOR_INPUT_ATTACHMENT = AccessType::FRAGMENT_SHADER_READ_COLOR_INPUT_ATTACHMENT; +const AccessType AccessTypeV::FRAGMENT_SHADER_READ_DEPTH_STENCIL_INPUT_ATTACHMENT = AccessType::FRAGMENT_SHADER_READ_DEPTH_STENCIL_INPUT_ATTACHMENT; +const AccessType AccessTypeV::FRAGMENT_SHADER_READ_OTHER = AccessType::FRAGMENT_SHADER_READ_OTHER; +const AccessType AccessTypeV::COLOR_ATTACHMENT_READ = AccessType::COLOR_ATTACHMENT_READ; +const AccessType AccessTypeV::DEPTH_STENCIL_ATTACHMENT_READ = AccessType::DEPTH_STENCIL_ATTACHMENT_READ; +const AccessType AccessTypeV::COMPUTE_SHADER_READ_UNIFORM_BUFFER = AccessType::COMPUTE_SHADER_READ_UNIFORM_BUFFER; +const AccessType AccessTypeV::COMPUTE_SHADER_READ_TEXTURE = AccessType::COMPUTE_SHADER_READ_TEXTURE; +const AccessType AccessTypeV::COMPUTE_SHADER_READ_OTHER = AccessType::COMPUTE_SHADER_READ_OTHER; +const AccessType AccessTypeV::TRANSFER_READ = AccessType::TRANSFER_READ; +const AccessType AccessTypeV::HOST_READ = AccessType::HOST_READ; +const AccessType AccessTypeV::PRESENT = AccessType::PRESENT; +const AccessType AccessTypeV::VERTEX_SHADER_WRITE = AccessType::VERTEX_SHADER_WRITE; +const AccessType AccessTypeV::FRAGMENT_SHADER_WRITE = AccessType::FRAGMENT_SHADER_WRITE; +const AccessType AccessTypeV::COLOR_ATTACHMENT_WRITE = AccessType::COLOR_ATTACHMENT_WRITE; +const AccessType AccessTypeV::DEPTH_STENCIL_ATTACHMENT_WRITE = AccessType::DEPTH_STENCIL_ATTACHMENT_WRITE; +const AccessType AccessTypeV::COMPUTE_SHADER_WRITE = AccessType::COMPUTE_SHADER_WRITE; +const AccessType AccessTypeV::TRANSFER_WRITE = AccessType::TRANSFER_WRITE; +const AccessType AccessTypeV::HOST_PREINITIALIZED = AccessType::HOST_PREINITIALIZED; +const AccessType AccessTypeV::HOST_WRITE = AccessType::HOST_WRITE; + const FormatInfo GFX_FORMAT_INFOS[] = { {"UNKNOWN", 0, 0, FormatType::NONE, false, false, false, false}, {"A8", 1, 1, FormatType::UNORM, true, false, false, false}, diff --git a/native/cocos/renderer/core/gfx/GFXDef.h b/native/cocos/renderer/core/gfx/GFXDef.h index 65515e148e..ef81f44467 100644 --- a/native/cocos/renderer/core/gfx/GFXDef.h +++ b/native/cocos/renderer/core/gfx/GFXDef.h @@ -329,12 +329,6 @@ bool isCombinedImageSampler(Type type); bool isSampledImage(Type type); bool isStorageImage(Type type); -enum class UniformMemoryAccessType { - READ_ONLY, - WRITE_ONLY, - READ_WRITE, -}; - enum class BufferUsageBit : FlagBits { NONE = 0, TRANSFER_SRC = 0x1, @@ -355,13 +349,13 @@ enum class BufferFlagBit : FlagBits { typedef BufferFlagBit BufferFlags; CC_ENUM_OPERATORS(BufferFlagBit); -enum class BufferAccessBit : FlagBits { +enum class MemoryAccessBit : FlagBits { NONE = 0, - READ = 0x1, - WRITE = 0x2, + READ_ONLY = 0x1, + WRITE_ONLY = 0x2, + READ_WRITE = READ_ONLY | WRITE_ONLY, }; -typedef BufferAccessBit BufferAccess; -CC_ENUM_OPERATORS(BufferAccessBit); +typedef MemoryAccessBit MemoryAccess; enum class MemoryUsageBit : FlagBits { NONE = 0, @@ -397,9 +391,8 @@ CC_ENUM_OPERATORS(TextureUsageBit); enum class TextureFlagBit : FlagBits { NONE = 0, GEN_MIPMAP = 0x1, - CUBEMAP = 0x2, - BAKUP_BUFFER = 0x4, - IMMUTABLE = 0x8, + BAKUP_BUFFER = 0x2, + IMMUTABLE = 0x4, }; typedef TextureFlagBit TextureFlags; CC_ENUM_OPERATORS(TextureFlagBit); @@ -510,20 +503,9 @@ enum class StoreOp { DISCARD, // Don't write the source to the destination }; -enum class TextureLayout { - UNDEFINED, - GENERAL, - COLOR_ATTACHMENT_OPTIMAL, - DEPTH_STENCIL_ATTACHMENT_OPTIMAL, - DEPTH_STENCIL_READONLY_OPTIMAL, - SHADER_READONLY_OPTIMAL, - TRANSFER_SRC_OPTIMAL, - TRANSFER_DST_OPTIMAL, - PREINITIALIZED, - PRESENT_SRC, -}; - enum class AccessType { + NONE, + // Read access INDIRECT_BUFFER, // Read as an indirect buffer for drawing or dispatch INDEX_BUFFER, // Read as an index buffer for drawing @@ -556,13 +538,37 @@ enum class AccessType { HOST_WRITE, // Written on the host }; -typedef cc::vector AccessTypeList; +namespace AccessTypeV { +extern const AccessType INDIRECT_BUFFER; +extern const AccessType INDEX_BUFFER; +extern const AccessType VERTEX_BUFFER; +extern const AccessType VERTEX_SHADER_READ_UNIFORM_BUFFER; +extern const AccessType VERTEX_SHADER_READ_TEXTURE; +extern const AccessType VERTEX_SHADER_READ_OTHER; +extern const AccessType FRAGMENT_SHADER_READ_UNIFORM_BUFFER; +extern const AccessType FRAGMENT_SHADER_READ_TEXTURE; +extern const AccessType FRAGMENT_SHADER_READ_COLOR_INPUT_ATTACHMENT; +extern const AccessType FRAGMENT_SHADER_READ_DEPTH_STENCIL_INPUT_ATTACHMENT; +extern const AccessType FRAGMENT_SHADER_READ_OTHER; +extern const AccessType COLOR_ATTACHMENT_READ; +extern const AccessType DEPTH_STENCIL_ATTACHMENT_READ; +extern const AccessType COMPUTE_SHADER_READ_UNIFORM_BUFFER; +extern const AccessType COMPUTE_SHADER_READ_TEXTURE; +extern const AccessType COMPUTE_SHADER_READ_OTHER; +extern const AccessType TRANSFER_READ; +extern const AccessType HOST_READ; +extern const AccessType PRESENT; +extern const AccessType VERTEX_SHADER_WRITE; +extern const AccessType FRAGMENT_SHADER_WRITE; +extern const AccessType COLOR_ATTACHMENT_WRITE; +extern const AccessType DEPTH_STENCIL_ATTACHMENT_WRITE; +extern const AccessType COMPUTE_SHADER_WRITE; +extern const AccessType TRANSFER_WRITE; +extern const AccessType HOST_PREINITIALIZED; +extern const AccessType HOST_WRITE; +} // namespace AccessTypeV -// for texture barriers the exact layout can be inferred from access types -enum class TextureBarrierLayout { - OPTIMAL, - GENERAL, -}; +typedef cc::vector AccessTypeList; enum class PipelineBindPoint { GRAPHICS, @@ -815,7 +821,6 @@ struct Viewport { } }; -#pragma pack(push, 1) struct Color { float x = 0.0f; float y = 0.0f; @@ -829,7 +834,6 @@ struct Color { math::IsEqualF(w, rhs.w)); } }; -#pragma pack(pop) typedef cc::vector ColorList; /** @@ -894,7 +898,6 @@ struct BufferViewInfo { uint range = 0u; }; -#pragma pack(push, 1) struct DrawInfo { uint vertexCount = 0; uint firstVertex = 0; @@ -904,11 +907,9 @@ struct DrawInfo { uint instanceCount = 0; uint firstInstance = 0; }; -#pragma pack(pop) typedef cc::vector DrawInfoList; -#pragma pack(push, 1) struct DispatchInfo { uint groupCountX = 0; uint groupCountY = 0; @@ -917,7 +918,6 @@ struct DispatchInfo { Buffer *indirectBuffer = nullptr; uint indirectOffset = 0; }; -#pragma pack(pop) typedef cc::vector DispatchInfoList; @@ -1023,7 +1023,7 @@ struct UniformStorageImage { String name; Type type = Type::UNKNOWN; uint count = 0u; - UniformMemoryAccessType memoryAccess = UniformMemoryAccessType::READ_WRITE; + MemoryAccess memoryAccess = MemoryAccess::READ_WRITE; }; typedef cc::vector UniformStorageImageList; @@ -1033,7 +1033,7 @@ struct UniformStorageBuffer { uint binding = 0u; String name; uint count = 0u; - UniformMemoryAccessType memoryAccess = UniformMemoryAccessType::READ_WRITE; + MemoryAccess memoryAccess = MemoryAccess::READ_WRITE; }; typedef cc::vector UniformStorageBufferList; @@ -1048,7 +1048,7 @@ struct UniformInputAttachment { typedef cc::vector UniformInputAttachmentList; struct ShaderStage { - ShaderStageFlagBit stage; + ShaderStageFlagBit stage = ShaderStageFlagBit::NONE; String source; }; @@ -1089,24 +1089,24 @@ struct InputAssemblerInfo { struct ColorAttachment { Format format = Format::UNKNOWN; - uint sampleCount = 1; + SampleCount sampleCount = SampleCount::X1; LoadOp loadOp = LoadOp::CLEAR; StoreOp storeOp = StoreOp::STORE; - TextureLayout beginLayout = TextureLayout::UNDEFINED; - TextureLayout endLayout = TextureLayout::PRESENT_SRC; + AccessType beginAccess = AccessType::NONE; + AccessType endAccess = AccessType::PRESENT; }; typedef cc::vector ColorAttachmentList; struct DepthStencilAttachment { Format format = Format::UNKNOWN; - uint sampleCount = 1; + SampleCount sampleCount = SampleCount::X1; LoadOp depthLoadOp = LoadOp::CLEAR; StoreOp depthStoreOp = StoreOp::STORE; LoadOp stencilLoadOp = LoadOp::CLEAR; StoreOp stencilStoreOp = StoreOp::STORE; - TextureLayout beginLayout = TextureLayout::UNDEFINED; - TextureLayout endLayout = TextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL; + AccessType beginAccess = AccessType::NONE; + AccessType endAccess = AccessType::DEPTH_STENCIL_ATTACHMENT_WRITE; }; struct SubPassInfo { @@ -1127,28 +1127,39 @@ struct RenderPassInfo { }; struct GlobalBarrier { - AccessType *prevAccesses = nullptr; + AccessType const *prevAccesses = nullptr; uint prevAccessCount = 0u; - AccessType *nextAccesses = nullptr; + AccessType const *nextAccesses = nullptr; uint nextAccessCount = 0u; }; typedef cc::vector GlobalBarrierList; struct TextureBarrier { - AccessType *prevAccesses; - uint prevAccessCount; - AccessType *nextAccesses; - uint nextAccessCount; + AccessType const *prevAccesses = nullptr; + uint prevAccessCount = 0u; + AccessType const *nextAccesses = nullptr; + uint nextAccessCount = 0u; - TextureBarrierLayout prevLayout = TextureBarrierLayout::OPTIMAL; - TextureBarrierLayout nextLayout = TextureBarrierLayout::OPTIMAL; bool discardContents = false; Texture *texture = nullptr; Queue *srcQueue = nullptr; Queue *dstQueue = nullptr; }; -typedef cc::vector ImageBarrierList; +typedef cc::vector TextureBarrierList; + +struct BufferBarrier { + AccessType const *prevAccesses = nullptr; + uint prevAccessCount = 0u; + AccessType const *nextAccesses = nullptr; + uint nextAccessCount = 0u; + + Buffer *buffer = nullptr; + + Queue *srcQueue = nullptr; + Queue *dstQueue = nullptr; +}; +typedef cc::vector BufferBarrierList; typedef cc::vector BufferList; typedef cc::vector TextureList; @@ -1166,7 +1177,7 @@ struct DescriptorSetLayoutBinding { uint binding = GFX_INVALID_BINDING; DescriptorType descriptorType = DescriptorType::UNKNOWN; uint count = 0; - ShaderStageFlagBit stageFlags = ShaderStageFlagBit::NONE; + ShaderStageFlags stageFlags = ShaderStageFlagBit::NONE; SamplerList immutableSamplers; }; typedef cc::vector DescriptorSetLayoutBindingList; @@ -1287,21 +1298,21 @@ struct FormatInfo { bool isCompressed = false; }; -extern CC_DLL const DescriptorType DESCRIPTOR_BUFFER_TYPE; -extern CC_DLL const DescriptorType DESCRIPTOR_TEXTURE_TYPE; -extern CC_DLL const DescriptorType DESCRIPTOR_DYNAMIC_TYPE; +extern const DescriptorType DESCRIPTOR_BUFFER_TYPE; +extern const DescriptorType DESCRIPTOR_TEXTURE_TYPE; +extern const DescriptorType DESCRIPTOR_DYNAMIC_TYPE; -extern CC_DLL const FormatInfo GFX_FORMAT_INFOS[]; -extern CC_DLL const uint GFX_TYPE_SIZES[]; +extern const FormatInfo GFX_FORMAT_INFOS[]; +extern const uint GFX_TYPE_SIZES[]; struct MemoryStatus { uint bufferSize = 0; uint textureSize = 0; }; -extern CC_DLL uint FormatSize(Format format, uint width, uint height, uint depth); +extern uint FormatSize(Format format, uint width, uint height, uint depth); -extern CC_DLL uint FormatSurfaceSize(Format format, uint width, uint height, uint depth, uint mips); +extern uint FormatSurfaceSize(Format format, uint width, uint height, uint depth, uint mips); } // namespace gfx } // namespace cc diff --git a/native/cocos/renderer/core/gfx/GFXRenderPass.cpp b/native/cocos/renderer/core/gfx/GFXRenderPass.cpp index e89bee3f5e..50426e5bfd 100755 --- a/native/cocos/renderer/core/gfx/GFXRenderPass.cpp +++ b/native/cocos/renderer/core/gfx/GFXRenderPass.cpp @@ -22,27 +22,27 @@ uint RenderPass::computeHash() const { if (iaIndex >= _colorAttachments.size()) break; const auto ia = _colorAttachments[iaIndex]; seed ^= (uint)(ia.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= ia.sampleCount + 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= (uint)ia.sampleCount + 0x9e3779b9 + (seed << 6) + (seed >> 2); } for (const auto &caIndex : subPass.colors) { if (caIndex >= _colorAttachments.size()) break; const auto ca = _colorAttachments[caIndex]; seed ^= (uint)(ca.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= ca.sampleCount + 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= (uint)ca.sampleCount + 0x9e3779b9 + (seed << 6) + (seed >> 2); } if (subPass.depthStencil < _colorAttachments.size()) { const auto ds = _colorAttachments[subPass.depthStencil]; seed ^= (uint)(ds.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= ds.sampleCount + 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= (uint)ds.sampleCount + 0x9e3779b9 + (seed << 6) + (seed >> 2); } } } else { for (const auto &colorAttachment : _colorAttachments) { seed ^= (uint)(colorAttachment.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= colorAttachment.sampleCount + 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= (uint)colorAttachment.sampleCount + 0x9e3779b9 + (seed << 6) + (seed >> 2); } seed ^= (uint)(_depthStencilAttachment.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= _depthStencilAttachment.sampleCount + 0x9e3779b9 + (seed << 6) + (seed >> 2); + seed ^= (uint)_depthStencilAttachment.sampleCount + 0x9e3779b9 + (seed << 6) + (seed >> 2); } return static_cast(seed); diff --git a/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.cpp b/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.cpp index 1cc2049c8c..2cc0e5fe53 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.cpp +++ b/native/cocos/renderer/gfx-gles3/GLES3CommandBuffer.cpp @@ -463,7 +463,7 @@ void GLES3CommandBuffer::pipelineBarrier(const GlobalBarrier *barrier, const Tex if (!barrier) return; GLES3CmdBarrier *cmd = _cmdAllocator->barrierCmdPool.alloc(); - MapGLBarriers(barrier->nextAccesses, barrier->nextAccessCount, cmd->barriers, cmd->barriersByRegion); + MapGLBarriers(barrier, cmd->barriers, cmd->barriersByRegion); _curCmdPackage->barrierCmds.push(cmd); _curCmdPackage->cmds.push(GLES3CmdType::BARRIER); } else { diff --git a/native/cocos/renderer/gfx-gles3/GLES3Commands.cpp b/native/cocos/renderer/gfx-gles3/GLES3Commands.cpp index fe9511f0bc..507c043c20 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Commands.cpp +++ b/native/cocos/renderer/gfx-gles3/GLES3Commands.cpp @@ -613,9 +613,25 @@ const GLenum GL_MEMORY_ACCESS[] = { }; } // namespace -void MapGLBarriers(const AccessType *list, uint count, GLbitfield &glBarriers, GLbitfield &glBarriersByRegion) { - for (size_t j = 0u; j < count; ++j) { - switch (list[j]) { +void MapGLBarriers(const GlobalBarrier *barrier, GLbitfield &glBarriers, GLbitfield &glBarriersByRegion) { + bool hasShaderWrites = false; + for (size_t i = 0u; i < barrier->prevAccessCount; ++i) { + switch (barrier->prevAccesses[i]) { + case AccessType::COMPUTE_SHADER_WRITE: + case AccessType::VERTEX_SHADER_WRITE: + case AccessType::FRAGMENT_SHADER_WRITE: + case AccessType::COLOR_ATTACHMENT_WRITE: + case AccessType::DEPTH_STENCIL_ATTACHMENT_WRITE: + hasShaderWrites = true; + break; + default: + break; + } + } + if (!hasShaderWrites) return; + + for (size_t i = 0u; i < barrier->nextAccessCount; ++i) { + switch (barrier->nextAccesses[i]) { case AccessType::INDIRECT_BUFFER: glBarriers |= GL_COMMAND_BARRIER_BIT; break; @@ -633,6 +649,8 @@ void MapGLBarriers(const AccessType *list, uint count, GLbitfield &glBarriers, G case AccessType::COMPUTE_SHADER_READ_TEXTURE: case AccessType::VERTEX_SHADER_READ_TEXTURE: case AccessType::FRAGMENT_SHADER_READ_TEXTURE: + case AccessType::FRAGMENT_SHADER_READ_COLOR_INPUT_ATTACHMENT: + case AccessType::FRAGMENT_SHADER_READ_DEPTH_STENCIL_INPUT_ATTACHMENT: glBarriersByRegion |= GL_SHADER_IMAGE_ACCESS_BARRIER_BIT; glBarriersByRegion |= GL_TEXTURE_FETCH_BARRIER_BIT; break; @@ -642,27 +660,26 @@ void MapGLBarriers(const AccessType *list, uint count, GLbitfield &glBarriers, G glBarriersByRegion |= GL_SHADER_STORAGE_BARRIER_BIT; break; case AccessType::COLOR_ATTACHMENT_READ: - case AccessType::COLOR_ATTACHMENT_WRITE: case AccessType::DEPTH_STENCIL_ATTACHMENT_READ: - case AccessType::DEPTH_STENCIL_ATTACHMENT_WRITE: glBarriersByRegion |= GL_FRAMEBUFFER_BARRIER_BIT; break; case AccessType::TRANSFER_READ: glBarriers |= GL_PIXEL_BUFFER_BARRIER_BIT; break; - case AccessType::FRAGMENT_SHADER_WRITE: - glBarriersByRegion |= GL_FRAMEBUFFER_BARRIER_BIT; - break; case AccessType::COMPUTE_SHADER_WRITE: + case AccessType::VERTEX_SHADER_WRITE: + case AccessType::FRAGMENT_SHADER_WRITE: + glBarriersByRegion |= GL_SHADER_IMAGE_ACCESS_BARRIER_BIT; glBarriersByRegion |= GL_SHADER_STORAGE_BARRIER_BIT; break; + case AccessType::COLOR_ATTACHMENT_WRITE: + case AccessType::DEPTH_STENCIL_ATTACHMENT_WRITE: + glBarriersByRegion |= GL_FRAMEBUFFER_BARRIER_BIT; + break; case AccessType::TRANSFER_WRITE: glBarriers |= GL_TEXTURE_UPDATE_BARRIER_BIT; glBarriers |= GL_BUFFER_UPDATE_BARRIER_BIT; break; - case AccessType::VERTEX_SHADER_WRITE: - case AccessType::FRAGMENT_SHADER_READ_COLOR_INPUT_ATTACHMENT: - case AccessType::FRAGMENT_SHADER_READ_DEPTH_STENCIL_INPUT_ATTACHMENT: case AccessType::HOST_PREINITIALIZED: case AccessType::HOST_WRITE: case AccessType::PRESENT: diff --git a/native/cocos/renderer/gfx-gles3/GLES3Commands.h b/native/cocos/renderer/gfx-gles3/GLES3Commands.h index b4918daad4..20c6fe9b68 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3Commands.h +++ b/native/cocos/renderer/gfx-gles3/GLES3Commands.h @@ -295,7 +295,7 @@ public: } }; -CC_GLES3_API void MapGLBarriers(const AccessType *barrier, uint count, GLbitfield &glBarriers, GLbitfield &glBarriersByRegion); +CC_GLES3_API void MapGLBarriers(const GlobalBarrier *barrier, GLbitfield &glBarriers, GLbitfield &glBarriersByRegion); CC_GLES3_API void GLES3CmdFuncCreateBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer); CC_GLES3_API void GLES3CmdFuncDestroyBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer); CC_GLES3_API void GLES3CmdFuncResizeBuffer(GLES3Device *device, GLES3GPUBuffer *gpuBuffer); diff --git a/native/cocos/renderer/gfx-gles3/GLES3PrimaryCommandBuffer.cpp b/native/cocos/renderer/gfx-gles3/GLES3PrimaryCommandBuffer.cpp index 2f8ee63b3d..77c652f30f 100644 --- a/native/cocos/renderer/gfx-gles3/GLES3PrimaryCommandBuffer.cpp +++ b/native/cocos/renderer/gfx-gles3/GLES3PrimaryCommandBuffer.cpp @@ -215,7 +215,7 @@ void GLES3PrimaryCommandBuffer::pipelineBarrier(const GlobalBarrier *barrier, co GLbitfield glBarriers = 0u; GLbitfield glBarriersByRegion = 0u; - MapGLBarriers(barrier->nextAccesses, barrier->nextAccessCount, glBarriers, glBarriersByRegion); + MapGLBarriers(barrier, glBarriers, glBarriersByRegion); GLES3CmdFuncMemoryBarrier((GLES3Device *)_device, glBarriers, glBarriersByRegion); } else { CC_LOG_ERROR("Command 'pipelineBarrier' must be recorded outside a render pass."); diff --git a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cpp b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cpp index cad0eac3df..c97aea7782 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cpp +++ b/native/cocos/renderer/gfx-vulkan/VKCommandBuffer.cpp @@ -73,7 +73,7 @@ void CCVKCommandBuffer::destroy() { void CCVKCommandBuffer::begin(RenderPass *renderPass, uint subpass, Framebuffer *frameBuffer) { if (_gpuCommandBuffer->began) return; - ((CCVKDevice *)_device)->gpuDevice()->getCommandBufferPool(std::this_thread::get_id())->request(_gpuCommandBuffer); + ((CCVKDevice *)_device)->gpuDevice()->getCommandBufferPool()->request(_gpuCommandBuffer); _curGPUPipelineState = nullptr; _curGPUInputAssember = nullptr; @@ -122,7 +122,7 @@ void CCVKCommandBuffer::end() { _gpuCommandBuffer->began = false; _pendingQueue.push(_gpuCommandBuffer->vkCommandBuffer); - ((CCVKDevice *)_device)->gpuDevice()->getCommandBufferPool(std::this_thread::get_id())->yield(_gpuCommandBuffer); + ((CCVKDevice *)_device)->gpuDevice()->getCommandBufferPool()->yield(_gpuCommandBuffer); } void CCVKCommandBuffer::beginRenderPass(RenderPass *renderPass, Framebuffer *fbo, const Rect &renderArea, const Color *colors, float depth, int stencil, CommandBuffer *const *secondaryCBs, uint32_t secondaryCBCount) { @@ -164,6 +164,15 @@ void CCVKCommandBuffer::beginRenderPass(RenderPass *renderPass, Framebuffer *fbo VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, 0, 1, &barrier, 0, nullptr, 0, nullptr); } + + // guard against RAW hazard + //ThsvsAccessType prevType = THSVS_ACCESS_TRANSFER_WRITE; + //ThsvsGlobalBarrier barrier{}; + //barrier.prevAccessCount = 1; + //barrier.pPrevAccesses = &prevType; + //barrier.nextAccessCount = gpuBuffer->accessTypes.size(); + //barrier.pNextAccesses = gpuBuffer->accessTypes.data(); + //thsvsCmdPipelineBarrier(_gpuCommandBuffer->vkCommandBuffer, &barrier, 0, nullptr, 0, nullptr); #endif VkRenderPassBeginInfo passBeginInfo{VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO}; @@ -191,20 +200,20 @@ void CCVKCommandBuffer::endRenderPass() { #endif for (size_t i = 0u; i < _curGPUFBO->gpuRenderPass->colorAttachments.size(); ++i) { - VkImageLayout layout = VK_IMAGE_LAYOUTS[(uint)_curGPUFBO->gpuRenderPass->colorAttachments[i].endLayout]; + ThsvsAccessType accessType = THSVS_ACCESS_TYPES[(uint)_curGPUFBO->gpuRenderPass->colorAttachments[i].endAccess]; if (_curGPUFBO->gpuColorViews[i]) { - _curGPUFBO->gpuColorViews[i]->gpuTexture->currentLayout = layout; + _curGPUFBO->gpuColorViews[i]->gpuTexture->currentAccessTypes.assign({accessType}); } else { - _curGPUFBO->swapchain->swapchainImageLayouts[_curGPUFBO->swapchain->curImageIndex] = layout; + _curGPUFBO->swapchain->swapchainImageAccessTypes[_curGPUFBO->swapchain->curImageIndex].assign({accessType}); } } if (_curGPUFBO->gpuRenderPass->depthStencilAttachment.format != Format::UNKNOWN) { - VkImageLayout layout = VK_IMAGE_LAYOUTS[(uint)_curGPUFBO->gpuRenderPass->depthStencilAttachment.endLayout]; + ThsvsAccessType accessType = THSVS_ACCESS_TYPES[(uint)_curGPUFBO->gpuRenderPass->depthStencilAttachment.endAccess]; if (_curGPUFBO->gpuDepthStencilView) { - _curGPUFBO->gpuDepthStencilView->gpuTexture->currentLayout = layout; + _curGPUFBO->gpuDepthStencilView->gpuTexture->currentAccessTypes.assign({accessType}); } else { - _curGPUFBO->swapchain->depthStencilImageLayouts[_curGPUFBO->swapchain->curImageIndex] = layout; + _curGPUFBO->swapchain->depthStencilImageAccessTypes[_curGPUFBO->swapchain->curImageIndex].assign({accessType}); } } @@ -374,7 +383,6 @@ void CCVKCommandBuffer::draw(InputAssembler *ia) { sizeof(VkDrawIndirectCommand)); } } else { - // If multi draw is not available, we must issue separate draw commands if (gpuIndirectBuffer->isDrawIndirectByIndex) { for (VkDeviceSize j = 0u; j < drawInfoCount; j++) { vkCmdDrawIndexedIndirect(_gpuCommandBuffer->vkCommandBuffer, @@ -467,28 +475,31 @@ void CCVKCommandBuffer::blitTexture(Texture *srcTexture, Texture *dstTexture, co CCVKGPUTexture *gpuTextureSrc = ((CCVKTexture *)srcTexture)->gpuTexture(); srcAspectMask = gpuTextureSrc->aspectMask; srcImage = gpuTextureSrc->vkImage; - srcImageLayout = gpuTextureSrc->currentLayout; + srcImageLayout = (gpuTextureSrc->layoutRule == THSVS_IMAGE_LAYOUT_OPTIMAL ? VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL); } else { srcAspectMask = VK_IMAGE_ASPECT_COLOR_BIT; srcImage = swapchain->swapchainImages[swapchain->curImageIndex]; srcImageLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; #if BARRIER_DEDUCTION_LEVEL >= BARRIER_DEDUCTION_LEVEL_FULL - if (swapchain->swapchainImageLayouts[swapchain->curImageIndex] != srcImageLayout) { - VkImageMemoryBarrier barrier{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER}; - barrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; - barrier.oldLayout = swapchain->swapchainImageLayouts[swapchain->curImageIndex]; - barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + vector &curAccessTypes = swapchain->swapchainImageAccessTypes[swapchain->curImageIndex]; + if (std::find(curAccessTypes.begin(), curAccessTypes.end(), THSVS_ACCESS_TRANSFER_READ) == curAccessTypes.end()) { + ThsvsImageBarrier barrier{}; + barrier.prevAccessCount = curAccessTypes.size(); + barrier.pPrevAccesses = curAccessTypes.data(); + barrier.nextAccessCount = 1; + barrier.pNextAccesses = &THSVS_ACCESS_TYPES[(uint)AccessType::TRANSFER_READ]; + barrier.prevLayout = THSVS_IMAGE_LAYOUT_OPTIMAL; + barrier.nextLayout = THSVS_IMAGE_LAYOUT_OPTIMAL; barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.image = srcImage; barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; - vkCmdPipelineBarrier(_gpuCommandBuffer->vkCommandBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier); + thsvsCmdPipelineBarrier(_gpuCommandBuffer->vkCommandBuffer, nullptr, 0, nullptr, 1, &barrier); - swapchain->swapchainImageLayouts[swapchain->curImageIndex] = srcImageLayout; + curAccessTypes.assign({THSVS_ACCESS_TRANSFER_READ}); } #endif } @@ -497,28 +508,31 @@ void CCVKCommandBuffer::blitTexture(Texture *srcTexture, Texture *dstTexture, co CCVKGPUTexture *gpuTextureDst = ((CCVKTexture *)dstTexture)->gpuTexture(); dstAspectMask = gpuTextureDst->aspectMask; dstImage = gpuTextureDst->vkImage; - dstImageLayout = gpuTextureDst->currentLayout; + dstImageLayout = (gpuTextureDst->layoutRule == THSVS_IMAGE_LAYOUT_OPTIMAL ? VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL : VK_IMAGE_LAYOUT_GENERAL); } else { dstAspectMask = VK_IMAGE_ASPECT_COLOR_BIT; dstImage = swapchain->swapchainImages[swapchain->curImageIndex]; dstImageLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; #if BARRIER_DEDUCTION_LEVEL >= BARRIER_DEDUCTION_LEVEL_FULL - if (swapchain->swapchainImageLayouts[swapchain->curImageIndex] != dstImageLayout) { - VkImageMemoryBarrier barrier{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER}; - barrier.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - barrier.oldLayout = swapchain->swapchainImageLayouts[swapchain->curImageIndex]; - barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + vector &curAccessTypes = swapchain->swapchainImageAccessTypes[swapchain->curImageIndex]; + if (std::find(curAccessTypes.begin(), curAccessTypes.end(), THSVS_ACCESS_TRANSFER_WRITE) == curAccessTypes.end()) { + ThsvsImageBarrier barrier{}; + barrier.prevAccessCount = curAccessTypes.size(); + barrier.pPrevAccesses = curAccessTypes.data(); + barrier.nextAccessCount = 1; + barrier.pNextAccesses = &THSVS_ACCESS_TYPES[(uint)AccessType::TRANSFER_WRITE]; + barrier.prevLayout = THSVS_IMAGE_LAYOUT_OPTIMAL; + barrier.nextLayout = THSVS_IMAGE_LAYOUT_OPTIMAL; barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; barrier.image = dstImage; barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; - vkCmdPipelineBarrier(_gpuCommandBuffer->vkCommandBuffer, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier); + thsvsCmdPipelineBarrier(_gpuCommandBuffer->vkCommandBuffer, nullptr, 0, nullptr, 1, &barrier); - swapchain->swapchainImageLayouts[swapchain->curImageIndex] = dstImageLayout; + curAccessTypes.assign({THSVS_ACCESS_TRANSFER_WRITE}); } #endif } @@ -568,34 +582,6 @@ void CCVKCommandBuffer::bindDescriptorSets(VkPipelineBindPoint bindPoint) { if (_curGPUDescriptorSets[i]) { const CCVKGPUDescriptorSet::Instance &instance = _curGPUDescriptorSets[i]->instances[gpuDevice->curBackBufferIndex]; _curVkDescriptorSets[i] = instance.vkDescriptorSet; - -#if BARRIER_DEDUCTION_LEVEL >= BARRIER_DEDUCTION_LEVEL_FULL - const CCVKGPUDescriptorList &descriptors = _curGPUDescriptorSets[i]->gpuDescriptors; - for (size_t j = 0u; j < descriptors.size(); ++j) { - if (descriptors[j].type & DESCRIPTOR_TEXTURE_TYPE) { - VkImageLayout ¤tLayout = descriptors[j].gpuTextureView->gpuTexture->currentLayout; - VkImageLayout expectedLayout = instance.descriptorInfos[j].image.imageLayout; - if (currentLayout != expectedLayout) { - - VkImageMemoryBarrier barrier{VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER}; - barrier.srcAccessMask = 0; - barrier.dstAccessMask = descriptors[j].gpuTextureView->gpuTexture->accessMask; - barrier.oldLayout = currentLayout; - barrier.newLayout = expectedLayout; - barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barrier.image = descriptors[j].gpuTextureView->gpuTexture->vkImage; - barrier.subresourceRange.aspectMask = descriptors[j].gpuTextureView->gpuTexture->aspectMask; - barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; - barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; - vkCmdPipelineBarrier(_gpuCommandBuffer->vkCommandBuffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, - descriptors[j].gpuTextureView->gpuTexture->targetStage, 0, 0, nullptr, 0, nullptr, 1, &barrier); - - currentLayout = expectedLayout; - } - } - } -#endif } else { _curVkDescriptorSets[i] = pipelineLayout->setLayouts[i]->defaultDescriptorSet; } @@ -649,7 +635,7 @@ void CCVKCommandBuffer::pipelineBarrier(const GlobalBarrier *barrier, const Text uint index = 0u; if (barrier) { - ThsvsGlobalBarrier globalBarrier; + ThsvsGlobalBarrier globalBarrier{}; globalBarrier.prevAccessCount = barrier->prevAccessCount; globalBarrier.pPrevAccesses = _accessTypes.data() + index; for (uint i = 0u; i < barrier->prevAccessCount; ++i, ++index) { @@ -677,7 +663,7 @@ void CCVKCommandBuffer::pipelineBarrier(const GlobalBarrier *barrier, const Text VkPipelineStageFlags tempDstStageMask = 0; for (uint b = 0u; b < textureBarrierCount; ++b) { const TextureBarrier &textureBarrier = textureBarriers[b]; - ThsvsImageBarrier imageBarrier; + ThsvsImageBarrier imageBarrier{}; imageBarrier.prevAccessCount = textureBarrier.prevAccessCount; imageBarrier.pPrevAccesses = _accessTypes.data() + index; @@ -691,18 +677,20 @@ void CCVKCommandBuffer::pipelineBarrier(const GlobalBarrier *barrier, const Text _accessTypes[index] = THSVS_ACCESS_TYPES[(uint)textureBarrier.nextAccesses[i]]; } - imageBarrier.prevLayout = THSVS_IMAGE_LAYOUTS[(uint)textureBarrier.prevLayout]; - imageBarrier.nextLayout = THSVS_IMAGE_LAYOUTS[(uint)textureBarrier.nextLayout]; imageBarrier.discardContents = textureBarrier.discardContents; + CCVKGPUTexture *gpuTexture = nullptr; + CCVKGPUSwapchain *swapchain = nullptr; if (textureBarrier.texture) { - CCVKGPUTexture *gpuTexture = ((CCVKTexture *)textureBarrier.texture)->gpuTexture(); + gpuTexture = ((CCVKTexture *)textureBarrier.texture)->gpuTexture(); imageBarrier.image = gpuTexture->vkImage; imageBarrier.subresourceRange.aspectMask = gpuTexture->aspectMask; + imageBarrier.prevLayout = imageBarrier.nextLayout = gpuTexture->layoutRule; } else { - const CCVKGPUSwapchain *swapchain = ((CCVKDevice *)_device)->gpuSwapchain(); + swapchain = ((CCVKDevice *)_device)->gpuSwapchain(); imageBarrier.image = swapchain->swapchainImages[swapchain->curImageIndex]; imageBarrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + imageBarrier.prevLayout = imageBarrier.nextLayout = THSVS_IMAGE_LAYOUT_OPTIMAL; } imageBarrier.subresourceRange.baseMipLevel = 0u; @@ -721,7 +709,11 @@ void CCVKCommandBuffer::pipelineBarrier(const GlobalBarrier *barrier, const Text srcStageMask |= tempSrcStageMask; dstStageMask |= tempDstStageMask; - if (textureBarrier.texture) ((CCVKTexture *)textureBarrier.texture)->gpuTexture()->currentLayout = _imageMemoryBarriers[b].newLayout; + if (gpuTexture) { + gpuTexture->currentAccessTypes.assign(imageBarrier.pNextAccesses, imageBarrier.pNextAccesses + imageBarrier.nextAccessCount); + } else { + swapchain->swapchainImageAccessTypes[swapchain->curImageIndex].assign(imageBarrier.pNextAccesses, imageBarrier.pNextAccesses + imageBarrier.nextAccessCount); + } } } diff --git a/native/cocos/renderer/gfx-vulkan/VKCommands.cpp b/native/cocos/renderer/gfx-vulkan/VKCommands.cpp index 50a238c81a..081513226d 100644 --- a/native/cocos/renderer/gfx-vulkan/VKCommands.cpp +++ b/native/cocos/renderer/gfx-vulkan/VKCommands.cpp @@ -37,7 +37,8 @@ THE SOFTWARE. namespace cc { namespace gfx { -CCVKGPUCommandBufferPool *CCVKGPUDevice::getCommandBufferPool(std::thread::id threadID) { +CCVKGPUCommandBufferPool *CCVKGPUDevice::getCommandBufferPool() { + std::thread::id threadID = std::this_thread::get_id(); if (!commandBufferPools.count(threadID)) { //std::scoped_lock guard(mutex); commandBufferPools[threadID] = CC_NEW(CCVKGPUCommandBufferPool(this)); @@ -130,10 +131,8 @@ void CCVKCmdFuncCreateTexture(CCVKDevice *device, CCVKGPUTexture *gpuTexture) { VK_CHECK(vmaCreateImage(device->gpuDevice()->memoryAllocator, &createInfo, &allocInfo, &gpuTexture->vkImage, &gpuTexture->vmaAllocation, &res)); //CC_LOG_DEBUG("Allocated texture: %llu %llx %llx %llu %x", res.size, gpuTexture->vkImage, res.deviceMemory, res.offset, res.pMappedData); - gpuTexture->layout = MapVkImageLayout(gpuTexture->usage, gpuTexture->format); - gpuTexture->accessMask = MapVkAccessFlags(gpuTexture->usage); gpuTexture->aspectMask = MapVkImageAspectFlags(gpuTexture->format); - gpuTexture->targetStage = MapVkPipelineStageFlags(gpuTexture->usage); + gpuTexture->layoutRule = gpuTexture->usage & TextureUsage::STORAGE ? THSVS_IMAGE_LAYOUT_GENERAL : THSVS_IMAGE_LAYOUT_OPTIMAL; // as per vulkan spec } void CCVKCmdFuncCreateTextureView(CCVKDevice *device, CCVKGPUTextureView *gpuTextureView) { @@ -215,9 +214,6 @@ void CCVKCmdFuncCreateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer) { gpuBuffer->mappedData = (uint8_t *)res.pMappedData; gpuBuffer->startOffset = 0; // we are creating one VkBuffer each for now - - gpuBuffer->accessMask = MapVkAccessFlags(gpuBuffer->usage); - gpuBuffer->targetStage = MapVkPipelineStageFlags(gpuBuffer->usage); } void CCVKCmdFuncCreateRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRenderPass) { @@ -225,37 +221,42 @@ void CCVKCmdFuncCreateRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRende const size_t hasDepth = gpuRenderPass->depthStencilAttachment.format != Format::UNKNOWN ? 1 : 0; vector attachmentDescriptions(colorAttachmentCount + hasDepth); gpuRenderPass->clearValues.resize(colorAttachmentCount + hasDepth); + + ThsvsImageBarrier barrier{1, nullptr, 1, nullptr, THSVS_IMAGE_LAYOUT_OPTIMAL, THSVS_IMAGE_LAYOUT_OPTIMAL, false}; + VkPipelineStageFlags srcStages = 0; + VkPipelineStageFlags dstStages = 0; + VkImageMemoryBarrier vkBarrier; for (size_t i = 0u; i < colorAttachmentCount; i++) { const ColorAttachment &attachment = gpuRenderPass->colorAttachments[i]; - const VkImageLayout beginLayout = VK_IMAGE_LAYOUTS[(uint)attachment.beginLayout]; - const VkImageLayout endLayout = VK_IMAGE_LAYOUTS[(uint)attachment.endLayout]; - const VkAccessFlags beginAccessMask = MapVkAccessFlags(attachment.beginLayout); - const VkAccessFlags endAccessMask = MapVkAccessFlags(attachment.endLayout); + barrier.pPrevAccesses = &THSVS_ACCESS_TYPES[(uint)attachment.beginAccess]; + barrier.pNextAccesses = &THSVS_ACCESS_TYPES[(uint)attachment.endAccess]; + if (attachment.loadOp != LoadOp::LOAD) barrier.discardContents = true; + thsvsGetVulkanImageMemoryBarrier(barrier, &srcStages, &dstStages, &vkBarrier); + attachmentDescriptions[i].format = MapVkFormat(attachment.format); attachmentDescriptions[i].samples = MapVkSampleCount(attachment.sampleCount); attachmentDescriptions[i].loadOp = MapVkLoadOp(attachment.loadOp); attachmentDescriptions[i].storeOp = MapVkStoreOp(attachment.storeOp); attachmentDescriptions[i].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; attachmentDescriptions[i].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; - attachmentDescriptions[i].initialLayout = beginLayout; - attachmentDescriptions[i].finalLayout = endLayout; + attachmentDescriptions[i].initialLayout = vkBarrier.oldLayout; + attachmentDescriptions[i].finalLayout = vkBarrier.newLayout; } if (hasDepth) { const DepthStencilAttachment &depthStencilAttachment = gpuRenderPass->depthStencilAttachment; - const VkImageLayout beginLayout = VK_IMAGE_LAYOUTS[(uint)depthStencilAttachment.beginLayout]; - const VkImageLayout endLayout = VK_IMAGE_LAYOUTS[(uint)depthStencilAttachment.endLayout]; - const VkAccessFlags beginAccessMask = MapVkAccessFlags(depthStencilAttachment.beginLayout); - const VkAccessFlags endAccessMask = MapVkAccessFlags(depthStencilAttachment.endLayout); - const bool hasStencil = GFX_FORMAT_INFOS[(uint)depthStencilAttachment.format].hasStencil; - const VkImageAspectFlags aspectMask = hasStencil ? VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_DEPTH_BIT; + barrier.pPrevAccesses = &THSVS_ACCESS_TYPES[(uint)depthStencilAttachment.beginAccess]; + barrier.pNextAccesses = &THSVS_ACCESS_TYPES[(uint)depthStencilAttachment.endAccess]; + if (depthStencilAttachment.depthLoadOp != LoadOp::LOAD && depthStencilAttachment.stencilLoadOp != LoadOp::LOAD) barrier.discardContents = true; + thsvsGetVulkanImageMemoryBarrier(barrier, &srcStages, &dstStages, &vkBarrier); + attachmentDescriptions[colorAttachmentCount].format = MapVkFormat(depthStencilAttachment.format); attachmentDescriptions[colorAttachmentCount].samples = MapVkSampleCount(depthStencilAttachment.sampleCount); attachmentDescriptions[colorAttachmentCount].loadOp = MapVkLoadOp(depthStencilAttachment.depthLoadOp); attachmentDescriptions[colorAttachmentCount].storeOp = MapVkStoreOp(depthStencilAttachment.depthStoreOp); attachmentDescriptions[colorAttachmentCount].stencilLoadOp = MapVkLoadOp(depthStencilAttachment.stencilLoadOp); attachmentDescriptions[colorAttachmentCount].stencilStoreOp = MapVkStoreOp(depthStencilAttachment.stencilStoreOp); - attachmentDescriptions[colorAttachmentCount].initialLayout = beginLayout; - attachmentDescriptions[colorAttachmentCount].finalLayout = endLayout; + attachmentDescriptions[colorAttachmentCount].initialLayout = vkBarrier.oldLayout; + attachmentDescriptions[colorAttachmentCount].finalLayout = vkBarrier.newLayout; } const size_t subpassCount = gpuRenderPass->subPasses.size(); @@ -705,19 +706,6 @@ void CCVKCmdFuncUpdateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer, const VkBufferCopy region{stagingBuffer.startOffset, gpuBuffer->startOffset, sizeToUpload}; auto upload = [&stagingBuffer, &gpuBuffer, ®ion](const CCVKGPUCommandBuffer *cmdBuffer) { vkCmdCopyBuffer(cmdBuffer->vkCommandBuffer, stagingBuffer.vkBuffer, gpuBuffer->vkBuffer, 1, ®ion); - -#if BARRIER_DEDUCTION_LEVEL >= BARRIER_DEDUCTION_LEVEL_BASIC - // guard against RAW hazard - VkBufferMemoryBarrier barrier{VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER}; - barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - barrier.dstAccessMask = gpuBuffer->accessMask; - barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barrier.buffer = gpuBuffer->vkBuffer; - barrier.offset = region.dstOffset; - barrier.size = region.size; - vkCmdPipelineBarrier(cmdBuffer->vkCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, gpuBuffer->targetStage, 0, 0, nullptr, 1, &barrier, 0, nullptr); -#endif }; if (cmdBuffer) { @@ -729,22 +717,23 @@ void CCVKCmdFuncUpdateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer, const void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, const uint8_t *const *buffers, CCVKGPUTexture *gpuTexture, const BufferTextureCopy *regions, uint count, const CCVKGPUCommandBuffer *cmdBuff) { - VkImageMemoryBarrier barriers[2]{}; - barriers[0].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; - barriers[0].image = gpuTexture->vkImage; - barriers[0].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barriers[0].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barriers[0].subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; - barriers[0].subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; - barriers[0].subresourceRange.aspectMask = gpuTexture->aspectMask; - barriers[0].srcAccessMask = gpuTexture->accessMask; - barriers[0].dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - barriers[0].oldLayout = gpuTexture->currentLayout; - barriers[0].newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; + vector &curTypes = gpuTexture->currentAccessTypes; - if (gpuTexture->currentLayout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) { - vkCmdPipelineBarrier(cmdBuff->vkCommandBuffer, gpuTexture->targetStage, VK_PIPELINE_STAGE_TRANSFER_BIT, - VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, 1, barriers); + ThsvsImageBarrier barrier{}; + barrier.image = gpuTexture->vkImage; + barrier.discardContents = false; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; + barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; + barrier.subresourceRange.aspectMask = gpuTexture->aspectMask; + barrier.prevAccessCount = curTypes.size(); + barrier.pPrevAccesses = curTypes.data(); + barrier.nextAccessCount = 1; + barrier.pNextAccesses = &THSVS_ACCESS_TYPES[(uint)AccessType::TRANSFER_WRITE]; + + if (std::find(curTypes.begin(), curTypes.end(), THSVS_ACCESS_TRANSFER_WRITE) == curTypes.end()) { + thsvsCmdPipelineBarrier(cmdBuff->vkCommandBuffer, nullptr, 0, nullptr, 1, &barrier); } uint totalSize = 0u; @@ -780,7 +769,6 @@ void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, const uint8_t *const *b vkCmdCopyBufferToImage(cmdBuff->vkCommandBuffer, stagingBuffer.vkBuffer, gpuTexture->vkImage, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, stagingRegions.size(), stagingRegions.data()); - bool layoutReady = false; if (gpuTexture->flags & TextureFlags::GEN_MIPMAP) { VkFormatProperties formatProperties; vkGetPhysicalDeviceFormatProperties(device->gpuContext()->physicalDevice, MapVkFormat(gpuTexture->format), &formatProperties); @@ -797,16 +785,14 @@ void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, const uint8_t *const *b blitInfo.dstSubresource.layerCount = gpuTexture->arrayLayers; blitInfo.srcOffsets[1] = {width, height, 1}; blitInfo.dstOffsets[1] = {std::max(width >> 1, 1), std::max(height >> 1, 1), 1}; - barriers[0].subresourceRange.levelCount = 1; - barriers[0].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - barriers[0].dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; - barriers[0].oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; - barriers[0].newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; + barrier.subresourceRange.levelCount = 1; + barrier.prevAccessCount = 1; + barrier.pPrevAccesses = &THSVS_ACCESS_TYPES[(uint)AccessType::TRANSFER_WRITE]; + barrier.pNextAccesses = &THSVS_ACCESS_TYPES[(uint)AccessType::TRANSFER_READ]; for (uint i = 1u; i < gpuTexture->mipLevels; i++) { - barriers[0].subresourceRange.baseMipLevel = i - 1; - vkCmdPipelineBarrier(cmdBuff->vkCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, - VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, 1, barriers); + barrier.subresourceRange.baseMipLevel = i - 1; + thsvsCmdPipelineBarrier(cmdBuff->vkCommandBuffer, nullptr, 0, nullptr, 1, &barrier); blitInfo.srcSubresource.mipLevel = i - 1; blitInfo.dstSubresource.mipLevel = i; @@ -819,42 +805,20 @@ void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, const uint8_t *const *b blitInfo.dstOffsets[1].y = std::max(h >> 1, 1); } - barriers[0].subresourceRange.baseMipLevel = gpuTexture->mipLevels - 1; - barriers[0].dstAccessMask = gpuTexture->accessMask; - barriers[0].newLayout = gpuTexture->layout; + barrier.subresourceRange.baseMipLevel = 0; + barrier.subresourceRange.levelCount = gpuTexture->mipLevels - 1; + barrier.pPrevAccesses = &THSVS_ACCESS_TYPES[(uint)AccessType::TRANSFER_READ]; + barrier.pNextAccesses = &THSVS_ACCESS_TYPES[(uint)AccessType::TRANSFER_WRITE]; - barriers[1].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; - barriers[1].image = gpuTexture->vkImage; - barriers[1].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barriers[1].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; - barriers[1].subresourceRange.aspectMask = gpuTexture->aspectMask; - barriers[1].subresourceRange.baseMipLevel = 0; - barriers[1].subresourceRange.levelCount = gpuTexture->mipLevels - 1; - barriers[1].subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; - barriers[1].srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT; - barriers[1].dstAccessMask = gpuTexture->accessMask; - barriers[1].oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - barriers[1].newLayout = gpuTexture->layout; - - vkCmdPipelineBarrier(cmdBuff->vkCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, gpuTexture->targetStage, - VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, 2, barriers); - layoutReady = true; + thsvsCmdPipelineBarrier(cmdBuff->vkCommandBuffer, nullptr, 0, nullptr, 1, &barrier); } else { const char *formatName = GFX_FORMAT_INFOS[(uint)gpuTexture->format].name.c_str(); CC_LOG_WARNING("CCVKCmdFuncCopyBuffersToTexture: generate mipmap for %s is not supported on this platform", formatName); } } - if (!layoutReady && gpuTexture->layout != VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) { - barriers[0].srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; - barriers[0].dstAccessMask = gpuTexture->accessMask; - barriers[0].oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; - barriers[0].newLayout = gpuTexture->layout; - vkCmdPipelineBarrier(cmdBuff->vkCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, gpuTexture->targetStage, - VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, 1, barriers); - } - - gpuTexture->currentLayout = gpuTexture->layout; + curTypes.assign({THSVS_ACCESS_TRANSFER_WRITE}); + device->gpuTextureLayoutManager()->checkIn(gpuTexture); } void CCVKCmdFuncDestroyRenderPass(CCVKGPUDevice *gpuDevice, CCVKGPURenderPass *gpuRenderPass) { diff --git a/native/cocos/renderer/gfx-vulkan/VKDescriptorSet.cpp b/native/cocos/renderer/gfx-vulkan/VKDescriptorSet.cpp index e5ccc1f027..c1d1bf69ac 100644 --- a/native/cocos/renderer/gfx-vulkan/VKDescriptorSet.cpp +++ b/native/cocos/renderer/gfx-vulkan/VKDescriptorSet.cpp @@ -27,8 +27,8 @@ THE SOFTWARE. #include "VKCommands.h" #include "VKDescriptorSet.h" #include "VKDescriptorSetLayout.h" -#include "VKPipelineLayout.h" #include "VKDevice.h" +#include "VKPipelineLayout.h" #include "VKSampler.h" #include "VKShader.h" #include "VKTexture.h" @@ -60,8 +60,37 @@ bool CCVKDescriptorSet::initialize(const DescriptorSetInfo &info) { for (size_t i = 0u, k = 0u; i < bindingCount; ++i) { const DescriptorSetLayoutBinding &binding = gpuDescriptorSetLayout->bindings[i]; + CCVKGPUDescriptor &gpuDescriptor = _gpuDescriptorSet->gpuDescriptors[k]; for (uint j = 0; j < binding.count; ++j, ++k) { - _gpuDescriptorSet->gpuDescriptors[k].type = binding.descriptorType; + gpuDescriptor.type = binding.descriptorType; + switch (binding.descriptorType) { + case DescriptorType::UNIFORM_BUFFER: + case DescriptorType::DYNAMIC_UNIFORM_BUFFER: + if (binding.stageFlags & ShaderStageFlags::COMPUTE) gpuDescriptor.accessTypes.push_back(THSVS_ACCESS_COMPUTE_SHADER_READ_UNIFORM_BUFFER); + if (binding.stageFlags & ShaderStageFlags::VERTEX) gpuDescriptor.accessTypes.push_back(THSVS_ACCESS_VERTEX_SHADER_READ_UNIFORM_BUFFER); + if (binding.stageFlags & ShaderStageFlags::FRAGMENT) gpuDescriptor.accessTypes.push_back(THSVS_ACCESS_FRAGMENT_SHADER_READ_UNIFORM_BUFFER); + break; + case DescriptorType::STORAGE_BUFFER: + case DescriptorType::DYNAMIC_STORAGE_BUFFER: + case DescriptorType::STORAGE_IMAGE: + // here we don't handle write accesses, which should be handled manually + if (binding.stageFlags & ShaderStageFlags::COMPUTE) gpuDescriptor.accessTypes.push_back(THSVS_ACCESS_COMPUTE_SHADER_READ_OTHER); + if (binding.stageFlags & ShaderStageFlags::VERTEX) gpuDescriptor.accessTypes.push_back(THSVS_ACCESS_VERTEX_SHADER_READ_OTHER); + if (binding.stageFlags & ShaderStageFlags::FRAGMENT) gpuDescriptor.accessTypes.push_back(THSVS_ACCESS_FRAGMENT_SHADER_READ_OTHER); + break; + case DescriptorType::SAMPLER_TEXTURE: + case DescriptorType::TEXTURE: + if (binding.stageFlags & ShaderStageFlags::COMPUTE) gpuDescriptor.accessTypes.push_back(THSVS_ACCESS_COMPUTE_SHADER_READ_SAMPLED_IMAGE_OR_UNIFORM_TEXEL_BUFFER); + if (binding.stageFlags & ShaderStageFlags::VERTEX) gpuDescriptor.accessTypes.push_back(THSVS_ACCESS_VERTEX_SHADER_READ_SAMPLED_IMAGE_OR_UNIFORM_TEXEL_BUFFER); + if (binding.stageFlags & ShaderStageFlags::FRAGMENT) gpuDescriptor.accessTypes.push_back(THSVS_ACCESS_FRAGMENT_SHADER_READ_SAMPLED_IMAGE_OR_UNIFORM_TEXEL_BUFFER); + break; + case DescriptorType::INPUT_ATTACHMENT: + gpuDescriptor.accessTypes.push_back(THSVS_ACCESS_FRAGMENT_SHADER_READ_COLOR_INPUT_ATTACHMENT); + break; + case DescriptorType::SAMPLER: + default: + break; + } } } @@ -172,6 +201,7 @@ void CCVKDescriptorSet::destroy() { void CCVKDescriptorSet::update() { if (_isDirty && _gpuDescriptorSet) { CCVKGPUDescriptorHub *descriptorHub = ((CCVKDevice *)_device)->gpuDescriptorHub(); + CCVKGPUTextureLayoutManager *layoutMgr = ((CCVKDevice *)_device)->gpuTextureLayoutManager(); uint descriptorCount = _gpuDescriptorSet->gpuDescriptors.size(); for (size_t i = 0u; i < descriptorCount; i++) { @@ -207,6 +237,7 @@ void CCVKDescriptorSet::update() { if (textureView) { descriptorHub->connect(textureView, &descriptorInfo.image); descriptorHub->update(textureView, &descriptorInfo.image); + layoutMgr->checkIn(textureView->gpuTexture, binding.accessTypes.data(), binding.accessTypes.size()); } } binding.gpuTextureView = textureView; diff --git a/native/cocos/renderer/gfx-vulkan/VKDescriptorSet.h b/native/cocos/renderer/gfx-vulkan/VKDescriptorSet.h index 9b6de4d99e..86ce4eb345 100644 --- a/native/cocos/renderer/gfx-vulkan/VKDescriptorSet.h +++ b/native/cocos/renderer/gfx-vulkan/VKDescriptorSet.h @@ -34,7 +34,6 @@ public: CCVKDescriptorSet(Device *device); ~CCVKDescriptorSet(); -public: virtual bool initialize(const DescriptorSetInfo &info) override; virtual void destroy() override; virtual void update() override; diff --git a/native/cocos/renderer/gfx-vulkan/VKDevice.cpp b/native/cocos/renderer/gfx-vulkan/VKDevice.cpp index d8f814fd72..ab423d5e23 100644 --- a/native/cocos/renderer/gfx-vulkan/VKDevice.cpp +++ b/native/cocos/renderer/gfx-vulkan/VKDevice.cpp @@ -309,11 +309,11 @@ bool CCVKDevice::initialize(const DeviceInfo &info) { } _gpuBufferHub = CC_NEW(CCVKGPUBufferHub(_gpuDevice)); - _gpuTransportHub = CC_NEW(CCVKGPUTransportHub(_gpuDevice)); - _gpuTransportHub->link(((CCVKQueue *)_queue)->gpuQueue()); + _gpuTransportHub = CC_NEW(CCVKGPUTransportHub(_gpuDevice, ((CCVKQueue *)_queue)->gpuQueue())); _gpuDescriptorHub = CC_NEW(CCVKGPUDescriptorHub(_gpuDevice)); _gpuSemaphorePool = CC_NEW(CCVKGPUSemaphorePool(_gpuDevice)); _gpuDescriptorSetHub = CC_NEW(CCVKGPUDescriptorSetHub(_gpuDevice)); + _gpuTextureLayoutManager = CC_NEW(CCVKGPUTextureLayoutManager(_gpuDevice)); CommandBufferInfo cmdBuffInfo; cmdBuffInfo.type = CommandBufferType::PRIMARY; @@ -411,6 +411,7 @@ void CCVKDevice::destroy() { CC_SAFE_DELETE(_gpuSemaphorePool); CC_SAFE_DELETE(_gpuDescriptorHub); CC_SAFE_DELETE(_gpuDescriptorSetHub); + CC_SAFE_DELETE(_gpuTextureLayoutManager); uint backBufferCount = ((CCVKContext *)_context)->gpuContext()->swapchainCreateInfo.minImageCount; for (uint i = 0u; i < backBufferCount; i++) { @@ -718,8 +719,8 @@ bool CCVKDevice::checkSwapchainStatus() { }, true); // submit immediately - _gpuSwapchain->swapchainImageLayouts.assign(imageCount, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR); - _gpuSwapchain->depthStencilImageLayouts.assign(imageCount, hasStencil ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL); + _gpuSwapchain->swapchainImageAccessTypes.assign(imageCount, {THSVS_ACCESS_PRESENT}); + _gpuSwapchain->depthStencilImageAccessTypes.assign(imageCount, {THSVS_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ}); for (FramebufferListMapIter it = _gpuSwapchain->vkSwapchainFramebufferListMap.begin(); it != _gpuSwapchain->vkSwapchainFramebufferListMap.end(); it++) { @@ -731,8 +732,8 @@ bool CCVKDevice::checkSwapchainStatus() { void CCVKDevice::destroySwapchain() { if (_gpuSwapchain->vkSwapchain != VK_NULL_HANDLE) { - _gpuSwapchain->swapchainImageLayouts.clear(); - _gpuSwapchain->depthStencilImageLayouts.clear(); + _gpuSwapchain->swapchainImageAccessTypes.clear(); + _gpuSwapchain->depthStencilImageAccessTypes.clear(); _gpuSwapchain->depthStencilImageViews.clear(); _gpuSwapchain->depthStencilImages.clear(); diff --git a/native/cocos/renderer/gfx-vulkan/VKDevice.h b/native/cocos/renderer/gfx-vulkan/VKDevice.h index 997d32acf1..b7a06565fd 100644 --- a/native/cocos/renderer/gfx-vulkan/VKDevice.h +++ b/native/cocos/renderer/gfx-vulkan/VKDevice.h @@ -38,6 +38,7 @@ class CCVKGPUTransportHub; class CCVKGPUDescriptorHub; class CCVKGPUSemaphorePool; class CCVKGPUDescriptorSetHub; +class CCVKGPUTextureLayoutManager; class CCVKGPUFencePool; class CCVKGPURecycleBin; @@ -86,6 +87,7 @@ public: CC_INLINE CCVKGPUDescriptorHub *gpuDescriptorHub() { return _gpuDescriptorHub; } CC_INLINE CCVKGPUSemaphorePool *gpuSemaphorePool() { return _gpuSemaphorePool; } CC_INLINE CCVKGPUDescriptorSetHub *gpuDescriptorSetHub() { return _gpuDescriptorSetHub; } + CC_INLINE CCVKGPUTextureLayoutManager *gpuTextureLayoutManager() { return _gpuTextureLayoutManager; } CCVKGPUFencePool *gpuFencePool(); CCVKGPURecycleBin *gpuRecycleBin(); @@ -124,6 +126,7 @@ private: CCVKGPUDescriptorHub *_gpuDescriptorHub = nullptr; CCVKGPUSemaphorePool *_gpuSemaphorePool = nullptr; CCVKGPUDescriptorSetHub *_gpuDescriptorSetHub = nullptr; + CCVKGPUTextureLayoutManager *_gpuTextureLayoutManager = nullptr; vector _layers; vector _extensions; diff --git a/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h b/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h index 02b4ebdc0f..4cbd233b6d 100644 --- a/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h +++ b/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h @@ -58,7 +58,10 @@ public: ColorAttachmentList colorAttachments; DepthStencilAttachment depthStencilAttachment; SubPassInfoList subPasses; + VkRenderPass vkRenderPass; + + // helper storage vector clearValues; }; @@ -75,15 +78,15 @@ public: uint mipLevels = 1u; SampleCount samples = SampleCount::X1; TextureFlags flags = TextureFlagBit::NONE; + VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + ThsvsImageLayout layoutRule = THSVS_IMAGE_LAYOUT_OPTIMAL; bool isPowerOf2 = false; VkImage vkImage = VK_NULL_HANDLE; VmaAllocation vmaAllocation = VK_NULL_HANDLE; - VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED; - VkImageLayout currentLayout = VK_IMAGE_LAYOUT_UNDEFINED; - VkAccessFlags accessMask = VK_ACCESS_SHADER_READ_BIT; - VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - VkPipelineStageFlags targetStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + + vector currentAccessTypes; + vector renderAccessTypes; // gathered from desriptor sets }; class CCVKGPUTextureView final : public Object { @@ -132,9 +135,6 @@ public: vector indirectCmds; vector indexedIndirectCmds; - VkAccessFlags accessMask = VK_ACCESS_SHADER_READ_BIT; - VkPipelineStageFlags targetStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; - uint8_t *mappedData = nullptr; VmaAllocation vmaAllocation = VK_NULL_HANDLE; @@ -175,8 +175,8 @@ public: VkSwapchainKHR vkSwapchain = VK_NULL_HANDLE; vector vkSwapchainImageViews; FramebufferListMap vkSwapchainFramebufferListMap; - vector swapchainImageLayouts; - vector depthStencilImageLayouts; + vector> swapchainImageAccessTypes; + vector> depthStencilImageAccessTypes; // external references vector swapchainImages; vector depthStencilImages; @@ -206,7 +206,7 @@ struct CCVKGPUShaderStage { CCVKGPUShaderStage(ShaderStageFlagBit t, String s) : type(t), source(s) { } - ShaderStageFlagBit type; + ShaderStageFlagBit type = ShaderStageFlagBit::NONE; String source; VkShaderModule vkShader = VK_NULL_HANDLE; }; @@ -238,6 +238,7 @@ union CCVKDescriptorInfo { }; struct CCVKGPUDescriptor { DescriptorType type = DescriptorType::UNKNOWN; + vector accessTypes; CCVKGPUBufferView *gpuBufferView = nullptr; CCVKGPUTextureView *gpuTextureView = nullptr; CCVKGPUSampler *gpuSampler = nullptr; @@ -326,7 +327,7 @@ public: CommandBufferPools commandBufferPools; - CCVKGPUCommandBufferPool *getCommandBufferPool(std::thread::id threadID); + CCVKGPUCommandBufferPool *getCommandBufferPool(); }; /** @@ -905,6 +906,60 @@ private: vector> _setsToBeUpdated; }; +class CCVKGPUTextureLayoutManager final : public Object { +public: + CCVKGPUTextureLayoutManager(CCVKGPUDevice *device) + : _device(device) {} + + void checkIn(CCVKGPUTexture *gpuTexture, const ThsvsAccessType *newTypes = nullptr, uint newTypeCount = 0) { + vector &target = gpuTexture->renderAccessTypes; + for (uint i = 0u; i < newTypeCount; ++i) { + if (std::find(target.begin(), target.end(), newTypes[i]) == target.end()) { + target.push_back(newTypes[i]); + } + } + if (!std::is_permutation(gpuTexture->currentAccessTypes.begin(), gpuTexture->currentAccessTypes.end(), target.begin(), target.end())) { + _texturesToBeChecked.insert(gpuTexture); + } + } + + void update(CCVKGPUCommandBuffer *cmdBuffer) { + ThsvsImageBarrier barrier{}; + VkPipelineStageFlags srcStages = 0; + VkPipelineStageFlags dstStages = 0; + VkImageMemoryBarrier vkBarrier; + + for (CCVKGPUTexture *gpuTexture : _texturesToBeChecked) { + barrier.prevAccessCount = gpuTexture->currentAccessTypes.size(); + barrier.pPrevAccesses = gpuTexture->currentAccessTypes.data(); + barrier.nextAccessCount = gpuTexture->renderAccessTypes.size(); + barrier.pNextAccesses = gpuTexture->renderAccessTypes.data(); + barrier.discardContents = false; + barrier.prevLayout = gpuTexture->layoutRule; + barrier.nextLayout = gpuTexture->layoutRule; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.image = gpuTexture->vkImage; + barrier.subresourceRange.aspectMask = gpuTexture->aspectMask; + barrier.subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; + barrier.subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; + thsvsGetVulkanImageMemoryBarrier(barrier, &srcStages, &dstStages, &vkBarrier); + + if (vkBarrier.oldLayout != vkBarrier.newLayout) { + vkCmdPipelineBarrier(cmdBuffer->vkCommandBuffer, srcStages, dstStages, 0, 0, nullptr, 0, nullptr, 1, &vkBarrier); + } + gpuTexture->currentAccessTypes = gpuTexture->renderAccessTypes; + } + _texturesToBeChecked.clear(); + } + + CC_INLINE bool needUpdate() { return !_texturesToBeChecked.empty(); } + +private: + unordered_set _texturesToBeChecked; + CCVKGPUDevice *_device = nullptr; +}; + /** * Manages buffer update events, across all back buffer instances. */ @@ -1046,8 +1101,13 @@ private: //#define ASYNC_BUFFER_UPDATE class CCVKGPUTransportHub final : public Object { public: - CCVKGPUTransportHub(CCVKGPUDevice *device) - : _device(device) { + CCVKGPUTransportHub(CCVKGPUDevice *device, CCVKGPUQueue *queue) + : _device(device), _queue(queue) { + _cmdBuff.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + _cmdBuff.queueFamilyIndex = _queue->queueFamilyIndex; + + VkFenceCreateInfo createInfo{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; + VK_CHECK(vkCreateFence(_device->vkDevice, &createInfo, nullptr, &_fence)); } ~CCVKGPUTransportHub() { @@ -1057,23 +1117,13 @@ public: } } - void link(CCVKGPUQueue *queue) { - _queue = queue; - - _cmdBuff.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; - _cmdBuff.queueFamilyIndex = _queue->queueFamilyIndex; - - VkFenceCreateInfo createInfo{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO}; - VK_CHECK(vkCreateFence(_device->vkDevice, &createInfo, nullptr, &_fence)); - } - CC_INLINE bool empty() { return !_cmdBuff.vkCommandBuffer; } template void checkIn(const TFunc &record, bool immediateSubmission = false) { - CCVKGPUCommandBufferPool *commandBufferPool = _device->getCommandBufferPool(std::this_thread::get_id()); + CCVKGPUCommandBufferPool *commandBufferPool = _device->getCommandBufferPool(); if (!_cmdBuff.vkCommandBuffer) { commandBufferPool->request(&_cmdBuff); @@ -1097,21 +1147,19 @@ public: } } - void depart() { - if (_cmdBuff.vkCommandBuffer) { - CCVKGPUCommandBufferPool *commandBufferPool = _device->getCommandBufferPool(std::this_thread::get_id()); - - VK_CHECK(vkEndCommandBuffer(_cmdBuff.vkCommandBuffer)); - _queue->commandBuffers.push(_cmdBuff.vkCommandBuffer); - commandBufferPool->yield(&_cmdBuff); - _cmdBuff.vkCommandBuffer = VK_NULL_HANDLE; + VkCommandBuffer readyForFlight() { + VkCommandBuffer vkCommandBuffer = _cmdBuff.vkCommandBuffer; + if (vkCommandBuffer) { + VK_CHECK(vkEndCommandBuffer(vkCommandBuffer)); + _device->getCommandBufferPool()->yield(&_cmdBuff); } + return vkCommandBuffer; } private: CCVKGPUDevice *_device = nullptr; - CCVKGPUQueue *_queue = nullptr; + CCVKGPUQueue *_queue = nullptr; CCVKGPUCommandBuffer _cmdBuff; VkFence _fence = VK_NULL_HANDLE; }; diff --git a/native/cocos/renderer/gfx-vulkan/VKQueue.cpp b/native/cocos/renderer/gfx-vulkan/VKQueue.cpp index 49ce171cdb..273e20451d 100644 --- a/native/cocos/renderer/gfx-vulkan/VKQueue.cpp +++ b/native/cocos/renderer/gfx-vulkan/VKQueue.cpp @@ -61,7 +61,17 @@ void CCVKQueue::destroy() { void CCVKQueue::submit(CommandBuffer *const *cmdBuffs, uint count) { CCVKDevice *device = (CCVKDevice *)_device; _gpuQueue->commandBuffers.clear(); - device->gpuTransportHub()->depart(); + + CCVKGPUTextureLayoutManager *layoutMgr = device->gpuTextureLayoutManager(); + if (layoutMgr->needUpdate()) { + device->gpuTransportHub()->checkIn([layoutMgr](CCVKGPUCommandBuffer *cmdBuffer) { + layoutMgr->update(cmdBuffer); + }); + } + + if (!device->gpuTransportHub()->empty()) { + _gpuQueue->commandBuffers.push(device->gpuTransportHub()->readyForFlight()); + } for (uint i = 0u; i < count; ++i) { CCVKCommandBuffer *cmdBuff = (CCVKCommandBuffer *)cmdBuffs[i]; diff --git a/native/cocos/renderer/gfx-vulkan/VKQueue.h b/native/cocos/renderer/gfx-vulkan/VKQueue.h index 516ad71698..2059785bce 100644 --- a/native/cocos/renderer/gfx-vulkan/VKQueue.h +++ b/native/cocos/renderer/gfx-vulkan/VKQueue.h @@ -36,7 +36,6 @@ public: friend class CCVKDevice; -public: bool initialize(const QueueInfo &info); void destroy(); void submit(CommandBuffer *const *cmdBuffs, uint count); @@ -44,7 +43,8 @@ public: CC_INLINE CCVKGPUQueue *gpuQueue() const { return _gpuQueue; } private: - CCVKGPUQueue *_gpuQueue; + CCVKGPUQueue *_gpuQueue = nullptr; + uint _numDrawCalls = 0; uint _numInstances = 0; uint _numTriangles = 0; diff --git a/native/cocos/renderer/gfx-vulkan/VKUtils.h b/native/cocos/renderer/gfx-vulkan/VKUtils.h index 0a445e6e81..d8b3f3c9d8 100644 --- a/native/cocos/renderer/gfx-vulkan/VKUtils.h +++ b/native/cocos/renderer/gfx-vulkan/VKUtils.h @@ -37,7 +37,7 @@ THE SOFTWARE. #define BARRIER_DEDUCTION_LEVEL_BASIC 1 #define BARRIER_DEDUCTION_LEVEL_FULL 2 -#define BARRIER_DEDUCTION_LEVEL BARRIER_DEDUCTION_LEVEL_BASIC +#define BARRIER_DEDUCTION_LEVEL BARRIER_DEDUCTION_LEVEL_FULL namespace cc { namespace gfx { @@ -174,25 +174,6 @@ VkFormat MapVkFormat(Format format) { } } -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(LoadOp loadOp) { switch (loadOp) { case LoadOp::CLEAR: return VK_ATTACHMENT_LOAD_OP_CLEAR; @@ -216,58 +197,6 @@ VkAttachmentStoreOp MapVkStoreOp(StoreOp storeOp) { } } -VkAccessFlags MapVkAccessFlags(TextureLayout layout) { - switch (layout) { - case TextureLayout::UNDEFINED: return 0; - case TextureLayout::GENERAL: return 0; - case TextureLayout::COLOR_ATTACHMENT_OPTIMAL: return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - case TextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; - case TextureLayout::DEPTH_STENCIL_READONLY_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; - case TextureLayout::SHADER_READONLY_OPTIMAL: return VK_ACCESS_SHADER_READ_BIT; - case TextureLayout::TRANSFER_SRC_OPTIMAL: return VK_ACCESS_TRANSFER_READ_BIT; - case TextureLayout::TRANSFER_DST_OPTIMAL: return VK_ACCESS_TRANSFER_WRITE_BIT; - case TextureLayout::PREINITIALIZED: return 0; - case TextureLayout::PRESENT_SRC: return 0; - default: { - CCASSERT(false, "Unsupported TextureLayout, convert to VkImageLayout failed."); - return 0; - } - } -} - -VkAccessFlags MapVkAccessFlags(TextureUsage usage) { - if (usage & TextureUsage::COLOR_ATTACHMENT) return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - if (usage & TextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; - if (usage & TextureUsage::INPUT_ATTACHMENT) return VK_ACCESS_INPUT_ATTACHMENT_READ_BIT; - if (usage & TextureUsage::STORAGE) return VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT; - if (usage & TextureUsage::SAMPLED) return VK_ACCESS_SHADER_READ_BIT; - if (usage & TextureUsage::TRANSFER_SRC) return VK_ACCESS_TRANSFER_READ_BIT; - if (usage & TextureUsage::TRANSFER_DST) return VK_ACCESS_TRANSFER_WRITE_BIT; - return VK_ACCESS_SHADER_READ_BIT; -} - -VkAccessFlags MapVkAccessFlags(BufferUsage usage) { - if (usage & BufferUsage::VERTEX) return VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT; - if (usage & BufferUsage::INDEX) return VK_ACCESS_INDEX_READ_BIT; - if (usage & BufferUsage::UNIFORM) return VK_ACCESS_UNIFORM_READ_BIT; - if (usage & BufferUsage::INDIRECT) return VK_ACCESS_INDIRECT_COMMAND_READ_BIT; - if (usage & BufferUsage::STORAGE) return VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT; - if (usage & BufferUsage::TRANSFER_SRC) return VK_ACCESS_TRANSFER_READ_BIT; - if (usage & BufferUsage::TRANSFER_DST) return VK_ACCESS_TRANSFER_WRITE_BIT; - return VK_ACCESS_UNIFORM_READ_BIT; -} - -VkPipelineStageFlags MapVkPipelineStageFlags(BufferUsage usage) { - if (usage & BufferUsage::VERTEX) return VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; - if (usage & BufferUsage::INDEX) return VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; - if (usage & BufferUsage::UNIFORM) return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; - if (usage & BufferUsage::INDIRECT) return VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT; - if (usage & BufferUsage::STORAGE) return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; - if (usage & BufferUsage::TRANSFER_SRC) return VK_PIPELINE_STAGE_TRANSFER_BIT; - if (usage & BufferUsage::TRANSFER_DST) return VK_PIPELINE_STAGE_TRANSFER_BIT; - return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; -} - VkBufferUsageFlagBits MapVkBufferUsageFlagBits(BufferUsage usage) { uint flags = 0u; if (usage & BufferUsage::TRANSFER_SRC) flags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT; @@ -336,29 +265,6 @@ VkImageUsageFlagBits MapVkImageUsageFlagBits(TextureUsage usage) { return (VkImageUsageFlagBits)flags; } -VkImageLayout MapVkImageLayout(TextureUsage usage, Format format) { - const FormatInfo &info = GFX_FORMAT_INFOS[(uint)format]; - if (usage & TextureUsage::STORAGE) return VK_IMAGE_LAYOUT_GENERAL; // storage image has to be general - if (usage & TextureUsage::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 & TextureUsage::COLOR_ATTACHMENT) return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - if (usage & TextureUsage::DEPTH_STENCIL_ATTACHMENT) { - if (info.hasStencil) - return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; - else - return VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL; - } - if (usage & TextureUsage::TRANSFER_SRC) return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; - if (usage & TextureUsage::TRANSFER_DST) return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; - return VK_IMAGE_LAYOUT_UNDEFINED; -} - VkImageAspectFlags MapVkImageAspectFlags(Format format) { VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; const FormatInfo &info = GFX_FORMAT_INFOS[(uint)format]; @@ -371,25 +277,6 @@ VkImageAspectFlags MapVkImageAspectFlags(Format format) { return aspectMask; } -VkPipelineStageFlags MapVkPipelineStageFlags(TextureUsage usage) { - if (usage & TextureUsage::COLOR_ATTACHMENT) return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; - if (usage & TextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; - if (usage & TextureUsage::STORAGE) return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; - if (usage & TextureUsage::SAMPLED) return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; - if (usage & TextureUsage::TRANSFER_SRC) return VK_PIPELINE_STAGE_TRANSFER_BIT; - if (usage & TextureUsage::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 = 0u; 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; -} - VkImageCreateFlags MapVkImageCreateFlags(TextureType type) { uint res = 0u; switch (type) { @@ -639,6 +526,7 @@ const VkPipelineBindPoint VK_PIPELINE_BIND_POINTS[] = { }; const ThsvsAccessType THSVS_ACCESS_TYPES[] = { + THSVS_ACCESS_NONE, // NONE THSVS_ACCESS_INDIRECT_BUFFER, // INDIRECT_BUFFER THSVS_ACCESS_INDEX_BUFFER, // INDEX_BUFFER THSVS_ACCESS_VERTEX_BUFFER, // VERTEX_BUFFER @@ -668,11 +556,6 @@ const ThsvsAccessType THSVS_ACCESS_TYPES[] = { THSVS_ACCESS_HOST_WRITE, // HOST_WRITE }; -const ThsvsImageLayout THSVS_IMAGE_LAYOUTS[] = { - THSVS_IMAGE_LAYOUT_OPTIMAL, - THSVS_IMAGE_LAYOUT_GENERAL, -}; - const VkImageLayout VK_IMAGE_LAYOUTS[] = { VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_GENERAL, diff --git a/native/cocos/renderer/gfx-vulkan/thsvs_simpler_vulkan_synchronization.h b/native/cocos/renderer/gfx-vulkan/thsvs_simpler_vulkan_synchronization.h index 36badaad36..838b9229d5 100644 --- a/native/cocos/renderer/gfx-vulkan/thsvs_simpler_vulkan_synchronization.h +++ b/native/cocos/renderer/gfx-vulkan/thsvs_simpler_vulkan_synchronization.h @@ -930,6 +930,10 @@ void thsvsGetVulkanBufferMemoryBarrier( pVkBarrier->offset = thBarrier.offset; pVkBarrier->size = thBarrier.size; +#ifdef THSVS_ERROR_CHECK_COULD_USE_GLOBAL_BARRIER + assert(pVkBarrier->srcQueueFamilyIndex != pVkBarrier->dstQueueFamilyIndex); +#endif + for (uint32_t i = 0; i < thBarrier.prevAccessCount; ++i) { ThsvsAccessType prevAccess = thBarrier.pPrevAccesses[i]; @@ -1054,11 +1058,6 @@ void thsvsGetVulkanImageMemoryBarrier( #endif pVkBarrier->oldLayout = layout; } - -#ifdef THSVS_ERROR_CHECK_COULD_USE_GLOBAL_BARRIER - assert(pVkBarrier->srcQueueFamilyIndex != pVkBarrier->dstQueueFamilyIndex || - pVkBarrier->srcQueueFamilyIndex == VK_QUEUE_FAMILY_IGNORED); -#endif } for (uint32_t i = 0; i < thBarrier.nextAccessCount; ++i) @@ -1109,7 +1108,8 @@ void thsvsGetVulkanImageMemoryBarrier( } #ifdef THSVS_ERROR_CHECK_COULD_USE_GLOBAL_BARRIER - assert(pVkBarrier->newLayout != pVkBarrier->oldLayout); + assert(pVkBarrier->newLayout != pVkBarrier->oldLayout || + pVkBarrier->srcQueueFamilyIndex != pVkBarrier->dstQueueFamilyIndex); #endif // Ensure that the stage masks are valid if no stages were determined