Frag Engine Demo

fragshader.glsl

#version 150

in vec3 Color;

out vec4 outColor;

void main()
{
    outColor = vec4(Color, 1.0);
}

main.cpp

#include <GL/glew.h>
#include <fragengine.hpp>
#include <window.hpp>
#include <math.h>
#include <drawing.hpp>
#include <game.hpp>

// States
class TestState : public frag::State {
public:
    TestState(frag::Game game) : State(game)
    {
        GLfloat vertices[] = {
            -1.0f,  1.0f, 0.1f, 0.05f, 0.0f,
             0.0f, -1.0f, 0.0f, 0.0f, 0.2f,
            -1.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.0f, 1.0f, 1.0f,
           -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
            0.5f, 0.5f, 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(2, vert_shader, frag_shader);

        // Make shader program active
        glUseProgram(shader_program);

        // Define vertex attribute layout
        frag::VertexAttribute attrs[] = {
            {"position", GL_FLOAT, 2 * sizeof(GLfloat), 2},
            {"color",    GL_FLOAT, 2 * 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);

    }

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

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

    void render()
    {
        // Drawing
        rect->bind();
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
        tri->bind();
        glDrawArrays(GL_TRIANGLES, 0, 3);
    }

public:
    frag::VertexArray* rect;
    frag::VertexArray* tri;
    frag::VertexArray* random;
    GLuint shader_program, vert_shader, frag_shader;
};

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

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

    while (game.cycle()) {}

    return 0;
}

vertshader.glsl

#version 150

in vec2 position;
in vec3 color;

out vec3 Color;

void main()
{
    Color = color;
    gl_Position = vec4(position, 0.0, 1.0);
}