Renderer.hpp

Go to the documentation of this file.

#pragma once

#define GLEW_NO_GLU
#include <GL/glew.h>
#include <GLFW/glfw3.h>

#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
{

  class Renderer
  {

  private:

    GLFWwindow* window;

    static int realScreenWidth, realScreenHeight;

    uint32_t perspectiveProgram = 0;
    uint32_t orthographicProgram = 0;
    uint32_t vao = 0;

    uint32_t renderOrientation = 0;
    uint32_t cameraOrientation = 0;
    uint32_t worldDetails = 0;
    uint32_t lightUboId = 0;
    uint32_t perspColourUboId = 0;
    uint32_t orthoColourUboId = 0;

    bool noShaders;

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

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

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

    static void framebufferSizeCallback(GLFWwindow* window, int width,
                    int height);

    std::string loadShaderFromFile(const std::string& fileLocation) const;
    uint32_t compileShader(const std::string& shaderSourceFile,
      const uint32_t shaderType) const;
    std::string getProgramInfoLog(const uint32_t linkedProgram) const;
    std::string getShaderInfoLog(const uint32_t shader) const;
    void initOpenGL();
    void checkForOpenGLErrors(const std::string& when, const bool abort) const;

    void positionNextObject(const glm::vec3& offset,
      const glm::vec3& rotation) const;
    void positionCamera() const;
    uint32_t getTextureHandle(const std::string& name) const;
    uint32_t 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& windowTitle,
      const std::string& shadersPath);
    void initWindow(int& width, int& height,
      const std::string& windowTitle = "");

    void setPerspectiveAndLight();

    void bindTexture(const std::string& name, bool perspective);

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

    Renderer();

  public:
    glm::vec3 lightDirection;

    glm::vec3 cameraPosition;

    glm::vec3 cameraRotation;

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

    GLFWwindow* getWindow() const;

    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 =
      "resources/fonts/CrusoeText/CrusoeText-Regular.ttf",
      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) const;

    void swapBuffers() const;

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

  };

}