I'm trying to fancy up my ui in one of my programs and wanted to use other shapes than just squares and rectangles. But I'm having problems with the code crashing. Does this look like a good way to do it?

Heres

EDIT: I've attached what one of the images look like. Its pretty much looks like a quarter part of an o.

It seems to me that the active area for a mouse is still rectangular even if the widget is oval or whatever. It'd be rather hard to notice this unless your OCD or something.

It probably crashes because:

    for(int i = 0; i < al_get_bitmap_height(UpImage); i++)
    {
        for(int j = 0; j < al_get_bitmap_width(UpImage); j++)
        {
            Pixels[i][j] = al_get_pixel(UpImage, i, j);
        }
    }

should probably be:

    for(int j = 0; j < al_get_bitmap_height(UpImage); j++)
    {
        for(int i = 0; i < al_get_bitmap_width(UpImage); i++)
        {
            Pixels[i][j] = al_get_pixel(UpImage, i, j);
        }
    }

But really, why store every pixel?

Just translate the mouse so that it is relative to the bitmap eg: if bitmap is at 50,50 subtract 50,50 from mouse position.
Then do bounds check on your mouse so mouseX >= 0 && mouseX < width ... same for height. Then just make 1 call to al_get_pixel(mouseX,mouseY).

But if you want to do it your way, remember c++ is row major so [width][height]

Yeah thats what I figured was causing the crash. I just wanted to store all the pixels because I thought that if the mouse is moved alot over the image that all the al_get_pixel calls would cause lag.

EDIT: The code seems to work fine. Its pixel perfect precision. But after I click on one button and then click on another on it crashes on al_unmap_rgba(ImagePixels[x][y], &r, &g, &b, &alpha);

EDIT2: Changing the code to this stops the crashes

            unsigned char r, g, b, alpha;
            al_unmap_rgba(al_get_pixel(UpImage, MouseX-x1, MouseY-y1), &r, &g, &b, &alpha);
            Over = true;

            if(alpha == 0) // if the pixel that the mouse is over is completly transparent then over is false
            {
                Over = false;
            }

Will locking the bitmap in this situation increase performance?(between the unmap_rgba)

I don't think so. I think the cost of locking it so often would outweigh the performance boost.

Locking would probably help unless you're only doing a few pixels. Just make sure to only lock the region you need if it's not the whole bitmap. Sorry, I didn't really read your code so I don't know what's best for you, just that locking helps if you're accessing more than a few pixels and they're all adjacent.

Well al_get_pixel is called everytime an allegro_event_mouse_axes event occurs and the mouse is over the bitmap.

If it's just called once then it doesn't matter if you lock the bitmap.

The way it works is, al_get_pixel will lock a 1x1 pixel region of the bitmap for you if the bitmap isn't locked already. Then it will unlock it.

If it is already locked, it just reads from the lock data and doesn't unlock the bitmap. If you get a pixel outside of the locked region it will return 0s for the pixel data.

So for 1 pixel the behaviour is identical. For more than 1 pixel you can avoid locking operatings in al_get_pixel by locking yourself which will be faster, because locking is slow.