mrrgbaimage.cpp

Games programming all in one code chapter 20

 /* 'mrRGBAImage.cpp' */

 /* Complement header file */
#include "mrRGBAImage.h"

 /* Default constructor */
mrRGBAImage::mrRGBAImage (void)
{
 m_iWidth        = 0;
 m_iHeight       = 0;
 m_piImageBuffer = NULL;
}

 /* Default destructor */
mrRGBAImage::~mrRGBAImage (void)
{
 m_iWidth        = 0;
 m_iHeight       = 0;

  /* If memory was allocated, release it */
 if (NULL != m_piImageBuffer)
 {
  delete [] m_piImageBuffer;
  m_piImageBuffer = NULL;
 }
}

 /* Copy this image to another */
mrRGBAImage & mrRGBAImage::operator = (mrRGBAImage & rkImage)
{
 m_iWidth  = rkImage.GetWidth ();
 m_iHeight = rkImage.GetHeight ();
 SetImageBuffer (rkImage.GetImageBuffer ());

  /* Return an instance of this class */
 return * this;
}

 /* Load image from a windows bitmap file */
mrError32 mrRGBAImage::LoadFromBitmap (LPSTR lpszFilename)
{
 fstream      kBitmap;

 kBitmap.open (lpszFilename, ios::binary | ios::in);

	if (kBitmap.is_open ())
	{
		mrUInt16     iType;
		kBitmap.read ((char *) &iType, sizeof (mrUInt16));

			/* Get bitmap signature */
		if (0x4D42 != iType)
		{
			return mrErrorNotBitmapFile;
		}

			/* Ignore eight bytes */
		kBitmap.seekg (8, ios::cur);

			/* Get the position of the start of the bitmap buffer */
		mrUInt32     iStartBuffer;
		kBitmap.read ((char *) &iStartBuffer, sizeof (mrUInt32));

			/* Ignore four bytes */
		kBitmap.seekg (4, ios::cur);

			/* Get width and height of bitmap */
		kBitmap.read ((char *) &m_iWidth, sizeof (mrUInt32));
		kBitmap.read ((char *) &m_iHeight, sizeof (mrUInt32));
 
			/* Ignore two bytes */
		kBitmap.seekg (2, ios::cur);

			/* Get bit count */
		mrUInt16     iBitCount;
		kBitmap.read ((char *) &iBitCount, sizeof (mrUInt16));

			/* If not 24 mode not supported, return error */
		if (iBitCount != 24)
		{
			return mrErrorBitmapNotSupported;
		}
			/* Get compression */
		mrUInt32     iCompression;
		kBitmap.read ((char *) &iCompression, sizeof (mrUInt32));

			/* If compressed not supported, return error */
		if (iCompression != BI_RGB)
		{
			return mrErrorBitmapNotSupported;
		}
 
			/* Move to bitmap buffer */
		kBitmap.seekg (iStartBuffer, ios::beg);

			/* Read image buffer from file */
		mrUInt8 * piBuffer = new mrUInt8 [m_iWidth * m_iHeight * 3];
		kBitmap.read ((char *) piBuffer, m_iWidth * m_iHeight * 3 * 
																sizeof (mrUInt8));

			/* Allocate memory for image buffer */
		if (NULL != m_piImageBuffer)
		{
			delete [] m_piImageBuffer;
		}
		m_piImageBuffer = new mrUInt32 [m_iWidth * m_iHeight];

			/* Get each pixel color components and fill image buffer */ 
		mrUInt32 iX, iY;

		for (iY = 0; iY < m_iHeight; iY++)
		{
			for (iX = 0; iX < m_iWidth; iX++)
			{
					/* Needs to be flipped */
				if (m_iHeight > 0)
				{
						m_piImageBuffer [iX + (m_iHeight - 1 - iY) * (m_iWidth)] = 255 |
												(piBuffer [(iX + iY * (m_iWidth)) * 3 + 0] << 8) |
												(piBuffer [(iX + iY * (m_iWidth)) * 3 + 1] << 16) |
												(piBuffer [(iX + iY * (m_iWidth)) * 3 + 2] << 24);
				}
					/* Doesn't need to be flipped */
				else
				{
					m_piImageBuffer [iX + (iY * m_iWidth)] =  255 |
												(piBuffer [iX + (iY * m_iWidth) * 3 + 0] << 8) |
												(piBuffer [iX + (iY * m_iWidth) * 3 + 1] << 16) |
												(piBuffer [iX + (iY * m_iWidth) * 3 + 2] << 24);
				}
			}
		}

			/* Close file, release memory and return no error */
		if (NULL != piBuffer)
		{
			delete [] piBuffer;
		}

		kBitmap.close ();
	}

 return mrNoError;
}

 /* Load image from TARGA file */
mrError32 mrRGBAImage::LoadFromTarga (LPSTR lpszFilename)
{
 fstream      kTarga;

 kTarga.open (lpszFilename, ios::binary | ios::in);
	
	if (kTarga.is_open ())
	{
			/* Read field description size */
		mrUInt8      iFieldDescSize;
		kTarga.read ((char *) &iFieldDescSize, sizeof (mrUInt8));

			/* Ignore one byte */
		kTarga.seekg (1, ios::cur);

			/* Read image color code */
		mrUInt8      iImageCode;
		kTarga.read ((char *) &iImageCode, sizeof (mrUInt8));

		if (2 != iImageCode)
		{
			return mrErrorTargaNotSupported;
		}

			/* Ignore two bytes */
		kTarga.seekg (2, ios::cur);

			/* Read color map */
		mrUInt16      iMapLength;
		kTarga.read ((char *) &iMapLength, sizeof (mrUInt16));

			/* Ignore one byte */
		kTarga.seekg (1, ios::cur);

			/* Read image start positions */
		mrUInt16      iXStart;
		kTarga.read ((char *) &iXStart, sizeof (mrUInt16));
		mrUInt16      iYStart;
		kTarga.read ((char *) &iYStart, sizeof (mrUInt16));

			/* Read image size */
		mrUInt16      iWidth;
		kTarga.read ((char *) &iWidth, sizeof (mrUInt16));
		mrUInt16      iHeight;
		kTarga.read ((char *) &iHeight, sizeof (mrUInt16));

		m_iWidth  = iWidth;
		m_iHeight = iHeight;

			/* Read image bit depth */
		mrUInt8      iImageBits;

		kTarga.read ((char *) &iImageBits, sizeof (mrUInt8));
		if (32 != iImageBits)
		{
			return mrErrorTargaNotSupported;
		}

			/* Read image description */
		mrUInt8      iImageDesc;
		kTarga.read ((char *) &iImageDesc, sizeof (mrUInt8));
 
			/* Ignore field description */
		kTarga.seekg (iFieldDescSize, ios::cur);
			/* Ignore color map */
		kTarga.seekg (iMapLength * 4, ios::cur);
 
			/* Read image buffer from file */
		mrUInt32 * piBuffer = new mrUInt32 [m_iWidth * m_iHeight];
		kTarga.read ((char *) piBuffer, m_iWidth * m_iHeight * 4 * 
																sizeof (mrUInt8));

			/* Allocate memory for image buffer */
		if (NULL != m_piImageBuffer)
		{
			delete [] m_piImageBuffer;
		}
		m_piImageBuffer = new mrUInt32 [m_iWidth * m_iHeight];

		mrUInt8  iRed, iGreen, iBlue, iAlpha;
		mrUInt32 iColor;

			/* Get each pixel color components and fill image buffer */ 
		mrUInt32 iX, iY;

		for (iY = 0; iY < m_iHeight; iY++)
		{
			for (iX = 0; iX < m_iWidth; iX++)
			{
					/* Doens't need to be flipped */
				if ((iImageDesc & 1) << 4)
				{
						/* Get color components */
					iColor = piBuffer [iX + (iY * m_iWidth)];

					iAlpha = (mrUInt8)((iColor & 0xFF000000) >> 24);
					iRed   = (mrUInt8)((iColor & 0x00FF0000) >> 16);
					iGreen = (mrUInt8)((iColor & 0x0000FF00) >> 8);
					iBlue  = (mrUInt8)((iColor & 0x000000FF));

						/* Copy flipped position */
					m_piImageBuffer [iX + (iY * m_iWidth)] = 
												iAlpha << 0 | iBlue << 8 | iGreen << 16 | iRed << 24;
				}
					/* Needs to be flipped */
				else
				{
						/* Get color components */
					iColor = piBuffer [iX + (iY * m_iWidth)];

					iAlpha = (mrUInt8)((iColor & 0xFF000000) >> 24);
					iRed   = (mrUInt8)((iColor & 0x00FF0000) >> 16);
					iGreen = (mrUInt8)((iColor & 0x0000FF00) >> 8);
					iBlue  = (mrUInt8)((iColor & 0x000000FF));

						/* Copy position */
					m_piImageBuffer [iX + (m_iHeight - 1 - iY) * (m_iWidth)] = 
												iAlpha << 0 | iBlue << 8 | iGreen << 16 | iRed << 24;
				}
			}
		}

			/* Close file, release memory and return no error */
		if (NULL != piBuffer)
		{
			delete [] piBuffer;
		}

		kTarga.close ();
		}

 return mrNoError;

}


 /* Set image color key for rendering */
void mrRGBAImage::SetColorKey (mrUInt8 iRed, mrUInt8 iGreen, 
                               mrUInt8 iBlue)
{
  /* Get each pixel color components and set color key */ 
 mrUInt32 iX, iY;
 mrUInt8 iOriRed, iOriGreen, iOriBlue;

 for (iY = 0; iY < m_iHeight; iY++)
 {
  for (iX = 0; iX < m_iWidth; iX++)
  {
   iOriRed   = (mrUInt8)((m_piImageBuffer [iX + (iY * m_iWidth)] 
                         & 0xFF000000) >> 24);
   iOriGreen = (mrUInt8)((m_piImageBuffer [iX + (iY * m_iWidth)] 
                         & 0x00FF0000) >> 16);
   iOriBlue  = (mrUInt8)((m_piImageBuffer [iX + (iY * m_iWidth)] 
                         & 0x0000FF00) >> 8);

    /* If color matches, set alpha to 0 */
   if ( (iOriRed == iRed) && (iOriGreen == iGreen) && (iOriBlue == iBlue))
   {
    m_piImageBuffer [iX + (iY * m_iWidth)] = iOriRed   << 24 | 
                                             iOriGreen << 16 | 
                                             iOriBlue  << 8  | 
																																													0;
   }
  }
 }
}

 /* Set image width */
void mrRGBAImage::SetWidth (mrUInt32 iWidth)
{
 m_iWidth = iWidth;
}

 /* Set image height */
void mrRGBAImage::SetHeight (mrUInt32 iHeight)
{
 m_iHeight = iHeight;
}

 /* Set color at given position */
void mrRGBAImage::SetColor (mrUInt32 iX, mrUInt32 iY, mrUInt8 iRed, 
																												mrUInt8 iGreen, mrUInt8 iBlue, 
																												mrUInt8 iAlpha)
{
	mrUInt32 iColor;
	iColor = D3DCOLOR_RGBA (iRed, iGreen, iBlue, iAlpha);

 m_piImageBuffer [iX + (iY * m_iWidth - 1)] = iColor;
}

 /* Set the image buffer */
void mrRGBAImage::SetImageBuffer (mrUInt32 * pImage)
{
 if (NULL != m_piImageBuffer)
 {
  delete [] m_piImageBuffer;
 }
 m_piImageBuffer = new mrUInt32 [m_iWidth * m_iHeight];

 memcpy (m_piImageBuffer, pImage, 
         sizeof (mrUInt32) * m_iWidth * m_iHeight);
}

 /* Returns image width */
mrUInt32 mrRGBAImage::GetWidth (void)
{
 return m_iWidth;
}

 /* Returns image height */
mrUInt32 mrRGBAImage::GetHeight (void)
{
 return m_iHeight;
}

 /* Returns image color at a point */
mrUInt32 mrRGBAImage::GetColor (mrUInt32 iX, mrUInt32 iY)
{
 return m_piImageBuffer [iX + iY * m_iWidth];
}

 /* Returns image buffer */
mrUInt32 * mrRGBAImage::GetImageBuffer (void)
{
 return m_piImageBuffer;
}