frag engine test

fraggame.cpp

#include <GL/glew.h>
#include <fragengine.hpp>
#include <window.hpp>
#include <math.h>
#include <resource.hpp>
#include <drawing.hpp>
#include <game.hpp>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

// States
class TestState : public frag::State {
public:
    TestState(frag::Game game) : State(game)
    {
        GLfloat vertices[] = {
            -1.0f,  1.0f, -0.2f, 0.1f, 0.05f, 0.0f,
             0.0f, -1.0f,  0.5f, 0.0f, 1.0f,  0.2f,
            -1.0f, -1.0f,  0.0f, 1.0f, 1.0f,  1.0f,
            -1.0f,  1.0f,  1.0f, 0.0f, 0.5f,  1.0f
        };

        GLfloat vertices2[] = {
            0.0f, 0.0f, 0.2f, 0.0f, 1.0f, 1.0f,
           -0.5f, 0.5f, 0.2f, 0.0f, 0.0f, 1.0f,
            0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.3f
        };

        GLuint order[] = {
            0, 1, 2,
            2, 3, 0
        };

        // Create and compile the vertex shader
        vert_shader =
            frag::create_shader_from_file(GL_VERTEX_SHADER, "vertshader.glsl");

        // Create and compile the fragment shader
        frag_shader =
            frag::create_shader_from_file(GL_FRAGMENT_SHADER, "fragshader.glsl");

        // Link the vertex and fragment shader into a shader program
        shader_program =
            frag::create_shader_program("outColor", 2, vert_shader,
                                        frag_shader);

        // Make shader program active
        glUseProgram(shader_program);

        // Define vertex attribute layout
        frag::VertexAttribute attrs[] = {
            {"position", GL_FLOAT, 3 * sizeof(GLfloat), 3},
            {"color",    GL_FLOAT, 3 * sizeof(GLfloat), 3}
        };

        // Create new VertexArray, upload vertex data and set layout
        rect = new frag::VertexArray(vertices, 24, shader_program, order, 6);
        rect->upload(GL_STATIC_DRAW);
        rect->set_layout(attrs, 2);

        tri = new frag::VertexArray(vertices2, 18, shader_program);
        tri->upload(GL_STATIC_DRAW);
        tri->set_layout(attrs, 2);

        // Create view matrix (set the camera to look at a point from a
        // location)
        view = glm::lookAt(
            glm::vec3(1.2f, 1.2f, 1.2f),
            glm::vec3(0.0f, 0.0f, 0.0f),
            glm::vec3(0.0f, 0.0f, 1.0f)
        );

        // Create projection matrix

        proj = glm::perspective(glm::radians(90.f),
                                (float)game.window->width / game.window->height,
                                1.f, 10.f);

        modelmat_ref = glGetUniformLocation(shader_program, "model");
        viewmat_ref = glGetUniformLocation(shader_program, "view");
        projmat_ref = glGetUniformLocation(shader_program, "proj");

        glUniformMatrix4fv(viewmat_ref, 1, GL_FALSE, glm::value_ptr(view));
        glUniformMatrix4fv(projmat_ref, 1, GL_FALSE, glm::value_ptr(proj));

    }

    ~TestState()
    {
        // Clean up
        glDeleteProgram(shader_program);
        glDeleteShader(vert_shader);
        glDeleteShader(frag_shader);

        tri->delete_data();
        rect->delete_data();
    }

    void render()
    {
        // Drawing

        // Preserve initial model matrix
        frag::push_matrix(model);

        // Apply transformation
        model = glm::rotate(glm::mat4(), SDL_GetTicks() / 360.f,
                            glm::vec3(0.f, 0.5f, 1.f));
        glUniformMatrix4fv(modelmat_ref, 1, GL_FALSE, glm::value_ptr(model));

        // Draw
        rect->bind();
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);


        // Apply new transformation
        model = glm::rotate(glm::mat4(), sinf(SDL_GetTicks() / 100.f),
                            glm::vec3(0.f, 1.f, 0.f));
        glUniformMatrix4fv(modelmat_ref, 1, GL_FALSE, glm::value_ptr(model));

        // Draw
        tri->bind();
        glDrawArrays(GL_TRIANGLES, 0, 3);

        // Pop back old matrix
        model = frag::pop_matrix();
    }

public:
    frag::VertexArray* rect;
    frag::VertexArray* tri;

    GLuint shader_program, vert_shader, frag_shader;
    GLint modelmat_ref = 0, viewmat_ref = 0, projmat_ref = 0;
    frag::Matrix model = glm::mat4(), view = glm::mat4(), proj = glm::mat4();
};

int main(int argc, char** argv)
{
    uint16_t width = 800, height = 600;
    uint8_t glmajor = 2, glminor = 1;

    for (size_t i = 1; i < argc; i++) {
        if (strcmp(argv[i], "-w") == 0) {
            if (argc - 1 < i + 1) {
                printf("No argument provided for option 'w'\n");
                exit(1);
            }
            width = atoi(argv[i + 1]);
            i++;
        } else if (strcmp(argv[i], "-h") == 0) {
            if (argc - 1 < i + 1) {
                printf("No argument provided for option 'h'\n");
                exit(1);
            }
            height = atoi(argv[i + 1]);
            i++;
        } else if (strcmp(argv[i], "-gl") == 0) {
            if (argc - 1 < i + 1) {
                printf("No argument provided for option 'gl'\n");
                exit(1);
            }
            char* dot = strstr(argv[i + 1], ".");
            glmajor = strtol(argv[i + 1], &dot, 10);
            glminor = strtol(strstr(argv[i + 1], ".") + 1, NULL, 10);
        }
    }

    // OpenGL version
    frag::GLVersion glversion = {glmajor, glminor};
    // Create a Window
    frag::Window window("Frag Engine Demo", width, height, glversion);
    // Create a new game instance
    frag::Game game(&window);

    frag::Package base(frag::BASE, "archive.tar.gz");
    base.delete_tar();

    TestState tstate(game);
    game.state = &tstate;

    while (game.cycle()) {}

    return 0;
}