cube-game-plus-plus/engine/GameEngine.cpp

#include "GameEngine.h"
#include "MouseManager.h"
#include <cmath>

GameEngine* GameEngine::instance = nullptr;

void GameEngine::start(int width, int height, const char* name, InitFunction init, TickFunction tick, RenderTickFunction renderTick)
{    
    if(!glfwInit())
    {
        cout << "could not initialize GLFW" << endl;
        return;
    }

    glfwDefaultWindowHints();
    glfwWindowHint(GLFW_VISIBLE, 0);
    glfwWindowHint(GLFW_RESIZABLE, 1);
    GLFWwindow* window = glfwCreateWindow(width, height, name, nullptr, nullptr);
    if(!window)
    {
        cout << "could not create window" << endl;
        glfwTerminate();
        return;
    }

    glfwMakeContextCurrent(window);
    glfwSwapInterval(1);

    glfwShowWindow(window);

    GLenum err = glewInit();
    if(GLEW_OK != err)
    {
        cout << "could not initialize GLEW: " << glewGetErrorString(err) << endl;
        return;
    }
    cout << "Status: Using GLEW " << glewGetString(GLEW_VERSION) << endl;

    GLuint vShader = 0;
    GLuint fShader = 0;
    GLuint program = createProgram(vShader, program);
    if(program == 0)
    {
        if(vShader != 0)
        {
            glDeleteShader(vShader);
        }
        if(fShader != 0)
        {
            glDeleteShader(fShader);
        }
        glfwDestroyWindow(window);
        glfwTerminate();
        return;
    }
    
    GameEngine::instance = new GameEngine(program, vShader, fShader, window, width, height, tick, renderTick);
    glfwSetKeyCallback(window, [](GLFWwindow* w, int key, int scancode, int action, int mods) 
    {
        GameEngine::instance->onKeyEvent(w, key, scancode, action, mods);
    });
    glfwSetMouseButtonCallback(window, [](GLFWwindow* w, int button, int action, int mods)
    {
        GameEngine::instance->onMouseClick(w, button, action, mods);
    });
    glfwSetFramebufferSizeCallback(window, [](GLFWwindow* w, int width, int height)
    {
        GameEngine::instance->onWindowResize(w, width, height);
    }); 
    //glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
    //glfwSetCursorPosCallback(window, onMouseMove);
    
    init();
    instance->run();
    delete instance;
}

void GameEngine::stop()
{
    if(GameEngine::instance != nullptr)
    {
        glfwSetWindowShouldClose(GameEngine::instance->window, 1);
    }
}

void GameEngine::run()
{    
    glEnable(GL_CULL_FACE);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    
    uint64_t newTime = glfwGetTimerValue();
    uint64_t oldTime = newTime;
    uint64_t lag = 0;
    while(!glfwWindowShouldClose(window))
    {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        oldTime = newTime;
        newTime = glfwGetTimerValue();
        lag += newTime - oldTime;

        int ticksPerFrame = 0;
        while(lag >= NANOS_PER_TICK)
        {
            lag -= NANOS_PER_TICK;

            tps.update();
            tick();
            keyManager.tick();
            mouseManager.tick();
            ticksPerFrame++;

            if(ticksPerFrame >= MAX_TICKS_PER_FRAME)
            {
                long skip = lag / NANOS_PER_TICK;
                lag -= skip * NANOS_PER_TICK;
                if(skip > 0)
                {
                    cout << "skipped " << skip << " game ticks " << lag << endl;
                }
                break;
            }
        }

        fps.update();
        renderTick((float) lag / NANOS_PER_TICK);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    
    glDeleteShader(vShader);
    glDeleteShader(fShader);
    glDeleteProgram(program);
    glfwDestroyWindow(window);
    glfwTerminate();
}

GLuint GameEngine::setInstance(GLuint program, GameEngine* en)
{
    GameEngine::instance = en;
    return program;
}

GameEngine::GameEngine(GLuint program, GLuint vShader, GLuint fShader, GLFWwindow* window, 
        int width, int height, TickFunction tick, RenderTickFunction renderTick) :
    program(setInstance(program, this)), vShader(vShader), fShader(fShader), window(window), width(width), height(height), tick(tick), renderTick(renderTick)
{
    updateScale();
}

GameEngine::~GameEngine()
{
}

void GameEngine::onKeyEvent(GLFWwindow* w, int key, int scancode, int action, int mods)
{
    if(action == GLFW_RELEASE)
    {
        if(key == GLFW_KEY_ESCAPE)
        {
            //activeFocus = 0;
            glfwSetInputMode(w, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
        }
        keyManager.release(key);
    }
    else if(action == GLFW_PRESS)
    {
        keyManager.press(key);
    }
}

void GameEngine::onMouseClick(GLFWwindow* w, int button, int action, int mods)
{
    if(action == GLFW_PRESS)
    {
        /*if(!activeFocus)
        {
            glfwSetInputMode(w, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
            oldMouseX = 0;
            oldMouseY = 0;
            activeFocus = 1;
        }
        else
        {*/
            mouseManager.press(button);
        //}
    }
    else if(action == GLFW_RELEASE)
    {
        mouseManager.release(button);
    }
}

/*void GameEngine::onMouseMove(GLFWwindow* w, double x, double y)
{
    if(activeFocus)
    {
        if(oldMouseX == 0 && oldMouseY == 0)
        {
            oldMouseX = x;
            oldMouseY = y;
        }
        else
        {
            mouseMove(x - oldMouseX, y - oldMouseY);
            oldMouseX = x;
            oldMouseY = y;
        }
    }
}*/

void GameEngine::onWindowResize(GLFWwindow* w, int width, int height)
{
    glViewport(0, 0, width, height);
    GameEngine::width = width;
    GameEngine::height = height;
    updateScale();
}

GLchar* GameEngine::readFile(const char* name)
{
    ifstream in;
    in.open(name);
    if(!in.fail())
    {
        int size = 128;
        int index = 0;
        GLchar* content = new GLchar[size];
        
        while(true)
        {
            GLchar c = in.get();
            if(in.eof())
            {
                break;
            }
            if(index >= size - 1)
            {
                GLchar* newContent = new GLchar[size * 2];
                memcpy(newContent, content, size);
                size *= 2;
                delete[] content;
                content = newContent;
            }
            content[index] = c;
            index++;
        }
        
        content[index] = '\0';
        index++;
        
        in.close();
        return content;
    }
    return nullptr;
}

bool GameEngine::checkShaderErrors(const char* name, GLuint shader)
{
    bool returnValue = false;
    
    cout << "compiling " << name << " shader ..." << endl;
    GLenum error = glGetError();
    if(error)
    {
        cout << "error: " << glGetError() << endl;
        returnValue = true;
    }
    else
    {
        cout << "no error occured ..." << endl;
    }
    
    GLint compiled[1];
    glGetShaderiv(shader, GL_COMPILE_STATUS, compiled);
    if(compiled[0])
    {
        cout << name << " shader successfully compiled" << endl;
    }
    else
    {
        cout << name << "compiling of " << name << " failed:" << endl;
        GLchar buffer[512];
        GLsizei bufferSize = 512;
        GLsizei charsUsed = 0;
        glGetShaderInfoLog(shader, bufferSize, &charsUsed, buffer);
        // glGetProgramInfoLog should be null terminated ...
        buffer[bufferSize - 1] = '\0';
        cout << buffer << endl;
        returnValue = true;
    }
    return returnValue;
}

GLuint GameEngine::compileProgram(GLuint& vShader, GLuint& fShader, const GLchar* vertex, const GLchar* fragment)
{
    vShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vShader, 1, &vertex, nullptr);
    glCompileShader(vShader);

    if(checkShaderErrors("vertex", vShader))
    {
        return 0;
    }    
    
    fShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fShader, 1, &fragment, nullptr);
    glCompileShader(fShader);

    if(checkShaderErrors("fragment", fShader))
    {
        return 0;
    }    

    GLuint program = glCreateProgram();
    glAttachShader(program, vShader);
    glAttachShader(program, fShader);
    glLinkProgram(program);
    
    cout << "linking shaders to program ..." << endl;

    GLenum error = glGetError();
    if(error)
    {
        cout << "error: " << glGetError() << endl;
        return 0;
    }
    else
    {
        cout << "no error occured ..." << endl;
    }

    GLint compiled[1];
    glGetProgramiv(program, GL_LINK_STATUS, compiled);
    if(compiled[0])
    {
        cout << "shaders successfully linked" << endl;
    }
    else
    {
        cout << "linking of shaders failed:" << endl;
        GLchar buffer[512];
        GLsizei bufferSize = 512;
        GLsizei charsUsed = 0;
        glGetProgramInfoLog(program, bufferSize, &charsUsed, buffer);
        // glGetProgramInfoLog should be null terminated ...
        buffer[bufferSize - 1] = '\0';
        cout << buffer << endl;
        return 0;
    }
    
    glUseProgram(program);
    return program;
}

GLuint GameEngine::createProgram(GLuint& vShader, GLuint& fShader)
{
    GLchar* vertex = readFile("shader/vertex.vs");
    if(vertex == nullptr)
    {
        cout << "cannot read vertex.vs" << endl;
        return 0;
    }
    GLchar* fragment = readFile("shader/fragment.fs");
    if(fragment == nullptr)
    {
        cout << "cannot read fragment.fs" << endl;
        delete[] vertex;
        return 0;
    }
    
    GLuint program = compileProgram(vShader, fShader, vertex, fragment);
    delete[] vertex;
    delete[] fragment;
    return program;
}

void GameEngine::printError()
{
    GLenum error = glGetError();
    switch(error)
    {
        case GL_NO_ERROR: 
            cout << "> No error has been recorded." << endl;
            break;
        case GL_INVALID_ENUM: 
            cout << "> An unacceptable value is specified for an enumerated argument." << endl;
            break;
        case GL_INVALID_VALUE: 
            cout << "> A numeric argument is out of range." << endl;
            break;
        case GL_INVALID_OPERATION: 
            cout << "> The specified operation is not allowed in the current state." << endl;
            break;
        case GL_INVALID_FRAMEBUFFER_OPERATION: 
            cout << "> The framebuffer object is not complete." << endl;
            break;
        case GL_OUT_OF_MEMORY: 
            cout << "> There is not enough memory left to execute the command." << endl;
            break;
        case GL_STACK_UNDERFLOW: 
            cout << "> An attempt has been made to perform an operation that would cause an internal stack to underflow." << endl;
            break;
        case GL_STACK_OVERFLOW: 
            cout << "> An attempt has been made to perform an operation that would cause an internal stack to overflow." << endl;
            break;
        default:
            cout << "> Unknown OpenGL error: " << error << endl;
    }
}

void GameEngine::updateScale()
{
    scale = 1;
    while(width / (scale + 1) >= 400 && height / (scale + 1) >= 300)
    {
        scale++;
    }
}

GameEngine* GameEngine::get()
{
    return instance;
}

KeyManager& GameEngine::getKeyManager()
{
    return keyManager;
}

MouseManager& GameEngine::getMouseManager()
{
    return mouseManager;
}

Shader& GameEngine::getShader()
{
    return shader;
}

DirectRenderer& GameEngine::getDirectRenderer()
{
    return directRenderer;
}

double GameEngine::getTicksPerSecond() const
{
    return tps.getUpdatesPerSecond();
}

double GameEngine::getFramesPerSecond() const
{
    return fps.getUpdatesPerSecond();
}

int GameEngine::getScale() const
{
    return scale;
}

int GameEngine::getWidth() const
{
    return width;
}

int GameEngine::getHeight() const
{
    return height;
}

GLint GameEngine::getUniformLocation(const GLchar* name) const
{
    return glGetUniformLocation(program, name);
}

void GameEngine::setMatrix(GLint location, const GLfloat* m)
{
    glUniformMatrix4fv(location, 1, 0, m);
}

void GameEngine::setInt(GLint location, GLint i)
{
    glUniform1i(location, i);
}

void GameEngine::setFloat(GLint location, GLfloat f1, GLfloat f2, GLfloat f3, GLfloat f4)
{
    glUniform4f(location, f1, f2, f3, f4);
}