Renderer.hpp

Go to the documentation of this file.

 
#pragma once
#include <vector>
 
#define GLEW_NO_GLU
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#ifdef _WIN32
#define GLFW_EXPOSE_NATIVE_WIN32
#include <GLFW/glfw3native.h>
#endif
 
#include "Logger.hpp"
#include "Image.hpp"
#include "Model.hpp"
#include "SceneObject.hpp"
#include <unordered_map>
#include "Math.h"
#include <ft2build.h>
#include FT_FREETYPE_H
 
namespace small3d
{
 
  class Renderer
  {
 
  private:
 
    GLFWwindow* window;
 
    static int realScreenWidth, realScreenHeight;
 
    uint32_t shaderProgram = 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 fieldOfView = 0.0f;
    float zNear = 0.0f;
    float zFar = 0.0f;
 
    Vec4 clearColour = Vec4(0.0f, 0.0f, 0.0f, 1.0f);
 
    std::unordered_map<std::string, uint32_t> textures;
 
    FT_Library library = 0;
    std::vector<uint8_t> textMemory;
    std::unordered_map<std::string, FT_Face> fontFaces;
 
    Mat4 cameraTransformation = Mat4(1.0f);
    Vec3 cameraRotationXYZ = Vec3(0.0f);
    bool cameraRotationByMatrix = false;
 
    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 transform(Model& model, Vec3& offset,
      const Mat4& rotation, uint64_t currentPose) const;
 
    uint32_t getTextureHandle(const std::string& name) const;
    uint32_t generateTexture(const std::string& name, const uint8_t* 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 setWorldDetails(bool perspective);
 
    void bindTexture(const std::string& name);
 
    void clearScreen() const;
 
    Renderer(const std::string& windowTitle, const int width, const int height,
      const float fieldOfView, const float zNear, const float zFar,
      const std::string& shadersPath,
      const uint32_t objectsPerFrame,
      const uint32_t objectsPerFrameInc);
 
    Renderer();
 
    std::vector<std::tuple< Model*, Vec3, Mat4, Vec4, std::string, bool, uint64_t>> renderList;
 
    void renderTuple(std::tuple< Model*, Vec3, Mat4, Vec4, std::string, bool, uint64_t> tuple);
 
    GLuint depthMapFramebuffer = 0;
    GLuint depthMapTexture = 0;
 
    const uint32_t depthMapTextureWidth = 2048;
    const uint32_t depthMapTextureHeight = 2048;
    Mat4 lightSpaceMatrix = Mat4(0);
    bool renderingDepthMap = false;
 
 
#ifdef _WIN32
    void captureScreen();
#endif
 
  public:
    GLint origRenderbuffer = 0;
 
    GLint origFramebuffer = 0;
 
    bool shadowsActive = false;
 
    void start(const std::string& windowTitle, const int width, const int height,
      const float fieldOfView, const float zNear, const float zFar,
      const std::string& shadersPath,
      const uint32_t objectsPerFrame,
      const uint32_t objectsPerFrameInc);
 
    void stop();
 
    Vec3 lightDirection = Vec3(0.0f, 0.7f, 0.3f);
 
    float shadowSpaceSize = 20.0f;
 
    Mat4 shadowCamTransformation =
      rotate(Mat4(1.0f), 1.57f, Vec3(1.0f, 0.0f, 0.0f)) *
      translate(Mat4(1.0f), Vec3(0.0f, -10.0f, 0.0f));
 
    Vec3 cameraPosition = Vec3(0, 0, 0);
 
    void setCameraRotation(const Vec3& rotation);
 
    void rotateCamera(const Vec3& rotation);
 
    void setCameraTransformation(const Mat4& transformation);
 
    const Vec3 getCameraOrientation() const;
 
    const Mat4 getCameraRotation() const;
 
    const Vec3 getCameraRotationXYZ() const;
 
    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 fieldOfView = 0.785,
      const float zNear = 1.0f,
      const float zFar = 24.0f,
      const std::string& shadersPath =
 
      "resources/shaders/",
 
      const uint32_t objectsPerFrame = 200,
      const uint32_t objectsPerFrameInc = 1000);
 
    ~Renderer();
 
    GLFWwindow* getWindow() const;
 
    void generateTexture(const std::string& name, const Image& image);
 
    void generateTexture(const std::string& name, const std::string& text,
      const 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 Vec3& topLeft,
      const Vec3& bottomRight);
 
    void render(Model& model, const Vec3& position, const Vec3& rotation,
      const Vec4& colour, const std::string& textureName = "",
      const uint64_t currentPose = 0,
      const bool perspective = true);
 
    void render(Model& model, const Vec3& position, const Vec3& rotation,
      const std::string& textureName, const uint64_t currentPose = 0);
 
    void render(Model& model, const Vec3& position, const Mat4& rotation,
      const Vec4& colour, const std::string& textureName = "",
      const uint64_t currentPose = 0,
      const bool perspective = true);
 
    void render(Model& model, const Vec3& position, const Mat4& rotation,
      const std::string& textureName, const uint64_t currentPose = 0);
 
    void render(Model& model, const std::string& textureName, const uint64_t currentPose = 0,
      const bool perspective = true);
 
    void render(Model& model, const Vec4& colour, const uint64_t currentPose = 0,
      const bool perspective = true);
 
    void render(SceneObject& sceneObject, const Vec4& colour);
 
    void render(SceneObject& sceneObject, const std::string& textureName);
 
    void clearBuffers(Model& model) const;
 
    void clearBuffers(SceneObject& sceneObject) const;
 
    void setBackgroundColour(const Vec4& colour);
 
    void swapBuffers();
 
#ifdef _WIN32
 
    bool screenCapture = false;
#endif
 
    Renderer(Renderer const&) = delete;
    void operator=(Renderer const&) = delete;
    Renderer(Renderer&&) = delete;
    void operator=(Renderer&&) = delete;
 
  };
 
}