cube-game-plus-plus/client/GameClient.cpp

#include <iostream>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <unordered_map>
#include <cmath>
#include <cstring>
#include <array>

#include "common/utils/Types.h"
#include "client/GameClient.h"
#include "client/input/Keys.h"
#include "client/input/MouseButtons.h"
#include "client/rendering/Shader.h"
#include "client/rendering/FontRenderer.h"
#include "client/rendering/Mesh.h"
#include "client/rendering/Framebuffer.h"
#include "client/Utils.h"
#include "client/math/Camera.h"
#include "client/math/Matrix.h"
#include "client/math/MatrixStack.h"
#include "client/Game.h"
#include "rendering/NoiseTexture.h"

struct InternGameClient {

    ~InternGameClient() {
        if(window != nullptr) {
            glfwDestroyWindow(window);
        }
        if(glfwInitDone) {
            glfwTerminate();
        }
    }

    bool glfwInitDone = false;
    GLFWwindow* window = nullptr;
};

static const u64 NANOS_PER_TICK = 50000000;
static const float lagFactor = 1.0f / NANOS_PER_TICK;
static u64 timeFactor = 1;
static int width = 0;
static int height = 0;
static bool resize = false;
static float fovY = 60.0f;
static float nearClip = 0.1f;
static float farClip = 1000.0f;
static InternGameClient client;
static Keys keys;
static MouseButtons mButtons;
static bool useSSAO = false;

static float testRadius = 0.005;
static float testBias = 0.00025;

struct Shaders {

    Shaders() :
    world("resources/shader/worldVertex.vs", "resources/shader/worldFragment.fs"),
    ssao("resources/shader/ssaoVertex.vs", "resources/shader/ssaoFragment.fs"),
    ssaoBlur("resources/shader/ssaoBlurVertex.vs", "resources/shader/ssaoBlurFragment.fs"),
    shadow("resources/shader/worldShadowVertex.vs", "resources/shader/worldShadowFragment.fs"),
    postWorld("resources/shader/worldPostVertex.vs", "resources/shader/worldPostFragment.fs"),
    text("resources/shader/textVertex.vs", "resources/shader/textFragment.fs") {
        worldProj.set(11, -1.0f);
        worldProj.set(15, 0.0f);

        worldShadowProj.set(11, -1.0f);
        worldShadowProj.set(15, 0.0f);
    }

    Shader world;
    Shader ssao;
    Shader ssaoBlur;
    Shader shadow;
    Shader postWorld;
    Shader text;
    bool once = true;

    Matrix worldProj;
    Matrix worldView;

    Matrix worldShadowProj;
    Matrix worldShadowView;
    Matrix worldShadowProjView;

    bool isValid() const {
        return world.isValid() && ssao.isValid() && ssaoBlur.isValid() &&
                shadow.isValid() && postWorld.isValid() && text.isValid();
    }

    void updateWorldProjection() {
        float tan = tanf((0.5f * fovY) * M_PI / 180.0f);
        float q = 1.0f / tan;
        float aspect = (float) width / height;

        worldProj.set(0, q / aspect);
        worldProj.set(5, q);
        worldProj.set(10, (nearClip + farClip) / (nearClip - farClip));
        worldProj.set(14, (2.0f * nearClip * farClip) / (nearClip - farClip));

        if(once) {
            worldShadowProj.setToIdentity();
            worldShadowProj.set(0, 2.0f / (10.0f * aspect));
            worldShadowProj.set(5, 2.0f / (10.0f));
            worldShadowProj.set(10, -2.0f / (farClip - nearClip));
        }
    }

    void updateWorldView(float lag, Camera& cam) {
        cam.update(lag);
        Vector right = cam.getRight();
        Vector up = cam.getUp();
        Vector back = cam.getBack();
        Vector pos = cam.getPosition();

        worldView.set(0, right.getX());
        worldView.set(1, up.getX());
        worldView.set(2, back.getX());
        worldView.set(4, right.getY());
        worldView.set(5, up.getY());
        worldView.set(6, back.getY());
        worldView.set(8, right.getZ());
        worldView.set(9, up.getZ());
        worldView.set(10, back.getZ());
        worldView.set(12, right.dotInverse(pos));
        worldView.set(13, up.dotInverse(pos));
        worldView.set(14, back.dotInverse(pos));

        if(once) {
            // lengthAngle = 20; widthAngle = 35;
            right.set(0.939693f, 0.0f, -0.34202f);
            back.set(0.280166f, 0.573576f, 0.769751f);
            up.set(-0.196175f, 0.819152f, -0.538986f);
            pos.set(0.0f, 2.5f, 0.0f);

            once = false;
            worldShadowView.set(0, right.getX());
            worldShadowView.set(1, up.getX());
            worldShadowView.set(2, back.getX());
            worldShadowView.set(4, right.getY());
            worldShadowView.set(5, up.getY());
            worldShadowView.set(6, back.getY());
            worldShadowView.set(8, right.getZ());
            worldShadowView.set(9, up.getZ());
            worldShadowView.set(10, back.getZ());
            worldShadowView.set(12, right.dotInverse(pos));
            worldShadowView.set(13, up.dotInverse(pos));
            worldShadowView.set(14, back.dotInverse(pos));
        }
    }
};

struct Framebuffers {

    Framebuffers(u32 w, u32 h) :
    world(w, h, Framebuffer::POSITION | Framebuffer::NORMAL | Framebuffer::COLOR | Framebuffer::RED | Framebuffer::DEPTH24_STENCIL8, 0),
    ssao(w, h, Framebuffer::RED, 0),
    ssaoBlur(w, h, Framebuffer::RED, 0),
    shadow(w, h, Framebuffer::DEPTH24_STENCIL8, 0 /*GL_LEQUAL*/) {
    }

    void resize(u32 w, u32 h) const {
        world.resize(w, h);
        ssao.resize(w, h);
        ssaoBlur.resize(w, h);
        shadow.resize(w, h);
    }

    bool isValid() const {
        return world.isValid() && ssao.isValid() && ssaoBlur.isValid();
    }

    Framebuffer world;
    Framebuffer ssao;
    Framebuffer ssaoBlur;
    Framebuffer shadow;
};

struct InternGame {

    InternGame() : ssaoNoise(4, 4) {
        rectangle.add( {-1, -1, 0, 0, 0, 0, 0, 0});
        rectangle.add( {1, 1, 0, 1, 1, 0, 0, 0});
        rectangle.add( {-1, 1, 0, 0, 1, 0, 0, 0});
        rectangle.add( {-1, -1, 0, 0, 0, 0, 0, 0});
        rectangle.add( {1, -1, 0, 1, 0, 0, 0, 0});
        rectangle.add( {1, 1, 0, 1, 1, 0, 0, 0});
        rectangle.build();
    }

    Game game;
    Camera cam;
    MatrixStack model;
    FontRenderer fontRenderer;
    NoiseTexture ssaoNoise;
    Mesh rectangle;
};

static u64 getTimeNanos() {
    return glfwGetTimerValue() * timeFactor;
}

static bool initGLFW() {
    client.glfwInitDone = glfwInit();
    if(!client.glfwInitDone) {
        std::cout << "could not initialize GLFW\n";
        return true;
    }
    timeFactor = 1000000000 / glfwGetTimerFrequency();
    return false;
}

static bool initWindow(int w, int h, const char* windowName) {
    width = w;
    height = h;

    glfwDefaultWindowHints();
    glfwWindowHint(GLFW_VISIBLE, 0);
    glfwWindowHint(GLFW_RESIZABLE, 1);

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    client.window = glfwCreateWindow(width, height, windowName, nullptr, nullptr);
    if(client.window == nullptr) {
        std::cout << "could not create window\n";
        return true;
    }
    glfwMakeContextCurrent(client.window);
    glfwSwapInterval(1);
    return false;
}

static 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;
}

static void initCallbacks() {
    // GLFWwindow* w, int key, int scancode, int action, int mod
    glfwSetKeyCallback(client.window, [](GLFWwindow*, int key, int, int action, int) {
        if(action == GLFW_PRESS) {
            keys.press(key);
        } else if(action == GLFW_RELEASE) {
            keys.release(key);
        }
    });
    // GLFWwindow* w, int button, int action, int mods
    glfwSetMouseButtonCallback(client.window, [](GLFWwindow*, int button, int action, int) {
        if(action == GLFW_PRESS) {
            mButtons.press(button);
        } else if(action == GLFW_RELEASE) {
            mButtons.release(button);
        }
    });
    // GLFWwindow* w, double xpos, double ypos
    glfwSetCursorPosCallback(client.window, [](GLFWwindow*, double x, double y) {
        mButtons.move(x, y);
    });
    // GLFWwindow* w, int width, int height
    glfwSetFramebufferSizeCallback(client.window, [](GLFWwindow*, int w, int h) {
        glViewport(0, 0, w, h);
        width = w;
        height = h;
        resize = true;
    });
}

static void tick(InternGame& game) {
    keys.tick();
    mButtons.tick();
    game.game.tick(keys, mButtons, game.cam);
    if(keys.test.isDown()) {
        //useSSAO = !useSSAO;
        //useSSAO = true;
        testRadius /= 0.95f;
    }
    if(keys.test2.isDown()) {
        testRadius *= 0.95f;
    }
    if(keys.test3.isDown()) {
        testBias /= 0.95f;
    }
    if(keys.test4.isDown()) {
        testBias *= 0.95f;
    }
    mButtons.postTick();
}

static void renderShadow(float lag, Shaders& shaders, InternGame& game, Framebuffers& fb) {
    fb.shadow.bind();
    glEnable(GL_DEPTH_TEST);
    shaders.shadow.use();
    shaders.worldShadowProjView = shaders.worldShadowProj;
    shaders.worldShadowProjView.mul(shaders.worldShadowView);
    shaders.shadow.setMatrix("projView", shaders.worldShadowProjView.getValues());
    
    game.game.renderWorld(lag, game.model, shaders.shadow);
}

static void renderWorld(float lag, Shaders& shaders, InternGame& game, Framebuffers& fb) {
    fb.world.bind();
    glEnable(GL_DEPTH_TEST);
    shaders.world.use();

    Matrix rWorldShadowProjView;
    rWorldShadowProjView.translate(0.5f, 0.5f, 0.5f);
    rWorldShadowProjView.scale(0.5f, 0.5f, 0.5f);
    rWorldShadowProjView.mul(shaders.worldShadowProjView);

    shaders.world.setMatrix("projViewShadow", rWorldShadowProjView.getValues());
    shaders.world.setMatrix("proj", shaders.worldProj.getValues());
    shaders.world.setMatrix("view", shaders.worldView.getValues());
    game.model.clear();
    shaders.world.setMatrix("model", game.model.get().getValues());
    fb.shadow.bindDepthTexture(1);
    shaders.world.setFloat("radius", testRadius);
    shaders.world.setFloat("bias", testBias);
    game.game.renderWorld(lag, game.model, shaders.world);
}

static void renderSSAO(Shaders& shaders, InternGame& game, Framebuffers& fb) {
    // ssao
    shaders.ssao.use();

    Matrix rProj;
    rProj.translate(0.5f, 0.5f, 0.5f);
    rProj.scale(0.5f, 0.5f, 0.5f);
    rProj.mul(shaders.worldProj);

    shaders.ssao.setMatrix("proj", rProj.getValues());
    shaders.ssao.setInt("width", width);
    shaders.ssao.setInt("height", height);
    fb.world.bindPositionTexture(0);
    fb.world.bindNormalTexture(1);
    fb.world.bindColorTexture(2);
    fb.world.bindDepthTexture(3);
    game.ssaoNoise.bind(4);
    fb.ssao.bind();
    game.rectangle.draw();
    // ssao blur
    shaders.ssaoBlur.use();
    fb.ssao.bindRedTexture(0);
    fb.ssaoBlur.bind();
    game.rectangle.draw();
}

static void renderPostWorld(Shaders& shaders, InternGame& game, Framebuffers& fb) {
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    shaders.postWorld.use();
    fb.world.bindColorTexture(0);
    fb.ssaoBlur.bindRedTexture(1);
    fb.world.bindRedTexture(2);
    fb.world.bindNormalTexture(3);
    shaders.postWorld.setInt("useSSAO", useSSAO);
    game.rectangle.draw();
}

static u64 last = 0;
static u64 sum = 0;
static u64 tindex = 0;
static std::array<u64, 128> values;

static void renderTextOverlay(float lag, Shaders& shaders, InternGame& game) {
    glDisable(GL_DEPTH_TEST);
    shaders.text.use();

    Matrix m;
    shaders.text.setMatrix("proj", m.getValues());
    m.translate(-1.0f, 1.0f, 0.0f);
    m.scale(2.0f / width, -2.0f / height, 1.0f);
    shaders.text.setMatrix("view", m.getValues());
    game.model.clear();
    game.model.get().scale(2.0f, 2.0f, 2.0f);
    shaders.text.setMatrix("model", game.model.get().getValues());

    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glBlendEquation(GL_FUNC_ADD);
    char buffer[50];
    snprintf(buffer, 50, "FPS: %f %f %f", 128000000000.0f / sum, testRadius, testBias);
    game.fontRenderer.drawString(20, 20, buffer);
    game.game.renderTextOverlay(lag, game.model, shaders.text, game.fontRenderer);
    glDisable(GL_BLEND);
}

static void renderTick(float lag, Shaders& shaders, InternGame& game, Framebuffers& fb) {
    u64 current = getTimeNanos();
    sum -= values[tindex];
    values[tindex] = current - last;
    sum += values[tindex];
    last = current;
    tindex = (tindex + 1) & (127);

    if(resize) {
        fb.resize(width, height);
        resize = false;
    }
    shaders.updateWorldProjection();
    shaders.updateWorldView(lag, game.cam);

    renderShadow(lag, shaders, game, fb);
    renderWorld(lag, shaders, game, fb);
    if(useSSAO) {
        renderSSAO(shaders, game, fb);
    }
    renderPostWorld(shaders, game, fb);
    renderTextOverlay(lag, shaders, game);
}

static void loop() {
    Shaders shaders;
    if(!shaders.isValid()) {
        return;
    }
    Framebuffers fb(width, height);
    if(!fb.isValid()) {
        return;
    }
    InternGame game;

    last = getTimeNanos();
    u64 lastTime = getTimeNanos();
    u64 lag = 0;
    while(!glfwWindowShouldClose(client.window)) {
        renderTick(lag * lagFactor, shaders, game, fb);
        glfwSwapBuffers(client.window);

        u64 newTime = getTimeNanos();
        lag += newTime - lastTime;
        lastTime = newTime;

        while(lag >= NANOS_PER_TICK) {
            lag -= NANOS_PER_TICK;
            tick(game);
        }
        glfwPollEvents();
    }
}

void GameClient::start(int w, int h, const char* windowName) {
    if(initGLFW() || initWindow(w, h, windowName) || initGLEW()) {
        return;
    }
    initCallbacks();
    glfwShowWindow(client.window);
    loop();
}