/****************************************************************************
*
*						MegaGraph Graphics Library
*
*                   Copyright (C) 1996 SciTech Software.
*							All rights reserved.
*
* Filename:		$Workfile:   mgraph.h  $
* Version:		$Revision:   1.29  $
*
* Language:		ANSI C
* Environment:	IBM PC (MS DOS)
*
* Description:	Header file for the MegaGraph Graphics Library. You can
*				defined one of the following to specify which MGL API you
*				wish to use.
*
*					MGL_LITE	- Compile for the MGL/Lite API
*					MGL_PRO		- Compile for the MGL/Pro API
*					MGL_FIX3D	- Compile for the MGL/3D API (fixed point)
*					MGL_FLT3D	- Compile for the MGL/3D API (floating point)
*
*				If you do not define any of these, MGL_FIX3D will be defined
*				automatically for compatibility with older versions of the
*				MGL.
*
* $Date:   11 Mar 1997 16:46:42  $ $Author:   KendallB  $
*
****************************************************************************/

#ifndef	__MGRAPH_H
#define	__MGRAPH_H

#include <stdio.h>

#ifndef	__DEBUG_H
#include "debug.h"
#endif

#if	!defined(MGL_LITE) && !defined(MGL_PRO) && !defined(MGL_FIX3D) \
	&& !defined(MGL_FLT3D)
#define	MGL_FIX3D
#endif

#if	defined(MGL_FIX3D) || defined(MGL_FLT3D)
#define	MGL_3D
#endif

/*---------------------- Macros and type definitions ----------------------*/

#pragma pack(1)				/* Pack structures to byte granularity		*/

/* Define the version number for the MGL release */

#define MGL_VERSION_STR     "3.1"

/* Define the calling conventions for all public MGL functions. If we
 * are compiling the MGL as a DLL, then all public functions are compiled
 * and exported with standard C calling conventions, otherwise we use
 * the default calling conventions provided by the compiler.
 *
 * Note that because Watcom C++ uses register based parameter passing
 * by default we also provide special DLL's for watcom that are compiled
 * with register parameter passing. This is necessary to work with all
 * the extra libraries provided as they are all compiled to call MGL
 * functions with arguments in registers whenever possible. You can still
 * use the standard DLL but if you do you will need to re-compile all
 * of the extra libraries with the MGL_DLL #define to change the calling
 * conventions for the MGL functions.
 */

#if		defined(MGL_DLL)
#define	MGLAPI	_EXPORT __cdecl
#else
#define	MGLAPI	_EXPORT _PUBAPI
#endif
#define	ASMAPI	_EXPORT __cdecl

/* Define a type for integers used in the library. For most environments
 * we simply define it as a normal integer (16 or 32 bits), however for
 * 16 bit Windows it is defined as a 32 bit integer as all the real code
 * lives in a 32 bit DLL that uses 32 bit integers.
 */

#ifndef	__M_INT_DEFINED
#if	defined(__WINDOWS16__)
typedef	long			m_int;
typedef unsigned long	m_uint;
#else
typedef int				m_int;
typedef	unsigned int	m_uint;
#endif
#define	__M_INT_DEFINED
#endif

/* Define the graphics subsystems available	*/

typedef enum
{
	grDETECT		= -1,	/* Auto detect the graphics subsystem		*/
	grNONE			= 0,	/* No graphics hardware detected			*/
	grVGA,					/* Standard VGA								*/
	grVESA,					/* VESA VBE compliant SuperVGA				*/
	grSVGA,					/* Unaccelerated SuperVGA					*/
	grACCEL,				/* Accelerated SuperVGA						*/
	grDDRAW,				/* Unaccelerated DirectDraw					*/
	grDDRAWACCEL,			/* Accelerated DirectDraw 					*/
	grDDRAW3D,				/* 3D Accelerated DirectDraw 				*/
	grMAXDRIVER,			/* Maximum driver number					*/
} MGL_driverType;

/* Graphics modes supported	- the only video modes supported by this
 * graphics library are those that support at least 16 colors per pixel.
 */

typedef enum
{
	/* 16 color VGA video modes */
	
	grVGA_320x200x16,
	grVGA_640x200x16,
	grVGA_640x350x16,
	grVGA_640x400x16,
	grVGA_640x480x16,
	grSVGA_800x600x16,
	
	/* 256 color VGA ModeX video modes */
	
	grVGAX_320x200x256,
	grVGAX_320x240x256,
	grVGAX_320x400x256,
	grVGAX_320x480x256,
	
	/* 256 color VGA video modes */
	
	grVGA_320x200x256,
	
	/* 256 color VGA/SuperVGA video modes */
	
	grSVGA_320x200x256,
	grSVGA_320x240x256,
	grSVGA_320x400x256,
	grSVGA_320x480x256,
	grSVGA_400x300x256,
	grSVGA_512x384x256,
	grSVGA_640x350x256,
	grSVGA_640x400x256,
	grSVGA_640x480x256,
	grSVGA_800x600x256,
	grSVGA_1024x768x256,
	grSVGA_1152x864x256,
	grSVGA_1280x960x256,
	grSVGA_1280x1024x256,
	grSVGA_1600x1200x256,
	
	/* 32,768 color Super VGA video modes */
	
	grSVGA_320x200x32k,
	grSVGA_320x240x32k,
	grSVGA_320x400x32k,
	grSVGA_320x480x32k,
	grSVGA_400x300x32k,
	grSVGA_512x384x32k,
	grSVGA_640x350x32k,
	grSVGA_640x400x32k,
	grSVGA_640x480x32k,
	grSVGA_800x600x32k,
	grSVGA_1024x768x32k,
	grSVGA_1152x864x32k,
	grSVGA_1280x960x32k,
	grSVGA_1280x1024x32k,
	grSVGA_1600x1200x32k,
	
	/* 65,536 color Super VGA video modes */
	
	grSVGA_320x200x64k,
	grSVGA_320x240x64k,
	grSVGA_320x400x64k,
	grSVGA_320x480x64k,
	grSVGA_400x300x64k,
	grSVGA_512x384x64k,
	grSVGA_640x350x64k,
	grSVGA_640x400x64k,
	grSVGA_640x480x64k,
	grSVGA_800x600x64k,
	grSVGA_1024x768x64k,
	grSVGA_1152x864x64k,
	grSVGA_1280x960x64k,
	grSVGA_1280x1024x64k,
	grSVGA_1600x1200x64k,
	
	/* 16 million color, 24 bits per pixel Super VGA video modes */
	
	grSVGA_320x200x16m,
	grSVGA_320x240x16m,
	grSVGA_320x400x16m,
	grSVGA_320x480x16m,
	grSVGA_400x300x16m,
	grSVGA_512x384x16m,
	grSVGA_640x350x16m,
	grSVGA_640x400x16m,
	grSVGA_640x480x16m,
	grSVGA_800x600x16m,
	grSVGA_1024x768x16m,
	grSVGA_1152x864x16m,
	grSVGA_1280x960x16m,
	grSVGA_1280x1024x16m,
	grSVGA_1600x1200x16m,
	
	/* 16 million color, 32 bits per pixel Super VGA video modes */
	
	grSVGA_320x200x4G,
	grSVGA_320x240x4G,
	grSVGA_320x400x4G,
	grSVGA_320x480x4G,
	grSVGA_400x300x4G,
	grSVGA_512x384x4G,
	grSVGA_640x350x4G,
	grSVGA_640x400x4G,
	grSVGA_640x480x4G,
	grSVGA_800x600x4G,
	grSVGA_1024x768x4G,
	grSVGA_1152x864x4G,
	grSVGA_1280x960x4G,
	grSVGA_1280x1024x4G,
	grSVGA_1600x1200x4G,
	
	/* Render into Windowing System DC (Windows, OS/2 PM, X11) */
	
	grWINDOWED,
	
	grMAXMODE,					/* Maximum mode number					*/
} MGL_modeType;

/* MGL_result() error codes	*/

typedef enum
{
	grOK			= 0,	/* No error									*/
	grNoInit		= -1,	/* Graphics driver has not been installed	*/
	grNotDetected	= -2,	/* Graphics hardware was not detected		*/
	grDriverNotFound = -3,	/* Graphics driver file not found			*/
	grBadDriver		= -4,	/* File loaded was not a graphics driver	*/
	grLoadMem		= -5,	/* Not enough memory to load graphics driver*/
	grInvalidMode	= -6,	/* Invalid graphics mode for selected driver*/
	grError			= -8,	/* General graphics error					*/
	grInvalidName	= -9,	/* Invalid driver name						*/
	grNoMem			= -10,	/* Not enough memory to perform operation	*/
	grNoModeSupport	= -11,	/* Select video mode not supported by hard.	*/
	grInvalidFont	= -12,	/* Invalid font data						*/
	grBadFontFile	= -13,	/* File loaded was not a font file			*/
	grFontNotFound	= -14,	/* Font file was not found					*/
	grOldDriver     = -15,	/* Driver file is an old version			*/
	grInvalidDevice	= -16,	/* Invalid device for selected operation	*/
	grInvalidDC		= -17,	/* Invalid device context					*/
	grInvalidCursor	= -18,	/* Invalid cursor file						*/
	grCursorNotFound = -19,	/* Cursor file was not found				*/
	grInvalidIcon	= -20,	/* Invalid icon file						*/
	grIconNotFound	= -21,	/* Icon file was not found					*/
	grInvalidBitmap = -22,	/* Invalid bitmap file						*/
	grBitmapNotFound = -23,	/* Bitmap file was not found				*/
	grZbufferTooBig	= -24,	/* Zbuffer allocation is too large			*/
	grNewFontFile	= -25,	/* Only Windows 2.x font files supported	*/
	grNoDoubleBuff  = -26,	/* Double buffering is not available		*/
	grNoHardwareBlt	= -28,	/* No hardware bitBlt for OffscreenDC		*/
	grNoOffscreenMem = -29,	/* No available offscreen memory			*/
	grInvalidPF		= -30,	/* Invalid pixel format for memory DC		*/
	
	grLastError		= -31,	/* Last error number in list				*/
} MGL_errorType;

#define	MGL_CLIPON		true
#define	MGL_CLIPOFF		false

/* Color mapped modes */

typedef enum
{
	MGL_CMAP_MODE,					/* Normal Color mapped mode 	*/
	MGL_DITHER_RGB_MODE,			/* 24 bit RGB halftone dithered	*/
} MGL_colorModes;

/* Standard colors - this is the standard set of colors for the IBM PC. The
 * default palette will have been programmed to contain these values when a
 * graphics modes is started. If the palette has been changed, they will
 * not correspond to the actual colors on the screen. Under a Windowing
 * manage environment these colors will also not be setup by default.
 */

enum MGL_COLORS
{
	MGL_BLACK,						/* dark colors	*/
	MGL_BLUE,
	MGL_GREEN,
	MGL_CYAN,
	MGL_RED,
	MGL_MAGENTA,
	MGL_BROWN,
	MGL_LIGHTGRAY,
	MGL_DARKGRAY,					/* light colors	*/
	MGL_LIGHTBLUE,
	MGL_LIGHTGREEN,
	MGL_LIGHTCYAN,
	MGL_LIGHTRED,
	MGL_LIGHTMAGENTA,
	MGL_YELLOW,
	MGL_WHITE,
};

/* Windows standard color indices for 256 color bitmaps. 8,9,246,247 are
 * reserved and you should not count on these colors always being the
 * same. For 16 color bitmaps, colors 248-255 map to colors 8-15.
 */

enum MGL_WIN_COLORS
{
	MGL_WIN_BLACK 			= 0,
	MGL_WIN_DARKRED			= 1,
	MGL_WIN_DARKGREEN		= 2,
	MGL_WIN_DARKYELLOW		= 3,
	MGL_WIN_DARKBLUE		= 4,
	MGL_WIN_DARKMAGENTA		= 5,
	MGL_WIN_DARKCYAN		= 6,
	MGL_WIN_LIGHTGRAY		= 7,
	MGL_WIN_TURQUOISE		= 8,		/* Reserved; dont count on this	*/
	MGL_WIN_SKYBLUE			= 9,		/* Reserved; dont count on this	*/
	MGL_WIN_CREAM			= 246,		/* Reserved; dont count on this	*/
	MGL_WIN_MEDIUMGRAY		= 247,		/* Reserved; dont count on this	*/
	MGL_WIN_DARKGRAY		= 248,
	MGL_WIN_LIGHTRED		= 249,
	MGL_WIN_LIGHTGREEN		= 250,
	MGL_WIN_LIGHTYELLOW		= 251,
	MGL_WIN_LIGHTBLUE		= 252,
	MGL_WIN_LIGHTMAGENTA	= 253,
	MGL_WIN_LIGHTCYAN		= 254,
	MGL_WIN_WHITE 			= 255,
};

typedef enum
{
	MGL_MARKER_SQUARE,
	MGL_MARKER_CIRCLE,
	MGL_MARKER_X,
} MGL_markerStyleType;

typedef enum  						/* Write mode operators				*/
{
	MGL_REPLACE_MODE,				/* Replace mode						*/
	MGL_AND_MODE,					/* AND mode							*/
	MGL_OR_MODE,					/* OR mode							*/
	MGL_XOR_MODE,					/* XOR mode							*/
} MGL_writeModeType;

typedef enum
{
	MGL_BITMAP_SOLID,
	MGL_BITMAP_OPAQUE,
	MGL_BITMAP_TRANSPARENT,
	MGL_PIXMAP,
} MGL_fillStyleType;

typedef enum
{
	MGL_LINE_PENSTYLE,				/* Line drawn in current pen style	*/
	MGL_LINE_STIPPLE,				/* Line drawn with current stipple	*/
} MGL_lineStyleType;

typedef enum
{
	MGL_CONVEX_POLYGON,				/* Monotone vertical polygon		*/
	MGL_COMPLEX_POLYGON,			/* Non-Simple polygons				*/
	MGL_AUTO_POLYGON,				/* Auto detect the polygon type		*/
} MGL_polygonType;

/* Text manipulation defines */

typedef enum
{
	MGL_LEFT_TEXT		=	0,		/* Justify from left				*/
	MGL_TOP_TEXT		=	0,		/* Justify from top					*/
	MGL_CENTER_TEXT		=	1,		/* Center the text					*/
	MGL_RIGHT_TEXT		=	2,		/* Justify from right				*/
	MGL_BOTTOM_TEXT		=	2,		/* Justify from bottom				*/
	MGL_BASELINE_TEXT	=	3,		/* Justify from the baseline		*/
} MGL_textJustType;

typedef enum
{
	MGL_LEFT_DIR		=	0,		/* Text goes to left				*/
	MGL_UP_DIR			=	1,		/* Text goes up						*/
	MGL_RIGHT_DIR		=	2,		/* Text goes right					*/
	MGL_DOWN_DIR		=	3,		/* Text goes down					*/
} MGL_textDirType;

/* Font types */

typedef enum
{
	MGL_VECTORFONT = 1,				/* Vector font						*/
	MGL_FIXEDFONT,					/* Fixed width bitmap font			*/
	MGL_PROPFONT,					/* Proportional width bitmap font	*/
} MGL_fontType;

/* Palette rotation directions */

typedef enum
{
	MGL_ROTATE_UP,					/* Rotate the palette values up		*/
	MGL_ROTATE_DOWN,				/* Rotate the palette values down	*/
} MGL_palRotateType;

/* Border drawing routine styles */

typedef enum
{
	MGL_BDR_INSET,					/* Interior is inset into screen	*/
	MGL_BDR_OUTSET,					/* Interior is outset from screen	*/
	MGL_BDR_OUTLINE,				/* Border is 3d outline				*/
} MGL_bdrStyleType;

/* Standard display driver names 	*/

#define	MGL_VGA4NAME		"VGA4.DRV"		/* Standard VGA drivers			*/
#define	MGL_VGA8NAME		"VGA8.DRV"
#define	MGL_VGAXNAME		"VGAX.DRV"

#define	MGL_SVGA4NAME		"SVGA4.DRV"		/* Generic SuperVGA drivers		*/
#define	MGL_SVGA8NAME		"SVGA8.DRV"
#define	MGL_SVGA16NAME		"SVGA16.DRV"
#define	MGL_SVGA24NAME		"SVGA24.DRV"
#define	MGL_SVGA32NAME		"SVGA32.DRV"

#define	MGL_LINEAR8NAME		"LINEAR8.DRV"	/* Linear framebuffer drivers	*/
#define	MGL_LINEAR16NAME	"LINEAR16.DRV"
#define	MGL_LINEAR24NAME	"LINEAR24.DRV"
#define	MGL_LINEAR32NAME	"LINEAR32.DRV"

#define	MGL_ACCEL8NAME		"ACCEL8.DRV"	/* VBE/AF Accelerated drivers	*/
#define	MGL_ACCEL16NAME		"ACCEL16.DRV"
#define	MGL_ACCEL24NAME		"ACCEL24.DRV"
#define	MGL_ACCEL32NAME		"ACCEL32.DRV"

#define	MGL_DDRAW8NAME		"DDRAW8.DRV"	/* DirectDraw drivers			*/
#define	MGL_DDRAW16NAME		"DDRAW16.DRV"
#define	MGL_DDRAW24NAME		"DDRAW24.DRV"
#define	MGL_DDRAW32NAME		"DDRAW32.DRV"

/* Standard memory driver names 	*/

#define	MGL_PACKED1NAME		"PACK1.DRV"
#define	MGL_PACKED4NAME		"PACK4.DRV"
#define	MGL_PACKED8NAME		"PACK8.DRV"
#define	MGL_PACKED16NAME	"PACK16.DRV"
#define	MGL_PACKED24NAME	"PACK24.DRV"
#define	MGL_PACKED32NAME	"PACK32.DRV"

/* Standard bitmap names	*/

#define	MGL_EMPTY_FILL	_MGL_getEmptyPat()
#define	MGL_GRAY_FILL	_MGL_getGrayPat()
#define	MGL_SOLID_FILL	_MGL_getSolidPat()

/* Event message masks for keyDown events */

#define	EVT_ASCIIMASK	0x00FF	/* Ascii code of key pressed			*/
#define	EVT_SCANMASK	0xFF00	/* Scan code of key pressed				*/
#define	EVT_COUNTMASK	0x7FFF0000L		/* Count for KEYREPEAT's		*/

#define	EVT_asciiCode(m)	( (uchar) (m & EVT_ASCIIMASK) )
#define	EVT_scanCode(m)		( (uchar) ( (m & EVT_SCANMASK) >> 8 ) )
#define	EVT_repeatCount(m)	( (short) ( (m & EVT_COUNTMASK) >> 16 ) )

/* Event message masks for mouse events */

#define	EVT_LEFTBMASK	0x0001	/* Left button is bit 0					*/
#define	EVT_RIGHTBMASK	0x0004	/* Right button is bit 1				*/
#define	EVT_BOTHBMASK	0x0005	/* Both left and right together			*/
#define	EVT_ALLBMASK	0x0005	/* All buttons pressed					*/

/* Modifier masks */

#define	EVT_LEFTBUT		0x0001	/* Set if left button was down			*/
#define	EVT_RIGHTBUT	0x0002	/* Set if right button was down			*/
#define	EVT_RIGHTSHIFT	0x0008	/* Set if right shift down				*/
#define	EVT_LEFTSHIFT	0x0010	/* Set if left shift down				*/
#define	EVT_CTRLSTATE	0x0020	/* Set if ctrl key down					*/
#define	EVT_ALTSTATE	0x0040	/* Set if alt key down					*/
#define	EVT_LEFTCTRL	0x0080	/* Set if left ctrl key down			*/
#define	EVT_LEFTALT		0x0100	/* Set if left alt key down				*/
#define	EVT_SHIFTKEY	0x0018	/* Any shift key						*/

/* Event codes */

#define	EVT_NULLEVT		0x0000	/* A null event							*/
#define	EVT_KEYDOWN		0x0001	/* Key down event						*/
#define	EVT_KEYREPEAT	0x0002	/* Key repeat event						*/
#define	EVT_KEYUP		0x0004	/* Key up event							*/
#define	EVT_MOUSEDOWN	0x0008	/* Mouse down event						*/
#define	EVT_MOUSEUP		0x0010	/* Mouse up event						*/
#define	EVT_MOUSEMOVE	0x0020	/* Mouse movement event					*/
#define	EVT_TIMERTICK	0x0040	/* Timer tick event						*/
#define	EVT_USEREVT		0x0080	/* First user event						*/

/* Event code masks */

#define	EVT_KEYEVT		(EVT_KEYDOWN | EVT_KEYREPEAT | EVT_KEYUP)
#define	EVT_MOUSEEVT	(EVT_MOUSEDOWN | EVT_MOUSEUP | EVT_MOUSEMOVE)
#define	EVT_MOUSECLICK	(EVT_MOUSEDOWN | EVT_MOUSEUP)
#define	EVT_EVERYEVT	0xFFFF

/* Suspend Application callback type codes. This callback is called
 * when the user presses one of the corresponding keys indicating that
 * they wish to change the active application. The MGL will catch these
 * events and if you have registered a callback, will call the callback to
 * save the state of the application so that it can be properly restored
 * when the user switches back to your application. The MGL takes care of
 * all the details about saving and restoring the state of the hardware,
 * and all your application needs to do is save its own state so that you can
 * re-draw the application screen upon re-activation.
 *
 * NOTE: Your application suspend callback may get called twice with the
 *		 MGL_DEACTIVATE flag in order to test whether the switch should
 *		 occur (under both DirectDraw and WinDirect fullscreen modes).
 *
 * NOTE: When your callback is called with the MGL_DEACTIVATE flag, you
 *		 cannot assume that you have access to the display memory surfaces
 *		 as they may have been lost by the time your callback has been called.
 */

#define	MGL_DEACTIVATE	0x0001	/* Application losing active focus		*/
#define	MGL_REACTIVATE	0x0002	/* Application regaining active focus	*/

/* Return codes from the suspend application callback. The normal value
 * to be returned is MGL_SUSPEND_APP and this will cause the app to be
 * suspended while back in GDI mode until the app is re-activated again
 * by the user.
 *
 * MGL_NO_DEACTIVATE signals to WinDirect that the application does not want
 * to allow switching to occur, and the switch request will be ignored and
 * the app will remain in fullscreen mode.
 *
 * MGL_NO_SUSPEND_APP can be used to tell WinDirect to switch back to the
 * desktop, but not to suspend the application. This must be used with
 * care as the suspend application callback is then responsible for setting
 * a flag in the application that will stop the application from doing any
 * rendering to the framebuffer while the application is in GDI mode. This
 * return value is useful for games that need to maintain network
 * connectivity while the user has temporarily switched back to GDI mode.
 */

#define	MGL_NO_DEACTIVATE	0	/* Dont allow app to be deactivated 	*/
#define	MGL_SUSPEND_APP		1	/* Suspend application until restored	*/
#define	MGL_NO_SUSPEND_APP	2	/* Dont suspend, but allow switch		*/

/* Here we define the structures used to represent points and rectangles */

typedef struct
{
	m_int	x, y;
} point_t;

typedef	struct
{
	m_int	left;
	m_int	top;
	m_int	right;
	m_int	bottom;
} rect_t;

/* All colors are represented as longs by the library. This allows
 * code to work correctly with up to 24 bit color device drivers. The
 * device drivers themselves expect the color to be a color index if in
 * a color mapped mode, or a 15/16/24 bit RGB tuple in a hicolor or truecolor
 * mode. You can use the appropriate routines to pack and unpack
 * colors into the color_t format.
 */

typedef	ulong		color_t;

/* Define the value used to clear the software ZBuffer. The MGL always uses
 * a > operator for the z compare, and the smallest value is 0.
 */

#define	MGL_ZCLEARVAL	0

/* Structures for passing vertex information to polygon rendering routines.
 * All fixed point coordinates are passed in 16.16 signed fixed point
 * format, while zbuffer coordinates are passed in 4.28 signed fixed point
 * format. The sign bit is used purely for overflow and arithmetic
 * internally, and all user passed zbuffer values should be greater than
 * 0. All shaded rendering routines either take a color index in 8.16 fixed
 * point format (range 0-255.9) or separate RGB components in 8.16 fixed
 * point format (range 0-255.9).
 */

#ifdef	__FX_FIXED_H
#define	fix32_t			FXFixed
#else
typedef	long			fix32_t;
#endif
typedef	fix32_t			fxcolor_t;
typedef	long			zfix32_t;

typedef	struct
{
	fix32_t x, y;
} fxpoint_t;

typedef	struct
{
	fxcolor_t	r, g, b;
} fxrgb_t;

typedef struct
{
	fix32_t		w, s, t;
} fxtex_t;

typedef	struct
{
	fxcolor_t	c;
	fxpoint_t   p;
} fxpointc_t;

typedef	struct
{
	fxrgb_t		c;
	fxpoint_t	p;
} fxpointrgb_t;

typedef	struct
{
	fxpoint_t	p;
	zfix32_t	z;
} fxpointz_t;

typedef	struct
{
	fxcolor_t	c;
	fxpoint_t	p;
	zfix32_t	z;
} fxpointcz_t;

typedef	struct
{
	fxrgb_t		c;
	fxpoint_t	p;
	zfix32_t	z;
} fxpointrgbz_t;

/* Macros to convert between integer and 32 bit fixed point format */

#define	MGL_FIX_1			0x10000L
#define	MGL_FIX_2			0x20000L
#define	MGL_FIX_HALF		0x08000L
#define	MGL_TOFIX(i)		((long)(i) << 16)
#define MGL_FIXTOINT(f)		((m_int)((f) >> 16))
#define	MGL_FIXROUND(f) 	((m_int)(((f) + MGL_FIX_HALF) >> 16))

#define	MGL_ZFIX_1			0x10000000L
#define	MGL_ZFIX_HALF		0x08000000L
#define MGL_FIXTOZ(i)		((i) << 12)
#define	MGL_ZTOFIX(i)		((i) >> 12)
#define	MGL_TOZFIX(i)		((long)(i) << 28)
#define MGL_ZFIXTOINT(f)	((m_int)((f) >> 28))
#define	MGL_ZFIXROUND(f) 	((m_int)(((f) + MGL_ZFIX_HALF) >> 28))

/* Region structure */

#ifdef	BUILD_MGL
struct _span_t;
typedef	struct _span_t	span_t;
#else
typedef void		span_t;
#endif

typedef struct
{
	rect_t      rect;			/* Bounding rectangle for region		*/
	span_t		*spans;			/* Start of span list for region		*/
} region_t;

/* Palette entry structure	*/

typedef struct
{
	uchar	blue;				/* Blue component of color				*/
	uchar	green;				/* Green component of color				*/
	uchar	red;				/* Blue component of color				*/
	uchar	alpha;				/* Alpha or alignment byte				*/
} palette_t;

/* Maximum value for each palette entry component */

#define	PALMAX		255				/* Max value for palette components	*/

/* Pixel format structure */

typedef struct
{
	uchar	redMask, greenMask;		/* Mask values for pixels			*/
	uchar	blueMask, rsvdMask;
	m_int	redPos, redAdjust;		/* Red position and adjustment		*/
	m_int	greenPos, greenAdjust;	/* Green position and adjustment	*/
	m_int	bluePos, blueAdjust;		/* Blue position and adjustment		*/
	m_int	rsvdPos, rsvdAdjust;		/* Reserved position and adjustment */
} pixel_format_t;

/* Structure to hold arc coordinate information */

typedef struct
{
	m_int	x, y;					/* Centre point of the arc			*/
	m_int	startX, startY;			/* Starting point on arc			*/
	m_int	endX, endY;				/* Ending point on arc				*/
} arc_coords_t;

/* Mouse cursor structure */

typedef	struct
{
	ulong		xorMask[32];
	ulong		andMask[32];
	m_int		xHotSpot;
	m_int		yHotSpot;
} cursor_t;

/* Bitmap structure - always packed pixel DIB format */

typedef struct
{
	m_int		width;				/* Width of bitmap in pixels		*/
	m_int		height;				/* Height of bitmap in pixels		*/
	m_int		bitsPerPixel;		/* Pixel width						*/
	m_int		bytesPerLine;		/* Bytes per line value for surface */
	uchar		*surface;			/* Pointer to bitmap surface		*/
	palette_t	*pal;				/* Palette (NULL if not loaded)		*/
	pixel_format_t *pf;				/* Pixel format (NULL if none)		*/
	
	/* ... palette, pixel format and bitmap data are store contiguously */
} bitmap_t;

/* Icon structure - can be 32x23, 64x64 or in fact any size */

typedef struct
{
	m_int		byteWidth;			/* Byte with for AND mask			*/
	uchar		*andMask;			/* Hold punch mask for icon			*/
	bitmap_t	xorMask;			/* XOR mask for the icon			*/
	
	/* ... AND mask and bitmap structure are stored contiguously */
} icon_t;

/* Default cursor name */

#define	MGL_DEF_CURSOR		_MGL_getDefCursor()

/* Generic Font structure */

#define	_MGL_FNAMESIZE		58

typedef struct
{
	char			name[_MGL_FNAMESIZE];/* Name of the font			*/
	short			fontType;		/* Type of font						*/
	short			maxWidth;		/* Maximum character width			*/
	short			maxKern;		/* Maximum character kern			*/
	short			fontWidth;		/* Font width						*/
	short			fontHeight;		/* Font height						*/
	short			ascent;			/* Font ascent value				*/
	short			descent;		/* Font descent value				*/
	short			leading;		/* Font leading value				*/
} font_t;

/* Character and font metrics structure */

typedef struct
{
	m_int			width;			/* Width of character or font		*/
	m_int			fontWidth;		/* Character width (tightest fit)	*/
	m_int			fontHeight;		/* Height of the font				*/
	m_int			ascent;			/* Ascent value						*/
	m_int			descent;		/* Descent value					*/
	m_int			leading;		/* Leading value					*/
	m_int			kern;			/* Kern value						*/
} metrics_t;

/* Text settings structure */

typedef struct
{
	m_int			horizJust;		/* Horizontal justfication			*/
	m_int			vertJust;		/* Vertical justification			*/
	m_int			dir;			/* Text drawing direction			*/
	m_int 			szNumerx;		/* Text x size numerator			*/
	m_int 			szNumery;		/* Text y size numerator			*/
	m_int			szDenomx;		/* Text x size denominator			*/
	m_int			szDenomy;		/* Text y size denominator			*/
	m_int			spaceExtra;		/* Space extra term					*/
	font_t 			*font;			/* Currently selected font			*/
} text_settings_t;

/* Macros to access the (left,top) and (right,bottom) points of a
 * rectangle.
 */

#define	MGL_leftTop(r)		(((point_t *) &(r))[0])
#define	MGL_rightBottom(r)	(((point_t *) &(r))[1])

typedef uchar	pattern_t[8];
typedef color_t	pixpattern_t[8][8];

/* Attributes structure */

typedef struct
{
	color_t			color;			/* Foreground color					*/
	color_t			backColor;		/* Background color					*/
	m_int			colorMode;		/* Current color mode				*/
	m_int			markerSize;		/* Size of markers in pixels		*/
	m_int			markerStyle;	/* Style of markers					*/
	color_t			markerColor;	/* Color to draw markers in			*/
	color_t			bdrBright;		/* Border bright color				*/
	color_t			bdrDark;		/* Border dark color				*/
	point_t			CP;				/* Graphics pen position			*/
	m_int			writeMode;		/* Scan conversion write mode op.	*/
	m_int			penStyle;		/* Pen style						*/
	m_int			penHeight;		/* Height of pen					*/
	m_int			penWidth;		/* Width of pen						*/
	pattern_t		penPat;			/* Pattern for pen					*/
	pixpattern_t	penPixPat;		/* Pixmap pattern for pen			*/
	m_int			lineStyle;		/* Line style						*/
	ushort			lineStipple;	/* Line stipple						*/
	m_uint			stippleCount;	/* Current line stipple count		*/
	rect_t			viewPort;		/* Viewport dimensions				*/
	point_t			viewPortOrg;	/* Logical viewport origin			*/
	rect_t			clipRect;		/* Clipping rectangle dimensions	*/
	m_int			clip;			/* Is clipping on?					*/
	m_int			polyType;		/* Polygon drawing type				*/
	text_settings_t	ts;				/* Text drawing attributes			*/
} attributes_t;

/* Mode specific format information. This structrure can be used by
 * the device driver to build tables of values for all supported modes
 */

typedef struct
{
	m_int	xRes;			/* Device x resolution - 1					*/
	m_int	yRes;			/* Device y resolution - 1					*/
	m_int	bitsPerPixel;	/* Number of bits per pixel					*/
	m_int	numberOfPlanes;	/* Number of planes in image				*/
	color_t	maxColor;		/* Maximum number of colors - 1				*/
	m_int	maxPage;		/* Maximum number of video pages - 1		*/
	m_int	bytesPerLine;	/* Number of bytes in a line				*/
	m_int	aspectRatio;	/* Mode aspect ratio (horiz/vert * 1000)	*/
	long	pageSize;		/* Number of bytes in a page				*/
	m_int	scratch1;		/* Scratch pad value 1						*/
	m_int	scratch2;		/* Scratch pad value 2						*/
	char    redMaskSize;            /* Size of direct color red mask    */
	char    redFieldPosition;       /* Bit posn of lsb of red mask      */
	char    greenMaskSize;          /* Size of direct color green mask  */
	char    greenFieldPosition;     /* Bit posn of lsb of green mask    */
	char    blueMaskSize;           /* Size of direct color blue mask   */
	char    blueFieldPosition;      /* Bit posn of lsb of blue mask     */
	char	rsvdMaskSize;			/* Size of reserved mask			*/
	char	rsvdFieldPosition;		/* Bit posn of reserved mask		*/
} gmode_t;

/* Public Device Context Structure. The 'surface' member along with the
 * gmode_t information block, provides direct access to the active
 * display surface for user applications. The MGL virtualises the surface
 * in SuperVGA modes that dont have a real linear framebuffer.
 */

typedef struct
{
	attributes_t a;			/* Active device attributes					*/
	void	*surface;		/* Pointer to active device surface			*/
	void	*zbuffer;		/* Pointer to Z-buffer if allocated			*/
	m_int	zbits;			/* Bits per zbuffer element					*/
	m_int   zwidth;			/* Width of the zbuffer in pixels			*/
	gmode_t	mi;				/* Mode specific information block			*/
	pixel_format_t pf;		/* Current pixel format for device context	*/
	color_t	*colorTab;		/* Color lookup table cache					*/
	color_t	*shadeTab;		/* Currently active shade table				*/
	m_int	bankOffset;		/* Offset of starting bank number			*/
	
	/* Remainder of Device Context structure is private and internal	*/
} publicDevCtx_t;

#ifndef	BUILD_MGL
typedef publicDevCtx_t			MGLDC;
#else
struct internalDevCtx_t;
typedef struct internalDevCtx_t	MGLDC;
#endif

typedef	struct
{
	ulong		which;			/* Which window for window manager code	*/
	m_uint		what;			/* Event code							*/
	ulong		when;			/* Clock ticks since midnight			*/
	m_int		where_x;		/* Mouse location 						*/
	m_int		where_y;
	ulong		message;		/* Event specific message				*/
	ulong		modifiers;		/* Modifier flags						*/
	m_int		next;   		/* Next event in queue					*/
	m_int		prev;			/* Previous event in queue				*/
} event_t;

/* Structure containing file I/O functions allowing the user application to
 * completely replace the MGL's file I/O functions with their own. This
 * allows the app to store all MGL related files in a single large file,
 * with encryption or compression is desired. By default normal file I/O
 * functions will be used.
 */

typedef struct
{
	FILE *	(*fopen) (const char *filename, const char *mode);
	int	(*fclose) (FILE *f);
	int	(*fseek) (FILE *f, long offset, int whence);
	long	(*ftell) (FILE *f);
	size_t	(*fread) (void *ptr, size_t size, size_t n, FILE *f);
	size_t	(*fwrite) (const void *ptr, size_t size, size_t n, FILE *f);
} fileio_t;

/* Define the flags for the types of direct surface access provided */

#define	MGL_NO_ACCESS		0x0		/* Surface cannot be accessed		*/
#define	MGL_VIRTUAL_ACCESS	0x1		/* Surface is virtualised 			*/
#define	MGL_LINEAR_ACCESS	0x2		/* Surface can be linearly accessed	*/
#define	MGL_SURFACE_FLAGS	0x3

/* Define the flags for the types of direct zbuffer access provided */

#define	MGL_NO_ZACCESS		0x0		/* Zbuffer cannot be accessed		*/
#define	MGL_VIRTUAL_ZACCESS	0x4		/* Zbuffer is virtualised in 		*/
#define	MGL_LINEAR_ZACCESS	0x8		/* Zbuffer can be linearly accessed	*/
#define	MGL_ZBUFFER_FLAGS	0xC

/* Define the flags for the types of hardware acceleration supported by
 * the device context. This will allow the application to tailor the use of
 * MGL functions depending upon whether specific hardware support is
 * available. Hence applications can use specialised software rendering
 * support if the desired hardware support is not available.
 *
 * NOTE: If the hardware flags are not MGL_HW_NONE, you *must* call
 *		 the MGL_beginDirectAccess() and MGL_endDirectAccess() functions
 *		 before and after any custom code that does direct framebuffer
 *		 rendering!!
 *
 *		 This is not necessary for non-accelerated device context, so you
 *		 might want to optimise these calls out if there is no hardware
 *		 acceleration support.
 */

#define	MGL_HW_NONE			0x0000	/* No hardware acceleration			*/
#define	MGL_HW_LINE			0x0010	/* Hardware line drawing			*/
#define	MGL_HW_STIPPLE_LINE	0x0020	/* Hardware stippled line drawing	*/
#define	MGL_HW_POLY			0x0040	/* Hardware polygon filling			*/
#define	MGL_HW_RECT			0x0080	/* Hardware rectangle fill			*/
#define	MGL_HW_PATT_RECT	0x0100	/* Hardware pattern rectangle fill	*/
#define	MGL_HW_CLRPATT_RECT	0x0200	/* Hardware color pattern fill		*/
#define	MGL_HW_SCR_BLT		0x0400	/* Hardware screen/screen bitBlt	*/
#define	MGL_HW_SRCTRANS_BLT	0x0800	/* Hardware source transparent blt	*/
#define	MGL_HW_DSTTRANS_BLT	0x1000	/* Hardware dest. transparent blt	*/
#define	MGL_HW_MONO_BLT		0x2000	/* Hardware monochrome blt			*/
#define	MGL_HW_CLIP			0x4000	/* Hardware clipping				*/
#define	MGL_HW_FLAGS		0xFFF0

#ifdef	__cplusplus
extern "C" {			/* Use "C" linkage when in C++ mode	*/
#endif

	/*------------------------- Function Prototypes ---------------------------*/
	
	/*---------------------------------------------------------------------------
	 * Routines bound to a specific device context. These routines all take
	 * an MGLDC as a parmeter for the context to work with and hence dont work
	 * with the current context. If however the context passed is the currently
	 * active context, all changes to that context are reflected in the
	 * currently active context as well.
	 *-------------------------------------------------------------------------*/
	
	/* Environment detection and initialisation */
	
	m_int 	MGLAPI MGL_registerDriver (const char *name, void *driver);
	void	MGLAPI MGL_unregisterAllDrivers (void);
	void	MGLAPI MGL_registerAllDispDrivers (bool useLinear, bool useDirectDraw, bool useWinDirect);
	void	MGLAPI MGL_registerAllMemDrivers (void);
	void 	MGLAPI MGL_detectGraph (m_int *driver, m_int *mode);
	uchar 	*MGLAPI MGL_availableModes (void);
	m_int	MGLAPI MGL_availablePages (m_int mode);
	m_int	MGLAPI MGL_modeResolution (m_int mode, m_int *xRes, m_int *yRes, m_int *bitsPerPixel);
	bool	MGLAPI MGL_isDisplayDC (MGLDC *dc);
	bool	MGLAPI MGL_isWindowedDC (MGLDC *dc);
	bool	MGLAPI MGL_isMemoryDC (MGLDC *dc);
	void 	MGLAPI MGL_exit (void);
	void 	MGLAPI MGL_setBufSize (unsigned size);
	void	MGLAPI MGL_fatalError (const char *msg);
	m_int 	MGLAPI MGL_result (void);
	void	MGLAPI MGL_setResult (m_int result);
	const char *MGLAPI MGL_errorMsg (m_int err);
	const char *MGLAPI MGL_modeName (m_int mode);
	const char *MGLAPI MGL_modeDriverName (m_int mode);
	const char *MGLAPI MGL_driverName (m_int driver);
	m_int	MGLAPI MGL_getDriver (MGLDC *dc);
	m_int	MGLAPI MGL_getMode (MGLDC *dc);
	m_int	MGLAPI MGL_surfaceAccessType (MGLDC *dc);
	m_int	MGLAPI MGL_zbufferAccessType (MGLDC *dc);
	long	MGLAPI MGL_getHardwareFlags (MGLDC *dc);
	void 	MGLAPI MGL_defaultAttributes (MGLDC *dc);
	void 	MGLAPI MGL_makeSubDC (MGLDC *dc, m_int left, m_int top, m_int right, m_int bottom);
	
	/* Viewport and clip rectangle manipulation bound to a specific DC */
	
	void 	MGLAPI MGL_setViewportDC (MGLDC *dc, rect_t view);
	void	MGLAPI MGL_setRelViewportDC (MGLDC *dc, rect_t view);
	void 	MGLAPI MGL_getViewportDC (MGLDC *dc, rect_t *view);
	void 	MGLAPI MGL_setViewportOrgDC (MGLDC *dc, point_t org);
	void	MGLAPI MGL_getViewportOrgDC (MGLDC *dc, point_t *org);
	void	MGLAPI MGL_globalToLocalDC (MGLDC *dc, point_t *p);
	void	MGLAPI MGL_localToGlobalDC (MGLDC *dc, point_t *p);
	m_int 	MGLAPI MGL_maxxDC (MGLDC *dc);
	m_int 	MGLAPI MGL_maxyDC (MGLDC *dc);
	void 	MGLAPI MGL_setClipRectDC (MGLDC *dc, rect_t clip);
	void 	MGLAPI MGL_getClipRectDC (MGLDC *dc, rect_t *clip);
	void 	MGLAPI MGL_setClipModeDC (MGLDC *dc, bool mode);
	bool 	MGLAPI MGL_getClipModeDC (MGLDC *dc);
	
	/* Color and palette manipulation */
	
	color_t	MGLAPI MGL_realColor (MGLDC *dc, m_int color);
	color_t	MGLAPI MGL_rgbColor (MGLDC *dc, uchar R, uchar G, uchar B);
	void 	MGLAPI MGL_setPaletteEntry (MGLDC *dc, m_int entry, uchar red, uchar green, uchar blue);
	void 	MGLAPI MGL_getPaletteEntry (MGLDC *dc, m_int entry, uchar *red, uchar *green, uchar *blue);
	void 	MGLAPI MGL_setPalette (MGLDC *dc, palette_t *pal, m_int numColors, m_int startIndex);
	void 	MGLAPI MGL_getPalette (MGLDC *dc, palette_t *pal, m_int numColors, m_int startIndex);
	void	ASMAPI MGL_rotatePalette (MGLDC *dc, m_int numColors, m_int startIndex, m_int direction);
	bool	ASMAPI MGL_fadePalette (MGLDC *dc, palette_t *fullIntensity, m_int numColors, m_int startIndex, uchar intensity);
	void	MGLAPI MGL_realizePalette (MGLDC *dc, m_int numColors, m_int startIndex, m_int waitVRT);
	m_int	MGLAPI MGL_getPaletteSize (MGLDC *dc);
	void	MGLAPI MGL_getDefaultPalette (MGLDC *dc, palette_t *pal);
	void 	MGLAPI MGL_setDefaultPalette (MGLDC *dc);
#ifndef	MGL_LITE
	bool	MGLAPI MGL_checkIdentityPalette (bool enable);
	void	MGLAPI MGL_mapToPalette (MGLDC *dc, palette_t *pal);
#endif
	
	/* Generic device context information and manipulation */
	
	bool 	MGLAPI MGL_haveWidePalette (MGLDC *dc);
	m_int	MGLAPI MGL_getBitsPerPixel (MGLDC *dc);
	color_t	MGLAPI MGL_maxColor (MGLDC *dc);
	m_int	MGLAPI MGL_maxPage (MGLDC *dc);
	m_int 	MGLAPI MGL_sizex (MGLDC *dc);
	m_int 	MGLAPI MGL_sizey (MGLDC *dc);
	void 	MGLAPI MGL_getPixelFormat (MGLDC *dc, pixel_format_t *pf);
	void	 *MGLAPI MGL_computePixelAddr (MGLDC *dc, int x, int y);
	
	/* Double buffering support */
	
	void	MGLAPI MGL_setActivePage (MGLDC *dc, m_int page);
	m_int	MGLAPI MGL_getActivePage (MGLDC *dc);
	void	MGLAPI MGL_setVisualPage (MGLDC *dc, m_int page, m_int waitVRT);
	m_int	MGLAPI MGL_getVisualPage (MGLDC *dc);
	void	MGLAPI MGL_setDisplayStart (MGLDC *dc, m_int x, m_int y, m_int waitFlag);
	void	MGLAPI MGL_getDisplayStart (MGLDC *dc, m_int *x, m_int *y);
	void	MGLAPI MGL_vSync (MGLDC *dc);
	bool	MGLAPI MGL_doubleBuffer (MGLDC *dc);
	void	MGLAPI MGL_singleBuffer (MGLDC *dc);
	void	MGLAPI MGL_swapBuffers (MGLDC *dc, m_int waitVRT);
	
	/* Zbuffering support */
	
#ifdef	MGL_3D
	m_int	MGLAPI MGL_getHardwareZBufferDepth (MGLDC *dc);
	bool    ASMAPI MGL_zBegin (MGLDC *dc, m_int zbits);
	bool	MGLAPI MGL_zShareZBuffer (MGLDC *dc, MGLDC *dcShared, m_int zbits);
#endif
	
	/* Event handling support */
	
	bool 	MGLAPI EVT_getNext (event_t *evt, m_uint mask);
	bool	MGLAPI EVT_peekNext (event_t *evt, m_uint mask);
	bool	MGLAPI EVT_post (ulong which, m_uint what, ulong message, ulong modifiers);
	void	MGLAPI EVT_flush (m_uint mask);
	void 	MGLAPI EVT_halt (event_t *evt, m_uint mask);
	m_int	MGLAPI EVT_setTimerTick (m_int ticks);
	
	/*---------------------------------------------------------------------------
	 * Routines bound to the currently active context. All these routines work
	 * with the currently active context and do not reflect any changes made
	 * to the global context to the original user supplied context (because it
	 * may be cached). The cached DC is automatically flushed back to the
	 * original DC when a new context is enabled with MGL_makeCurrentDC().
	 *
	 * Before destroying a DC that is current, make sure you call
	 * MGL_makeCurrentDC(NULL) first!
	 *-------------------------------------------------------------------------*/
	
	/* Routines to change the active global device context */
	
	MGLDC 	*MGLAPI MGL_makeCurrentDC (MGLDC *dc);
	bool	MGLAPI MGL_isCurrentDC (MGLDC *dc);
	
	/* Current device context information and manipulation */
	
	m_int 	MGLAPI MGL_getAspectRatio (void);
	void 	MGLAPI MGL_setAspectRatio (m_int aspectRatio);
	void 	ASMAPI MGL_setColor (color_t color);
	void	MGLAPI MGL_setColorRGB (uchar R, uchar G, uchar B);
	void	MGLAPI MGL_setColorCI (m_int index);
	color_t MGLAPI MGL_getColor (void);
	void 	ASMAPI MGL_setBackColor (color_t color);
	color_t MGLAPI MGL_getBackColor (void);
	color_t	ASMAPI MGL_packColor (pixel_format_t *pf, uchar R, uchar G, uchar B);
	void	MGLAPI MGL_unpackColor (pixel_format_t *pf, color_t color, uchar *R, uchar *G, uchar *B);
	color_t	ASMAPI MGL_packColorRGB (uchar R, uchar G, uchar B);
	void	MGLAPI MGL_unpackColorRGB (color_t color, uchar *R, uchar *G, uchar *B);
	color_t	MGLAPI MGL_defaultColor (void);
#ifndef	MGL_LITE
	void	MGLAPI MGL_setMarkerSize (m_int size);
	m_int	MGLAPI MGL_getMarkerSize (void);
	void	MGLAPI MGL_setMarkerStyle (m_int style);
	m_int	MGLAPI MGL_getMarkerStyle (void);
	void	MGLAPI MGL_setMarkerColor (color_t color);
	color_t	MGLAPI MGL_getMarkerColor (void);
	void	MGLAPI MGL_setBorderColors (color_t bright, color_t dark);
	void	MGLAPI MGL_getBorderColors (color_t *bright, color_t *dark);
	void 	ASMAPI MGL_setWriteMode (m_int mode);
	m_int 	MGLAPI MGL_getWriteMode (void);
	void 	ASMAPI MGL_setPenStyle (m_int style);
	m_int 	MGLAPI MGL_getPenStyle (void);
	void 	MGLAPI MGL_setLineStyle (m_int style);
	m_int 	MGLAPI MGL_getLineStyle (void);
	void 	ASMAPI MGL_setLineStipple (ushort stipple);
	ushort	MGLAPI MGL_getLineStipple (void);
	void 	ASMAPI MGL_setLineStippleCount (m_uint stippleCount);
	m_uint	MGLAPI MGL_getLineStippleCount (void);
	void 	ASMAPI MGL_setPenBitmapPattern (const pattern_t *pat);
	void 	MGLAPI MGL_getPenBitmapPattern (pattern_t *pat);
	void 	ASMAPI MGL_setPenPixmapPattern (const pixpattern_t *pat);
	void 	MGLAPI MGL_getPenPixmapPattern (pixpattern_t *pat);
	void	MGLAPI MGL_setPenSize (m_int height, m_int width);
	void 	MGLAPI MGL_getPenSize (m_int *height, m_int *width);
#ifndef	MGL_LITE
	void 	MGLAPI MGL_setColorMapMode (m_int mode);
	m_int	MGLAPI MGL_getColorMapMode (void);
#endif
	void	MGLAPI MGL_setPolygonType (m_int type);
	m_int	MGLAPI MGL_getPolygonType (void);
#endif
	void 	MGLAPI MGL_getAttributes (attributes_t *attr);
	void 	MGLAPI MGL_restoreAttributes (attributes_t *attr);
	
	/* Device clearing */
	
	void	ASMAPI MGL_clearDevice (void);
	void 	MGLAPI MGL_clearViewport (void);
	
	/* Viewport and clip rectangle manipulation */
	
	void 	MGLAPI MGL_setViewport (rect_t view);
	void	MGLAPI MGL_setRelViewport (rect_t view);
	void 	MGLAPI MGL_getViewport (rect_t *view);
	void 	MGLAPI MGL_setViewportOrg (point_t org);
	void	MGLAPI MGL_getViewportOrg (point_t *org);
	void	MGLAPI MGL_globalToLocal (point_t *p);
	void	MGLAPI MGL_localToGlobal (point_t *p);
	m_int 	MGLAPI MGL_maxx (void);
	m_int 	MGLAPI MGL_maxy (void);
	void 	MGLAPI MGL_setClipRect (rect_t clip);
	void 	MGLAPI MGL_getClipRect (rect_t *clip);
	void 	MGLAPI MGL_setClipMode (bool mode);
	bool 	MGLAPI MGL_getClipMode (void);
	
	/* Pixel plotting */
	
	void 	MGLAPI MGL_pixelCoord (m_int x, m_int y);
	color_t	MGLAPI MGL_getPixelCoord (m_int x, m_int y);
	void	ASMAPI MGL_beginPixel (void);
	void 	MGLAPI MGL_pixelCoordFast (m_int x, m_int y);
	color_t	MGLAPI MGL_getPixelCoordFast (m_int x, m_int y);
	void	ASMAPI MGL_endPixel (void);
	
	/* Line drawing and clipping */
	
	void 	MGLAPI MGL_moveToCoord (m_int x, m_int y);
	void 	MGLAPI MGL_moveRelCoord (m_int dx, m_int dy);
	void 	MGLAPI MGL_lineToCoord (m_int x, m_int y);
	void 	MGLAPI MGL_lineRelCoord (m_int dx, m_int dy);
	m_int 	MGLAPI MGL_getX (void);
	m_int 	MGLAPI MGL_getY (void);
	void	MGLAPI MGL_getCP (point_t *CP);
	void 	MGLAPI MGL_lineCoord (m_int x1, m_int y1, m_int x2, m_int y2);
	void 	MGLAPI MGL_lineCoordFX (fix32_t x1, fix32_t y1, fix32_t x2, fix32_t y2);
	void	MGLAPI MGL_lineCoordFast (m_int x1, m_int y1, m_int x2, m_int y2);
	void	MGLAPI MGL_lineCoordFastFX (fix32_t x1, fix32_t y1, fix32_t x2, fix32_t y2);
	void    MGLAPI MGL_lineEngine (fix32_t x1, fix32_t y1, fix32_t x2, fix32_t y2, void (ASMAPI *plotPoint) (m_int x, m_int y));
	bool	MGLAPI MGL_clipLineFX (fix32_t *x1, fix32_t *y1, fix32_t *x2, fix32_t *y2, fix32_t left, fix32_t top, fix32_t right, fix32_t bottom);
#ifndef	MGL_LITE
	void 	ASMAPI MGL_scanLine (m_int y, m_int x1, m_int x2);
#endif
	
	/* Routines to perform bank switching for banked framebuffers for custom
	 * rendering code. The first version is callable only from assembler and
	 * requires the new bank value to be passed in the DL register. The second
	 * version is callable directly from C. DO NOT CALL THESE FUNCTIONS WHEN
	 * RUNNING WITH A LINEAR FRAMEBUFFER!!!
	 */
	
	void	_ASMAPI SVGA_setBank (void);
	void	_ASMAPI SVGA_setBankC (int bank);
	
	/* Routines to begin/end direct framebuffer access. You must call these
	 * functions is you wish to render directly to a hardware accelerated
	 * device surface.
	 */
	
	void 	ASMAPI MGL_beginDirectAccess (void);
	void 	ASMAPI MGL_endDirectAccess (void);
	
	/* Routines to begin/end fast rendering of flat shaded lines, scanlines
	 * and polygons.
	 */
	
	void 	ASMAPI MGL_beginDrawing (void);
	void 	ASMAPI MGL_endDrawing (void);
	
	/* Routines to begin/end fast rendering of smooth shaded lines, scanlines
	 * and polygons.
	 */
	
#ifdef	MGL_3D
	void 	ASMAPI MGL_beginShadedDrawing (void);
	void 	ASMAPI MGL_endShadedDrawing (void);
#endif
	
	/* Routines to begin/end fast rendering of flat shaded, zbuffered lines and
	 * polygons.
	 */
	
#ifdef	MGL_3D
	void 	ASMAPI MGL_beginZDrawing (void);
	void 	ASMAPI MGL_endZDrawing (void);
#endif
	
	/* Routines to begin/end fast rendering of smooth shaded, zbuffered lines and
	 * polygons.
	 */
	
#ifdef	MGL_3D
	void 	ASMAPI MGL_beginZShadedDrawing (void);
	void 	ASMAPI MGL_endZShadedDrawing (void);
#endif
	
	/* Polygon drawing: Note that the following fast polygon routines
	 * only work with convex polygons. The integer coordinate versions are
	 * provided for compatibility only, and convert the coordinates to fixed
	 * point and call the appropriate fixed point routines below.
	 */
	
#ifndef	MGL_LITE
	void	MGLAPI MGL_fillPolygon (m_int count, point_t *vArray, m_int xOffset, m_int yOffset);
	void	MGLAPI MGL_fillPolygonFast (m_int count, point_t *vArray, m_int xOffset, m_int yOffset);
	void    ASMAPI MGL_fillPolygonFX (m_int count, fxpoint_t *vArray, m_int vinc, fix32_t xOffset, fix32_t yOffset);
	void    ASMAPI MGL_fillPolygonFastFX (m_int count, fxpoint_t *vArray, m_int vinc, fix32_t xOffset, fix32_t yOffset);
#endif
	
	/* 3D rasterization routines */
	
#ifdef	MGL_3D
	void    MGLAPI MGL_zClearCoord (m_int left, m_int top, m_int right, m_int bottom, zfix32_t clearVal);
#endif
	
#ifdef	MGL_FIX3D
	void	ASMAPI MGL_cLineCoordFast (fix32_t x1, fix32_t y1, fix32_t c1, fix32_t x2, fix32_t y2, fix32_t c2);
	void	ASMAPI MGL_rgbLineCoordFast (fix32_t x1, fix32_t y1, fix32_t r1, fix32_t g1, fix32_t b1, fix32_t x2, fix32_t y2, fix32_t r2, fix32_t g2, fix32_t b2);
	void	ASMAPI MGL_zLineCoordFast (fix32_t x1, fix32_t y1, zfix32_t z1, fix32_t x2, fix32_t y2, zfix32_t z2);
	void	ASMAPI MGL_czLineCoordFast (fix32_t x1, fix32_t y1, zfix32_t z1, fix32_t c1, fix32_t x2, fix32_t y2, zfix32_t z2, fix32_t c2);
	void	ASMAPI MGL_rgbzLineCoordFast (fix32_t x1, fix32_t y1, zfix32_t z1, fix32_t r1, fix32_t g1, fix32_t b1, fix32_t x2, fix32_t y2, zfix32_t z2, fix32_t r2, fix32_t g2, fix32_t b2);
	
	void	ASMAPI MGL_triFast (fxpoint_t *v1, fxpoint_t *v2, fxpoint_t *v3, fix32_t xOffset, fix32_t yOffset);
	void	ASMAPI MGL_cTriFast (fxpointc_t *v1, fxpointc_t *v2, fxpointc_t *v3, fix32_t xOffset, fix32_t yOffset);
	void	ASMAPI MGL_rgbTriFast (fxpointrgb_t *v1, fxpointrgb_t *v2, fxpointrgb_t *v3, fix32_t xOffset, fix32_t yOffset);
	void	ASMAPI MGL_zTriFast (fxpointz_t *v1, fxpointz_t *v2, fxpointz_t *v3, fix32_t xOffset, fix32_t yOffset, zfix32_t zOffset);
	void	ASMAPI MGL_czTriFast (fxpointcz_t *v1, fxpointcz_t *v2, fxpointcz_t *v3, fix32_t xOffset, fix32_t yOffset, zfix32_t zOffset);
	void	ASMAPI MGL_rgbzTriFast (fxpointrgbz_t *v1, fxpointrgbz_t *v2, fxpointrgbz_t *v3, fix32_t xOffset, fix32_t yOffset, zfix32_t zOffset);
	
	void	ASMAPI MGL_quadFast (fxpoint_t *v1, fxpoint_t *v2, fxpoint_t *v3, fxpoint_t *v4, fix32_t xOffset, fix32_t yOffset);
	void	ASMAPI MGL_cQuadFast (fxpointc_t *v1, fxpointc_t *v2, fxpointc_t *v3, fxpointc_t *v4, fix32_t xOffset, fix32_t yOffset);
	void	ASMAPI MGL_rgbQuadFast (fxpointrgb_t *v1, fxpointrgb_t *v2, fxpointrgb_t *v3, fxpointrgb_t *v4, fix32_t xOffset, fix32_t yOffset);
	void	ASMAPI MGL_zQuadFast (fxpointz_t *v1, fxpointz_t *v2, fxpointz_t *v3, fxpointz_t *v4, fix32_t xOffset, fix32_t yOffset, zfix32_t zOffset);
	void	ASMAPI MGL_czQuadFast (fxpointcz_t *v1, fxpointcz_t *v2, fxpointcz_t *v3, fxpointcz_t *v4, fix32_t xOffset, fix32_t yOffset, zfix32_t zOffset);
	void	ASMAPI MGL_rgbzQuadFast (fxpointrgbz_t *v1, fxpointrgbz_t *v2, fxpointrgbz_t *v3, fxpointrgbz_t *v4, fix32_t xOffset, fix32_t yOffset, zfix32_t zOffset);
#endif
	
	/* Routine to set the currently active shade table. In HiColor and TrueColor
	 * video modes, you must set a valid shadeTable before you call any of the
	 * color index shaded rendering routines (MGL_cTri() etc). These routines
	 * will interpolate an index into the current shade table rather than
	 * each of the RGB color channels, and the appropriate full RGB color is
	 * extracted directly from the shade table. The shade table can be any size,
	 * but the application must ensure that the indices passed in are within
	 * the range of the current shade table.
	 */
	
#ifdef	MGL_3D
	void	MGLAPI MGL_setShadeTable (color_t *shadeTab);
#endif
	
	/* Polyline drawing */
	
#ifndef	MGL_LITE
	void 	MGLAPI MGL_marker (point_t p);
	void	MGLAPI MGL_polyPoint (m_int count, point_t *vArray);
	void 	MGLAPI MGL_polyMarker (m_int count, point_t *vArray);
	void 	MGLAPI MGL_polyLine (m_int count, point_t *vArray);
#endif
	
	/* Rectangle drawing */
	
#ifndef	MGL_LITE
	void 	MGLAPI MGL_rectCoord (m_int left, m_int top, m_int right, m_int bottom);
	void 	MGLAPI MGL_fillRectCoord (m_int left, m_int top, m_int right, m_int bottom);
#endif
	
	/* Scanline color scanning. Thee routines are primitive, and do not perform
	 * any clipping or viewport mapping, so can be used to build you own
	 * high performance floodfilling routines (see the example file ffill.c
	 * for pre-built high speed floodfill routines).
	 */
	
#ifndef	MGL_LITE
	m_int	ASMAPI MGL_scanRightForColor (m_int x, m_int y, color_t color);
	m_int	ASMAPI MGL_scanLeftForColor (m_int x, m_int y, color_t color);
	m_int 	ASMAPI MGL_scanRightWhileColor (m_int x, m_int y, color_t color);
	m_int	ASMAPI MGL_scanLeftWhileColor (m_int x, m_int y, color_t color);
#endif
	
	/* Psuedo 3D border drawing */
	
#ifndef	MGL_LITE
	void	MGLAPI MGL_drawBorderCoord (m_int left, m_int top, m_int right, m_int bottom, m_int style, m_int thickness);
	void 	MGLAPI MGL_drawHDivider (m_int y, m_int x1, m_int x2);
	void 	MGLAPI MGL_drawVDivider (m_int x, m_int y1, m_int y2);
#endif
	
	/* Ellipse drawing */
	
#ifndef	MGL_LITE
	void	MGLAPI MGL_ellipseArc (rect_t extentRect, m_int startAngle, m_int endAngle);
	void	MGLAPI MGL_ellipseArcCoord (m_int x, m_int y, m_int xradius, m_int yradius, m_int startAngle, m_int endAngle);
	void	ASMAPI MGL_getArcCoords (arc_coords_t *coords);
	void	MGLAPI MGL_ellipse (rect_t extentRect);
	void	MGLAPI MGL_ellipseCoord (m_int x, m_int y, m_int xradius, m_int yradius);
	void	MGLAPI MGL_fillEllipseArc (rect_t extentRect, m_int startAngle, m_int endAngle);
	void	MGLAPI MGL_fillEllipseArcCoord (m_int x, m_int y, m_int xradius, m_int yradius, m_int startAngle, m_int endAngle);
	void	MGLAPI MGL_fillEllipse (rect_t extentRect);
	void	MGLAPI MGL_fillEllipseCoord (m_int x, m_int y, m_int xradius, m_int yradius);
	void	MGLAPI MGL_ellipseEngine (rect_t extentRect, void (ASMAPI *setup) (m_int topY, m_int botY, m_int left, m_int right), void (ASMAPI *set4pixels) (bool inc_x, bool inc_y, bool region1), void (ASMAPI *finished) (void));
	void 	MGLAPI MGL_ellipseArcEngine (rect_t extentRect, m_int startAngle, m_int endAngle, arc_coords_t *ac, void (ASMAPI *plotPoint) (m_int x, m_int y));
#endif
	
	/* Text attribute manipulation */
	
#ifndef	MGL_LITE
	void 	MGLAPI MGL_setTextJustify (m_int horiz, m_int vert);
	void 	MGLAPI MGL_getTextJustify (m_int *horiz, m_int *vert);
	void 	MGLAPI MGL_setTextDirection (m_int direction);
	m_int   MGLAPI MGL_getTextDirection (void);
	void	MGLAPI MGL_setTextSize (m_int numerx, m_int denomx, m_int numery, m_int denomy);
	void	MGLAPI MGL_getTextSize (m_int *numerx, m_int *denomx, m_int *numery, m_int *denomy);
	void	MGLAPI MGL_setSpaceExtra (m_int extra);
	m_int	MGLAPI MGL_getSpaceExtra (void);
	void	MGLAPI MGL_setTextSettings (text_settings_t *settings);
	void	MGLAPI MGL_getTextSettings (text_settings_t *settings);
	m_int 	MGLAPI MGL_textHeight (void);
	m_int 	MGLAPI MGL_textWidth (const char *str);
	void	MGLAPI MGL_textBounds (m_int x, m_int y, const char *str, rect_t *bounds);
	m_int	MGLAPI MGL_charWidth (char ch);
	void	MGLAPI MGL_getFontMetrics (metrics_t *metrics);
	void	MGLAPI MGL_getCharMetrics (char ch, metrics_t *metrics);
	m_int	MGLAPI MGL_maxCharWidth (void);
	void	MGLAPI MGL_underScoreLocation (m_int *x, m_int *y, const char *str);
#endif
	
	/* Text drawing */
	
#ifndef	MGL_LITE
	void 	MGLAPI MGL_drawStr (const char *str);
	void	MGLAPI MGL_drawStrXY (m_int x, m_int y, const char *str);
	bool	MGLAPI MGL_useFont (font_t *font);
	font_t 	 *MGLAPI MGL_getFont (void);
	bool	MGLAPI MGL_vecFontEngine (m_int x, m_int y, const char *str, void (ASMAPI *move) (m_int x, m_int y), void (ASMAPI *draw) (m_int x, m_int y));
#endif
	
	/* BitBlt support */
	
	void 	MGLAPI MGL_bitBltCoord (MGLDC *dst, MGLDC *src, m_int left, m_int top, m_int right, m_int bottom, m_int dstLeft, m_int dstTop, m_int op);
	void 	MGLAPI MGL_stretchBltCoord (MGLDC *dst, MGLDC *src, m_int left, m_int top, m_int right, m_int bottom, m_int dstLeft, m_int dstTop, m_int dstRight, m_int dstBottom);
#ifndef	MGL_LITE
	void 	MGLAPI MGL_getDivotCoord (MGLDC *dc, m_int left, m_int top, m_int right, m_int bottom, void *divot);
	void 	MGLAPI MGL_putDivot (MGLDC *dc, void *divot);
	long 	MGLAPI MGL_divotSizeCoord (MGLDC *dc, m_int left, m_int top, m_int right, m_int bottom);
	void 	MGLAPI MGL_putMonoImage (MGLDC *dc, m_int x, m_int y, m_int byteWidth, m_int height, void *image);
	void	MGLAPI MGL_putBitmap (MGLDC *dc, m_int x, m_int y, const bitmap_t *bitmap, m_int op);
	void	MGLAPI MGL_putBitmapSection (MGLDC *dc, m_int left, m_int top, m_int right, m_int bottom, m_int dstLeft, m_int dstTop, const bitmap_t *bitmap, m_int op);
	void	MGLAPI MGL_putBitmapTransparent (MGLDC *dc, m_int x, m_int y, const bitmap_t *bitmap, color_t transparent, bool sourceTrans);
	void	MGLAPI MGL_putBitmapTransparentSection (MGLDC *dc, m_int left, m_int top, m_int right, m_int bottom, m_int dstLeft, m_int dstTop, const bitmap_t *bitmap, color_t transparent, bool sourceTrans);
	void	MGLAPI MGL_putBitmapMask (MGLDC *dc, m_int x, m_int y, const bitmap_t *mask, color_t color);
	void	MGLAPI MGL_stretchBitmap (MGLDC *dc, m_int left, m_int top, m_int right, m_int bottom, const bitmap_t *bitmap);
	void	MGLAPI MGL_putIcon (MGLDC *dc, m_int x, m_int y, const icon_t *icon);
	void 	MGLAPI MGL_transBltCoord (MGLDC *dst, MGLDC *src, m_int left, m_int top, m_int right, m_int bottom, m_int dstLeft, m_int dstTop, color_t transparent, bool sourceTrans);
#endif
	
	/* Linear offscreen DC BitBlt support */
	
#ifndef	MGL_LITE
	void 	MGLAPI MGL_bitBltLinCoord (MGLDC *dst, MGLDC *src, ulong srcOfs, m_int dstLeft, m_int dstTop, m_int dstRight, m_int dstBottom, m_int op);
	void 	MGLAPI MGL_transBltLinCoord (MGLDC *dst, MGLDC *src, ulong srcOfs, m_int dstLeft, m_int dstTop, m_int dstRight, m_int dstBottom, color_t transparent, bool sourceTrans);
#endif
	
	/* Monochrome bitmap manipulation */
	
#ifndef	MGL_LITE
	void	MGLAPI MGL_drawGlyph (font_t *g, m_int x, m_int y, uchar glyph);
	m_int	MGLAPI MGL_getGlyphWidth (font_t *font, uchar glyph);
	m_int	MGLAPI MGL_getGlyphHeight (font_t *font);
	void 	MGLAPI MGL_rotateGlyph (uchar *dst, uchar *src, m_int *byteWidth, m_int *height, m_int rotation);
	void 	MGLAPI MGL_mirrorGlyph (uchar *dst, uchar *src, m_int byteWidth, m_int height);
#endif
	
	/* Region management */
	
#ifndef	MGL_LITE
	region_t *MGLAPI MGL_newRegion (void);
	region_t *MGLAPI MGL_copyRegion (const region_t *s);
	void	MGLAPI MGL_clearRegion (region_t *r);
	void 	MGLAPI MGL_freeRegion (region_t *r);
	void 	MGLAPI MGL_drawRegion (m_int x, m_int y, const region_t *r);
#endif
	
	/* Region generation primitives */
	
#ifndef	MGL_LITE
	region_t *MGLAPI MGL_rgnLineCoord (m_int x1, m_int y1, m_int x2, m_int y2, const region_t *pen);
	region_t *MGLAPI MGL_rgnLineCoordFX (fix32_t x1, fix32_t y1, fix32_t x2, fix32_t y2, const region_t *pen);
	/*region_t * MGLAPI MGL_rgnPolygon(m_int count,point_t *vArray);*/
	/*region_t * MGLAPI MGL_rgnPolygonFast(m_int count,point_t *vArray);*/
	region_t *MGLAPI MGL_rgnSolidRectCoord (m_int left, m_int top, m_int right, m_int bottom);
	region_t *MGLAPI MGL_rgnEllipse (rect_t extentRect, const region_t *pen);
	region_t *MGLAPI MGL_rgnEllipseArc (rect_t extentRect, m_int startAngle, m_int endAngle, const region_t *pen);
	void	MGLAPI MGL_rgnGetArcCoords (arc_coords_t *coords);
	region_t *MGLAPI MGL_rgnSolidEllipse (rect_t extentRect);
	region_t *MGLAPI MGL_rgnSolidEllipseArc (rect_t extentRect, m_int startAngle, m_int endAngle);
#endif
	
	/* Region alegbra */
	
#ifndef	MGL_LITE
	region_t *MGLAPI MGL_sectRegion (const region_t *r1, const region_t *r2);
	region_t *MGLAPI MGL_sectRegionRect (const region_t *r1, const rect_t *r2);
	bool	MGLAPI MGL_unionRegion (region_t *r1, const region_t *r2);
	bool	MGLAPI MGL_unionRegionRect (region_t *r1, const rect_t *r2);
	bool 	MGLAPI MGL_unionRegionOfs (region_t *r1, const region_t *r2, m_int xOffset, m_int yOffset);
	bool	MGLAPI MGL_diffRegion (region_t *r1, const region_t *r2);
	bool	MGLAPI MGL_diffRegionRect (region_t *r1, const rect_t *r2);
	void	MGLAPI MGL_optimizeRegion (region_t *r);
	void 	MGLAPI MGL_offsetRegion (region_t *r, m_int dx, m_int dy);
	bool	MGLAPI MGL_emptyRegion (const region_t *r);
	bool	MGLAPI MGL_equalRegion (const region_t *r1, const region_t *r2);
	bool	MGLAPI MGL_ptInRegionCoord (m_int x, m_int y, const region_t *r);
#endif
	
	/* Region traversal */
	
#ifndef	MGL_LITE
	typedef void (ASMAPI *rgncallback_t) (const rect_t *r);
	
	void 	MGLAPI MGL_traverseRegion (region_t *rgn, rgncallback_t doRect);
#endif
	
	/* RGB to 8 bit halftone dithering routines */
	
#ifndef	MGL_LITE
	void 	MGLAPI MGL_getHalfTonePalette (palette_t *pal);
	uchar	MGLAPI MGL_halfTonePixel (m_int x, m_int y, uchar R, uchar G, uchar B);
#endif
	
	/* Resource loading/unloading */
	
	font_t *MGLAPI MGL_loadFont (const char *fontname);
	bool	MGLAPI MGL_availableFont (const char *fontname);
	void	MGLAPI MGL_unloadFont (font_t *font);
	cursor_t *MGLAPI MGL_loadCursor (const char *cursorName);
	bool	MGLAPI MGL_availableCursor (const char *cursorName);
	void 	MGLAPI MGL_unloadCursor (cursor_t *cursor);
#ifndef	MGL_LITE
	icon_t *MGLAPI MGL_loadIcon (const char *iconName, bool loadPalette);
	bool	MGLAPI MGL_availableIcon (const char *iconName);
	void	MGLAPI MGL_unloadIcon (icon_t *icon);
#endif
	
	/* Windows BMP bitmap loading/unloading/saving */
	
#ifndef	MGL_LITE
	bitmap_t *MGLAPI MGL_loadBitmap (const char *bitmapName, bool loadPalette);
	bool	MGLAPI MGL_availableBitmap (const char *bitmapName);
	void	MGLAPI MGL_unloadBitmap (bitmap_t *bitmap);
	bool	MGLAPI MGL_getBitmapSize (const char *bitmapName, m_int *width, m_int *height, m_int *bitsPerPixel, pixel_format_t *pf);
	bool	MGLAPI MGL_loadBitmapIntoDC (MGLDC *dc, const char *bitmapName, m_int dstLeft, m_int dstTop, bool loadPalette);
	bool	MGLAPI MGL_saveBitmapFromDC (MGLDC *dc, const char *bitmapName, m_int left, m_int top, m_int right, m_int bottom);
	bitmap_t *MGLAPI MGL_getBitmapFromDC (MGLDC *dc, m_int left, m_int top, m_int right, m_int bottom, bool savePalette);
	bitmap_t *MGLAPI MGL_buildMonoMask (bitmap_t *bitmap, color_t transparent);
#endif
	
	/* PCX bitmap loading/unloading/saving (1/4/8 bpp only) */
	
#ifndef	MGL_LITE
	bitmap_t *MGLAPI MGL_loadPCX (const char *bitmapName, bool loadPalette);
	bool	MGLAPI MGL_availablePCX (const char *bitmapName);
	bool	MGLAPI MGL_getPCXSize (const char *bitmapName, m_int *width, m_int *height, m_int *bitsPerPixel);
	bool	MGLAPI MGL_loadPCXIntoDC (MGLDC *dc, const char *bitmapName, m_int dstLeft, m_int dstTop, bool loadPalette);
	bool	MGLAPI MGL_savePCXFromDC (MGLDC *dc, const char *bitmapName, m_int left, m_int top, m_int right, m_int bottom);
#endif
	
	/* Random number generation routines for shorts and longs with full range */
	
	void    ASMAPI MGL_srand (m_uint seed);
	ushort	ASMAPI MGL_random (ushort max);
	ulong	ASMAPI MGL_randoml (ulong max);
	
	/* Mouse support */
	
	bool	MGLAPI MS_available (void);
	void	MGLAPI MS_show (void);
	void	MGLAPI MS_hide (void);
	void	MGLAPI MS_obscure (void);
	void	MGLAPI MS_setCursor (cursor_t *curs);
	void	MGLAPI MS_setCursorColor (color_t color);
	void 	MGLAPI MS_moveTo (m_int x, m_int y);
	void	MGLAPI MS_getPos (m_int *x, m_int *y);
	void	MGLAPI MS_drawCursor (void);
	
	/* Rectangle and Point manipulation */
	
	rect_t 	MGLAPI MGL_defRect (m_int left, m_int top, m_int right, m_int bottom);
	rect_t 	MGLAPI MGL_defRectPt (point_t leftTop, point_t rightBottom);
	bool 	MGLAPI MGL_sectRect (rect_t s1, rect_t s2, rect_t *d);
	bool 	MGLAPI MGL_sectRectCoord (m_int left1, m_int top1, m_int right1, m_int bottom1, m_int left2, m_int top2, m_int right2, m_int bottom2, rect_t *d);
	void 	MGLAPI MGL_unionRect (rect_t s1, rect_t s2, rect_t *d);
	void 	MGLAPI MGL_unionRectCoord (m_int left1, m_int top1, m_int right1, m_int bottom1, m_int left2, m_int top2, m_int right2, m_int bottom2, rect_t *d);
	
	/* Built-in patterns and mouse cursor */
	
#ifndef	MGL_LITE
	pattern_t	 *MGLAPI _MGL_getEmptyPat (void);
	pattern_t    *MGLAPI _MGL_getGrayPat (void);
	pattern_t    *MGLAPI _MGL_getSolidPat (void);
#endif
	cursor_t     *MGLAPI _MGL_getDefCursor (void);
	
	/* Fixed point multiplication/divide routines */
	
#if defined(__WATCOMC__) && defined(__386__)
	
	/* For Watcom C++ we can use special inline assembler code that is much
	 * faster than calling the 386 assembler functions. Currently this is the
	 * the only compiler that will allow inline assembler to be expanded
	 * directly as inline functions.
	 */
	
	fix32_t	MGL_FixMul (fix32_t a, fix32_t b);
#pragma aux MGL_FixMul =			\
	"imul	edx"					\
	"add	eax,8000h"				\
	"adc	edx,0"					\
	"shrd	eax,edx,16"				\
	parm [eax] [edx]				\
	value [eax]						\
	modify exact [eax edx];
	
	fix32_t	MGL_FixDiv (fix32_t a, fix32_t b);
#pragma aux MGL_FixDiv =			\
	"xor	eax,eax"				\
	"shrd	eax,edx,16"				\
	"sar	edx,16"					\
	"idiv	ebx"              		\
	parm [edx] [ebx] 				\
	value [eax]             		\
	modify exact [eax edx];
	
	fix32_t	MGL_FixMulDiv (fix32_t a, fix32_t b, fix32_t c);
#pragma aux MGL_FixMulDiv =			\
	"imul	ebx"					\
	"idiv	ecx"              		\
	parm [eax] [ebx] [ecx] 			\
	value [eax]             		\
	modify exact [eax edx];
	
	m_int	MGL_backfacing (fix32_t dx1, fix32_t dy1, fix32_t dx2, fix32_t dy2);
#pragma aux MGL_backfacing =		\
	"imul	ebx"					\
	"mov	ebx,eax"				\
	"mov	ecx,edx"				\
	"mov	eax,esi"				\
	"imul	edi"					\
	"sub	eax,ebx"				\
	"mov	eax,1"					\
	"sbb	edx,ecx"				\
	"jns	@@Backfacing"			\
	"xor	eax,eax"				\
	"@@Backfacing:"					\
	parm [eax] [esi] [edi] [ebx]	\
	value [eax]             		\
	modify exact [eax ecx edx];
	
	void MGL_memcpy (void *dst, void *src, m_int n);
#pragma aux MGL_memcpy =            \
	"mov	eax,ecx"				\
	"shr    ecx,2"                  \
	"rep    movsd"                  \
	"mov	cl,al"					\
	"and	cl,3"					\
	"rep	movsb"					\
	parm [edi] [esi] [ecx]			\
	modify exact [eax ecx esi edi];
	
#else
	
	fix32_t	ASMAPI MGL_FixMul (fix32_t a, fix32_t b);
	fix32_t	ASMAPI MGL_FixDiv (fix32_t a, fix32_t b);
	fix32_t	ASMAPI MGL_FixMulDiv (fix32_t a, fix32_t b, fix32_t c);
	m_int	ASMAPI MGL_backfacing (fix32_t dx1, fix32_t dy1, fix32_t dx2, fix32_t dy2);
	void 	ASMAPI MGL_memcpy (void *dst, void *src, m_int n);
	
#endif
	
	/* The following are special memcpy routines that properly handler reading
	 * and writing to virtual linear buffer memory by forcing the proper
	 * alignment. Note that the copy is extended to use a DWORD copy of speed.
	 */
	
	void 	ASMAPI MGL_memcpyVIRTSRC (void *dst, void *src, m_int n);
	void 	ASMAPI MGL_memcpyVIRTDST (void *dst, void *src, m_int n);
	
	/* Function to find an MGL system file's full pathname */
	
	bool	MGLAPI _MGL_findFile (char *validpath, const char *dir, const char *filename, const char *mode);
	
	/* Override the internal MGL file I/O functions */
	
	void	MGLAPI MGL_setFileIO (fileio_t *fio);
	
	/* The following dummy symbols are used to link in driver files to be used. A
	 * driver is not active until it is linked in with the MGL_registerDriver
	 * call. Because we dont export globals in DLLs, we provide functions to
	 * get the address of the drivers. However for a static link library we
	 * need to use globals so that if the driver data is unreferenced, it will
	 * not be linked in with the code.
	 */
	
#ifndef	BUILD_MGL
#if	defined(MGL_DLL) && !defined(BUILD_MGLDLL)
	void *MGLAPI VGA4_getDriverAddr (void);
	void *MGLAPI VGAX_getDriverAddr (void);
	void *MGLAPI SVGA4_getDriverAddr (void);
	void *MGLAPI SVGA8_getDriverAddr (void);
	void *MGLAPI SVGA16_getDriverAddr (void);
	void *MGLAPI SVGA24_getDriverAddr (void);
	void *MGLAPI SVGA32_getDriverAddr (void);
#if !defined(__16BIT__)
	void *MGLAPI VGA8_getDriverAddr (void);
	void *MGLAPI LINEAR8_getDriverAddr (void);
	void *MGLAPI LINEAR16_getDriverAddr (void);
	void *MGLAPI LINEAR24_getDriverAddr (void);
	void *MGLAPI LINEAR32_getDriverAddr (void);
	void *MGLAPI ACCEL8_getDriverAddr (void);
	void *MGLAPI ACCEL16_getDriverAddr (void);
	void *MGLAPI ACCEL24_getDriverAddr (void);
	void *MGLAPI ACCEL32_getDriverAddr (void);
#if defined(MGLWIN) || defined(__WINDOWS__)
	void *MGLAPI DDRAW8_getDriverAddr (void);
	void *MGLAPI DDRAW16_getDriverAddr (void);
	void *MGLAPI DDRAW24_getDriverAddr (void);
	void *MGLAPI DDRAW32_getDriverAddr (void);
#endif
#endif
	void *MGLAPI PACKED1_getDriverAddr (void);
	void *MGLAPI PACKED4_getDriverAddr (void);
	void *MGLAPI PACKED8_getDriverAddr (void);
	void *MGLAPI PACKED16_getDriverAddr (void);
	void *MGLAPI PACKED24_getDriverAddr (void);
	void *MGLAPI PACKED32_getDriverAddr (void);
#define VGA4_driver			VGA4_getDriverAddr()
#define VGAX_driver			VGAX_getDriverAddr()
#define SVGA4_driver		SVGA4_getDriverAddr()
#define SVGA8_driver		SVGA8_getDriverAddr()
#define SVGA16_driver		SVGA16_getDriverAddr()
#define SVGA24_driver		SVGA24_getDriverAddr()
#define SVGA32_driver		SVGA32_getDriverAddr()
#if !defined(__16BIT__)
#define VGA8_driver			VGA8_getDriverAddr()
#define LINEAR8_driver		LINEAR8_getDriverAddr()
#define LINEAR16_driver		LINEAR16_getDriverAddr()
#define LINEAR24_driver     LINEAR24_getDriverAddr()
#define LINEAR32_driver     LINEAR32_getDriverAddr()
#define ACCEL8_driver       ACCEL8_getDriverAddr()
#define ACCEL16_driver      ACCEL16_getDriverAddr()
#define ACCEL24_driver      ACCEL24_getDriverAddr()
#define ACCEL32_driver      ACCEL32_getDriverAddr()
#if defined(MGLWIN) || defined(__WINDOWS__)
#define DDRAW8_driver       DDRAW8_getDriverAddr()
#define DDRAW16_driver      DDRAW16_getDriverAddr()
#define DDRAW24_driver      DDRAW24_getDriverAddr()
#define DDRAW32_driver      DDRAW32_getDriverAddr()
#endif
#endif
#define PACKED1_driver      PACKED1_getDriverAddr()
#define PACKED4_driver      PACKED4_getDriverAddr()
#define PACKED8_driver      PACKED8_getDriverAddr()
#define PACKED16_driver     PACKED16_getDriverAddr()
#define PACKED24_driver     PACKED24_getDriverAddr()
#define PACKED32_driver		PACKED32_getDriverAddr()
#else
	extern m_int _VARAPI VGA4_driver[];
	extern m_int _VARAPI VGAX_driver[];
	extern m_int _VARAPI SVGA4_driver[];
	extern m_int _VARAPI SVGA8_driver[];
	extern m_int _VARAPI SVGA16_driver[];
	extern m_int _VARAPI SVGA24_driver[];
	extern m_int _VARAPI SVGA32_driver[];
#if !defined(__16BIT__)
	extern m_int _VARAPI VGA8_driver[];
	extern m_int _VARAPI LINEAR8_driver[];
	extern m_int _VARAPI LINEAR16_driver[];
	extern m_int _VARAPI LINEAR24_driver[];
	extern m_int _VARAPI LINEAR32_driver[];
	extern m_int _VARAPI ACCEL8_driver[];
	extern m_int _VARAPI ACCEL16_driver[];
	extern m_int _VARAPI ACCEL24_driver[];
	extern m_int _VARAPI ACCEL32_driver[];
#if defined(MGLWIN) || defined(__WINDOWS__)
	extern m_int _VARAPI DDRAW8_driver[];
	extern m_int _VARAPI DDRAW16_driver[];
	extern m_int _VARAPI DDRAW24_driver[];
	extern m_int _VARAPI DDRAW32_driver[];
#endif
#endif
	extern m_int _VARAPI PACKED1_driver[];
	extern m_int _VARAPI PACKED4_driver[];
	extern m_int _VARAPI PACKED8_driver[];
	extern m_int _VARAPI PACKED16_driver[];
	extern m_int _VARAPI PACKED24_driver[];
	extern m_int _VARAPI PACKED32_driver[];
#endif
#endif
	
	/*---------------------------------------------------------------------------
	 * Memory allocation and utility functions.
	 *-------------------------------------------------------------------------*/
	
#ifndef	__16BIT__
#define	_HUGE
#else
#define	_HUGE	_huge
#endif
	
	void MGL_availableMemory (ulong *physical, ulong *total);
	void MGL_useLocalMalloc (void _HUGE * (*malloc) (long size), void (*free) (void _HUGE *p));
	void *MGLAPI MGL_malloc (long size);
	void *MGLAPI MGL_calloc (long size, long n);
	void MGLAPI MGL_free (void _HUGE *p);
	void MGLAPI MGL_memset (void _HUGE *s, m_int c, long n);
	void MGLAPI MGL_memsetw (void _HUGE *s, m_int c, long n);
	void MGLAPI MGL_memsetl (void _HUGE *s, long c, long n);
	
	/*---------------------------------------------------------------------------
	 * Set a fullscreen suspend application callback function. This is used in
	 * fullscreen video modes to allow switching back to the normal operating
	 * system graphical shell (such as Windows GDI, OS/2 PM etc).
	 *-------------------------------------------------------------------------*/
	
	typedef m_int (ASMAPI *MGL_suspend_cb_t) (MGLDC *dc, m_int flags);
	void	MGLAPI MGL_setSuspendAppCallback (MGL_suspend_cb_t staveState);
	
	/*---------------------------------------------------------------------------
	 * Tell the MGL to use a pre-loaded ACCEL.DRV driver file. This allows
	 * you to link with the SciTech WinDirect/Pro and WinDirect/Ultra device
	 * support libraries and tell the MGL to use the device support drivers.
	 * If the user has a real ACCEL.DRV driver file in the standard location
	 * on their machine, this driver file will still be used.
	 *-------------------------------------------------------------------------*/
	
	void	MGLAPI MGL_setACCELDriver (void *driver);
	
	/*---------------------- Inline functions as Macros -----------------------*/
	
#define	MGL_equalPoint(p1,p2)	((p1).x == (p2).x && (p1).y == (p2).y)
	
#define	MGL_equalRect(r1,r2)	((r1).left == (r2).left &&			\
								 (r1).top == (r2).top &&			\
								 (r1).right == (r2).right &&		\
								 (r1).bottom == (r2).bottom)
	
#define	MGL_emptyRect(r)		((r).bottom <= (r).top || 			\
								 (r).right <= (r).left)
	
#define	MGL_disjointRect(r1,r2)	((r1).right <= (r2).left ||			\
								 (r1).left >= (r2).right ||			\
								 (r1).bottom <= (r2).top ||			\
								 (r1).top >= (r2).bottom)
	
#define	MGL_sectRect(s1,s2,d)										\
   ((d)->left = MAX((s1).left,(s2).left),                           \
	(d)->right = MIN((s1).right,(s2).right),                        \
	(d)->top = MAX((s1).top,(s2).top),                              \
	(d)->bottom = MIN((s1).bottom,(s2).bottom),                     \
	!MGL_emptyRect(*d))
	
#define	MGL_sectRectFast(s1,s2,d)									\
	(d)->left = MAX((s1).left,(s2).left);                           \
	(d)->right = MIN((s1).right,(s2).right);                        \
	(d)->top = MAX((s1).top,(s2).top);                              \
	(d)->bottom = MIN((s1).bottom,(s2).bottom)
	
#define	MGL_sectRectCoord(l1,t1,r1,b1,l2,t2,r2,b2,d)				\
   ((d)->left = MAX(l1,l2),											\
	(d)->right = MIN(r1,r2),										\
	(d)->top = MAX(t1,t2),											\
	(d)->bottom = MIN(b1,b2),										\
	!MGL_emptyRect(*d))
	
#define	MGL_sectRectFastCoord(l1,t1,r1,b1,l2,t2,r2,b2,d)			\
	(d)->left = MAX(l1,l2);											\
	(d)->right = MIN(r1,r2);										\
	(d)->top = MAX(t1,t2);											\
	(d)->bottom = MIN(b1,b2)
	
#define	MGL_unionRect(s1,s2,d)										\
	(d)->left = MIN((s1).left,(s2).left);                           \
	(d)->right = MAX((s1).right,(s2).right);                        \
	(d)->top = MIN((s1).top,(s2).top);                              \
	(d)->bottom = MAX((s1).bottom,(s2).bottom)
	
#define MGL_unionRectCoord(l1,t1,r1,b1,l2,t2,r2,b2,d)				\
	(d)->left = MIN(l1,l2);                                 		\
	(d)->right = MAX(r1,r2);                              			\
	(d)->top = MIN(t1,t2);                                    		\
	(d)->bottom = MAX(b1,b2)
	
#define	MGL_offsetRect(r,dx,dy)										\
	{	(r).left += dx; (r).right += dx;							\
		(r).top += dy; (r).bottom += dy; }
	
#define	MGL_insetRect(r,dx,dy)										\
	{	(r).left += dx; (r).right -= dx;							\
		(r).top += dy; (r).bottom -= dy;							\
		if (MGL_emptyRect(r))										\
			(r).left = (r).right = (r).top = (r).bottom = 0; }
	
#define	MGL_ptInRect(p,r)		((p).x >= (r).left &&				\
								 (p).x < (r).right &&				\
								 (p).y >= (r).top &&				\
								 (p).y < (r).bottom)
	
#define	MGL_ptInRectCoord(x,y,r)	((x) >= (r).left &&				\
									 (x) < (r).right &&				\
									 (y) >= (r).top &&				\
									 (y) < (r).bottom)
	
#define	MGL_ptInRegion(p,r)		MGL_ptInRegionCoord((p).x,(p).y,r)
	
#define	MGL_pixel(p)			MGL_pixelCoord((p).x,(p).y)
#define	MGL_getPixel(p)			MGL_getPixelCoord((p).x,(p).y)
#define	MGL_pixelFast(p)		MGL_pixelCoordFast((p).x,(p).y)
#define	MGL_getPixelFast(p)		MGL_getPixelCoordFast((p).x,(p).y)
#define	MGL_moveTo(p)			MGL_moveToCoord((p).x,(p).y)
#define MGL_moveRel(p)			MGL_moveRelCoord((p).x,(p).y)
#define	MGL_line(p1,p2)			MGL_lineCoord((p1).x,(p1).y,(p2).x,(p2).y)
#define	MGL_lineFast(p1,p2)		MGL_lineCoordFast((p1).x,(p1).y,(p2).x,(p2).y)
#define	MGL_lineFX(p1,p2)		MGL_lineCoordFX((p1).x,(p1).y,(p2).x,(p2).y)
#define	MGL_lineFastFX(p1,p2)	MGL_lineCoordFastFX((p1).x,(p1).y,(p2).x,(p2).y)
#define	MGL_cLineFast(p1,p2)	MGL_cLineCoordFast((p1).p.x,(p1).p.y,(p1).c,(p2).p.x,(p2).p.y,(p2).c)
#define	MGL_rgbLineFast(p1,p2)	MGL_rgbLineCoordFast((p1).p.x,(p1).p.y,(p1).c.r,(p1).c.g,(p1).c.b,(p2).p.x,(p2).p.y,(p2).c.r,(p2).c.g,(p2).c.b)
#define	MGL_zLineFast(p1,p2)	MGL_zLineCoordFast((p1).p.x,(p1).p.y,(p1).z,(p2).p.x,(p2).p.y,(p2).z)
#define	MGL_czLineFast(p1,p2)	MGL_czLineCoordFast((p1).p.x,(p1).p.y,(p1).z,(p1).c,(p2).p.x,(p2).p.y,(p2).z,(p2).c)
#define	MGL_rgbzLineFast(p1,p2)	MGL_rgbzLineCoordFast((p1).p.x,(p1).p.y,(p1).z,(p1).c.r,(p1).c.g,(p1).c.b,(p2).p.x,(p2).p.y,(p2).z,(p2).c.r,(p2).c.g,(p2).c.b)
	
#define	MGL_zClearPt(lt,rb,z)	MGL_zClearCoord((lt).x,(lt).y,	\
									(rb).x,(rb).y,z)
#define	MGL_zClear(r,z)			MGL_zClearCoord((r).left,(r).top,	\
									(r).right,(r).bottom,z)
#define	MGL_lineTo(p)			MGL_lineToCoord((p).x,(p).y)
#define	MGL_lineRel(p)			MGL_lineRelCoord((p).x,(p).y);
#define	MGL_rectPt(lt,rb)		MGL_rectCoord((lt).x,(lt).y,(rb).x,(rb).y)
#define	MGL_rect(r)				MGL_rectCoord((r).left,(r).top,			\
									(r).right,(r).bottom)
#define	MGL_drawBorder(r,s,t)	MGL_drawBorderCoord((r).left,(r).top,	\
									(r).right,(r).bottom,(s),(t))
#define	MGL_fillRectPt(lt,rb)	MGL_fillRectCoord((lt).x,(lt).y,	\
									(rb).x,(rb).y)
#define	MGL_fillRect(r)			MGL_fillRectCoord((r).left,(r).top,	\
									(r).right,(r).bottom)
#define	MGL_bitBlt(d,s,r,dl,dt,op) 	MGL_bitBltCoord((d),(s),(r).left,		\
									(r).top,(r).right,(r).bottom,dl,dt,op)
#define	MGL_bitBltLin(d,s,so,r,op) MGL_bitBltLinCoord((d),(s),so,			\
									(r).left,(r).top,(r).right,(r).bottom,op)
#define	MGL_stretchBlt(d,s,sr,dr) 	MGL_stretchBltCoord((d),(s),(sr).left,		\
									(sr).top,(sr).right,(sr).bottom,	\
									(dr).left,(dr).top,(dr).right,(dr).bottom)
#define	MGL_transBlt(d,s,r,dl,dt,c,st)	MGL_transBltCoord((d),(s),(r).left,		\
									(r).top,(r).right,(r).bottom,dl,dt,c,st)
#define	MGL_transBltLin(d,s,so,r,c,st) MGL_transBltLinCoord((d),(s),so,	\
									(r).left,(r).top,(r).right,(r).bottom,c,st)
#define	MGL_getDivot(dc,r,divot) MGL_getDivotCoord(dc,(r).left,(r).top,	\
									(r).right,(r).bottom,divot)
#define	MGL_divotSize(dc,r)		MGL_divotSizeCoord(dc,(r).left,(r).top,\
									(r).right,(r).bottom)
#define	MGL_isSimpleRegion(r)	(((region_t*)(r))->spans == NULL)
#define	MGL_rgnLine(p1,p2,p)	MGL_rgnLineCoord((p1).x,(p1).y,(p2).x,(p2).y,p)
#define	MGL_rgnLineFX(p1,p2,p)	MGL_rgnLineCoordFX((p1).x,(p1).y,(p2).x,(p2).y,p)
#define	MGL_rgnSolidRectPt(lt,rb)	MGL_rgnSolidRectCoord((lt).x,(lt).y,	\
									(rb).x,(rb).y)
#define	MGL_rgnSolidRect(r)			MGL_rgnSolidRectCoord((r).left,(r).top,	\
									(r).right,(r).bottom)
	
	/* Fast color packing/unpacking routines implemented as macros */
	
#define	MGL_packColorFast(pf,R,G,B)													\
 ((ulong)(((uchar)(R) >> (pf)->redAdjust) & (pf)->redMask) << (pf)->redPos)			\
 | ((ulong)(((uchar)(G) >> (pf)->greenAdjust) & (pf)->greenMask) << (pf)->greenPos)	\
 | ((ulong)(((uchar)(B) >> (pf)->blueAdjust) & (pf)->blueMask) << (pf)->bluePos)
	
#define	MGL_unpackColorFast(pf,c,R,G,B)												\
{																					\
 (R) = (uchar)((((ulong)(c) >> (pf)->redPos) & (pf)->redMask) << (pf)->redAdjust);		\
 (G) = (uchar)((((ulong)(c) >> (pf)->greenPos) & (pf)->greenMask) << (pf)->greenAdjust);\
 (B) = (uchar)((((ulong)(c) >> (pf)->bluePos) & (pf)->blueMask) << (pf)->blueAdjust);	\
}
	
	/* Macros to access the RGB components in a packed 24 bit RGB tuple */
	
#define	MGL_rgbRed(c)	(((uchar*)&(c))[2])
#define	MGL_rgbGreen(c)	(((uchar*)&(c))[1])
#define	MGL_rgbBlue(c)	(((uchar*)&(c))[0])
	
	/* Fast 24 bit color packing/unpacking routines implemented as macros */
	
#define	MGL_packColorRGBFast(R,G,B)											\
 (((ulong)((uchar)(R)) << 16) | ((ulong)((uchar)(G)) << 8) | (uchar)(B))
	
#define	MGL_packColorRGBFast2(c,R,G,B)										\
{																			\
 MGL_rgbRed(c) = (uchar)(R);												\
 MGL_rgbGreen(c) = (uchar)(G);												\
 MGL_rgbBlue(c) = (uchar)(B);												\
}
	
#define	MGL_unpackColorRGBFast(c,R,G,B)										\
{																			\
 (R) = MGL_rgbRed(c);														\
 (G) = MGL_rgbGreen(c);														\
 (B) = MGL_rgbBlue(c);														\
}
	
#ifdef	__cplusplus
}						/* End of "C" linkage for C++	*/

#include "mglrect.hpp"	/* Include C++ point/rectangle classes			*/

#endif	/* __cplusplus */

/* Include appropriate platform specific bindings */

#if defined(MGLWIN) || defined(__WINDOWS__)
#include "mglwin.h"
#elif defined(MGLPM) || defined(__OS2__)
/*#include "mglpm.h"*/
#elif defined(MGLX) || defined(__UNIX__)
/*#include "mglx.h"*/
#else
#include "mgldos.h"
#endif

#pragma pack()				/* Return to default packing				*/

#endif	/* __MGRAPH_H */
