[A5] Masked drawing?

Chris Katko

Are there any functions in Allegro 5 to do bitmasked drawing?

Ala the ground in this picture:
{"name":"WormsArmageddon1.PNG","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/c\/d\/cd522b2ea198b49ac72533a93431b1c6.png","w":633,"h":252,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/c\/d\/cd522b2ea198b49ac72533a93431b1c6"}

SiegeLord

You'd use the alpha channel.

Chris Katko

So you're saying use the alpha channel to denote whether or not there is land at that point?

That's neat and it might work, but that doesn't really allow things like rolling textures or multiple textures. I think I'm looking for more of a "draw X bitmap given Y mask against the screen."

I guess I could use some sort of Stencil Buffer... though I can't remember if that was depreciated.

SiegeLord

Ah... I think I'd approach this problem using a shader. Allegro definitely doesn't expose the stenciling feature in any way I know of.

beoran

It's possible to do masked blends using the features of Allegro 5 only by using al_set_blender. I do this to generate automatic blends for my game's tile maps. Here's a snippet from my code that should be helpful:

#SelectExpand
  1
  2/** Draw a tile into the given bitmap, which should be of size TILE_W, TILE_H 
* applying the given mask bitmap, where the mask will 
  4be flipped and rotated as per the given mask_flags. The mask bitmap
  5should be white, but with different alpha levels on the white 
  6which will be applied as the mask. Does nothing if tile is NULL.  
  7This requires al_hold_bitmap_drawing to be turned off!
  8You can use this code snippet freely. You just do whatever you want with it, no warrantees, yadda yadda.
  9
 10*/
 11void tile_draw_masked_to
 12(Image * result, Tile * tile, Image * mask, float angle, int mask_flags) {  
Image  * buffer;   
 14
Tileset * set;
Image * sheet;
ALLEGRO_BITMAP * target;
Color dcolor = al_map_rgb(0xee, 0x00, 0xee);
float dx, dy, sx, sy, sw, sh;
int bmpflags;

if (!tile) return;

bmpflags         = al_get_new_bitmap_flags();
al_set_new_bitmap_flags(ALLEGRO_CONVERT_BITMAP);
buffer           = al_create_bitmap(al_get_bitmap_width(tile),
                   al_get_bitmap_height(tile));
al_set_new_bitmap_flags(bmpflags);


/* Keep the target bitmap. */
target = al_get_target_bitmap();

/* Copy the tile into the buffer.  */
al_set_target_bitmap(buffer);
set     = tile->set;
sheet   = set->sheet;
dx      = 0.0;
dy      = 0.0; 
sx      = (float) tile->now.x;
sy      = (float) tile->now.y;
sw      = (float) TILE_W;
sh      = (float) TILE_H;
/* Set blender to copy mode. */
 45
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
al_draw_bitmap_region(sheet, sx, sy, sw, sh, 0, 0, 0);

/* Draw the mask over the tile, taking the alpha of the mask  */
al_set_blender(ALLEGRO_ADD, ALLEGRO_ZERO, ALLEGRO_ALPHA);
al_draw_bitmap(mask, 0, 0, mask_flags);
 52
/* Restore normal Allegro blending. */
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);

sx = 0.0;
sy = 0.0;
if (angle != 0.0) {
  sx = TILE_H / 2.0;
  sy = TILE_W / 2.0;
  dx += sx;
  dy += sy;
} 

/* Draw the tile mask buffer to the result bitmap */
al_set_target_bitmap(result);
al_draw_rotated_bitmap(tile_mask_buffer, sx, sy, dx, dy, angle, 0);
/* And restore the target bitmap. */ 
al_set_target_bitmap(target);
al_destroy_bitmap(buffer);
 71}

Edit:
Note that this will likely be slower than using a shader. Maybe masked draws would be a nice feature for a later version of Allegro....

Edit2:
Looks like stencil buffers are not obsolete and available in opengl
https://www.khronos.org/opengles/sdk/docs/man3/html/glStencilOp.xhtml
And in opengl ES 2.0 and 3.0 (though not 1.0?)
https://www.khronos.org/opengles/sdk/docs/man3/html/glStencilOp.xhtml
So definitely something we may be able to put an Allegro wrapper around...

Edit 3:
Also in Direct3D 9
https://msdn.microsoft.com/en-us/library/windows/desktop/bb206123%28v=vs.85%29.aspx
And 10/11:
http://stackoverflow.com/questions/19320308/porting-opengl-stencil-functionality-to-directx-11

Elias

You can also look at the ex_depth_mask example, it does something similar without a shader, using the depth buffer as a mask. Stencil support definitely would be nice as well, especially in cases where you need both depth and stencil buffers at the same time.

Chris Katko

I can't get it to work, these blender options and alpha has always been confusing to me.

Do I want my mask to be in the RGB, or in the Alpha channel? I tried converting my map to alpha values, but that doesn't seem to work.

I guess I'm having trouble understanding when alpha moves. If I draw something with alpha, does that set the alpha of the destination bitmap?

#SelectExpand
  1//not complete code, just relevant slices.
  2
  3void load_map(std::string file_path)
{
collision_map = al_load_bitmap(file_path.c_str());
draw_map = al_load_bitmap(file_path.c_str());
texture_bmp = al_load_bitmap("data/texture.png");
draw_mask = al_create_bitmap(640, 480);
  9
// Convert RGB to alpha
al_set_target_bitmap(draw_mask);
al_lock_bitmap(draw_mask, al_get_bitmap_format(draw_mask), ALLEGRO_LOCK_WRITEONLY);
al_lock_bitmap(draw_map, al_get_bitmap_format(draw_map), ALLEGRO_LOCK_READONLY);
for(int i = 0; i < w; i++)
  for(int j = 0; j < h; j++)
    {
    ALLEGRO_COLOR temp = al_get_pixel(draw_map, i, j);
    al_put_pixel(i, j, al_map_rgba(0,0,0, (temp.r+temp.g+temp.g)/3  ));
    }
al_unlock_bitmap(draw_map);
al_unlock_bitmap(draw_mask);
al_set_target_bitmap(target); //restore stack
}
 24
 25void draw()
{
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);
al_draw_bitmap(draw_mask, 0, 0, 0); //mask
  
al_set_blender(ALLEGRO_ADD, ALLEGRO_ZERO, ALLEGRO_ALPHA);
al_draw_bitmap(texture_bmp, 0, 0, 0); //texture over mask
  
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA); //default
}

Edgar Reynaldo

Chris Katko said:

If I draw something with alpha, does that set the alpha of the destination bitmap?

Only if you use al_set_separate_blender. Otherwise the destination alpha is untouched.

beoran

Well you're drawing the bitmap over the mask which probably doesn't work. I'm drawing the mask over the bitmap to another bitmap, which does work if you re-draw this resulting bitmap to screen.

Chris Katko

Thanks! It took me awhile to things to sink in (they still aren't great), but the biggest error between the sample code and mine was that I forgot to convert my "map" bitmap's black color to an alpha channel. Once I called that function, it works great!

However, there is one downside to the depth test method (other than losing normal use of the depth buffer while using it for masking). What about smooth transitions?

If you wanted something to be drawn using variable alpha levels, how would you frame it? Is it exactly like that "rounded rectangle" thread that's also going on?

Keep in mind, these alphas/blenders are still very confusing to me so please break it down and elaborate.

Thank you.

Mark Oates

Hey what am I doing?! I totally have the function you're looking for!

create_masked_bitmap

but use this overload for simplicity:

ALLEGRO_BITMAP *create_masked_bitmap(ALLEGRO_BITMAP *top_image, ALLEGRO_BITMAP *bottom_image)

I haven't used it in a while (blending methods changed slightly in subsequent versions of allegro) but I just tested it and it seemed to work. This image shows a mask image (top_image), a texture image (bottom_image), and the example program putting the two together on a blue background.

{"name":"609403","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/c\/e\/cec488d8bf9f387b03b832c60122da4e.png","w":1921,"h":1079,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/c\/e\/cec488d8bf9f387b03b832c60122da4e"}

If you go to the header file here, you'll see there are variants of the function, too. You can apply use your own blending modes, and/or transforms to the top/bottom images, and/or supply your own surface bitmap so that it's not created each time. There isn't a variant for looping the texture on the bottom to fit the mask, but you could use draw_textured_rectangle or draw_offset_textured_rectangle for that here).

All of this is still in the works, I don't have docs for this stuff, yet.

Chris Katko said:

I guess I'm having trouble understanding when alpha moves

It's very confusing. Back when I was working on this function, I had a program that generated all possible blends (hundreds of images, if I recall) just so I could find the correct blending sequence & bitmap order I was looking for. Which bitmap do you draw on the surface? Which one do you draw on top of that? Does it read the surface or the drawn bitmap? ALLEGRO_BLEND_MODE_WHUT?

F it. Just brute force.

beoran

Maybe the documentation needs improving, but I figured it out rather easily by playing with ex_blend.

http://sourceforge.net/p/alleg/allegro/ci/5.1/tree/examples/ex_blend.c

Chris Katko

Thanks for the help guys! I don't have time implement your most recent suggestions yet, but I'll keep you updated!

Here's a picture of it working so far (with ugly filler graphics):

{"name":"609406","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/0\/d\/0d9885974075845e438514233b3417d1.png","w":642,"h":505,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/0\/d\/0d9885974075845e438514233b3417d1"}

Background is drawn normally, the "map" (black for nothing, any other color for land) is converted to alpha, and then a texture is printed through that. The texture is tiled 2x2 right now to show its possible. Nothing too fancy, but it's baby steps.

Thread #615317. Printed from Allegro.cc