inverting-game/GameEngine.c

#include "GameEngine.h"
#include "Control.h"
 
static GLuint program;
static GLuint vShader;
static GLuint fShader;
static WindowResize windowResize;
static MouseMove mouseMove;
static int activeFocus = 0;

static double oldMouseX = 0;
static double oldMouseY = 0;

static void flushOutput()
{
    fflush(stdout);
}

static void 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);
        }
        keyRelease(key);
    }
    if(action == GLFW_PRESS)
    {
        keyPress(key);
    }
}

static void 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
        {
            mousePress(button);
        }
    }
    else if(action == GLFW_RELEASE)
    {
        mouseRelease(button);
    }
}

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

static void onWindowResize(GLFWwindow* w, int width, int height)
{
    glViewport(0, 0, width, height);
    windowResize(width, height);
}

static GLchar* readFile(char* name)
{
    FILE* file = fopen(name, "r");
    if(file != NULL)
    {
        int size = 128;
        int index = 0;
        GLchar* content = malloc(sizeof(GLchar) * size);
        
        while(1)
        {
            int c = fgetc(file);
            if(c == EOF)
            {
                break;
            }
            if(index >= size)
            {
                size *= 2;
                content = realloc(content, size);
            }
            content[index] = c;
            index++;
        }
        
        if(index >= size)
        {
            size++;
            content = realloc(content, size);
        }
        content[index] = '\0';
        index++;
        
        fclose(file);
        return content;
    }
    return NULL;
}

int checkShaderErrors(char* name, GLuint shader)
{
    int returnValue = 0;
    
    printf("compiling %s shader ...\n", name);
    GLenum error = glGetError();
    if(error)
    {
        fprintf(stderr, "error: %u\n", glGetError());
        returnValue = 1;
    }
    else
    {
        printf("no error occured ...\n");
    }
    
    GLint compiled[1];
    glGetShaderiv(shader, GL_COMPILE_STATUS, compiled);
    if(compiled[0])
    {
        printf("%s shader successfully compiled\n", name);
    }
    else
    {
        fprintf(stderr, "compiling of %s shader failed:\n", name);
        GLchar buffer[512];
        GLsizei bufferSize = 512;
        GLsizei charsUsed = 0;
        glGetShaderInfoLog(shader, bufferSize, &charsUsed, buffer);
        buffer[bufferSize - 1] = '\0';
        fprintf(stderr, "%s\n", buffer);
        returnValue = 1;
    }
    return returnValue;
}

static GLuint compileProgram(const GLchar* vertex, const GLchar* fragment)
{
    vShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vShader, 1, &vertex, NULL);
    glCompileShader(vShader);

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

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

    GLuint program = glCreateProgram();
    glAttachShader(program, vShader);
    glAttachShader(program, fShader);
    glLinkProgram(program);
    
    printf("linking shaders to program ...\n");
    GLenum error = glGetError();
    if(error)
    {
        fprintf(stderr, "error: %u\n", glGetError());
        return 0;
    }
    else
    {
        printf("no error occured ...\n");
    }

    GLint compiled[1];
    glGetProgramiv(program, GL_LINK_STATUS, compiled);
    if(compiled[0])
    {
        printf("shaders successfully linked\n");
    }
    else
    {
        fprintf(stderr, "linking of shaders failed:\n");
        GLchar buffer[512];
        GLsizei bufferSize = 512;
        GLsizei charsUsed = 0;
        glGetProgramInfoLog(program, bufferSize, &charsUsed, buffer);
        buffer[bufferSize - 1] = '\0';
        fprintf(stderr, "%s\n", buffer);
        return 0;
    }
    
    glUseProgram(program);
    return program;
}

static GLuint createProgram()
{
    GLchar* vertex = readFile("vertex.vs");
    if(vertex == NULL)
    {
        fprintf(stderr, "cannot read vertex.vs\n");
        return 0;
    }
    GLchar* fragment = readFile("fragment.fs");
    if(fragment == NULL)
    {
        fprintf(stderr, "cannot read fragment.fs\n");
        free(vertex);
        return 0;
    }
    
    GLuint program = compileProgram(vertex, fragment);
    flushOutput();
    free(vertex);
    free(fragment);
    return program;
}

static void onTerm(GLFWwindow* window)
{
    glfwDestroyWindow(window);
    glfwTerminate();
}

int startGame(char* name, InitFunction init, TickFunction tick, RenderTickFunction renderTick, WindowResize inWindowResize, MouseMove move)
{
    if(!glfwInit())
    {
        fprintf(stderr, "could not initialize GLFW");
        return 1;
    }   
    
    windowResize = inWindowResize;
    mouseMove = move;

    glfwDefaultWindowHints();
    glfwWindowHint(GLFW_VISIBLE, 0);
    glfwWindowHint(GLFW_RESIZABLE, 1);
    GLFWwindow* window = glfwCreateWindow(640, 480, name, NULL, NULL);
    if(!window)
    {
        fprintf(stderr, "could not create window");
        glfwTerminate();
        return 1;
    }
    
    glfwSetKeyCallback(window, onKeyEvent);
    glfwSetFramebufferSizeCallback(window, onWindowResize);
    glfwSetMouseButtonCallback(window, onMouseClick);
    glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
    activeFocus = 1;
    glfwSetCursorPosCallback(window, onMouseMove);

    glfwMakeContextCurrent(window);
    glfwSwapInterval(1);
    
    glfwShowWindow(window);
    
    GLenum err = glewInit();
    if (GLEW_OK != err)
    {
        fprintf(stderr, "Could not initialize GLEW: %s\n", glewGetErrorString(err));
        return 1;
    }
    printf("Status: Using GLEW %s\n", glewGetString(GLEW_VERSION));

    program = createProgram();
    if(program == 0)
    {
        onTerm(window);
        return 1;
    }
    
    //glEnable(GL_CULL_FACE);
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LEQUAL);
    init(program);
    
    //printf("%lu\n", glfwGetTimerFrequency());
    //printf("%lu\n", glfwGetTimerValue());
    //printf("%lu\n", glfwGetTimerValue());
    
    long newTime = glfwGetTimerValue();
    long oldTime = newTime;
    long 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;

            controlTick();
            tick(program);
            ticksPerFrame++;
            
            if(ticksPerFrame >= MAX_TICKS_PER_FRAME)
            {
                long skip = lag / NANOS_PER_TICK;
                lag -= skip * NANOS_PER_TICK;
                if(skip > 0)
                {
                    printf("skipped %ld game ticks %ld\n", skip, lag);
                }
                break;
            }
        }

        renderTick(program, (float) lag / NANOS_PER_TICK);
        
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glDeleteShader(vShader);
    glDeleteShader(fShader);
    glDeleteProgram(program);
    onTerm(window);
    return 0;
}

GLuint getProgram()
{
    return program;
}