convex-hull-visualizer/Main.cpp

#include <iostream>
#include <cstring>
#include <fstream>

#include "rendering/GLFW.h"
#include "rendering/Window.h"
#include "rendering/Shader.h"
#include "input/Keys.h"
#include "rendering/GL.h"
#include "rendering/Renderer.h"
#include "Game.h"
#include "utils/Random.h"

bool initGLEW() {
    GLenum err = glewInit();
    if(err != GLEW_OK) {
        std::cout << "could not initialize GLEW: " << glewGetErrorString(err) << "\n";
        return true;
    }
    std::cout << "using GLEW " << glewGetString(GLEW_VERSION) << "\n";
    return false;
}

void initCallbacks(Window& w, Keys& keys) {
    static Keys& cKeys = keys;
    w.setFramebufferSizeCallback([](GLFWwindow*, int newWidth, int newHeight) {
        glViewport(0, 0, newWidth, newHeight);
    });
    w.setKeyCallback([](GLFWwindow*, int key, int, int action, int) {
        if(action == GLFW_PRESS) {
            cKeys.press(key);
        } else if(action == GLFW_RELEASE) {
            cKeys.release(key);
        }
    });
}

int main(int argAmount, const char** args) {
    if(argAmount < 2 || strcmp(args[1], "-r") == 0) {
        std::cout << "expecting at least one argument: filename or number\n";
        return 0;
    }
    bool steps = true;
    bool skip = true;
    for(int i = 1; i < argAmount; i++) {
        if(strcmp(args[i], "-r") == 0) {
            steps = false;
        } else if(strcmp(args[i], "-v") == 0) {
            skip = false;
        }
    }

    if(skip) {
        Keys keys;
        Game game(keys, args[1], steps);
        return 0;
    }

    if(GLFW::hasError()) {
        return 0;
    }

    Window window(1024, 620, "Test");
    if(window.hasError() || initGLEW()) {
        return 0;
    }

    Shader shader;
    if(shader.hasError()) {
        return 0;
    }

    Keys keys;
    Game game(keys, args[1], steps);

    initCallbacks(window, keys);
    window.show();

    GL::disableDepthTesting();
    GL::checkAndPrintError("setup error");

    const u64 nanosPerTick = 25000000;
    u64 lastTime = GLFW::getTimeNanos();
    u64 lag = 0;
    while(!window.shouldClose() && game.isRunning()) {
        GL::checkAndPrintError("loop error");

        GL::prepareMainFramebuffer();
        shader.use();
        Renderer renderer;
        game.render(static_cast<float> (lag) / nanosPerTick, renderer);

        window.swapBuffers();
        u64 currentTime = GLFW::getTimeNanos();
        lag += currentTime - lastTime;
        lastTime = currentTime;
        while(lag >= nanosPerTick) {
            lag -= nanosPerTick;
            keys.tick();
            game.tick();
        }
        glfwPollEvents();
    }
    return 0;
}