CX/src/cx.c

#include <cx.h>

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

    glfwWindowHint(GLFW_SAMPLES, 4);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // To make MacOS happy; should not be needed
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

    // 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("../3d_assets/cube.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 *translation_matrix = matrix_new();


    // Temporary storage of transformation results
    GLfloat *temp_buffer[2];

    translation_matrix[3] = 0.5f;


    int t = 0;

    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);


        rotation_matrix[0] = cos(M_PI*2/256*(t%256));
        rotation_matrix[8] = -sin(M_PI*2/256*(t%256));
        rotation_matrix[2] = sin(M_PI*2/256*(t%256));
        rotation_matrix[10] = cos(M_PI*2/256*(t%256));


        // BANANA, ROH-TAH-TEH
        temp_buffer[0] = matrix_transform(model->object, model->bufsize, rotation_matrix);
        temp_buffer[1] = matrix_transform(temp_buffer[0], model->bufsize, translation_matrix);

        // Guess I'm just projecting.
        free(temp_buffer[0]);

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

        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();

        temp_buffer[0] = matrix_transform(model->object, model->bufsize, translation_matrix);

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

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

    return 0;
}


int cx_nninit(Neural_Network **nn) {
    // Allocate a Neural Network
    *nn = neural_new(64, 1);
    if(!*nn) {
        fprintf(stderr, "Failed to initialize Neural Network.\n");
        return -1;
    }

    // Populate the neural network with sensible values.
    neural_randomize(*nn);

    return 0;
}

int cx_nnrun(Neural_Network *nn) {

    // Establish a neural interface.
    float *input_buffer = malloc(64*sizeof(float));
    float *output_buffer;

    output_buffer = neural_process(nn, input_buffer);
    return 0;
}