140 lines
4.0 KiB
C++
140 lines
4.0 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $Header: $
|
|
// $NoKeywords: $
|
|
//===========================================================================//
|
|
|
|
#ifndef BITMAP_H
|
|
#define BITMAP_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "Color.h"
|
|
#include "bitmap/imageformat.h"
|
|
#include "dbg.h"
|
|
|
|
class CUtlBuffer;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A Bitmap
|
|
//-----------------------------------------------------------------------------
|
|
struct Bitmap_t {
|
|
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;
|
|
};
|
|
|
|
inline void Bitmap_t::Reset() {
|
|
m_nWidth = 0;
|
|
m_nHeight = 0;
|
|
m_ImageFormat = IMAGE_FORMAT_UNKNOWN;
|
|
m_pBits = NULL;
|
|
m_nPixelSize = 0;
|
|
m_bOwnsBuffer = false;
|
|
m_nStride = 0;
|
|
}
|
|
|
|
inline unsigned char *Bitmap_t::GetPixel(int x, int y) {
|
|
if (!m_pBits) return NULL;
|
|
|
|
return m_pBits + (y * m_nStride) + x * m_nPixelSize;
|
|
}
|
|
|
|
inline const unsigned char *Bitmap_t::GetPixel(int x, int y) const {
|
|
if (!m_pBits) return NULL;
|
|
|
|
return m_pBits + (y * m_nStride) + x * m_nPixelSize;
|
|
}
|
|
|
|
#endif // BITMAP_H
|