Allegro5 Shader Test

// -----------------------------------------------------------------------
// --- Includes ---
// -----------------------------------------------------------------------

#include <iostream>
#include <allegro5/allegro.h>
#include <allegro5/allegro_image.h>
#include <allegro5/allegro_primitives.h>
#include <allegro5/allegro_opengl.h>

// -----------------------------------------------------------------------
// --- Global variables ---
// -----------------------------------------------------------------------

ALLEGRO_KEYBOARD_STATE keyState;
ALLEGRO_MOUSE_STATE mouseState;
ALLEGRO_DISPLAY * windowDisplay(NULL);
ALLEGRO_BITMAP * windowBuffer(NULL);

ALLEGRO_EVENT_QUEUE * eventQueue(NULL);
ALLEGRO_TIMER * framerateTimer(NULL);
int framerate(0);

// User data
ALLEGRO_SHADER * myShader(NULL);
const char * myShaderVertFileName("myShaderVert.glsl");
const char * myShaderFragFileName("myShaderFrag.glsl");

ALLEGRO_BITMAP * myImage(NULL);
const char * myImageFileName("bg0.png");
// Window setting
int screenW(640);
int screenH(360);
int zoom(2);
// Absolute mouse position
int mouseXi(0);
int mouseYi(0);
// Relative mouse position
float mouseXf(0);
float mouseYf(0);
// Window  position in the desktop
int xWindow(0);
int yWindow(0);

// -----------------------------------------------------------------------
// --- Global Methods ---
// -----------------------------------------------------------------------

template <class M>
int log (int error, M msg)
{
    std::cout << msg;

    return error;
}

void setFramerate(int fps)
{
    eventQueue = al_create_event_queue();
    framerate = fps;
    framerateTimer = al_create_timer(1.000/framerate);

    al_register_event_source (eventQueue,al_get_timer_event_source(framerateTimer));
    al_start_timer(framerateTimer);
}

void drawGrid(int screenW, int screenH,
              int sizeX, int sizeY,
              ALLEGRO_COLOR color)
{
    for (int i(0); i<(screenW/sizeX); i++)
    {
        al_draw_line(i*sizeX+.5, .5, i*sizeX+.5, screenH+.5, color,0);
    }

    for (int i(0); i<(screenH/sizeY)+1; i++)
    {
        al_draw_line(.5, i*sizeY+.5, screenW+.5, i*sizeY+.5, color,0);
    }
}

ALLEGRO_SHADER* create_shader(const char* fileNameVert, const char* fileNameFrag )
{
    ALLEGRO_SHADER* shader = al_create_shader(ALLEGRO_SHADER_GLSL);
//    if(!al_attach_shader_source(shader,
//                                ALLEGRO_VERTEX_SHADER,
//                                al_get_default_shader_source(ALLEGRO_SHADER_GLSL, ALLEGRO_VERTEX_SHADER)))
    if(!al_attach_shader_source_file(shader, ALLEGRO_VERTEX_SHADER, fileNameVert))
    {
        printf("%s\n", al_get_shader_log(shader));
        return NULL;
    }
    if(!al_attach_shader_source_file(shader, ALLEGRO_PIXEL_SHADER, fileNameFrag))
    {
        printf("%s\n", al_get_shader_log(shader));
        return NULL;
    }
    if(!al_build_shader(shader))
    {
        printf("%s\n", al_get_shader_log(shader));
        return NULL;
    }
    std::cout << " >>> "<< al_get_shader_log(shader) << " \n";

    return shader;
}

// -----------------------------------------------------------------------
// ---- INIT ---
// -----------------------------------------------------------------------
int init()
{
// Init Allegro 5
    if (!al_init())
        return log(1,"Unable to Init ALLEGRO_5 ! \n");

// Init & Install : Modules & Addon
    if (!al_install_keyboard())
        return log(1,"Unable to Install Keyboard ! \n");

    if (!al_install_mouse())
        return log(1,"Unable to Intall Keyboard ! \n");

    if (!al_init_image_addon())
        return log(1,"Unable to Init Image addon ! \n");

    if (!al_init_primitives_addon())
        return log(1,"Unable to Init Primitives addon ! \n");

// Settings
    al_set_new_display_flags(ALLEGRO_WINDOWED);
    al_set_new_display_flags(ALLEGRO_OPENGL);
    //al_set_new_display_flags(ALLEGRO_PROGRAMMABLE_PIPELINE | ALLEGRO_OPENGL);

    setFramerate(60);

// Create All
    windowDisplay = al_create_display(screenW*zoom, screenH*zoom);
    if (!windowDisplay)
        return log(1,"Unable to Create display ! \n");

    windowBuffer = al_create_bitmap(screenW, screenH);
    if (!windowDisplay)
        return log(1,"Unable to Create Buffer ! \n");

    al_show_mouse_cursor(windowDisplay);

    myImage = al_load_bitmap(myImageFileName);


    myShader = create_shader(myShaderVertFileName,myShaderFragFileName);

    if(!myShader)
        return log(1," Error in create myShader !\n");

    return log(0,"--- init OK !\n");
}
// -----------------------------------------------------------------------
// --- DONE ---
// -----------------------------------------------------------------------
int done()
{
// Destroy All
    al_destroy_bitmap(myImage);
    al_destroy_event_queue(eventQueue);
    al_destroy_timer(framerateTimer);
    al_destroy_shader(myShader);
    al_destroy_bitmap(windowBuffer);
    al_destroy_display(windowDisplay);

    return log(0,"--- done OK !\n");
}
// -----------------------------------------------------------------------
// --- RUN ---
// -----------------------------------------------------------------------
int run()
{
    std::cout<<"al_opengl_version: "<< al_get_opengl_version() << "\n";

    int glVersion[] = { -1, -1};

    glGetIntegerv(GL_MAJOR_VERSION, &glVersion[0]);
    glGetIntegerv(GL_MINOR_VERSION, &glVersion[1]);

    std::cout<<"OpenGL Version: "<<glVersion[0]<<"."<<glVersion[1]<< "\n";

    bool quit(false);

    float centerX(0);
    float centerY(0);
    float radius(0);
    float maxRadius(0.8);
    float speed(0);

    bool useShader = false;

    while (!quit)
    {
    // --- Update ---

        ALLEGRO_EVENT event;
        al_wait_for_event(eventQueue, &event);

        // Keyboard Input !
        al_get_keyboard_state(&keyState);
        if (al_key_down(&keyState, ALLEGRO_KEY_ESCAPE))
            quit = true;

        // Mouse Input !
        al_get_mouse_state(&mouseState);
//        al_get_window_position (windowDisplay, &xWindow, &yWindow);
//        al_get_mouse_cursor_position(&mouseXi, &mouseYi);
//        mouseXf = (float(mouseXi-xWindow)-2)/zoom;
//        mouseYf = (float(mouseYi-yWindow)-24)/zoom;

        mouseXf = mouseState.x/zoom;
        mouseYf = mouseState.y/zoom;

        if (mouseState.buttons & 1)
        {
            centerX = mouseXf;
            centerY = mouseYf;
            radius = 0.0;
            speed = 0.01;
            useShader = true;
        }

        // ShockWave Update !
        radius += speed;

        if (radius > maxRadius)
        {
            speed = -0.01;
        }

        if (radius < 0)
        {
            radius = 0;
            speed = 0;
            useShader = false;
        }

    // --- Render ---

        // clear windowbuffer !
        al_set_target_bitmap(windowBuffer);
        al_clear_to_color(al_map_rgb(0,25,40));

        // Begin drawing !



        al_draw_bitmap(myImage, 0,0,0);





        drawGrid(screenW, screenH,32,32,al_map_rgba(0,45,80,50));
        al_draw_rectangle(0.5, 0.5,
                          screenW-.5, screenH-.5,
                          al_map_rgb(250,120,180),0);

        al_draw_line(0, mouseYf, screenW, mouseYf, al_map_rgba(210,100,155,50), 0);
        al_draw_line(mouseXf, 0, mouseXf, screenH, al_map_rgba(210,100,155,50), 0);

        //al_draw_circle(centerX, centerY, radius*400, al_map_rgba(250,200,210,25),0);


        /// End drawing !

        // Blit buffer to display !
        al_set_target_backbuffer(windowDisplay);
        al_clear_to_color(al_map_rgb(0,0,0));

        // Use shader here before blit buffer to display !!

        if (useShader) al_use_shader(myShader);
        al_set_shader_sampler("tex", windowBuffer, 0);

        float center[2] = {centerX, al_get_bitmap_height(myImage)-centerY};
        //float surface[2] = { al_get_bitmap_width(myImage), al_get_bitmap_height(myImage) };
        float surface[2] = { float(screenW), float(screenH) };
        //float center[2] = { mouseXf, mouseYf };
        //float resolution[2] = { 200, 200 };
        float shockParams[3] = {10.0, 0.8, 0.1};

        al_set_shader_float("time", radius);
        al_set_shader_float_vector("center", 2, &center[0], 1);
        al_set_shader_float_vector("surface", 2, &surface[0], 1);
        //al_set_shader_float_vector("resolution", 2, &resolution[0], 1);
        al_set_shader_float_vector("shockParams", 3, &shockParams[0], 1);


        al_draw_scaled_bitmap(windowBuffer,
                              0, 0, screenW, screenH,
                              0, 0, screenW*zoom, screenH*zoom,
                              0),

        al_use_shader(NULL);

        // Flip display !
        al_flip_display();


    }

    return log(0,"--- run OK !\n");
}
// -----------------------------------------------------------------------
// --- MAIN ---
// -----------------------------------------------------------------------
int main()
{
    if (init())
        return log(1, "Error in init() \n");
    if (run())
        return log(1, "Error in run() \n");
    if (done())
        return log(1, "Error in done() \n");

    return log(0,"--- Terminated normally ! \n");;
}