distancefieldfonts.cpp

/*
* Vulkan Example - Font rendering using signed distance fields
*
* Font generated using https://github.com/libgdx/libgdx/wiki/Hiero
*
* Copyright (C) 2016 by Sascha Willems - www.saschawillems.de
*
* This code is licensed under the MIT license (MIT)
* (http://opensource.org/licenses/MIT)
*/

#include <array>
#include <assert.h>
#include <sstream>
#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_transform.hpp>

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

#define VERTEX_BUFFER_BIND_ID 0
#define ENABLE_VALIDATION false

// Vertex layout for this example
struct Vertex {
  float pos[3];
  float uv[2];
};

// AngelCode .fnt format structs and classes
struct bmchar {
  uint32_t x, y;
  uint32_t width;
  uint32_t height;
  int32_t xoffset;
  int32_t yoffset;
  int32_t xadvance;
  uint32_t page;
};

// Quick and dirty : complete ASCII table
// Only chars present in the .fnt are filled with data!
std::array<bmchar, 255> fontChars;

int32_t nextValuePair(std::stringstream *stream) {
  std::string pair;
  *stream >> pair;
  uint32_t spos = pair.find("=");
  std::string value = pair.substr(spos + 1);
  int32_t val = std::stoi(value);
  return val;
}

class VulkanExample : public VulkanExampleBase {
public:
  bool splitScreen = true;

  struct {
    vks::Texture2D fontSDF;
    vks::Texture2D fontBitmap;
  } textures;

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

  vks::Buffer vertexBuffer;
  vks::Buffer indexBuffer;
  uint32_t indexCount;

  struct {
    vks::Buffer vs;
    vks::Buffer fs;
  } uniformBuffers;

  struct UBOVS {
    glm::mat4 projection;
    glm::mat4 model;
  } uboVS;

  struct UBOFS {
    glm::vec4 outlineColor = glm::vec4(1.0f, 0.0f, 0.0f, 0.0f);
    float outlineWidth = 0.6f;
    float outline = true;
  } uboFS;

  struct {
    VkPipeline sdf;
    VkPipeline bitmap;
  } pipelines;

  struct {
    VkDescriptorSet sdf;
    VkDescriptorSet bitmap;
  } descriptorSets;

  VkPipelineLayout pipelineLayout;
  VkDescriptorSetLayout descriptorSetLayout;

  VulkanExample() : VulkanExampleBase(ENABLE_VALIDATION) {
    zoom = -2.0f;
    title = "Distance field font rendering";
    settings.overlay = true;
  }

  ~VulkanExample() {
    // Clean up used Vulkan resources
    // Note : Inherited destructor cleans up resources stored in base class

    // Clean up texture resources
    textures.fontSDF.destroy();
    textures.fontBitmap.destroy();

    vkDestroyPipeline(device, pipelines.sdf, nullptr);
    vkDestroyPipeline(device, pipelines.bitmap, nullptr);

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

    vertexBuffer.destroy();
    indexBuffer.destroy();

    uniformBuffers.vs.destroy();
    uniformBuffers.fs.destroy();
  }

  // Basic parser fpr AngelCode bitmap font format files
  // See http://www.angelcode.com/products/bmfont/doc/file_format.html for
  // details
  void parsebmFont() {
    std::string fileName = getAssetPath() + "font.fnt";

#if defined(__ANDROID__)
    // Font description file is stored inside the apk
    // So we need to load it using the asset manager
    AAsset *asset = AAssetManager_open(androidApp->activity->assetManager,
                                       fileName.c_str(), AASSET_MODE_STREAMING);
    assert(asset);
    size_t size = AAsset_getLength(asset);

    assert(size > 0);

    void *fileData = malloc(size);
    AAsset_read(asset, fileData, size);
    AAsset_close(asset);

    std::stringbuf sbuf((const char *)fileData);
    std::istream istream(&sbuf);
#else
    std::filebuf fileBuffer;
    fileBuffer.open(fileName, std::ios::in);
    std::istream istream(&fileBuffer);
#endif

    assert(istream.good());

    while (!istream.eof()) {
      std::string line;
      std::stringstream lineStream;
      std::getline(istream, line);
      lineStream << line;

      std::string info;
      lineStream >> info;

      if (info == "char") {
        // char id
        uint32_t charid = nextValuePair(&lineStream);
        // Char properties
        fontChars[charid].x = nextValuePair(&lineStream);
        fontChars[charid].y = nextValuePair(&lineStream);
        fontChars[charid].width = nextValuePair(&lineStream);
        fontChars[charid].height = nextValuePair(&lineStream);
        fontChars[charid].xoffset = nextValuePair(&lineStream);
        fontChars[charid].yoffset = nextValuePair(&lineStream);
        fontChars[charid].xadvance = nextValuePair(&lineStream);
        fontChars[charid].page = nextValuePair(&lineStream);
      }
    }
  }

  void loadAssets() {
    textures.fontSDF.loadFromFile(getAssetPath() + "textures/font_sdf_rgba.ktx",
                                  VK_FORMAT_R8G8B8A8_UNORM, vulkanDevice,
                                  queue);
    textures.fontBitmap.loadFromFile(
        getAssetPath() + "textures/font_bitmap_rgba.ktx",
        VK_FORMAT_R8G8B8A8_UNORM, vulkanDevice, queue);
  }

  void reBuildCommandBuffers() {
    if (!checkCommandBuffers()) {
      destroyCommandBuffers();
      createCommandBuffers();
    }
    buildCommandBuffers();
  }

  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) {
      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, (splitScreen) ? (float)height / 2.0f : (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);

      VkDeviceSize offsets[1] = {0};

      // Signed distance field font
      vkCmdBindDescriptorSets(drawCmdBuffers[i],
                              VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout,
                              0, 1, &descriptorSets.sdf, 0, NULL);
      vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS,
                        pipelines.sdf);
      vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1,
                             &vertexBuffer.buffer, offsets);
      vkCmdBindIndexBuffer(drawCmdBuffers[i], indexBuffer.buffer, 0,
                           VK_INDEX_TYPE_UINT32);
      vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0);

      // Linear filtered bitmap font
      if (splitScreen) {
        viewport.y = (float)height / 2.0f;
        vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
        vkCmdBindDescriptorSets(drawCmdBuffers[i],
                                VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout,
                                0, 1, &descriptorSets.bitmap, 0, NULL);
        vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS,
                          pipelines.bitmap);
        vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0);
      }

      vkCmdEndRenderPass(drawCmdBuffers[i]);

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

  // Creates a vertex buffer containing quads for the passed text
  void generateText(std::string text) {
    std::vector<Vertex> vertices;
    std::vector<uint32_t> indices;
    uint32_t indexOffset = 0;

    float w = textures.fontSDF.width;

    float posx = 0.0f;
    float posy = 0.0f;

    for (uint32_t i = 0; i < text.size(); i++) {
      bmchar *charInfo = &fontChars[(int)text[i]];

      if (charInfo->width == 0)
        charInfo->width = 36;

      float charw = ((float)(charInfo->width) / 36.0f);
      float dimx = 1.0f * charw;
      float charh = ((float)(charInfo->height) / 36.0f);
      float dimy = 1.0f * charh;
      posy = 1.0f - charh;

      float us = charInfo->x / w;
      float ue = (charInfo->x + charInfo->width) / w;
      float ts = charInfo->y / w;
      float te = (charInfo->y + charInfo->height) / w;

      float xo = charInfo->xoffset / 36.0f;
      float yo = charInfo->yoffset / 36.0f;

      vertices.push_back({{posx + dimx + xo, posy + dimy, 0.0f}, {ue, te}});
      vertices.push_back({{posx + xo, posy + dimy, 0.0f}, {us, te}});
      vertices.push_back({{posx + xo, posy, 0.0f}, {us, ts}});
      vertices.push_back({{posx + dimx + xo, posy, 0.0f}, {ue, ts}});

      std::array<uint32_t, 6> letterIndices = {0, 1, 2, 2, 3, 0};
      for (auto &index : letterIndices) {
        indices.push_back(indexOffset + index);
      }
      indexOffset += 4;

      float advance = ((float)(charInfo->xadvance) / 36.0f);
      posx += advance;
    }
    indexCount = indices.size();

    // Center
    for (auto &v : vertices) {
      v.pos[0] -= posx / 2.0f;
      v.pos[1] -= 0.5f;
    }

    // Generate host accesible buffers for the text vertices and indices and
    // upload the data

    VK_CHECK_RESULT(vulkanDevice->createBuffer(
        VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
            VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
        &vertexBuffer, vertices.size() * sizeof(Vertex), vertices.data()));

    VK_CHECK_RESULT(vulkanDevice->createBuffer(
        VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
        VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
            VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
        &indexBuffer, indices.size() * sizeof(uint32_t), indices.data()));
  }

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

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

    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() {
    std::vector<VkDescriptorPoolSize> poolSizes = {
        vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
                                              4),
        vks::initializers::descriptorPoolSize(
            VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 2)};

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

    VkResult vkRes = vkCreateDescriptorPool(device, &descriptorPoolInfo,
                                            nullptr, &descriptorPool);
    assert(!vkRes);
  }

  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 image sampler
        vks::initializers::descriptorSetLayoutBinding(
            VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
            VK_SHADER_STAGE_FRAGMENT_BIT, 1),
        // Binding 2 : Fragment shader uniform buffer
        vks::initializers::descriptorSetLayoutBinding(
            VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT,
            2)};

    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);

    // Signed distance front descriptor set
    VK_CHECK_RESULT(
        vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.sdf));

    // Image descriptor for the color map texture
    VkDescriptorImageInfo texDescriptor =
        vks::initializers::descriptorImageInfo(
            textures.fontSDF.sampler, textures.fontSDF.view,
            VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

    std::vector<VkWriteDescriptorSet> writeDescriptorSets = {
        // Binding 0 : Vertex shader uniform buffer
        vks::initializers::writeDescriptorSet(descriptorSets.sdf,
                                              VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
                                              0, &uniformBuffers.vs.descriptor),
        // Binding 1 : Fragment shader texture sampler
        vks::initializers::writeDescriptorSet(
            descriptorSets.sdf, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1,
            &texDescriptor),
        // Binding 2 : Fragment shader uniform buffer
        vks::initializers::writeDescriptorSet(
            descriptorSets.sdf, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2,
            &uniformBuffers.fs.descriptor)};

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

    // Default font rendering descriptor set
    VK_CHECK_RESULT(
        vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.bitmap));

    // Image descriptor for the color map texture
    texDescriptor.sampler = textures.fontBitmap.sampler;
    texDescriptor.imageView = textures.fontBitmap.view;

    writeDescriptorSets = {
        // Binding 0 : Vertex shader uniform buffer
        vks::initializers::writeDescriptorSet(descriptorSets.bitmap,
                                              VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
                                              0, &uniformBuffers.vs.descriptor),
        // Binding 1 : Fragment shader texture sampler
        vks::initializers::writeDescriptorSet(
            descriptorSets.bitmap, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1,
            &texDescriptor)};

    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_NONE,
            VK_FRONT_FACE_COUNTER_CLOCKWISE, 0);

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

    blendAttachmentState.blendEnable = VK_TRUE;
    blendAttachmentState.srcColorBlendFactor = VK_BLEND_FACTOR_ONE;
    blendAttachmentState.dstColorBlendFactor =
        VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
    blendAttachmentState.colorBlendOp = VK_BLEND_OP_ADD;
    blendAttachmentState.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE;
    blendAttachmentState.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO;
    blendAttachmentState.alphaBlendOp = VK_BLEND_OP_ADD;
    blendAttachmentState.colorWriteMask =
        VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
        VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;

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

    VkPipelineDepthStencilStateCreateInfo depthStencilState =
        vks::initializers::pipelineDepthStencilStateCreateInfo(
            VK_FALSE, 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);

    // Load shaders
    std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;

    shaderStages[0] =
        loadShader(getAssetPath() + "shaders/distancefieldfonts/sdf.vert.spv",
                   VK_SHADER_STAGE_VERTEX_BIT);
    shaderStages[1] =
        loadShader(getAssetPath() + "shaders/distancefieldfonts/sdf.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,
                                              &pipelines.sdf));

    // Default bitmap font rendering pipeline
    shaderStages[0] = loadShader(
        getAssetPath() + "shaders/distancefieldfonts/bitmap.vert.spv",
        VK_SHADER_STAGE_VERTEX_BIT);
    shaderStages[1] = loadShader(
        getAssetPath() + "shaders/distancefieldfonts/bitmap.frag.spv",
        VK_SHADER_STAGE_FRAGMENT_BIT);
    VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1,
                                              &pipelineCreateInfo, nullptr,
                                              &pipelines.bitmap));
  }

  // Prepare and initialize uniform buffer containing shader uniforms
  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,
                                   &uniformBuffers.vs, sizeof(uboVS)));

    // Fragment sahder uniform buffer block (Contains font rendering parameters)
    VK_CHECK_RESULT(
        vulkanDevice->createBuffer(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
                                   VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                                       VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
                                   &uniformBuffers.fs, sizeof(uboFS)));

    // Map persistent
    VK_CHECK_RESULT(uniformBuffers.vs.map());
    VK_CHECK_RESULT(uniformBuffers.fs.map());

    updateUniformBuffers();
    updateFontSettings();
  }

  void updateUniformBuffers() {
    // Vertex shader
    glm::mat4 viewMatrix = glm::mat4(1.0f);
    uboVS.projection = glm::perspective(
        glm::radians(splitScreen ? 30.0f : 45.0f),
        (float)width / (float)(height * ((splitScreen) ? 0.5f : 1.0f)), 0.001f,
        256.0f);
    viewMatrix = glm::translate(
        viewMatrix, glm::vec3(0.0f, 0.0f, splitScreen ? zoom : zoom - 2.0f));

    uboVS.model = glm::mat4(1.0f);
    uboVS.model = viewMatrix * glm::translate(uboVS.model, cameraPos);
    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));

    memcpy(uniformBuffers.vs.mapped, &uboVS, sizeof(uboVS));
  }

  void updateFontSettings() {
    // Fragment shader
    memcpy(uniformBuffers.fs.mapped, &uboFS, sizeof(uboFS));
  }

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

    // Command buffer to be sumitted to the queue
    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];

    // Submit to queue
    VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));

    VulkanExampleBase::submitFrame();
  }

  void prepare() {
    VulkanExampleBase::prepare();
    parsebmFont();
    loadAssets();
    generateText("Vulkan");
    setupVertexDescriptions();
    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")) {
      bool outline = (uboFS.outline == 1.0f);
      if (overlay->checkBox("Outline", &outline)) {
        uboFS.outline = outline ? 1.0f : 0.0f;
        updateFontSettings();
      }
      if (overlay->checkBox("Splitscreen", &splitScreen)) {
        buildCommandBuffers();
        updateUniformBuffers();
      }
    }
  }
};

VULKAN_EXAMPLE_MAIN()