Question

So I decided to look up some collision detection but I’ve been having trouble finding proper information
regarding 2d collision detection between two images that includes how to properly avoid detecting the transparent
areas of an image but I did find one post which I got myself attached to but the problem is that I don’t
really understand the post nor do I understand why he does some of those things…

Here’s the post in question: https://stackoverflow.com/posts/336615/revisions

So first of all I want to ask if this solution is actually a good one / proper or if I should just look elsewhere.

Secondly I wonder, in his post, he mentions using integer arrays, not 2d arrays either it seems, to
set 1 and 0 to decide whether or not the pixel is transparent or not but I don’t really know how I am supposed
to achieve this. At first I thought it could be achieved by just forming a string of 1 and 0s and convert it to a Long
but even with a mere image width of 25, the Long, gets… too long…

I also tried this with no luck, since the code does not function with this array:

 long[] array = new long[30*30]; // height * width of the image
    int x = 0;
    int y = 0;

for(int i = 0; i<30*30; i++){
    if(image.getRGB(x,y) == 0){
         array[i] = 0;
    }
    else{ array[i] = 1; }

    x++;
    if (x==30){
         y++;
         x=0;
    } 
}

Thirdly, I was hoping someone could maybe explain the whole process and why the things he does, are necessary.
By the way, I do know how those bit wise operators work!
In other words, I don’t understand his train of thought / motivation for doing the all things in the code and I would like to gain an understanding of all this!

I don’t really know how to proceed right now hehe…

Answer 1

The result of the bitwise AND operation (&) is true (1) for each each bit where the the corresponding bit is true in both operands, and false (0) otherwise.

The idea he’s using is to create a version of the image (a mask) where each non-transparent pixel in the original image is stored as a ‘1’ bit, and each transparent pixel as a ‘0’ bit. These are packed into a single integer, which can be tested against the mask for another image with a single AND operation (before the AND he calculates the horizontal distance between the two images and shifts one of the masks if necessary).

For example, let’s assume that we have the following two 4×1 pixel images:

5, 0, 0, 5
      8, 8, 8, 8

Although I placed them on separate rows here for practical purposes, you should view them as being on the same row, so the last two pixels of the left image overlap with the first two of the right image.

The masks for the rows when viewed in binary representation would be:

1001
1111

The distance between the left and right image is -2, so we shift the first mask left by 2 bits:

1001 << 2 => 100100

So now we have these masks:

100100
001111

ANDing these gives us:

000100

The non-zero result tells us that we have a collision.