I'm only able to draw about 3000 sprites on my Intel HD, 2.7ghz machine, running with no throttling, before the framerate dips. This is a lot less than I expected.

I've tried everything, and I am using bitmap holding (and a single spritesheet) and it makes no difference (it does make a huge difference when drawing a 20x14 tilemap strangely ... 0.5ms vs 1.5ms)

I've also made sure it's not my code that is slowing it down - removing the call to al_draw_tinted_scaled_rotated_bitmap_region speeds things up by about 40%. Also tried calling al_draw_bitmap_region instead, and that didn't make a difference.

Any ideas?

EDIT: I just realized I am sorting my sprites by their Y position, and I lied, I am using 2 spritesheets, so that would account for the lack of speedup from holding. Still, I was expecting more, like around 5-6000?

16x16. Yes to video bitmaps.

I added a quick-and-dirty visibility culling.

Forth:

    : sprite  ( - )
        x 2@ spritewh aabb cam 's x 2@ viewwh aabb overlap? if sprite ;then ;

Now we're down to 5ms to render about 1700 objects (500 of them are drawing themselves twice to create a shadow-casting effect)

(So actually it was less than 3000 before and more like 2000.)

300-500us of that is the tilemap background, and the rest is I guess engine overhead. If I didn't depth-sort everything it might save a little, but it's a radix sort so it's extremely fast.

You have to separate the drawing by src texture, otherwise holding won't do anything.

Why on earth do you need to draw 3000+ sprites in one frame ?
holy smoke

But redrawing all 8100 tiles if they don't change is silly.

You can use buffering techniques, dirty rectangles, shaders, there are lots of options.

If your layers don't change often, you can also upload a VBO (Vertex Buffer Object) to the gpu, so you don't have to waste bandwidth uploading the same vertices over and over again.

I hate this argument. Why? Why not.

Ask Factorio.

{"name":"7e3tiqtd3fk11.jpg","src":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/6\/7\/6738552d07106bd70b2874e322801c9a.jpg","w":1920,"h":1080,"tn":"\/\/djungxnpq2nug.cloudfront.net\/image\/cache\/6\/7\/6738552d07106bd70b2874e322801c9a"}

That's 1080p.

I play in 4K

ala

And even with screen real estate, don't forget the fact that it's not just 2d pixel area. You can (and often do) have multiple layers, and multiple rendering passes (shadows, lighting, fog-of-war, and more).

No part of an API should be orders-of-a-magnitude slower than ideal performance without the API. Maybe that's why Factorio ripped out Allegro from their code last year. There's a huge difference between say, Vulkan, requiring you to model your codebase around hardware (as opposed to a simpler abstract API model), and Allegro flatout being 2X+ slower than the exact same operation without Allegro.

And what if they DO change every frame, as in the aforementioned lighting example?

[edit]

Lastly, Factorio has made MILLIONS upon MILLIONS of dollars. So I've already shown a real-world example of 1) this exact use case, and 2) Allegro possibly being a problem for it. This is not a hypothetical scenario. This is a massively sold, real product that exhibits this exact use-case, not a what-if.

As Edgar said, if Factorio is 2x slower using Allegro then they were doing something wrong. Just using atlases with a correct rendering pipe/algorithm/loop should be as fast as doing it calling OpenGL/DirectX directly (or a little slower, but not a half!).

check where the this slow down is you can use some beter sorting logic so you don't sort if there is no change. after a complete sort. do smaller sorts on objects that have changed

used the same logic used in database backups full/intermediate

edit: you can also use object tricks like object blocks

when you have many of the same object together change them into a single object this works great for this type of game. 4 factories in placed next to each other becomes one factor object one sprite. the game knows its 4 but the sort will know it as one. if object takes damage than you can revert it to 4 if you need to show that one of the 4 took more damage than the others