jedi-academy/codemp/qcommon/cm_draw.h

251 lines
8.4 KiB
C
Raw Normal View History

2013-04-19 02:52:48 +00:00
///////////////////////////////////////////////////////////////////////////////
// CDraw32 Class Interface
//
// Basic drawing routines for 32-bit per pixel buffer
///////////////////////////////////////////////////////////////////////////////
#if !defined(CM_DRAW_H_INC)
#define CM_DRAW_H_INC
#ifndef __linux__
//#include <windows.h>
#include "../qcommon/platform.h"
#endif
// calc offset into image array for a pixel at (x,y)
#define PIXPOS(x,y,stride) (((y)*(stride))+(x))
#ifndef MIN
// handy macros
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define ABS(x) ((x)<0 ? -(x):(x))
#define SIGN(x) (((x) < 0) ? -1 : (((x) > 0) ? 1 : 0))
#endif
#ifndef CLAMP
#define SWAP(a,b) { a^=b; b^=a; a^=b; }
#define SQR(a) ((a)*(a))
#define CLAMP(v,l,h) ((v)<(l) ? (l) : (v) > (h) ? (h) : (v))
#define LERP(t, a, b) (((b)-(a))*(t) + (a))
// round a to nearest integer towards 0
#define FLOOR(a) ((a)>0 ? (int)(a) : -(int)(-a))
// round a to nearest integer away from 0
#define CEILING(a) \
((a)==(int)(a) ? (a) : (a)>0 ? 1+(int)(a) : -(1+(int)(-a)))
#include <stdlib.h>
#endif
class CPixel32
{
public:
byte r;
byte g;
byte b;
byte a;
CPixel32(byte R = 0, byte G = 0, byte B = 0, byte A = 255) : r(R), g(G), b(B), a(A) {}
CPixel32(long l) {r = (l >> 24) & 0xff; g = (l >> 16) & 0xff; b = (l >> 8) & 0xff; a = l & 0xff;};
~CPixel32()
{}
};
#define PIX32_SIZE sizeof(CPixel32)
// standard image operator macros
#define IMAGE_SIZE(width,height) ((width)*(height)*(PIX32_SIZE))
inline CPixel32 AVE_PIX (CPixel32 x, CPixel32 y)
{ CPixel32 t; t.r = (byte)(((int)x.r + (int)y.r)>>1);
t.g = (byte)(((int)x.g + (int)y.g)>>1);
t.b = (byte)(((int)x.b + (int)y.b)>>1);
t.a = (byte)(((int)x.a + (int)y.a)>>1); return t;}
inline CPixel32 ALPHA_PIX (CPixel32 x, CPixel32 y, long alpha, long inv_alpha)
{ CPixel32 t; t.r = (byte)((x.r*alpha + y.r*inv_alpha)>>8);
t.g = (byte)((x.g*alpha + y.g*inv_alpha)>>8);
t.b = (byte)((x.b*alpha + y.b*inv_alpha)>>8);
// t.a = (byte)((x.a*alpha + y.a*inv_alpha)>>8); return t;}
t.a = y.a; return t;}
inline CPixel32 LIGHT_PIX (CPixel32 p, long light)
{ CPixel32 t;
t.r = (byte)CLAMP(((p.r * light)>>10) + p.r, 0, 255);
t.g = (byte)CLAMP(((p.g * light)>>10) + p.g, 0, 255);
t.b = (byte)CLAMP(((p.b * light)>>10) + p.b, 0, 255);
t.a = p.a; return t;}
// Colors are 32-bit RGBA
// draw class
class CDraw32
{
public: // static drawing context - static so we set only ONCE for many draw calls
static CPixel32* buffer; // pointer to pixel buffer (one active)
static long buf_width; // size of buffer
static long buf_height; // size of buffer
static long stride; // stride of buffer in pixels
static long clip_min_x; // clip bounds
static long clip_min_y; // clip bounds
static long clip_max_x; // clip bounds
static long clip_max_y; // clip bounds
static long* row_off; // Table for quick Y calculations
private:
void BlitClip(long& dstX, long& dstY,
long& width, long& height,
long& srcX, long& srcY);
protected:
public:
CDraw32(); // constructor
~CDraw32(); // destructor
// set the rect to clip drawing functions to
static void SetClip(long min_x, long min_y,long max_x, long max_y)
{clip_min_x = MAX(min_x,0); clip_max_x = MIN(max_x,buf_width-1);
clip_min_y = MAX(min_y,0); clip_max_y = MIN(max_y,buf_height-1);}
static void GetClip(long& min_x, long& min_y,long& max_x, long& max_y)
{min_x = clip_min_x; min_y = clip_min_y;
max_x = clip_max_x; max_y = clip_max_y; }
// set the buffer to use for drawing off-screen
static void SetBuffer(CPixel32* buf) {buffer = buf;};
// set the dimensions of the off-screen buffer
static bool SetBufferSize(long width,long height,long stride_len);
// call this to free the table for quick y calcs before the program ends
static void CleanUp(void)
{if (row_off) delete [] row_off; row_off=NULL; buf_width=0; buf_height=0;}
// set a pixel at (x,y) to color (no clipping)
void PutPixNC(long x, long y, CPixel32 color)
{buffer[row_off[y] + x] = color;}
// set a pixel at (x,y) to color
void PutPix(long x, long y, CPixel32 color)
{ // clipping check
if (x < clip_min_x || x > clip_max_x ||
y < clip_min_y || y > clip_max_y)
return;
PutPixNC(x,y,color);
}
// get the color of a pixel at (x,y)
CPixel32 GetPix(long x, long y)
{return buffer[row_off[y] + x];}
// set a pixel at (x,y) with 50% translucency (no clip)
void PutPixAveNC(long x, long y, CPixel32 color)
{ PutPixNC(x,y,AVE_PIX(GetPix(x, y), color)); }
// set a pixel at (x,y) with 50% translucency
void PutPixAve(long x, long y, CPixel32 color)
{ // clipping check
if (x < clip_min_x || x > clip_max_x ||
y < clip_min_y || y > clip_max_y)
return;
PutPixNC(x,y,AVE_PIX(GetPix(x, y), color));
}
// set a pixel at (x,y) with translucency level (no clip)
void PutPixAlphaNC(long x, long y, CPixel32 color)
{ PutPixNC(x,y,ALPHA_PIX(color, GetPix(x, y), color.a, 256-color.a));}
// set a pixel at (x,y) with translucency level
void PutPixAlpha(long x, long y, CPixel32 color)
{ // clipping check
if (x < clip_min_x || x > clip_max_x ||
y < clip_min_y || y > clip_max_y)
return;
PutPixNC(x,y,ALPHA_PIX(color, GetPix(x, y), color.a, 256-color.a));}
// clear screen buffer to color from start to end line
void ClearLines(CPixel32 color,long start,long end);
// clear screen buffer to color provided
void ClearBuffer(CPixel32 color)
{ClearLines(color,0,buf_height-1);};
// fill buffer alpha from start to end line
void SetAlphaLines(byte alpha,long start,long end);
// clear screen buffer to color provided
void SetAlphaBuffer(byte alpha)
{SetAlphaLines(alpha,0,buf_height-1);};
// clip a line segment to the clip rect
bool ClipLine(long& x1, long& y1, long& x2, long& y2);
// draw a solid colored line, no clipping
void DrawLineNC(long x1, long y1, long x2, long y2, CPixel32 color);
// draw a solid color line
void DrawLine(long x1, long y1, long x2, long y2, CPixel32 color)
{ if (ClipLine(x1,y1,x2,y2)) DrawLineNC(x1,y1,x2,y2,color);}
void DrawLineAveNC(long x1, long y1, long x2, long y2, CPixel32 color);
// draw a translucent solid color line
void DrawLineAve(long x1, long y1, long x2, long y2, CPixel32 color)
{ if (ClipLine(x1,y1,x2,y2)) DrawLineAveNC(x1,y1,x2,y2,color);}
// draw an anti-aliased line, no clipping
void DrawLineAANC(long x0, long y0, long x1, long y1, CPixel32 color);
// draw an anti-aliased line
void DrawLineAA(long x1, long y1, long x2, long y2, CPixel32 color)
{ if (ClipLine(x1,y1,x2,y2)) DrawLineAANC(x1,y1,x2,y2,color);}
// draw a filled rectangle, no clipping
void DrawRectNC(long ulx, long uly, long width, long height,CPixel32 color);
// draw a filled rectangle
void DrawRect(long ulx, long uly, long width, long height, CPixel32 color);
// draw a filled rectangle
void DrawRectAve(long ulx, long uly, long width, long height,CPixel32 color);
// draw a box (unfilled rectangle) no clip
void DrawBoxNC(long ulx, long uly, long width, long height, CPixel32 color);
// draw a box (unfilled rectangle)
void DrawBox(long ulx, long uly, long width, long height, CPixel32 color);
// draw a box (unfilled rectangle)
void DrawBoxAve(long ulx, long uly, long width, long height, CPixel32 color);
// draw a circle with fill and edge colors
void DrawCircle(long xc, long yc, long r, CPixel32 edge, CPixel32 fill);
// draw a circle with fill and edge colors averaged with dest
void DrawCircleAve(long xc, long yc, long r, CPixel32 edge, CPixel32 fill);
// draw a polygon (complex) with fill and edge colors
void DrawPolygon(long nvert, POINT *point, CPixel32 edge, CPixel32 fill);
// simple blit function
void BlitNC(long dstX, long dstY, long dstWidth, long dstHeight,
CPixel32* srcImage, long srcX, long srcY, long srcStride);
void Blit(long dstX, long dstY, long dstWidth, long dstHeight,
CPixel32* srcImage, long srcX, long srcY, long srcStride);
// blit image times color
void BlitColor(long dstX, long dstY, long dstWidth, long dstHeight,
CPixel32* srcImage, long srcX, long srcY, long srcStride, CPixel32 color);
void Emboss(long dstX, long dstY, long width, long height,
CPixel32* clrImage, long clrX, long clrY, long clrStride);
};
///////////////////////////////////////////////////////////////////////////////
#endif