void Shader::use()
{
if(!m_enabled)
return;
m_inUse = true;
mountShader();
al_use_shader(NULL);
al_use_shader(m_shader);
}
bool Renderer::setShader(Renderer::ShaderType type)
{
switch(type)
{
case SHADER_DEFAULT:
return al_use_shader(prg_);
case SHADER_ALLEGRO:
return al_use_shader(al_prg_);
}
return false;
}
void _reload_loaded_bitmaps_delayed(void)
{
int flags = al_get_new_bitmap_flags();
int format = al_get_new_bitmap_format();
for (size_t i = 0; i < loaded_bitmaps.size(); i++) {
MBITMAP *m = loaded_bitmaps[i]->bitmap;
if ((loaded_bitmaps[i]->flags & ALLEGRO_NO_PRESERVE_TEXTURE) && loaded_bitmaps[i]->delayed) {
al_set_new_bitmap_flags(loaded_bitmaps[i]->flags);
al_set_new_bitmap_format(loaded_bitmaps[i]->format);
if (loaded_bitmaps[i]->load_type == LOAD_LOAD) {
m->bitmap = my_load_bitmap(loaded_bitmaps[i]->load.filename.c_str());
if (loaded_bitmaps[i]->load.redraw) {
loaded_bitmaps[i]->load.redraw(m, loaded_bitmaps[i]->load.data);
}
}
else { // create
Recreate *d = &loaded_bitmaps[i]->recreate;
m->bitmap = my_al_create_bitmap(d->w, d->h);
if (d->func) { // recreate with func
d->func(m, d->data);
}
}
al_use_shader(NULL);
}
}
al_set_new_bitmap_flags(flags);
al_set_new_bitmap_format(format);
}
static bool sdl_acknowledge_resize(ALLEGRO_DISPLAY *display)
{
ALLEGRO_DISPLAY_SDL *sdl = (void *)display;
SDL_GetWindowSize(sdl->window, &display->w, &display->h);
_al_ogl_setup_gl(display);
if (display->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
display->default_shader = _al_create_default_shader(display->flags);
al_use_shader(display->default_shader);
}
recreate_textures(display);
_al_glsl_unuse_shaders();
return true;
}
void Renderer::uninit()
{
if(queue_)
al_destroy_event_queue(queue_);
if(tmr_)
al_destroy_timer(tmr_);
if(prg_)
{
al_use_shader(nullptr);
al_destroy_shader(prg_);
}
if(resManager_)
delete resManager_;
for(auto chunk: chunkData_)
{
delete chunk.second;
}
chunkData_.clear();
if(dpy_)
al_destroy_display(dpy_);
if(al_is_system_installed())
al_uninstall_system();
tmr_ = nullptr;
dpy_ = nullptr;
queue_ = nullptr;
prg_ = nullptr;
resManager_ = nullptr;
// TODO: delete loaded chunks?
}
void Shader::stop()
{
al_use_shader(NULL);
}
/* Function: al_create_display
*/
ALLEGRO_DISPLAY *al_create_display(int w, int h)
{
ALLEGRO_SYSTEM *system;
ALLEGRO_DISPLAY_INTERFACE *driver;
ALLEGRO_DISPLAY *display;
ALLEGRO_EXTRA_DISPLAY_SETTINGS *settings;
int flags;
system = al_get_system_driver();
driver = system->vt->get_display_driver();
if (!driver) {
ALLEGRO_ERROR("Failed to create display (no display driver)\n");
return NULL;
}
display = driver->create_display(w, h);
if (!display) {
ALLEGRO_ERROR("Failed to create display (NULL)\n");
return NULL;
}
ASSERT(display->vt);
settings = &display->extra_settings;
flags = settings->required | settings->suggested;
if (!(flags & (1 << ALLEGRO_AUTO_CONVERT_BITMAPS))) {
settings->settings[ALLEGRO_AUTO_CONVERT_BITMAPS] = 1;
}
display->min_w = 0;
display->min_h = 0;
display->max_w = 0;
display->max_h = 0;
display->use_constraints = false;
display->vertex_cache = 0;
display->num_cache_vertices = 0;
display->cache_enabled = false;
display->vertex_cache_size = 0;
display->cache_texture = 0;
al_identity_transform(&display->projview_transform);
display->default_shader = NULL;
_al_vector_init(&display->display_invalidated_callbacks, sizeof(void *));
_al_vector_init(&display->display_validated_callbacks, sizeof(void *));
display->render_state.write_mask = ALLEGRO_MASK_RGBA | ALLEGRO_MASK_DEPTH;
display->render_state.depth_test = false;
display->render_state.depth_function = ALLEGRO_RENDER_LESS;
display->render_state.alpha_test = false;
display->render_state.alpha_function = ALLEGRO_RENDER_ALWAYS;
display->render_state.alpha_test_value = 0;
_al_vector_init(&display->bitmaps, sizeof(ALLEGRO_BITMAP*));
if (settings->settings[ALLEGRO_COMPATIBLE_DISPLAY]) {
al_set_target_bitmap(al_get_backbuffer(display));
}
else {
ALLEGRO_DEBUG("ALLEGRO_COMPATIBLE_DISPLAY not set\n");
_al_set_current_display_only(display);
}
if (display->flags & ALLEGRO_PROGRAMMABLE_PIPELINE) {
display->default_shader = _al_create_default_shader(display->flags);
if (!display->default_shader) {
al_destroy_display(display);
return NULL;
}
al_use_shader(display->default_shader);
}
/* Clear the screen */
if (settings->settings[ALLEGRO_COMPATIBLE_DISPLAY]) {
al_clear_to_color(al_map_rgb(0, 0, 0));
/* TODO:
* on iphone, don't kill the initial splashscreen - in fact, it's also
* annoying in linux to have an extra black frame as first frame and I
* suppose we never really want it
*/
#if 0
al_flip_display();
#endif
}
if (settings->settings[ALLEGRO_AUTO_CONVERT_BITMAPS]) {
/* We convert video bitmaps to memory bitmaps when the display is
* destroyed, so seems only fair to re-convertt hem when the
* display is re-created again.
*/
al_convert_memory_bitmaps();
}
return display;
}
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;
}
void use_shader(ALLEGRO_SHADER *shader)
{
al_use_shader(shader);
}
