mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 23:52:40 +08:00
vk: clang format (#2535)
This commit is contained in:
@@ -676,6 +676,7 @@ struct GFXWindowInfo {
|
||||
bool isFullscreen = false;
|
||||
GFXVsyncMode vsyncMode = GFXVsyncMode::OFF;
|
||||
uintptr_t windowHandle = 0;
|
||||
GFXRenderPass *renderPass = nullptr;
|
||||
};
|
||||
|
||||
struct GFXContextInfo {
|
||||
|
||||
@@ -1,31 +1,27 @@
|
||||
#include "VKStd.h"
|
||||
|
||||
#include "VKBindingLayout.h"
|
||||
#include "VKCommands.h"
|
||||
#include "VKBuffer.h"
|
||||
#include "VKTextureView.h"
|
||||
#include "VKSampler.h"
|
||||
#include "VKCommands.h"
|
||||
#include "VKDevice.h"
|
||||
#include "VKSampler.h"
|
||||
#include "VKTextureView.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKBindingLayout::CCVKBindingLayout(GFXDevice* device)
|
||||
: GFXBindingLayout(device)
|
||||
{
|
||||
CCVKBindingLayout::CCVKBindingLayout(GFXDevice *device)
|
||||
: GFXBindingLayout(device) {
|
||||
}
|
||||
|
||||
CCVKBindingLayout::~CCVKBindingLayout()
|
||||
{
|
||||
CCVKBindingLayout::~CCVKBindingLayout() {
|
||||
}
|
||||
|
||||
bool CCVKBindingLayout::initialize(const GFXBindingLayoutInfo &info)
|
||||
{
|
||||
if (info.bindings.size())
|
||||
{
|
||||
bool CCVKBindingLayout::initialize(const GFXBindingLayoutInfo &info) {
|
||||
if (info.bindings.size()) {
|
||||
_bindingUnits.resize(info.bindings.size());
|
||||
for (size_t i = 0; i < _bindingUnits.size(); ++i)
|
||||
{
|
||||
GFXBindingUnit& bindingUnit = _bindingUnits[i];
|
||||
const GFXBinding& binding = info.bindings[i];
|
||||
for (size_t i = 0; i < _bindingUnits.size(); ++i) {
|
||||
GFXBindingUnit &bindingUnit = _bindingUnits[i];
|
||||
const GFXBinding &binding = info.bindings[i];
|
||||
bindingUnit.binding = binding.binding;
|
||||
bindingUnit.type = binding.type;
|
||||
bindingUnit.name = binding.name;
|
||||
@@ -35,18 +31,16 @@ bool CCVKBindingLayout::initialize(const GFXBindingLayoutInfo &info)
|
||||
}
|
||||
|
||||
_gpuBindingLayout = CC_NEW(CCVKGPUBindingLayout);
|
||||
CCVKCmdFuncCreateBindingLayout((CCVKDevice*)_device, _gpuBindingLayout, _bindingUnits);
|
||||
CCVKCmdFuncCreateBindingLayout((CCVKDevice *)_device, _gpuBindingLayout, _bindingUnits);
|
||||
|
||||
_status = GFXStatus::SUCCESS;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKBindingLayout::destroy()
|
||||
{
|
||||
if (_gpuBindingLayout)
|
||||
{
|
||||
CCVKCmdFuncDestroyBindingLayout((CCVKDevice*)_device, _gpuBindingLayout);
|
||||
void CCVKBindingLayout::destroy() {
|
||||
if (_gpuBindingLayout) {
|
||||
CCVKCmdFuncDestroyBindingLayout((CCVKDevice *)_device, _gpuBindingLayout);
|
||||
CC_DELETE(_gpuBindingLayout);
|
||||
_gpuBindingLayout = nullptr;
|
||||
}
|
||||
@@ -54,53 +48,46 @@ void CCVKBindingLayout::destroy()
|
||||
_status = GFXStatus::UNREADY;
|
||||
}
|
||||
|
||||
void CCVKBindingLayout::update()
|
||||
{
|
||||
if (_isDirty && _gpuBindingLayout)
|
||||
{
|
||||
for (size_t i = 0; i < _bindingUnits.size(); ++i)
|
||||
{
|
||||
GFXBindingUnit& bindingUnit = _bindingUnits[i];
|
||||
auto &binding = _gpuBindingLayout->bindings[i];
|
||||
void CCVKBindingLayout::update() {
|
||||
if (_isDirty && _gpuBindingLayout) {
|
||||
for (size_t i = 0; i < _bindingUnits.size(); ++i) {
|
||||
GFXBindingUnit &bindingUnit = _bindingUnits[i];
|
||||
VkWriteDescriptorSet &binding = _gpuBindingLayout->bindings[i];
|
||||
|
||||
switch (bindingUnit.type)
|
||||
{
|
||||
case GFXBindingType::UNIFORM_BUFFER:
|
||||
{
|
||||
if (bindingUnit.buffer)
|
||||
{
|
||||
auto buffer = ((CCVKBuffer*)bindingUnit.buffer)->gpuBuffer();
|
||||
auto info = (VkDescriptorBufferInfo*)binding.pBufferInfo;
|
||||
switch (bindingUnit.type) {
|
||||
case GFXBindingType::UNIFORM_BUFFER: {
|
||||
if (bindingUnit.buffer) {
|
||||
CCVKGPUBuffer *buffer = ((CCVKBuffer *)bindingUnit.buffer)->gpuBuffer();
|
||||
VkDescriptorBufferInfo *info = (VkDescriptorBufferInfo *)binding.pBufferInfo;
|
||||
|
||||
info->buffer = buffer->vkBuffer;
|
||||
info->offset = 0;
|
||||
info->range = buffer->size;
|
||||
info->buffer = buffer->vkBuffer;
|
||||
info->offset = 0;
|
||||
info->range = buffer->size;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
case GFXBindingType::SAMPLER: {
|
||||
VkDescriptorImageInfo *info = (VkDescriptorImageInfo *)binding.pImageInfo;
|
||||
info->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
||||
|
||||
break;
|
||||
}
|
||||
case GFXBindingType::SAMPLER:
|
||||
{
|
||||
auto info = (VkDescriptorImageInfo*)binding.pImageInfo;
|
||||
info->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
||||
if (bindingUnit.texView) {
|
||||
info->imageView = ((CCVKTextureView *)bindingUnit.texView)->gpuTexView()->vkImageView;
|
||||
} else {
|
||||
info->imageView = ((CCVKDevice *)_device)->nullTexView2D->gpuTexView()->vkImageView;
|
||||
}
|
||||
|
||||
if (bindingUnit.texView)
|
||||
{
|
||||
info->imageView = ((CCVKTextureView*)bindingUnit.texView)->gpuTexView()->vkImageView;
|
||||
if (bindingUnit.sampler) {
|
||||
info->sampler = ((CCVKSampler *)bindingUnit.sampler)->gpuSampler()->vkSampler;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
if (bindingUnit.sampler)
|
||||
{
|
||||
info->sampler = ((CCVKSampler*)bindingUnit.sampler)->gpuSampler()->vkSampler;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
vkUpdateDescriptorSets(((CCVKDevice*)_device)->gpuDevice()->vkDevice,
|
||||
_gpuBindingLayout->bindings.size(), _gpuBindingLayout->bindings.data(), 0, nullptr);
|
||||
vkUpdateDescriptorSets(((CCVKDevice *)_device)->gpuDevice()->vkDevice,
|
||||
_gpuBindingLayout->bindings.size(), _gpuBindingLayout->bindings.data(), 0, nullptr);
|
||||
|
||||
_isDirty = false;
|
||||
}
|
||||
|
||||
@@ -5,21 +5,20 @@ NS_CC_BEGIN
|
||||
|
||||
class CCVKGPUBindingLayout;
|
||||
|
||||
class CC_VULKAN_API CCVKBindingLayout : public GFXBindingLayout
|
||||
{
|
||||
class CC_VULKAN_API CCVKBindingLayout : public GFXBindingLayout {
|
||||
public:
|
||||
CCVKBindingLayout(GFXDevice* device);
|
||||
CCVKBindingLayout(GFXDevice *device);
|
||||
~CCVKBindingLayout();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXBindingLayoutInfo& info);
|
||||
bool initialize(const GFXBindingLayoutInfo &info);
|
||||
void destroy();
|
||||
void update();
|
||||
|
||||
CC_INLINE CCVKGPUBindingLayout* gpuBindingLayout() const { return _gpuBindingLayout; }
|
||||
CC_INLINE CCVKGPUBindingLayout *gpuBindingLayout() const { return _gpuBindingLayout; }
|
||||
|
||||
private:
|
||||
CCVKGPUBindingLayout* _gpuBindingLayout = nullptr;
|
||||
CCVKGPUBindingLayout *_gpuBindingLayout = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -1,20 +1,18 @@
|
||||
#include "VKStd.h"
|
||||
|
||||
#include "VKBuffer.h"
|
||||
#include "VKCommands.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKBuffer::CCVKBuffer(GFXDevice* device)
|
||||
: GFXBuffer(device)
|
||||
{
|
||||
CCVKBuffer::CCVKBuffer(GFXDevice *device)
|
||||
: GFXBuffer(device) {
|
||||
}
|
||||
|
||||
CCVKBuffer::~CCVKBuffer()
|
||||
{
|
||||
CCVKBuffer::~CCVKBuffer() {
|
||||
}
|
||||
|
||||
bool CCVKBuffer::initialize(const GFXBufferInfo& info)
|
||||
{
|
||||
bool CCVKBuffer::initialize(const GFXBufferInfo &info) {
|
||||
_usage = info.usage;
|
||||
_memUsage = info.memUsage;
|
||||
_size = info.size;
|
||||
@@ -22,9 +20,8 @@ bool CCVKBuffer::initialize(const GFXBufferInfo& info)
|
||||
_count = _size / _stride;
|
||||
_flags = info.flags;
|
||||
|
||||
if ((_flags & GFXBufferFlagBit::BAKUP_BUFFER) && _size > 0)
|
||||
{
|
||||
_buffer = (uint8_t*)CC_MALLOC(_size);
|
||||
if ((_flags & GFXBufferFlagBit::BAKUP_BUFFER) && _size > 0) {
|
||||
_buffer = (uint8_t *)CC_MALLOC(_size);
|
||||
_device->getMemoryStatus().bufferSize += _size;
|
||||
}
|
||||
|
||||
@@ -35,30 +32,26 @@ bool CCVKBuffer::initialize(const GFXBufferInfo& info)
|
||||
_gpuBuffer->stride = _stride;
|
||||
_gpuBuffer->count = _count;
|
||||
|
||||
if (!(_usage & GFXBufferUsageBit::INDIRECT))
|
||||
{
|
||||
if (!(_usage & GFXBufferUsageBit::INDIRECT)) {
|
||||
_gpuBuffer->buffer = _buffer;
|
||||
}
|
||||
|
||||
CCVKCmdFuncCreateBuffer((CCVKDevice*)_device, _gpuBuffer);
|
||||
CCVKCmdFuncCreateBuffer((CCVKDevice *)_device, _gpuBuffer);
|
||||
_device->getMemoryStatus().bufferSize += _size;
|
||||
_status = GFXStatus::SUCCESS;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKBuffer::destroy()
|
||||
{
|
||||
if (_gpuBuffer)
|
||||
{
|
||||
CCVKCmdFuncDestroyBuffer((CCVKDevice*)_device, _gpuBuffer);
|
||||
void CCVKBuffer::destroy() {
|
||||
if (_gpuBuffer) {
|
||||
CCVKCmdFuncDestroyBuffer((CCVKDevice *)_device, _gpuBuffer);
|
||||
_device->getMemoryStatus().bufferSize -= _size;
|
||||
CC_DELETE(_gpuBuffer);
|
||||
_gpuBuffer = nullptr;
|
||||
}
|
||||
|
||||
if (_buffer)
|
||||
{
|
||||
if (_buffer) {
|
||||
CC_FREE(_buffer);
|
||||
_device->getMemoryStatus().bufferSize -= _size;
|
||||
_buffer = nullptr;
|
||||
@@ -67,25 +60,22 @@ void CCVKBuffer::destroy()
|
||||
_status = GFXStatus::UNREADY;
|
||||
}
|
||||
|
||||
void CCVKBuffer::resize(uint size)
|
||||
{
|
||||
if (_size != size)
|
||||
{
|
||||
void CCVKBuffer::resize(uint size) {
|
||||
if (_size != size) {
|
||||
const uint old_size = _size;
|
||||
_size = size;
|
||||
_count = _size / _stride;
|
||||
|
||||
GFXMemoryStatus& status = _device->getMemoryStatus();
|
||||
GFXMemoryStatus &status = _device->getMemoryStatus();
|
||||
_gpuBuffer->size = _size;
|
||||
_gpuBuffer->count = _count;
|
||||
CCVKCmdFuncResizeBuffer((CCVKDevice*)_device, _gpuBuffer);
|
||||
CCVKCmdFuncResizeBuffer((CCVKDevice *)_device, _gpuBuffer);
|
||||
status.bufferSize -= old_size;
|
||||
status.bufferSize += _size;
|
||||
|
||||
if (_buffer)
|
||||
{
|
||||
const uint8_t* old_buff = _buffer;
|
||||
_buffer = (uint8_t*)CC_MALLOC(_size);
|
||||
if (_buffer) {
|
||||
const uint8_t *old_buff = _buffer;
|
||||
_buffer = (uint8_t *)CC_MALLOC(_size);
|
||||
memcpy(_buffer, old_buff, old_size);
|
||||
CC_FREE(_buffer);
|
||||
status.bufferSize -= old_size;
|
||||
@@ -94,13 +84,11 @@ void CCVKBuffer::resize(uint size)
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKBuffer::update(void* buffer, uint offset, uint size)
|
||||
{
|
||||
if (_buffer)
|
||||
{
|
||||
void CCVKBuffer::update(void *buffer, uint offset, uint size) {
|
||||
if (_buffer) {
|
||||
memcpy(_buffer + offset, buffer, size);
|
||||
}
|
||||
CCVKCmdFuncUpdateBuffer((CCVKDevice*)_device, _gpuBuffer, buffer, offset, size);
|
||||
CCVKCmdFuncUpdateBuffer((CCVKDevice *)_device, _gpuBuffer, buffer, offset, size);
|
||||
}
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -5,22 +5,21 @@ NS_CC_BEGIN
|
||||
|
||||
class CCVKGPUBuffer;
|
||||
|
||||
class CC_VULKAN_API CCVKBuffer : public GFXBuffer
|
||||
{
|
||||
class CC_VULKAN_API CCVKBuffer : public GFXBuffer {
|
||||
public:
|
||||
CCVKBuffer(GFXDevice* device);
|
||||
CCVKBuffer(GFXDevice *device);
|
||||
~CCVKBuffer();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXBufferInfo& info);
|
||||
bool initialize(const GFXBufferInfo &info);
|
||||
void destroy();
|
||||
void resize(uint size);
|
||||
void update(void* buffer, uint offset, uint size);
|
||||
void update(void *buffer, uint offset, uint size);
|
||||
|
||||
CC_INLINE CCVKGPUBuffer* gpuBuffer() const { return _gpuBuffer; }
|
||||
CC_INLINE CCVKGPUBuffer *gpuBuffer() const { return _gpuBuffer; }
|
||||
|
||||
private:
|
||||
CCVKGPUBuffer* _gpuBuffer = nullptr;
|
||||
CCVKGPUBuffer *_gpuBuffer = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -1,43 +1,38 @@
|
||||
#include "VKStd.h"
|
||||
|
||||
#include "VKCommandAllocator.h"
|
||||
#include "VKCommands.h"
|
||||
#include "VKDevice.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKCommandAllocator::CCVKCommandAllocator(GFXDevice* device)
|
||||
: GFXCommandAllocator(device)
|
||||
{
|
||||
CCVKCommandAllocator::CCVKCommandAllocator(GFXDevice *device)
|
||||
: GFXCommandAllocator(device) {
|
||||
}
|
||||
|
||||
CCVKCommandAllocator::~CCVKCommandAllocator()
|
||||
{
|
||||
CCVKCommandAllocator::~CCVKCommandAllocator() {
|
||||
}
|
||||
|
||||
bool CCVKCommandAllocator::initialize(const GFXCommandAllocatorInfo& info)
|
||||
{
|
||||
bool CCVKCommandAllocator::initialize(const GFXCommandAllocatorInfo &info) {
|
||||
_gpuCommandPool = CC_NEW(CCVKGPUCommandPool);
|
||||
|
||||
CCVKCmdFuncCreateCommandPool((CCVKDevice*)_device, _gpuCommandPool);
|
||||
CCVKCmdFuncCreateCommandPool((CCVKDevice *)_device, _gpuCommandPool);
|
||||
|
||||
_status = GFXStatus::SUCCESS;
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKCommandAllocator::destroy()
|
||||
{
|
||||
CCVKCmdFuncDestroyCommandPool((CCVKDevice*)_device, _gpuCommandPool);
|
||||
void CCVKCommandAllocator::destroy() {
|
||||
CCVKCmdFuncDestroyCommandPool((CCVKDevice *)_device, _gpuCommandPool);
|
||||
|
||||
_status = GFXStatus::UNREADY;
|
||||
}
|
||||
|
||||
void CCVKCommandAllocator::reset()
|
||||
{
|
||||
VK_CHECK(vkResetCommandPool(((CCVKDevice*)_device)->gpuDevice()->vkDevice, _gpuCommandPool->vkCommandPool, 0));
|
||||
void CCVKCommandAllocator::reset() {
|
||||
VK_CHECK(vkResetCommandPool(((CCVKDevice *)_device)->gpuDevice()->vkDevice, _gpuCommandPool->vkCommandPool, 0));
|
||||
|
||||
for (uint i = 0u; i < 2u; i++)
|
||||
{
|
||||
auto &usedList = _gpuCommandPool->usedCommandBuffers[i];
|
||||
for (uint i = 0u; i < 2u; i++) {
|
||||
CachedArray<VkCommandBuffer> &usedList = _gpuCommandPool->usedCommandBuffers[i];
|
||||
_gpuCommandPool->commandBuffers[i].concat(usedList);
|
||||
usedList.clear();
|
||||
}
|
||||
|
||||
@@ -7,18 +7,18 @@ class CCVKGPUCommandPool;
|
||||
|
||||
class CC_VULKAN_API CCVKCommandAllocator : public GFXCommandAllocator {
|
||||
public:
|
||||
CCVKCommandAllocator(GFXDevice* device);
|
||||
CCVKCommandAllocator(GFXDevice *device);
|
||||
~CCVKCommandAllocator();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXCommandAllocatorInfo& info);
|
||||
bool initialize(const GFXCommandAllocatorInfo &info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUCommandPool* gpuCommandPool() { return _gpuCommandPool; }
|
||||
CC_INLINE CCVKGPUCommandPool *gpuCommandPool() { return _gpuCommandPool; }
|
||||
void reset();
|
||||
|
||||
private:
|
||||
CCVKGPUCommandPool* _gpuCommandPool;
|
||||
CCVKGPUCommandPool *_gpuCommandPool;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -1,31 +1,27 @@
|
||||
#include "VKStd.h"
|
||||
|
||||
#include "VKBindingLayout.h"
|
||||
#include "VKBuffer.h"
|
||||
#include "VKCommandAllocator.h"
|
||||
#include "VKCommandBuffer.h"
|
||||
#include "VKCommands.h"
|
||||
#include "VKCommandAllocator.h"
|
||||
#include "VKFramebuffer.h"
|
||||
|
||||
#include "VKBuffer.h"
|
||||
#include "VKTexture.h"
|
||||
#include "VKRenderPass.h"
|
||||
#include "VKPipelineState.h"
|
||||
#include "VKBindingLayout.h"
|
||||
#include "VKInputAssembler.h"
|
||||
#include "VKPipelineState.h"
|
||||
#include "VKRenderPass.h"
|
||||
#include "VKTexture.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKCommandBuffer::CCVKCommandBuffer(GFXDevice* device)
|
||||
: GFXCommandBuffer(device)
|
||||
{
|
||||
CCVKCommandBuffer::CCVKCommandBuffer(GFXDevice *device)
|
||||
: GFXCommandBuffer(device) {
|
||||
}
|
||||
|
||||
CCVKCommandBuffer::~CCVKCommandBuffer()
|
||||
{
|
||||
CCVKCommandBuffer::~CCVKCommandBuffer() {
|
||||
}
|
||||
|
||||
bool CCVKCommandBuffer::initialize(const GFXCommandBufferInfo& info)
|
||||
{
|
||||
if (!info.allocator)
|
||||
{
|
||||
bool CCVKCommandBuffer::initialize(const GFXCommandBufferInfo &info) {
|
||||
if (!info.allocator) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -34,18 +30,16 @@ bool CCVKCommandBuffer::initialize(const GFXCommandBufferInfo& info)
|
||||
|
||||
_gpuCommandBuffer = CC_NEW(CCVKGPUCommandBuffer);
|
||||
_gpuCommandBuffer->type = _type;
|
||||
_gpuCommandBuffer->commandPool = ((CCVKCommandAllocator*)_allocator)->gpuCommandPool();
|
||||
CCVKCmdFuncAllocateCommandBuffer((CCVKDevice*)_device, _gpuCommandBuffer);
|
||||
_gpuCommandBuffer->commandPool = ((CCVKCommandAllocator *)_allocator)->gpuCommandPool();
|
||||
CCVKCmdFuncAllocateCommandBuffer((CCVKDevice *)_device, _gpuCommandBuffer);
|
||||
|
||||
_status = GFXStatus::SUCCESS;
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::destroy()
|
||||
{
|
||||
if (_gpuCommandBuffer)
|
||||
{
|
||||
CCVKCmdFuncFreeCommandBuffer((CCVKDevice*)_device, _gpuCommandBuffer);
|
||||
void CCVKCommandBuffer::destroy() {
|
||||
if (_gpuCommandBuffer) {
|
||||
CCVKCmdFuncFreeCommandBuffer((CCVKDevice *)_device, _gpuCommandBuffer);
|
||||
CC_DELETE(_gpuCommandBuffer);
|
||||
_gpuCommandBuffer = nullptr;
|
||||
}
|
||||
@@ -54,8 +48,7 @@ void CCVKCommandBuffer::destroy()
|
||||
_status = GFXStatus::UNREADY;
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::begin(GFXRenderPass* renderPass, uint subpass, GFXFramebuffer* frameBuffer)
|
||||
{
|
||||
void CCVKCommandBuffer::begin(GFXRenderPass *renderPass, uint subpass, GFXFramebuffer *frameBuffer) {
|
||||
_curGPUPipelineState = nullptr;
|
||||
_curGPUBindingLayout = nullptr;
|
||||
_curGPUInputAssember = nullptr;
|
||||
@@ -63,39 +56,34 @@ void CCVKCommandBuffer::begin(GFXRenderPass* renderPass, uint subpass, GFXFrameb
|
||||
_numInstances = 0;
|
||||
_numTriangles = 0;
|
||||
|
||||
VkCommandBufferBeginInfo beginInfo{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO };
|
||||
VkCommandBufferBeginInfo beginInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO};
|
||||
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
||||
|
||||
if (_type == GFXCommandBufferType::SECONDARY)
|
||||
{
|
||||
if (!renderPass)
|
||||
{
|
||||
if (_type == GFXCommandBufferType::SECONDARY) {
|
||||
if (!renderPass) {
|
||||
CC_LOG_ERROR("RenderPass has to be specified when beginning secondary command buffers.");
|
||||
return;
|
||||
}
|
||||
VkCommandBufferInheritanceInfo inheritanceInfo{ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO };
|
||||
inheritanceInfo.renderPass = ((CCVKRenderPass*)renderPass)->gpuRenderPass()->vkRenderPass;
|
||||
VkCommandBufferInheritanceInfo inheritanceInfo{VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO};
|
||||
inheritanceInfo.renderPass = ((CCVKRenderPass *)renderPass)->gpuRenderPass()->vkRenderPass;
|
||||
inheritanceInfo.subpass = subpass;
|
||||
if (frameBuffer) inheritanceInfo.framebuffer = ((CCVKFramebuffer*)frameBuffer)->gpuFBO()->vkFramebuffer;
|
||||
if (frameBuffer) inheritanceInfo.framebuffer = ((CCVKFramebuffer *)frameBuffer)->gpuFBO()->vkFramebuffer;
|
||||
beginInfo.pInheritanceInfo = &inheritanceInfo;
|
||||
}
|
||||
VK_CHECK(vkBeginCommandBuffer(_gpuCommandBuffer->vkCommandBuffer, &beginInfo));
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::end()
|
||||
{
|
||||
void CCVKCommandBuffer::end() {
|
||||
_curGPUFBO = nullptr;
|
||||
VK_CHECK(vkEndCommandBuffer(_gpuCommandBuffer->vkCommandBuffer));
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::beginRenderPass(GFXFramebuffer* fbo, const GFXRect& renderArea,
|
||||
GFXClearFlags clearFlags, const std::vector<GFXColor>& colors, float depth, int stencil)
|
||||
{
|
||||
_curGPUFBO = ((CCVKFramebuffer*)fbo)->gpuFBO();
|
||||
void CCVKCommandBuffer::beginRenderPass(GFXFramebuffer *fbo, const GFXRect &renderArea,
|
||||
GFXClearFlags clearFlags, const std::vector<GFXColor> &colors, float depth, int stencil) {
|
||||
_curGPUFBO = ((CCVKFramebuffer *)fbo)->gpuFBO();
|
||||
CCVKGPURenderPass *renderPass = _curGPUFBO->gpuRenderPass;
|
||||
VkFramebuffer framebuffer = _curGPUFBO->vkFramebuffer;
|
||||
if (!_curGPUFBO->isOffscreen)
|
||||
{
|
||||
if (!_curGPUFBO->isOffscreen) {
|
||||
renderPass = _curGPUFBO->swapchain->renderPass;
|
||||
framebuffer = _curGPUFBO->swapchain->vkSwapchainFramebuffers[_curGPUFBO->swapchain->curImageIndex];
|
||||
}
|
||||
@@ -104,25 +92,21 @@ void CCVKCommandBuffer::beginRenderPass(GFXFramebuffer* fbo, const GFXRect& rend
|
||||
vector<VkClearValue>::type &clearValues = renderPass->clearValues;
|
||||
size_t attachmentCount = barriers.size();
|
||||
|
||||
if (attachmentCount)
|
||||
{
|
||||
for (size_t i = 0u; i < attachmentCount - 1; i++)
|
||||
{
|
||||
barriers[i].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuColorViews[i]->gpuTexture->vkImage :
|
||||
_curGPUFBO->swapchain->swapchainImages[_curGPUFBO->swapchain->curImageIndex];
|
||||
clearValues[i].color = { colors[i].r, colors[i].g, colors[i].b, colors[i].a };
|
||||
if (attachmentCount) {
|
||||
for (size_t i = 0u; i < attachmentCount - 1; i++) {
|
||||
barriers[i].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuColorViews[i]->gpuTexture->vkImage : _curGPUFBO->swapchain->swapchainImages[_curGPUFBO->swapchain->curImageIndex];
|
||||
clearValues[i].color = {colors[i].r, colors[i].g, colors[i].b, colors[i].a};
|
||||
}
|
||||
barriers[attachmentCount - 1].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuDepthStencilView->gpuTexture->vkImage :
|
||||
_curGPUFBO->swapchain->depthStencilImages[_curGPUFBO->swapchain->curImageIndex];
|
||||
clearValues[attachmentCount - 1].depthStencil = { depth, (uint)stencil };
|
||||
barriers[attachmentCount - 1].image = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuDepthStencilView->gpuTexture->vkImage : _curGPUFBO->swapchain->depthStencilImages[_curGPUFBO->swapchain->curImageIndex];
|
||||
clearValues[attachmentCount - 1].depthStencil = {depth, (uint)stencil};
|
||||
|
||||
// transition to COLOR_ATTACHMENT_OPTIMAL
|
||||
vkCmdPipelineBarrier(_gpuCommandBuffer->vkCommandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||||
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
|
||||
VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, attachmentCount, barriers.data());
|
||||
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
|
||||
VK_DEPENDENCY_BY_REGION_BIT, 0, nullptr, 0, nullptr, attachmentCount, barriers.data());
|
||||
}
|
||||
|
||||
VkRenderPassBeginInfo passBeginInfo{ VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO };
|
||||
VkRenderPassBeginInfo passBeginInfo{VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO};
|
||||
passBeginInfo.renderPass = renderPass->vkRenderPass;
|
||||
passBeginInfo.framebuffer = framebuffer;
|
||||
passBeginInfo.renderArea.offset.x = renderArea.x;
|
||||
@@ -134,15 +118,14 @@ void CCVKCommandBuffer::beginRenderPass(GFXFramebuffer* fbo, const GFXRect& rend
|
||||
|
||||
vkCmdBeginRenderPass(_gpuCommandBuffer->vkCommandBuffer, &passBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
|
||||
|
||||
VkViewport viewport{ (float)renderArea.x, (float)renderArea.y, (float)renderArea.width, (float)renderArea.height, 0, 1 };
|
||||
VkViewport viewport{(float)renderArea.x, (float)renderArea.y, (float)renderArea.width, (float)renderArea.height, 0, 1};
|
||||
vkCmdSetViewport(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &viewport);
|
||||
|
||||
VkRect2D scissor{ { renderArea.x, renderArea.y }, { renderArea.width, renderArea.height } };
|
||||
VkRect2D scissor{{renderArea.x, renderArea.y}, {renderArea.width, renderArea.height}};
|
||||
vkCmdSetScissor(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &scissor);
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::endRenderPass()
|
||||
{
|
||||
void CCVKCommandBuffer::endRenderPass() {
|
||||
vkCmdEndRenderPass(_gpuCommandBuffer->vkCommandBuffer);
|
||||
|
||||
//CCVKGPURenderPass *renderPass = _curGPUFBO->isOffscreen ? _curGPUFBO->gpuRenderPass : _curGPUFBO->swapchain->renderPass;
|
||||
@@ -168,102 +151,84 @@ void CCVKCommandBuffer::endRenderPass()
|
||||
_curGPUFBO = nullptr;
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::bindPipelineState(GFXPipelineState* pso)
|
||||
{
|
||||
CCVKGPUPipelineState* gpuPipelineState = ((CCVKPipelineState*)pso)->gpuPipelineState();
|
||||
void CCVKCommandBuffer::bindPipelineState(GFXPipelineState *pso) {
|
||||
CCVKGPUPipelineState *gpuPipelineState = ((CCVKPipelineState *)pso)->gpuPipelineState();
|
||||
|
||||
if (_curGPUPipelineState != gpuPipelineState)
|
||||
{
|
||||
if (_curGPUPipelineState != gpuPipelineState) {
|
||||
vkCmdBindPipeline(_gpuCommandBuffer->vkCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, gpuPipelineState->vkPipeline);
|
||||
_curGPUPipelineState = gpuPipelineState;
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::bindBindingLayout(GFXBindingLayout* layout)
|
||||
{
|
||||
if (!_curGPUPipelineState)
|
||||
{
|
||||
void CCVKCommandBuffer::bindBindingLayout(GFXBindingLayout *layout) {
|
||||
if (!_curGPUPipelineState) {
|
||||
CC_LOG_ERROR("Command 'bindBindingLayout' must be recorded after 'bindPipelineState'.");
|
||||
return;
|
||||
}
|
||||
|
||||
CCVKGPUBindingLayout* gpuBindingLayout = ((CCVKBindingLayout*)layout)->gpuBindingLayout();
|
||||
CCVKGPUBindingLayout *gpuBindingLayout = ((CCVKBindingLayout *)layout)->gpuBindingLayout();
|
||||
|
||||
if (_curGPUBindingLayout != gpuBindingLayout)
|
||||
{
|
||||
if (_curGPUBindingLayout != gpuBindingLayout) {
|
||||
vkCmdBindDescriptorSets(_gpuCommandBuffer->vkCommandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
|
||||
_curGPUPipelineState->gpuLayout->vkPipelineLayout, 0, 1, &gpuBindingLayout->vkDescriptorSet, 0, nullptr);
|
||||
_curGPUPipelineState->gpuLayout->vkPipelineLayout, 0, 1, &gpuBindingLayout->vkDescriptorSet, 0, nullptr);
|
||||
_curGPUBindingLayout = gpuBindingLayout;
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::bindInputAssembler(GFXInputAssembler* ia)
|
||||
{
|
||||
CCVKGPUInputAssembler* gpuInputAssembler = ((CCVKInputAssembler*)ia)->gpuInputAssembler();
|
||||
void CCVKCommandBuffer::bindInputAssembler(GFXInputAssembler *ia) {
|
||||
CCVKGPUInputAssembler *gpuInputAssembler = ((CCVKInputAssembler *)ia)->gpuInputAssembler();
|
||||
|
||||
if (_curGPUInputAssember != gpuInputAssembler)
|
||||
{
|
||||
if (_curGPUInputAssember != gpuInputAssembler) {
|
||||
// buffers may be rebuilt(e.g. resize event) without IA's acknowledge
|
||||
size_t vbCount = gpuInputAssembler->gpuVertexBuffers.size();
|
||||
if (gpuInputAssembler->vertexBuffers.size() < vbCount)
|
||||
{
|
||||
if (gpuInputAssembler->vertexBuffers.size() < vbCount) {
|
||||
gpuInputAssembler->vertexBuffers.resize(vbCount);
|
||||
gpuInputAssembler->vertexBufferOffsets.resize(vbCount);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < vbCount; i++)
|
||||
{
|
||||
for (size_t i = 0; i < vbCount; i++) {
|
||||
gpuInputAssembler->vertexBuffers[i] = gpuInputAssembler->gpuVertexBuffers[i]->vkBuffer;
|
||||
gpuInputAssembler->vertexBufferOffsets[i] = gpuInputAssembler->gpuVertexBuffers[i]->startOffset;
|
||||
}
|
||||
|
||||
vkCmdBindVertexBuffers(_gpuCommandBuffer->vkCommandBuffer, 0, vbCount,
|
||||
gpuInputAssembler->vertexBuffers.data(), gpuInputAssembler->vertexBufferOffsets.data());
|
||||
gpuInputAssembler->vertexBuffers.data(), gpuInputAssembler->vertexBufferOffsets.data());
|
||||
|
||||
if (gpuInputAssembler->gpuIndexBuffer)
|
||||
{
|
||||
if (gpuInputAssembler->gpuIndexBuffer) {
|
||||
vkCmdBindIndexBuffer(_gpuCommandBuffer->vkCommandBuffer, gpuInputAssembler->gpuIndexBuffer->vkBuffer, 0,
|
||||
gpuInputAssembler->gpuIndexBuffer->stride == 32 ? VK_INDEX_TYPE_UINT32 : VK_INDEX_TYPE_UINT16);
|
||||
gpuInputAssembler->gpuIndexBuffer->stride == 32 ? VK_INDEX_TYPE_UINT32 : VK_INDEX_TYPE_UINT16);
|
||||
}
|
||||
_curGPUInputAssember = gpuInputAssembler;
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::setViewport(const GFXViewport& vp)
|
||||
{
|
||||
if (_curViewport != vp)
|
||||
{
|
||||
void CCVKCommandBuffer::setViewport(const GFXViewport &vp) {
|
||||
if (_curViewport != vp) {
|
||||
_curViewport = vp;
|
||||
VkViewport viewport{ (float)vp.left, (float)vp.top, (float)vp.width, (float)vp.height, vp.minDepth, vp.maxDepth };
|
||||
VkViewport viewport{(float)vp.left, (float)vp.top, (float)vp.width, (float)vp.height, vp.minDepth, vp.maxDepth};
|
||||
vkCmdSetViewport(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &viewport);
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::setScissor(const GFXRect& rect)
|
||||
{
|
||||
if (_curScissor != rect)
|
||||
{
|
||||
void CCVKCommandBuffer::setScissor(const GFXRect &rect) {
|
||||
if (_curScissor != rect) {
|
||||
_curScissor = rect;
|
||||
VkRect2D scissor{ { rect.x, rect.y }, { rect.width, rect.height } };
|
||||
VkRect2D scissor{{rect.x, rect.y}, {rect.width, rect.height}};
|
||||
vkCmdSetScissor(_gpuCommandBuffer->vkCommandBuffer, 0, 1, &scissor);
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::setLineWidth(const float width)
|
||||
{
|
||||
if (math::IsNotEqualF(_curLineWidth, width))
|
||||
{
|
||||
void CCVKCommandBuffer::setLineWidth(const float width) {
|
||||
if (math::IsNotEqualF(_curLineWidth, width)) {
|
||||
_curLineWidth = width;
|
||||
vkCmdSetLineWidth(_gpuCommandBuffer->vkCommandBuffer, width);
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::setDepthBias(float constant, float clamp, float slope)
|
||||
{
|
||||
void CCVKCommandBuffer::setDepthBias(float constant, float clamp, float slope) {
|
||||
if (math::IsNotEqualF(_curDepthBias.constant, constant) ||
|
||||
math::IsNotEqualF(_curDepthBias.clamp, clamp) ||
|
||||
math::IsNotEqualF(_curDepthBias.slope, slope))
|
||||
{
|
||||
math::IsNotEqualF(_curDepthBias.slope, slope)) {
|
||||
_curDepthBias.constant = constant;
|
||||
_curDepthBias.clamp = clamp;
|
||||
_curDepthBias.slope = slope;
|
||||
@@ -271,50 +236,42 @@ void CCVKCommandBuffer::setDepthBias(float constant, float clamp, float slope)
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::setBlendConstants(const GFXColor& constants)
|
||||
{
|
||||
void CCVKCommandBuffer::setBlendConstants(const GFXColor &constants) {
|
||||
if (math::IsNotEqualF(_curBlendConstants.r, constants.r) ||
|
||||
math::IsNotEqualF(_curBlendConstants.g, constants.g) ||
|
||||
math::IsNotEqualF(_curBlendConstants.b, constants.b) ||
|
||||
math::IsNotEqualF(_curBlendConstants.a, constants.a))
|
||||
{
|
||||
math::IsNotEqualF(_curBlendConstants.a, constants.a)) {
|
||||
_curBlendConstants.r = constants.r;
|
||||
_curBlendConstants.g = constants.g;
|
||||
_curBlendConstants.b = constants.b;
|
||||
_curBlendConstants.a = constants.a;
|
||||
vkCmdSetBlendConstants(_gpuCommandBuffer->vkCommandBuffer, reinterpret_cast<const float*>(&constants));
|
||||
vkCmdSetBlendConstants(_gpuCommandBuffer->vkCommandBuffer, reinterpret_cast<const float *>(&constants));
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::setDepthBound(float minBounds, float maxBounds)
|
||||
{
|
||||
void CCVKCommandBuffer::setDepthBound(float minBounds, float maxBounds) {
|
||||
if (math::IsNotEqualF(_curDepthBounds.minBounds, minBounds) ||
|
||||
math::IsNotEqualF(_curDepthBounds.maxBounds, maxBounds))
|
||||
{
|
||||
math::IsNotEqualF(_curDepthBounds.maxBounds, maxBounds)) {
|
||||
_curDepthBounds.minBounds = minBounds;
|
||||
_curDepthBounds.maxBounds = maxBounds;
|
||||
vkCmdSetDepthBounds(_gpuCommandBuffer->vkCommandBuffer, minBounds, maxBounds);
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::setStencilWriteMask(GFXStencilFace face, uint mask)
|
||||
{
|
||||
void CCVKCommandBuffer::setStencilWriteMask(GFXStencilFace face, uint mask) {
|
||||
if ((_curStencilWriteMask.face != face) ||
|
||||
(_curStencilWriteMask.write_mask != mask))
|
||||
{
|
||||
(_curStencilWriteMask.write_mask != mask)) {
|
||||
_curStencilWriteMask.face = face;
|
||||
_curStencilWriteMask.write_mask = mask;
|
||||
vkCmdSetStencilWriteMask(_gpuCommandBuffer->vkCommandBuffer,
|
||||
face == GFXStencilFace::FRONT ? VK_STENCIL_FACE_FRONT_BIT : VK_STENCIL_FACE_BACK_BIT, mask);
|
||||
face == GFXStencilFace::FRONT ? VK_STENCIL_FACE_FRONT_BIT : VK_STENCIL_FACE_BACK_BIT, mask);
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::setStencilCompareMask(GFXStencilFace face, int reference, uint mask)
|
||||
{
|
||||
void CCVKCommandBuffer::setStencilCompareMask(GFXStencilFace face, int reference, uint mask) {
|
||||
if ((_curStencilCompareMask.face != face) ||
|
||||
(_curStencilCompareMask.reference != reference) ||
|
||||
(_curStencilCompareMask.compareMask != mask))
|
||||
{
|
||||
(_curStencilCompareMask.compareMask != mask)) {
|
||||
_curStencilCompareMask.face = face;
|
||||
_curStencilCompareMask.reference = reference;
|
||||
_curStencilCompareMask.compareMask = mask;
|
||||
@@ -325,68 +282,56 @@ void CCVKCommandBuffer::setStencilCompareMask(GFXStencilFace face, int reference
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::draw(GFXInputAssembler* ia)
|
||||
{
|
||||
void CCVKCommandBuffer::draw(GFXInputAssembler *ia) {
|
||||
if ((_type == GFXCommandBufferType::PRIMARY && _curGPUFBO) ||
|
||||
(_type == GFXCommandBufferType::SECONDARY))
|
||||
{
|
||||
CCVKGPUInputAssembler* gpuInputAssembler = ((CCVKInputAssembler*)ia)->gpuInputAssembler();
|
||||
(_type == GFXCommandBufferType::SECONDARY)) {
|
||||
CCVKGPUInputAssembler *gpuInputAssembler = ((CCVKInputAssembler *)ia)->gpuInputAssembler();
|
||||
GFXDrawInfo drawInfo;
|
||||
|
||||
if (gpuInputAssembler->gpuIndirectBuffer)
|
||||
{
|
||||
if (gpuInputAssembler->gpuIndirectBuffer) {
|
||||
// TODO
|
||||
}
|
||||
else
|
||||
{
|
||||
((CCVKInputAssembler*)ia)->extractDrawInfo(drawInfo);
|
||||
} else {
|
||||
((CCVKInputAssembler *)ia)->extractDrawInfo(drawInfo);
|
||||
uint instanceCount = std::max(drawInfo.instanceCount, 1u);
|
||||
bool hasIndexBuffer = gpuInputAssembler->gpuIndexBuffer && drawInfo.indexCount >= 0;
|
||||
|
||||
if (hasIndexBuffer)
|
||||
{
|
||||
if (hasIndexBuffer) {
|
||||
vkCmdDrawIndexed(_gpuCommandBuffer->vkCommandBuffer, drawInfo.indexCount, instanceCount,
|
||||
drawInfo.firstIndex, drawInfo.vertexOffset, drawInfo.firstInstance);
|
||||
}
|
||||
else
|
||||
{
|
||||
drawInfo.firstIndex, drawInfo.vertexOffset, drawInfo.firstInstance);
|
||||
} else {
|
||||
vkCmdDraw(_gpuCommandBuffer->vkCommandBuffer, drawInfo.vertexCount, instanceCount,
|
||||
drawInfo.firstVertex, drawInfo.firstInstance);
|
||||
drawInfo.firstVertex, drawInfo.firstInstance);
|
||||
}
|
||||
|
||||
++_numDrawCalls;
|
||||
_numInstances += drawInfo.instanceCount;
|
||||
if (_curGPUPipelineState)
|
||||
{
|
||||
if (_curGPUPipelineState) {
|
||||
uint indexCount = hasIndexBuffer ? drawInfo.indexCount : drawInfo.vertexCount;
|
||||
switch (_curGPUPipelineState->primitive)
|
||||
{
|
||||
case GFXPrimitiveMode::TRIANGLE_LIST:
|
||||
_numTriangles += indexCount / 3 * instanceCount;
|
||||
break;
|
||||
case GFXPrimitiveMode::TRIANGLE_STRIP:
|
||||
case GFXPrimitiveMode::TRIANGLE_FAN:
|
||||
_numTriangles += (indexCount - 2) * instanceCount;
|
||||
break;
|
||||
switch (_curGPUPipelineState->primitive) {
|
||||
case GFXPrimitiveMode::TRIANGLE_LIST:
|
||||
_numTriangles += indexCount / 3 * instanceCount;
|
||||
break;
|
||||
case GFXPrimitiveMode::TRIANGLE_STRIP:
|
||||
case GFXPrimitiveMode::TRIANGLE_FAN:
|
||||
_numTriangles += (indexCount - 2) * instanceCount;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
CC_LOG_ERROR("Command 'draw' must be recorded inside a render pass.");
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::execute(const std::vector<GFXCommandBuffer*>& cmdBuffs, uint count)
|
||||
{
|
||||
if (!count) { return; }
|
||||
void CCVKCommandBuffer::execute(const std::vector<GFXCommandBuffer *> &cmdBuffs, uint count) {
|
||||
if (!count) {
|
||||
return;
|
||||
}
|
||||
|
||||
vector<VkCommandBuffer>::type vkCmdBuffs(count);
|
||||
|
||||
for (uint i = 0; i < count; ++i)
|
||||
{
|
||||
CCVKCommandBuffer* cmdBuff = (CCVKCommandBuffer*)cmdBuffs[i];
|
||||
for (uint i = 0; i < count; ++i) {
|
||||
CCVKCommandBuffer *cmdBuff = (CCVKCommandBuffer *)cmdBuffs[i];
|
||||
vkCmdBuffs[i] = cmdBuff->_gpuCommandBuffer->vkCommandBuffer;
|
||||
|
||||
_numDrawCalls += cmdBuff->getNumDrawCalls();
|
||||
@@ -397,31 +342,23 @@ void CCVKCommandBuffer::execute(const std::vector<GFXCommandBuffer*>& cmdBuffs,
|
||||
vkCmdExecuteCommands(_gpuCommandBuffer->vkCommandBuffer, count, vkCmdBuffs.data());
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::updateBuffer(GFXBuffer* buff, void* data, uint size, uint offset)
|
||||
{
|
||||
void CCVKCommandBuffer::updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset) {
|
||||
if ((_type == GFXCommandBufferType::PRIMARY && !_curGPUFBO) ||
|
||||
(_type == GFXCommandBufferType::SECONDARY))
|
||||
{
|
||||
CCVKCmdFuncUpdateBuffer((CCVKDevice*)_device, ((CCVKBuffer*)buff)->gpuBuffer(), data, offset, size);
|
||||
}
|
||||
else
|
||||
{
|
||||
(_type == GFXCommandBufferType::SECONDARY)) {
|
||||
CCVKCmdFuncUpdateBuffer((CCVKDevice *)_device, ((CCVKBuffer *)buff)->gpuBuffer(), data, offset, size);
|
||||
} else {
|
||||
CC_LOG_ERROR("Command 'updateBuffer' must be recorded outside a render pass.");
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKCommandBuffer::copyBufferToTexture(GFXBuffer* src, GFXTexture* dst, GFXTextureLayout layout, const GFXBufferTextureCopyList& regions)
|
||||
{
|
||||
void CCVKCommandBuffer::copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions) {
|
||||
if ((_type == GFXCommandBufferType::PRIMARY && !_curGPUFBO) ||
|
||||
(_type == GFXCommandBufferType::SECONDARY))
|
||||
{
|
||||
(_type == GFXCommandBufferType::SECONDARY)) {
|
||||
//const CCVKGPUBuffer* gpuBuffer = ((CCVKBuffer*)src)->gpuBuffer();
|
||||
//const CCVKGPUTexture* gpuTexture = ((CCVKTexture*)dst)->gpuTexture();
|
||||
//vkCmdCopyBufferToImage(_gpuCommandBuffer->vkCommandBuffer, gpuBuffer->vkBuffer, gpuTexture->vkImage, MapVkImageLayout(layout),
|
||||
// regions.size(), regions.data());
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
CC_LOG_ERROR("Command 'copyBufferToTexture' must be recorded outside a render pass.");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,47 +5,46 @@
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
class CC_VULKAN_API CCVKCommandBuffer : public GFXCommandBuffer
|
||||
{
|
||||
class CC_VULKAN_API CCVKCommandBuffer : public GFXCommandBuffer {
|
||||
public:
|
||||
CCVKCommandBuffer(GFXDevice* device);
|
||||
CCVKCommandBuffer(GFXDevice *device);
|
||||
~CCVKCommandBuffer();
|
||||
|
||||
friend class CCVKQueue;
|
||||
|
||||
public:
|
||||
bool initialize(const GFXCommandBufferInfo& info);
|
||||
bool initialize(const GFXCommandBufferInfo &info);
|
||||
void destroy();
|
||||
|
||||
void begin(GFXRenderPass* renderPass = nullptr, uint subpass = 0, GFXFramebuffer* frameBuffer = nullptr);
|
||||
void begin(GFXRenderPass *renderPass = nullptr, uint subpass = 0, GFXFramebuffer *frameBuffer = nullptr);
|
||||
void end();
|
||||
void beginRenderPass(GFXFramebuffer* fbo, const GFXRect& render_area, GFXClearFlags clear_flags, const std::vector<GFXColor>& colors, float depth, int stencil);
|
||||
void beginRenderPass(GFXFramebuffer *fbo, const GFXRect &render_area, GFXClearFlags clear_flags, const std::vector<GFXColor> &colors, float depth, int stencil);
|
||||
void endRenderPass();
|
||||
void bindPipelineState(GFXPipelineState* pso);
|
||||
void bindBindingLayout(GFXBindingLayout* layout);
|
||||
void bindInputAssembler(GFXInputAssembler* ia);
|
||||
void setViewport(const GFXViewport& vp);
|
||||
void setScissor(const GFXRect& rect);
|
||||
void bindPipelineState(GFXPipelineState *pso);
|
||||
void bindBindingLayout(GFXBindingLayout *layout);
|
||||
void bindInputAssembler(GFXInputAssembler *ia);
|
||||
void setViewport(const GFXViewport &vp);
|
||||
void setScissor(const GFXRect &rect);
|
||||
void setLineWidth(const float width);
|
||||
void setDepthBias(float constant, float clamp, float slope);
|
||||
void setBlendConstants(const GFXColor& constants);
|
||||
void setBlendConstants(const GFXColor &constants);
|
||||
void setDepthBound(float min_bounds, float max_bounds);
|
||||
void setStencilWriteMask(GFXStencilFace face, uint mask);
|
||||
void setStencilCompareMask(GFXStencilFace face, int reference, uint mask);
|
||||
void draw(GFXInputAssembler* ia);
|
||||
void updateBuffer(GFXBuffer* buff, void* data, uint size, uint offset);
|
||||
void copyBufferToTexture(GFXBuffer* src, GFXTexture* dst, GFXTextureLayout layout, const GFXBufferTextureCopyList& regions);
|
||||
void execute(const std::vector<GFXCommandBuffer*>& cmd_buffs, uint count);
|
||||
void draw(GFXInputAssembler *ia);
|
||||
void updateBuffer(GFXBuffer *buff, void *data, uint size, uint offset);
|
||||
void copyBufferToTexture(GFXBuffer *src, GFXTexture *dst, GFXTextureLayout layout, const GFXBufferTextureCopyList ®ions);
|
||||
void execute(const std::vector<GFXCommandBuffer *> &cmd_buffs, uint count);
|
||||
|
||||
CCVKGPUCommandBuffer* gpuCommandBuffer() const { return _gpuCommandBuffer; }
|
||||
CCVKGPUCommandBuffer *gpuCommandBuffer() const { return _gpuCommandBuffer; }
|
||||
|
||||
private:
|
||||
CCVKGPUCommandBuffer* _gpuCommandBuffer = nullptr;
|
||||
CCVKGPUCommandBuffer *_gpuCommandBuffer = nullptr;
|
||||
|
||||
CCVKGPUPipelineState* _curGPUPipelineState = nullptr;
|
||||
CCVKGPUBindingLayout* _curGPUBindingLayout = nullptr;
|
||||
CCVKGPUInputAssembler* _curGPUInputAssember = nullptr;
|
||||
CCVKGPUFramebuffer* _curGPUFBO = nullptr;
|
||||
CCVKGPUPipelineState *_curGPUPipelineState = nullptr;
|
||||
CCVKGPUBindingLayout *_curGPUBindingLayout = nullptr;
|
||||
CCVKGPUInputAssembler *_curGPUInputAssember = nullptr;
|
||||
CCVKGPUFramebuffer *_curGPUFBO = nullptr;
|
||||
|
||||
GFXViewport _curViewport;
|
||||
GFXRect _curScissor;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -7,65 +7,61 @@ NS_CC_BEGIN
|
||||
|
||||
class CCVKDevice;
|
||||
|
||||
struct CCVKDepthBias
|
||||
{
|
||||
struct CCVKDepthBias {
|
||||
float constant = 0.0f;
|
||||
float clamp = 0.0f;
|
||||
float slope = 0.0f;
|
||||
};
|
||||
|
||||
struct CCVKDepthBounds
|
||||
{
|
||||
struct CCVKDepthBounds {
|
||||
float minBounds = 0.0f;
|
||||
float maxBounds = 0.0f;
|
||||
};
|
||||
|
||||
struct CCVKStencilWriteMask
|
||||
{
|
||||
struct CCVKStencilWriteMask {
|
||||
GFXStencilFace face = GFXStencilFace::FRONT;
|
||||
uint32_t write_mask = 0;
|
||||
};
|
||||
|
||||
struct CCVKStencilCompareMask
|
||||
{
|
||||
struct CCVKStencilCompareMask {
|
||||
GFXStencilFace face = GFXStencilFace::FRONT;
|
||||
int reference = 0;
|
||||
uint32_t compareMask = 0;
|
||||
};
|
||||
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRenderPass);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyRenderPass(CCVKDevice* device, CCVKGPURenderPass* gpuRenderPass);
|
||||
CC_VULKAN_API void CCVKCmdFuncGetDeviceQueue(CCVKDevice* device, CCVKGPUQueue* gpuQueue);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateCommandPool(CCVKDevice* device, CCVKGPUCommandPool* gpuCommandPool);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyCommandPool(CCVKDevice* device, CCVKGPUCommandPool* gpuCommandPool);
|
||||
CC_VULKAN_API void CCVKCmdFuncAllocateCommandBuffer(CCVKDevice* device, CCVKGPUCommandBuffer* gpuCommandBuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncFreeCommandBuffer(CCVKDevice* device, CCVKGPUCommandBuffer* gpuCommandBuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRenderPass);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRenderPass);
|
||||
CC_VULKAN_API void CCVKCmdFuncGetDeviceQueue(CCVKDevice *device, CCVKGPUQueue *gpuQueue);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateCommandPool(CCVKDevice *device, CCVKGPUCommandPool *gpuCommandPool);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyCommandPool(CCVKDevice *device, CCVKGPUCommandPool *gpuCommandPool);
|
||||
CC_VULKAN_API void CCVKCmdFuncAllocateCommandBuffer(CCVKDevice *device, CCVKGPUCommandBuffer *gpuCommandBuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncFreeCommandBuffer(CCVKDevice *device, CCVKGPUCommandBuffer *gpuCommandBuffer);
|
||||
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncResizeBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncUpdateBuffer(CCVKDevice* device, CCVKGPUBuffer* gpuBuffer, void* buffer, uint offset, uint size);
|
||||
CC_VULKAN_API bool CCVKCmdFuncCreateTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateTextureView(CCVKDevice* device, CCVKGPUTextureView* gpuTextureView);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyTextureView(CCVKDevice* device, CCVKGPUTextureView* gpuTextureView);
|
||||
CC_VULKAN_API void CCVKCmdFuncResizeTexture(CCVKDevice* device, CCVKGPUTexture* gpuTexture);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateSampler(CCVKDevice* device, CCVKGPUSampler* gpuSampler);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroySampler(CCVKDevice* device, CCVKGPUSampler* gpuSampler);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateShader(CCVKDevice* device, CCVKGPUShader* gpuShader);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyShader(CCVKDevice* device, CCVKGPUShader* gpuShader);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateInputAssembler(CCVKDevice* device, CCVKGPUInputAssembler* gpuInputAssembler);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyInputAssembler(CCVKDevice* device, CCVKGPUInputAssembler* gpuInputAssembler);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateFramebuffer(CCVKDevice* device, CCVKGPUFramebuffer* gpuFramebuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyFramebuffer(CCVKDevice* device, CCVKGPUFramebuffer* gpuFramebuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* gpuBindingLayout, GFXBindingUnitList bindings);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyBindingLayout(CCVKDevice* device, CCVKGPUBindingLayout* gpuBindingLayout);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreatePipelineLayout(CCVKDevice* device, CCVKGPUPipelineLayout* gpuPipelineLayout);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyPipelineLayout(CCVKDevice* device, CCVKGPUPipelineLayout* gpuPipelineLayout);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreatePipelineState(CCVKDevice* device, CCVKGPUPipelineState* gpuPipelineState);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyPipelineState(CCVKDevice* device, CCVKGPUPipelineState* gpuPipelineState);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncResizeBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncUpdateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer, void *buffer, uint offset, uint size);
|
||||
CC_VULKAN_API bool CCVKCmdFuncCreateTexture(CCVKDevice *device, CCVKGPUTexture *gpuTexture);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyTexture(CCVKDevice *device, CCVKGPUTexture *gpuTexture);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateTextureView(CCVKDevice *device, CCVKGPUTextureView *gpuTextureView);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyTextureView(CCVKDevice *device, CCVKGPUTextureView *gpuTextureView);
|
||||
CC_VULKAN_API void CCVKCmdFuncResizeTexture(CCVKDevice *device, CCVKGPUTexture *gpuTexture);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateSampler(CCVKDevice *device, CCVKGPUSampler *gpuSampler);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroySampler(CCVKDevice *device, CCVKGPUSampler *gpuSampler);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateShader(CCVKDevice *device, CCVKGPUShader *gpuShader);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyShader(CCVKDevice *device, CCVKGPUShader *gpuShader);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateInputAssembler(CCVKDevice *device, CCVKGPUInputAssembler *gpuInputAssembler);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyInputAssembler(CCVKDevice *device, CCVKGPUInputAssembler *gpuInputAssembler);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateFramebuffer(CCVKDevice *device, CCVKGPUFramebuffer *gpuFramebuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyFramebuffer(CCVKDevice *device, CCVKGPUFramebuffer *gpuFramebuffer);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreateBindingLayout(CCVKDevice *device, CCVKGPUBindingLayout *gpuBindingLayout, GFXBindingUnitList bindings);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyBindingLayout(CCVKDevice *device, CCVKGPUBindingLayout *gpuBindingLayout);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreatePipelineLayout(CCVKDevice *device, CCVKGPUPipelineLayout *gpuPipelineLayout);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyPipelineLayout(CCVKDevice *device, CCVKGPUPipelineLayout *gpuPipelineLayout);
|
||||
CC_VULKAN_API void CCVKCmdFuncCreatePipelineState(CCVKDevice *device, CCVKGPUPipelineState *gpuPipelineState);
|
||||
CC_VULKAN_API void CCVKCmdFuncDestroyPipelineState(CCVKDevice *device, CCVKGPUPipelineState *gpuPipelineState);
|
||||
|
||||
CC_VULKAN_API void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice* device, uint8_t* const* buffers, CCVKGPUTexture* gpuTexture, const GFXBufferTextureCopyList& regions);
|
||||
CC_VULKAN_API void CCVKCmdFuncCopyBuffersToTexture(CCVKDevice *device, uint8_t *const *buffers, CCVKGPUTexture *gpuTexture, const GFXBufferTextureCopyList ®ions);
|
||||
|
||||
NS_CC_END
|
||||
|
||||
|
||||
@@ -1,73 +1,59 @@
|
||||
#include "VKStd.h"
|
||||
|
||||
#include "VKContext.h"
|
||||
#include "VKUtils.h"
|
||||
#include "VKGPUObjects.h"
|
||||
#include "VKDevice.h"
|
||||
#include "VKGPUObjects.h"
|
||||
#include "VKRenderPass.h"
|
||||
#include "VKTexture.h"
|
||||
#include "VKTextureView.h"
|
||||
#include "VKUtils.h"
|
||||
|
||||
#define CC_GFX_DEBUG
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
namespace
|
||||
{
|
||||
namespace {
|
||||
#ifdef CC_GFX_DEBUG
|
||||
VKAPI_ATTR VkBool32 VKAPI_CALL debugUtilsMessengerCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
|
||||
VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT *callbackData, void * user_data)
|
||||
{
|
||||
// https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/1818
|
||||
if (!strcmp(callbackData->pMessageIdName, "VUID-vkQueuePresentKHR-pWaitSemaphores-03268"))
|
||||
{
|
||||
return VK_FALSE;
|
||||
}
|
||||
// TODO: handle the few frames with no command submission at start up
|
||||
if (!strcmp(callbackData->pMessageIdName, "VUID-VkPresentInfoKHR-pImageIndices-01296"))
|
||||
{
|
||||
return VK_FALSE;
|
||||
}
|
||||
|
||||
// Log debug messge
|
||||
if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT)
|
||||
{
|
||||
CC_LOG_WARNING("%s: %s", callbackData->pMessageIdName, callbackData->pMessage);
|
||||
}
|
||||
else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT)
|
||||
{
|
||||
CC_LOG_ERROR("%s: %s", callbackData->pMessageIdName, callbackData->pMessage);
|
||||
CCASSERT(0, "Validation Error");
|
||||
}
|
||||
VKAPI_ATTR VkBool32 VKAPI_CALL debugUtilsMessengerCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
|
||||
VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT *callbackData, void *user_data) {
|
||||
// https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/1818
|
||||
if (!strcmp(callbackData->pMessageIdName, "VUID-vkQueuePresentKHR-pWaitSemaphores-03268")) {
|
||||
return VK_FALSE;
|
||||
}
|
||||
// TODO: handle the few frames with no command submission at start up
|
||||
if (!strcmp(callbackData->pMessageIdName, "VUID-VkPresentInfoKHR-pImageIndices-01296")) {
|
||||
return VK_FALSE;
|
||||
}
|
||||
|
||||
VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallback(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT type,
|
||||
uint64_t object, size_t location, int32_t messageCode, const char *layerPrefix, const char *message, void *userData)
|
||||
{
|
||||
if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
|
||||
{
|
||||
CC_LOG_ERROR("VError: %s: %s", layerPrefix, message);
|
||||
CCASSERT(0, "Validation Error");
|
||||
}
|
||||
else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT)
|
||||
{
|
||||
CC_LOG_ERROR("VWarning: %s: %s", layerPrefix, message);
|
||||
}
|
||||
else if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT)
|
||||
{
|
||||
CC_LOG_INFO("VPerfWarning: %s: %s", layerPrefix, message);
|
||||
}
|
||||
else
|
||||
{
|
||||
CC_LOG_INFO("VInfo: %s: %s", layerPrefix, message);
|
||||
}
|
||||
return VK_FALSE;
|
||||
// Log debug messge
|
||||
if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT) {
|
||||
CC_LOG_WARNING("%s: %s", callbackData->pMessageIdName, callbackData->pMessage);
|
||||
} else if (messageSeverity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) {
|
||||
CC_LOG_ERROR("%s: %s", callbackData->pMessageIdName, callbackData->pMessage);
|
||||
CCASSERT(0, "Validation Error");
|
||||
}
|
||||
#endif
|
||||
return VK_FALSE;
|
||||
}
|
||||
|
||||
CCVKContext::CCVKContext(GFXDevice* device)
|
||||
: GFXContext(device){
|
||||
VKAPI_ATTR VkBool32 VKAPI_CALL debugReportCallback(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT type,
|
||||
uint64_t object, size_t location, int32_t messageCode, const char *layerPrefix, const char *message, void *userData) {
|
||||
if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
|
||||
CC_LOG_ERROR("VError: %s: %s", layerPrefix, message);
|
||||
CCASSERT(0, "Validation Error");
|
||||
} else if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
|
||||
CC_LOG_ERROR("VWarning: %s: %s", layerPrefix, message);
|
||||
} else if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) {
|
||||
CC_LOG_INFO("VPerfWarning: %s: %s", layerPrefix, message);
|
||||
} else {
|
||||
CC_LOG_INFO("VInfo: %s: %s", layerPrefix, message);
|
||||
}
|
||||
return VK_FALSE;
|
||||
}
|
||||
#endif
|
||||
} // namespace
|
||||
|
||||
CCVKContext::CCVKContext(GFXDevice *device)
|
||||
: GFXContext(device) {
|
||||
}
|
||||
|
||||
CCVKContext::~CCVKContext() {
|
||||
@@ -78,28 +64,24 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
_vsyncMode = info.vsyncMode;
|
||||
_windowHandle = info.windowHandle;
|
||||
|
||||
if (!info.sharedCtx)
|
||||
{
|
||||
if (!info.sharedCtx) {
|
||||
_isPrimaryContex = true;
|
||||
_windowHandle = info.windowHandle;
|
||||
|
||||
_gpuContext = CC_NEW(CCVKGPUContext);
|
||||
|
||||
// only enable the absolute essentials for now
|
||||
vector<const char *>::type requestedLayers
|
||||
{
|
||||
vector<const char *>::type requestedLayers{
|
||||
|
||||
};
|
||||
vector<const char *>::type requestedExtensions
|
||||
{
|
||||
vector<const char *>::type requestedExtensions{
|
||||
VK_KHR_SURFACE_EXTENSION_NAME,
|
||||
VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME,
|
||||
};
|
||||
|
||||
///////////////////// Instance Creation /////////////////////
|
||||
|
||||
if (volkInitialize())
|
||||
{
|
||||
if (volkInitialize()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -126,13 +108,12 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
#elif defined(VK_USE_PLATFORM_XCB_KHR)
|
||||
requestedExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
|
||||
#else
|
||||
# pragma error Platform not supported
|
||||
#pragma error Platform not supported
|
||||
#endif
|
||||
|
||||
#ifdef CC_GFX_DEBUG
|
||||
// Determine the optimal validation layers to enable that are necessary for useful debugging
|
||||
vector<vector<const char*>::type>::type validationLayerPriorityList
|
||||
{
|
||||
vector<vector<const char *>::type>::type validationLayerPriorityList{
|
||||
// The preferred validation layer is "VK_LAYER_KHRONOS_validation"
|
||||
{"VK_LAYER_KHRONOS_validation"},
|
||||
|
||||
@@ -149,21 +130,16 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
},
|
||||
|
||||
// Otherwise as a last resort we fallback to attempting to enable the LunarG core layer
|
||||
{"VK_LAYER_LUNARG_core_validation"}
|
||||
};
|
||||
for (vector<const char*>::type &validationLayers : validationLayerPriorityList)
|
||||
{
|
||||
{"VK_LAYER_LUNARG_core_validation"}};
|
||||
for (vector<const char *>::type &validationLayers : validationLayerPriorityList) {
|
||||
bool found = true;
|
||||
for (const char* layer : validationLayers)
|
||||
{
|
||||
if (!isLayerSupported(layer, supportedLayers))
|
||||
{
|
||||
for (const char *layer : validationLayers) {
|
||||
if (!isLayerSupported(layer, supportedLayers)) {
|
||||
found = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (found)
|
||||
{
|
||||
if (found) {
|
||||
requestedLayers.insert(requestedLayers.end(), validationLayers.begin(), validationLayers.end());
|
||||
break;
|
||||
}
|
||||
@@ -171,29 +147,22 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
|
||||
// Check if VK_EXT_debug_utils is supported, which supersedes VK_EXT_Debug_Report
|
||||
bool debugUtils = false;
|
||||
if (isExtensionSupported(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, supportedExtensions))
|
||||
{
|
||||
if (isExtensionSupported(VK_EXT_DEBUG_UTILS_EXTENSION_NAME, supportedExtensions)) {
|
||||
debugUtils = true;
|
||||
requestedExtensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
requestedExtensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
|
||||
}
|
||||
#endif
|
||||
|
||||
// just filter out the unsupported layers & extensions
|
||||
for (const char* layer : requestedLayers)
|
||||
{
|
||||
if (isLayerSupported(layer, supportedLayers))
|
||||
{
|
||||
for (const char *layer : requestedLayers) {
|
||||
if (isLayerSupported(layer, supportedLayers)) {
|
||||
_layers.push_back(layer);
|
||||
}
|
||||
}
|
||||
for (const char* extension : requestedExtensions)
|
||||
{
|
||||
if (isExtensionSupported(extension, supportedExtensions))
|
||||
{
|
||||
for (const char *extension : requestedExtensions) {
|
||||
if (isExtensionSupported(extension, supportedExtensions)) {
|
||||
_extensions.push_back(extension);
|
||||
}
|
||||
}
|
||||
@@ -205,11 +174,11 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
_majorVersion = VK_VERSION_MAJOR(apiVersion);
|
||||
_minorVersion = VK_VERSION_MINOR(apiVersion);
|
||||
|
||||
VkApplicationInfo app{ VK_STRUCTURE_TYPE_APPLICATION_INFO };
|
||||
VkApplicationInfo app{VK_STRUCTURE_TYPE_APPLICATION_INFO};
|
||||
app.pEngineName = "Cocos Creator";
|
||||
app.apiVersion = apiVersion;
|
||||
|
||||
VkInstanceCreateInfo instanceInfo{ VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO };
|
||||
VkInstanceCreateInfo instanceInfo{VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO};
|
||||
instanceInfo.pApplicationInfo = &app;
|
||||
instanceInfo.enabledExtensionCount = toUint(_extensions.size());
|
||||
instanceInfo.ppEnabledExtensionNames = _extensions.data();
|
||||
@@ -217,18 +186,15 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
instanceInfo.ppEnabledLayerNames = _layers.data();
|
||||
|
||||
#ifdef CC_GFX_DEBUG
|
||||
VkDebugUtilsMessengerCreateInfoEXT debugUtilsCreateInfo{ VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT };
|
||||
VkDebugReportCallbackCreateInfoEXT debugReportCreateInfo{ VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT };
|
||||
if (debugUtils)
|
||||
{
|
||||
VkDebugUtilsMessengerCreateInfoEXT debugUtilsCreateInfo{VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT};
|
||||
VkDebugReportCallbackCreateInfoEXT debugReportCreateInfo{VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT};
|
||||
if (debugUtils) {
|
||||
debugUtilsCreateInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT;
|
||||
debugUtilsCreateInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
|
||||
debugUtilsCreateInfo.pfnUserCallback = debugUtilsMessengerCallback;
|
||||
|
||||
instanceInfo.pNext = &debugUtilsCreateInfo;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
debugReportCreateInfo.flags = VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT;
|
||||
debugReportCreateInfo.pfnCallback = debugReportCallback;
|
||||
|
||||
@@ -242,12 +208,9 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
volkLoadInstance(_gpuContext->vkInstance);
|
||||
|
||||
#ifdef CC_GFX_DEBUG
|
||||
if (debugUtils)
|
||||
{
|
||||
if (debugUtils) {
|
||||
VK_CHECK(vkCreateDebugUtilsMessengerEXT(_gpuContext->vkInstance, &debugUtilsCreateInfo, nullptr, &_gpuContext->vkDebugUtilsMessenger));
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
VK_CHECK(vkCreateDebugReportCallbackEXT(_gpuContext->vkInstance, &debugReportCreateInfo, nullptr, &_gpuContext->vkDebugReport));
|
||||
}
|
||||
#endif
|
||||
@@ -255,44 +218,43 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
///////////////////// Surface Creation /////////////////////
|
||||
|
||||
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
|
||||
VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR };
|
||||
surfaceCreateInfo.window = (ANativeWindow*)_windowHandle;
|
||||
VkAndroidSurfaceCreateInfoKHR surfaceCreateInfo{VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR};
|
||||
surfaceCreateInfo.window = (ANativeWindow *)_windowHandle;
|
||||
VK_CHECK(vkCreateAndroidSurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
|
||||
#elif defined(VK_USE_PLATFORM_WIN32_KHR)
|
||||
VkWin32SurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR };
|
||||
VkWin32SurfaceCreateInfoKHR surfaceCreateInfo{VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR};
|
||||
surfaceCreateInfo.hinstance = (HINSTANCE)GetModuleHandle(0);
|
||||
surfaceCreateInfo.hwnd = (HWND)_windowHandle;
|
||||
VK_CHECK(vkCreateWin32SurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
|
||||
#elif defined(VK_USE_PLATFORM_IOS_MVK)
|
||||
VkIOSSurfaceCreateInfoMVK surfaceCreateInfo{ VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK };
|
||||
surfaceCreateInfo.pView = (void*)_windowHandle;
|
||||
VkIOSSurfaceCreateInfoMVK surfaceCreateInfo{VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK};
|
||||
surfaceCreateInfo.pView = (void *)_windowHandle;
|
||||
VK_CHECK(vkCreateIOSSurfaceMVK(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
|
||||
#elif defined(VK_USE_PLATFORM_MACOS_MVK)
|
||||
VkMacOSSurfaceCreateInfoMVK surfaceCreateInfo{ VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK };
|
||||
surfaceCreateInfo.pView = (void*)_windowHandle;
|
||||
VkMacOSSurfaceCreateInfoMVK surfaceCreateInfo{VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK};
|
||||
surfaceCreateInfo.pView = (void *)_windowHandle;
|
||||
VK_CHECK(vkCreateMacOSSurfaceMVK(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
|
||||
#elif defined(VK_USE_PLATFORM_WAYLAND_KHR)
|
||||
VkWaylandSurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR };
|
||||
VkWaylandSurfaceCreateInfoKHR surfaceCreateInfo{VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR};
|
||||
surfaceCreateInfo.display = nullptr; // TODO
|
||||
surfaceCreateInfo.surface = (wl_surface*)_windowHandle;
|
||||
surfaceCreateInfo.surface = (wl_surface *)_windowHandle;
|
||||
VK_CHECK(vkCreateWaylandSurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
|
||||
#elif defined(VK_USE_PLATFORM_XCB_KHR)
|
||||
VkXcbSurfaceCreateInfoKHR surfaceCreateInfo{ VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR };
|
||||
VkXcbSurfaceCreateInfoKHR surfaceCreateInfo{VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR};
|
||||
surfaceCreateInfo.connection = nullptr; // TODO
|
||||
surfaceCreateInfo.window = (xcb_window_t)_windowHandle;
|
||||
VK_CHECK(vkCreateXcbSurfaceKHR(_gpuContext->vkInstance, &surfaceCreateInfo, nullptr, &_gpuContext->vkSurface));
|
||||
#else
|
||||
# pragma error Platform not supported
|
||||
#pragma error Platform not supported
|
||||
#endif
|
||||
|
||||
///////////////////// Physical Device Selection /////////////////////
|
||||
|
||||
// Querying valid physical devices on the machine
|
||||
uint physicalDeviceCount{ 0 };
|
||||
uint physicalDeviceCount{0};
|
||||
VK_CHECK(vkEnumeratePhysicalDevices(_gpuContext->vkInstance, &physicalDeviceCount, nullptr));
|
||||
|
||||
if (physicalDeviceCount < 1)
|
||||
{
|
||||
if (physicalDeviceCount < 1) {
|
||||
return false;
|
||||
}
|
||||
|
||||
@@ -302,17 +264,14 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
vector<VkPhysicalDeviceProperties>::type physicalDeviceProperties(physicalDeviceCount);
|
||||
|
||||
uint deviceIndex;
|
||||
for (deviceIndex = 0u; deviceIndex < physicalDeviceCount; ++deviceIndex)
|
||||
{
|
||||
VkPhysicalDeviceProperties& properties = physicalDeviceProperties[deviceIndex];
|
||||
for (deviceIndex = 0u; deviceIndex < physicalDeviceCount; ++deviceIndex) {
|
||||
VkPhysicalDeviceProperties &properties = physicalDeviceProperties[deviceIndex];
|
||||
vkGetPhysicalDeviceProperties(physicalDeviceHandles[deviceIndex], &properties);
|
||||
}
|
||||
|
||||
for (deviceIndex = 0u; deviceIndex < physicalDeviceCount; ++deviceIndex)
|
||||
{
|
||||
VkPhysicalDeviceProperties& properties = physicalDeviceProperties[deviceIndex];
|
||||
if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
|
||||
{
|
||||
for (deviceIndex = 0u; deviceIndex < physicalDeviceCount; ++deviceIndex) {
|
||||
VkPhysicalDeviceProperties &properties = physicalDeviceProperties[deviceIndex];
|
||||
if (properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -322,8 +281,7 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
vkGetPhysicalDeviceFeatures(_gpuContext->physicalDevice, &_gpuContext->physicalDeviceFeatures);
|
||||
_gpuContext->physicalDeviceFeatures2.pNext = &_gpuContext->physicalDeviceVulkan11Features;
|
||||
_gpuContext->physicalDeviceVulkan11Features.pNext = &_gpuContext->physicalDeviceVulkan12Features;
|
||||
if (_minorVersion >= 1 || checkExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME))
|
||||
{
|
||||
if (_minorVersion >= 1 || checkExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
|
||||
vkGetPhysicalDeviceFeatures2(_gpuContext->physicalDevice, &_gpuContext->physicalDeviceFeatures2);
|
||||
}
|
||||
|
||||
@@ -333,10 +291,9 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
_gpuContext->queueFamilyProperties.resize(queueFamilyPropertiesCount);
|
||||
vkGetPhysicalDeviceQueueFamilyProperties(_gpuContext->physicalDevice, &queueFamilyPropertiesCount, _gpuContext->queueFamilyProperties.data());
|
||||
_gpuContext->queueFamilyPresentables.resize(queueFamilyPropertiesCount);
|
||||
for (uint propertyIndex = 0U; propertyIndex < queueFamilyPropertiesCount; propertyIndex++)
|
||||
{
|
||||
for (uint propertyIndex = 0U; propertyIndex < queueFamilyPropertiesCount; propertyIndex++) {
|
||||
vkGetPhysicalDeviceSurfaceSupportKHR(_gpuContext->physicalDevice, propertyIndex,
|
||||
_gpuContext->vkSurface, &_gpuContext->queueFamilyPresentables[propertyIndex]);
|
||||
_gpuContext->vkSurface, &_gpuContext->queueFamilyPresentables[propertyIndex]);
|
||||
}
|
||||
|
||||
///////////////////// Swapchain Preperation /////////////////////
|
||||
@@ -357,26 +314,21 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
vector<VkPresentModeKHR>::type presentModes(presentModeCount);
|
||||
VK_CHECK(vkGetPhysicalDeviceSurfacePresentModesKHR(_gpuContext->physicalDevice, _gpuContext->vkSurface, &presentModeCount, presentModes.data()));
|
||||
|
||||
VkExtent2D imageExtent{ 1u, 1u };
|
||||
VkExtent2D imageExtent{1u, 1u};
|
||||
|
||||
VkFormat colorFormat = VK_FORMAT_B8G8R8A8_UNORM;
|
||||
VkColorSpaceKHR colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
|
||||
// If the surface format list only includes one entry with VK_FORMAT_UNDEFINED,
|
||||
// there is no preferered format, so we assume VK_FORMAT_B8G8R8A8_UNORM
|
||||
if ((surfaceFormatCount == 1) && (surfaceFormats[0].format == VK_FORMAT_UNDEFINED))
|
||||
{
|
||||
if ((surfaceFormatCount == 1) && (surfaceFormats[0].format == VK_FORMAT_UNDEFINED)) {
|
||||
colorFormat = VK_FORMAT_B8G8R8A8_UNORM;
|
||||
colorSpace = surfaceFormats[0].colorSpace;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
// iterate over the list of available surface format and
|
||||
// check for the presence of VK_FORMAT_B8G8R8A8_UNORM
|
||||
bool imageFormatFound = false;
|
||||
for (VkSurfaceFormatKHR &surfaceFormat : surfaceFormats)
|
||||
{
|
||||
if (surfaceFormat.format == VK_FORMAT_B8G8R8A8_UNORM)
|
||||
{
|
||||
for (VkSurfaceFormatKHR &surfaceFormat : surfaceFormats) {
|
||||
if (surfaceFormat.format == VK_FORMAT_B8G8R8A8_UNORM) {
|
||||
colorFormat = surfaceFormat.format;
|
||||
colorSpace = surfaceFormat.colorSpace;
|
||||
imageFormatFound = true;
|
||||
@@ -386,30 +338,25 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
|
||||
// in case VK_FORMAT_B8G8R8A8_UNORM is not available
|
||||
// select the first available color format
|
||||
if (!imageFormatFound)
|
||||
{
|
||||
if (!imageFormatFound) {
|
||||
colorFormat = surfaceFormats[0].format;
|
||||
colorSpace = surfaceFormats[0].colorSpace;
|
||||
}
|
||||
}
|
||||
|
||||
vector<std::pair<GFXFormat, VkFormat>>::type depthFormatPriorityList =
|
||||
{
|
||||
{ GFXFormat::D32F_S8, VK_FORMAT_D32_SFLOAT_S8_UINT },
|
||||
{ GFXFormat::D24S8, VK_FORMAT_D24_UNORM_S8_UINT },
|
||||
{ GFXFormat::D16S8, VK_FORMAT_D16_UNORM_S8_UINT },
|
||||
{ GFXFormat::D32F, VK_FORMAT_D32_SFLOAT },
|
||||
{ GFXFormat::D16, VK_FORMAT_D16_UNORM }
|
||||
};
|
||||
for (std::pair<GFXFormat, VkFormat> &format : depthFormatPriorityList)
|
||||
{
|
||||
{
|
||||
{GFXFormat::D32F_S8, VK_FORMAT_D32_SFLOAT_S8_UINT},
|
||||
{GFXFormat::D24S8, VK_FORMAT_D24_UNORM_S8_UINT},
|
||||
{GFXFormat::D16S8, VK_FORMAT_D16_UNORM_S8_UINT},
|
||||
{GFXFormat::D32F, VK_FORMAT_D32_SFLOAT},
|
||||
{GFXFormat::D16, VK_FORMAT_D16_UNORM}};
|
||||
for (std::pair<GFXFormat, VkFormat> &format : depthFormatPriorityList) {
|
||||
VkFormatProperties formatProperties;
|
||||
vkGetPhysicalDeviceFormatProperties(_gpuContext->physicalDevice, format.second, &formatProperties);
|
||||
// Format must support depth stencil attachment for optimal tiling
|
||||
if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT)
|
||||
{
|
||||
if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)
|
||||
{
|
||||
if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) {
|
||||
if (formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) {
|
||||
_depthStencilFmt = format.first;
|
||||
break;
|
||||
}
|
||||
@@ -420,41 +367,34 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
|
||||
vector<VkPresentModeKHR>::type presentModePriorityList;
|
||||
|
||||
switch (_vsyncMode)
|
||||
{
|
||||
case GFXVsyncMode::OFF: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR }); break;
|
||||
case GFXVsyncMode::ON: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_FIFO_KHR }); break;
|
||||
case GFXVsyncMode::RELAXED: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_FIFO_RELAXED_KHR, VK_PRESENT_MODE_FIFO_KHR }); break;
|
||||
case GFXVsyncMode::MAILBOX: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR }); break;
|
||||
case GFXVsyncMode::HALF: presentModePriorityList.insert(presentModePriorityList.end(), { VK_PRESENT_MODE_FIFO_KHR }); break; // TODO
|
||||
switch (_vsyncMode) {
|
||||
case GFXVsyncMode::OFF: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR}); break;
|
||||
case GFXVsyncMode::ON: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_KHR}); break;
|
||||
case GFXVsyncMode::RELAXED: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_RELAXED_KHR, VK_PRESENT_MODE_FIFO_KHR}); break;
|
||||
case GFXVsyncMode::MAILBOX: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_MAILBOX_KHR, VK_PRESENT_MODE_IMMEDIATE_KHR, VK_PRESENT_MODE_FIFO_KHR}); break;
|
||||
case GFXVsyncMode::HALF: presentModePriorityList.insert(presentModePriorityList.end(), {VK_PRESENT_MODE_FIFO_KHR}); break; // TODO
|
||||
}
|
||||
|
||||
VkPresentModeKHR swapchainPresentMode = VK_PRESENT_MODE_FIFO_KHR;
|
||||
|
||||
for (VkPresentModeKHR presentMode : presentModePriorityList)
|
||||
{
|
||||
if (std::find(presentModes.begin(), presentModes.end(), presentMode) != presentModes.end())
|
||||
{
|
||||
for (VkPresentModeKHR presentMode : presentModePriorityList) {
|
||||
if (std::find(presentModes.begin(), presentModes.end(), presentMode) != presentModes.end()) {
|
||||
swapchainPresentMode = presentMode;
|
||||
}
|
||||
}
|
||||
|
||||
// Determine the number of images
|
||||
uint desiredNumberOfSwapchainImages = surfaceCapabilities.minImageCount + 1;
|
||||
if ((surfaceCapabilities.maxImageCount > 0) && (desiredNumberOfSwapchainImages > surfaceCapabilities.maxImageCount))
|
||||
{
|
||||
if ((surfaceCapabilities.maxImageCount > 0) && (desiredNumberOfSwapchainImages > surfaceCapabilities.maxImageCount)) {
|
||||
desiredNumberOfSwapchainImages = surfaceCapabilities.maxImageCount;
|
||||
}
|
||||
|
||||
// Find the transformation of the surface
|
||||
VkSurfaceTransformFlagBitsKHR preTransform;
|
||||
if (surfaceCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR)
|
||||
{
|
||||
if (surfaceCapabilities.supportedTransforms & VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR) {
|
||||
// We prefer a non-rotated transform
|
||||
preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
preTransform = surfaceCapabilities.currentTransform;
|
||||
}
|
||||
|
||||
@@ -467,24 +407,20 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR,
|
||||
VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR,
|
||||
};
|
||||
for (VkCompositeAlphaFlagBitsKHR compositeAlphaFlag : compositeAlphaFlags)
|
||||
{
|
||||
if (surfaceCapabilities.supportedCompositeAlpha & compositeAlphaFlag)
|
||||
{
|
||||
for (VkCompositeAlphaFlagBitsKHR compositeAlphaFlag : compositeAlphaFlags) {
|
||||
if (surfaceCapabilities.supportedCompositeAlpha & compositeAlphaFlag) {
|
||||
compositeAlpha = compositeAlphaFlag;
|
||||
break;
|
||||
};
|
||||
}
|
||||
VkImageUsageFlags imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
||||
// Enable transfer source on swap chain images if supported
|
||||
if (surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT)
|
||||
{
|
||||
if (surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_SRC_BIT) {
|
||||
imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
|
||||
}
|
||||
|
||||
// Enable transfer destination on swap chain images if supported
|
||||
if (surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT)
|
||||
{
|
||||
if (surfaceCapabilities.supportedUsageFlags & VK_IMAGE_USAGE_TRANSFER_DST_BIT) {
|
||||
imageUsage |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
||||
}
|
||||
|
||||
@@ -501,42 +437,36 @@ bool CCVKContext::initialize(const GFXContextInfo &info) {
|
||||
_gpuContext->swapchainCreateInfo.clipped = VK_TRUE; // Setting clipped to VK_TRUE allows the implementation to discard rendering outside of the surface area
|
||||
|
||||
} else {
|
||||
CCVKContext* sharedCtx = (CCVKContext*)info.sharedCtx;
|
||||
CCVKContext *sharedCtx = (CCVKContext *)info.sharedCtx;
|
||||
|
||||
_majorVersion = sharedCtx->majorVersion();
|
||||
_minorVersion = sharedCtx->minorVersion();
|
||||
_majorVersion = sharedCtx->majorVersion();
|
||||
_minorVersion = sharedCtx->minorVersion();
|
||||
|
||||
// TODO
|
||||
// TODO
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKContext::destroy()
|
||||
{
|
||||
if (_gpuContext)
|
||||
{
|
||||
if (_gpuContext->vkSurface != VK_NULL_HANDLE)
|
||||
{
|
||||
void CCVKContext::destroy() {
|
||||
if (_gpuContext) {
|
||||
if (_gpuContext->vkSurface != VK_NULL_HANDLE) {
|
||||
vkDestroySurfaceKHR(_gpuContext->vkInstance, _gpuContext->vkSurface, nullptr);
|
||||
_gpuContext->vkSurface = VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
#ifdef CC_GFX_DEBUG
|
||||
if (_gpuContext->vkDebugUtilsMessenger != VK_NULL_HANDLE)
|
||||
{
|
||||
if (_gpuContext->vkDebugUtilsMessenger != VK_NULL_HANDLE) {
|
||||
vkDestroyDebugUtilsMessengerEXT(_gpuContext->vkInstance, _gpuContext->vkDebugUtilsMessenger, nullptr);
|
||||
_gpuContext->vkDebugUtilsMessenger = VK_NULL_HANDLE;
|
||||
}
|
||||
if (_gpuContext->vkDebugReport != VK_NULL_HANDLE)
|
||||
{
|
||||
if (_gpuContext->vkDebugReport != VK_NULL_HANDLE) {
|
||||
vkDestroyDebugReportCallbackEXT(_gpuContext->vkInstance, _gpuContext->vkDebugReport, nullptr);
|
||||
_gpuContext->vkDebugReport = VK_NULL_HANDLE;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (_gpuContext->vkInstance != VK_NULL_HANDLE)
|
||||
{
|
||||
if (_gpuContext->vkInstance != VK_NULL_HANDLE) {
|
||||
vkDestroyInstance(_gpuContext->vkInstance, nullptr);
|
||||
_gpuContext->vkInstance = VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
@@ -11,7 +11,7 @@ class CCVKGPUSemaphorePool;
|
||||
|
||||
class CC_VULKAN_API CCVKContext : public GFXContext {
|
||||
public:
|
||||
CCVKContext(GFXDevice* device);
|
||||
CCVKContext(GFXDevice *device);
|
||||
~CCVKContext();
|
||||
|
||||
public:
|
||||
@@ -19,23 +19,21 @@ public:
|
||||
void destroy();
|
||||
void present() {}
|
||||
|
||||
CC_INLINE bool checkExtension(const String &extension) const
|
||||
{
|
||||
CC_INLINE bool checkExtension(const String &extension) const {
|
||||
return std::find_if(_extensions.begin(), _extensions.end(),
|
||||
[extension](const char* device_extension)
|
||||
{
|
||||
return std::strcmp(device_extension, extension.c_str()) == 0;
|
||||
}) != _extensions.end();
|
||||
[extension](const char *device_extension) {
|
||||
return std::strcmp(device_extension, extension.c_str()) == 0;
|
||||
}) != _extensions.end();
|
||||
}
|
||||
|
||||
CC_INLINE int majorVersion() const { return _majorVersion; }
|
||||
CC_INLINE int minorVersion() const { return _minorVersion; }
|
||||
CC_INLINE CCVKGPUContext* gpuContext() { return _gpuContext; }
|
||||
CC_INLINE const vector<const char *>::type& getLayers() const { return _layers; }
|
||||
CC_INLINE const vector<const char *>::type& getExtensions() const { return _extensions; }
|
||||
CC_INLINE CCVKGPUContext *gpuContext() { return _gpuContext; }
|
||||
CC_INLINE const vector<const char *>::type &getLayers() const { return _layers; }
|
||||
CC_INLINE const vector<const char *>::type &getExtensions() const { return _extensions; }
|
||||
|
||||
private:
|
||||
CCVKGPUContext* _gpuContext = nullptr;
|
||||
CCVKGPUContext *_gpuContext = nullptr;
|
||||
bool _isPrimaryContex = false;
|
||||
int _majorVersion = 0;
|
||||
int _minorVersion = 0;
|
||||
|
||||
@@ -1,23 +1,24 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKDevice.h"
|
||||
#include "VKUtils.h"
|
||||
#include "VKContext.h"
|
||||
#include "VKWindow.h"
|
||||
#include "VKFence.h"
|
||||
#include "VKQueue.h"
|
||||
|
||||
#include "VKBindingLayout.h"
|
||||
#include "VKBuffer.h"
|
||||
#include "VKCommandAllocator.h"
|
||||
#include "VKCommandBuffer.h"
|
||||
#include "VKBuffer.h"
|
||||
#include "VKTexture.h"
|
||||
#include "VKTextureView.h"
|
||||
#include "VKSampler.h"
|
||||
#include "VKShader.h"
|
||||
#include "VKInputAssembler.h"
|
||||
#include "VKRenderPass.h"
|
||||
#include "VKContext.h"
|
||||
#include "VKDevice.h"
|
||||
#include "VKFence.h"
|
||||
#include "VKFramebuffer.h"
|
||||
#include "VKBindingLayout.h"
|
||||
#include "VKInputAssembler.h"
|
||||
#include "VKPipelineLayout.h"
|
||||
#include "VKPipelineState.h"
|
||||
#include "VKQueue.h"
|
||||
#include "VKRenderPass.h"
|
||||
#include "VKSampler.h"
|
||||
#include "VKShader.h"
|
||||
#include "VKTexture.h"
|
||||
#include "VKTextureView.h"
|
||||
#include "VKUtils.h"
|
||||
#include "VKWindow.h"
|
||||
|
||||
CC_DISABLE_WARNINGS()
|
||||
#define VMA_IMPLEMENTATION
|
||||
@@ -26,23 +27,19 @@ CC_ENABLE_WARNINGS()
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKDevice::CCVKDevice()
|
||||
{
|
||||
CCVKDevice::CCVKDevice() {
|
||||
_minClipZ = 0.0f;
|
||||
_projectionSignY = -1.0f;
|
||||
}
|
||||
|
||||
CCVKDevice::~CCVKDevice()
|
||||
{
|
||||
CCVKDevice::~CCVKDevice() {
|
||||
}
|
||||
|
||||
CCVKGPUContext* CCVKDevice::gpuContext() const
|
||||
{
|
||||
return ((CCVKContext*)_context)->gpuContext();
|
||||
CCVKGPUContext *CCVKDevice::gpuContext() const {
|
||||
return ((CCVKContext *)_context)->gpuContext();
|
||||
}
|
||||
|
||||
bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
{
|
||||
bool CCVKDevice::initialize(const GFXDeviceInfo &info) {
|
||||
_gfxAPI = GFXAPI::VULKAN;
|
||||
_deviceName = "Vulkan";
|
||||
_width = info.width;
|
||||
@@ -56,32 +53,29 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
contextCreateInfo.sharedCtx = info.sharedCtx;
|
||||
|
||||
_context = CC_NEW(CCVKContext(this));
|
||||
if (!_context->initialize(contextCreateInfo))
|
||||
{
|
||||
if (!_context->initialize(contextCreateInfo)) {
|
||||
destroy();
|
||||
return false;
|
||||
}
|
||||
const CCVKContext* context = (CCVKContext*)_context;
|
||||
const CCVKGPUContext* gpuContext = ((CCVKContext*)_context)->gpuContext();
|
||||
const CCVKContext *context = (CCVKContext *)_context;
|
||||
const CCVKGPUContext *gpuContext = ((CCVKContext *)_context)->gpuContext();
|
||||
const VkPhysicalDeviceFeatures &deviceFeatures = gpuContext->physicalDeviceFeatures;
|
||||
const VkPhysicalDeviceFeatures2 &deviceFeatures2 = gpuContext->physicalDeviceFeatures2;
|
||||
const VkPhysicalDeviceVulkan11Features &deviceVulkan11Features = gpuContext->physicalDeviceVulkan11Features;
|
||||
const VkPhysicalDeviceVulkan12Features &deviceVulkan12Features = gpuContext->physicalDeviceVulkan12Features;
|
||||
|
||||
// only enable the absolute essentials for now
|
||||
std::vector<const char *> requestedValidationLayers
|
||||
{
|
||||
std::vector<const char *> requestedValidationLayers{
|
||||
"VK_LAYER_KHRONOS_validation",
|
||||
};
|
||||
std::vector<const char *> requestedExtensions
|
||||
{
|
||||
std::vector<const char *> requestedExtensions{
|
||||
VK_KHR_SWAPCHAIN_EXTENSION_NAME,
|
||||
VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME,
|
||||
VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME,
|
||||
};
|
||||
VkPhysicalDeviceFeatures2 requestedFeatures2{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 };
|
||||
VkPhysicalDeviceVulkan11Features requestedVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES };
|
||||
VkPhysicalDeviceVulkan12Features requestedVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES };
|
||||
VkPhysicalDeviceFeatures2 requestedFeatures2{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2};
|
||||
VkPhysicalDeviceVulkan11Features requestedVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES};
|
||||
VkPhysicalDeviceVulkan12Features requestedVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES};
|
||||
// features should be enabled like this:
|
||||
requestedFeatures2.features.textureCompressionASTC_LDR = deviceFeatures2.features.textureCompressionASTC_LDR;
|
||||
requestedFeatures2.features.textureCompressionBC = deviceFeatures2.features.textureCompressionBC;
|
||||
@@ -104,28 +98,23 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
VK_CHECK(vkEnumerateDeviceExtensionProperties(gpuContext->physicalDevice, nullptr, &availableExtensionCount, _gpuDevice->extensions.data()));
|
||||
|
||||
// just filter out the unsupported layers & extensions
|
||||
for (const char* layer : requestedValidationLayers)
|
||||
{
|
||||
if (isLayerSupported(layer, _gpuDevice->layers))
|
||||
{
|
||||
for (const char *layer : requestedValidationLayers) {
|
||||
if (isLayerSupported(layer, _gpuDevice->layers)) {
|
||||
_layers.push_back(layer);
|
||||
}
|
||||
}
|
||||
for (const char* extension : requestedExtensions)
|
||||
{
|
||||
if (isExtensionSupported(extension, _gpuDevice->extensions))
|
||||
{
|
||||
for (const char *extension : requestedExtensions) {
|
||||
if (isExtensionSupported(extension, _gpuDevice->extensions)) {
|
||||
_extensions.push_back(extension);
|
||||
}
|
||||
}
|
||||
|
||||
// prepare the device queues
|
||||
uint queueFamilyPropertiesCount = toUint(gpuContext->queueFamilyProperties.size());
|
||||
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos(queueFamilyPropertiesCount, { VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO });
|
||||
std::vector<std::vector<float>> queuePriorities(queueFamilyPropertiesCount);
|
||||
uint queueFamilyPropertiesCount = toUint(gpuContext->queueFamilyProperties.size());
|
||||
std::vector<VkDeviceQueueCreateInfo> queueCreateInfos(queueFamilyPropertiesCount, {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO});
|
||||
std::vector<std::vector<float>> queuePriorities(queueFamilyPropertiesCount);
|
||||
|
||||
for (uint queueFamilyIndex = 0u; queueFamilyIndex < queueFamilyPropertiesCount; ++queueFamilyIndex)
|
||||
{
|
||||
for (uint queueFamilyIndex = 0u; queueFamilyIndex < queueFamilyPropertiesCount; ++queueFamilyIndex) {
|
||||
const VkQueueFamilyProperties &queueFamilyProperty = gpuContext->queueFamilyProperties[queueFamilyIndex];
|
||||
|
||||
queuePriorities[queueFamilyIndex].resize(queueFamilyProperty.queueCount, 1.0f);
|
||||
@@ -137,7 +126,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
queueCreateInfo.pQueuePriorities = queuePriorities[queueFamilyIndex].data();
|
||||
}
|
||||
|
||||
VkDeviceCreateInfo deviceCreateInfo{ VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO };
|
||||
VkDeviceCreateInfo deviceCreateInfo{VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO};
|
||||
|
||||
deviceCreateInfo.queueCreateInfoCount = toUint(queueCreateInfos.size());
|
||||
deviceCreateInfo.pQueueCreateInfos = queueCreateInfos.data();
|
||||
@@ -146,12 +135,9 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
deviceCreateInfo.enabledExtensionCount = toUint(_extensions.size());
|
||||
deviceCreateInfo.ppEnabledExtensionNames = _extensions.data();
|
||||
if (context->minorVersion() < 1 &&
|
||||
!context->checkExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME))
|
||||
{
|
||||
!context->checkExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) {
|
||||
deviceCreateInfo.pEnabledFeatures = &requestedFeatures2.features;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
deviceCreateInfo.pNext = &requestedFeatures2;
|
||||
if (context->minorVersion() >= 1) requestedFeatures2.pNext = &requestedVulkan11Features;
|
||||
if (context->minorVersion() >= 2) requestedVulkan11Features.pNext = &requestedVulkan12Features;
|
||||
@@ -178,15 +164,14 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
vmaVulkanFunc.vkInvalidateMappedMemoryRanges = vkInvalidateMappedMemoryRanges;
|
||||
vmaVulkanFunc.vkMapMemory = vkMapMemory;
|
||||
vmaVulkanFunc.vkUnmapMemory = vkUnmapMemory;
|
||||
|
||||
|
||||
VmaAllocatorCreateInfo allocatorInfo{};
|
||||
allocatorInfo.physicalDevice = gpuContext->physicalDevice;
|
||||
allocatorInfo.device = _gpuDevice->vkDevice;
|
||||
allocatorInfo.instance = gpuContext->vkInstance;
|
||||
|
||||
if (checkExtension(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME) &&
|
||||
checkExtension(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME))
|
||||
{
|
||||
if (checkExtension(VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME) &&
|
||||
checkExtension(VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME)) {
|
||||
allocatorInfo.flags |= VMA_ALLOCATOR_CREATE_KHR_DEDICATED_ALLOCATION_BIT;
|
||||
vmaVulkanFunc.vkGetBufferMemoryRequirements2KHR = vkGetBufferMemoryRequirements2KHR;
|
||||
vmaVulkanFunc.vkGetImageMemoryRequirements2KHR = vkGetImageMemoryRequirements2KHR;
|
||||
@@ -204,7 +189,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
stagingBufferInfo.memUsage = GFXMemoryUsage::HOST;
|
||||
stagingBufferInfo.stride = _defaultStagingBufferSize;
|
||||
stagingBufferInfo.size = _defaultStagingBufferSize;
|
||||
_stagingBuffer = (CCVKBuffer*)createBuffer(stagingBufferInfo);
|
||||
_stagingBuffer = (CCVKBuffer *)createBuffer(stagingBufferInfo);
|
||||
|
||||
GFXQueueInfo queueInfo;
|
||||
queueInfo.type = GFXQueueType::GRAPHICS;
|
||||
@@ -213,22 +198,21 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
GFXCommandAllocatorInfo cmdAllocInfo;
|
||||
_cmdAllocator = createCommandAllocator(cmdAllocInfo);
|
||||
|
||||
for (uint i = 0; i < gpuContext->swapchainCreateInfo.minImageCount; i++)
|
||||
{
|
||||
for (uint i = 0; i < gpuContext->swapchainCreateInfo.minImageCount; i++) {
|
||||
GFXTextureInfo depthStecnilTexInfo;
|
||||
depthStecnilTexInfo.type = GFXTextureType::TEX2D;
|
||||
depthStecnilTexInfo.usage = GFXTextureUsageBit::DEPTH_STENCIL_ATTACHMENT | GFXTextureUsageBit::SAMPLED;
|
||||
depthStecnilTexInfo.format = _context->getDepthStencilFormat();
|
||||
depthStecnilTexInfo.width = 1;
|
||||
depthStecnilTexInfo.height = 1;
|
||||
CCVKTexture* texture = (CCVKTexture*)createTexture(depthStecnilTexInfo);
|
||||
CCVKTexture *texture = (CCVKTexture *)createTexture(depthStecnilTexInfo);
|
||||
_depthStencilTextures.push_back(texture);
|
||||
|
||||
GFXTextureViewInfo depthStecnilTexViewInfo;
|
||||
depthStecnilTexViewInfo.texture = texture;
|
||||
depthStecnilTexViewInfo.type = GFXTextureViewType::TV2D;
|
||||
depthStecnilTexViewInfo.format = _context->getDepthStencilFormat();
|
||||
CCVKTextureView* textureView = (CCVKTextureView*)createTextureView(depthStecnilTexViewInfo);
|
||||
CCVKTextureView *textureView = (CCVKTextureView *)createTextureView(depthStecnilTexViewInfo);
|
||||
_depthStencilTextureViews.push_back(textureView);
|
||||
}
|
||||
|
||||
@@ -242,7 +226,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
colorAttachment.endLayout = GFXTextureLayout::PRESENT_SRC;
|
||||
renderPassInfo.colorAttachments.emplace_back(colorAttachment);
|
||||
|
||||
GFXDepthStencilAttachment& depthStencilAttachment = renderPassInfo.depthStencilAttachment;
|
||||
GFXDepthStencilAttachment &depthStencilAttachment = renderPassInfo.depthStencilAttachment;
|
||||
depthStencilAttachment.format = _context->getDepthStencilFormat();
|
||||
depthStencilAttachment.depthLoadOp = GFXLoadOp::CLEAR;
|
||||
depthStencilAttachment.depthStoreOp = GFXStoreOp::STORE;
|
||||
@@ -252,7 +236,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
depthStencilAttachment.beginLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||
depthStencilAttachment.endLayout = GFXTextureLayout::PRESENT_SRC;
|
||||
|
||||
_renderPass = (CCVKRenderPass*)createRenderPass(renderPassInfo);
|
||||
_renderPass = (CCVKRenderPass *)createRenderPass(renderPassInfo);
|
||||
_gpuSwapchain = CC_NEW(CCVKGPUSwapchain);
|
||||
_gpuSwapchain->renderPass = _renderPass->gpuRenderPass();
|
||||
|
||||
@@ -264,21 +248,38 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
windowInfo.isOffscreen = false;
|
||||
_window = createWindow(windowInfo);
|
||||
|
||||
GFXTextureInfo textureInfo;
|
||||
GFXTextureViewInfo texViewInfo;
|
||||
|
||||
textureInfo.usage = GFXTextureUsageBit::SAMPLED;
|
||||
textureInfo.format = GFXFormat::RGBA8;
|
||||
textureInfo.width = 2;
|
||||
textureInfo.height = 2;
|
||||
GFXTexture *nullTexture2D = createTexture(textureInfo);
|
||||
|
||||
texViewInfo.texture = nullTexture2D;
|
||||
texViewInfo.format = GFXFormat::RGBA8;
|
||||
nullTexView2D = (CCVKTextureView *)createTextureView(texViewInfo);
|
||||
|
||||
textureInfo.arrayLayer = 6;
|
||||
textureInfo.flags = GFXTextureFlagBit::CUBEMAP;
|
||||
GFXTexture *nullTextureCube = createTexture(textureInfo);
|
||||
|
||||
texViewInfo.texture = nullTextureCube;
|
||||
texViewInfo.layerCount = 6;
|
||||
nullTexViewCube = (CCVKTextureView *)createTextureView(texViewInfo);
|
||||
|
||||
String instanceLayers, instanceExtensions, deviceLayers, deviceExtensions;
|
||||
for (const char* layer : ((CCVKContext*)_context)->getLayers())
|
||||
{
|
||||
for (const char *layer : ((CCVKContext *)_context)->getLayers()) {
|
||||
instanceLayers += layer + String(" ");
|
||||
}
|
||||
for (const char* extension : ((CCVKContext*)_context)->getExtensions())
|
||||
{
|
||||
for (const char *extension : ((CCVKContext *)_context)->getExtensions()) {
|
||||
instanceExtensions += extension + String(" ");
|
||||
}
|
||||
for (const char* layer : _layers)
|
||||
{
|
||||
for (const char *layer : _layers) {
|
||||
deviceLayers += layer + String(" ");
|
||||
}
|
||||
for (const char* extension : _extensions)
|
||||
{
|
||||
for (const char *extension : _extensions) {
|
||||
deviceExtensions += extension + String(" ");
|
||||
}
|
||||
|
||||
@@ -295,13 +296,11 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
_features[(int)GFXFeature::INSTANCED_ARRAYS] = true;
|
||||
|
||||
String compressedFmts;
|
||||
if (deviceFeatures.textureCompressionETC2)
|
||||
{
|
||||
if (deviceFeatures.textureCompressionETC2) {
|
||||
_features[(int)GFXFeature::FORMAT_ETC2] = true;
|
||||
compressedFmts += "etc2 ";
|
||||
}
|
||||
if (deviceFeatures.textureCompressionASTC_LDR)
|
||||
{
|
||||
if (deviceFeatures.textureCompressionASTC_LDR) {
|
||||
_features[(int)GFXFeature::FORMAT_ASTC] = true;
|
||||
compressedFmts += "astc ";
|
||||
}
|
||||
@@ -310,7 +309,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
_renderer = gpuContext->physicalDeviceProperties.deviceName;
|
||||
_vendor = MapVendorName(gpuContext->physicalDeviceProperties.vendorID);
|
||||
_version = StringUtil::Format("%d.%d.%d", VK_VERSION_MAJOR(apiVersion),
|
||||
VK_VERSION_MINOR(apiVersion), VK_VERSION_PATCH(apiVersion));
|
||||
VK_VERSION_MINOR(apiVersion), VK_VERSION_PATCH(apiVersion));
|
||||
|
||||
CC_LOG_INFO("Vulkan device initialized.");
|
||||
CC_LOG_INFO("RENDERER: %s", _renderer.c_str());
|
||||
@@ -327,8 +326,7 @@ bool CCVKDevice::initialize(const GFXDeviceInfo& info)
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKDevice::destroy()
|
||||
{
|
||||
void CCVKDevice::destroy() {
|
||||
CC_SAFE_DESTROY(_cmdAllocator);
|
||||
CC_SAFE_DESTROY(_queue);
|
||||
CC_SAFE_DESTROY(_stagingBuffer);
|
||||
@@ -337,32 +335,26 @@ void CCVKDevice::destroy()
|
||||
CC_SAFE_DELETE(_gpuSemaphorePool);
|
||||
CC_SAFE_DELETE(_gpuFencePool);
|
||||
|
||||
for (CCVKTextureView* textureView : _depthStencilTextureViews)
|
||||
{
|
||||
for (CCVKTextureView *textureView : _depthStencilTextureViews) {
|
||||
CC_SAFE_DESTROY(textureView);
|
||||
}
|
||||
_depthStencilTextureViews.clear();
|
||||
for (CCVKTexture* texture : _depthStencilTextures)
|
||||
{
|
||||
for (CCVKTexture *texture : _depthStencilTextures) {
|
||||
CC_SAFE_DESTROY(texture);
|
||||
}
|
||||
_depthStencilTextures.clear();
|
||||
|
||||
if (_gpuSwapchain)
|
||||
{
|
||||
if (_gpuSwapchain->vkSwapchain != VK_NULL_HANDLE)
|
||||
{
|
||||
if (_gpuSwapchain) {
|
||||
if (_gpuSwapchain->vkSwapchain != VK_NULL_HANDLE) {
|
||||
_gpuSwapchain->depthStencilImageViews.clear();
|
||||
_gpuSwapchain->depthStencilImages.clear();
|
||||
|
||||
for (VkFramebuffer framebuffer : _gpuSwapchain->vkSwapchainFramebuffers)
|
||||
{
|
||||
for (VkFramebuffer framebuffer : _gpuSwapchain->vkSwapchainFramebuffers) {
|
||||
vkDestroyFramebuffer(_gpuDevice->vkDevice, framebuffer, nullptr);
|
||||
}
|
||||
_gpuSwapchain->vkSwapchainFramebuffers.clear();
|
||||
|
||||
for (VkImageView imageView : _gpuSwapchain->vkSwapchainImageViews)
|
||||
{
|
||||
for (VkImageView imageView : _gpuSwapchain->vkSwapchainImageViews) {
|
||||
vkDestroyImageView(_gpuDevice->vkDevice, imageView, nullptr);
|
||||
}
|
||||
_gpuSwapchain->vkSwapchainImageViews.clear();
|
||||
@@ -376,10 +368,8 @@ void CCVKDevice::destroy()
|
||||
_gpuSwapchain = nullptr;
|
||||
}
|
||||
|
||||
if (_gpuDevice)
|
||||
{
|
||||
if (_gpuDevice->memoryAllocator != VK_NULL_HANDLE)
|
||||
{
|
||||
if (_gpuDevice) {
|
||||
if (_gpuDevice->memoryAllocator != VK_NULL_HANDLE) {
|
||||
VmaStats stats;
|
||||
vmaCalculateStats(_gpuDevice->memoryAllocator, &stats);
|
||||
CC_LOG_INFO("Total device memory leaked: %d bytes.", stats.total.usedBytes);
|
||||
@@ -388,8 +378,7 @@ void CCVKDevice::destroy()
|
||||
_gpuDevice->memoryAllocator = VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
if (_gpuDevice->vkDevice != VK_NULL_HANDLE)
|
||||
{
|
||||
if (_gpuDevice->vkDevice != VK_NULL_HANDLE) {
|
||||
vkDestroyDevice(_gpuDevice->vkDevice, nullptr);
|
||||
_gpuDevice->vkDevice = VK_NULL_HANDLE;
|
||||
}
|
||||
@@ -401,17 +390,15 @@ void CCVKDevice::destroy()
|
||||
CC_SAFE_DESTROY(_context);
|
||||
}
|
||||
|
||||
void CCVKDevice::resize(uint width, uint height)
|
||||
{
|
||||
void CCVKDevice::resize(uint width, uint height) {
|
||||
_width = width;
|
||||
_height = height;
|
||||
buildSwapchain();
|
||||
_window->resize(_width, _height);
|
||||
}
|
||||
|
||||
void CCVKDevice::buildSwapchain()
|
||||
{
|
||||
CCVKGPUContext* context = ((CCVKContext*)_context)->gpuContext();
|
||||
void CCVKDevice::buildSwapchain() {
|
||||
CCVKGPUContext *context = ((CCVKContext *)_context)->gpuContext();
|
||||
context->swapchainCreateInfo.oldSwapchain = _gpuSwapchain->vkSwapchain;
|
||||
_gpuSwapchain->curImageIndex = 0;
|
||||
|
||||
@@ -419,36 +406,29 @@ void CCVKDevice::buildSwapchain()
|
||||
VK_CHECK(vkGetPhysicalDeviceSurfaceCapabilitiesKHR(context->physicalDevice, context->vkSurface, &surfaceCapabilities));
|
||||
|
||||
if (context->swapchainCreateInfo.imageExtent.width == surfaceCapabilities.currentExtent.width &&
|
||||
context->swapchainCreateInfo.imageExtent.height == surfaceCapabilities.currentExtent.height)
|
||||
{
|
||||
context->swapchainCreateInfo.imageExtent.height == surfaceCapabilities.currentExtent.height) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (surfaceCapabilities.currentExtent.width == (uint)-1)
|
||||
{
|
||||
if (surfaceCapabilities.currentExtent.width == (uint)-1) {
|
||||
context->swapchainCreateInfo.imageExtent.width = _width;
|
||||
context->swapchainCreateInfo.imageExtent.height = _height;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
_width = context->swapchainCreateInfo.imageExtent.width = surfaceCapabilities.currentExtent.width;
|
||||
_height = context->swapchainCreateInfo.imageExtent.height = surfaceCapabilities.currentExtent.height;
|
||||
}
|
||||
VK_CHECK(vkCreateSwapchainKHR(_gpuDevice->vkDevice, &context->swapchainCreateInfo, nullptr, &_gpuSwapchain->vkSwapchain));
|
||||
|
||||
if (context->swapchainCreateInfo.oldSwapchain != VK_NULL_HANDLE)
|
||||
{
|
||||
if (context->swapchainCreateInfo.oldSwapchain != VK_NULL_HANDLE) {
|
||||
_gpuSwapchain->depthStencilImageViews.clear();
|
||||
_gpuSwapchain->depthStencilImages.clear();
|
||||
|
||||
for (VkFramebuffer framebuffer : _gpuSwapchain->vkSwapchainFramebuffers)
|
||||
{
|
||||
for (VkFramebuffer framebuffer : _gpuSwapchain->vkSwapchainFramebuffers) {
|
||||
vkDestroyFramebuffer(_gpuDevice->vkDevice, framebuffer, nullptr);
|
||||
}
|
||||
_gpuSwapchain->vkSwapchainFramebuffers.clear();
|
||||
|
||||
for (VkImageView imageView : _gpuSwapchain->vkSwapchainImageViews)
|
||||
{
|
||||
for (VkImageView imageView : _gpuSwapchain->vkSwapchainImageViews) {
|
||||
vkDestroyImageView(_gpuDevice->vkDevice, imageView, nullptr);
|
||||
}
|
||||
_gpuSwapchain->vkSwapchainImageViews.clear();
|
||||
@@ -465,10 +445,9 @@ void CCVKDevice::buildSwapchain()
|
||||
|
||||
_gpuSwapchain->vkSwapchainImageViews.resize(imageCount);
|
||||
_gpuSwapchain->vkSwapchainFramebuffers.resize(imageCount);
|
||||
for (uint i = 0; i < imageCount; i++)
|
||||
{
|
||||
for (uint i = 0; i < imageCount; i++) {
|
||||
_depthStencilTextures[i]->resize(_width, _height);
|
||||
_gpuSwapchain->depthStencilImages.push_back(((CCVKTexture*)_depthStencilTextures[i])->gpuTexture()->vkImage);
|
||||
_gpuSwapchain->depthStencilImages.push_back(((CCVKTexture *)_depthStencilTextures[i])->gpuTexture()->vkImage);
|
||||
|
||||
_depthStencilTextureViews[i]->destroy();
|
||||
GFXTextureViewInfo textureViewInfo;
|
||||
@@ -476,9 +455,9 @@ void CCVKDevice::buildSwapchain()
|
||||
textureViewInfo.type = GFXTextureViewType::TV2D;
|
||||
textureViewInfo.format = _context->getDepthStencilFormat();
|
||||
_depthStencilTextureViews[i]->initialize(textureViewInfo);
|
||||
_gpuSwapchain->depthStencilImageViews.push_back(((CCVKTextureView*)_depthStencilTextureViews[i])->gpuTexView()->vkImageView);
|
||||
_gpuSwapchain->depthStencilImageViews.push_back(((CCVKTextureView *)_depthStencilTextureViews[i])->gpuTexView()->vkImageView);
|
||||
|
||||
VkImageViewCreateInfo imageViewCreateInfo{ VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO };
|
||||
VkImageViewCreateInfo imageViewCreateInfo{VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
|
||||
imageViewCreateInfo.image = _gpuSwapchain->swapchainImages[i];
|
||||
imageViewCreateInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
||||
imageViewCreateInfo.format = context->swapchainCreateInfo.imageFormat;
|
||||
@@ -488,9 +467,9 @@ void CCVKDevice::buildSwapchain()
|
||||
|
||||
VK_CHECK(vkCreateImageView(_gpuDevice->vkDevice, &imageViewCreateInfo, nullptr, &_gpuSwapchain->vkSwapchainImageViews[i]));
|
||||
|
||||
VkImageView attachments[] = { _gpuSwapchain->vkSwapchainImageViews[i], _depthStencilTextureViews[i]->gpuTexView()->vkImageView };
|
||||
VkImageView attachments[] = {_gpuSwapchain->vkSwapchainImageViews[i], _depthStencilTextureViews[i]->gpuTexView()->vkImageView};
|
||||
|
||||
VkFramebufferCreateInfo framebufferCreateInfo{ VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO };
|
||||
VkFramebufferCreateInfo framebufferCreateInfo{VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO};
|
||||
framebufferCreateInfo.renderPass = _renderPass->gpuRenderPass()->vkRenderPass;
|
||||
framebufferCreateInfo.attachmentCount = COUNTOF(attachments);
|
||||
framebufferCreateInfo.pAttachments = attachments;
|
||||
@@ -502,19 +481,18 @@ void CCVKDevice::buildSwapchain()
|
||||
}
|
||||
}
|
||||
|
||||
void CCVKDevice::acquire()
|
||||
{
|
||||
void CCVKDevice::acquire() {
|
||||
VK_CHECK(vkDeviceWaitIdle(_gpuDevice->vkDevice));
|
||||
_gpuSemaphorePool->reset();
|
||||
_gpuFencePool->reset();
|
||||
((CCVKCommandAllocator*)_cmdAllocator)->reset();
|
||||
((CCVKCommandAllocator *)_cmdAllocator)->reset();
|
||||
|
||||
VkSemaphore acquireSemaphore = _gpuSemaphorePool->alloc();
|
||||
VK_CHECK(vkAcquireNextImageKHR(_gpuDevice->vkDevice, _gpuSwapchain->vkSwapchain,
|
||||
~0ull, acquireSemaphore, VK_NULL_HANDLE, &_gpuSwapchain->curImageIndex));
|
||||
~0ull, acquireSemaphore, VK_NULL_HANDLE, &_gpuSwapchain->curImageIndex));
|
||||
|
||||
// Clear queue stats
|
||||
CCVKQueue* queue = (CCVKQueue*)_queue;
|
||||
CCVKQueue *queue = (CCVKQueue *)_queue;
|
||||
queue->_numDrawCalls = 0;
|
||||
queue->_numInstances = 0;
|
||||
queue->_numTriangles = 0;
|
||||
@@ -522,14 +500,13 @@ void CCVKDevice::acquire()
|
||||
queue->gpuQueue()->nextSignalSemaphore = _gpuSemaphorePool->alloc();
|
||||
}
|
||||
|
||||
void CCVKDevice::present()
|
||||
{
|
||||
CCVKQueue* queue = (CCVKQueue*)_queue;
|
||||
void CCVKDevice::present() {
|
||||
CCVKQueue *queue = (CCVKQueue *)_queue;
|
||||
_numDrawCalls = queue->_numDrawCalls;
|
||||
_numInstances = queue->_numInstances;
|
||||
_numTriangles = queue->_numTriangles;
|
||||
|
||||
VkPresentInfoKHR presentInfo{ VK_STRUCTURE_TYPE_PRESENT_INFO_KHR };
|
||||
VkPresentInfoKHR presentInfo{VK_STRUCTURE_TYPE_PRESENT_INFO_KHR};
|
||||
presentInfo.waitSemaphoreCount = 1;
|
||||
presentInfo.pWaitSemaphores = &queue->gpuQueue()->nextWaitSemaphore;
|
||||
presentInfo.swapchainCount = 1;
|
||||
@@ -539,9 +516,8 @@ void CCVKDevice::present()
|
||||
VK_CHECK(vkQueuePresentKHR(queue->gpuQueue()->vkQueue, &presentInfo));
|
||||
}
|
||||
|
||||
GFXWindow* CCVKDevice::createWindow(const GFXWindowInfo& info)
|
||||
{
|
||||
GFXWindow* window = CC_NEW(CCVKWindow(this));
|
||||
GFXWindow *CCVKDevice::createWindow(const GFXWindowInfo &info) {
|
||||
GFXWindow *window = CC_NEW(CCVKWindow(this));
|
||||
if (window->initialize(info))
|
||||
return window;
|
||||
|
||||
@@ -549,9 +525,8 @@ GFXWindow* CCVKDevice::createWindow(const GFXWindowInfo& info)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXFence* CCVKDevice::createFence(const GFXFenceInfo& info)
|
||||
{
|
||||
GFXFence* fence = CC_NEW(CCVKFence(this));
|
||||
GFXFence *CCVKDevice::createFence(const GFXFenceInfo &info) {
|
||||
GFXFence *fence = CC_NEW(CCVKFence(this));
|
||||
if (fence->initialize(info))
|
||||
return fence;
|
||||
|
||||
@@ -559,9 +534,8 @@ GFXFence* CCVKDevice::createFence(const GFXFenceInfo& info)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXQueue* CCVKDevice::createQueue(const GFXQueueInfo& info)
|
||||
{
|
||||
GFXQueue* queue = CC_NEW(CCVKQueue(this));
|
||||
GFXQueue *CCVKDevice::createQueue(const GFXQueueInfo &info) {
|
||||
GFXQueue *queue = CC_NEW(CCVKQueue(this));
|
||||
if (queue->initialize(info))
|
||||
return queue;
|
||||
|
||||
@@ -569,9 +543,8 @@ GFXQueue* CCVKDevice::createQueue(const GFXQueueInfo& info)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXCommandAllocator* CCVKDevice::createCommandAllocator(const GFXCommandAllocatorInfo& info)
|
||||
{
|
||||
GFXCommandAllocator* cmdAllocator = CC_NEW(CCVKCommandAllocator(this));
|
||||
GFXCommandAllocator *CCVKDevice::createCommandAllocator(const GFXCommandAllocatorInfo &info) {
|
||||
GFXCommandAllocator *cmdAllocator = CC_NEW(CCVKCommandAllocator(this));
|
||||
if (cmdAllocator->initialize(info))
|
||||
return cmdAllocator;
|
||||
|
||||
@@ -579,9 +552,8 @@ GFXCommandAllocator* CCVKDevice::createCommandAllocator(const GFXCommandAllocato
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXCommandBuffer* CCVKDevice::createCommandBuffer(const GFXCommandBufferInfo& info)
|
||||
{
|
||||
GFXCommandBuffer* gfx_cmd_buff = CC_NEW(CCVKCommandBuffer(this));
|
||||
GFXCommandBuffer *CCVKDevice::createCommandBuffer(const GFXCommandBufferInfo &info) {
|
||||
GFXCommandBuffer *gfx_cmd_buff = CC_NEW(CCVKCommandBuffer(this));
|
||||
if (gfx_cmd_buff->initialize(info))
|
||||
return gfx_cmd_buff;
|
||||
|
||||
@@ -589,9 +561,8 @@ GFXCommandBuffer* CCVKDevice::createCommandBuffer(const GFXCommandBufferInfo& in
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXBuffer* CCVKDevice::createBuffer(const GFXBufferInfo& info)
|
||||
{
|
||||
GFXBuffer* buffer = CC_NEW(CCVKBuffer(this));
|
||||
GFXBuffer *CCVKDevice::createBuffer(const GFXBufferInfo &info) {
|
||||
GFXBuffer *buffer = CC_NEW(CCVKBuffer(this));
|
||||
if (buffer->initialize(info))
|
||||
return buffer;
|
||||
|
||||
@@ -599,9 +570,8 @@ GFXBuffer* CCVKDevice::createBuffer(const GFXBufferInfo& info)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXTexture* CCVKDevice::createTexture(const GFXTextureInfo& info)
|
||||
{
|
||||
GFXTexture* texture = CC_NEW(CCVKTexture(this));
|
||||
GFXTexture *CCVKDevice::createTexture(const GFXTextureInfo &info) {
|
||||
GFXTexture *texture = CC_NEW(CCVKTexture(this));
|
||||
if (texture->initialize(info))
|
||||
return texture;
|
||||
|
||||
@@ -609,9 +579,8 @@ GFXTexture* CCVKDevice::createTexture(const GFXTextureInfo& info)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXTextureView* CCVKDevice::createTextureView(const GFXTextureViewInfo& info)
|
||||
{
|
||||
GFXTextureView* texView = CC_NEW(CCVKTextureView(this));
|
||||
GFXTextureView *CCVKDevice::createTextureView(const GFXTextureViewInfo &info) {
|
||||
GFXTextureView *texView = CC_NEW(CCVKTextureView(this));
|
||||
if (texView->initialize(info))
|
||||
return texView;
|
||||
|
||||
@@ -619,9 +588,8 @@ GFXTextureView* CCVKDevice::createTextureView(const GFXTextureViewInfo& info)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXSampler* CCVKDevice::createSampler(const GFXSamplerInfo& info)
|
||||
{
|
||||
GFXSampler* sampler = CC_NEW(CCVKSampler(this));
|
||||
GFXSampler *CCVKDevice::createSampler(const GFXSamplerInfo &info) {
|
||||
GFXSampler *sampler = CC_NEW(CCVKSampler(this));
|
||||
if (sampler->initialize(info))
|
||||
return sampler;
|
||||
|
||||
@@ -629,9 +597,8 @@ GFXSampler* CCVKDevice::createSampler(const GFXSamplerInfo& info)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXShader* CCVKDevice::createShader(const GFXShaderInfo& info)
|
||||
{
|
||||
GFXShader* shader = CC_NEW(CCVKShader(this));
|
||||
GFXShader *CCVKDevice::createShader(const GFXShaderInfo &info) {
|
||||
GFXShader *shader = CC_NEW(CCVKShader(this));
|
||||
if (shader->initialize(info))
|
||||
return shader;
|
||||
|
||||
@@ -639,9 +606,8 @@ GFXShader* CCVKDevice::createShader(const GFXShaderInfo& info)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXInputAssembler* CCVKDevice::createInputAssembler(const GFXInputAssemblerInfo& info)
|
||||
{
|
||||
GFXInputAssembler* inputAssembler = CC_NEW(CCVKInputAssembler(this));
|
||||
GFXInputAssembler *CCVKDevice::createInputAssembler(const GFXInputAssemblerInfo &info) {
|
||||
GFXInputAssembler *inputAssembler = CC_NEW(CCVKInputAssembler(this));
|
||||
if (inputAssembler->initialize(info))
|
||||
return inputAssembler;
|
||||
|
||||
@@ -649,9 +615,8 @@ GFXInputAssembler* CCVKDevice::createInputAssembler(const GFXInputAssemblerInfo&
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXRenderPass* CCVKDevice::createRenderPass(const GFXRenderPassInfo& info)
|
||||
{
|
||||
GFXRenderPass* renderPass = CC_NEW(CCVKRenderPass(this));
|
||||
GFXRenderPass *CCVKDevice::createRenderPass(const GFXRenderPassInfo &info) {
|
||||
GFXRenderPass *renderPass = CC_NEW(CCVKRenderPass(this));
|
||||
if (renderPass->initialize(info))
|
||||
return renderPass;
|
||||
|
||||
@@ -659,9 +624,8 @@ GFXRenderPass* CCVKDevice::createRenderPass(const GFXRenderPassInfo& info)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXFramebuffer* CCVKDevice::createFramebuffer(const GFXFramebufferInfo& info)
|
||||
{
|
||||
GFXFramebuffer* framebuffer = CC_NEW(CCVKFramebuffer(this));
|
||||
GFXFramebuffer *CCVKDevice::createFramebuffer(const GFXFramebufferInfo &info) {
|
||||
GFXFramebuffer *framebuffer = CC_NEW(CCVKFramebuffer(this));
|
||||
if (framebuffer->initialize(info))
|
||||
return framebuffer;
|
||||
|
||||
@@ -669,9 +633,8 @@ GFXFramebuffer* CCVKDevice::createFramebuffer(const GFXFramebufferInfo& info)
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXBindingLayout* CCVKDevice::createBindingLayout(const GFXBindingLayoutInfo& info)
|
||||
{
|
||||
GFXBindingLayout* bindingLayout = CC_NEW(CCVKBindingLayout(this));
|
||||
GFXBindingLayout *CCVKDevice::createBindingLayout(const GFXBindingLayoutInfo &info) {
|
||||
GFXBindingLayout *bindingLayout = CC_NEW(CCVKBindingLayout(this));
|
||||
if (bindingLayout->initialize(info))
|
||||
return bindingLayout;
|
||||
|
||||
@@ -679,10 +642,8 @@ GFXBindingLayout* CCVKDevice::createBindingLayout(const GFXBindingLayoutInfo& in
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
GFXPipelineState* CCVKDevice::createPipelineState(const GFXPipelineStateInfo& info)
|
||||
{
|
||||
GFXPipelineState* pipelineState = CC_NEW(CCVKPipelineState(this));
|
||||
GFXPipelineState *CCVKDevice::createPipelineState(const GFXPipelineStateInfo &info) {
|
||||
GFXPipelineState *pipelineState = CC_NEW(CCVKPipelineState(this));
|
||||
if (pipelineState->initialize(info))
|
||||
return pipelineState;
|
||||
|
||||
@@ -690,9 +651,8 @@ GFXPipelineState* CCVKDevice::createPipelineState(const GFXPipelineStateInfo& in
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
GFXPipelineLayout* CCVKDevice::createPipelineLayout(const GFXPipelineLayoutInfo& info)
|
||||
{
|
||||
GFXPipelineLayout* layout = CC_NEW(CCVKPipelineLayout(this));
|
||||
GFXPipelineLayout *CCVKDevice::createPipelineLayout(const GFXPipelineLayoutInfo &info) {
|
||||
GFXPipelineLayout *layout = CC_NEW(CCVKPipelineLayout(this));
|
||||
if (layout->initialize(info))
|
||||
return layout;
|
||||
|
||||
@@ -700,9 +660,8 @@ GFXPipelineLayout* CCVKDevice::createPipelineLayout(const GFXPipelineLayoutInfo&
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void CCVKDevice::copyBuffersToTexture(const GFXDataArray& buffers, GFXTexture* dst, const GFXBufferTextureCopyList& regions)
|
||||
{
|
||||
CCVKCmdFuncCopyBuffersToTexture(this, buffers.datas.data(), ((CCVKTexture*)dst)->gpuTexture(), regions);
|
||||
void CCVKDevice::copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) {
|
||||
CCVKCmdFuncCopyBuffersToTexture(this, buffers.datas.data(), ((CCVKTexture *)dst)->gpuTexture(), regions);
|
||||
}
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -13,63 +13,65 @@ class CCVKTextureView;
|
||||
class CCVKRenderPass;
|
||||
class CCVKBuffer;
|
||||
|
||||
class CC_VULKAN_API CCVKDevice : public GFXDevice
|
||||
{
|
||||
class CC_VULKAN_API CCVKDevice : public GFXDevice {
|
||||
public:
|
||||
CCVKDevice();
|
||||
~CCVKDevice();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXDeviceInfo& info) override;
|
||||
bool initialize(const GFXDeviceInfo &info) override;
|
||||
void destroy() override;
|
||||
void resize(uint width, uint height) override;
|
||||
void acquire() override;
|
||||
void present() override;
|
||||
GFXWindow* createWindow(const GFXWindowInfo& info) override;
|
||||
GFXFence* createFence(const GFXFenceInfo& info) override;
|
||||
GFXQueue* createQueue(const GFXQueueInfo& info) override;
|
||||
GFXCommandAllocator* createCommandAllocator(const GFXCommandAllocatorInfo& info) override;
|
||||
GFXCommandBuffer* createCommandBuffer(const GFXCommandBufferInfo& info) override;
|
||||
GFXBuffer* createBuffer(const GFXBufferInfo& info) override;
|
||||
GFXTexture* createTexture(const GFXTextureInfo& info) override;
|
||||
GFXTextureView* createTextureView(const GFXTextureViewInfo& info) override;
|
||||
GFXSampler* createSampler(const GFXSamplerInfo& info) override;
|
||||
GFXShader* createShader(const GFXShaderInfo& info) override;
|
||||
GFXInputAssembler* createInputAssembler(const GFXInputAssemblerInfo& info) override;
|
||||
GFXRenderPass* createRenderPass(const GFXRenderPassInfo& info) override;
|
||||
GFXFramebuffer* createFramebuffer(const GFXFramebufferInfo& info) override;
|
||||
GFXBindingLayout* createBindingLayout(const GFXBindingLayoutInfo& info) override;
|
||||
virtual GFXPipelineState* createPipelineState(const GFXPipelineStateInfo& info) override;
|
||||
virtual GFXPipelineLayout* createPipelineLayout(const GFXPipelineLayoutInfo& info) override;
|
||||
virtual void copyBuffersToTexture(const GFXDataArray& buffers, GFXTexture* dst, const GFXBufferTextureCopyList& regions) override;
|
||||
GFXWindow *createWindow(const GFXWindowInfo &info) override;
|
||||
GFXFence *createFence(const GFXFenceInfo &info) override;
|
||||
GFXQueue *createQueue(const GFXQueueInfo &info) override;
|
||||
GFXCommandAllocator *createCommandAllocator(const GFXCommandAllocatorInfo &info) override;
|
||||
GFXCommandBuffer *createCommandBuffer(const GFXCommandBufferInfo &info) override;
|
||||
GFXBuffer *createBuffer(const GFXBufferInfo &info) override;
|
||||
GFXTexture *createTexture(const GFXTextureInfo &info) override;
|
||||
GFXTextureView *createTextureView(const GFXTextureViewInfo &info) override;
|
||||
GFXSampler *createSampler(const GFXSamplerInfo &info) override;
|
||||
GFXShader *createShader(const GFXShaderInfo &info) override;
|
||||
GFXInputAssembler *createInputAssembler(const GFXInputAssemblerInfo &info) override;
|
||||
GFXRenderPass *createRenderPass(const GFXRenderPassInfo &info) override;
|
||||
GFXFramebuffer *createFramebuffer(const GFXFramebufferInfo &info) override;
|
||||
GFXBindingLayout *createBindingLayout(const GFXBindingLayoutInfo &info) override;
|
||||
virtual GFXPipelineState *createPipelineState(const GFXPipelineStateInfo &info) override;
|
||||
virtual GFXPipelineLayout *createPipelineLayout(const GFXPipelineLayoutInfo &info) override;
|
||||
virtual void copyBuffersToTexture(const GFXDataArray &buffers, GFXTexture *dst, const GFXBufferTextureCopyList ®ions) override;
|
||||
|
||||
CC_INLINE bool checkExtension(const String& extension) const {
|
||||
CC_INLINE bool checkExtension(const String &extension) const {
|
||||
return std::find_if(_extensions.begin(), _extensions.end(),
|
||||
[extension](const char* device_extension) {
|
||||
return std::strcmp(device_extension, extension.c_str()) == 0;
|
||||
}) != _extensions.end();
|
||||
[extension](const char *device_extension) {
|
||||
return std::strcmp(device_extension, extension.c_str()) == 0;
|
||||
}) != _extensions.end();
|
||||
}
|
||||
|
||||
CCVKGPUContext* gpuContext() const;
|
||||
CC_INLINE CCVKGPUDevice* gpuDevice() const { return _gpuDevice; }
|
||||
CC_INLINE CCVKGPUSwapchain* gpuSwapchain() { return _gpuSwapchain; }
|
||||
CC_INLINE CCVKGPUSemaphorePool* gpuSemaphorePool() { return _gpuSemaphorePool; }
|
||||
CC_INLINE CCVKGPUFencePool* gpuFencePool() { return _gpuFencePool; }
|
||||
CC_INLINE CCVKBuffer* stagingBuffer() { return _stagingBuffer; }
|
||||
CC_INLINE const std::vector<const char *>& getLayers() const { return _layers; }
|
||||
CC_INLINE const std::vector<const char *>& getExtensions() const { return _extensions; }
|
||||
CCVKGPUContext *gpuContext() const;
|
||||
CC_INLINE CCVKGPUDevice *gpuDevice() const { return _gpuDevice; }
|
||||
CC_INLINE CCVKGPUSwapchain *gpuSwapchain() { return _gpuSwapchain; }
|
||||
CC_INLINE CCVKGPUSemaphorePool *gpuSemaphorePool() { return _gpuSemaphorePool; }
|
||||
CC_INLINE CCVKGPUFencePool *gpuFencePool() { return _gpuFencePool; }
|
||||
CC_INLINE CCVKBuffer *stagingBuffer() { return _stagingBuffer; }
|
||||
CC_INLINE const std::vector<const char *> &getLayers() const { return _layers; }
|
||||
CC_INLINE const std::vector<const char *> &getExtensions() const { return _extensions; }
|
||||
|
||||
CCVKTextureView *nullTexView2D = nullptr;
|
||||
CCVKTextureView *nullTexViewCube = nullptr;
|
||||
|
||||
private:
|
||||
void buildSwapchain();
|
||||
|
||||
CCVKGPUDevice* _gpuDevice = nullptr;
|
||||
CCVKGPUSemaphorePool* _gpuSemaphorePool = nullptr;
|
||||
CCVKGPUFencePool* _gpuFencePool = nullptr;
|
||||
CCVKGPUSwapchain* _gpuSwapchain = nullptr;
|
||||
std::vector<CCVKTextureView*> _depthStencilTextureViews;
|
||||
std::vector<CCVKTexture*> _depthStencilTextures;
|
||||
CCVKRenderPass* _renderPass = nullptr;
|
||||
CCVKBuffer* _stagingBuffer = nullptr;
|
||||
CCVKGPUDevice *_gpuDevice = nullptr;
|
||||
CCVKGPUSemaphorePool *_gpuSemaphorePool = nullptr;
|
||||
CCVKGPUFencePool *_gpuFencePool = nullptr;
|
||||
CCVKGPUSwapchain *_gpuSwapchain = nullptr;
|
||||
std::vector<CCVKTextureView *> _depthStencilTextureViews;
|
||||
std::vector<CCVKTexture *> _depthStencilTextures;
|
||||
CCVKRenderPass *_renderPass = nullptr;
|
||||
CCVKBuffer *_stagingBuffer = nullptr;
|
||||
|
||||
uint32_t _defaultStagingBufferSize = 1024;
|
||||
|
||||
|
||||
@@ -1,40 +1,35 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKFence.h"
|
||||
|
||||
#include "VKDevice.h"
|
||||
#include "VKFence.h"
|
||||
#include "VKGPUObjects.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKFence::CCVKFence(GFXDevice* device)
|
||||
: GFXFence(device)
|
||||
{
|
||||
CCVKFence::CCVKFence(GFXDevice *device)
|
||||
: GFXFence(device) {
|
||||
}
|
||||
|
||||
CCVKFence::~CCVKFence()
|
||||
{
|
||||
CCVKFence::~CCVKFence() {
|
||||
}
|
||||
|
||||
bool CCVKFence::initialize(const GFXFenceInfo &info)
|
||||
{
|
||||
bool CCVKFence::initialize(const GFXFenceInfo &info) {
|
||||
_gpuFence = CC_NEW(CCVKGPUFence);
|
||||
if (!_gpuFence)
|
||||
{
|
||||
if (!_gpuFence) {
|
||||
CC_LOG_ERROR("GLES2Fence: CC_NEW CCVKGPUFence failed.");
|
||||
return false;
|
||||
}
|
||||
|
||||
VkFenceCreateInfo createInfo{ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO };
|
||||
VK_CHECK(vkCreateFence(((CCVKDevice*)_device)->gpuDevice()->vkDevice, &createInfo, nullptr, &_gpuFence->vkFence));
|
||||
VkFenceCreateInfo createInfo{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
|
||||
VK_CHECK(vkCreateFence(((CCVKDevice *)_device)->gpuDevice()->vkDevice, &createInfo, nullptr, &_gpuFence->vkFence));
|
||||
|
||||
_status = GFXStatus::SUCCESS;
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKFence::destroy()
|
||||
{
|
||||
if (_gpuFence)
|
||||
{
|
||||
vkDestroyFence(((CCVKDevice*)_device)->gpuDevice()->vkDevice, _gpuFence->vkFence, nullptr);
|
||||
void CCVKFence::destroy() {
|
||||
if (_gpuFence) {
|
||||
vkDestroyFence(((CCVKDevice *)_device)->gpuDevice()->vkDevice, _gpuFence->vkFence, nullptr);
|
||||
|
||||
CC_DELETE(_gpuFence);
|
||||
_gpuFence = nullptr;
|
||||
@@ -42,14 +37,12 @@ void CCVKFence::destroy()
|
||||
_status = GFXStatus::UNREADY;
|
||||
}
|
||||
|
||||
void CCVKFence::wait()
|
||||
{
|
||||
VK_CHECK(vkWaitForFences(((CCVKDevice*)_device)->gpuDevice()->vkDevice, 1, &_gpuFence->vkFence, VK_TRUE, DEFAULT_FENCE_TIMEOUT));
|
||||
void CCVKFence::wait() {
|
||||
VK_CHECK(vkWaitForFences(((CCVKDevice *)_device)->gpuDevice()->vkDevice, 1, &_gpuFence->vkFence, VK_TRUE, DEFAULT_FENCE_TIMEOUT));
|
||||
}
|
||||
|
||||
void CCVKFence::reset()
|
||||
{
|
||||
VK_CHECK(vkResetFences(((CCVKDevice*)_device)->gpuDevice()->vkDevice, 1, &_gpuFence->vkFence));
|
||||
void CCVKFence::reset() {
|
||||
VK_CHECK(vkResetFences(((CCVKDevice *)_device)->gpuDevice()->vkDevice, 1, &_gpuFence->vkFence));
|
||||
}
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -7,19 +7,19 @@ class CCVKGPUFence;
|
||||
|
||||
class CC_VULKAN_API CCVKFence : public GFXFence {
|
||||
public:
|
||||
CCVKFence(GFXDevice* device);
|
||||
CCVKFence(GFXDevice *device);
|
||||
virtual ~CCVKFence() override;
|
||||
|
||||
public:
|
||||
virtual bool initialize(const GFXFenceInfo& info) override;
|
||||
virtual bool initialize(const GFXFenceInfo &info) override;
|
||||
virtual void destroy() override;
|
||||
virtual void wait() override;
|
||||
virtual void reset() override;
|
||||
|
||||
CC_INLINE CCVKGPUFence* gpuFence() { return _gpuFence; }
|
||||
CC_INLINE CCVKGPUFence *gpuFence() { return _gpuFence; }
|
||||
|
||||
private:
|
||||
CCVKGPUFence* _gpuFence = nullptr;
|
||||
CCVKGPUFence *_gpuFence = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -1,63 +1,54 @@
|
||||
#include "VKStd.h"
|
||||
|
||||
#include "VKCommands.h"
|
||||
#include "VKDevice.h"
|
||||
#include "VKFramebuffer.h"
|
||||
#include "VKRenderPass.h"
|
||||
#include "VKCommands.h"
|
||||
#include "VKTextureView.h"
|
||||
#include "VKDevice.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKFramebuffer::CCVKFramebuffer(GFXDevice* device)
|
||||
: GFXFramebuffer(device)
|
||||
{
|
||||
CCVKFramebuffer::CCVKFramebuffer(GFXDevice *device)
|
||||
: GFXFramebuffer(device) {
|
||||
}
|
||||
|
||||
CCVKFramebuffer::~CCVKFramebuffer()
|
||||
{
|
||||
CCVKFramebuffer::~CCVKFramebuffer() {
|
||||
}
|
||||
|
||||
bool CCVKFramebuffer::initialize(const GFXFramebufferInfo &info)
|
||||
{
|
||||
bool CCVKFramebuffer::initialize(const GFXFramebufferInfo &info) {
|
||||
_renderPass = info.renderPass;
|
||||
_colorViews = info.colorViews;
|
||||
_depthStencilView = info.depthStencilView;
|
||||
_isOffscreen = info.isOffscreen;
|
||||
|
||||
_gpuFBO = CC_NEW(CCVKGPUFramebuffer);
|
||||
_gpuFBO->gpuRenderPass = ((CCVKRenderPass*)_renderPass)->gpuRenderPass();
|
||||
_gpuFBO->gpuRenderPass = ((CCVKRenderPass *)_renderPass)->gpuRenderPass();
|
||||
|
||||
if (_isOffscreen)
|
||||
{
|
||||
if (_isOffscreen) {
|
||||
_gpuFBO->gpuColorViews.resize(_colorViews.size());
|
||||
for (size_t i = 0; i < _colorViews.size(); ++i)
|
||||
{
|
||||
CCVKTextureView* colorview = (CCVKTextureView*)_colorViews[i];
|
||||
for (size_t i = 0; i < _colorViews.size(); ++i) {
|
||||
CCVKTextureView *colorview = (CCVKTextureView *)_colorViews[i];
|
||||
_gpuFBO->gpuColorViews[i] = colorview->gpuTexView();
|
||||
}
|
||||
|
||||
if (_depthStencilView)
|
||||
{
|
||||
_gpuFBO->gpuDepthStencilView = ((CCVKTextureView*)_depthStencilView)->gpuTexView();
|
||||
if (_depthStencilView) {
|
||||
_gpuFBO->gpuDepthStencilView = ((CCVKTextureView *)_depthStencilView)->gpuTexView();
|
||||
}
|
||||
|
||||
_gpuFBO->isOffscreen = _isOffscreen;
|
||||
|
||||
}
|
||||
|
||||
CCVKCmdFuncCreateFramebuffer((CCVKDevice*)_device, _gpuFBO);
|
||||
CCVKCmdFuncCreateFramebuffer((CCVKDevice *)_device, _gpuFBO);
|
||||
|
||||
_status = GFXStatus::SUCCESS;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKFramebuffer::destroy()
|
||||
{
|
||||
if (_gpuFBO)
|
||||
{
|
||||
if (_isOffscreen)
|
||||
{
|
||||
CCVKCmdFuncDestroyFramebuffer((CCVKDevice*)_device, _gpuFBO);
|
||||
void CCVKFramebuffer::destroy() {
|
||||
if (_gpuFBO) {
|
||||
if (_isOffscreen) {
|
||||
CCVKCmdFuncDestroyFramebuffer((CCVKDevice *)_device, _gpuFBO);
|
||||
}
|
||||
CC_DELETE(_gpuFBO);
|
||||
_gpuFBO = nullptr;
|
||||
|
||||
@@ -6,18 +6,18 @@ NS_CC_BEGIN
|
||||
class CCVKGPUFramebuffer;
|
||||
|
||||
class CC_VULKAN_API CCVKFramebuffer : public GFXFramebuffer {
|
||||
public:
|
||||
CCVKFramebuffer(GFXDevice* device);
|
||||
~CCVKFramebuffer();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXFramebufferInfo& info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUFramebuffer* gpuFBO() const { return _gpuFBO; }
|
||||
|
||||
private:
|
||||
CCVKGPUFramebuffer* _gpuFBO = nullptr;
|
||||
public:
|
||||
CCVKFramebuffer(GFXDevice *device);
|
||||
~CCVKFramebuffer();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXFramebufferInfo &info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUFramebuffer *gpuFBO() const { return _gpuFBO; }
|
||||
|
||||
private:
|
||||
CCVKGPUFramebuffer *_gpuFBO = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -5,8 +5,7 @@
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
class CCVKGPUContext : public Object
|
||||
{
|
||||
class CCVKGPUContext : public Object {
|
||||
public:
|
||||
VkInstance vkInstance = VK_NULL_HANDLE;
|
||||
VkDebugUtilsMessengerEXT vkDebugUtilsMessenger = VK_NULL_HANDLE;
|
||||
@@ -14,9 +13,9 @@ public:
|
||||
|
||||
VkPhysicalDevice physicalDevice = VK_NULL_HANDLE;
|
||||
VkPhysicalDeviceFeatures physicalDeviceFeatures{};
|
||||
VkPhysicalDeviceFeatures2 physicalDeviceFeatures2{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 };
|
||||
VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES};
|
||||
VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES };
|
||||
VkPhysicalDeviceFeatures2 physicalDeviceFeatures2{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2};
|
||||
VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES};
|
||||
VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES};
|
||||
VkPhysicalDeviceProperties physicalDeviceProperties{};
|
||||
VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties{};
|
||||
vector<VkQueueFamilyProperties>::type queueFamilyProperties;
|
||||
@@ -24,11 +23,10 @@ public:
|
||||
|
||||
VkSurfaceKHR vkSurface = VK_NULL_HANDLE;
|
||||
|
||||
VkSwapchainCreateInfoKHR swapchainCreateInfo{ VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR };
|
||||
VkSwapchainCreateInfoKHR swapchainCreateInfo{VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR};
|
||||
};
|
||||
|
||||
class CCVKGPUDevice : public Object
|
||||
{
|
||||
class CCVKGPUDevice : public Object {
|
||||
public:
|
||||
VkDevice vkDevice = VK_NULL_HANDLE;
|
||||
vector<VkLayerProperties>::type layers;
|
||||
@@ -36,8 +34,7 @@ public:
|
||||
VmaAllocator memoryAllocator = VK_NULL_HANDLE;
|
||||
};
|
||||
|
||||
class CCVKGPURenderPass : public Object
|
||||
{
|
||||
class CCVKGPURenderPass : public Object {
|
||||
public:
|
||||
GFXColorAttachmentList colorAttachments;
|
||||
GFXDepthStencilAttachment depthStencilAttachment;
|
||||
@@ -48,8 +45,7 @@ public:
|
||||
vector<VkImageMemoryBarrier>::type endBarriers;
|
||||
};
|
||||
|
||||
class CCVKGPUSwapchain : public Object
|
||||
{
|
||||
class CCVKGPUSwapchain : public Object {
|
||||
public:
|
||||
uint curImageIndex = 0;
|
||||
VkSwapchainKHR vkSwapchain = VK_NULL_HANDLE;
|
||||
@@ -59,27 +55,24 @@ public:
|
||||
vector<VkImage>::type swapchainImages;
|
||||
vector<VkImage>::type depthStencilImages;
|
||||
vector<VkImageView>::type depthStencilImageViews;
|
||||
CCVKGPURenderPass* renderPass;
|
||||
CCVKGPURenderPass *renderPass;
|
||||
};
|
||||
|
||||
class CCVKGPUCommandPool : public Object
|
||||
{
|
||||
class CCVKGPUCommandPool : public Object {
|
||||
public:
|
||||
VkCommandPool vkCommandPool = VK_NULL_HANDLE;
|
||||
CachedArray<VkCommandBuffer> commandBuffers[2];
|
||||
CachedArray<VkCommandBuffer> usedCommandBuffers[2];
|
||||
};
|
||||
|
||||
class CCVKGPUCommandBuffer : public Object
|
||||
{
|
||||
class CCVKGPUCommandBuffer : public Object {
|
||||
public:
|
||||
GFXCommandBufferType type;
|
||||
CCVKGPUCommandPool* commandPool = nullptr;
|
||||
CCVKGPUCommandPool *commandPool = nullptr;
|
||||
VkCommandBuffer vkCommandBuffer = VK_NULL_HANDLE;
|
||||
};
|
||||
|
||||
class CCVKGPUQueue : public Object
|
||||
{
|
||||
class CCVKGPUQueue : public Object {
|
||||
public:
|
||||
GFXQueueType type;
|
||||
VkQueue vkQueue;
|
||||
@@ -90,26 +83,24 @@ public:
|
||||
CachedArray<VkCommandBuffer> commandBuffers;
|
||||
};
|
||||
|
||||
class CCVKGPUBuffer : public Object
|
||||
{
|
||||
class CCVKGPUBuffer : public Object {
|
||||
public:
|
||||
GFXBufferUsage usage = GFXBufferUsage::NONE;
|
||||
GFXMemoryUsage memUsage = GFXMemoryUsage::NONE;
|
||||
uint size = 0;
|
||||
uint stride = 0;
|
||||
uint count = 0;
|
||||
void* buffer = nullptr;
|
||||
void *buffer = nullptr;
|
||||
GFXDrawInfoList indirects;
|
||||
|
||||
VkBuffer vkBuffer = VK_NULL_HANDLE;
|
||||
VkDeviceSize startOffset = 0u;
|
||||
uint8_t* mappedData = nullptr;
|
||||
uint8_t *mappedData = nullptr;
|
||||
VmaAllocation vmaAllocation = VK_NULL_HANDLE;
|
||||
};
|
||||
typedef vector<CCVKGPUBuffer*>::type CCVKGPUBufferList;
|
||||
typedef vector<CCVKGPUBuffer *>::type CCVKGPUBufferList;
|
||||
|
||||
class CCVKGPUTexture : public Object
|
||||
{
|
||||
class CCVKGPUTexture : public Object {
|
||||
public:
|
||||
GFXTextureType type = GFXTextureType::TEX2D;
|
||||
GFXTextureViewType viewType = GFXTextureViewType::TV2D;
|
||||
@@ -133,10 +124,9 @@ public:
|
||||
VkPipelineStageFlags targetStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
|
||||
};
|
||||
|
||||
class CCVKGPUTextureView : public Object
|
||||
{
|
||||
class CCVKGPUTextureView : public Object {
|
||||
public:
|
||||
CCVKGPUTexture* gpuTexture = nullptr;
|
||||
CCVKGPUTexture *gpuTexture = nullptr;
|
||||
GFXTextureViewType type = GFXTextureViewType::TV2D;
|
||||
GFXFormat format = GFXFormat::UNKNOWN;
|
||||
uint baseLevel = 0;
|
||||
@@ -144,10 +134,9 @@ public:
|
||||
VkImageView vkImageView = VK_NULL_HANDLE;
|
||||
};
|
||||
|
||||
typedef vector<CCVKGPUTextureView*>::type CCVKGPUTextureViewList;
|
||||
typedef vector<CCVKGPUTextureView *>::type CCVKGPUTextureViewList;
|
||||
|
||||
class CCVKGPUSampler : public Object
|
||||
{
|
||||
class CCVKGPUSampler : public Object {
|
||||
public:
|
||||
GFXFilter minFilter = GFXFilter::LINEAR;
|
||||
GFXFilter magFilter = GFXFilter::LINEAR;
|
||||
@@ -164,13 +153,9 @@ public:
|
||||
VkSampler vkSampler;
|
||||
};
|
||||
|
||||
struct CCVKGPUShaderStage
|
||||
{
|
||||
struct CCVKGPUShaderStage {
|
||||
CCVKGPUShaderStage(GFXShaderType t, String s, GFXShaderMacroList m)
|
||||
: type(t)
|
||||
, source(s)
|
||||
, macros(m)
|
||||
{
|
||||
: type(t), source(s), macros(m) {
|
||||
}
|
||||
GFXShaderType type;
|
||||
String source;
|
||||
@@ -179,8 +164,7 @@ struct CCVKGPUShaderStage
|
||||
};
|
||||
typedef vector<CCVKGPUShaderStage>::type CCVKGPUShaderStageList;
|
||||
|
||||
class CCVKGPUShader : public Object
|
||||
{
|
||||
class CCVKGPUShader : public Object {
|
||||
public:
|
||||
String name;
|
||||
GFXUniformBlockList blocks;
|
||||
@@ -188,30 +172,27 @@ public:
|
||||
CCVKGPUShaderStageList gpuStages;
|
||||
};
|
||||
|
||||
class CCVKGPUInputAssembler : public Object
|
||||
{
|
||||
class CCVKGPUInputAssembler : public Object {
|
||||
public:
|
||||
GFXAttributeList attributes;
|
||||
CCVKGPUBufferList gpuVertexBuffers;
|
||||
CCVKGPUBuffer* gpuIndexBuffer = nullptr;
|
||||
CCVKGPUBuffer* gpuIndirectBuffer = nullptr;
|
||||
CCVKGPUBuffer *gpuIndexBuffer = nullptr;
|
||||
CCVKGPUBuffer *gpuIndirectBuffer = nullptr;
|
||||
vector<VkBuffer>::type vertexBuffers;
|
||||
vector<VkDeviceSize>::type vertexBufferOffsets;
|
||||
};
|
||||
|
||||
class CCVKGPUFramebuffer : public Object
|
||||
{
|
||||
class CCVKGPUFramebuffer : public Object {
|
||||
public:
|
||||
CCVKGPURenderPass* gpuRenderPass = nullptr;
|
||||
CCVKGPURenderPass *gpuRenderPass = nullptr;
|
||||
CCVKGPUTextureViewList gpuColorViews;
|
||||
CCVKGPUTextureView* gpuDepthStencilView = nullptr;
|
||||
CCVKGPUTextureView *gpuDepthStencilView = nullptr;
|
||||
VkFramebuffer vkFramebuffer = VK_NULL_HANDLE;
|
||||
bool isOffscreen = false;
|
||||
CCVKGPUSwapchain* swapchain = nullptr;
|
||||
CCVKGPUSwapchain *swapchain = nullptr;
|
||||
};
|
||||
|
||||
class CCVKGPUBindingLayout : public Object
|
||||
{
|
||||
class CCVKGPUBindingLayout : public Object {
|
||||
public:
|
||||
vector<VkWriteDescriptorSet>::type bindings;
|
||||
VkDescriptorSetLayout vkDescriptorSetLayout = VK_NULL_HANDLE;
|
||||
@@ -219,63 +200,54 @@ public:
|
||||
VkDescriptorSet vkDescriptorSet = VK_NULL_HANDLE;
|
||||
};
|
||||
|
||||
class CCVKGPUPipelineLayout : public Object
|
||||
{
|
||||
class CCVKGPUPipelineLayout : public Object {
|
||||
public:
|
||||
GFXPushConstantRangeList pushConstantRanges;
|
||||
vector<CCVKGPUBindingLayout*>::type gpuBindingLayouts;
|
||||
vector<CCVKGPUBindingLayout *>::type gpuBindingLayouts;
|
||||
VkPipelineLayout vkPipelineLayout;
|
||||
};
|
||||
|
||||
class CCVKGPUPipelineState : public Object
|
||||
{
|
||||
class CCVKGPUPipelineState : public Object {
|
||||
public:
|
||||
GFXPrimitiveMode primitive = GFXPrimitiveMode::TRIANGLE_LIST;
|
||||
CCVKGPUShader* gpuShader = nullptr;
|
||||
CCVKGPUShader *gpuShader = nullptr;
|
||||
GFXInputState inputState;
|
||||
GFXRasterizerState rs;
|
||||
GFXDepthStencilState dss;
|
||||
GFXBlendState bs;
|
||||
GFXDynamicStateList dynamicStates;
|
||||
CCVKGPUPipelineLayout* gpuLayout = nullptr;
|
||||
CCVKGPURenderPass* gpuRenderPass = nullptr;
|
||||
CCVKGPUPipelineLayout *gpuLayout = nullptr;
|
||||
CCVKGPURenderPass *gpuRenderPass = nullptr;
|
||||
VkPipeline vkPipeline = VK_NULL_HANDLE;
|
||||
VkPipelineCache vkPipelineCache = VK_NULL_HANDLE;
|
||||
};
|
||||
|
||||
class CCVKGPUFence : public Object
|
||||
{
|
||||
class CCVKGPUFence : public Object {
|
||||
public:
|
||||
VkFence vkFence;
|
||||
};
|
||||
|
||||
class CCVKGPUSemaphorePool : public Object
|
||||
{
|
||||
class CCVKGPUSemaphorePool : public Object {
|
||||
public:
|
||||
CCVKGPUSemaphorePool(CCVKGPUDevice* device)
|
||||
: _device(device)
|
||||
{
|
||||
CCVKGPUSemaphorePool(CCVKGPUDevice *device)
|
||||
: _device(device) {
|
||||
}
|
||||
|
||||
~CCVKGPUSemaphorePool()
|
||||
{
|
||||
for (VkBuffer semaphore : _semaphores)
|
||||
{
|
||||
~CCVKGPUSemaphorePool() {
|
||||
for (VkBuffer semaphore : _semaphores) {
|
||||
vkDestroySemaphore(_device->vkDevice, semaphore, nullptr);
|
||||
}
|
||||
_semaphores.clear();
|
||||
_count = 0;
|
||||
}
|
||||
|
||||
VkSemaphore alloc()
|
||||
{
|
||||
if (_count < _semaphores.size())
|
||||
{
|
||||
VkSemaphore alloc() {
|
||||
if (_count < _semaphores.size()) {
|
||||
return _semaphores[_count++];
|
||||
}
|
||||
|
||||
VkSemaphore semaphore = VK_NULL_HANDLE;
|
||||
VkSemaphoreCreateInfo createInfo{ VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO };
|
||||
VkSemaphoreCreateInfo createInfo{VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO};
|
||||
VK_CHECK(vkCreateSemaphore(_device->vkDevice, &createInfo, nullptr, &semaphore));
|
||||
_semaphores.push_back(semaphore);
|
||||
_count++;
|
||||
@@ -283,49 +255,41 @@ public:
|
||||
return semaphore;
|
||||
}
|
||||
|
||||
void reset()
|
||||
{
|
||||
void reset() {
|
||||
_count = 0;
|
||||
}
|
||||
|
||||
uint size()
|
||||
{
|
||||
uint size() {
|
||||
return _count;
|
||||
}
|
||||
|
||||
private:
|
||||
CCVKGPUDevice* _device;
|
||||
CCVKGPUDevice *_device;
|
||||
uint _count = 0;
|
||||
vector<VkSemaphore>::type _semaphores;
|
||||
};
|
||||
|
||||
class CCVKGPUFencePool : public Object
|
||||
{
|
||||
class CCVKGPUFencePool : public Object {
|
||||
public:
|
||||
CCVKGPUFencePool(CCVKGPUDevice* device)
|
||||
: _device(device)
|
||||
{
|
||||
CCVKGPUFencePool(CCVKGPUDevice *device)
|
||||
: _device(device) {
|
||||
}
|
||||
|
||||
~CCVKGPUFencePool()
|
||||
{
|
||||
for (VkFence fence : _fences)
|
||||
{
|
||||
~CCVKGPUFencePool() {
|
||||
for (VkFence fence : _fences) {
|
||||
vkDestroyFence(_device->vkDevice, fence, nullptr);
|
||||
}
|
||||
_fences.clear();
|
||||
_count = 0;
|
||||
}
|
||||
|
||||
VkFence alloc()
|
||||
{
|
||||
if (_count < _fences.size())
|
||||
{
|
||||
VkFence alloc() {
|
||||
if (_count < _fences.size()) {
|
||||
return _fences[_count++];
|
||||
}
|
||||
|
||||
VkFence fence = VK_NULL_HANDLE;
|
||||
VkFenceCreateInfo createInfo{ VK_STRUCTURE_TYPE_FENCE_CREATE_INFO };
|
||||
VkFenceCreateInfo createInfo{VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
|
||||
VK_CHECK(vkCreateFence(_device->vkDevice, &createInfo, nullptr, &fence));
|
||||
_fences.push_back(fence);
|
||||
_count++;
|
||||
@@ -333,22 +297,19 @@ public:
|
||||
return fence;
|
||||
}
|
||||
|
||||
void reset()
|
||||
{
|
||||
if (_count)
|
||||
{
|
||||
void reset() {
|
||||
if (_count) {
|
||||
VK_CHECK(vkResetFences(_device->vkDevice, _count, _fences.data()));
|
||||
_count = 0;
|
||||
}
|
||||
}
|
||||
|
||||
uint size()
|
||||
{
|
||||
uint size() {
|
||||
return _count;
|
||||
}
|
||||
|
||||
private:
|
||||
CCVKGPUDevice* _device;
|
||||
CCVKGPUDevice *_device;
|
||||
uint _count = 0;
|
||||
vector<VkFence>::type _fences;
|
||||
};
|
||||
|
||||
@@ -1,32 +1,27 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKInputAssembler.h"
|
||||
#include "VKCommands.h"
|
||||
|
||||
#include "VKBuffer.h"
|
||||
#include "VKCommands.h"
|
||||
#include "VKInputAssembler.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKInputAssembler::CCVKInputAssembler(GFXDevice* device)
|
||||
: GFXInputAssembler(device)
|
||||
{
|
||||
CCVKInputAssembler::CCVKInputAssembler(GFXDevice *device)
|
||||
: GFXInputAssembler(device) {
|
||||
}
|
||||
|
||||
CCVKInputAssembler::~CCVKInputAssembler()
|
||||
{
|
||||
CCVKInputAssembler::~CCVKInputAssembler() {
|
||||
}
|
||||
|
||||
bool CCVKInputAssembler::initialize(const GFXInputAssemblerInfo &info)
|
||||
{
|
||||
bool CCVKInputAssembler::initialize(const GFXInputAssemblerInfo &info) {
|
||||
_attributes = info.attributes;
|
||||
_vertexBuffers = info.vertexBuffers;
|
||||
_indexBuffer = info.indexBuffer;
|
||||
_indirectBuffer = info.indirectBuffer;
|
||||
|
||||
if (_indexBuffer)
|
||||
{
|
||||
if (_indexBuffer) {
|
||||
_indexCount = _indexBuffer->getCount();
|
||||
}
|
||||
else if (_vertexBuffers.size())
|
||||
{
|
||||
} else if (_vertexBuffers.size()) {
|
||||
_vertexCount = _vertexBuffers[0]->getCount();
|
||||
}
|
||||
|
||||
@@ -34,34 +29,29 @@ bool CCVKInputAssembler::initialize(const GFXInputAssemblerInfo &info)
|
||||
_gpuInputAssembler->attributes = _attributes;
|
||||
_gpuInputAssembler->gpuVertexBuffers.resize(_vertexBuffers.size());
|
||||
|
||||
for (size_t i = 0; i < _gpuInputAssembler->gpuVertexBuffers.size(); ++i)
|
||||
{
|
||||
CCVKBuffer* vb = (CCVKBuffer*)_vertexBuffers[i];
|
||||
for (size_t i = 0; i < _gpuInputAssembler->gpuVertexBuffers.size(); ++i) {
|
||||
CCVKBuffer *vb = (CCVKBuffer *)_vertexBuffers[i];
|
||||
_gpuInputAssembler->gpuVertexBuffers[i] = vb->gpuBuffer();
|
||||
}
|
||||
|
||||
if (info.indexBuffer)
|
||||
{
|
||||
_gpuInputAssembler->gpuIndexBuffer = static_cast<CCVKBuffer*>(info.indexBuffer)->gpuBuffer();
|
||||
if (info.indexBuffer) {
|
||||
_gpuInputAssembler->gpuIndexBuffer = static_cast<CCVKBuffer *>(info.indexBuffer)->gpuBuffer();
|
||||
}
|
||||
|
||||
if (info.indirectBuffer)
|
||||
{
|
||||
_gpuInputAssembler->gpuIndirectBuffer = static_cast<CCVKBuffer*>(info.indirectBuffer)->gpuBuffer();
|
||||
if (info.indirectBuffer) {
|
||||
_gpuInputAssembler->gpuIndirectBuffer = static_cast<CCVKBuffer *>(info.indirectBuffer)->gpuBuffer();
|
||||
}
|
||||
|
||||
CCVKCmdFuncCreateInputAssembler((CCVKDevice*)_device, _gpuInputAssembler);
|
||||
CCVKCmdFuncCreateInputAssembler((CCVKDevice *)_device, _gpuInputAssembler);
|
||||
_attributesHash = computeAttributesHash();
|
||||
_status = GFXStatus::SUCCESS;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKInputAssembler::destroy()
|
||||
{
|
||||
if (_gpuInputAssembler)
|
||||
{
|
||||
CCVKCmdFuncDestroyInputAssembler((CCVKDevice*)_device, _gpuInputAssembler);
|
||||
void CCVKInputAssembler::destroy() {
|
||||
if (_gpuInputAssembler) {
|
||||
CCVKCmdFuncDestroyInputAssembler((CCVKDevice *)_device, _gpuInputAssembler);
|
||||
CC_DELETE(_gpuInputAssembler);
|
||||
_gpuInputAssembler = nullptr;
|
||||
}
|
||||
|
||||
@@ -5,20 +5,19 @@ NS_CC_BEGIN
|
||||
|
||||
class CCVKGPUInputAssembler;
|
||||
|
||||
class CC_VULKAN_API CCVKInputAssembler : public GFXInputAssembler
|
||||
{
|
||||
class CC_VULKAN_API CCVKInputAssembler : public GFXInputAssembler {
|
||||
public:
|
||||
CCVKInputAssembler(GFXDevice* device);
|
||||
CCVKInputAssembler(GFXDevice *device);
|
||||
~CCVKInputAssembler();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXInputAssemblerInfo& info);
|
||||
bool initialize(const GFXInputAssemblerInfo &info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUInputAssembler* gpuInputAssembler() const { return _gpuInputAssembler; }
|
||||
CC_INLINE CCVKGPUInputAssembler *gpuInputAssembler() const { return _gpuInputAssembler; }
|
||||
|
||||
private:
|
||||
CCVKGPUInputAssembler* _gpuInputAssembler = nullptr;
|
||||
CCVKGPUInputAssembler *_gpuInputAssembler = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -1,21 +1,19 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKPipelineLayout.h"
|
||||
#include "VKCommands.h"
|
||||
|
||||
#include "VKBindingLayout.h"
|
||||
#include "VKCommands.h"
|
||||
#include "VKPipelineLayout.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKPipelineLayout::CCVKPipelineLayout(GFXDevice* device)
|
||||
: GFXPipelineLayout(device)
|
||||
{
|
||||
CCVKPipelineLayout::CCVKPipelineLayout(GFXDevice *device)
|
||||
: GFXPipelineLayout(device) {
|
||||
}
|
||||
|
||||
CCVKPipelineLayout::~CCVKPipelineLayout()
|
||||
{
|
||||
CCVKPipelineLayout::~CCVKPipelineLayout() {
|
||||
}
|
||||
|
||||
bool CCVKPipelineLayout::initialize(const GFXPipelineLayoutInfo &info)
|
||||
{
|
||||
bool CCVKPipelineLayout::initialize(const GFXPipelineLayoutInfo &info) {
|
||||
|
||||
_layouts = info.layouts;
|
||||
_pushConstantsRanges = info.pushConstantsRanges;
|
||||
@@ -24,22 +22,19 @@ bool CCVKPipelineLayout::initialize(const GFXPipelineLayoutInfo &info)
|
||||
_gpuPipelineLayout->pushConstantRanges = _pushConstantsRanges;
|
||||
uint layoutCount = _layouts.size();
|
||||
_gpuPipelineLayout->gpuBindingLayouts.resize(layoutCount);
|
||||
for (uint i = 0u; i < layoutCount; i++)
|
||||
{
|
||||
_gpuPipelineLayout->gpuBindingLayouts[i] = ((CCVKBindingLayout*)_layouts[i])->gpuBindingLayout();
|
||||
for (uint i = 0u; i < layoutCount; i++) {
|
||||
_gpuPipelineLayout->gpuBindingLayouts[i] = ((CCVKBindingLayout *)_layouts[i])->gpuBindingLayout();
|
||||
}
|
||||
|
||||
CCVKCmdFuncCreatePipelineLayout((CCVKDevice*)_device, _gpuPipelineLayout);
|
||||
CCVKCmdFuncCreatePipelineLayout((CCVKDevice *)_device, _gpuPipelineLayout);
|
||||
|
||||
_status = GFXStatus::SUCCESS;
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKPipelineLayout::destroy()
|
||||
{
|
||||
if (_gpuPipelineLayout)
|
||||
{
|
||||
CCVKCmdFuncDestroyPipelineLayout((CCVKDevice*)_device, _gpuPipelineLayout);
|
||||
void CCVKPipelineLayout::destroy() {
|
||||
if (_gpuPipelineLayout) {
|
||||
CCVKCmdFuncDestroyPipelineLayout((CCVKDevice *)_device, _gpuPipelineLayout);
|
||||
CC_DELETE(_gpuPipelineLayout);
|
||||
_gpuPipelineLayout = nullptr;
|
||||
}
|
||||
|
||||
@@ -5,19 +5,19 @@ NS_CC_BEGIN
|
||||
|
||||
class CCVKGPUPipelineLayout;
|
||||
|
||||
class CC_VULKAN_API CCVKPipelineLayout : public GFXPipelineLayout
|
||||
{
|
||||
class CC_VULKAN_API CCVKPipelineLayout : public GFXPipelineLayout {
|
||||
public:
|
||||
CCVKPipelineLayout(GFXDevice* device);
|
||||
CCVKPipelineLayout(GFXDevice *device);
|
||||
~CCVKPipelineLayout();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXPipelineLayoutInfo& info);
|
||||
bool initialize(const GFXPipelineLayoutInfo &info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUPipelineLayout* gpuPipelineLayout() const { return _gpuPipelineLayout; }
|
||||
CC_INLINE CCVKGPUPipelineLayout *gpuPipelineLayout() const { return _gpuPipelineLayout; }
|
||||
|
||||
private:
|
||||
CCVKGPUPipelineLayout* _gpuPipelineLayout = nullptr;
|
||||
CCVKGPUPipelineLayout *_gpuPipelineLayout = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -1,23 +1,21 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKPipelineState.h"
|
||||
|
||||
#include "VKCommands.h"
|
||||
#include "VKShader.h"
|
||||
#include "VKRenderPass.h"
|
||||
#include "VKPipelineLayout.h"
|
||||
#include "VKPipelineState.h"
|
||||
#include "VKRenderPass.h"
|
||||
#include "VKShader.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKPipelineState::CCVKPipelineState(GFXDevice* device)
|
||||
: GFXPipelineState(device)
|
||||
{
|
||||
CCVKPipelineState::CCVKPipelineState(GFXDevice *device)
|
||||
: GFXPipelineState(device) {
|
||||
}
|
||||
|
||||
CCVKPipelineState::~CCVKPipelineState()
|
||||
{
|
||||
CCVKPipelineState::~CCVKPipelineState() {
|
||||
}
|
||||
|
||||
bool CCVKPipelineState::initialize(const GFXPipelineStateInfo &info)
|
||||
{
|
||||
bool CCVKPipelineState::initialize(const GFXPipelineStateInfo &info) {
|
||||
_primitive = info.primitive;
|
||||
_shader = info.shader;
|
||||
_inputState = info.inputState;
|
||||
@@ -27,30 +25,28 @@ bool CCVKPipelineState::initialize(const GFXPipelineStateInfo &info)
|
||||
_dynamicStates = info.dynamicStates;
|
||||
_layout = info.layout;
|
||||
_renderPass = info.renderPass;
|
||||
|
||||
|
||||
_gpuPipelineState = CC_NEW(CCVKGPUPipelineState);
|
||||
_gpuPipelineState->primitive = _primitive;
|
||||
_gpuPipelineState->gpuShader = ((CCVKShader*)_shader)->gpuShader();
|
||||
_gpuPipelineState->gpuShader = ((CCVKShader *)_shader)->gpuShader();
|
||||
_gpuPipelineState->inputState = _inputState;
|
||||
_gpuPipelineState->rs = _rasterizerState;
|
||||
_gpuPipelineState->dss = _depthStencilState;
|
||||
_gpuPipelineState->bs = _blendState;
|
||||
_gpuPipelineState->dynamicStates = _dynamicStates;
|
||||
_gpuPipelineState->gpuLayout = ((CCVKPipelineLayout*)_layout)->gpuPipelineLayout();
|
||||
_gpuPipelineState->gpuRenderPass = ((CCVKRenderPass*)_renderPass)->gpuRenderPass();
|
||||
_gpuPipelineState->gpuLayout = ((CCVKPipelineLayout *)_layout)->gpuPipelineLayout();
|
||||
_gpuPipelineState->gpuRenderPass = ((CCVKRenderPass *)_renderPass)->gpuRenderPass();
|
||||
|
||||
CCVKCmdFuncCreatePipelineState((CCVKDevice *)_device, _gpuPipelineState);
|
||||
|
||||
CCVKCmdFuncCreatePipelineState((CCVKDevice*)_device, _gpuPipelineState);
|
||||
|
||||
_status = GFXStatus::SUCCESS;
|
||||
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKPipelineState::destroy()
|
||||
{
|
||||
if (_gpuPipelineState)
|
||||
{
|
||||
CCVKCmdFuncDestroyPipelineState((CCVKDevice*)_device, _gpuPipelineState);
|
||||
void CCVKPipelineState::destroy() {
|
||||
if (_gpuPipelineState) {
|
||||
CCVKCmdFuncDestroyPipelineState((CCVKDevice *)_device, _gpuPipelineState);
|
||||
CC_DELETE(_gpuPipelineState);
|
||||
_gpuPipelineState = nullptr;
|
||||
}
|
||||
|
||||
@@ -5,20 +5,19 @@ NS_CC_BEGIN
|
||||
|
||||
class CCVKGPUPipelineState;
|
||||
|
||||
class CC_VULKAN_API CCVKPipelineState : public GFXPipelineState
|
||||
{
|
||||
class CC_VULKAN_API CCVKPipelineState : public GFXPipelineState {
|
||||
public:
|
||||
CCVKPipelineState(GFXDevice* device);
|
||||
CCVKPipelineState(GFXDevice *device);
|
||||
~CCVKPipelineState();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXPipelineStateInfo& info);
|
||||
bool initialize(const GFXPipelineStateInfo &info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUPipelineState* gpuPipelineState() const { return _gpuPipelineState; }
|
||||
CC_INLINE CCVKGPUPipelineState *gpuPipelineState() const { return _gpuPipelineState; }
|
||||
|
||||
private:
|
||||
CCVKGPUPipelineState* _gpuPipelineState = nullptr;
|
||||
CCVKGPUPipelineState *_gpuPipelineState = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -1,37 +1,33 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKQueue.h"
|
||||
|
||||
#include "VKCommandBuffer.h"
|
||||
#include "VKCommands.h"
|
||||
#include "VKDevice.h"
|
||||
#include "VKFence.h"
|
||||
#include "VKCommands.h"
|
||||
#include "VKCommandBuffer.h"
|
||||
#include "VKQueue.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKQueue::CCVKQueue(GFXDevice* device)
|
||||
: GFXQueue(device)
|
||||
{
|
||||
CCVKQueue::CCVKQueue(GFXDevice *device)
|
||||
: GFXQueue(device) {
|
||||
}
|
||||
|
||||
CCVKQueue::~CCVKQueue()
|
||||
{
|
||||
CCVKQueue::~CCVKQueue() {
|
||||
}
|
||||
|
||||
bool CCVKQueue::initialize(const GFXQueueInfo &info)
|
||||
{
|
||||
bool CCVKQueue::initialize(const GFXQueueInfo &info) {
|
||||
_type = info.type;
|
||||
|
||||
_gpuQueue = CC_NEW(CCVKGPUQueue);
|
||||
_gpuQueue->type = _type;
|
||||
CCVKCmdFuncGetDeviceQueue((CCVKDevice*)_device, _gpuQueue);
|
||||
CCVKCmdFuncGetDeviceQueue((CCVKDevice *)_device, _gpuQueue);
|
||||
|
||||
_status = GFXStatus::SUCCESS;
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKQueue::destroy()
|
||||
{
|
||||
if (_gpuQueue)
|
||||
{
|
||||
void CCVKQueue::destroy() {
|
||||
if (_gpuQueue) {
|
||||
_gpuQueue->vkQueue = VK_NULL_HANDLE;
|
||||
CC_DELETE(_gpuQueue);
|
||||
_gpuQueue = nullptr;
|
||||
@@ -39,22 +35,19 @@ void CCVKQueue::destroy()
|
||||
_status = GFXStatus::UNREADY;
|
||||
}
|
||||
|
||||
void CCVKQueue::submit(const std::vector<GFXCommandBuffer*>& cmdBuffs, GFXFence* fence)
|
||||
{
|
||||
if (!_isAsync)
|
||||
{
|
||||
void CCVKQueue::submit(const std::vector<GFXCommandBuffer *> &cmdBuffs, GFXFence *fence) {
|
||||
if (!_isAsync) {
|
||||
_gpuQueue->commandBuffers.clear();
|
||||
uint count = cmdBuffs.size();
|
||||
for (uint i = 0u; i < count; ++i)
|
||||
{
|
||||
CCVKCommandBuffer* cmdBuffer = (CCVKCommandBuffer*)cmdBuffs[i];
|
||||
for (uint i = 0u; i < count; ++i) {
|
||||
CCVKCommandBuffer *cmdBuffer = (CCVKCommandBuffer *)cmdBuffs[i];
|
||||
_gpuQueue->commandBuffers.push(cmdBuffer->_gpuCommandBuffer->vkCommandBuffer);
|
||||
_numDrawCalls += cmdBuffer->_numDrawCalls;
|
||||
_numInstances += cmdBuffer->_numInstances;
|
||||
_numTriangles += cmdBuffer->_numTriangles;
|
||||
}
|
||||
|
||||
VkSubmitInfo submitInfo{ VK_STRUCTURE_TYPE_SUBMIT_INFO };
|
||||
VkSubmitInfo submitInfo{VK_STRUCTURE_TYPE_SUBMIT_INFO};
|
||||
submitInfo.waitSemaphoreCount = 1;
|
||||
submitInfo.pWaitSemaphores = &_gpuQueue->nextWaitSemaphore;
|
||||
submitInfo.pWaitDstStageMask = &_gpuQueue->submitStageMask;
|
||||
@@ -63,11 +56,11 @@ void CCVKQueue::submit(const std::vector<GFXCommandBuffer*>& cmdBuffs, GFXFence*
|
||||
submitInfo.signalSemaphoreCount = 1;
|
||||
submitInfo.pSignalSemaphores = &_gpuQueue->nextSignalSemaphore;
|
||||
|
||||
VkFence vkFence = fence ? ((CCVKFence*)fence)->gpuFence()->vkFence : VK_NULL_HANDLE;
|
||||
VkFence vkFence = fence ? ((CCVKFence *)fence)->gpuFence()->vkFence : VK_NULL_HANDLE;
|
||||
VK_CHECK(vkQueueSubmit(_gpuQueue->vkQueue, 1, &submitInfo, vkFence));
|
||||
|
||||
_gpuQueue->nextWaitSemaphore = _gpuQueue->nextSignalSemaphore;
|
||||
_gpuQueue->nextSignalSemaphore = ((CCVKDevice*)_device)->gpuSemaphorePool()->alloc();
|
||||
_gpuQueue->nextSignalSemaphore = ((CCVKDevice *)_device)->gpuSemaphorePool()->alloc();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -7,21 +7,21 @@ class CCVKGPUQueue;
|
||||
|
||||
class CC_VULKAN_API CCVKQueue : public GFXQueue {
|
||||
public:
|
||||
CCVKQueue(GFXDevice* device);
|
||||
CCVKQueue(GFXDevice *device);
|
||||
~CCVKQueue();
|
||||
|
||||
friend class CCVKDevice;
|
||||
|
||||
public:
|
||||
bool initialize(const GFXQueueInfo& info);
|
||||
bool initialize(const GFXQueueInfo &info);
|
||||
void destroy();
|
||||
void submit(const std::vector<GFXCommandBuffer*>& cmd_buffs, GFXFence* fence);
|
||||
void submit(const std::vector<GFXCommandBuffer *> &cmd_buffs, GFXFence *fence);
|
||||
|
||||
CC_INLINE bool isAsync() const { return _isAsync; }
|
||||
CC_INLINE CCVKGPUQueue* gpuQueue() const { return _gpuQueue; }
|
||||
CC_INLINE CCVKGPUQueue *gpuQueue() const { return _gpuQueue; }
|
||||
|
||||
private:
|
||||
CCVKGPUQueue* _gpuQueue;
|
||||
CCVKGPUQueue *_gpuQueue;
|
||||
bool _isAsync = false;
|
||||
uint _numDrawCalls = 0;
|
||||
uint _numInstances = 0;
|
||||
|
||||
@@ -1,20 +1,18 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKRenderPass.h"
|
||||
|
||||
#include "VKCommands.h"
|
||||
#include "VKRenderPass.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKRenderPass::CCVKRenderPass(GFXDevice* device)
|
||||
: GFXRenderPass(device)
|
||||
{
|
||||
CCVKRenderPass::CCVKRenderPass(GFXDevice *device)
|
||||
: GFXRenderPass(device) {
|
||||
}
|
||||
|
||||
CCVKRenderPass::~CCVKRenderPass()
|
||||
{
|
||||
CCVKRenderPass::~CCVKRenderPass() {
|
||||
}
|
||||
|
||||
bool CCVKRenderPass::initialize(const GFXRenderPassInfo &info)
|
||||
{
|
||||
bool CCVKRenderPass::initialize(const GFXRenderPassInfo &info) {
|
||||
_colorAttachments = info.colorAttachments;
|
||||
_depthStencilAttachment = info.depthStencilAttachment;
|
||||
_subPasses = info.subPasses;
|
||||
@@ -23,7 +21,7 @@ bool CCVKRenderPass::initialize(const GFXRenderPassInfo &info)
|
||||
_gpuRenderPass->colorAttachments = _colorAttachments;
|
||||
_gpuRenderPass->depthStencilAttachment = _depthStencilAttachment;
|
||||
_gpuRenderPass->subPasses = _subPasses;
|
||||
CCVKCmdFuncCreateRenderPass((CCVKDevice*)_device, _gpuRenderPass);
|
||||
CCVKCmdFuncCreateRenderPass((CCVKDevice *)_device, _gpuRenderPass);
|
||||
|
||||
_hash = computeHash();
|
||||
_status = GFXStatus::SUCCESS;
|
||||
@@ -31,11 +29,9 @@ bool CCVKRenderPass::initialize(const GFXRenderPassInfo &info)
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKRenderPass::destroy()
|
||||
{
|
||||
if (_gpuRenderPass)
|
||||
{
|
||||
CCVKCmdFuncDestroyRenderPass((CCVKDevice*)_device, _gpuRenderPass);
|
||||
void CCVKRenderPass::destroy() {
|
||||
if (_gpuRenderPass) {
|
||||
CCVKCmdFuncDestroyRenderPass((CCVKDevice *)_device, _gpuRenderPass);
|
||||
CC_DELETE(_gpuRenderPass);
|
||||
_gpuRenderPass = nullptr;
|
||||
}
|
||||
|
||||
@@ -5,20 +5,19 @@ NS_CC_BEGIN
|
||||
|
||||
class CCVKGPURenderPass;
|
||||
|
||||
class CC_VULKAN_API CCVKRenderPass : public GFXRenderPass
|
||||
{
|
||||
class CC_VULKAN_API CCVKRenderPass : public GFXRenderPass {
|
||||
public:
|
||||
CCVKRenderPass(GFXDevice* device);
|
||||
CCVKRenderPass(GFXDevice *device);
|
||||
~CCVKRenderPass();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXRenderPassInfo& info);
|
||||
bool initialize(const GFXRenderPassInfo &info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPURenderPass* gpuRenderPass() const { return _gpuRenderPass; }
|
||||
CC_INLINE CCVKGPURenderPass *gpuRenderPass() const { return _gpuRenderPass; }
|
||||
|
||||
private:
|
||||
CCVKGPURenderPass* _gpuRenderPass = nullptr;
|
||||
CCVKGPURenderPass *_gpuRenderPass = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -1,158 +1,148 @@
|
||||
#ifndef CC_GFXVULKAN_SPIRV_H_
|
||||
#define CC_GFXVULKAN_SPIRV_H_
|
||||
#define CC_GFXVULKAN_SPIRV_H_
|
||||
|
||||
#include "SPIRV/GlslangToSpv.h"
|
||||
#include "glslang/Public/ShaderLang.h"
|
||||
#include "SPIRV/GlslangToSpv.h"
|
||||
#include "glslang/Public/ShaderLang.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
namespace
|
||||
{
|
||||
EShLanguage getShaderStage(GFXShaderType type)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
namespace {
|
||||
EShLanguage getShaderStage(GFXShaderType type) {
|
||||
switch (type) {
|
||||
case GFXShaderType::VERTEX: return EShLangVertex;
|
||||
case GFXShaderType::CONTROL: return EShLangTessControl;
|
||||
case GFXShaderType::EVALUATION: return EShLangTessEvaluation;
|
||||
case GFXShaderType::GEOMETRY: return EShLangGeometry;
|
||||
case GFXShaderType::FRAGMENT: return EShLangFragment;
|
||||
case GFXShaderType::COMPUTE: return EShLangCompute;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXShaderType, convert to EShLanguage failed.");
|
||||
return EShLangVertex;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
glslang::EShTargetClientVersion getClientVersion(int vulkanMinorVersion)
|
||||
{
|
||||
switch (vulkanMinorVersion)
|
||||
{
|
||||
glslang::EShTargetClientVersion getClientVersion(int vulkanMinorVersion) {
|
||||
switch (vulkanMinorVersion) {
|
||||
case 0: return glslang::EShTargetVulkan_1_0;
|
||||
case 1: return glslang::EShTargetVulkan_1_1;
|
||||
case 2: return glslang::EShTargetVulkan_1_2;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported vulkan version, convert to EShTargetClientVersion failed.");
|
||||
return glslang::EShTargetVulkan_1_0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
glslang::EShTargetLanguageVersion getTargetVersion(int vulkanMinorVersion)
|
||||
{
|
||||
switch (vulkanMinorVersion)
|
||||
{
|
||||
glslang::EShTargetLanguageVersion getTargetVersion(int vulkanMinorVersion) {
|
||||
switch (vulkanMinorVersion) {
|
||||
case 0: return glslang::EShTargetSpv_1_0;
|
||||
case 1: return glslang::EShTargetSpv_1_3;
|
||||
case 2: return glslang::EShTargetSpv_1_5;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported vulkan version, convert to EShTargetLanguageVersion failed.");
|
||||
return glslang::EShTargetSpv_1_0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool glslangInitialized = false;
|
||||
bool glslangInitialized = false;
|
||||
|
||||
const TBuiltInResource defaultTBuiltInResource{
|
||||
/* .MaxLights = */ 32,
|
||||
/* .MaxClipPlanes = */ 6,
|
||||
/* .MaxTextureUnits = */ 32,
|
||||
/* .MaxTextureCoords = */ 32,
|
||||
/* .MaxVertexAttribs = */ 64,
|
||||
/* .MaxVertexUniformComponents = */ 4096,
|
||||
/* .MaxVaryingFloats = */ 64,
|
||||
/* .MaxVertexTextureImageUnits = */ 32,
|
||||
/* .MaxCombinedTextureImageUnits = */ 80,
|
||||
/* .MaxTextureImageUnits = */ 32,
|
||||
/* .MaxFragmentUniformComponents = */ 4096,
|
||||
/* .MaxDrawBuffers = */ 32,
|
||||
/* .MaxVertexUniformVectors = */ 128,
|
||||
/* .MaxVaryingVectors = */ 8,
|
||||
/* .MaxFragmentUniformVectors = */ 16,
|
||||
/* .MaxVertexOutputVectors = */ 16,
|
||||
/* .MaxFragmentInputVectors = */ 15,
|
||||
/* .MinProgramTexelOffset = */ -8,
|
||||
/* .MaxProgramTexelOffset = */ 7,
|
||||
/* .MaxClipDistances = */ 8,
|
||||
/* .MaxComputeWorkGroupCountX = */ 65535,
|
||||
/* .MaxComputeWorkGroupCountY = */ 65535,
|
||||
/* .MaxComputeWorkGroupCountZ = */ 65535,
|
||||
/* .MaxComputeWorkGroupSizeX = */ 1024,
|
||||
/* .MaxComputeWorkGroupSizeY = */ 1024,
|
||||
/* .MaxComputeWorkGroupSizeZ = */ 64,
|
||||
/* .MaxComputeUniformComponents = */ 1024,
|
||||
/* .MaxComputeTextureImageUnits = */ 16,
|
||||
/* .MaxComputeImageUniforms = */ 8,
|
||||
/* .MaxComputeAtomicCounters = */ 8,
|
||||
/* .MaxComputeAtomicCounterBuffers = */ 1,
|
||||
/* .MaxVaryingComponents = */ 60,
|
||||
/* .MaxVertexOutputComponents = */ 64,
|
||||
/* .MaxGeometryInputComponents = */ 64,
|
||||
/* .MaxGeometryOutputComponents = */ 128,
|
||||
/* .MaxFragmentInputComponents = */ 128,
|
||||
/* .MaxImageUnits = */ 8,
|
||||
/* .MaxCombinedImageUnitsAndFragmentOutputs = */ 8,
|
||||
/* .MaxCombinedShaderOutputResources = */ 8,
|
||||
/* .MaxImageSamples = */ 0,
|
||||
/* .MaxVertexImageUniforms = */ 0,
|
||||
/* .MaxTessControlImageUniforms = */ 0,
|
||||
/* .MaxTessEvaluationImageUniforms = */ 0,
|
||||
/* .MaxGeometryImageUniforms = */ 0,
|
||||
/* .MaxFragmentImageUniforms = */ 8,
|
||||
/* .MaxCombinedImageUniforms = */ 8,
|
||||
/* .MaxGeometryTextureImageUnits = */ 16,
|
||||
/* .MaxGeometryOutputVertices = */ 256,
|
||||
/* .MaxGeometryTotalOutputComponents = */ 1024,
|
||||
/* .MaxGeometryUniformComponents = */ 1024,
|
||||
/* .MaxGeometryVaryingComponents = */ 64,
|
||||
/* .MaxTessControlInputComponents = */ 128,
|
||||
/* .MaxTessControlOutputComponents = */ 128,
|
||||
/* .MaxTessControlTextureImageUnits = */ 16,
|
||||
/* .MaxTessControlUniformComponents = */ 1024,
|
||||
/* .MaxTessControlTotalOutputComponents = */ 4096,
|
||||
/* .MaxTessEvaluationInputComponents = */ 128,
|
||||
/* .MaxTessEvaluationOutputComponents = */ 128,
|
||||
/* .MaxTessEvaluationTextureImageUnits = */ 16,
|
||||
/* .MaxTessEvaluationUniformComponents = */ 1024,
|
||||
/* .MaxTessPatchComponents = */ 120,
|
||||
/* .MaxPatchVertices = */ 32,
|
||||
/* .MaxTessGenLevel = */ 64,
|
||||
/* .MaxViewports = */ 16,
|
||||
/* .MaxVertexAtomicCounters = */ 0,
|
||||
/* .MaxTessControlAtomicCounters = */ 0,
|
||||
/* .MaxTessEvaluationAtomicCounters = */ 0,
|
||||
/* .MaxGeometryAtomicCounters = */ 0,
|
||||
/* .MaxFragmentAtomicCounters = */ 8,
|
||||
/* .MaxCombinedAtomicCounters = */ 8,
|
||||
/* .MaxAtomicCounterBindings = */ 1,
|
||||
/* .MaxVertexAtomicCounterBuffers = */ 0,
|
||||
/* .MaxTessControlAtomicCounterBuffers = */ 0,
|
||||
/* .MaxTessEvaluationAtomicCounterBuffers = */ 0,
|
||||
/* .MaxGeometryAtomicCounterBuffers = */ 0,
|
||||
/* .MaxFragmentAtomicCounterBuffers = */ 1,
|
||||
/* .MaxCombinedAtomicCounterBuffers = */ 1,
|
||||
/* .MaxAtomicCounterBufferSize = */ 16384,
|
||||
/* .MaxTransformFeedbackBuffers = */ 4,
|
||||
/* .MaxTransformFeedbackInterleavedComponents = */ 64,
|
||||
/* .MaxCullDistances = */ 8,
|
||||
/* .MaxCombinedClipAndCullDistances = */ 8,
|
||||
/* .MaxSamples = */ 4,
|
||||
/* .maxMeshOutputVerticesNV = */ 256,
|
||||
/* .maxMeshOutputPrimitivesNV = */ 512,
|
||||
/* .maxMeshWorkGroupSizeX_NV = */ 32,
|
||||
/* .maxMeshWorkGroupSizeY_NV = */ 1,
|
||||
/* .maxMeshWorkGroupSizeZ_NV = */ 1,
|
||||
/* .maxTaskWorkGroupSizeX_NV = */ 32,
|
||||
/* .maxTaskWorkGroupSizeY_NV = */ 1,
|
||||
/* .maxTaskWorkGroupSizeZ_NV = */ 1,
|
||||
/* .maxMeshViewCountNV = */ 4,
|
||||
const TBuiltInResource defaultTBuiltInResource{
|
||||
/* .MaxLights = */ 32,
|
||||
/* .MaxClipPlanes = */ 6,
|
||||
/* .MaxTextureUnits = */ 32,
|
||||
/* .MaxTextureCoords = */ 32,
|
||||
/* .MaxVertexAttribs = */ 64,
|
||||
/* .MaxVertexUniformComponents = */ 4096,
|
||||
/* .MaxVaryingFloats = */ 64,
|
||||
/* .MaxVertexTextureImageUnits = */ 32,
|
||||
/* .MaxCombinedTextureImageUnits = */ 80,
|
||||
/* .MaxTextureImageUnits = */ 32,
|
||||
/* .MaxFragmentUniformComponents = */ 4096,
|
||||
/* .MaxDrawBuffers = */ 32,
|
||||
/* .MaxVertexUniformVectors = */ 128,
|
||||
/* .MaxVaryingVectors = */ 8,
|
||||
/* .MaxFragmentUniformVectors = */ 16,
|
||||
/* .MaxVertexOutputVectors = */ 16,
|
||||
/* .MaxFragmentInputVectors = */ 15,
|
||||
/* .MinProgramTexelOffset = */ -8,
|
||||
/* .MaxProgramTexelOffset = */ 7,
|
||||
/* .MaxClipDistances = */ 8,
|
||||
/* .MaxComputeWorkGroupCountX = */ 65535,
|
||||
/* .MaxComputeWorkGroupCountY = */ 65535,
|
||||
/* .MaxComputeWorkGroupCountZ = */ 65535,
|
||||
/* .MaxComputeWorkGroupSizeX = */ 1024,
|
||||
/* .MaxComputeWorkGroupSizeY = */ 1024,
|
||||
/* .MaxComputeWorkGroupSizeZ = */ 64,
|
||||
/* .MaxComputeUniformComponents = */ 1024,
|
||||
/* .MaxComputeTextureImageUnits = */ 16,
|
||||
/* .MaxComputeImageUniforms = */ 8,
|
||||
/* .MaxComputeAtomicCounters = */ 8,
|
||||
/* .MaxComputeAtomicCounterBuffers = */ 1,
|
||||
/* .MaxVaryingComponents = */ 60,
|
||||
/* .MaxVertexOutputComponents = */ 64,
|
||||
/* .MaxGeometryInputComponents = */ 64,
|
||||
/* .MaxGeometryOutputComponents = */ 128,
|
||||
/* .MaxFragmentInputComponents = */ 128,
|
||||
/* .MaxImageUnits = */ 8,
|
||||
/* .MaxCombinedImageUnitsAndFragmentOutputs = */ 8,
|
||||
/* .MaxCombinedShaderOutputResources = */ 8,
|
||||
/* .MaxImageSamples = */ 0,
|
||||
/* .MaxVertexImageUniforms = */ 0,
|
||||
/* .MaxTessControlImageUniforms = */ 0,
|
||||
/* .MaxTessEvaluationImageUniforms = */ 0,
|
||||
/* .MaxGeometryImageUniforms = */ 0,
|
||||
/* .MaxFragmentImageUniforms = */ 8,
|
||||
/* .MaxCombinedImageUniforms = */ 8,
|
||||
/* .MaxGeometryTextureImageUnits = */ 16,
|
||||
/* .MaxGeometryOutputVertices = */ 256,
|
||||
/* .MaxGeometryTotalOutputComponents = */ 1024,
|
||||
/* .MaxGeometryUniformComponents = */ 1024,
|
||||
/* .MaxGeometryVaryingComponents = */ 64,
|
||||
/* .MaxTessControlInputComponents = */ 128,
|
||||
/* .MaxTessControlOutputComponents = */ 128,
|
||||
/* .MaxTessControlTextureImageUnits = */ 16,
|
||||
/* .MaxTessControlUniformComponents = */ 1024,
|
||||
/* .MaxTessControlTotalOutputComponents = */ 4096,
|
||||
/* .MaxTessEvaluationInputComponents = */ 128,
|
||||
/* .MaxTessEvaluationOutputComponents = */ 128,
|
||||
/* .MaxTessEvaluationTextureImageUnits = */ 16,
|
||||
/* .MaxTessEvaluationUniformComponents = */ 1024,
|
||||
/* .MaxTessPatchComponents = */ 120,
|
||||
/* .MaxPatchVertices = */ 32,
|
||||
/* .MaxTessGenLevel = */ 64,
|
||||
/* .MaxViewports = */ 16,
|
||||
/* .MaxVertexAtomicCounters = */ 0,
|
||||
/* .MaxTessControlAtomicCounters = */ 0,
|
||||
/* .MaxTessEvaluationAtomicCounters = */ 0,
|
||||
/* .MaxGeometryAtomicCounters = */ 0,
|
||||
/* .MaxFragmentAtomicCounters = */ 8,
|
||||
/* .MaxCombinedAtomicCounters = */ 8,
|
||||
/* .MaxAtomicCounterBindings = */ 1,
|
||||
/* .MaxVertexAtomicCounterBuffers = */ 0,
|
||||
/* .MaxTessControlAtomicCounterBuffers = */ 0,
|
||||
/* .MaxTessEvaluationAtomicCounterBuffers = */ 0,
|
||||
/* .MaxGeometryAtomicCounterBuffers = */ 0,
|
||||
/* .MaxFragmentAtomicCounterBuffers = */ 1,
|
||||
/* .MaxCombinedAtomicCounterBuffers = */ 1,
|
||||
/* .MaxAtomicCounterBufferSize = */ 16384,
|
||||
/* .MaxTransformFeedbackBuffers = */ 4,
|
||||
/* .MaxTransformFeedbackInterleavedComponents = */ 64,
|
||||
/* .MaxCullDistances = */ 8,
|
||||
/* .MaxCombinedClipAndCullDistances = */ 8,
|
||||
/* .MaxSamples = */ 4,
|
||||
/* .maxMeshOutputVerticesNV = */ 256,
|
||||
/* .maxMeshOutputPrimitivesNV = */ 512,
|
||||
/* .maxMeshWorkGroupSizeX_NV = */ 32,
|
||||
/* .maxMeshWorkGroupSizeY_NV = */ 1,
|
||||
/* .maxMeshWorkGroupSizeZ_NV = */ 1,
|
||||
/* .maxTaskWorkGroupSizeX_NV = */ 32,
|
||||
/* .maxTaskWorkGroupSizeY_NV = */ 1,
|
||||
/* .maxTaskWorkGroupSizeZ_NV = */ 1,
|
||||
/* .maxMeshViewCountNV = */ 4,
|
||||
|
||||
/* .limits = */ {
|
||||
/* .limits = */ {
|
||||
/* .nonInductiveForLoops = */ 1,
|
||||
/* .whileLoops = */ 1,
|
||||
/* .doWhileLoops = */ 1,
|
||||
@@ -162,52 +152,48 @@ namespace
|
||||
/* .generalSamplerIndexing = */ 1,
|
||||
/* .generalVariableIndexing = */ 1,
|
||||
/* .generalConstantMatrixVectorIndexing = */ 1,
|
||||
} };
|
||||
}};
|
||||
|
||||
const vector<unsigned int>::type GLSL2SPIRV(GFXShaderType type, const String &source, int vulkanMinorVersion = 2)
|
||||
{
|
||||
if (!glslangInitialized)
|
||||
{
|
||||
glslang::InitializeProcess();
|
||||
glslangInitialized = true;
|
||||
}
|
||||
|
||||
EShLanguage stage = getShaderStage(type);
|
||||
const char* string = source.c_str();
|
||||
glslang::TShader shader(stage);
|
||||
shader.setStrings(&string, 1);
|
||||
|
||||
int clientInputSemanticsVersion = 100 + vulkanMinorVersion * 10;
|
||||
glslang::EShTargetClientVersion clientVersion = getClientVersion(vulkanMinorVersion);
|
||||
glslang::EShTargetLanguageVersion targetVersion = getTargetVersion(vulkanMinorVersion);
|
||||
|
||||
shader.setEnvInput(glslang::EShSourceGlsl, stage, glslang::EShClientVulkan, clientInputSemanticsVersion);
|
||||
shader.setEnvClient(glslang::EShClientVulkan, clientVersion);
|
||||
shader.setEnvTarget(glslang::EShTargetSpv, targetVersion);
|
||||
|
||||
EShMessages messages = (EShMessages)(EShMsgSpvRules | EShMsgVulkanRules);
|
||||
|
||||
if (!shader.parse(&defaultTBuiltInResource, clientInputSemanticsVersion, false, messages))
|
||||
{
|
||||
CC_LOG_ERROR("GLSL Parsing Failed:\n%s\n%s", shader.getInfoLog(), shader.getInfoDebugLog());
|
||||
}
|
||||
|
||||
glslang::TProgram program;
|
||||
program.addShader(&shader);
|
||||
|
||||
if (!program.link(messages))
|
||||
{
|
||||
CC_LOG_ERROR("GLSL Linking Failed:\n%s\n%s", program.getInfoLog(), program.getInfoDebugLog());
|
||||
}
|
||||
|
||||
std::vector<unsigned int> spirv;
|
||||
spv::SpvBuildLogger logger;
|
||||
glslang::SpvOptions spvOptions;
|
||||
glslang::GlslangToSpv(*program.getIntermediate(stage), spirv, &logger, &spvOptions);
|
||||
|
||||
return std::move(spirv);
|
||||
const vector<unsigned int>::type GLSL2SPIRV(GFXShaderType type, const String &source, int vulkanMinorVersion = 2) {
|
||||
if (!glslangInitialized) {
|
||||
glslang::InitializeProcess();
|
||||
glslangInitialized = true;
|
||||
}
|
||||
|
||||
EShLanguage stage = getShaderStage(type);
|
||||
const char *string = source.c_str();
|
||||
glslang::TShader shader(stage);
|
||||
shader.setStrings(&string, 1);
|
||||
|
||||
int clientInputSemanticsVersion = 100 + vulkanMinorVersion * 10;
|
||||
glslang::EShTargetClientVersion clientVersion = getClientVersion(vulkanMinorVersion);
|
||||
glslang::EShTargetLanguageVersion targetVersion = getTargetVersion(vulkanMinorVersion);
|
||||
|
||||
shader.setEnvInput(glslang::EShSourceGlsl, stage, glslang::EShClientVulkan, clientInputSemanticsVersion);
|
||||
shader.setEnvClient(glslang::EShClientVulkan, clientVersion);
|
||||
shader.setEnvTarget(glslang::EShTargetSpv, targetVersion);
|
||||
|
||||
EShMessages messages = (EShMessages)(EShMsgSpvRules | EShMsgVulkanRules);
|
||||
|
||||
if (!shader.parse(&defaultTBuiltInResource, clientInputSemanticsVersion, false, messages)) {
|
||||
CC_LOG_ERROR("GLSL Parsing Failed:\n%s\n%s", shader.getInfoLog(), shader.getInfoDebugLog());
|
||||
}
|
||||
|
||||
glslang::TProgram program;
|
||||
program.addShader(&shader);
|
||||
|
||||
if (!program.link(messages)) {
|
||||
CC_LOG_ERROR("GLSL Linking Failed:\n%s\n%s", program.getInfoLog(), program.getInfoDebugLog());
|
||||
}
|
||||
|
||||
std::vector<unsigned int> spirv;
|
||||
spv::SpvBuildLogger logger;
|
||||
glslang::SpvOptions spvOptions;
|
||||
glslang::GlslangToSpv(*program.getIntermediate(stage), spirv, &logger, &spvOptions);
|
||||
|
||||
return std::move(spirv);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
@@ -1,20 +1,18 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKSampler.h"
|
||||
|
||||
#include "VKCommands.h"
|
||||
#include "VKSampler.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKSampler::CCVKSampler(GFXDevice* device)
|
||||
: GFXSampler(device)
|
||||
{
|
||||
CCVKSampler::CCVKSampler(GFXDevice *device)
|
||||
: GFXSampler(device) {
|
||||
}
|
||||
|
||||
CCVKSampler::~CCVKSampler()
|
||||
{
|
||||
CCVKSampler::~CCVKSampler() {
|
||||
}
|
||||
|
||||
bool CCVKSampler::initialize(const GFXSamplerInfo &info)
|
||||
{
|
||||
bool CCVKSampler::initialize(const GFXSamplerInfo &info) {
|
||||
_name = info.name;
|
||||
_minFilter = info.minFilter;
|
||||
_magFilter = info.magFilter;
|
||||
@@ -43,18 +41,16 @@ bool CCVKSampler::initialize(const GFXSamplerInfo &info)
|
||||
_gpuSampler->maxLOD = _maxLOD;
|
||||
_gpuSampler->mipLODBias = _mipLODBias;
|
||||
|
||||
CCVKCmdFuncCreateSampler((CCVKDevice*)_device, _gpuSampler);
|
||||
CCVKCmdFuncCreateSampler((CCVKDevice *)_device, _gpuSampler);
|
||||
|
||||
_status = GFXStatus::SUCCESS;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKSampler::destroy()
|
||||
{
|
||||
if (_gpuSampler)
|
||||
{
|
||||
CCVKCmdFuncDestroySampler((CCVKDevice*)_device, _gpuSampler);
|
||||
void CCVKSampler::destroy() {
|
||||
if (_gpuSampler) {
|
||||
CCVKCmdFuncDestroySampler((CCVKDevice *)_device, _gpuSampler);
|
||||
CC_DELETE(_gpuSampler);
|
||||
_gpuSampler = nullptr;
|
||||
}
|
||||
|
||||
@@ -7,17 +7,17 @@ class CCVKGPUSampler;
|
||||
|
||||
class CC_VULKAN_API CCVKSampler : public GFXSampler {
|
||||
public:
|
||||
CCVKSampler(GFXDevice* device);
|
||||
~CCVKSampler();
|
||||
|
||||
CCVKSampler(GFXDevice *device);
|
||||
~CCVKSampler();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXSamplerInfo& info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUSampler* gpuSampler() const { return _gpuSampler; }
|
||||
|
||||
bool initialize(const GFXSamplerInfo &info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUSampler *gpuSampler() const { return _gpuSampler; }
|
||||
|
||||
private:
|
||||
CCVKGPUSampler* _gpuSampler = nullptr;
|
||||
CCVKGPUSampler *_gpuSampler = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -1,20 +1,18 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKShader.h"
|
||||
|
||||
#include "VKCommands.h"
|
||||
#include "VKShader.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKShader::CCVKShader(GFXDevice* device)
|
||||
: GFXShader(device)
|
||||
{
|
||||
CCVKShader::CCVKShader(GFXDevice *device)
|
||||
: GFXShader(device) {
|
||||
}
|
||||
|
||||
CCVKShader::~CCVKShader()
|
||||
{
|
||||
CCVKShader::~CCVKShader() {
|
||||
}
|
||||
|
||||
bool CCVKShader::initialize(const GFXShaderInfo &info)
|
||||
{
|
||||
bool CCVKShader::initialize(const GFXShaderInfo &info) {
|
||||
_name = info.name;
|
||||
_stages = info.stages;
|
||||
_blocks = info.blocks;
|
||||
@@ -24,23 +22,20 @@ bool CCVKShader::initialize(const GFXShaderInfo &info)
|
||||
_gpuShader->name = _name;
|
||||
_gpuShader->blocks = _blocks;
|
||||
_gpuShader->samplers = _samplers;
|
||||
for (const auto& stage : _stages)
|
||||
{
|
||||
_gpuShader->gpuStages.push_back({ stage.type, stage.source, stage.macros });
|
||||
for (GFXShaderStage &stage : _stages) {
|
||||
_gpuShader->gpuStages.push_back({stage.type, stage.source, stage.macros});
|
||||
}
|
||||
|
||||
CCVKCmdFuncCreateShader((CCVKDevice*)_device, _gpuShader);
|
||||
CCVKCmdFuncCreateShader((CCVKDevice *)_device, _gpuShader);
|
||||
|
||||
_status = GFXStatus::SUCCESS;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKShader::destroy()
|
||||
{
|
||||
if (_gpuShader)
|
||||
{
|
||||
CCVKCmdFuncDestroyShader((CCVKDevice*)_device, _gpuShader);
|
||||
void CCVKShader::destroy() {
|
||||
if (_gpuShader) {
|
||||
CCVKCmdFuncDestroyShader((CCVKDevice *)_device, _gpuShader);
|
||||
CC_DELETE(_gpuShader);
|
||||
_gpuShader = nullptr;
|
||||
}
|
||||
|
||||
@@ -6,17 +6,18 @@ NS_CC_BEGIN
|
||||
class CCVKGPUShader;
|
||||
|
||||
class CC_VULKAN_API CCVKShader : public GFXShader {
|
||||
public:
|
||||
CCVKShader(GFXDevice* device);
|
||||
~CCVKShader();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXShaderInfo& info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUShader* gpuShader() const { return _gpuShader; }
|
||||
private:
|
||||
CCVKGPUShader* _gpuShader = nullptr;
|
||||
public:
|
||||
CCVKShader(GFXDevice *device);
|
||||
~CCVKShader();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXShaderInfo &info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUShader *gpuShader() const { return _gpuShader; }
|
||||
|
||||
private:
|
||||
CCVKGPUShader *_gpuShader = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -4,38 +4,34 @@
|
||||
#include <Core.h>
|
||||
|
||||
#if (CC_PLATFORM == CC_PLATFORM_WINDOWS)
|
||||
# if defined(CC_STATIC)
|
||||
# define CC_VULKAN_API
|
||||
# else
|
||||
# ifdef CC_VK_EXPORTS
|
||||
# define CC_VULKAN_API __declspec(dllexport)
|
||||
# else
|
||||
# define CC_VULKAN_API __declspec(dllimport)
|
||||
# endif
|
||||
# endif
|
||||
#if defined(CC_STATIC)
|
||||
#define CC_VULKAN_API
|
||||
#else
|
||||
#ifdef CC_VK_EXPORTS
|
||||
#define CC_VULKAN_API __declspec(dllexport)
|
||||
#else
|
||||
#define CC_VULKAN_API __declspec(dllimport)
|
||||
#endif
|
||||
#endif
|
||||
#else
|
||||
# define CC_VULKAN_API
|
||||
#define CC_VULKAN_API
|
||||
#endif
|
||||
|
||||
#define VK_CHECK(x) \
|
||||
do \
|
||||
{ \
|
||||
do { \
|
||||
VkResult err = x; \
|
||||
if (err) \
|
||||
{ \
|
||||
if (err) { \
|
||||
CC_LOG_ERROR("Detected Vulkan error: %d", err); \
|
||||
CCASSERT(0, "Vulkan Error"); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define ASSERT_VK_HANDLE(handle) \
|
||||
do \
|
||||
{ \
|
||||
if ((handle) == VK_NULL_HANDLE) \
|
||||
{ \
|
||||
CC_LOG_ERROR("Handle is NULL"); \
|
||||
CCASSERT(0); \
|
||||
} \
|
||||
do { \
|
||||
if ((handle) == VK_NULL_HANDLE) { \
|
||||
CC_LOG_ERROR("Handle is NULL"); \
|
||||
CCASSERT(0); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#endif
|
||||
|
||||
@@ -1,20 +1,18 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKTexture.h"
|
||||
|
||||
#include "VKCommands.h"
|
||||
#include "VKTexture.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKTexture::CCVKTexture(GFXDevice* device)
|
||||
: GFXTexture(device)
|
||||
{
|
||||
CCVKTexture::CCVKTexture(GFXDevice *device)
|
||||
: GFXTexture(device) {
|
||||
}
|
||||
|
||||
CCVKTexture::~CCVKTexture()
|
||||
{
|
||||
CCVKTexture::~CCVKTexture() {
|
||||
}
|
||||
|
||||
bool CCVKTexture::initialize(const GFXTextureInfo &info)
|
||||
{
|
||||
bool CCVKTexture::initialize(const GFXTextureInfo &info) {
|
||||
_type = info.type;
|
||||
_usage = info.usage;
|
||||
_format = info.format;
|
||||
@@ -27,61 +25,44 @@ bool CCVKTexture::initialize(const GFXTextureInfo &info)
|
||||
_flags = info.flags;
|
||||
_size = GFXFormatSize(_format, _width, _height, _depth);
|
||||
|
||||
if (_flags & GFXTextureFlags::BAKUP_BUFFER)
|
||||
{
|
||||
_buffer = (uint8_t*)CC_MALLOC(_size);
|
||||
if (_flags & GFXTextureFlags::BAKUP_BUFFER) {
|
||||
_buffer = (uint8_t *)CC_MALLOC(_size);
|
||||
_device->getMemoryStatus().textureSize += _size;
|
||||
}
|
||||
|
||||
_gpuTexture = CC_NEW(CCVKGPUTexture);
|
||||
_gpuTexture->type = _type;
|
||||
|
||||
switch (_type)
|
||||
{
|
||||
case GFXTextureType::TEX1D:
|
||||
{
|
||||
if (_arrayLayer)
|
||||
{
|
||||
_gpuTexture->viewType = _arrayLayer <= 1 ? GFXTextureViewType::TV1D : GFXTextureViewType::TV1D_ARRAY;
|
||||
switch (_type) {
|
||||
case GFXTextureType::TEX1D: {
|
||||
if (_arrayLayer) {
|
||||
_gpuTexture->viewType = _arrayLayer <= 1 ? GFXTextureViewType::TV1D : GFXTextureViewType::TV1D_ARRAY;
|
||||
} else {
|
||||
_gpuTexture->viewType = GFXTextureViewType::TV1D;
|
||||
}
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
_gpuTexture->viewType = GFXTextureViewType::TV1D;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case GFXTextureType::TEX2D:
|
||||
{
|
||||
if (_arrayLayer)
|
||||
{
|
||||
if (_arrayLayer <= 1)
|
||||
{
|
||||
case GFXTextureType::TEX2D: {
|
||||
if (_arrayLayer) {
|
||||
if (_arrayLayer <= 1) {
|
||||
_gpuTexture->viewType = GFXTextureViewType::TV2D;
|
||||
} else if (_flags & GFXTextureFlagBit::CUBEMAP) {
|
||||
_gpuTexture->viewType = GFXTextureViewType::CUBE;
|
||||
} else {
|
||||
_gpuTexture->viewType = GFXTextureViewType::TV2D_ARRAY;
|
||||
}
|
||||
} else {
|
||||
_gpuTexture->viewType = GFXTextureViewType::TV2D;
|
||||
}
|
||||
else if (_flags & GFXTextureFlagBit::CUBEMAP)
|
||||
{
|
||||
_gpuTexture->viewType = GFXTextureViewType::CUBE;
|
||||
}
|
||||
else
|
||||
{
|
||||
_gpuTexture->viewType = GFXTextureViewType::TV2D_ARRAY;
|
||||
}
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
case GFXTextureType::TEX3D: {
|
||||
_gpuTexture->viewType = GFXTextureViewType::TV3D;
|
||||
break;
|
||||
}
|
||||
default: {
|
||||
_gpuTexture->viewType = GFXTextureViewType::TV2D;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case GFXTextureType::TEX3D:
|
||||
{
|
||||
_gpuTexture->viewType = GFXTextureViewType::TV3D;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
_gpuTexture->viewType = GFXTextureViewType::TV2D;
|
||||
}
|
||||
}
|
||||
|
||||
_gpuTexture->format = _format;
|
||||
@@ -96,13 +77,10 @@ bool CCVKTexture::initialize(const GFXTextureInfo &info)
|
||||
_gpuTexture->flags = _flags;
|
||||
_gpuTexture->isPowerOf2 = math::IsPowerOfTwo(_width) && math::IsPowerOfTwo(_height);
|
||||
|
||||
if (CCVKCmdFuncCreateTexture((CCVKDevice*)_device, _gpuTexture))
|
||||
{
|
||||
if (CCVKCmdFuncCreateTexture((CCVKDevice *)_device, _gpuTexture)) {
|
||||
_device->getMemoryStatus().textureSize += _size;
|
||||
_status = GFXStatus::SUCCESS;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
CC_DELETE(_gpuTexture);
|
||||
_gpuTexture = nullptr;
|
||||
_status = GFXStatus::FAILED;
|
||||
@@ -112,18 +90,15 @@ bool CCVKTexture::initialize(const GFXTextureInfo &info)
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKTexture::destroy()
|
||||
{
|
||||
if (_gpuTexture)
|
||||
{
|
||||
CCVKCmdFuncDestroyTexture((CCVKDevice*)_device, _gpuTexture);
|
||||
void CCVKTexture::destroy() {
|
||||
if (_gpuTexture) {
|
||||
CCVKCmdFuncDestroyTexture((CCVKDevice *)_device, _gpuTexture);
|
||||
_device->getMemoryStatus().textureSize -= _size;
|
||||
CC_DELETE(_gpuTexture);
|
||||
_gpuTexture = nullptr;
|
||||
}
|
||||
|
||||
if (_buffer)
|
||||
{
|
||||
if (_buffer) {
|
||||
CC_FREE(_buffer);
|
||||
_device->getMemoryStatus().textureSize -= _size;
|
||||
_buffer = nullptr;
|
||||
@@ -132,28 +107,25 @@ void CCVKTexture::destroy()
|
||||
_status = GFXStatus::UNREADY;
|
||||
}
|
||||
|
||||
void CCVKTexture::resize(uint width, uint height)
|
||||
{
|
||||
void CCVKTexture::resize(uint width, uint height) {
|
||||
uint size = GFXFormatSize(_format, width, height, _depth);
|
||||
if (_size != size)
|
||||
{
|
||||
if (_size != size) {
|
||||
const uint old_size = _size;
|
||||
_width = width;
|
||||
_height = height;
|
||||
_size = size;
|
||||
|
||||
GFXMemoryStatus& status = _device->getMemoryStatus();
|
||||
GFXMemoryStatus &status = _device->getMemoryStatus();
|
||||
_gpuTexture->width = _width;
|
||||
_gpuTexture->height = _height;
|
||||
_gpuTexture->size = _size;
|
||||
CCVKCmdFuncResizeTexture((CCVKDevice*)_device, _gpuTexture);
|
||||
CCVKCmdFuncResizeTexture((CCVKDevice *)_device, _gpuTexture);
|
||||
status.bufferSize -= old_size;
|
||||
status.bufferSize += _size;
|
||||
|
||||
if (_buffer)
|
||||
{
|
||||
const uint8_t* old_buff = _buffer;
|
||||
_buffer = (uint8_t*)CC_MALLOC(_size);
|
||||
if (_buffer) {
|
||||
const uint8_t *old_buff = _buffer;
|
||||
_buffer = (uint8_t *)CC_MALLOC(_size);
|
||||
memcpy(_buffer, old_buff, old_size);
|
||||
CC_FREE(_buffer);
|
||||
status.bufferSize -= old_size;
|
||||
|
||||
@@ -6,19 +6,19 @@ NS_CC_BEGIN
|
||||
class CCVKGPUTexture;
|
||||
|
||||
class CC_VULKAN_API CCVKTexture : public GFXTexture {
|
||||
public:
|
||||
CCVKTexture(GFXDevice* device);
|
||||
~CCVKTexture();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXTextureInfo& info);
|
||||
void destroy();
|
||||
void resize(uint width, uint height);
|
||||
|
||||
CC_INLINE CCVKGPUTexture* gpuTexture() const { return _gpuTexture; }
|
||||
public:
|
||||
CCVKTexture(GFXDevice *device);
|
||||
~CCVKTexture();
|
||||
|
||||
private:
|
||||
CCVKGPUTexture* _gpuTexture = nullptr;
|
||||
public:
|
||||
bool initialize(const GFXTextureInfo &info);
|
||||
void destroy();
|
||||
void resize(uint width, uint height);
|
||||
|
||||
CC_INLINE CCVKGPUTexture *gpuTexture() const { return _gpuTexture; }
|
||||
|
||||
private:
|
||||
CCVKGPUTexture *_gpuTexture = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -1,21 +1,19 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKTextureView.h"
|
||||
#include "VKTexture.h"
|
||||
|
||||
#include "VKCommands.h"
|
||||
#include "VKTexture.h"
|
||||
#include "VKTextureView.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKTextureView::CCVKTextureView(GFXDevice* device)
|
||||
: GFXTextureView(device)
|
||||
{
|
||||
CCVKTextureView::CCVKTextureView(GFXDevice *device)
|
||||
: GFXTextureView(device) {
|
||||
}
|
||||
|
||||
CCVKTextureView::~CCVKTextureView()
|
||||
{
|
||||
CCVKTextureView::~CCVKTextureView() {
|
||||
}
|
||||
|
||||
bool CCVKTextureView::initialize(const GFXTextureViewInfo &info)
|
||||
{
|
||||
bool CCVKTextureView::initialize(const GFXTextureViewInfo &info) {
|
||||
_texture = info.texture;
|
||||
_type = info.type;
|
||||
_format = info.format;
|
||||
@@ -23,31 +21,28 @@ bool CCVKTextureView::initialize(const GFXTextureViewInfo &info)
|
||||
_levelCount = info.levelCount;
|
||||
_baseLayer = info.baseLayer;
|
||||
_layerCount = info.layerCount;
|
||||
if(_texture == nullptr)
|
||||
{
|
||||
if (_texture == nullptr) {
|
||||
CC_LOG_ERROR("CCVKTextureView: texture should not be nullptr.");
|
||||
_status = GFXStatus::FAILED;
|
||||
return false;
|
||||
}
|
||||
_gpuTexView = CC_NEW(CCVKGPUTextureView);
|
||||
_gpuTexView->gpuTexture = static_cast<CCVKTexture*>(_texture)->gpuTexture();
|
||||
_gpuTexView->gpuTexture = static_cast<CCVKTexture *>(_texture)->gpuTexture();
|
||||
_gpuTexView->type = _type;
|
||||
_gpuTexView->format = _format;
|
||||
_gpuTexView->baseLevel = info.baseLevel;
|
||||
_gpuTexView->levelCount = info.levelCount;
|
||||
|
||||
CCVKCmdFuncCreateTextureView((CCVKDevice*)_device, _gpuTexView);
|
||||
CCVKCmdFuncCreateTextureView((CCVKDevice *)_device, _gpuTexView);
|
||||
|
||||
_status = GFXStatus::SUCCESS;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKTextureView::destroy()
|
||||
{
|
||||
if (_gpuTexView)
|
||||
{
|
||||
CCVKCmdFuncDestroyTextureView((CCVKDevice*)_device, _gpuTexView);
|
||||
void CCVKTextureView::destroy() {
|
||||
if (_gpuTexView) {
|
||||
CCVKCmdFuncDestroyTextureView((CCVKDevice *)_device, _gpuTexView);
|
||||
CC_DELETE(_gpuTexView);
|
||||
_gpuTexView = nullptr;
|
||||
}
|
||||
|
||||
@@ -7,17 +7,17 @@ class CCVKGPUTextureView;
|
||||
|
||||
class CC_VULKAN_API CCVKTextureView : public GFXTextureView {
|
||||
public:
|
||||
CCVKTextureView(GFXDevice* device);
|
||||
~CCVKTextureView();
|
||||
|
||||
CCVKTextureView(GFXDevice *device);
|
||||
~CCVKTextureView();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXTextureViewInfo& info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUTextureView* gpuTexView() const { return _gpuTexView; }
|
||||
|
||||
bool initialize(const GFXTextureViewInfo &info);
|
||||
void destroy();
|
||||
|
||||
CC_INLINE CCVKGPUTextureView *gpuTexView() const { return _gpuTexView; }
|
||||
|
||||
private:
|
||||
CCVKGPUTextureView* _gpuTexView = nullptr;
|
||||
CCVKGPUTextureView *_gpuTexView = nullptr;
|
||||
};
|
||||
|
||||
NS_CC_END
|
||||
|
||||
@@ -10,12 +10,9 @@
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
namespace
|
||||
{
|
||||
VkFormat MapVkFormat(GFXFormat format)
|
||||
{
|
||||
switch (format)
|
||||
{
|
||||
namespace {
|
||||
VkFormat MapVkFormat(GFXFormat format) {
|
||||
switch (format) {
|
||||
case GFXFormat::R8: return VK_FORMAT_R8_UNORM;
|
||||
case GFXFormat::R8SN: return VK_FORMAT_R8_SNORM;
|
||||
case GFXFormat::R8UI: return VK_FORMAT_R8_UINT;
|
||||
@@ -106,59 +103,57 @@ namespace
|
||||
case GFXFormat::PVRTC_RGBA4: return VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
|
||||
case GFXFormat::PVRTC2_2BPP: return VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG;
|
||||
case GFXFormat::PVRTC2_4BPP: return VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXFormat, convert to VkFormat failed.");
|
||||
return VK_FORMAT_B8G8R8A8_UNORM;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkSampleCountFlagBits MapVkSampleCount(uint sampleCount)
|
||||
{
|
||||
if (sampleCount == 1) return VK_SAMPLE_COUNT_1_BIT;
|
||||
else if (sampleCount == 2) return VK_SAMPLE_COUNT_2_BIT;
|
||||
else if (sampleCount == 4) return VK_SAMPLE_COUNT_4_BIT;
|
||||
else if (sampleCount == 8) return VK_SAMPLE_COUNT_8_BIT;
|
||||
else if (sampleCount == 16) return VK_SAMPLE_COUNT_16_BIT;
|
||||
else if (sampleCount == 32) return VK_SAMPLE_COUNT_32_BIT;
|
||||
else if (sampleCount == 64) return VK_SAMPLE_COUNT_64_BIT;
|
||||
else return VK_SAMPLE_COUNT_1_BIT;
|
||||
}
|
||||
VkSampleCountFlagBits MapVkSampleCount(uint sampleCount) {
|
||||
if (sampleCount == 1)
|
||||
return VK_SAMPLE_COUNT_1_BIT;
|
||||
else if (sampleCount == 2)
|
||||
return VK_SAMPLE_COUNT_2_BIT;
|
||||
else if (sampleCount == 4)
|
||||
return VK_SAMPLE_COUNT_4_BIT;
|
||||
else if (sampleCount == 8)
|
||||
return VK_SAMPLE_COUNT_8_BIT;
|
||||
else if (sampleCount == 16)
|
||||
return VK_SAMPLE_COUNT_16_BIT;
|
||||
else if (sampleCount == 32)
|
||||
return VK_SAMPLE_COUNT_32_BIT;
|
||||
else if (sampleCount == 64)
|
||||
return VK_SAMPLE_COUNT_64_BIT;
|
||||
else
|
||||
return VK_SAMPLE_COUNT_1_BIT;
|
||||
}
|
||||
|
||||
VkAttachmentLoadOp MapVkLoadOp(GFXLoadOp loadOp)
|
||||
{
|
||||
switch (loadOp)
|
||||
{
|
||||
VkAttachmentLoadOp MapVkLoadOp(GFXLoadOp loadOp) {
|
||||
switch (loadOp) {
|
||||
case GFXLoadOp::CLEAR: return VK_ATTACHMENT_LOAD_OP_CLEAR;
|
||||
case GFXLoadOp::LOAD: return VK_ATTACHMENT_LOAD_OP_LOAD;
|
||||
case GFXLoadOp::DISCARD: return VK_ATTACHMENT_LOAD_OP_DONT_CARE;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXLoadOp, convert to VkLoadOp failed.");
|
||||
return VK_ATTACHMENT_LOAD_OP_LOAD;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkAttachmentStoreOp MapVkStoreOp(GFXStoreOp storeOp)
|
||||
{
|
||||
switch (storeOp)
|
||||
{
|
||||
VkAttachmentStoreOp MapVkStoreOp(GFXStoreOp storeOp) {
|
||||
switch (storeOp) {
|
||||
case GFXStoreOp::STORE: return VK_ATTACHMENT_STORE_OP_STORE;
|
||||
case GFXStoreOp::DISCARD: return VK_ATTACHMENT_STORE_OP_DONT_CARE;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXStoreOp, convert to VkStoreOp failed.");
|
||||
return VK_ATTACHMENT_STORE_OP_STORE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkImageLayout MapVkImageLayout(GFXTextureLayout layout)
|
||||
{
|
||||
switch (layout)
|
||||
{
|
||||
VkImageLayout MapVkImageLayout(GFXTextureLayout layout) {
|
||||
switch (layout) {
|
||||
case GFXTextureLayout::UNDEFINED: return VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
case GFXTextureLayout::GENERAL: return VK_IMAGE_LAYOUT_GENERAL;
|
||||
case GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL: return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
@@ -169,18 +164,15 @@ namespace
|
||||
case GFXTextureLayout::TRANSFER_DST_OPTIMAL: return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||||
case GFXTextureLayout::PREINITIALIZED: return VK_IMAGE_LAYOUT_PREINITIALIZED;
|
||||
case GFXTextureLayout::PRESENT_SRC: return VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXTextureLayout, convert to VkImageLayout failed.");
|
||||
return VK_IMAGE_LAYOUT_GENERAL;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkAccessFlags MapVkAccessFlags(GFXTextureLayout layout)
|
||||
{
|
||||
switch (layout)
|
||||
{
|
||||
VkAccessFlags MapVkAccessFlags(GFXTextureLayout layout) {
|
||||
switch (layout) {
|
||||
case GFXTextureLayout::UNDEFINED: return 0;
|
||||
case GFXTextureLayout::GENERAL: return 0;
|
||||
case GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL: return VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||||
@@ -191,442 +183,395 @@ namespace
|
||||
case GFXTextureLayout::TRANSFER_DST_OPTIMAL: return VK_ACCESS_TRANSFER_WRITE_BIT;
|
||||
case GFXTextureLayout::PREINITIALIZED: return 0;
|
||||
case GFXTextureLayout::PRESENT_SRC: return 0;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXTextureLayout, convert to VkImageLayout failed.");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkAccessFlags MapVkAccessFlags(GFXTextureUsage usage, GFXFormat format)
|
||||
{
|
||||
if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||||
if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
||||
if (usage & GFXTextureUsage::INPUT_ATTACHMENT) return VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
|
||||
if (usage & GFXTextureUsage::SAMPLED)
|
||||
{
|
||||
if (GFX_FORMAT_INFOS[(uint)format].hasDepth) return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
|
||||
else return VK_ACCESS_SHADER_READ_BIT;
|
||||
}
|
||||
if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_ACCESS_TRANSFER_READ_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSFER_DST) return VK_ACCESS_TRANSFER_WRITE_BIT;
|
||||
return VK_ACCESS_SHADER_READ_BIT;
|
||||
VkAccessFlags MapVkAccessFlags(GFXTextureUsage usage, GFXFormat format) {
|
||||
if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
|
||||
if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
|
||||
if (usage & GFXTextureUsage::INPUT_ATTACHMENT) return VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
|
||||
if (usage & GFXTextureUsage::SAMPLED) {
|
||||
if (GFX_FORMAT_INFOS[(uint)format].hasDepth)
|
||||
return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
|
||||
else
|
||||
return VK_ACCESS_SHADER_READ_BIT;
|
||||
}
|
||||
if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_ACCESS_TRANSFER_READ_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSFER_DST) return VK_ACCESS_TRANSFER_WRITE_BIT;
|
||||
return VK_ACCESS_SHADER_READ_BIT;
|
||||
}
|
||||
|
||||
VkPipelineBindPoint MapVkPipelineBindPoint(GFXPipelineBindPoint bindPoint)
|
||||
{
|
||||
switch (bindPoint)
|
||||
{
|
||||
VkPipelineBindPoint MapVkPipelineBindPoint(GFXPipelineBindPoint bindPoint) {
|
||||
switch (bindPoint) {
|
||||
case GFXPipelineBindPoint::GRAPHICS: return VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||||
case GFXPipelineBindPoint::COMPUTE: return VK_PIPELINE_BIND_POINT_COMPUTE;
|
||||
case GFXPipelineBindPoint::RAY_TRACING: return VK_PIPELINE_BIND_POINT_RAY_TRACING_NV;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXPipelineBindPoint, convert to VkPipelineBindPoint failed.");
|
||||
return VK_PIPELINE_BIND_POINT_GRAPHICS;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkBufferUsageFlagBits MapVkBufferUsageFlagBits(GFXBufferUsage usage)
|
||||
{
|
||||
uint flags = 0u;
|
||||
if (usage & GFXBufferUsage::TRANSFER_SRC) flags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
||||
if (usage & GFXBufferUsage::TRANSFER_DST) flags |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
|
||||
if (usage & GFXBufferUsage::INDEX) flags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
|
||||
if (usage & GFXBufferUsage::VERTEX) flags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
|
||||
if (usage & GFXBufferUsage::UNIFORM) flags |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
|
||||
if (usage & GFXBufferUsage::STORAGE) flags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
|
||||
if (usage & GFXBufferUsage::INDIRECT) flags |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
|
||||
return (VkBufferUsageFlagBits)flags;
|
||||
}
|
||||
VkBufferUsageFlagBits MapVkBufferUsageFlagBits(GFXBufferUsage usage) {
|
||||
uint flags = 0u;
|
||||
if (usage & GFXBufferUsage::TRANSFER_SRC) flags |= VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
||||
if (usage & GFXBufferUsage::TRANSFER_DST) flags |= VK_BUFFER_USAGE_TRANSFER_DST_BIT;
|
||||
if (usage & GFXBufferUsage::INDEX) flags |= VK_BUFFER_USAGE_INDEX_BUFFER_BIT;
|
||||
if (usage & GFXBufferUsage::VERTEX) flags |= VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
|
||||
if (usage & GFXBufferUsage::UNIFORM) flags |= VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT;
|
||||
if (usage & GFXBufferUsage::STORAGE) flags |= VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
|
||||
if (usage & GFXBufferUsage::INDIRECT) flags |= VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
|
||||
return (VkBufferUsageFlagBits)flags;
|
||||
}
|
||||
|
||||
VkImageType MapVkImageType(GFXTextureType type)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
VkImageType MapVkImageType(GFXTextureType type) {
|
||||
switch (type) {
|
||||
case GFXTextureType::TEX1D: return VK_IMAGE_TYPE_1D;
|
||||
case GFXTextureType::TEX2D: return VK_IMAGE_TYPE_2D;
|
||||
case GFXTextureType::TEX3D: return VK_IMAGE_TYPE_3D;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXTextureType, convert to VkImageType failed.");
|
||||
return VK_IMAGE_TYPE_2D;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkSampleCountFlagBits MapVkSampleCount(GFXSampleCount count)
|
||||
{
|
||||
switch (count)
|
||||
{
|
||||
VkSampleCountFlagBits MapVkSampleCount(GFXSampleCount count) {
|
||||
switch (count) {
|
||||
case GFXSampleCount::X1: return VK_SAMPLE_COUNT_1_BIT;
|
||||
case GFXSampleCount::X2: return VK_SAMPLE_COUNT_2_BIT;
|
||||
case GFXSampleCount::X4: return VK_SAMPLE_COUNT_4_BIT;
|
||||
case GFXSampleCount::X8: return VK_SAMPLE_COUNT_8_BIT;
|
||||
case GFXSampleCount::X16: return VK_SAMPLE_COUNT_16_BIT;
|
||||
case GFXSampleCount::X32: return VK_SAMPLE_COUNT_32_BIT;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXTextureType, convert to VkImageType failed.");
|
||||
return VK_SAMPLE_COUNT_1_BIT;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkFormatFeatureFlags MapVkFormatFeatureFlags(GFXTextureUsage usage)
|
||||
{
|
||||
uint flags = 0u;
|
||||
if (usage & GFXTextureUsage::TRANSFER_SRC) flags |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSFER_DST) flags |= VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
|
||||
if (usage & GFXTextureUsage::SAMPLED) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
|
||||
if (usage & GFXTextureUsage::STORAGE) flags |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
|
||||
if (usage & GFXTextureUsage::COLOR_ATTACHMENT) flags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
|
||||
if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
|
||||
if (usage & GFXTextureUsage::INPUT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
|
||||
return (VkFormatFeatureFlags)flags;
|
||||
VkFormatFeatureFlags MapVkFormatFeatureFlags(GFXTextureUsage usage) {
|
||||
uint flags = 0u;
|
||||
if (usage & GFXTextureUsage::TRANSFER_SRC) flags |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSFER_DST) flags |= VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
|
||||
if (usage & GFXTextureUsage::SAMPLED) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
|
||||
if (usage & GFXTextureUsage::STORAGE) flags |= VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
|
||||
if (usage & GFXTextureUsage::COLOR_ATTACHMENT) flags |= VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT;
|
||||
if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
|
||||
if (usage & GFXTextureUsage::INPUT_ATTACHMENT) flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
|
||||
return (VkFormatFeatureFlags)flags;
|
||||
}
|
||||
|
||||
VkImageUsageFlagBits MapVkImageUsageFlagBits(GFXTextureUsage usage) {
|
||||
uint flags = 0u;
|
||||
if (usage & GFXTextureUsage::TRANSFER_SRC) flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSFER_DST) flags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
||||
if (usage & GFXTextureUsage::SAMPLED) flags |= VK_IMAGE_USAGE_SAMPLED_BIT;
|
||||
if (usage & GFXTextureUsage::STORAGE) flags |= VK_IMAGE_USAGE_STORAGE_BIT;
|
||||
if (usage & GFXTextureUsage::COLOR_ATTACHMENT) flags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
||||
if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
|
||||
if (usage & GFXTextureUsage::INPUT_ATTACHMENT) flags |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
|
||||
return (VkImageUsageFlagBits)flags;
|
||||
}
|
||||
|
||||
VkImageLayout MapVkImageLayout(GFXTextureUsage usage, GFXFormat format) {
|
||||
const GFXFormatInfo &info = GFX_FORMAT_INFOS[(uint)format];
|
||||
if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) {
|
||||
if (info.hasStencil)
|
||||
return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||
else
|
||||
return VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
|
||||
}
|
||||
|
||||
VkImageUsageFlagBits MapVkImageUsageFlagBits(GFXTextureUsage usage)
|
||||
{
|
||||
uint flags = 0u;
|
||||
if (usage & GFXTextureUsage::TRANSFER_SRC) flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSFER_DST) flags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
|
||||
if (usage & GFXTextureUsage::SAMPLED) flags |= VK_IMAGE_USAGE_SAMPLED_BIT;
|
||||
if (usage & GFXTextureUsage::STORAGE) flags |= VK_IMAGE_USAGE_STORAGE_BIT;
|
||||
if (usage & GFXTextureUsage::COLOR_ATTACHMENT) flags |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
|
||||
if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) flags |= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSIENT_ATTACHMENT) flags |= VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT;
|
||||
if (usage & GFXTextureUsage::INPUT_ATTACHMENT) flags |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
|
||||
return (VkImageUsageFlagBits)flags;
|
||||
if (usage & GFXTextureUsage::SAMPLED) {
|
||||
if (info.hasDepth && info.hasStencil)
|
||||
return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
|
||||
else if (info.hasDepth)
|
||||
return VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL;
|
||||
else
|
||||
return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
||||
}
|
||||
if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
|
||||
if (usage & GFXTextureUsage::TRANSFER_DST) return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||||
return VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
}
|
||||
|
||||
VkImageLayout MapVkImageLayout(GFXTextureUsage usage, GFXFormat format)
|
||||
{
|
||||
const GFXFormatInfo &info = GFX_FORMAT_INFOS[(uint)format];
|
||||
if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
|
||||
if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT)
|
||||
{
|
||||
if (info.hasStencil) return VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||
else return VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
|
||||
}
|
||||
if (usage & GFXTextureUsage::SAMPLED)
|
||||
{
|
||||
if (info.hasDepth && info.hasStencil) return VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
|
||||
else if (info.hasDepth) return VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL;
|
||||
else return VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
||||
}
|
||||
if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
|
||||
if (usage & GFXTextureUsage::TRANSFER_DST) return VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||||
return VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
VkImageAspectFlags MapVkImageAspectFlags(GFXFormat format) {
|
||||
VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
const GFXFormatInfo &info = GFX_FORMAT_INFOS[(uint)format];
|
||||
if (info.hasDepth) {
|
||||
aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT;
|
||||
}
|
||||
|
||||
VkImageAspectFlags MapVkImageAspectFlags(GFXFormat format)
|
||||
{
|
||||
VkImageAspectFlags aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
const GFXFormatInfo &info = GFX_FORMAT_INFOS[(uint)format];
|
||||
if (info.hasDepth) { aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; }
|
||||
if (info.hasStencil) { aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT; }
|
||||
return aspectMask;
|
||||
if (info.hasStencil) {
|
||||
aspectMask |= VK_IMAGE_ASPECT_STENCIL_BIT;
|
||||
}
|
||||
return aspectMask;
|
||||
}
|
||||
|
||||
VkPipelineStageFlags MapVkPipelineStageFlags(GFXTextureUsage usage)
|
||||
{
|
||||
if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||||
if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
||||
if (usage & GFXTextureUsage::SAMPLED) return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_PIPELINE_STAGE_TRANSFER_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSFER_DST) return VK_PIPELINE_STAGE_TRANSFER_BIT;
|
||||
return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
|
||||
}
|
||||
VkPipelineStageFlags MapVkPipelineStageFlags(GFXTextureUsage usage) {
|
||||
if (usage & GFXTextureUsage::COLOR_ATTACHMENT) return VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
|
||||
if (usage & GFXTextureUsage::DEPTH_STENCIL_ATTACHMENT) return VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
|
||||
if (usage & GFXTextureUsage::SAMPLED) return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSFER_SRC) return VK_PIPELINE_STAGE_TRANSFER_BIT;
|
||||
if (usage & GFXTextureUsage::TRANSFER_DST) return VK_PIPELINE_STAGE_TRANSFER_BIT;
|
||||
return VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
|
||||
}
|
||||
|
||||
uint selectMemoryType(const VkPhysicalDeviceMemoryProperties& memoryProperties, uint memoryTypeBits, VkMemoryPropertyFlags flags)
|
||||
{
|
||||
for (uint i = 0; i < memoryProperties.memoryTypeCount; ++i)
|
||||
if ((memoryTypeBits & (1 << i)) != 0 && (memoryProperties.memoryTypes[i].propertyFlags & flags) == flags)
|
||||
return i;
|
||||
uint selectMemoryType(const VkPhysicalDeviceMemoryProperties &memoryProperties, uint memoryTypeBits, VkMemoryPropertyFlags flags) {
|
||||
for (uint i = 0; i < memoryProperties.memoryTypeCount; ++i)
|
||||
if ((memoryTypeBits & (1 << i)) != 0 && (memoryProperties.memoryTypes[i].propertyFlags & flags) == flags)
|
||||
return i;
|
||||
|
||||
CCASSERT(false, "No compatible memory type found.");
|
||||
return ~0u;
|
||||
}
|
||||
CCASSERT(false, "No compatible memory type found.");
|
||||
return ~0u;
|
||||
}
|
||||
|
||||
VkImageCreateFlags MapVkImageCreateFlags(GFXTextureViewType type)
|
||||
{
|
||||
uint res = 0u;
|
||||
switch (type)
|
||||
{
|
||||
VkImageCreateFlags MapVkImageCreateFlags(GFXTextureViewType type) {
|
||||
uint res = 0u;
|
||||
switch (type) {
|
||||
case cocos2d::GFXTextureViewType::CUBE: res |= VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; break;
|
||||
case cocos2d::GFXTextureViewType::TV2D_ARRAY: res |= VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT; break;
|
||||
}
|
||||
return (VkImageCreateFlags)res;
|
||||
}
|
||||
return (VkImageCreateFlags)res;
|
||||
}
|
||||
|
||||
VkImageViewType MapVkImageViewType(GFXTextureViewType viewType)
|
||||
{
|
||||
switch (viewType)
|
||||
{
|
||||
VkImageViewType MapVkImageViewType(GFXTextureViewType viewType) {
|
||||
switch (viewType) {
|
||||
case GFXTextureViewType::TV1D: return VK_IMAGE_VIEW_TYPE_1D;
|
||||
case GFXTextureViewType::TV1D_ARRAY: return VK_IMAGE_VIEW_TYPE_1D_ARRAY;
|
||||
case GFXTextureViewType::TV2D: return VK_IMAGE_VIEW_TYPE_2D;
|
||||
case GFXTextureViewType::TV2D_ARRAY: return VK_IMAGE_VIEW_TYPE_2D_ARRAY;
|
||||
case GFXTextureViewType::TV3D: return VK_IMAGE_VIEW_TYPE_3D;
|
||||
case GFXTextureViewType::CUBE: return VK_IMAGE_VIEW_TYPE_CUBE;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXTextureViewType, convert to VkImageViewType failed.");
|
||||
return VK_IMAGE_VIEW_TYPE_2D;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkCommandBufferLevel MapVkCommandBufferLevel(GFXCommandBufferType type)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
VkCommandBufferLevel MapVkCommandBufferLevel(GFXCommandBufferType type) {
|
||||
switch (type) {
|
||||
case GFXCommandBufferType::PRIMARY: return VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
||||
case GFXCommandBufferType::SECONDARY: return VK_COMMAND_BUFFER_LEVEL_SECONDARY;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXCommandBufferType, convert to VkCommandBufferLevel failed.");
|
||||
return VK_COMMAND_BUFFER_LEVEL_SECONDARY;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkDescriptorType MapVkDescriptorType(GFXBindingType type)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
VkDescriptorType MapVkDescriptorType(GFXBindingType type) {
|
||||
switch (type) {
|
||||
case cocos2d::GFXBindingType::UNIFORM_BUFFER: return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
|
||||
case cocos2d::GFXBindingType::SAMPLER: return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
|
||||
case cocos2d::GFXBindingType::STORAGE_BUFFER: return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXBindingType, convert to VkDescriptorType failed.");
|
||||
return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkColorComponentFlags MapVkColorComponentFlags(GFXColorMask colorMask)
|
||||
{
|
||||
uint flags = 0u;
|
||||
if (colorMask & GFXColorMask::R) flags |= VK_COLOR_COMPONENT_R_BIT;
|
||||
if (colorMask & GFXColorMask::G) flags |= VK_COLOR_COMPONENT_G_BIT;
|
||||
if (colorMask & GFXColorMask::B) flags |= VK_COLOR_COMPONENT_B_BIT;
|
||||
if (colorMask & GFXColorMask::A) flags |= VK_COLOR_COMPONENT_A_BIT;
|
||||
if (colorMask & GFXColorMask::ALL) flags |= VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
||||
return (VkColorComponentFlags)flags;
|
||||
}
|
||||
VkColorComponentFlags MapVkColorComponentFlags(GFXColorMask colorMask) {
|
||||
uint flags = 0u;
|
||||
if (colorMask & GFXColorMask::R) flags |= VK_COLOR_COMPONENT_R_BIT;
|
||||
if (colorMask & GFXColorMask::G) flags |= VK_COLOR_COMPONENT_G_BIT;
|
||||
if (colorMask & GFXColorMask::B) flags |= VK_COLOR_COMPONENT_B_BIT;
|
||||
if (colorMask & GFXColorMask::A) flags |= VK_COLOR_COMPONENT_A_BIT;
|
||||
if (colorMask & GFXColorMask::ALL) flags |= VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
|
||||
return (VkColorComponentFlags)flags;
|
||||
}
|
||||
|
||||
VkShaderStageFlagBits MapVkShaderStageFlagBits(GFXShaderType stage)
|
||||
{
|
||||
switch (stage)
|
||||
{
|
||||
VkShaderStageFlagBits MapVkShaderStageFlagBits(GFXShaderType stage) {
|
||||
switch (stage) {
|
||||
case GFXShaderType::VERTEX: return VK_SHADER_STAGE_VERTEX_BIT;
|
||||
case GFXShaderType::CONTROL: return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
|
||||
case GFXShaderType::EVALUATION: return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
|
||||
case GFXShaderType::GEOMETRY: return VK_SHADER_STAGE_GEOMETRY_BIT;
|
||||
case GFXShaderType::FRAGMENT: return VK_SHADER_STAGE_FRAGMENT_BIT;
|
||||
case GFXShaderType::COMPUTE: return VK_SHADER_STAGE_COMPUTE_BIT;
|
||||
default:
|
||||
{
|
||||
default: {
|
||||
CCASSERT(false, "Unsupported GFXShaderType, convert to VkShaderStageFlagBits failed.");
|
||||
return VK_SHADER_STAGE_VERTEX_BIT;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VkShaderStageFlags MapVkShaderStageFlags(GFXShaderType stages) {
|
||||
uint flags = 0u;
|
||||
if (stages & GFXShaderType::VERTEX) flags |= VK_SHADER_STAGE_VERTEX_BIT;
|
||||
if (stages & GFXShaderType::CONTROL) flags |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
|
||||
if (stages & GFXShaderType::EVALUATION) flags |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
|
||||
if (stages & GFXShaderType::GEOMETRY) flags |= VK_SHADER_STAGE_GEOMETRY_BIT;
|
||||
if (stages & GFXShaderType::FRAGMENT) flags |= VK_SHADER_STAGE_FRAGMENT_BIT;
|
||||
if (stages & GFXShaderType::COMPUTE) flags |= VK_SHADER_STAGE_COMPUTE_BIT;
|
||||
return (VkShaderStageFlags)flags;
|
||||
}
|
||||
|
||||
const VkPrimitiveTopology VK_PRIMITIVE_MODES[] = {
|
||||
VK_PRIMITIVE_TOPOLOGY_POINT_LIST, // POINT_LIST
|
||||
VK_PRIMITIVE_TOPOLOGY_LINE_LIST, // LINE_LIST
|
||||
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, // LINE_STRIP
|
||||
(VkPrimitiveTopology)0, // LINE_LOOP
|
||||
VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, // LINE_LIST_ADJACENCY
|
||||
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, // LINE_STRIP_ADJACENCY
|
||||
(VkPrimitiveTopology)0, // ISO_LINE_LIST
|
||||
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // TRIANGLE_LIST
|
||||
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // TRIANGLE_STRIP
|
||||
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, // TRIANGLE_FAN
|
||||
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, // TRIANGLE_LIST_ADJACENCY
|
||||
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, // TRIANGLE_STRIP_ADJACENCY,
|
||||
(VkPrimitiveTopology)0, // TRIANGLE_PATCH_ADJACENCY,
|
||||
VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, // QUAD_PATCH_LIST,
|
||||
};
|
||||
|
||||
const VkCullModeFlags VK_CULL_MODES[] = {
|
||||
VK_CULL_MODE_NONE,
|
||||
VK_CULL_MODE_FRONT_BIT,
|
||||
VK_CULL_MODE_BACK_BIT,
|
||||
};
|
||||
|
||||
const VkPolygonMode VK_POLYGON_MODES[] = {
|
||||
VK_POLYGON_MODE_FILL,
|
||||
VK_POLYGON_MODE_LINE,
|
||||
VK_POLYGON_MODE_POINT,
|
||||
};
|
||||
|
||||
const VkCompareOp VK_CMP_FUNCS[] = {
|
||||
VK_COMPARE_OP_NEVER,
|
||||
VK_COMPARE_OP_LESS,
|
||||
VK_COMPARE_OP_EQUAL,
|
||||
VK_COMPARE_OP_LESS_OR_EQUAL,
|
||||
VK_COMPARE_OP_GREATER,
|
||||
VK_COMPARE_OP_NOT_EQUAL,
|
||||
VK_COMPARE_OP_GREATER_OR_EQUAL,
|
||||
VK_COMPARE_OP_ALWAYS,
|
||||
};
|
||||
|
||||
const VkStencilOp VK_STENCIL_OPS[] = {
|
||||
VK_STENCIL_OP_ZERO,
|
||||
VK_STENCIL_OP_KEEP,
|
||||
VK_STENCIL_OP_REPLACE,
|
||||
VK_STENCIL_OP_INCREMENT_AND_CLAMP,
|
||||
VK_STENCIL_OP_DECREMENT_AND_CLAMP,
|
||||
VK_STENCIL_OP_INVERT,
|
||||
VK_STENCIL_OP_INCREMENT_AND_WRAP,
|
||||
VK_STENCIL_OP_DECREMENT_AND_WRAP,
|
||||
};
|
||||
|
||||
const VkBlendOp VK_BLEND_OPS[] = {
|
||||
VK_BLEND_OP_ADD,
|
||||
VK_BLEND_OP_SUBTRACT,
|
||||
VK_BLEND_OP_REVERSE_SUBTRACT,
|
||||
VK_BLEND_OP_ADD,
|
||||
VK_BLEND_OP_ADD,
|
||||
};
|
||||
|
||||
const VkBlendFactor VK_BLEND_FACTORS[] = {
|
||||
VK_BLEND_FACTOR_ZERO,
|
||||
VK_BLEND_FACTOR_ONE,
|
||||
VK_BLEND_FACTOR_SRC_ALPHA,
|
||||
VK_BLEND_FACTOR_DST_ALPHA,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
|
||||
VK_BLEND_FACTOR_SRC_COLOR,
|
||||
VK_BLEND_FACTOR_DST_COLOR,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
|
||||
VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
|
||||
VK_BLEND_FACTOR_CONSTANT_COLOR,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
|
||||
VK_BLEND_FACTOR_CONSTANT_ALPHA,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA,
|
||||
};
|
||||
|
||||
const VkFilter VK_FILTERS[] = {
|
||||
(VkFilter)0, // NONE
|
||||
VK_FILTER_NEAREST, // POINT
|
||||
VK_FILTER_LINEAR, // LINEAR
|
||||
(VkFilter)0, // ANISOTROPIC
|
||||
};
|
||||
|
||||
const VkSamplerMipmapMode VK_SAMPLER_MIPMAP_MODES[] = {
|
||||
(VkSamplerMipmapMode)0, // NONE
|
||||
VK_SAMPLER_MIPMAP_MODE_NEAREST, // POINT
|
||||
VK_SAMPLER_MIPMAP_MODE_LINEAR, // LINEAR
|
||||
VK_SAMPLER_MIPMAP_MODE_LINEAR, // ANISOTROPIC
|
||||
};
|
||||
|
||||
const VkSamplerAddressMode VK_SAMPLER_ADDRESS_MODES[] = {
|
||||
VK_SAMPLER_ADDRESS_MODE_REPEAT, // WRAP
|
||||
VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, // MIRROR
|
||||
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // CLAMP
|
||||
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, // BORDER
|
||||
};
|
||||
|
||||
template <typename T, size_t Size>
|
||||
char (*countofHelper(T (&_Array)[Size]))[Size];
|
||||
|
||||
#define COUNTOF(array) (sizeof(*countofHelper(array)) + 0)
|
||||
|
||||
template <class T>
|
||||
uint toUint(T value) {
|
||||
static_assert(std::is_arithmetic<T>::value, "T must be numeric");
|
||||
|
||||
if (static_cast<uintmax_t>(value) > static_cast<uintmax_t>(std::numeric_limits<uint>::max())) {
|
||||
throw std::runtime_error("to_u32() failed, value is too big to be converted to uint");
|
||||
}
|
||||
|
||||
VkShaderStageFlags MapVkShaderStageFlags(GFXShaderType stages)
|
||||
{
|
||||
uint flags = 0u;
|
||||
if (stages & GFXShaderType::VERTEX) flags |= VK_SHADER_STAGE_VERTEX_BIT;
|
||||
if (stages & GFXShaderType::CONTROL) flags |= VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
|
||||
if (stages & GFXShaderType::EVALUATION) flags |= VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
|
||||
if (stages & GFXShaderType::GEOMETRY) flags |= VK_SHADER_STAGE_GEOMETRY_BIT;
|
||||
if (stages & GFXShaderType::FRAGMENT) flags |= VK_SHADER_STAGE_FRAGMENT_BIT;
|
||||
if (stages & GFXShaderType::COMPUTE) flags |= VK_SHADER_STAGE_COMPUTE_BIT;
|
||||
return (VkShaderStageFlags)flags;
|
||||
}
|
||||
return static_cast<uint>(value);
|
||||
}
|
||||
|
||||
const VkPrimitiveTopology VK_PRIMITIVE_MODES[] =
|
||||
{
|
||||
VK_PRIMITIVE_TOPOLOGY_POINT_LIST, // POINT_LIST
|
||||
VK_PRIMITIVE_TOPOLOGY_LINE_LIST, // LINE_LIST
|
||||
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, // LINE_STRIP
|
||||
(VkPrimitiveTopology)0, // LINE_LOOP
|
||||
VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY, // LINE_LIST_ADJACENCY
|
||||
VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, // LINE_STRIP_ADJACENCY
|
||||
(VkPrimitiveTopology)0, // ISO_LINE_LIST
|
||||
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, // TRIANGLE_LIST
|
||||
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, // TRIANGLE_STRIP
|
||||
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, // TRIANGLE_FAN
|
||||
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY, // TRIANGLE_LIST_ADJACENCY
|
||||
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY, // TRIANGLE_STRIP_ADJACENCY,
|
||||
(VkPrimitiveTopology)0, // TRIANGLE_PATCH_ADJACENCY,
|
||||
VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, // QUAD_PATCH_LIST,
|
||||
};
|
||||
uint nextPowerOf2(uint v) {
|
||||
v--;
|
||||
v |= v >> 1;
|
||||
v |= v >> 2;
|
||||
v |= v >> 4;
|
||||
v |= v >> 8;
|
||||
v |= v >> 16;
|
||||
return ++v;
|
||||
}
|
||||
|
||||
const VkCullModeFlags VK_CULL_MODES[] =
|
||||
{
|
||||
VK_CULL_MODE_NONE,
|
||||
VK_CULL_MODE_FRONT_BIT,
|
||||
VK_CULL_MODE_BACK_BIT,
|
||||
};
|
||||
|
||||
const VkPolygonMode VK_POLYGON_MODES[] =
|
||||
{
|
||||
VK_POLYGON_MODE_FILL,
|
||||
VK_POLYGON_MODE_LINE,
|
||||
VK_POLYGON_MODE_POINT,
|
||||
};
|
||||
|
||||
const VkCompareOp VK_CMP_FUNCS[] =
|
||||
{
|
||||
VK_COMPARE_OP_NEVER,
|
||||
VK_COMPARE_OP_LESS,
|
||||
VK_COMPARE_OP_EQUAL,
|
||||
VK_COMPARE_OP_LESS_OR_EQUAL,
|
||||
VK_COMPARE_OP_GREATER,
|
||||
VK_COMPARE_OP_NOT_EQUAL,
|
||||
VK_COMPARE_OP_GREATER_OR_EQUAL,
|
||||
VK_COMPARE_OP_ALWAYS,
|
||||
};
|
||||
|
||||
const VkStencilOp VK_STENCIL_OPS[] =
|
||||
{
|
||||
VK_STENCIL_OP_ZERO,
|
||||
VK_STENCIL_OP_KEEP,
|
||||
VK_STENCIL_OP_REPLACE,
|
||||
VK_STENCIL_OP_INCREMENT_AND_CLAMP,
|
||||
VK_STENCIL_OP_DECREMENT_AND_CLAMP,
|
||||
VK_STENCIL_OP_INVERT,
|
||||
VK_STENCIL_OP_INCREMENT_AND_WRAP,
|
||||
VK_STENCIL_OP_DECREMENT_AND_WRAP,
|
||||
};
|
||||
|
||||
const VkBlendOp VK_BLEND_OPS[] =
|
||||
{
|
||||
VK_BLEND_OP_ADD,
|
||||
VK_BLEND_OP_SUBTRACT,
|
||||
VK_BLEND_OP_REVERSE_SUBTRACT,
|
||||
VK_BLEND_OP_ADD,
|
||||
VK_BLEND_OP_ADD,
|
||||
};
|
||||
|
||||
const VkBlendFactor VK_BLEND_FACTORS[] =
|
||||
{
|
||||
VK_BLEND_FACTOR_ZERO,
|
||||
VK_BLEND_FACTOR_ONE,
|
||||
VK_BLEND_FACTOR_SRC_ALPHA,
|
||||
VK_BLEND_FACTOR_DST_ALPHA,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA,
|
||||
VK_BLEND_FACTOR_SRC_COLOR,
|
||||
VK_BLEND_FACTOR_DST_COLOR,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR,
|
||||
VK_BLEND_FACTOR_SRC_ALPHA_SATURATE,
|
||||
VK_BLEND_FACTOR_CONSTANT_COLOR,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR,
|
||||
VK_BLEND_FACTOR_CONSTANT_ALPHA,
|
||||
VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA,
|
||||
};
|
||||
|
||||
const VkFilter VK_FILTERS[] =
|
||||
{
|
||||
(VkFilter)0, // NONE
|
||||
VK_FILTER_NEAREST, // POINT
|
||||
VK_FILTER_LINEAR, // LINEAR
|
||||
(VkFilter)0, // ANISOTROPIC
|
||||
};
|
||||
|
||||
const VkSamplerMipmapMode VK_SAMPLER_MIPMAP_MODES[] =
|
||||
{
|
||||
(VkSamplerMipmapMode)0, // NONE
|
||||
VK_SAMPLER_MIPMAP_MODE_NEAREST, // POINT
|
||||
VK_SAMPLER_MIPMAP_MODE_LINEAR, // LINEAR
|
||||
VK_SAMPLER_MIPMAP_MODE_LINEAR, // ANISOTROPIC
|
||||
};
|
||||
|
||||
const VkSamplerAddressMode VK_SAMPLER_ADDRESS_MODES[] =
|
||||
{
|
||||
VK_SAMPLER_ADDRESS_MODE_REPEAT, // WRAP
|
||||
VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT, // MIRROR
|
||||
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, // CLAMP
|
||||
VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, // BORDER
|
||||
};
|
||||
|
||||
template <typename T, size_t Size>
|
||||
char(*countof_helper(T(&_Array)[Size]))[Size];
|
||||
|
||||
#define COUNTOF(array) (sizeof(*countof_helper(array)) + 0)
|
||||
|
||||
template <class T>
|
||||
uint toUint(T value)
|
||||
{
|
||||
static_assert(std::is_arithmetic<T>::value, "T must be numeric");
|
||||
|
||||
if (static_cast<uintmax_t>(value) > static_cast<uintmax_t>(std::numeric_limits<uint>::max()))
|
||||
{
|
||||
throw std::runtime_error("to_u32() failed, value is too big to be converted to uint");
|
||||
}
|
||||
|
||||
return static_cast<uint>(value);
|
||||
}
|
||||
|
||||
uint nextPowerOf2(uint v)
|
||||
{
|
||||
v--;
|
||||
v |= v >> 1;
|
||||
v |= v >> 2;
|
||||
v |= v >> 4;
|
||||
v |= v >> 8;
|
||||
v |= v >> 16;
|
||||
return ++v;
|
||||
}
|
||||
|
||||
const char* MapVendorName(uint32_t vendorID)
|
||||
{
|
||||
switch (vendorID)
|
||||
{
|
||||
const char *MapVendorName(uint32_t vendorID) {
|
||||
switch (vendorID) {
|
||||
case 0x1002: return "Advanced Micro Devices, Inc.";
|
||||
case 0x1010: return "Imagination Technologies";
|
||||
case 0x10DE: return "Nvidia Corporation";
|
||||
case 0x13B5: return "Arm Limited";
|
||||
case 0x5143: return "Qualcomm Incorporated";
|
||||
case 0x8086: return "Intel Corporation";
|
||||
}
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
bool isLayerSupported(const char * required, const std::vector<VkLayerProperties> &available)
|
||||
{
|
||||
for (const VkLayerProperties &availableLayer : available)
|
||||
{
|
||||
if (strcmp(availableLayer.layerName, required) == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool isExtensionSupported(const char * required, const std::vector<VkExtensionProperties> &available)
|
||||
{
|
||||
for (const VkExtensionProperties &availableExtension : available)
|
||||
{
|
||||
if (strcmp(availableExtension.extensionName, required) == 0)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return "Unknown";
|
||||
}
|
||||
|
||||
bool isLayerSupported(const char *required, const std::vector<VkLayerProperties> &available) {
|
||||
for (const VkLayerProperties &availableLayer : available) {
|
||||
if (strcmp(availableLayer.layerName, required) == 0) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool isExtensionSupported(const char *required, const std::vector<VkExtensionProperties> &available) {
|
||||
for (const VkExtensionProperties &availableExtension : available) {
|
||||
if (strcmp(availableExtension.extensionName, required) == 0) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
NS_CC_END
|
||||
|
||||
#endif // CC_GFXVULKAN_CCVK_UTILS_H_
|
||||
|
||||
@@ -1,20 +1,18 @@
|
||||
#include "VKStd.h"
|
||||
#include "VKWindow.h"
|
||||
|
||||
#include "VKCommands.h"
|
||||
#include "VKWindow.h"
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
CCVKWindow::CCVKWindow(GFXDevice* device)
|
||||
: GFXWindow(device)
|
||||
{
|
||||
CCVKWindow::CCVKWindow(GFXDevice *device)
|
||||
: GFXWindow(device) {
|
||||
}
|
||||
|
||||
CCVKWindow::~CCVKWindow()
|
||||
{
|
||||
CCVKWindow::~CCVKWindow() {
|
||||
}
|
||||
|
||||
bool CCVKWindow::initialize(const GFXWindowInfo &info)
|
||||
{
|
||||
bool CCVKWindow::initialize(const GFXWindowInfo &info) {
|
||||
_title = info.title;
|
||||
_left = info.left;
|
||||
_top = info.top;
|
||||
@@ -28,35 +26,36 @@ bool CCVKWindow::initialize(const GFXWindowInfo &info)
|
||||
_isFullscreen = info.isFullscreen;
|
||||
|
||||
// Create render pass
|
||||
if (info.renderPass) {
|
||||
_renderPass = info.renderPass;
|
||||
} else {
|
||||
GFXRenderPassInfo renderPassInfo;
|
||||
|
||||
GFXRenderPassInfo renderPassInfo;
|
||||
GFXColorAttachment colorAttachment;
|
||||
colorAttachment.format = _colorFmt;
|
||||
colorAttachment.loadOp = GFXLoadOp::CLEAR;
|
||||
colorAttachment.storeOp = GFXStoreOp::STORE;
|
||||
colorAttachment.sampleCount = 1;
|
||||
colorAttachment.beginLayout = GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL;
|
||||
colorAttachment.endLayout = _isOffscreen ? GFXTextureLayout::SHADER_READONLY_OPTIMAL : GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL;
|
||||
renderPassInfo.colorAttachments.emplace_back(colorAttachment);
|
||||
|
||||
GFXColorAttachment colorAttachment;
|
||||
colorAttachment.format = _colorFmt;
|
||||
colorAttachment.loadOp = GFXLoadOp::CLEAR;
|
||||
colorAttachment.storeOp = GFXStoreOp::STORE;
|
||||
colorAttachment.sampleCount = 1;
|
||||
colorAttachment.beginLayout = GFXTextureLayout::COLOR_ATTACHMENT_OPTIMAL;
|
||||
colorAttachment.endLayout = GFXTextureLayout::PRESENT_SRC;
|
||||
renderPassInfo.colorAttachments.emplace_back(colorAttachment);
|
||||
GFXDepthStencilAttachment &depthStencilAttachment = renderPassInfo.depthStencilAttachment;
|
||||
depthStencilAttachment.format = _depthStencilFmt;
|
||||
depthStencilAttachment.depthLoadOp = GFXLoadOp::CLEAR;
|
||||
depthStencilAttachment.depthStoreOp = GFXStoreOp::STORE;
|
||||
depthStencilAttachment.stencilLoadOp = GFXLoadOp::CLEAR;
|
||||
depthStencilAttachment.stencilStoreOp = GFXStoreOp::STORE;
|
||||
depthStencilAttachment.sampleCount = 1;
|
||||
depthStencilAttachment.beginLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||
depthStencilAttachment.endLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||
|
||||
GFXDepthStencilAttachment& depthStencilAttachment = renderPassInfo.depthStencilAttachment;
|
||||
depthStencilAttachment.format = _depthStencilFmt;
|
||||
depthStencilAttachment.depthLoadOp = GFXLoadOp::CLEAR;
|
||||
depthStencilAttachment.depthStoreOp = GFXStoreOp::STORE;
|
||||
depthStencilAttachment.stencilLoadOp = GFXLoadOp::CLEAR;
|
||||
depthStencilAttachment.stencilStoreOp = GFXStoreOp::STORE;
|
||||
depthStencilAttachment.sampleCount = 1;
|
||||
depthStencilAttachment.beginLayout = GFXTextureLayout::DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
|
||||
depthStencilAttachment.endLayout = GFXTextureLayout::PRESENT_SRC;
|
||||
|
||||
_renderPass = _device->createRenderPass(renderPassInfo);
|
||||
_renderPass = _device->createRenderPass(renderPassInfo);
|
||||
}
|
||||
|
||||
// Create texture & texture views
|
||||
if (_isOffscreen)
|
||||
{
|
||||
if (_colorFmt != GFXFormat::UNKNOWN)
|
||||
{
|
||||
if (_isOffscreen) {
|
||||
if (_colorFmt != GFXFormat::UNKNOWN) {
|
||||
GFXTextureInfo colorTexInfo;
|
||||
colorTexInfo.type = GFXTextureType::TEX2D;
|
||||
colorTexInfo.usage = GFXTextureUsageBit::COLOR_ATTACHMENT | GFXTextureUsageBit::SAMPLED;
|
||||
@@ -78,8 +77,7 @@ bool CCVKWindow::initialize(const GFXWindowInfo &info)
|
||||
colorTexViewInfo.layerCount = 1;
|
||||
_colorTexView = _device->createTextureView(colorTexViewInfo);
|
||||
}
|
||||
if (_depthStencilFmt != GFXFormat::UNKNOWN)
|
||||
{
|
||||
if (_depthStencilFmt != GFXFormat::UNKNOWN) {
|
||||
GFXTextureInfo depthStecnilTexInfo;
|
||||
depthStecnilTexInfo.type = GFXTextureType::TEX2D;
|
||||
depthStecnilTexInfo.usage = GFXTextureUsageBit::DEPTH_STENCIL_ATTACHMENT | GFXTextureUsageBit::SAMPLED;
|
||||
@@ -105,8 +103,7 @@ bool CCVKWindow::initialize(const GFXWindowInfo &info)
|
||||
|
||||
GFXFramebufferInfo fboInfo;
|
||||
fboInfo.renderPass = _renderPass;
|
||||
if (_colorTexView)
|
||||
{
|
||||
if (_colorTexView) {
|
||||
fboInfo.colorViews.push_back(_colorTexView);
|
||||
}
|
||||
fboInfo.depthStencilView = _depthStencilTexView;
|
||||
@@ -117,8 +114,7 @@ bool CCVKWindow::initialize(const GFXWindowInfo &info)
|
||||
return true;
|
||||
}
|
||||
|
||||
void CCVKWindow::destroy()
|
||||
{
|
||||
void CCVKWindow::destroy() {
|
||||
CC_SAFE_DESTROY(_renderPass);
|
||||
CC_SAFE_DESTROY(_colorTexView);
|
||||
CC_SAFE_DESTROY(_colorTex);
|
||||
@@ -129,18 +125,15 @@ void CCVKWindow::destroy()
|
||||
_status = GFXStatus::UNREADY;
|
||||
}
|
||||
|
||||
void CCVKWindow::resize(uint width, uint height)
|
||||
{
|
||||
void CCVKWindow::resize(uint width, uint height) {
|
||||
_width = width;
|
||||
_height = height;
|
||||
|
||||
if (width > _nativeWidth || height > _nativeHeight)
|
||||
{
|
||||
if (width > _nativeWidth || height > _nativeHeight) {
|
||||
_nativeWidth = width;
|
||||
_nativeHeight = height;
|
||||
|
||||
if (_colorTex)
|
||||
{
|
||||
if (_colorTex) {
|
||||
_colorTex->resize(width, height);
|
||||
_colorTexView->destroy();
|
||||
|
||||
@@ -150,8 +143,7 @@ void CCVKWindow::resize(uint width, uint height)
|
||||
_colorTexView->initialize(colorTexViewInfo);
|
||||
}
|
||||
|
||||
if (_depthStencilTex)
|
||||
{
|
||||
if (_depthStencilTex) {
|
||||
_depthStencilTex->resize(width, height);
|
||||
_depthStencilTexView->destroy();
|
||||
|
||||
@@ -161,8 +153,7 @@ void CCVKWindow::resize(uint width, uint height)
|
||||
_depthStencilTexView->initialize(depth_stencil_tex_view__info);
|
||||
}
|
||||
|
||||
if (_framebuffer)
|
||||
{
|
||||
if (_framebuffer) {
|
||||
_framebuffer->destroy();
|
||||
|
||||
GFXFramebufferInfo fboInfo;
|
||||
|
||||
@@ -3,14 +3,13 @@
|
||||
|
||||
NS_CC_BEGIN
|
||||
|
||||
class CC_VULKAN_API CCVKWindow : public GFXWindow
|
||||
{
|
||||
class CC_VULKAN_API CCVKWindow : public GFXWindow {
|
||||
public:
|
||||
CCVKWindow(GFXDevice* device);
|
||||
CCVKWindow(GFXDevice *device);
|
||||
~CCVKWindow();
|
||||
|
||||
public:
|
||||
bool initialize(const GFXWindowInfo& info);
|
||||
bool initialize(const GFXWindowInfo &info);
|
||||
void destroy();
|
||||
void resize(uint width, uint height);
|
||||
};
|
||||
|
||||
@@ -2664,6 +2664,34 @@ static bool js_gfx_GFXWindowInfo_set_windowHandle(se::State& s)
|
||||
}
|
||||
SE_BIND_PROP_SET(js_gfx_GFXWindowInfo_set_windowHandle)
|
||||
|
||||
static bool js_gfx_GFXWindowInfo_get_renderPass(se::State& s)
|
||||
{
|
||||
cocos2d::GFXWindowInfo* cobj = (cocos2d::GFXWindowInfo*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_gfx_GFXWindowInfo_get_renderPass : Invalid Native Object");
|
||||
|
||||
CC_UNUSED bool ok = true;
|
||||
se::Value jsret;
|
||||
ok &= native_ptr_to_seval(cobj->renderPass, &jsret);
|
||||
s.rval() = jsret;
|
||||
return true;
|
||||
}
|
||||
SE_BIND_PROP_GET(js_gfx_GFXWindowInfo_get_renderPass)
|
||||
|
||||
static bool js_gfx_GFXWindowInfo_set_renderPass(se::State& s)
|
||||
{
|
||||
const auto& args = s.args();
|
||||
cocos2d::GFXWindowInfo* cobj = (cocos2d::GFXWindowInfo*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_gfx_GFXWindowInfo_set_renderPass : Invalid Native Object");
|
||||
|
||||
CC_UNUSED bool ok = true;
|
||||
cocos2d::GFXRenderPass* arg0 = nullptr;
|
||||
ok &= seval_to_native_ptr(args[0], &arg0);
|
||||
SE_PRECONDITION2(ok, false, "js_gfx_GFXWindowInfo_set_renderPass : Error processing new value");
|
||||
cobj->renderPass = arg0;
|
||||
return true;
|
||||
}
|
||||
SE_BIND_PROP_SET(js_gfx_GFXWindowInfo_set_renderPass)
|
||||
|
||||
SE_DECLARE_FINALIZE_FUNC(js_cocos2d_GFXWindowInfo_finalize)
|
||||
|
||||
static bool js_gfx_GFXWindowInfo_constructor(se::State& s)
|
||||
@@ -2751,6 +2779,12 @@ static bool js_gfx_GFXWindowInfo_constructor(se::State& s)
|
||||
ok &= seval_to_uintptr_t(field, &arg10);
|
||||
cobj->windowHandle = arg10;
|
||||
}
|
||||
cocos2d::GFXRenderPass* arg11 = nullptr;
|
||||
json->getProperty("renderPass", &field);
|
||||
if(!field.isUndefined()) {
|
||||
ok &= seval_to_native_ptr(field, &arg11);
|
||||
cobj->renderPass = arg11;
|
||||
}
|
||||
|
||||
if(!ok) {
|
||||
JSB_FREE(cobj);
|
||||
@@ -2762,7 +2796,7 @@ static bool js_gfx_GFXWindowInfo_constructor(se::State& s)
|
||||
se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
|
||||
return true;
|
||||
}
|
||||
else if(argc == 11)
|
||||
else if(argc == 12)
|
||||
{
|
||||
cocos2d::GFXWindowInfo* cobj = JSB_ALLOC(cocos2d::GFXWindowInfo);
|
||||
cocos2d::String arg0;
|
||||
@@ -2820,6 +2854,11 @@ static bool js_gfx_GFXWindowInfo_constructor(se::State& s)
|
||||
ok &= seval_to_uintptr_t(args[10], &arg10);
|
||||
cobj->windowHandle = arg10;
|
||||
}
|
||||
cocos2d::GFXRenderPass* arg11 = nullptr;
|
||||
if (!args[11].isUndefined()) {
|
||||
ok &= seval_to_native_ptr(args[11], &arg11);
|
||||
cobj->renderPass = arg11;
|
||||
}
|
||||
|
||||
if(!ok) {
|
||||
JSB_FREE(cobj);
|
||||
@@ -2869,6 +2908,7 @@ bool js_register_gfx_GFXWindowInfo(se::Object* obj)
|
||||
cls->defineProperty("isFullscreen", _SE(js_gfx_GFXWindowInfo_get_isFullscreen), _SE(js_gfx_GFXWindowInfo_set_isFullscreen));
|
||||
cls->defineProperty("vsyncMode", _SE(js_gfx_GFXWindowInfo_get_vsyncMode), _SE(js_gfx_GFXWindowInfo_set_vsyncMode));
|
||||
cls->defineProperty("windowHandle", _SE(js_gfx_GFXWindowInfo_get_windowHandle), _SE(js_gfx_GFXWindowInfo_set_windowHandle));
|
||||
cls->defineProperty("renderPass", _SE(js_gfx_GFXWindowInfo_get_renderPass), _SE(js_gfx_GFXWindowInfo_set_renderPass));
|
||||
cls->defineFinalizeFunction(_SE(js_cocos2d_GFXWindowInfo_finalize));
|
||||
cls->install();
|
||||
JSBClassType::registerClass<cocos2d::GFXWindowInfo>(cls);
|
||||
@@ -14337,24 +14377,6 @@ static bool js_gfx_GFXWindow_getDepthStencilFormat(se::State& s)
|
||||
}
|
||||
SE_BIND_FUNC(js_gfx_GFXWindow_getDepthStencilFormat)
|
||||
|
||||
static bool js_gfx_GFXWindow_getFramebuffer(se::State& s)
|
||||
{
|
||||
cocos2d::GFXWindow* cobj = (cocos2d::GFXWindow*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_gfx_GFXWindow_getFramebuffer : Invalid Native Object");
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
CC_UNUSED bool ok = true;
|
||||
if (argc == 0) {
|
||||
cocos2d::GFXFramebuffer* result = cobj->getFramebuffer();
|
||||
ok &= native_ptr_to_seval(result, &s.rval());
|
||||
SE_PRECONDITION2(ok, false, "js_gfx_GFXWindow_getFramebuffer : Error processing arguments");
|
||||
return true;
|
||||
}
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_PROP_GET(js_gfx_GFXWindow_getFramebuffer)
|
||||
|
||||
static bool js_gfx_GFXWindow_getLeft(se::State& s)
|
||||
{
|
||||
cocos2d::GFXWindow* cobj = (cocos2d::GFXWindow*)s.nativeThisObject();
|
||||
@@ -14499,6 +14521,24 @@ static bool js_gfx_GFXWindow_isOffscreen(se::State& s)
|
||||
}
|
||||
SE_BIND_PROP_GET(js_gfx_GFXWindow_isOffscreen)
|
||||
|
||||
static bool js_gfx_GFXWindow_getFramebuffer(se::State& s)
|
||||
{
|
||||
cocos2d::GFXWindow* cobj = (cocos2d::GFXWindow*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_gfx_GFXWindow_getFramebuffer : Invalid Native Object");
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
CC_UNUSED bool ok = true;
|
||||
if (argc == 0) {
|
||||
cocos2d::GFXFramebuffer* result = cobj->getFramebuffer();
|
||||
ok &= native_ptr_to_seval(result, &s.rval());
|
||||
SE_PRECONDITION2(ok, false, "js_gfx_GFXWindow_getFramebuffer : Error processing arguments");
|
||||
return true;
|
||||
}
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_PROP_GET(js_gfx_GFXWindow_getFramebuffer)
|
||||
|
||||
static bool js_gfx_GFXWindow_getTitle(se::State& s)
|
||||
{
|
||||
cocos2d::GFXWindow* cobj = (cocos2d::GFXWindow*)s.nativeThisObject();
|
||||
@@ -18574,7 +18614,7 @@ bool register_all_gfx(se::Object* obj)
|
||||
js_register_gfx_GFXInputAssembler(ns);
|
||||
js_register_gfx_GFXContextInfo(ns);
|
||||
js_register_gfx_GFXShader(ns);
|
||||
js_register_gfx_GFXDeviceInfo(ns);
|
||||
js_register_gfx_GFXShaderStage(ns);
|
||||
js_register_gfx_GFXTextureView(ns);
|
||||
js_register_gfx_GFXPipelineLayout(ns);
|
||||
js_register_gfx_GFXFramebufferInfo(ns);
|
||||
@@ -18583,7 +18623,7 @@ bool register_all_gfx(se::Object* obj)
|
||||
js_register_gfx_GFXRasterizerState(ns);
|
||||
js_register_gfx_GFXTextureInfo(ns);
|
||||
js_register_gfx_GFXQueueInfo(ns);
|
||||
js_register_gfx_GFXShaderStage(ns);
|
||||
js_register_gfx_GFXDeviceInfo(ns);
|
||||
js_register_gfx_GFXShaderInfo(ns);
|
||||
js_register_gfx_GFXOffset(ns);
|
||||
js_register_gfx_GFXPushConstantRange(ns);
|
||||
|
||||
Reference in New Issue
Block a user