CX/src/cx.c

#include <cx.h>

int cx_glinit(GLFWwindow **window) {
    // Initialise GLFW
    if(!glfwInit()) {
        fprintf(stderr, "Failed to initialize GLFW\n");
        getchar();
        return -1;
    }

    glfwWindowHint(GLFW_SAMPLES, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // To make MacOS happy; should not be needed
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // Open a window and create its OpenGL context
    *window = glfwCreateWindow(1280, 720, "CONTROL-X", NULL, NULL);
    if (*window == NULL) {
        fprintf(stderr, "Failed to open GLFW window.\n");
        glfwTerminate();
        return -1;
    }

    glfwMakeContextCurrent(*window);

    // Initialize GLEW
    if (glewInit() != GLEW_OK) {
        fprintf(stderr, "Failed to initialize GLEW\n");
        glfwTerminate();
        return -1;
    }

    // Ensure we can capture the escape key being pressed below
    glfwSetInputMode(*window, GLFW_STICKY_KEYS, GL_TRUE);

    // Dark grey background
    glClearColor(0.15f, 0.15f, 0.15f, 0.0f);

    return 0;
}

int cx_glrun(GLFWwindow *window) {
    GLuint VertexArrayID;
    GLuint programID;

    glGenVertexArrays(1, &VertexArrayID);
    glBindVertexArray(VertexArrayID);

    // Create and compile our GLSL program from the shaders
    if (LoadShaders(&programID,
                    "../shaders/SimpleVertexShader.vertexshader",
                    "../shaders/SimpleFragmentShader.fragmentshader")) {
        fprintf(stderr, "Could not load shaders.\n");
        return -1;
    }


    // Load model to render from file
    Model *model;
    model = model_load("../triangle.obj");

    // Allocate the render buffer
    // GL uses this to feed the GPU
    GLfloat *render_buffer;
    render_buffer = malloc(model->bufsize * 4 * sizeof(GLfloat));
    memcpy(render_buffer, model->object, model->bufsize * 4 * sizeof(GLfloat));

    // Bind the render buffer to OpenGL
    GLuint vertexbuffer;
    glGenBuffers(1, &vertexbuffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
    glBufferData(GL_ARRAY_BUFFER, model->bufsize*4*sizeof(GLfloat), render_buffer, GL_STATIC_DRAW);

    // 1rst attribute buffer : vertices
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
    glVertexAttribPointer(
        0,                  // attribute 0 in the pipeline
        4,                  // size
        GL_FLOAT,           // type
        GL_FALSE,           // normalized?
        0,                  // stride
        NULL                // array buffer offset
    );

    // Remainder from cursor experiments, might be useful later
    double xpos, ypos;
    glfwGetCursorPos(window, &xpos, &ypos);

    GLfloat *rotation_matrix = matrix_new();
    GLfloat *projection_matrix = matrix_new();

    // Temporary storage of transformation results
    GLfloat *temp_buffer;
    GLfloat *projected_buffer;

    projection_matrix[14] = -1.0f;
    projection_matrix[0] = (GLfloat)9/16; // Widescreen FOV


    do {
        // Clear the screen. It's not mentioned before Tutorial 02,
        // but it can cause flickering, so it's there nonetheless.
        glClear(GL_COLOR_BUFFER_BIT);

        // Use our shader
        glUseProgram(programID);
        time_t t = time(NULL);


        rotation_matrix[0] = cos(M_PI*2/60*(t%60));
        rotation_matrix[4] = -sin(M_PI*2/60*(t%60));
        rotation_matrix[1] = sin(M_PI*2/60*(t%60));
        rotation_matrix[5] = cos(M_PI*2/60*(t%60));


        // BANANA, ROH-TAH-TEH
        temp_buffer = matrix_transform(model->object, model->bufsize, rotation_matrix);

        // Guess I'm just projecting.
        projected_buffer = matrix_transform(temp_buffer, model->bufsize, projection_matrix);

        memcpy(render_buffer, projected_buffer, model->bufsize * 4 * sizeof(GLfloat));
        free(temp_buffer);
        free(projected_buffer);

        glBufferData(GL_ARRAY_BUFFER, model->bufsize*4*sizeof(GLfloat), render_buffer, GL_STATIC_DRAW);

        // 1rst attribute buffer : vertices
        glEnableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
        glVertexAttribPointer(
            0,                  // attribute 0 in the pipeline
            4,                  // size
            GL_FLOAT,           // type
            GL_FALSE,           // normalized?
            0,                  // stride
            NULL                // array buffer offset
        );


        // Draw!
        glDrawArrays(GL_TRIANGLES, 0, model->bufsize); // 3 indices starting at 0 -> 1 triangle

        glDisableVertexAttribArray(0);

        // Swap buffers
        glfwSwapBuffers(window);
        glfwPollEvents();

        // Check if the ESC key was pressed or the window was closed
        usleep(1000000/60);
    } while(glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS &&
           !glfwWindowShouldClose(window));

    // Close OpenGL window and terminate GLFW
    glfwTerminate();
    free(rotation_matrix);
    free(projection_matrix);
    model_free(model);
    free(render_buffer);

    return 0;
}