Renderer.hpp

Go to the documentation of this file.

#pragma once

#if defined(__ANDROID__)
#include <android/asset_manager.h>
#elif defined(SMALL3D_IOS)
 // todo: Add ios includes if necessary
#else
#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#endif

#include "Logger.hpp"
#include "Image.hpp"
#include "Model.hpp"
#include "SceneObject.hpp"

#include <unordered_map>
#include <vector>

#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <ft2build.h>
#include FT_FREETYPE_H

namespace small3d
{
  struct VulkanImage {
    VkImageView imageView = VK_NULL_HANDLE;
    VkImage image = VK_NULL_HANDLE;
    VkDeviceMemory imageMemory = VK_NULL_HANDLE;
    VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
    VkDescriptorSet orthoDescriptorSet = VK_NULL_HANDLE;
  };

  struct UboOrientation {
    glm::mat4x4 xRotationMatrix;
    glm::mat4x4 yRotationMatrix;
    glm::mat4x4 zRotationMatrix;
    glm::vec3 offset;
    float padding[13];
  };

  struct UboColour {
    glm::vec4 colour;
    float padding[4];
  };

  class Renderer
  {

  private:

#if !defined(__ANDROID__) && !defined(SMALL3D_IOS)
    GLFWwindow* window;
#endif

    std::string windowTitle = "";

    static int realScreenWidth, realScreenHeight;

    std::string shadersPath = "";

    uint32_t maxObjectsPerPass;

    uint32_t perspectivePipelineIndex = 100;
    uint32_t orthographicPipelineIndex = 100;

    uint32_t currentSwapchainImageIndex = 0;

    std::vector<VkBuffer> renderOrientationBuffersDynamic;
    std::vector<VkDeviceMemory> renderOrientationBuffersDynamicMemory;

    std::vector<VkBuffer> cameraOrientationBuffers;
    std::vector<VkDeviceMemory> cameraOrientationBufferMemories;

    std::vector<VkBuffer> worldDetailsBuffers;
    std::vector<VkDeviceMemory> worldDetailsBufferMemories;

    std::vector<VkBuffer> lightIntensityBuffers;
    std::vector<VkDeviceMemory> lightIntensityBufferMemories;

    std::vector<VkBuffer> colourBuffersDynamic;
    std::vector<VkDeviceMemory> colourBuffersDynamicMemory;

    VkSampler textureSampler;

    std::vector<VkImageView> boundTextureViews;

    std::allocator<char> alloc;

    float frustumScale = 0.0f;
    float zNear = 0.0f;
    float zFar = 0.0f;
    float zOffsetFromCamera = 0.0f;

    std::unordered_map<std::string, VulkanImage> textures;

    FT_Library library = 0;
    std::vector<float> textMemory;
    std::unordered_map<std::string, FT_Face> fontFaces;

#ifdef __ANDROID__
    std::vector<AAsset*> fontAssets;
#endif

    static std::vector<Model> nextModelsToDraw;

    static VkVertexInputBindingDescription bd[3];
    static VkVertexInputAttributeDescription ad[3];

    static VkDescriptorSetLayout descriptorSetLayout;
    static VkDescriptorSet descriptorSet;
    static VkDescriptorSetLayout textureDescriptorSetLayout;
    static VkDescriptorSetLayout perspectiveLayouts[2];

    static VkVertexInputBindingDescription orthobd[2];
    static VkVertexInputAttributeDescription orthoad[2];

    static VkDescriptorSetLayout orthoDescriptorSetLayout;
    static VkDescriptorSet orthoDescriptorSet;
    static VkDescriptorSetLayout textureOrthoDescriptorSetLayout;
    static VkDescriptorSetLayout orthographicLayouts[2];

    size_t dynamicOrientationAlignment = 0;
    UboOrientation* uboOrientationDynamic = nullptr;
    uint32_t orientationMemIndex = 0;
    size_t uboOrientationDynamicSize = 0;

    size_t dynamicColourAlignment = 0;
    UboColour* uboColourDynamic = nullptr;
    uint32_t colourMemIndex = 0;
    size_t uboColourDynamicSize = 0;


#if !defined(__ANDROID__) && !defined(SMALL3D_IOS)
    static void framebufferSizeCallback(GLFWwindow* window, int width,
                    int height);
#endif
    
    static int setInputStateCallback(VkPipelineVertexInputStateCreateInfo*
      inputStateCreateInfo);
    static int setPipelineLayoutCallback(VkPipelineLayoutCreateInfo*
      pipelineLayoutCreateInfo);

    int bindBuffers(VkCommandBuffer commandBuffer, const Model& model);
    void recordDrawCommand(VkCommandBuffer commandBuffer,
      VkPipelineLayout pipelineLayout, const Model& model,
      uint32_t swapchainImageIndex);

    static int setOrthoInputStateCallback(VkPipelineVertexInputStateCreateInfo*
      inputStateCreateInfo);
    static int setOrthoPipelineLayoutCallback(VkPipelineLayoutCreateInfo*
      pipelineLayoutCreateInfo);

    int bindOrthoBuffers(VkCommandBuffer commandBuffer,
      const Model& model);
    void recordOrthoDrawCommand(VkCommandBuffer commandBuffer,
      VkPipelineLayout pipelineLayout, const Model& model,
      uint32_t swapchainImageIndex);

    void initVulkan();

    VkDescriptorPool descriptorPool;
    bool descriptorPoolCreated = false;
    void createDescriptorPool();

    VkDescriptorPool orthoDescriptorPool;
    bool orthoDescriptorPoolCreated = false;
    void createOrthoDescriptorPool();

    VkCommandBuffer nextCommandBuffer;

    std::vector<Model> garbageModels;

    void allocateDescriptorSets();
    void updateDescriptorSets();

    void allocateOrthoDescriptorSets();
    void updateOrthoDescriptorSets();

    void setColourBuffer(glm::vec4 colour, uint32_t memIndex);

    void positionNextObject(const glm::vec3 offset,
      const glm::vec3 rotation,
      uint32_t memIndex);
    void positionCamera();
    VulkanImage getTextureHandle(const std::string name) const;
    VulkanImage generateTexture(const std::string name,
      const float* data,
      const unsigned long width,
      const unsigned long height,
      const bool replace);

    void init(const int width, const int height,
      const std::string shadersPath);
    void initWindow(int& width, int& height);

    void setPerspectiveAndLight();

    // On Android and iOS, it is useful to be able to destroy and recreate the
    // renderer, so it is not provided only as a singleton for that platform.
    // By the way, do NOT create a renderer using getInstance and then
    // try to delete it in code. That will make an app crash. Either
    // create it with getInstance and assume it is a singleton which
    // will be destroyed automatically when the program terminates,
    // or instantiate it with "new" if you would like to delete it
    // later.
#if defined(__ANDROID__) || defined(SMALL3D_IOS)
  public:
    Renderer(const std::string &windowTitle = "",
      const int width = 0,
      const int height = 0,
      const float frustumScale = 1.0f,
      const float zNear = 1.0f,
      const float zFar = 24.0f,
      const float zOffsetFromCamera = -1.0f,
      const std::string &shadersPath =
#ifndef SMALL3D_IOS
      "resources/shaders/",
#else
      "resources1/shaders/",
#endif
      const uint32_t maxObjectsPerPass = 20);
#else
    Renderer(const std::string &windowTitle, const int width,
      const int height, const float frustumScale, const float zNear,
      const float zFar, const float zOffsetFromCamera,
      const std::string &shadersPath, const uint32_t maxObjectsPerPass);


#endif

    Renderer();

#if !defined(__ANDROID__) && !defined(SMALL3D_IOS)
  public:
#endif

    glm::vec3 lightDirection;

    glm::vec3 cameraPosition;

    glm::vec3 cameraRotation;

    int getScreenWidth();

    int getScreenHeight();

    float lightIntensity = 1.0f;

    static Renderer& getInstance(const std::string &windowTitle = "",
      const int width = 0,
      const int height = 0,
      const float frustumScale = 1.0f,
      const float zNear = 1.0f,
      const float zFar = 24.0f,
      const float zOffsetFromCamera = -1.0f,
      const std::string &shadersPath =
      "resources/shaders/",
      const uint32_t maxObjectsPerPass = 20);

    ~Renderer();

#if !defined(__ANDROID__) && !defined(SMALL3D_IOS)

    GLFWwindow* getWindow() const;
#endif

    void generateTexture(const std::string &name, const Image &image);

    void generateTexture(const std::string &name, const std::string &text,
      const glm::vec3 &colour,
      const int fontSize = 48,
      const std::string &fontPath =
#ifndef SMALL3D_IOS
      "resources/fonts/CrusoeText/CrusoeText-Regular.ttf",
#else
      "resources1/fonts/CrusoeText/CrusoeText-Regular.ttf",
#endif
      const bool replace = true);

    void deleteTexture(const std::string &name);

    void createRectangle(Model& rect,
      const glm::vec3& topLeft,
      const glm::vec3& bottomRight);

    void render(Model& model, const glm::vec3 &offset, const glm::vec3 &rotation,
      const glm::vec4 &colour, const std::string &textureName = "",
      const bool perspective = true);

    void render(Model& model, const glm::vec3 &offset, const glm::vec3 &rotation,
      const std::string &textureName);

    void render(Model& model, const std::string& textureName,
      const bool perspective = true);

    void render(Model& model, const glm::vec4& colour,
      const bool perspective = true);


    void render(SceneObject &sceneObject, const glm::vec4 &colour);

    void render(SceneObject &sceneObject, const std::string &textureName);

    void clearBuffers(Model& model) const;

    void clearBuffers(SceneObject& sceneObject) const;

    void clearScreen() const;

    void clearScreen(const glm::vec4 &colour);

    void swapBuffers();

    Renderer(Renderer const&) = delete;
    void operator=(Renderer const&) = delete;
    Renderer(Renderer&&) = delete;
    void operator=(Renderer&&) = delete;

  };
}