bool Renderer::loadShaders(const char *vertex_file_path, const char *fragment_file_path)
{
const char *slog = nullptr;
ALLEGRO_SHADER *prg = al_create_shader(ALLEGRO_SHADER_GLSL);
if(!prg)
goto load_fail;
if(!al_attach_shader_source_file(prg, ALLEGRO_VERTEX_SHADER, vertex_file_path))
{
NBT_Debug("failed to attach vertex shader:\n %s", al_get_shader_log(prg));
goto load_fail;
}
if(!al_attach_shader_source_file(prg, ALLEGRO_PIXEL_SHADER, fragment_file_path))
{
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;
}
slog = al_get_shader_log(prg);
if(slog)
{
NBT_Debug("shader log:\n%s", slog);
}
else
{
NBT_Debug("no shader log");
}
/*if(!al_use_shader(prg))
{
NBT_Debug("failed to use shader");
goto load_fail;
}*/
prg_ = prg;
return true;
load_fail:
if(prg)
al_destroy_shader(prg);
return false;
}
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;
}
bool Shader::link()
{
return al_build_shader(m_shader);
}
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;
}
