bool Renderer::loadAllegroShaders()
{
ALLEGRO_SHADER *prg = al_create_shader(ALLEGRO_SHADER_GLSL);
const char *vs = al_get_default_shader_source(ALLEGRO_SHADER_GLSL, ALLEGRO_VERTEX_SHADER);
const char *ps = al_get_default_shader_source(ALLEGRO_SHADER_GLSL, ALLEGRO_PIXEL_SHADER);
if(!prg)
goto load_fail;
if(!vs)
goto load_fail;
if(!ps)
goto load_fail;
if(!al_attach_shader_source(prg, ALLEGRO_VERTEX_SHADER, vs))
{
NBT_Debug("failed to attach vertex shader:\n %s", al_get_shader_log(prg));
goto load_fail;
}
if(!al_attach_shader_source(prg, ALLEGRO_PIXEL_SHADER, ps))
{
NBT_Debug("failed to attach pixel shader:\n %s", al_get_shader_log(prg));
goto load_fail;
}
if(!al_build_shader(prg))
{
NBT_Debug("failed to build shader:\n %s", al_get_shader_log(prg));
goto load_fail;
}
al_prg_ = prg;
return true;
load_fail:
if(prg)
al_destroy_shader(prg);
al_prg_ = nullptr;
return false;
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *bitmap[2];
ALLEGRO_TIMER *timer;
ALLEGRO_EVENT_QUEUE *queue;
bool redraw = true;
ALLEGRO_SHADER *shader;
int t = 0;
const char* pixel_file = NULL;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_install_mouse();
al_install_keyboard();
al_init_image_addon();
init_platform_specific();
al_set_new_bitmap_flags(ALLEGRO_MIN_LINEAR | ALLEGRO_MAG_LINEAR |
ALLEGRO_MIPMAP);
al_set_new_display_option(ALLEGRO_SAMPLE_BUFFERS, 1, ALLEGRO_SUGGEST);
al_set_new_display_option(ALLEGRO_SAMPLES, 4, ALLEGRO_SUGGEST);
al_set_new_display_flags(ALLEGRO_PROGRAMMABLE_PIPELINE);
display = al_create_display(640, 480);
if (!display) {
abort_example("Error creating display\n");
}
bitmap[0]= load_bitmap("data/mysha.pcx");
bitmap[1]= load_bitmap("data/obp.jpg");
shader = al_create_shader(ALLEGRO_SHADER_AUTO);
if (!shader)
abort_example("Error creating shader.\n");
if (al_get_shader_platform(shader) == ALLEGRO_SHADER_GLSL) {
#ifdef ALLEGRO_CFG_SHADER_GLSL
pixel_file = "data/ex_shader_multitex_pixel.glsl";
#endif
}
else {
#ifdef ALLEGRO_CFG_SHADER_HLSL
pixel_file = "data/ex_shader_multitex_pixel.hlsl";
#endif
}
if (!pixel_file) {
abort_example("No shader source\n");
}
if (!al_attach_shader_source(shader, ALLEGRO_VERTEX_SHADER,
al_get_default_shader_source(ALLEGRO_SHADER_AUTO, ALLEGRO_VERTEX_SHADER))) {
abort_example("al_attach_shader_source for vertex shader failed: %s\n", al_get_shader_log(shader));
}
if (!al_attach_shader_source_file(shader, ALLEGRO_PIXEL_SHADER, pixel_file))
abort_example("al_attach_shader_source_file for pixel shader failed: %s\n", al_get_shader_log(shader));
if (!al_build_shader(shader))
abort_example("al_build_shader failed: %s\n", al_get_shader_log(shader));
al_use_shader(shader);
timer = al_create_timer(1.0 / 60);
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
al_register_event_source(queue, al_get_timer_event_source(timer));
al_start_timer(timer);
while (1) {
ALLEGRO_EVENT event;
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
break;
if (event.type == ALLEGRO_EVENT_KEY_CHAR) {
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
break;
}
if (event.type == ALLEGRO_EVENT_TIMER) {
redraw = true;
t++;
}
if (redraw && al_is_event_queue_empty(queue)) {
int dw, dh;
double scale = 1 + 100 * (1 + sin(t * ALLEGRO_PI * 2 / 60 / 10));
double angle = ALLEGRO_PI * 2 * t / 60 / 15;
double x = 120 - 20 * cos(ALLEGRO_PI * 2 * t / 60 / 25);
double y = 120 - 20 * sin(ALLEGRO_PI * 2 * t / 60 / 25);
dw = al_get_display_width(display);
dh = al_get_display_height(display);
redraw = false;
al_clear_to_color(al_map_rgb_f(0, 0, 0));
/* We set a second bitmap for texture unit 1. Unit 0 will have
* the normal texture which al_draw_*_bitmap will set up for us.
* We then draw the bitmap like normal, except it will use the
* custom shader.
*/
al_set_shader_sampler("tex2", bitmap[1], 1);
al_draw_scaled_rotated_bitmap(bitmap[0], x, y, dw / 2, dh / 2,
scale, scale, angle, 0);
al_flip_display();
}
}
al_use_shader(NULL);
al_destroy_bitmap(bitmap[0]);
al_destroy_bitmap(bitmap[1]);
al_destroy_shader(shader);
return 0;
}
int main(int argc, char **argv)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *bmp, *tmp;
ALLEGRO_SHADER *horz_shader;
ALLEGRO_SHADER *vert_shader;
al_init();
al_install_keyboard();
al_init_image_addon();
display = al_create_display(480, 320);
bmp = al_load_bitmap("glow.png");
ALLEGRO_BITMAP *bg = al_load_bitmap("bg.png");
tmp = al_create_bitmap(
al_get_bitmap_width(bmp),
al_get_bitmap_height(bmp)
);
horz_shader = al_create_shader(ALLEGRO_SHADER_GLSL);
vert_shader = al_create_shader(ALLEGRO_SHADER_GLSL);
al_attach_shader_source(
horz_shader,
ALLEGRO_VERTEX_SHADER,
glsl_vertex_source
);
al_attach_shader_source(
horz_shader,
ALLEGRO_PIXEL_SHADER,
glsl_pixel_source_horz
);
al_link_shader(horz_shader);
al_attach_shader_source(
vert_shader,
ALLEGRO_VERTEX_SHADER,
glsl_vertex_source
);
al_attach_shader_source(
vert_shader,
ALLEGRO_PIXEL_SHADER,
glsl_pixel_source_vert
);
al_link_shader(vert_shader);
ALLEGRO_COLOR white = al_map_rgb(255, 255, 255);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA, white);
ALLEGRO_VERTEX *v;
v = new ALLEGRO_VERTEX[6*4];
v[0].x = 0;
v[0].y = 320;
v[0].z = 0;
v[0].u = 0;
v[0].v = 0;
v[0].color = white;
v[1].x = 0;
v[1].y = 0;
v[1].z = 0;
v[1].u = 0;
v[1].v = 1;
v[1].color = white;
v[2].x = 480;
v[2].y = 0;
v[2].z = 0;
v[2].u = 1;
v[2].v = 1;
v[2].color = white;
v[3].x = 0;
v[3].y = 320;
v[3].z = 0;
v[3].u = 0;
v[3].v = 0;
v[3].color = white;
v[4].x = 480;
v[4].y = 0;
v[4].z = 0;
v[4].u = 1;
v[4].v = 1;
v[4].color = white;
v[5].x = 480;
v[5].y = 320;
v[5].z = 0;
v[5].u = 1;
v[5].v = 0;
v[5].color = white;
al_set_shader_vertex_array(horz_shader, &v[0].x, sizeof(ALLEGRO_VERTEX));
al_set_shader_color_array(horz_shader, (unsigned char *)&v[0].color, sizeof(ALLEGRO_VERTEX));
al_set_shader_texcoord_array(horz_shader, &v[0].u, sizeof(ALLEGRO_VERTEX));
al_set_shader_vertex_array(vert_shader, &v[0].x, sizeof(ALLEGRO_VERTEX));
al_set_shader_color_array(vert_shader, (unsigned char *)&v[0].color, sizeof(ALLEGRO_VERTEX));
al_set_shader_texcoord_array(vert_shader, &v[0].u, sizeof(ALLEGRO_VERTEX));
float radius = 1;
float rinc = 4;
while (1) {
al_set_target_bitmap(tmp);
al_clear_to_color(al_map_rgba(0, 0, 0,0));
ALLEGRO_KEYBOARD_STATE s;
al_get_keyboard_state(&s);
if (al_key_down(&s, ALLEGRO_KEY_ESCAPE))
break;
radius += rinc;
if (rinc > 0 && radius >= 25) {
rinc = -rinc;
}
else if (rinc < 0 && radius < 1) {
rinc = -rinc;
}
al_set_shader_sampler(horz_shader, "t", bmp, 0);
al_set_shader_float(horz_shader, "img_width", al_get_bitmap_width(bmp));
al_set_shader_float(horz_shader, "radius", radius);
al_use_shader(horz_shader, true);
al_draw_bitmap(bmp, 0, 0, 0);
al_use_shader(horz_shader, false);
al_set_target_bitmap(al_get_backbuffer());
al_draw_bitmap(bg, 0, 0, 0);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE, white);
al_set_shader_sampler(vert_shader, "t", tmp, 0);
al_set_shader_float(vert_shader, "img_height", al_get_bitmap_height(bmp));
al_set_shader_float(vert_shader, "radius", radius);
al_use_shader(vert_shader, true);
al_draw_bitmap(tmp, 0, 0, 0);
al_use_shader(vert_shader, false);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ALPHA, ALLEGRO_INVERSE_ALPHA, white);
al_draw_bitmap(bmp, 0, 0, 0);
al_flip_display();
al_rest(0.016);
}
al_save_bitmap("bgxx.png", bg);
al_save_bitmap("tmpxx.png", tmp);
return 0;
}
