{

Bitmap_t() { Reset(); }

~Bitmap_t() { Clear(); }

//

// Accessors

//

inline int Width() const { return m_nWidth; }

inline int Height() const { return m_nHeight; }

inline ImageFormat Format() const { return m_ImageFormat; }

inline unsigned char *GetBits() const { return m_pBits; }

inline int Stride() const { return m_nStride; }

inline bool GetOwnsBuffer() const { return m_bOwnsBuffer; }

/// Allocate the buffer. Discards existing data, freeing it if we own it

void Init( int nWidth, int nHeight, ImageFormat imageFormat, int nStride = 0 );

/// Set the bitmap to the specified buffer. Any existing data is discarded/freed

/// as appropriate.

void SetBuffer( int nWidth, int nHeight, ImageFormat imageFormat, unsigned char *pBits, bool bAssumeOwnership, int nStride = 0 );

/// Sets / releases ownershp of the buffer. This does not otherwise alter the

/// state of the bitmap.

void SetOwnsBuffer( bool bOwnsBuffer )

{

Assert( m_pBits );

m_bOwnsBuffer = bOwnsBuffer;

}

/// Free up all memory and reset to default state

void Clear();

/// Return true if we have a valid size and buffer

bool IsValid() const;

/// Get pointer to raw pixel data.

unsigned char *GetPixel( int x, int y );

const unsigned char *GetPixel( int x, int y ) const;

/// Get pixel value at specified coordinates

Color GetColor( int x, int y ) const;

/// Set pixel value at specified coordinates

void SetColor( int x, int y, Color c );

/// Set this bitmap to be a logical copy of the specified

/// bitmap. No memory is allocated or copied, just copying

/// some pointers. We can also optionally transfer ownership

/// of the buffer.

void MakeLogicalCopyOf( Bitmap_t &src, bool bTransferBufferOwnership = false );

/// Set this bitmap to be a cropped rectangle from the given bitmap.

/// The source pointer can be NULL or point to this, which means to do

/// the crop in place.

void Crop( int x0, int y0, int nWidth, int nHeight, const Bitmap_t *pImgSource = NULL );

/// Blit a rectangle of pixel data into this image.

void SetPixelData( const Bitmap_t &src, int nSrcX1, int nSrcY1, int nCopySizeX, int nCopySizeY, int nDestX1, int nDestY1 );

/// Blit the entire source image into this image, at the specified offset.

/// the rectangle is clipped if necessary

void SetPixelData( const Bitmap_t &src, int nDestX1 = 0, int nDestY1 = 0 );

private:

void Reset();

/// Dimensions

int m_nWidth;

int m_nHeight;

/// Size, in bytes, of one pixel

int m_nPixelSize;

/// Image row stride, in bytes

int m_nStride;

// Do we own this buffer?

bool m_bOwnsBuffer;

/// Pixel format

ImageFormat m_ImageFormat;

/// Bitmap data. Must be allocated with malloc/free. Don't use

/// new/delete

unsigned char *m_pBits;

{

m_nWidth = 0;

m_nHeight = 0;

m_ImageFormat = IMAGE_FORMAT_UNKNOWN;

m_pBits = NULL;

m_nPixelSize = 0;

m_bOwnsBuffer = false;

m_nStride = 0;