Hey

(I'm sorry foy my english)

I have small problem, with function.
I made a function that checks whether the mouse cursor is in the field Bitmap.
eg. I want to function returns true, if mouse cursor is on alpha pixel.

In function check position cursor, if cursor is in the field Bitmap.
it then get pixel with Bitmap (before lock region bitmap and later unlock)

Function is play in ALLEGRO_EVENT_MOUSE_AXES

if I use functions this is delay big.
(without this function project is fast)

I'm not sure if I got exactly what you problem is, but I assume it's that lock bitmap and unlock bitmap slow down your application?

When you use lock bitmap and unlock bitmap on a display bitmap, it's bound to be slow, because the bitmap first has to be read from the GPU into system memory and then wrote back to the GPU. Try creating the bitmap as a system memory bitmap. That way you can always directly access the pixels and no data has to be copied. If you also need to render the bitmap, then maybe you should make two versions of the same bitmap. One in system memory and one in display memory. You could then use the system memory bitmap for collision checking and the display bitmap for rendering.

Mousemove is called A LOT. And locking / Unlocking can be costly if you do it a lot.

Here are a few suggestions:
-Create a bitfield. https://en.wikipedia.org/wiki/Bit_field Only lock your bitmap once at the start, and calculate which pixels are alpha and which ones are not and put it in the bitfield. Then check the mouse position against the bitfield to see if it is a transparent or opaque area.

If that is too complex to understand, an easier version would be to allocate a [w][h] 2D array of char to do it.

The other option is to build simple polygon approximations of your bitmaps and check if the mouse point is inside the simple polygon.

Before creating a bitmap. I set the flag and display options

I removed the lock and unlock bitmaps and are smaller delay.

but are still delays, but smaller

Try replacing ALLEGRO_VIDEO_BITMAP with ALLEGRO_MEMORY_BITMAP.

How swapped for the Allegro BITMAP MEMORY is even worse

And what if you do as suggested in my first post? Create two versions of that bitmap. One with ALLEGRO_VIDEO_BITMAP and one with ALLEGRO_MEMORY_BITMAP. Use the ALLEGRO_VIDEO_BITMAP one for rendering, while you use the ALLEGRO_MEMORY_BITMAP one for your alpha checks.

I'm just curious, 1) how many bitmaps are you checking and 2) what are the sizes of these bitmaps?

RPG Marker
It works ! and it very quickly . I did like you said

I have one questions.

If it is eg . 200 bitmaps is 200 * 2 is equal to 400 bitmaps.
it will not be problems with optimization ?

The game will, of course, use addtional memroy in system RAM for each copy of a bitmap that you use for mouse collision detection, but depending on the number of bitmaps you need mouse detection for, the size of each bitmap and the hardware you are targeting for your game, it hopefully shouldn't bee too much of a problem. Nowadays most machines have at least 4 to 8 GB of system RAM, which don't exceed to quickly.

If this RAM usage is still too much for you, you'll most likely have to try a different solution, like one of the solutions jmasterx suggested or maybe even just simple box collisions (depending on what you need this for in the first place). So yeah, the best solution really always depends on what exactly you're trying to do and for what purpose.

Thank you very much.

does not want create new thread, So here write

i often use al_clone_bitmap in project.
i tried use recording

only if drew on bt2 that bt1 also changed.

Why don't use al_clone_bitmap ? because if used clone_bitmap a lot, that is delay
and i tried solve a problem.

al_clone_bitmap will create and allocate in memory a whole new bitmap (based on the previous). Any time you allocate something new in memory, it is usually much slower than other things.

But if you do it like you showed:

ALLEGRO_BITMAP* bt1 = al_load_bitmap("bt.png");
ALLEGRO_BITMAP* bt2 = bt1;

Here you are just creating a new pointer. Now you have two variables that point to the same bitmap in memory, so no copying and allocation for a new bitmap has to happen.