static bool glsl_set_shader_sampler(ALLEGRO_SHADER *shader,
const char *name, ALLEGRO_BITMAP *bitmap, int unit)
{
ALLEGRO_SHADER_GLSL_S *gl_shader = (ALLEGRO_SHADER_GLSL_S *)shader;
GLint handle;
GLuint texture;
if (bitmap && al_get_bitmap_flags(bitmap) & ALLEGRO_MEMORY_BITMAP) {
ALLEGRO_WARN("Cannot use memory bitmap for sampler\n");
return false;
}
handle = glGetUniformLocation(gl_shader->program_object, name);
if (handle < 0) {
ALLEGRO_WARN("No uniform variable '%s' in shader program\n", name);
return false;
}
glActiveTexture(GL_TEXTURE0 + unit);
texture = bitmap ? al_get_opengl_texture(bitmap) : 0;
glBindTexture(GL_TEXTURE_2D, texture);
glUniform1i(handle, unit);
return check_gl_error(name);
}
void Quadnode::Render()
{
if(texture)
{
glBindTexture(GL_TEXTURE_2D, al_get_opengl_texture(texture));
glEnable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glAlphaFunc(GL_GREATER,0.1f);
glEnable(GL_ALPHA_TEST);
}
glBegin(GL_QUADS);
glNormal3f(normal.x, normal.y, normal.z);
glTexCoord2f(0, 0); glVertex3f(v[0].x, v[0].y, v[0].z);
glTexCoord2f(1, 0); glVertex3f(v[1].x, v[1].y, v[1].z);
glTexCoord2f(1, 1); glVertex3f(v[2].x, v[2].y, v[2].z);
glTexCoord2f(0, 1); glVertex3f(v[3].x, v[3].y, v[3].z);
glEnd();
if(texture)
{
glDisable(GL_ALPHA_TEST);
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_FLAT);
}
}
int
main (int argc, char **argv)
{
g_type_init ();
al_init ();
al_init_image_addon ();
al_set_new_display_option (ALLEGRO_RED_SIZE, 8, ALLEGRO_REQUIRE);
al_set_new_display_option (ALLEGRO_GREEN_SIZE, 8, ALLEGRO_REQUIRE);
al_set_new_display_option (ALLEGRO_BLUE_SIZE, 8, ALLEGRO_REQUIRE);
al_set_new_display_option (ALLEGRO_ALPHA_SIZE, 8, ALLEGRO_REQUIRE);
/* Nouveau = good */
/* al_set_new_display_option (ALLEGRO_AUX_BUFFERS, 4, ALLEGRO_REQUIRE); */
al_set_new_display_flags (ALLEGRO_WINDOWED | ALLEGRO_OPENGL);
ALLEGRO_DISPLAY *disp;
disp = al_create_display (640, 480);
xassert (disp);
g_xassert (al_get_opengl_extension_list ()->ALLEGRO_GL_ARB_depth_texture);
g_xassert (al_get_opengl_extension_list ()->ALLEGRO_GL_ARB_framebuffer_object);
al_set_target_backbuffer (disp);
printf ("OPENGL %x\n", al_get_opengl_version ());
blender_bmp = al_load_bitmap ("../data/n1img0.bmp");
g_xassert (640 == al_get_bitmap_width (blender_bmp) &&
480 == al_get_bitmap_height (blender_bmp));
blender_tex = al_get_opengl_texture (blender_bmp);
g_xassert (blender_tex);
GLint glvar;
/* Query GL_MAX_DRAW_BUFFERS, GL_MAX_COLOR_ATTACHMENTS */
glGetIntegerv (GL_MAX_DRAW_BUFFERS, &glvar);
xassert (4 <= glvar);
glGetIntegerv(GL_MAX_COLOR_ATTACHMENTS, &glvar);
xassert (4 <= glvar);
derp ();
al_flip_display ();
al_rest (2);
return EXIT_SUCCESS;
}
virtual ImageMedia *load(const File &file, bool force = false)
{
ALLEGRO_BITMAP *bmp;
GLuint tex;
bmp = al_load_bitmap(file.getFullName().c_str());
if (!bmp)
throw LoadingFailed(file.getFullName(), "ImageLoader failed to load image.");
// al_convert_mask_to_alpha(bmp, al_map_rgb(255, 0, 0));
tex = al_get_opengl_texture(bmp);
if (tex == 0)
throw LoadingFailed(file.getFullName(), "ImageLoader failed to load texture.");
return new ImageMedia(bmp, tex, file.getFileName(), force);
}
void rect_drawtext(rect_t r, ALLEGRO_COLOR c, const char *s)
{
int i, len;
int sx, fw = uistyle.fontw;
int sy, fh = uistyle.fonth;
if (s == NULL) return;
len = strlen(s);
/* make text and rect with the same center. */
/* Sbegin = Rcenter - Ssize */
sx = (r.x + r.w/2) - (fw * len)/2;
sy = (r.y + r.h/2) - (fh)/2;
rect_draw(r, c);
glBindTexture(GL_TEXTURE_2D, al_get_opengl_texture(uistyle.font12));
for (i=0; i<len; i++) drawchar(sx+i*fw, sy, s[i]);
}
int main(int argc, char **argv)
{
float r = 0.5, g = 0.5, b = 1, ratio = 0;
int dir = 1;
ALLEGRO_DISPLAY *display;
ALLEGRO_BITMAP *mysha;
ALLEGRO_BITMAP *buffer;
const char *tinter_shader_src[] = {
"uniform sampler2D backBuffer;",
"uniform float r;",
"uniform float g;",
"uniform float b;",
"uniform float ratio;",
"void main() {",
" vec4 color;",
" float avg, dr, dg, db;",
" color = texture2D(backBuffer, gl_TexCoord[0].st);",
" avg = (color.r + color.g + color.b) / 3.0;",
" dr = avg * r;",
" dg = avg * g;",
" db = avg * b;",
" color.r = color.r - (ratio * (color.r - dr));",
" color.g = color.g - (ratio * (color.g - dg));",
" color.b = color.b - (ratio * (color.b - db));",
" gl_FragColor = color;",
"}"
};
const int TINTER_LEN = 18;
double start;
GLint loc;
(void)argc;
(void)argv;
if (!al_init()) {
abort_example("Could not init Allegro\n");
}
al_install_keyboard();
al_init_image_addon();
al_set_new_display_flags(ALLEGRO_OPENGL);
display = al_create_display(320, 200);
if (!display) {
abort_example("Error creating display\n");
}
mysha = al_load_bitmap("data/mysha.pcx");
if (!mysha) {
abort_example("Could not load image.\n");
}
buffer = al_create_bitmap(320, 200);
if (!al_have_opengl_extension("GL_EXT_framebuffer_object")
&& !al_have_opengl_extension("GL_ARB_fragment_shader")) {
abort_example("Fragment shaders not supported.\n");
}
tinter_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
glShaderSourceARB(tinter_shader, TINTER_LEN, tinter_shader_src, NULL);
glCompileShaderARB(tinter_shader);
tinter = glCreateProgramObjectARB();
glAttachObjectARB(tinter, tinter_shader);
glLinkProgramARB(tinter);
loc = glGetUniformLocationARB(tinter, "backBuffer");
glUniform1iARB(loc, al_get_opengl_texture(buffer));
start = al_get_time();
while (1) {
double now, diff;
ALLEGRO_KEYBOARD_STATE state;
al_get_keyboard_state(&state);
if (al_key_down(&state, ALLEGRO_KEY_ESCAPE)) {
break;
}
now = al_get_time();
diff = now - start;
start = now;
ratio += diff * 0.5 * dir;
if (dir < 0 && ratio < 0) {
ratio = 0;
dir = -dir;
}
else if (dir > 0 && ratio > 1) {
ratio = 1;
dir = -dir;
}
al_set_target_bitmap(buffer);
glUseProgramObjectARB(tinter);
loc = glGetUniformLocationARB(tinter, "ratio");
glUniform1fARB(loc, ratio);
loc = glGetUniformLocationARB(tinter, "r");
glUniform1fARB(loc, r);
loc = glGetUniformLocationARB(tinter, "g");
glUniform1fARB(loc, g);
loc = glGetUniformLocationARB(tinter, "b");
glUniform1fARB(loc, b);
al_draw_bitmap(mysha, 0, 0, 0);
glUseProgramObjectARB(0);
al_set_target_backbuffer(display);
al_draw_bitmap(buffer, 0, 0, 0);
al_flip_display();
al_rest(0.001);
}
glDetachObjectARB(tinter, tinter_shader);
glDeleteObjectARB(tinter_shader);
al_uninstall_system();
return 0;
}
static void setup_state(const char* vtxs, const ALLEGRO_VERTEX_DECL* decl, ALLEGRO_BITMAP* texture)
{
if(decl) {
ALLEGRO_VERTEX_ELEMENT* e;
e = &decl->elements[ALLEGRO_PRIM_POSITION];
if(e->attribute) {
int ncoord = 0;
GLenum type = 0;
bool normalized;
glEnableClientState(GL_VERTEX_ARRAY);
convert_storage(e->storage, &type, &ncoord, &normalized);
glVertexPointer(ncoord, type, decl->stride, vtxs + e->offset);
} else {
glDisableClientState(GL_VERTEX_ARRAY);
}
e = &decl->elements[ALLEGRO_PRIM_TEX_COORD];
if(!e->attribute)
e = &decl->elements[ALLEGRO_PRIM_TEX_COORD_PIXEL];
if(texture && e->attribute) {
int ncoord = 0;
GLenum type = 0;
bool normalized;
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
convert_storage(e->storage, &type, &ncoord, &normalized);
glTexCoordPointer(ncoord, type, decl->stride, vtxs + e->offset);
} else {
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
e = &decl->elements[ALLEGRO_PRIM_COLOR_ATTR];
if(e->attribute) {
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(4, GL_FLOAT, decl->stride, vtxs + e->offset);
} else {
glDisableClientState(GL_COLOR_ARRAY);
glColor4f(1, 1, 1, 1);
}
} else {
const ALLEGRO_VERTEX* vtx = (const ALLEGRO_VERTEX*)vtxs;
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(ALLEGRO_VERTEX), &vtx[0].x);
glColorPointer(4, GL_FLOAT, sizeof(ALLEGRO_VERTEX), &vtx[0].color.r);
glTexCoordPointer(2, GL_FLOAT, sizeof(ALLEGRO_VERTEX), &vtx[0].u);
}
if (texture) {
GLuint gl_texture = al_get_opengl_texture(texture);
int true_w, true_h;
int tex_x, tex_y;
GLuint current_texture;
float mat[4][4] = {
{1, 0, 0, 0},
{0, -1, 0, 0},
{0, 0, 1, 0},
{0, 0, 0, 1}
};
int height;
if (texture->parent)
height = texture->parent->h;
else
height = texture->h;
al_get_opengl_texture_size(texture, &true_w, &true_h);
al_get_opengl_texture_position(texture, &tex_x, &tex_y);
mat[3][0] = (float)tex_x / true_w;
mat[3][1] = (float)(height - tex_y) / true_h;
if(decl) {
if(decl->elements[ALLEGRO_PRIM_TEX_COORD_PIXEL].attribute) {
mat[0][0] = 1.0f / true_w;
mat[1][1] = -1.0f / true_h;
} else {
mat[0][0] = (float)al_get_bitmap_width(texture) / true_w;
mat[1][1] = -(float)al_get_bitmap_height(texture) / true_h;
}
} else {
mat[0][0] = 1.0f / true_w;
mat[1][1] = -1.0f / true_h;
}
glGetIntegerv(GL_TEXTURE_BINDING_2D, (GLint*)¤t_texture);
if (current_texture != gl_texture) {
glBindTexture(GL_TEXTURE_2D, gl_texture);
}
glMatrixMode(GL_TEXTURE);
glLoadMatrixf(mat[0]);
glMatrixMode(GL_MODELVIEW);
} else {
glBindTexture(GL_TEXTURE_2D, 0);
}
}
