ContextVK.cpp

#include "ContextVK.h"
 
#include "GraphicsDeviceVK.h"
 
#include "BuffersVK.h"
#include "EffectsVK.h"
 
#include "Foundation/HashFunctions.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ContextVK");
}
 
void Cogs::ContextVK::initialize(GraphicsDeviceVK * graphicsDevice)
{
  this->graphicsDevice = graphicsDevice;
  device = graphicsDevice->device;
 
  effects = &graphicsDevice->effects;
  buffers = &graphicsDevice->buffers;
  textures = &graphicsDevice->textures;
  renderTargets = &graphicsDevice->renderTargets;
 
  for (auto & frameResource : frameResources) {
    const VkCommandPoolCreateInfo commandPoolInfo = {
      VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
      nullptr,
      VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
      0,
    };
 
    auto result = vkCreateCommandPool(device, &commandPoolInfo, nullptr, &frameResource.commandPool);
 
    if (VK_FAILED(result)) {
      VK_LOG_ERROR(result, "Could not create command pool.");
      return;
    }
 
    const VkCommandBufferAllocateInfo cmd = {
      VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
      nullptr,
      frameResource.commandPool,
      VK_COMMAND_BUFFER_LEVEL_PRIMARY,
      1,
    };
 
    result = vkAllocateCommandBuffers(device, &cmd, &frameResource.commandBuffer);
 
    if (VK_FAILED(result)) {
      VK_LOG_ERROR(result, "Could not create command buffer.");
      return;
    }
 
    VkDescriptorPoolSize descriptorSizes[2];
    descriptorSizes[0] = { VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 32000, };
    descriptorSizes[1] = { VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 32000, };
 
    const VkDescriptorPoolCreateInfo descriptorPoolInfo = {
      VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
      nullptr,
      0,
      32000,
      2,
      descriptorSizes,
    };
 
    result = vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &frameResource.descriptorPool);
 
    /*if (VK_FAILED(result)) {
      VK_LOG_ERROR(result, "Could not create descriptor pool.");
      return;
    }*/
 
    VkFenceCreateInfo fenceInfo = {};
    fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
    fenceInfo.flags = 0;
    vkCreateFence(device, &fenceInfo, nullptr, &frameResource.fence);
  }
 
  uint8_t textureData[4 * 1] = { 0 };
  defaultTexture = textures->loadTexture(textureData, 1, 1, TextureFormat::R8G8B8A8_UNORM, TextureFlags::Default);
  defaultSampler = textures->loadSamplerState(SamplerState::DefaultState());
 
  defaultDepthStencilState = renderTargets->loadDepthStencilState(DepthStencilState::DefaultState());
  defaultRasterizerState = renderTargets->loadRasterizerState(RasterizerState::DefaultState());
  defaultBlendState = renderTargets->loadBlendState(BlendState::DefaultState());
}
 
void Cogs::ContextVK::beginFrame()
{
  currentFrameResources = &frameResources[currentFrame % frameResources.size()];
 
  if (currentFrame != 0) {
    if (vkGetFenceStatus(device, currentFrameResources->fence) != VK_SUCCESS) {
      vkWaitForFences(device, 1, &currentFrameResources->fence, VK_TRUE, 100000000);
    }
 
    vkResetFences(device, 1, &currentFrameResources->fence);
 
    vkResetCommandBuffer(currentFrameResources->commandBuffer, 0);
    vkResetDescriptorPool(device, currentFrameResources->descriptorPool, 0);
  }
 
  descriptorPool = currentFrameResources->descriptorPool;
 
  currentEffect = EffectHandle::NoHandle;
  iaState = {};
  state = {};
  shaderState = {};
 
  ContextCommon::setCurrentEffect(nullptr);
 
  setRasterizerState(defaultRasterizerState);
  setDepthStencilState(defaultDepthStencilState);
  setBlendState(defaultBlendState);
 
  for (auto & ob : currentFrameResources->orhpanedBuffers) {
    ob->pool->deallocate(ob);
  }
 
  currentFrameResources->orhpanedBuffers.clear();
 
  const VkCommandBufferBeginInfo commandBufferBeginInfo = {
    VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
    nullptr,
    VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,
    nullptr,
  };
 
  auto result = vkBeginCommandBuffer(currentFrameResources->commandBuffer, &commandBufferBeginInfo);
 
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Could not begin command buffer.");
    return;
  }
 
  setRenderTarget(defaultRenderTarget, DepthStencilHandle::NoHandle);
}
 
void Cogs::ContextVK::endFrame()
{
  if (renderPass) {
    endRenderPass();
  } else {
    beginRenderPass();
    endRenderPass();
  }
 
  auto & texture = graphicsDevice->textures.textures[graphicsDevice->backBuffers[graphicsDevice->currentFrameBuffer]];
 
  if (graphicsDevice->getSettings().numSamples > 1) {
    resolveResource(graphicsDevice->backBuffersMS[graphicsDevice->currentFrameBuffer], graphicsDevice->backBuffers[graphicsDevice->currentFrameBuffer]);
  }
 
  setImageLayout(currentFrameResources->commandBuffer, texture, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
 
  auto result = vkEndCommandBuffer(currentFrameResources->commandBuffer);
 
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Could not close command buffer.");
  }
 
  ++currentFrame;
}
 
void Cogs::ContextVK::setRenderTarget(const RenderTargetHandle handle, const DepthStencilHandle depthStencilHandle)
{
  if (renderPass) {
    endRenderPass();
  }
 
  auto & renderTarget = renderTargets->renderTargets[HandleIsValid(handle) ? handle : defaultRenderTarget];
 
  state.renderTarget = &renderTarget;
  state.depthStencil = nullptr;
 
  clearValues.resize(renderTarget.textures.size() + (renderTarget.depthTexture ? 1 : 0));
 
  for (auto texture : renderTarget.textures) {
    setImageLayout(
      currentFrameResources->commandBuffer,
      *texture,
      VK_IMAGE_ASPECT_COLOR_BIT,
      VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
  }
 
  if (renderTarget.depthTexture) {
    setImageLayout(
      currentFrameResources->commandBuffer,
      *renderTarget.depthTexture,
      VK_IMAGE_ASPECT_DEPTH_BIT,
      VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
  }
}
 
void Cogs::ContextVK::setViewport(const float x, const float y, const float width, const float height)
{
  VkViewport viewport = {};
  viewport.height = height;
  viewport.width = width;
  viewport.minDepth = 0.0f;
  viewport.maxDepth = 1.0f;
  vkCmdSetViewport(currentFrameResources->commandBuffer, 0, 1, &viewport);
 
  VkRect2D scissor = {};
  scissor.extent.width = static_cast<uint32_t>(width);
  scissor.extent.height = static_cast<uint32_t>(height);
  scissor.offset.x = static_cast<int32_t>(x);
  scissor.offset.y = static_cast<int32_t>(y);
  vkCmdSetScissor(currentFrameResources->commandBuffer, 0, 1, &scissor);
}
 
void Cogs::ContextVK::setScissor(const int x, const int y, const int width, const int height)
{
}
 
void Cogs::ContextVK::clearRenderTarget(const float * color)
{
  clearRenderTarget(&color, 1);
}
 
void Cogs::ContextVK::clearRenderTarget(const float ** colors, const int count)
{
  for (size_t i = 0; i < state.renderTarget->textures.size(); ++i) {
    auto color = colors[count > 1 ? i : 0];
 
    clearValues[i].color.float32[0] = color[0];
    clearValues[i].color.float32[1] = color[1];
    clearValues[i].color.float32[2] = color[2];
    clearValues[i].color.float32[3] = color[3];
  }
}
 
void Cogs::ContextVK::clearDepth(const float depth)
{
  clearValues.back().depthStencil = { depth, 0 };
}
 
void Cogs::ContextVK::setDepthStencilState(const DepthStencilStateHandle handle)
{
  state.depthStencilState = &renderTargets->depthStencilStates[handle];
}
 
void Cogs::ContextVK::setBlendState(const BlendStateHandle handle, const float* constant)
{
  assert(constant == nullptr);
  state.blendState = &renderTargets->blendStates[handle];
}
 
void Cogs::ContextVK::setRasterizerState(const RasterizerStateHandle handle)
{
  state.rasterizerState = &renderTargets->rasterizerStates[handle];
}
 
void Cogs::ContextVK::setEffect(EffectHandle handle)
{
  currentEffect = handle;
  state.effect = &effects->effects[handle];
 
  auto & effect = *state.effect;
 
  ContextCommon::setCurrentEffect(&effect);
 
  shaderState.effectSignature = effect.signature;
 
  for (uint32_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    for (uint32_t j = 0; j < shaderState.effectSignature.slots[SlotType::CBV].values[i]; ++j) {
      shaderState.CBVs[i].setChanged();
    }
 
    for (uint32_t j = 0; j < shaderState.effectSignature.slots[SlotType::Sampler].values[i]; ++j) {
      shaderState.Samplers[i].setChanged();
    }
 
    for (uint32_t j = 0; j < shaderState.effectSignature.slots[SlotType::SRV].values[i]; ++j) {
      shaderState.SRVs[i].setChanged();
    }
 
    for (uint32_t j = 0; j < shaderState.effectSignature.slots[SlotType::UAV].values[i]; ++j) {
      shaderState.UAVs[i].setChanged();
    }
  }
}
 
void Cogs::ContextVK::updateConstantBuffers()
{
  if (constantBuffersUpdated) return;
 
  ContextCommon::updateConstantBuffers();
 
  auto & effect = effects->effects[currentEffect];
 
  for (auto & cb : effect.vertexShader.reflection.constantBuffers) {
    if (HandleIsValid(cb.buffer)) {
      shaderState.CBVs[ShaderType::VertexShader].setChanged(cb.slot, &buffers->buffers[cb.buffer]);
    }
  }
 
  for (auto & cb : effect.pixelShader.reflection.constantBuffers) {
    if (HandleIsValid(cb.buffer)) {
      shaderState.CBVs[ShaderType::PixelShader].setChanged(cb.slot, &buffers->buffers[cb.buffer]);
    }
  }
}
 
void Cogs::ContextVK::setTexture(const TextureBindingHandle textureBindingHandle, TextureViewHandle textureViewHandle)
{
}
 
void Cogs::ContextVK::setTexture(const TextureBindingHandle textureBindingHandle, const TextureHandle textureHandle)
{
  TextureVK * texture = HandleIsValid(textureHandle) ? &textures->textures[textureHandle] : nullptr;
 
  if (texture) {
    if (texture->layout != VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
      VkImageSubresourceRange range;
      range.aspectMask = texture->isDepth ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
      range.baseArrayLayer = 0;
      range.baseMipLevel = 0;
      range.layerCount = 1;
      range.levelCount = texture->mipLevels;
 
      setImageLayout(currentFrameResources->commandBuffer, *texture, range.aspectMask, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, range);
    }
  }
 
  uint32_t slots[ShaderType::NumShaderTypes];
  decode(textureBindingHandle.handle, slots);
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    if (slots[i] != NoBinding) {
      shaderState.SRVs[i].setChanged(slots[i], texture, true);
    }
  }
}
 
void Cogs::ContextVK::setSamplerState(const SamplerStateBindingHandle samplerStateBindingHandle, const SamplerStateHandle samplerStateHandle)
{
  SamplerVK * sampler = HandleIsValid(samplerStateHandle) ? &textures->samplers[samplerStateHandle] : nullptr;
 
  uint32_t slots[ShaderType::NumShaderTypes];
  decode(samplerStateBindingHandle.handle, slots);
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    if (slots[i] != NoBinding) {
      shaderState.Samplers[i].setChanged(slots[i], sampler, true);
    }
  }
}
 
void Cogs::ContextVK::setBuffer(const BufferBindingHandle bindingHandle, BufferHandle bufferHandle)
{
  assert(false);
}
 
void Cogs::ContextVK::setInputLayout(const InputLayoutHandle inputLayoutHandle)
{
  state.inputLayout = &buffers->inputLayouts[inputLayoutHandle];
}
 
void Cogs::ContextVK::setVertexBuffers(const VertexBufferHandle * vertexBufferHandles, const size_t count, const uint32_t * strides, const uint32_t * offsets)
{
  assert(false);
}
 
void Cogs::ContextVK::setVertexBuffers(const VertexBufferHandle * vertexBufferHandles, const size_t numVertexBuffers)
{
  iaState.numVertexBuffers = numVertexBuffers;
 
  for (uint32_t i = 0; i < numVertexBuffers; i++) {
    auto & buffer = this->buffers->buffers[BufferHandle(vertexBufferHandles[i].handle)];
 
    assert(buffer.bindFlags & BindFlags::VertexBuffer && "Buffer not bindable as vertex buffer.");
 
    iaState.currentVertexBuffers[i] = &buffer;
    iaState.formats[i] = buffer.vertexFormat;
 
    VkDeviceSize offsets[1] = { 0 };
    vkCmdBindVertexBuffers(currentFrameResources->commandBuffer, i, 1, &buffer.buffer, offsets);
  }
}
 
void Cogs::ContextVK::setIndexBuffer(IndexBufferHandle bufferHandle, uint32_t stride, uint32_t offset_in)
{
  iaState.currentIndexBuffer = &buffers->buffers[bufferHandle];
 
  uint32_t s = stride ? stride : iaState.currentIndexBuffer->indexSize;
  VkDeviceSize offset = offset_in;
  vkCmdBindIndexBuffer(currentFrameResources->commandBuffer,
                       iaState.currentIndexBuffer->buffer,
                       offset,
                       s == 4 ? VK_INDEX_TYPE_UINT32 : VK_INDEX_TYPE_UINT16);
}
 
void Cogs::ContextVK::setVertexArrayObject(VertexArrayObjectHandle vertexArrayObject)
{
  assert(false);
}
 
void Cogs::ContextVK::setConstantBuffer(const ConstantBufferBindingHandle bufferBindingHandle, const BufferHandle bufferHandle, const uint32_t offset, const uint32_t size)
{
  assert(offset == 0 && size == ~0u && "Offset into constant buffers is not implemented");
  auto & buffer = graphicsDevice->buffers.buffers[bufferHandle];
 
  uint32_t slots[ShaderType::NumShaderTypes];
  decode(bufferBindingHandle.handle, slots);
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    if (slots[i] != NoBinding) {
      shaderState.CBVs[i].setChanged(slots[i], &buffer, false);
    }
  }
}
 
void Cogs::ContextVK::setBufferCounter(BufferHandle bufferHandle, uint32_t value)
{
}
 
void Cogs::ContextVK::setBufferCounter(BufferHandle bufferHandle, BufferHandle sourceBufferHandle)
{
}
 
void Cogs::ContextVK::getBufferCounter(BufferHandle bufferHandle, BufferHandle destinationBufferHandle)
{
}
 
uint32_t Cogs::ContextVK::getBufferCounter(BufferHandle bufferHandle)
{
  return uint32_t();
}
 
void Cogs::ContextVK::draw(PrimitiveType::EPrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes)
{
  updatePipelineState(primitiveType);
 
  vkCmdDraw(currentFrameResources->commandBuffer, static_cast<uint32_t>(numVertexes), 1, static_cast<uint32_t>(startVertex), 0);
}
 
void Cogs::ContextVK::drawIndexed(PrimitiveType::EPrimitiveType primitiveType, const size_t startIndex, const size_t numIndexes, const size_t startVertex)
{
  updatePipelineState(primitiveType);
 
  vkCmdDrawIndexed(currentFrameResources->commandBuffer, static_cast<uint32_t>(numIndexes ? numIndexes : iaState.currentIndexBuffer->size), 1, static_cast<uint32_t>(startIndex), static_cast<uint32_t>(startVertex), 0);
}
 
void Cogs::ContextVK::drawInstanced(PrimitiveType::EPrimitiveType primitiveType, const size_t startVertex, const size_t numVertexes, const size_t startInstance, const size_t numInstances)
{
  updatePipelineState(primitiveType);
 
  vkCmdDraw(currentFrameResources->commandBuffer, static_cast<uint32_t>(numVertexes), static_cast<uint32_t>(numInstances), static_cast<uint32_t>(startVertex), static_cast<uint32_t>(startInstance));
}
 
void Cogs::ContextVK::drawInstancedIndexed(PrimitiveType::EPrimitiveType primitiveType, const size_t startInstance, const size_t numInstances, const size_t startIndex, const size_t numIndexes)
{
}
 
void Cogs::ContextVK::dispatchCompute(const unsigned int threadGroupsX, const unsigned int threadGroupsY, const unsigned int threadGroupsZ)
{
}
 
void Cogs::ContextVK::resolveResource(TextureHandle source, TextureHandle destination)
{
  auto & sourceTexture = textures->textures[source];
  auto & destinationTexture = textures->textures[destination];
 
  setImageLayout(currentFrameResources->commandBuffer, sourceTexture, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
  setImageLayout(currentFrameResources->commandBuffer, destinationTexture, VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
 
  VkImageResolve resolve = {};
  resolve.extent = { sourceTexture.width, sourceTexture.height, 1 };
  resolve.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
  resolve.srcSubresource.layerCount = 1;
  resolve.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
  resolve.dstSubresource.layerCount = 1;
 
  vkCmdResolveImage(currentFrameResources->commandBuffer,
    sourceTexture.image,
    sourceTexture.layout,
    destinationTexture.image,
    destinationTexture.layout,
    1,
    &resolve);
}
 
void Cogs::ContextVK::readDepthBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer::EFrameBuffer framebuffer)
{
  assert(false);
}
 
void Cogs::ContextVK::readColorBuffer(BufferHandle bufferHandle, int x, int y, int width, int height, Framebuffer::EFrameBuffer framebuffer)
{
  assert(false);
}
 
void * Cogs::ContextVK::map(BufferHandle bufferHandle, MapMode::EMapMode mapMode, uint32_t * stride)
{
  auto & buffer = graphicsDevice->buffers.buffers[bufferHandle];
 
  if (mapMode == MapMode::WriteDiscard) {
    if (buffer.poolBuffer) {
      currentFrameResources->orhpanedBuffers.push_back(buffer.poolBuffer);
 
      buffer.poolBuffer = buffer.poolBuffer->pool->allocate();
      buffer.bufferInfo.buffer = buffer.poolBuffer->buffer;
      buffer.bufferInfo.offset = buffer.poolBuffer->offset;
      buffer.bufferInfo.range = buffer.poolBuffer->size;
 
      return buffer.poolBuffer->mappedRegion;
    } else {
      void * mappedMemory;
      auto result = vkMapMemory(graphicsDevice->device, buffer.deviceMemory, 0, buffer.size, 0, &mappedMemory);
 
      if (VK_FAILED(result)) {
        return nullptr;
      }
 
      return mappedMemory;
    }
  } else if (mapMode == MapMode::Write) {
    void * mappedMemory;
    auto result = vkMapMemory(graphicsDevice->device, buffer.deviceMemory, 0, buffer.size, 0, &mappedMemory);
 
    if (VK_FAILED(result)) {
      return nullptr;
    }
 
    return mappedMemory;
  } else if (mapMode == MapMode::Read) {
    void * mappedMemory;
    auto result = vkMapMemory(graphicsDevice->device, buffer.deviceMemory, 0, buffer.size, 0, &mappedMemory);
 
    if (VK_FAILED(result)) {
      return nullptr;
    }
 
    return mappedMemory;
  } else {
    assert(false && "Map mode not supported.");
  }
 
  return nullptr;
}
 
void Cogs::ContextVK::unmap(BufferHandle bufferHandle)
{
  auto & buffer = graphicsDevice->buffers.buffers[bufferHandle];
 
  if (!buffer.poolBuffer) {
    vkUnmapMemory(graphicsDevice->device, buffer.deviceMemory);
  }
}
 
void Cogs::ContextVK::updateBuffer(BufferHandle bufferHandle, const void* data, size_t size)
{
  assert(false);
}
 
void *Cogs::ContextVK::map(TextureHandle textureHandle, MapMode::EMapMode accessMode, uint32_t * rowPitch, uint32_t * depthPitch)
{
  assert(false);
  return nullptr;
}
void Cogs::ContextVK::unmap(TextureHandle textureHandle)
{
  assert(false);
}
 
void Cogs::ContextVK::updateSubTexture(TextureHandle textureHandle, const size_t level, const void * data)
{
  assert(false);
  //textures->updateTextureData((const uint8_t **)&data, 1, 1, textures->textures[textureHandle]);
}
 
void Cogs::ContextVK::updateSubBuffer(BufferHandle bufferHandle, const size_t offset, const size_t size, const void * data)
{
  assert(false);
}
 
void Cogs::ContextVK::copyResource(BufferHandle destinationHandle, BufferHandle sourceHandle)
{
  assert(false);
}
 
void Cogs::ContextVK::copyResource(TextureHandle destinationHandle, TextureHandle sourceHandle)
{
  assert(false);
}
 
void Cogs::ContextVK::copyTexture(TextureHandle dstHandle, unsigned dstSub, unsigned dstX, unsigned dstY, unsigned dstZ, TextureHandle sourceHandle, unsigned srcSub)
{
  assert(false);
}
 
bool Cogs::ContextVK::updateDescriptorSet()
{
  auto & effect = graphicsDevice->effects.effects[currentEffect];
 
  bool anyChanged = false;
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    if (shaderState.CBVs[i].hasChanged()) {
      anyChanged = true;
      break;
    }
  }
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    if (shaderState.SRVs[i].hasChanged()) {
      anyChanged = true;
      break;
    }
  }
 
  if (!anyChanged) {
    return false;
  }
 
  VkDescriptorSetAllocateInfo allocInfo = {};
  allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
  allocInfo.descriptorPool = descriptorPool;
  allocInfo.descriptorSetCount = static_cast<uint32_t>(effect.descriptorSetLayouts.size());
  allocInfo.pSetLayouts = effect.descriptorSetLayouts.data();
 
  descriptorSets.resize(effect.descriptorSetLayouts.size());
 
  auto result = vkAllocateDescriptorSets(device, &allocInfo, descriptorSets.data());
 
  if (VK_FAILED(result)) {
    VK_LOG_ERROR(result, "Could not allocate descriptor sets.");
  }
 
  const Shader * shaders[] = {
    &effect.vertexShader,
    nullptr,
    nullptr,
    &effect.geometryShader,
    &effect.pixelShader,
  };
 
  const VkDescriptorSet * sets[] = {
    descriptorSets.size() ? &descriptorSets.front() : nullptr,
    nullptr,
    nullptr,
    descriptorSets.size() == 3 ? &descriptorSets[1] : nullptr,
    descriptorSets.size() ? &descriptorSets.back() : nullptr,
  };
 
  static thread_local std::vector<VkWriteDescriptorSet> writes;
  writes.clear();
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    auto & bindings = shaderState.CBVs[i];
    auto slots = shaderState.effectSignature.slots[SlotType::CBV].values[i];
 
    if (slots) {
      for (size_t j = 0; j < slots; ++j) {
        if (bindings[j]) {
          VkWriteDescriptorSet write = {};
          write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
          write.dstSet = *sets[i];
          write.dstBinding = shaders[i]->reflection.constantBuffers[j].binding;
          write.descriptorCount = 1;
          write.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
          write.pBufferInfo = &bindings[j]->bufferInfo;
          writes.push_back(write);
        }
      }
    }
  }
 
  static thread_local std::vector<VkDescriptorImageInfo> imageInfos;
  imageInfos.clear();
  imageInfos.reserve(128);
 
  for (size_t i = 0; i < ShaderType::NumShaderTypes; ++i) {
    auto & bindings = shaderState.SRVs[i];
    auto slots = shaderState.effectSignature.slots[SlotType::SRV].values[i];
 
    if (!shaders[i]) continue;
 
    auto offset = shaders[i]->reflection.constantBuffers.size();
 
    if (slots) {
      for (size_t j = 0; j < slots; ++j) {
        imageInfos.emplace_back();
        auto & imageInfo = imageInfos.back();
        imageInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL;
 
        if (bindings[j]) {
          imageInfo.imageView = bindings[j]->imageView;
          imageInfo.imageLayout = bindings[j]->layout;
        } else {
          imageInfo.imageView = textures->textures[defaultTexture].imageView;
        }
 
        if (shaderState.Samplers[i][j]) {
          imageInfo.sampler = shaderState.Samplers[i][j]->sampler;
        } else {
          imageInfo.sampler = textures->samplers[defaultSampler].sampler;
        }
 
        VkWriteDescriptorSet write = {};
        write.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
        write.dstSet = *sets[i];
        write.dstBinding = static_cast<uint32_t>(offset + j);
        write.descriptorCount = 1;
        write.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
        write.pImageInfo = &imageInfo;
        writes.push_back(write);
      }
    }
 
    shaderState.SRVs[i].setUnchanged();
  }
 
  vkUpdateDescriptorSets(device, static_cast<uint32_t>(writes.size()), writes.data(), 0, nullptr);
 
  return true;
}
 
bool Cogs::ContextVK::setupPipeline(PrimitiveType::EPrimitiveType primitiveType)
{
  size_t hashCode = fnv1a(reinterpret_cast<const uint8_t *>(&state), sizeof(Vulkan::PipelineState) - sizeof(size_t));
 
  if (hashCode != state.currentStateHash) {
    auto it = PSOs.find(hashCode);
 
    if (it == PSOs.end()) {
      auto & effect = *state.effect;
      auto & inputLayout = *state.inputLayout;
 
      VkDynamicState dynamicStateEnables[VK_DYNAMIC_STATE_RANGE_SIZE] = {};
      VkPipelineDynamicStateCreateInfo dynamicState = {};
      dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
      dynamicState.pDynamicStates = dynamicStateEnables;
 
      VkGraphicsPipelineCreateInfo pipelineInfo = {};
      pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
      pipelineInfo.layout = effect.pipelineLayout;
 
      VkPipelineInputAssemblyStateCreateInfo ia = {};
      ia.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
      ia.topology = primitiveType == PrimitiveType::TriangleList ? VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
 
      VkPipelineViewportStateCreateInfo vp = {};
      vp.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
      vp.viewportCount = 1;
      dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_VIEWPORT;
      vp.scissorCount = 1;
      dynamicStateEnables[dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_SCISSOR;
 
      std::vector<VkPipelineShaderStageCreateInfo> shaderStages;
 
      shaderStages.emplace_back(VkPipelineShaderStageCreateInfo{});
      auto & vsStage = shaderStages.back();
      vsStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
      vsStage.stage = VK_SHADER_STAGE_VERTEX_BIT;
      vsStage.module = effect.vertexShader.shaderModule;
      vsStage.pName = "main";
 
      if (effect.geometryShader.shaderModule) {
        shaderStages.emplace_back(VkPipelineShaderStageCreateInfo{});
        auto & gsStage = shaderStages.back();
        gsStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
        gsStage.stage = VK_SHADER_STAGE_GEOMETRY_BIT;
        gsStage.module = effect.geometryShader.shaderModule;
        gsStage.pName = "main";
      }
 
      if (effect.pixelShader.shaderModule) {
        shaderStages.emplace_back(VkPipelineShaderStageCreateInfo{});
        auto & psStage = shaderStages.back();
        psStage.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
        psStage.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
        psStage.module = effect.pixelShader.shaderModule;
        psStage.pName = "main";
      }
 
      auto & rt = *state.renderTarget;
      auto texture = rt.textures.size() ? rt.textures.front() : rt.depthTexture;
 
      VkPipelineMultisampleStateCreateInfo ms = {};
      ms.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
      ms.pSampleMask = nullptr;
      ms.rasterizationSamples = (VkSampleCountFlagBits)texture->samples;
      ms.sampleShadingEnable = VK_FALSE;
 
      pipelineInfo.pVertexInputState = &inputLayout.vertexInputState;
      pipelineInfo.pInputAssemblyState = &ia;
 
      pipelineInfo.pRasterizationState = &state.rasterizerState->state;
      pipelineInfo.pDepthStencilState = &state.depthStencilState->state;
      state.blendState->state.attachmentCount = static_cast<uint32_t>(rt.textures.size());
      pipelineInfo.pColorBlendState = &state.blendState->state;
 
      pipelineInfo.stageCount = static_cast<uint32_t>(shaderStages.size());
      pipelineInfo.pStages = shaderStages.data();
 
      pipelineInfo.renderPass = rt.renderPass;
      pipelineInfo.pMultisampleState = &ms;
      pipelineInfo.pViewportState = &vp;
      pipelineInfo.pDynamicState = &dynamicState;
 
      VkPipelineCacheCreateInfo pipelineCacheInfo = {};
      pipelineCacheInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
 
      auto result = vkCreatePipelineCache(device, &pipelineCacheInfo, nullptr, &pipelineCache);
 
      if (VK_FAILED(result)) {
        VK_LOG_ERROR(result, "Could not create pipeline cache.");
        return false;
      }
 
      VkPipeline pipeline = {};
      result = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineInfo, nullptr, &pipeline);
 
      if (VK_FAILED(result)) {
        VK_LOG_ERROR(result, "Could not create graphics pipeline.");
        return false;
      }
 
      vkDestroyPipelineCache(device, pipelineCache, nullptr);
 
      PSOs[hashCode] = pipeline;
      state.currentStateHash = hashCode;
    }
 
    vkCmdBindPipeline(currentFrameResources->commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, PSOs[hashCode]);
  }
 
  return true;
}
 
void Cogs::ContextVK::updatePipelineState(PrimitiveType::EPrimitiveType primitiveType)
{
  if (!renderPass) {
    beginRenderPass();
  }
 
  if (!setupPipeline(primitiveType)) {
    LOG_ERROR(logger, "Failed to update pipeline state.");
    return;
  }
 
  updateConstantBuffers();
 
  updateDescriptorSet();
 
  vkCmdBindDescriptorSets(currentFrameResources->commandBuffer,
    VK_PIPELINE_BIND_POINT_GRAPHICS,
    state.effect->pipelineLayout,
    0, static_cast<uint32_t>(descriptorSets.size()),
    descriptorSets.data(),
    0,
    nullptr);
}
 
void Cogs::ContextVK::beginRenderPass()
{
  auto & renderTarget = *state.renderTarget;
 
  VkRenderPassBeginInfo renderPassBeginInfo = {};
  renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
  renderPassBeginInfo.pNext = nullptr;
  renderPassBeginInfo.renderPass = renderTarget.renderPass;
  renderPassBeginInfo.framebuffer = renderTarget.framebuffer;
  renderPassBeginInfo.renderArea.offset.x = 0;
  renderPassBeginInfo.renderArea.offset.y = 0;
  if (renderTarget.textures.size() && renderTarget.textures[0]->width != 0) {
    renderPassBeginInfo.renderArea.extent.width = renderTarget.textures[0]->width;
    renderPassBeginInfo.renderArea.extent.height = renderTarget.textures[0]->height;
  } else if (renderTarget.depthTexture && renderTarget.depthTexture->width != 0) {
    renderPassBeginInfo.renderArea.extent.width = renderTarget.depthTexture->width;
    renderPassBeginInfo.renderArea.extent.height = renderTarget.depthTexture->height;
  } else {
    renderPassBeginInfo.renderArea.extent.width = graphicsDevice->width;
    renderPassBeginInfo.renderArea.extent.height = graphicsDevice->height;
  }
  renderPassBeginInfo.clearValueCount = static_cast<uint32_t>(clearValues.size());
  renderPassBeginInfo.pClearValues = clearValues.data();
 
  vkCmdBeginRenderPass(currentFrameResources->commandBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
  renderPass = renderTarget.renderPass;
}
 
void Cogs::ContextVK::endRenderPass()
{
  vkCmdEndRenderPass(currentFrameResources->commandBuffer);
  renderPass = VK_NULL_HANDLE;
}