Forum: pixelperfekt collision

#define BITW unsigned long int
#define BITW_LEN 32
#define BITW_MASK 31
#define BITN(n) ((BITW)1 << (n))
 
/* Sets the bit at (x,y) */
static INLINE void bitmask_setbit(bitmask *m,int x,int y)
{ 
  m->bits[x/BITW_LEN*m->h + y] |= BITN(x & BITW_MASK); 
}

m->bits[x/BITW_LEN*m->h + y] |= BITN(x & BITW_MASK);

index 0: 00000000 00000000 00000000 00000000
index 1: 00000000 00000000 00000000 00000000
index 2: 00000000 00000000 00000000 00000000
....
index w*h-1:00000000 00000000 00000000 00000000

x >
      0  1  2  3  4  5
y  0: 00 06 12 18 24 30
\\/ 1: 01 07 13 19 25 31
   2: 02 08 14 20 26 32
   3: 03 09 15 21 27 33
   4: 04 10 16 22 28 34
   5: 05 11 17 23 29 35

typedef struct bitmask
{
  int w,h;
  BITW *bits;
} bitmask;

for (int y = 0; y < image->height; ++y)
{
    for (int x = 0; x < image->width; ++x)
    {
        if (imageCanCollideAt(image, x, y))  // Hur du nu får reda på vilka pixlar som kolliderar
        {
            bitmask_setbit(my_bitmask, x, y);
        }
    }
}

void gameobject::setHitTable()
{
	DWORD * indexColor = hge->Texture_Lock(mSprite->GetTexture(), true);
	int width = mSprite->GetWidth();
	for(int y = 0; y<mSprite->GetHeight(); ++y)
	{
		for (int x = 0;x<width;x++)
		{
			DWORD *color = &indexColor[x+y*width];
			if((GETA(*color) != 0))
			{
				bitmask_setbit(mHitTable, x,y);
			}
		}
 
	}
 
	hge->Texture_Unlock(mSprite->GetTexture());
}

bool gameobject::isCollidingPixel(gameobject* collObj)
{
	if(isCollidingBox(collObj))
		return bitmask_overlap(mHitTable, collObj->getCollisionTable(),
mPosX -  collObj->getPosX(), mPosY -collObj->getPosY()) != 0; 
	else 
		return false;
}

/* Returns nonzero if the masks overlap with the given offset. */

The overlap tests uses the following offsets (which may be negative):
 
 *
 *   +----+----------..
 *   |A   | yoffset   
 *   |  +-+----------..
 *   +--|B        
 *   |xoffset      
 *   |  |
 *   :  :

#include "bitmask.h"
#include <cmath>
#include <cstdio>
 
// Ritar ut två maskor på varandra '1' är första masken, '2' den andra
// och 'X' är där de korsar.
void printmasks(bitmask *m1, bitmask *m2, int offX, int offY)
{
    for (int y = 0; y < m1->h && y < m2->h; y++)
    {
        for (int x = 0; x < m1->w && y < m2->w; x++)
        {
            bool b1 = bitmask_getbit(m1, x, y) != 0;
            bool b2 = false;
            if (x >= offX && y >= offY)
                b2 = bitmask_getbit(m2, x-offX, y-offY) != 0;
 
            if (b1 && b2)
                printf("X");
            else if (b1)
                printf("1");
            else if (b2)
                printf("2");
            else
                printf(".");
        }
        printf("\n");
    }
}
 
void printtest(bitmask *mask, int offX, int offY)
{
 
    printmasks(mask, mask, offX, offY);
    printf("Collide: %s\n",
            bitmask_overlap(mask, mask, offX, offY) ? "true" : "false");
}
 
int main()
{
    const int width = 20;
    const int height = 20;
 
    bitmask *mask = bitmask_create(width, height);
 
    // Gör en cirkel-maska
    for (float x = 0; x < width; x+=.1)
    {
        const int y = sqrt(width*width/4-4-(x-width/2)*(x-width/2));
        bitmask_setbit(mask, x, width/2+y);
        bitmask_setbit(mask, x, width/2-y);
    }
 
    // Skriv ut tre test-fall
    printtest(mask, 10, 10);
    printtest(mask, 12, 12);
    printtest(mask, 14, 14);
 
    bitmask_free(mask);
    return 0;
}

extern "C"
{
 #include "bitmask.h"
}