Is this the right way of using al_hold_bitmap

Karol Wu

Hello.

Generally I'm new to Allegro library. I'm also new to these forums, so Hello everyone!
I'm Carl, I'm from Poland and currently working on a MMORPG game.

I've been investigating different ways of accelerating map (2D) rendering and found this: https://www.allegro.cc/manual/5/al_hold_bitmap_drawing. I've implemented this idea in my code aand...

My question is... am I doing it in the right way? Here's my code:

#SelectExpand
  1std::map<unsigned int, ALLEGRO_BITMAP *> bitmaps;
      std::map<unsigned int, std::vector<std::shared_ptr<Tile>>> tiles_stagged;
  3
      for(unsigned short x = start_x; x <= end_x; ++x)
      {
          for(unsigned short y = start_y; y <= end_y; ++y)
          {
              std::shared_ptr<Tile> tile = this->layers[(Layer::Type)i].tiles[x][y];
  9
              if(tile == 0) continue;
 11
              ALLEGRO_BITMAP *tilegfx = NULL;
 13
              if(bitmaps.find(tile->graphic_id) == bitmaps.end())
              {
                  tilegfx = GFXLoader().GetBitmap(gid_offset[i], tile->graphic_id);
                  bitmaps[tile->graphic_id] = tilegfx;
              }
 19
              if(tile->x >= start_x && tile->x <= end_x && tile->y >= start_y && tile->y <= end_y)
                  tiles_stagged[tile->graphic_id].push_back(tile);
          }
      }
 24
      for(auto &ts : tiles_stagged)
      {
          al_hold_bitmap_drawing(true);
          for(auto &tile : ts.second)
          {
              if(bitmaps[ts.first] == NULL) continue;
 31
              int screen_x = tile->x * 64 - tile->x * 32 - tile->y * 32 + rx;
              int screen_y = tile->y * 16 + tile->x * 16 + ry;
 34
              int w = al_get_bitmap_width(bitmaps[ts.first]);
              int h = al_get_bitmap_height(bitmaps[ts.first]);
 37
              if(i == (int)Layer::Type::Object)
              {
                  if(w > 64)
                  {
                      screen_x -= w / 2;
                      screen_x += 32;
                  }
                  if(h > 32)
                  {
                      screen_y -= h;
                      screen_y += 32;
                  }
                  if(w < 64)
                  {
                      screen_x -= w / 2;
                      screen_x += 32;
                      if(h > 32) screen_y -= 8;
                  }
                  if(h < 32)
                  {
                      screen_y -= h / 2;
                      screen_y += 16;
                  }
              }
 62
              al_draw_bitmap(bitmaps[ts.first], screen_x, screen_y, 0);
          }
          al_hold_bitmap_drawing(false);
      }

Eric Johnson

Hello Carl. Welcome to the forum! Yes, that looks right. Although it might be better to move al_hold_bitmap_drawing() outside of the for loops, depending on what your aim is.

Elias

Unless your bitmaps are all sub-bitmaps of the same parent bitmap, al_hold_bitmap_drawing won't have any effect btw.

Karol Wu

Eric Johnson said:

Hello Carl. Welcome to the forum! Yes, that looks right. Although it might be better to move al_hold_bitmap_drawing() outside of the for loops, depending on what your aim is.

Thanks! Tiles are grouped by the bitmap ID they are using, so I thought it would be good to enable and disable al_hold_bitmap_drawing() for tiles of each bitmap. Wouldn't it? Would it have same effect if I enable it just once before drawing all tiles?

Elias said:

Unless your bitmaps are all sub-bitmaps of the same parent bitmap, al_hold_bitmap_drawing won't have any effect btw.

I appreciate your opinion. I would use same parent bitmap for all of them although it would require merging 100's of bitmaps I don't think I can use such big bitmap.

Edgar Reynaldo

If you use a couple large sprite sheets or tile maps, you can group them together on one large atlas texture. Then allocate each image a sub bitmap of an area on that larger atlas. This is where al_hold_bitmap_drawing comes in, because it can delay drawing as long as the bound context doesn't change. So you can happily blit millions of sprites as long as they are on the same texture.

Elias

Karol Wu said:

I appreciate your opinion. I would use same parent bitmap for all of them although it would require merging 100's of bitmaps I don't think I can use such big bitmap.

Well, I overstated that - there will be no affect if none of the bitmaps is a sub-bitmap - it does not have to be a single parent.

If I understand right you actually are grouping your al_hold_bitmap_drawing calls around bitmaps with the same parent, in which case you are using it exactly as intended. And in that case it doesn't matter if you call it once around both loops or inside each loop - basically all "held" bitmaps are drawn whenever one of two things happens:

1. al_hold_bitmap_drawing(false) is called
2. a bitmap with a different parent is drawn

Karol Wu

Elias said:

If I understand right you actually are grouping your al_hold_bitmap_drawing calls around bitmaps with the same parent

Yes exactly.

Elias said:

And in that case it doesn't matter if you call it once around both loops or inside each loop - basically all "held" bitmaps are drawn whenever one of two things happens:

1. al_hold_bitmap_drawing(false) is called
2. a bitmap with a different parent is drawn

Big thanks to you for sharing this information.

Regards
Carl

Thread #617214. Printed from Allegro.cc