vk: barrier refactor

This commit is contained in:
Yun Hsiao Wu
2021-01-21 18:42:10 +08:00
parent d590b0e800
commit ec0088baaf
20 changed files with 393 additions and 406 deletions
+1 -1
View File
@@ -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_)
@@ -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);
+28
View File
@@ -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},
+76 -65
View File
@@ -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<AccessType> 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<AccessType> 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<Color> 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<DrawInfo> 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<DispatchInfo> 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<UniformStorageImage> 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<UniformStorageBuffer> UniformStorageBufferList;
@@ -1048,7 +1048,7 @@ struct UniformInputAttachment {
typedef cc::vector<UniformInputAttachment> 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<ColorAttachment> 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<GlobalBarrier> 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<TextureBarrier> ImageBarrierList;
typedef cc::vector<TextureBarrier> 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<BufferBarrier> BufferBarrierList;
typedef cc::vector<Buffer *> BufferList;
typedef cc::vector<Texture *> 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<DescriptorSetLayoutBinding> 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
@@ -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<uint>(seed);
@@ -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 {
@@ -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:
@@ -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);
@@ -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.");
@@ -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<ThsvsAccessType> &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<ThsvsAccessType> &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 &currentLayout = 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);
}
}
}
+51 -87
View File
@@ -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<std::mutex> 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<VkAttachmentDescription> 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, &region](const CCVKGPUCommandBuffer *cmdBuffer) {
vkCmdCopyBuffer(cmdBuffer->vkCommandBuffer, stagingBuffer.vkBuffer, gpuBuffer->vkBuffer, 1, &region);
#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<ThsvsAccessType> &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) {
@@ -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;
@@ -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;
@@ -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();
@@ -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<const char *> _layers;
vector<const char *> _extensions;
+82 -34
View File
@@ -58,7 +58,10 @@ public:
ColorAttachmentList colorAttachments;
DepthStencilAttachment depthStencilAttachment;
SubPassInfoList subPasses;
VkRenderPass vkRenderPass;
// helper storage
vector<VkClearValue> 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<ThsvsAccessType> currentAccessTypes;
vector<ThsvsAccessType> renderAccessTypes; // gathered from desriptor sets
};
class CCVKGPUTextureView final : public Object {
@@ -132,9 +135,6 @@ public:
vector<VkDrawIndirectCommand> indirectCmds;
vector<VkDrawIndexedIndirectCommand> 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<VkImageView> vkSwapchainImageViews;
FramebufferListMap vkSwapchainFramebufferListMap;
vector<VkImageLayout> swapchainImageLayouts;
vector<VkImageLayout> depthStencilImageLayouts;
vector<vector<ThsvsAccessType>> swapchainImageAccessTypes;
vector<vector<ThsvsAccessType>> depthStencilImageAccessTypes;
// external references
vector<VkImage> swapchainImages;
vector<VkImage> 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<ThsvsAccessType> 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<unordered_set<CCVKGPUDescriptorSet *>> _setsToBeUpdated;
};
class CCVKGPUTextureLayoutManager final : public Object {
public:
CCVKGPUTextureLayoutManager(CCVKGPUDevice *device)
: _device(device) {}
void checkIn(CCVKGPUTexture *gpuTexture, const ThsvsAccessType *newTypes = nullptr, uint newTypeCount = 0) {
vector<ThsvsAccessType> &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<CCVKGPUTexture *> _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 <typename TFunc>
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;
};
+11 -1
View File
@@ -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];
+2 -2
View File
@@ -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;
+2 -119
View File
@@ -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,
@@ -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