vk: clang format (#2535)

This commit is contained in:
Yun Hsiao Wu
2020-06-09 09:45:27 +08:00
committed by GitHub
parent cad70edf1b
commit 7bacb7fb5c
44 changed files with 1799 additions and 2274 deletions
+1
View File
@@ -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
+23 -35
View File
@@ -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
+6 -7
View File
@@ -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 &regions) {
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 &regions);
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
+35 -39
View File
@@ -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 &regions);
NS_CC_END
+124 -194
View File
@@ -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;
}
+9 -11
View File
@@ -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;
+142 -183
View File
@@ -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 &regions) {
CCVKCmdFuncCopyBuffersToTexture(this, buffers.datas.data(), ((CCVKTexture *)dst)->gpuTexture(), regions);
}
NS_CC_END
+42 -40
View File
@@ -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 &regions) 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;
+16 -23
View File
@@ -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
+4 -4
View File
@@ -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
+63 -102
View File
@@ -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
+18 -25
View File
@@ -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();
}
}
+5 -5
View File
@@ -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
+150 -164
View File
@@ -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
+10 -14
View File
@@ -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;
}
+9 -9
View File
@@ -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
+12 -17
View File
@@ -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;
}
+12 -11
View File
@@ -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
+17 -21
View File
@@ -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
+45 -73
View File
@@ -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;
+12 -12
View File
@@ -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
+329 -384
View File
@@ -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_
+39 -48
View File
@@ -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 -4
View File
@@ -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);