mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-21 08:02:39 +08:00
vk: barrier refactor
This commit is contained in:
@@ -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);
|
||||
|
||||
@@ -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},
|
||||
|
||||
@@ -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 ¤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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -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, ®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<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;
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
|
||||
@@ -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];
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user