Sorry your browser is not supported!

D3DCOLOR readPixel(LPDIRECT3DTEXTURE9 pTexture, UINT x, UINT y)
{
	
   // Lock the texture:
   D3DLOCKED_RECT rect;
   HRESULT hResult = pTexture->LockRect(0, &rect, NULL, D3DLOCK_READONLY);
   if(FAILED(hResult))
   {
      // Failed to lock the texture, error
      return 0;
   }

   // Get the bits as a BYTE*
   const BYTE* pBits = (BYTE*)rect.pBits;

   // Seek to the correct pixel and read it
   DWORD nBytesPerPixel = 3;
   const DWORD* pPixel = (DWORD*)(pBits + y * rect.Pitch + x*nBytesPerPixel);
   DWORD dwPixel = *pPixel;
   

   // Unlock the texture
   pTexture->UnlockRect(0);

   // Return the pixel
   return dwPixel;
}

bool pixelCollision(int spriteOne, int spriteTwo)
{
	vector<int> spriteOneVect;
	vector<int> spriteTwoVect;


	/*---------------------------------------------------------------------------*/
	//                         Sprite Masking                                    //
	//                                                                           //
	/*---------------------------------------------------------------------------*/
	for(int y = 0; y < dbSpriteHeight(spriteOne); y++)
	{
		for(int x = 0; x < dbSpriteWidth(spriteOne); x++)
		{
			if(readPixel(dbGetImagePointer(spriteOne),x,y) == D3DCOLOR_XRGB(255,0,255))
			{
				spriteOneVect.push_back(0);
			}
			else
			{
				spriteOneVect.push_back(1);
			}
		}
	}
	
	for(int y = 0; y < dbSpriteHeight(spriteTwo); y++)
	{
		for(int x = 0; x < dbSpriteWidth(spriteTwo); x++)
		{
			if(readPixel(dbGetImagePointer(spriteTwo),x,y) == D3DCOLOR_XRGB(255,0,255))
			{
				spriteTwoVect.push_back(0);
			}
			else
			{
				spriteTwoVect.push_back(1);
			}
		}
	}
	
    /*---------------------------------------------------------------------------*/
	//                         Collision Overlap                                 //
	//                                                                           //
	/*---------------------------------------------------------------------------*/
	//find min and max coodinates of collision
	int minX;
	int maxX;
	int minY;
	int maxY;
	if (dbSpriteX(spriteOne) <= dbSpriteX(spriteTwo))
	{
		minX = dbSpriteX(spriteTwo);
	}
	else
	{
		minX = dbSpriteX(spriteOne);
	}
	if(dbSpriteX(spriteOne) + dbSpriteWidth(spriteOne) <= dbSpriteX(spriteTwo) + dbSpriteWidth(spriteTwo))
	{
		maxX = dbSpriteX(spriteOne) + dbSpriteWidth(spriteOne);
	}
	else
	{
		maxX = dbSpriteX(spriteTwo) + dbSpriteWidth(spriteTwo);
	}
	if(dbSpriteY(spriteOne) <= dbSpriteY(spriteTwo))
	{
		minY = dbSpriteY(spriteTwo);
	}
	else
	{
		minY = dbSpriteY(spriteOne);
	}
	if(dbSpriteY(spriteOne) + dbSpriteHeight(spriteOne) <= dbSpriteY(spriteTwo) + dbSpriteHeight(spriteTwo))
	{
		maxY = dbSpriteY(spriteOne) + dbSpriteHeight(spriteOne);
	}
	else
	{
		maxY = dbSpriteY(spriteTwo) + dbSpriteHeight(spriteTwo);
	}
	for(int currentY = minY; currentY < maxY; currentY++)
	{
		int sOneYAP = currentY - dbSpriteY(spriteOne)+1;
		int sTwoYAP = currentY - dbSpriteY(spriteTwo)+1;
		for(int currentX = minX; currentX < maxX; currentX++)
		{
			int sOneXAP = currentX - dbSpriteX(spriteOne)+1;
			int sTwoXAP = currentX - dbSpriteX(spriteTwo)+1;
			if(spriteOneVect[sOneXAP*sOneYAP] == spriteTwoVect[sTwoXAP*sTwoYAP] && spriteOneVect[sOneXAP*sOneYAP] == 1)
			{
				return true;
			}

		}
	}
	return false;
}

bool BuildSpriteMask(int s1, vector<int> &v)
{
  bool result = FALSE;

  LPDIRECT3DTEXTURE9 pTexture = dbGetImagePointer(s1);

  // Lock the texture:
  D3DLOCKED_RECT rect;
  HRESULT hResult = pTexture->LockRect(0, &rect, NULL, D3DLOCK_READONLY);
  if(FAILED(hResult))
  {
    // Failed to lock the texture, error
    return 0;
  }

  // Get the bits as a BYTE*
  const BYTE* pBits = (BYTE*)rect.pBits;

  // Seek to the correct pixel and read it
  DWORD nBytesPerPixel = 3;
  const DWORD* pPixel = 0;  // (DWORD*)(pBits + y * rect.Pitch + x*nBytesPerPixel);
  DWORD dwPixel = *pPixel;
 
  int sh = dbSpriteHeight(s1);
  int sw = dbSpriteWidth(s1);

  for(int y = 0; y < sh; y++)
  {
    for(int x = 0; x < sw; x++)
    {
      /* NOTE: I'm a little rusty on my math, but it should just be the same as before */
      pPixel = (DWORD*)(pBits + y * rect.Pitch + x*nBytesPerPixel);
      if( *pPixel == D3DCOLOR_XRGB(255,0,255))
      {
        v.push_back(0);
      }
      else
      {
        v.push_back(1);
      }
    }
  }

  // Unlock the texture
  pTexture->UnlockRect(0);

  return result;
}


bool PixelCollision( int s1, int s2 )
{

  /* 
    Load the Sprite1/Sprite2 variables into local memory so that we
    can avoid the extra overhead required for multiple calls to the
    related GDK calls. Functions are slower than memory reads, so
    we want to call them as few times as possible...
  */
  int s1X=dbSpriteX(s1);
  int s1y=dbSpriteY(s1);
  int s1w=dbSpriteWidth(s1);
  int s1h=dbSpriteHeight(s1);

  int s2x=dbSpriteX(s2);
  int s2y=dbSpriteY(s2);
  int s2w=dbSpriteWidth(s2);
  int s2h=dbSpriteHeight(s2);

  int s1x2 = s1x+s1w; 
  int s1y2 = s1y+s1h;

  int s2x2 = s2x+s2w;
  int s2y2 = s2y+s2h;

  /* Calculates the intersection rectangle between the two sprites */ 
  int minX=max(s1x, s2x);
  int maxX=min(s1x2, s2x2)
  int minY=max(s1y,s2y);
  int maxY=min(s1y2, s2y2)

  /* 
    if our instersection rect's Width is greater than the combined
    widths of both sprites, then no collision could have taken
    place since there would be at least one pixel between both
    sprites
  */
  if (maxX-minX > s1w+s2w)
    return false; 

  /* 
    Similarly, if our instersection rect's height is greater than
    the combined heights of both sprites, then no collision could 
    have taken place since there would be at least one pixel between 
    both sprites
  */
  if (maxY-minY > s1h+s2h)
    return false;

  /* 
    Now we know that there is still a potential for collision. In
    order to find out for sure, we have to test every pixel between
    both sprites that fall within the intersection rect - we can
    ignore all of the others.
  */

  /*
    First, we have to build the sprite masks of the images. To
    gain a performance boost, we wait until this point to actually
    build them because there was possibilities of no collisions
    that could be eliminated before wasting time reading video
    memory. Alas, we can't put it off any longer...

    Note: Ideally, the sprite masks would be built just once and
    stored in memory so that repeated calls to BuildSpriteMask()
    wouldn't be necessary...
  */
  vector<int> spriteOneVect;
  vector<int> spriteTwoVect;

  /* 
    We place a single call to BuildSpriteMask() for each sprite
    so that we only have to lock the video memory once instead of
    once for each pixel...
  */
  BuildSpriteMask( spriteOneVect, s1 );
  BuildSpriteMask( spriteTwoVect, s2 );

  /* Now that the sprite masks are built, let's test them */  
  for(int currentY = minY; currentY < maxY; currentY++)  
  {
    int sOneYAP = currentY - s1y+1;
    int sTwoYAP = currentY - s2y+1;
    for(int currentX = minX; currentX < maxX; currentX++)
    {
      int sOneXAP = currentX - s1x+1;
      int sTwoXAP = currentX - s2x+1;
      if(spriteOneVect[sOneXAP*sOneYAP] && spriteTwoVect[sTwoXAP*sTwoYAP])
      {
        return true;
      }
    } 
  }

  return false;
}

bool PixelCollision( int s1, int s2 )
{

  /* 
    Load the Sprite1/Sprite2 variables into local memory so that we
    can avoid the extra overhead required for multiple calls to the
    related GDK calls. Functions are slower than memory reads, so
    we want to call them as few times as possible...
  */
  int s1x=dbSpriteX(s1);
  int s1y=dbSpriteY(s1);
  int s1w=dbSpriteWidth(s1);
  int s1h=dbSpriteHeight(s1);

  int s2x=dbSpriteX(s2);
  int s2y=dbSpriteY(s2);
  int s2w=dbSpriteWidth(s2);
  int s2h=dbSpriteHeight(s2);

  int s1x2 = s1x+s1w; 
  int s1y2 = s1y+s1h;

  int s2x2 = s2x+s2w;
  int s2y2 = s2y+s2h;

  /* Calculates the intersection rectangle between the two sprites */ 
  int minX=max(s1x, s2x);
  int maxX=min(s1x2, s2x2);
  int minY=max(s1y,s2y);
  int maxY=min(s1y2, s2y2);

  /* 
    if our instersection rect's Width is greater than the combined
    widths of both sprites, then no collision could have taken
    place since there would be at least one pixel between both
    sprites
  */
  if (s1x2 < s2x || s2x2 < s1x)
    return false; 

  /* 
    Similarly, if our instersection rect's height is greater than
    the combined heights of both sprites, then no collision could 
    have taken place since there would be at least one pixel between 
    both sprites
  */
  if (s1y2 < s2y || s2y2 < s1y)
    return false;

  /* 
    Now we know that there is still a potential for collision. In
    order to find out for sure, we have to test every pixel between
    both sprites that fall within the intersection rect - we can
    ignore all of the others.
  */

  /*
    First, we have to build the sprite masks of the images. To
    gain a performance boost, we wait until this point to actually
    build them because there was possibilities of no collisions
    that could be eliminated before wasting time reading video
    memory. Alas, we can't put it off any longer...

    Note: Ideally, the sprite masks would be built just once and
    stored in memory so that repeated calls to BuildSpriteMask()
    wouldn't be necessary...
  */
  vector<int> spriteOneVect;
  vector<int> spriteTwoVect;

  /* 
    We place a single call to BuildSpriteMask() for each sprite
    so that we only have to lock the video memory once instead of
    once for each pixel...
  */
  BuildSpriteMask(  s1, spriteOneVect);
  BuildSpriteMask(  s2, spriteTwoVect);

  /* Now that the sprite masks are built, let's test them */  
  for(int currentY = minY; currentY < maxY; currentY++)  
  {
    int sOneYAP = currentY - s1y;
    int sTwoYAP = currentY - s2y;
    for(int currentX = minX; currentX < maxX; currentX++)
    {
      int sOneXAP = currentX - s1x;
      int sTwoXAP = currentX - s2x;
      if(spriteOneVect[sOneXAP*sOneYAP] == 1 && spriteTwoVect[sTwoXAP*sTwoYAP] == 1)
      {
        return true;
      }
    } 
  }

  return false;
}