Pasted

#include <GL/glew.h>
#include <GLFW/glfw3.h>
 
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
 
#include "Shader.h"
 
const float DEFAULT_FOV = 90.0f;
 
class Camera {
public:
    glm::vec3 Position = glm::vec3(0.0f);
    glm::vec3 Front;
    glm::vec3 Up;
    glm::vec3 Right;
    glm::vec3 FrontDirection;
    glm::vec3 RightDirection;
 
    float Yaw = 270.0f;
    float Pitch = 0.0f;
    float Zoom = DEFAULT_FOV;
 
    Camera() {
        UpdateCameraVectors();
    }
 
    inline glm::mat4 GetViewMatrix() {
        return glm::lookAt(Position, Position + Front, Up);
    }
    
    void UpdateCameraVectors();
};
 
void Camera::UpdateCameraVectors() {
    glm::vec3 front;
    front.x = glm::cos(glm::radians(Yaw)) * glm::cos(glm::radians(Pitch));
    front.y = glm::sin(glm::radians(Pitch));
    front.z = glm::sin(glm::radians(Yaw)) * glm::cos(glm::radians(Pitch));
 
    FrontDirection = glm::normalize(glm::vec3(front.x, 0, front.z));
    RightDirection = glm::vec3(-FrontDirection.z, 0, FrontDirection.x);
 
    Front = glm::normalize(front);
    Right = glm::normalize(glm::cross(Front, glm::vec3(0, 1, 0)));
    Up    = glm::normalize(glm::cross(Right, Front));
}
 
static bool WindowFocused   = true;
static bool WindowMinimized = false;
 
double DeltaTime = 0.0;
double LastFrame = 0.0;
 
// Defining shaders.
Shader* shader = nullptr;
 
// Initializing objects.
Camera Cam = Camera();
UniformBuffer UBO = UniformBuffer();
 
// The main window which everything is rendered in.
GLFWwindow* Window = nullptr;
 
bool FULLSCREEN            = true;
bool VSYNC                 = true;
 
int  FOV                   = 90;
int  MIPMAP_LEVEL          = 4;
int  SCREEN_HEIGHT         = 1080;
int  SCREEN_WIDTH          = 1920;
int  ANISOTROPIC_FILTERING = 16;
 
void Key_Proxy(GLFWwindow* window, int key, int scancode, int action, int mods) {
 
}
 
void Mouse_Proxy(GLFWwindow* window, double posX, double posY) {
 
}
 
// Proxy for receiving Unicode codepoints, very useful for getting text input.
void Text_Proxy(GLFWwindow* window, unsigned int codepoint) {
 
}
 
void Scroll_Proxy(GLFWwindow* window, double offsetX, double offsetY) {
 
}
 
void Click_Proxy(GLFWwindow* window, int button, int action, int mods) {
 
}
 
void Window_Focused(GLFWwindow* window, int focused) {
    WindowFocused = focused > 0;
}
 
void Window_Minimized(GLFWwindow* window, int iconified) {
    WindowMinimized = iconified > 0;
}
 
void Exit(void* caller) {
    glfwSetWindowShouldClose(Window, true);
}
 
void Init_GL() {
    // Set the OpenGL version.
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, true);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_RESIZABLE, false);
    glfwWindowHint(GLFW_AUTO_ICONIFY, false);
 
    GLFWmonitor* monitor = glfwGetPrimaryMonitor();
 
    // Get the video mode of the monitor.
    const GLFWvidmode* videoMode = glfwGetVideoMode(monitor);
 
    int sWidth, sHeight;
    glfwGetMonitorPhysicalSize(monitor, &sWidth, &sHeight);
 
    SCREEN_DPI = videoMode->width / (sWidth / 25.4);
 
    if (FULLSCREEN) {
        // Stops the window from having any decoration, such as a title bar.
        glfwWindowHint(GLFW_DECORATED, false);
 
        // Set SCREEN_WIDTH and SCREEN_HEIGHT to the resolution of the primary monitor.
        SCREEN_WIDTH = videoMode->width;
        SCREEN_HEIGHT = videoMode->height;
        glfwWindowHint(GLFW_REFRESH_RATE, videoMode->refreshRate);
 
        // Create a fullscreen window.
        Window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Craftmine", monitor, nullptr);
    }
    else {
        // Set the window to be decorated, allowing users to close it.
        glfwWindowHint(GLFW_DECORATED, true);
 
        // Create a windowed window.
        Window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Craftmine", nullptr, nullptr);
    }
 
    // Set the window's position to the upper left corner.
    glfwSetWindowPos(Window, 0, 0);
 
    // Set the window to be used for future OpenGL calls.
    glfwMakeContextCurrent(Window);
 
    // Set whether to use VSync based on the value in the config file.
    glfwSwapInterval(VSYNC);
 
    // Set GLEW to experimental mode (doesn't work otherwise D:)
    glewExperimental = GL_TRUE;
 
    // Initializes GLEW, which enables vendor-specific OpenGL extensions.
    glewInit();
 
    // Set all the callback functions for events to the appropiate proxy functions.
    glfwSetKeyCallback(Window, Key_Proxy);
    glfwSetCharCallback(Window, Text_Proxy);
    glfwSetScrollCallback(Window, Scroll_Proxy);
    glfwSetCursorPosCallback(Window, Mouse_Proxy);
    glfwSetMouseButtonCallback(Window, Click_Proxy);
    glfwSetWindowIconifyCallback(Window, Window_Minimized);
 
    // Enable Blending, which makes transparency work.
    glEnable(GL_BLEND);
 
    // Enable Fade Culling, which disables rendering of hidden faces.
    glEnable(GL_CULL_FACE);
 
    // Enable Depth Testing,
    // which chooses which elements to draw based on their depth, thus allowing 3D to work.
    glEnable(GL_DEPTH_TEST);
 
    // Set the proper function for evaluating blending.
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
    // Specify the size of the OpenGL view port.
    glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
 
    // Set the color that the window gets filled with when the color buffer gets cleared.
    glClearColor(CLEAR_COLOR.r, CLEAR_COLOR.g, CLEAR_COLOR.b, 1.0f);
}
 
void Init_Textures() {
    glActiveTexture(GL_TEXTURE0);
 
    // Load the texture atlas into a texture array, with mipmapping enabled,
    // and store it in the active Texture Unit.
    glBindTexture(
        GL_TEXTURE_2D_ARRAY,
        Load_Array_Texture(
            "atlas.png", {16, 32},
            MIPMAP_LEVEL, static_cast<float>(ANISOTROPIC_FILTERING)
        )
    );
}
 
void Init_Shaders() {
    // Load the shaders.
    shader = new Shader("shader");
 
    // Create the frustrum projection matrix for the camera.
    glm::mat4 projection = glm::perspective(
        glm::radians(static_cast<float>(FOV)),
        static_cast<float>(SCREEN_WIDTH) / SCREEN_HEIGHT,
        Z_NEAR_LIMIT, Z_FAR_LIMIT
    );
 
    // Create a matrix storage block in the shaders referenced in the last argument.
    UBO.Create("Matrices", 0, 2 * sizeof(glm::mat4),
        {shader}
    );
 
    UBO.Upload(1, projection);
}
 
void Init_Rendering() {
    // Default identity matrix, does nothing.
    glm::mat4 model;
 
    // Upload the empty matrix.
    shader->Upload("model", model);
 
    // Upload the light level of an unlit block.
    shader->Upload("ambient", AMBIENT_LIGHT);
 
    // Upload the max light level of a block.
    shader->Upload("diffuse", DIFFUSE_LIGHT);
 
    // Upload the texture unit index of the main textures.
    shader->Upload("diffTex", 0);
}
 
void Render_Scene() {
    UBO.Upload(0, Cam.GetViewMatrix());
 
    /*
     * RENDER SHIT
     */
}
 
int main() {
    // Initialize GLFW, the library responsible for windowing, events, etc...
    glfwInit();
 
    Init_GL();
    Init_Textures();
    Init_Shaders();
    Init_Rendering();
 
    // The main loop.
    // Runs until window is closed.
    while (!glfwWindowShouldClose(Window)) {
        if (WindowMinimized || !WindowFocused) {
            glfwWaitEvents();
            continue;
        }
 
        // Clear the screen buffer from the last frame.
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
        // Get the time difference between this frame and the last one.
        double currentFrame = glfwGetTime();
        DeltaTime = currentFrame - LastFrame;
        LastFrame = currentFrame;
 
        // Polls and processes received events.
        glfwPollEvents();
 
        Render_Scene();
 
        // Swap the newly rendered frame with the old one.
        glfwSwapBuffers(Window);
    }
 
    // Shut down the graphics library, and return.
    glfwTerminate();
 
    return 0;
}