sphericalenvmapping.cpp

/*
* Vulkan Example - Spherical Environment Mapping, using different mat caps
*
* Use +/-/space toggle through different material captures
*
* Based on
* https://www.clicktorelease.com/blog/creating-spherical-environment-mapping-shader
*
* Copyright (C) 2016 by Sascha Willems - www.saschawillems.de
*
* This code is licensed under the MIT license (MIT)
* (http://opensource.org/licenses/MIT)
*/

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>

#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/glm.hpp>
#include <glm/gtc/matrix_inverse.hpp>
#include <glm/gtc/matrix_transform.hpp>

#include "VulkanBuffer.hpp"
#include "VulkanModel.hpp"
#include "VulkanTexture.hpp"
#include "vulkanexamplebase.h"
#include <vulkan/vulkan.h>

#define VERTEX_BUFFER_BIND_ID 0
#define ENABLE_VALIDATION false

class VulkanExample : public VulkanExampleBase {
public:
  struct {
    VkPipelineVertexInputStateCreateInfo inputState;
    std::vector<VkVertexInputBindingDescription> bindingDescriptions;
    std::vector<VkVertexInputAttributeDescription> attributeDescriptions;
  } vertices;

  // Vertex layout for the models
  vks::VertexLayout vertexLayout = vks::VertexLayout({
      vks::VERTEX_COMPONENT_POSITION, vks::VERTEX_COMPONENT_NORMAL,
      vks::VERTEX_COMPONENT_UV, vks::VERTEX_COMPONENT_COLOR,
  });

  struct {
    vks::Model object;
  } models;

  struct {
    vks::Texture2DArray matCapArray;
  } textures;

  vks::Buffer uniformBuffer;

  struct UBOVS {
    glm::mat4 projection;
    glm::mat4 model;
    glm::mat4 normal;
    glm::mat4 view;
    int32_t texIndex = 0;
  } uboVS;

  VkPipeline pipeline;
  VkPipelineLayout pipelineLayout;
  VkDescriptorSet descriptorSet;
  VkDescriptorSetLayout descriptorSetLayout;

  VulkanExample() : VulkanExampleBase(ENABLE_VALIDATION) {
    zoom = -0.9f;
    rotationSpeed = 0.75f;
    zoomSpeed = 0.25f;
    rotation = glm::vec3(-25.0f, 23.75f, 0.0f);
    title = "Spherical Environment Mapping";
    settings.overlay = true;
  }

  ~VulkanExample() {
    // Clean up used Vulkan resources
    // Note : Inherited destructor cleans up resources stored in base class
    vkDestroyPipeline(device, pipeline, nullptr);

    vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
    vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);

    models.object.destroy();

    uniformBuffer.destroy();
    textures.matCapArray.destroy();
  }

  void loadAssets() {
    models.object.loadFromFile(getAssetPath() + "models/chinesedragon.dae",
                               vertexLayout, 0.05f, vulkanDevice, queue);
    // Multiple mat caps are stored in a single texture array so they can easily
    // be switched inside the shader  just by updating the index in a uniform
    // buffer
    textures.matCapArray.loadFromFile(
        getAssetPath() + "textures/matcap_array_rgba.ktx",
        VK_FORMAT_R8G8B8A8_UNORM, vulkanDevice, queue);
  }

  void buildCommandBuffers() {
    VkCommandBufferBeginInfo cmdBufInfo =
        vks::initializers::commandBufferBeginInfo();

    VkClearValue clearValues[2];
    clearValues[0].color = defaultClearColor;
    clearValues[1].depthStencil = {1.0f, 0};

    VkRenderPassBeginInfo renderPassBeginInfo =
        vks::initializers::renderPassBeginInfo();
    renderPassBeginInfo.renderPass = renderPass;
    renderPassBeginInfo.renderArea.offset.x = 0;
    renderPassBeginInfo.renderArea.offset.y = 0;
    renderPassBeginInfo.renderArea.extent.width = width;
    renderPassBeginInfo.renderArea.extent.height = height;
    renderPassBeginInfo.clearValueCount = 2;
    renderPassBeginInfo.pClearValues = clearValues;

    for (int32_t i = 0; i < drawCmdBuffers.size(); ++i) {
      // Set target frame buffer
      renderPassBeginInfo.framebuffer = frameBuffers[i];

      VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));

      vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo,
                           VK_SUBPASS_CONTENTS_INLINE);

      VkViewport viewport =
          vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);
      vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);

      VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);
      vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);

      vkCmdBindDescriptorSets(drawCmdBuffers[i],
                              VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout,
                              0, 1, &descriptorSet, 0, NULL);
      vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS,
                        pipeline);

      VkDeviceSize offsets[1] = {0};
      vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1,
                             &models.object.vertices.buffer, offsets);
      vkCmdBindIndexBuffer(drawCmdBuffers[i], models.object.indices.buffer, 0,
                           VK_INDEX_TYPE_UINT32);

      vkCmdDrawIndexed(drawCmdBuffers[i], models.object.indexCount, 1, 0, 0, 0);

      vkCmdEndRenderPass(drawCmdBuffers[i]);

      VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
    }
  }

  void prepareVertices() {
    // Binding description
    vertices.bindingDescriptions.resize(1);
    vertices.bindingDescriptions[0] =
        vks::initializers::vertexInputBindingDescription(
            VERTEX_BUFFER_BIND_ID, vertexLayout.stride(),
            VK_VERTEX_INPUT_RATE_VERTEX);

    // Attribute descriptions
    // Describes memory layout and shader positions
    vertices.attributeDescriptions.resize(4);
    // Location 0 : Position
    vertices.attributeDescriptions[0] =
        vks::initializers::vertexInputAttributeDescription(
            VERTEX_BUFFER_BIND_ID, 0, VK_FORMAT_R32G32B32_SFLOAT, 0);
    // Location 1 : Normal
    vertices.attributeDescriptions[1] =
        vks::initializers::vertexInputAttributeDescription(
            VERTEX_BUFFER_BIND_ID, 1, VK_FORMAT_R32G32B32_SFLOAT,
            sizeof(float) * 3);
    // Location 2 : Texture coordinates
    vertices.attributeDescriptions[2] =
        vks::initializers::vertexInputAttributeDescription(
            VERTEX_BUFFER_BIND_ID, 2, VK_FORMAT_R32G32_SFLOAT,
            sizeof(float) * 6);
    // Location 3 : Color
    vertices.attributeDescriptions[3] =
        vks::initializers::vertexInputAttributeDescription(
            VERTEX_BUFFER_BIND_ID, 3, VK_FORMAT_R32G32B32_SFLOAT,
            sizeof(float) * 8);

    vertices.inputState =
        vks::initializers::pipelineVertexInputStateCreateInfo();
    vertices.inputState.vertexBindingDescriptionCount =
        vertices.bindingDescriptions.size();
    vertices.inputState.pVertexBindingDescriptions =
        vertices.bindingDescriptions.data();
    vertices.inputState.vertexAttributeDescriptionCount =
        vertices.attributeDescriptions.size();
    vertices.inputState.pVertexAttributeDescriptions =
        vertices.attributeDescriptions.data();
  }

  void setupDescriptorPool() {
    // Example uses one ubo and one image sampler
    std::vector<VkDescriptorPoolSize> poolSizes = {
        vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
                                              1),
        vks::initializers::descriptorPoolSize(
            VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1)};

    VkDescriptorPoolCreateInfo descriptorPoolInfo =
        vks::initializers::descriptorPoolCreateInfo(poolSizes.size(),
                                                    poolSizes.data(), 2);

    VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr,
                                           &descriptorPool));
  }

  void setupDescriptorSetLayout() {
    std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {
        // Binding 0 : Vertex shader uniform buffer
        vks::initializers::descriptorSetLayoutBinding(
            VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_VERTEX_BIT, 0),
        // Binding 1 : Fragment shader color map image sampler
        vks::initializers::descriptorSetLayoutBinding(
            VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
            VK_SHADER_STAGE_FRAGMENT_BIT, 1)};

    VkDescriptorSetLayoutCreateInfo descriptorLayout =
        vks::initializers::descriptorSetLayoutCreateInfo(
            setLayoutBindings.data(), setLayoutBindings.size());

    VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout,
                                                nullptr, &descriptorSetLayout));

    VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =
        vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayout, 1);

    VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo,
                                           nullptr, &pipelineLayout));
  }

  void setupDescriptorSet() {
    VkDescriptorSetAllocateInfo allocInfo =
        vks::initializers::descriptorSetAllocateInfo(descriptorPool,
                                                     &descriptorSetLayout, 1);

    VK_CHECK_RESULT(
        vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));

    std::vector<VkWriteDescriptorSet> writeDescriptorSets = {
        // Binding 0 : Vertex shader uniform buffer
        vks::initializers::writeDescriptorSet(descriptorSet,
                                              VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
                                              0, &uniformBuffer.descriptor),
        // Binding 1 : Fragment shader image sampler
        vks::initializers::writeDescriptorSet(
            descriptorSet, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1,
            &textures.matCapArray.descriptor)};

    vkUpdateDescriptorSets(device, writeDescriptorSets.size(),
                           writeDescriptorSets.data(), 0, NULL);
  }

  void preparePipelines() {
    VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
        vks::initializers::pipelineInputAssemblyStateCreateInfo(
            VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, 0, VK_FALSE);

    VkPipelineRasterizationStateCreateInfo rasterizationState =
        vks::initializers::pipelineRasterizationStateCreateInfo(
            VK_POLYGON_MODE_FILL, VK_CULL_MODE_BACK_BIT,
            VK_FRONT_FACE_CLOCKWISE, 0);

    VkPipelineColorBlendAttachmentState blendAttachmentState =
        vks::initializers::pipelineColorBlendAttachmentState(0xf, VK_FALSE);

    VkPipelineColorBlendStateCreateInfo colorBlendState =
        vks::initializers::pipelineColorBlendStateCreateInfo(
            1, &blendAttachmentState);

    VkPipelineDepthStencilStateCreateInfo depthStencilState =
        vks::initializers::pipelineDepthStencilStateCreateInfo(
            VK_TRUE, VK_TRUE, VK_COMPARE_OP_LESS_OR_EQUAL);

    VkPipelineViewportStateCreateInfo viewportState =
        vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0);

    VkPipelineMultisampleStateCreateInfo multisampleState =
        vks::initializers::pipelineMultisampleStateCreateInfo(
            VK_SAMPLE_COUNT_1_BIT, 0);

    std::vector<VkDynamicState> dynamicStateEnables = {
        VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR};
    VkPipelineDynamicStateCreateInfo dynamicState =
        vks::initializers::pipelineDynamicStateCreateInfo(
            dynamicStateEnables.data(), dynamicStateEnables.size(), 0);

    // Spherical environment rendering pipeline
    // Load shaders
    std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
    shaderStages[0] =
        loadShader(getAssetPath() + "shaders/sphericalenvmapping/sem.vert.spv",
                   VK_SHADER_STAGE_VERTEX_BIT);
    shaderStages[1] =
        loadShader(getAssetPath() + "shaders/sphericalenvmapping/sem.frag.spv",
                   VK_SHADER_STAGE_FRAGMENT_BIT);

    VkGraphicsPipelineCreateInfo pipelineCreateInfo =
        vks::initializers::pipelineCreateInfo(pipelineLayout, renderPass, 0);

    pipelineCreateInfo.pVertexInputState = &vertices.inputState;
    pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
    pipelineCreateInfo.pRasterizationState = &rasterizationState;
    pipelineCreateInfo.pColorBlendState = &colorBlendState;
    pipelineCreateInfo.pMultisampleState = &multisampleState;
    pipelineCreateInfo.pViewportState = &viewportState;
    pipelineCreateInfo.pDepthStencilState = &depthStencilState;
    pipelineCreateInfo.pDynamicState = &dynamicState;
    pipelineCreateInfo.stageCount = shaderStages.size();
    pipelineCreateInfo.pStages = shaderStages.data();

    VK_CHECK_RESULT(vkCreateGraphicsPipelines(
        device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipeline));
  }

  void prepareUniformBuffers() {
    // Vertex shader uniform buffer block
    VK_CHECK_RESULT(
        vulkanDevice->createBuffer(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
                                   VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                                       VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
                                   &uniformBuffer, sizeof(uboVS)));

    // Map persistent
    VK_CHECK_RESULT(uniformBuffer.map());

    updateUniformBuffers();
  }

  void updateUniformBuffers() {
    uboVS.projection = glm::perspective(
        glm::radians(45.0f), (float)width / (float)height, 0.1f, 256.0f);

    uboVS.view = glm::lookAt(glm::vec3(0, 0, -zoom), glm::vec3(0, 0, 0),
                             glm::vec3(0, 1, 0));

    uboVS.model = glm::mat4(1.0f);
    uboVS.model = glm::rotate(uboVS.model, glm::radians(rotation.x),
                              glm::vec3(1.0f, 0.0f, 0.0f));
    uboVS.model = glm::rotate(uboVS.model, glm::radians(rotation.y),
                              glm::vec3(0.0f, 1.0f, 0.0f));
    uboVS.model = glm::rotate(uboVS.model, glm::radians(rotation.z),
                              glm::vec3(0.0f, 0.0f, 1.0f));

    uboVS.normal = glm::inverseTranspose(uboVS.view * uboVS.model);

    memcpy(uniformBuffer.mapped, &uboVS, sizeof(uboVS));
  }

  void draw() {
    VulkanExampleBase::prepareFrame();

    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
    VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));

    VulkanExampleBase::submitFrame();
  }

  void prepare() {
    VulkanExampleBase::prepare();
    loadAssets();
    prepareVertices();
    prepareUniformBuffers();
    setupDescriptorSetLayout();
    preparePipelines();
    setupDescriptorPool();
    setupDescriptorSet();
    buildCommandBuffers();
    prepared = true;
  }

  virtual void render() {
    if (!prepared)
      return;
    draw();
  }

  virtual void viewChanged() { updateUniformBuffers(); }

  virtual void OnUpdateUIOverlay(vks::UIOverlay *overlay) {
    if (overlay->header("Settings")) {
      if (overlay->sliderInt("Material cap", &uboVS.texIndex, 0,
                             textures.matCapArray.layerCount)) {
        updateUniformBuffers();
      }
    }
  }
};

VULKAN_EXAMPLE_MAIN()