/*
     File:       RAVE.h
 
     Contains:   Interface for RAVE (Renderer Acceleration Virtual Engine)
 
     Version:    Technology: Quickdraw 3D 1.6
                 Release:    QuickTime 7.3
 
     Copyright:  (c) 2007 (c) 1995-1999 by Apple Computer, Inc., all rights reserved.
 
     Bugs?:      For bug reports, consult the following page on
                 the World Wide Web:
 
                     http://developer.apple.com/bugreporter/
 
*/
#ifndef __RAVE__
#define __RAVE__

#ifndef __CONDITIONALMACROS__
#include "ConditionalMacros.h"
#endif


#if TARGET_OS_MAC
#ifndef __MACTYPES__
#include "MacTypes.h"
#endif

#ifndef __QUICKDRAW__
#include "Quickdraw.h"
#endif

#ifndef __QDOFFSCREEN__
#include "QDOffscreen.h"
#endif


#endif  /* TARGET_OS_MAC */

#if TARGET_OS_WIN32
#include "windows.h"
#ifndef RAVE_NO_DIRECTDRAW
#include "ddraw.h"
#endif  /* !defined(RAVE_NO_DIRECTDRAW) */

#endif  /* TARGET_OS_WIN32 */



#if PRAGMA_ONCE
#pragma once
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if PRAGMA_IMPORT
#pragma import on
#endif

#if PRAGMA_STRUCT_ALIGN
    #pragma options align=power
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
    #pragma pack(2)
#endif

#if PRAGMA_ENUM_ALWAYSINT
    #if defined(__fourbyteints__) && !__fourbyteints__ 
        #define __RAVE__RESTORE_TWOBYTEINTS
        #pragma fourbyteints on
    #endif
    #pragma enumsalwaysint on
#elif PRAGMA_ENUM_OPTIONS
    #pragma option enum=int
#elif PRAGMA_ENUM_PACK
    #if __option(pack_enums)
        #define __RAVE__RESTORE_PACKED_ENUMS
        #pragma options(!pack_enums)
    #endif
#endif

#define RAVE_OBSOLETE 0

/******************************************************************************
 *
 * Platform macros.
 * This sets kQAPlatform to one of kQAMacOS, kQAWin32, or kQAGeneric.
 * kQAPlatform controls platform-specific compilation switches and types.
 *
 *****************************************************************************/

#if !defined(kQAMacOS)
#define  kQAMacOS        1           /* Target is MacOS                  */
#endif

#if !defined(kQAGeneric)
#define kQAGeneric      2           /* Target is generic platform       */
#endif

#if !defined(kQAWin32)
#define kQAWin32      3           /* Target is Win32                  */
#endif

#if defined(_WIN32) || defined(_WINDOWS)
    #define kQAPlatform kQAWin32
#elif !defined(kQAPlatform)
   #define kQAPlatform kQAMacOS
#endif


/******************************************************************************
 *
 * Export Control
 *
 *****************************************************************************/
#if defined(_MSC_VER)
    /* Microsoft Visual C */
   #if defined(WIN32_RAVEEXPORTING)    
   /* define when building DLL */
     #define RAVE_EXPORT     __declspec( dllexport )
        #define RAVE_CALL
      #define RAVE_CALLBACK
  #else
      #define RAVE_EXPORT     __declspec( dllimport )
        #define RAVE_CALL       __cdecl
        #define RAVE_CALLBACK   __cdecl
    #endif 
    /* WIN32_RAVEEXPORTING */
#else
    #define RAVE_EXPORT
    #define RAVE_CALL
  #define RAVE_CALLBACK
#endif 
/* _MSC_VER */

/******************************************************************************
 *
 * Platform dependent datatypes: TQAImagePixelType, TQADevice, TQAClip, and TQARect.
 *
 *****************************************************************************/
enum TQAImagePixelType {
  kQAPixel_Alpha1               = 0,    /* 1 bit/pixel alpha */
  kQAPixel_RGB16                = 1,    /* 16 bits/pixel, R=14:10, G=9:5, B=4:0 */
  kQAPixel_ARGB16               = 2,    /* 16 bits/pixel, A=15, R=14:10, G=9:5, B=4:0 */
  kQAPixel_RGB32                = 3,    /* 32 bits/pixel, R=23:16, G=15:8, B=7:0 */
  kQAPixel_ARGB32               = 4,    /* 32 bits/pixel, A=31:24, R=23:16, G=15:8, B=7:0 */
  kQAPixel_CL4                  = 5,    /* 4 bit color look up table, always big endian, ie high 4 bits effect left pixel */
  kQAPixel_CL8                  = 6,    /* 8 bit color look up table */
  kQAPixel_RGB16_565            = 7,    /* Win32 ONLY  16 bits/pixel, no alpha, R:5, G:6, B:5 */
  kQAPixel_RGB24                = 8,    /* Win32 ONLY  24 bits/pixel, no alpha, R:8, G:8, B:8 */
  kQAPixel_RGB8_332             = 9,    /* 8 bits/pixel, R=7:5, G = 4:2, B = 1:0 */
  kQAPixel_ARGB16_4444          = 10,   /* 16 bits/pixel, A=15:12, R=11:8, G=7:4, B=3:0 */
  kQAPixel_ACL16_88             = 11,   /* 16 bits/pixel, A=15:8, CL=7:0, 8 bit alpha + 8 bit color lookup */
  kQAPixel_I8                   = 12,   /* 8 bits/pixel, I=7:0, intensity map (grayscale) */
  kQAPixel_AI16_88              = 13,   /* 16 bits/pixel, A=15:8, I=7:0, intensity map (grayscale) */
  kQAPixel_YUVS                 = 14,   /* 16 bits/pixel, QD's kYUVSPixelFormat (4:2:2, YUYV ordering, unsigned UV) */
  kQAPixel_YUVU                 = 15,   /* 16 bits/pixel, QD's kYUVUPixelFormat (4:2:2, YUYV ordering, signed UV) */
  kQAPixel_YVYU422              = 16,   /* 16 bits/pixel, QD's kYVYU422PixelFormat (4:2:2, YVYU ordering, unsigned UV) */
  kQAPixel_UYVY422              = 17    /* 16 bits/pixel, QD's kUYVY422PixelFormat (4:2:2, UYVY ordering, unsigned UV) */
};
typedef enum TQAImagePixelType TQAImagePixelType;

enum TQAColorTableType {
  kQAColorTable_CL8_RGB32       = 0,    /* 256 entry, 32 bit/pixel, R=23:16, G=15:8, B=7:0 */
  kQAColorTable_CL4_RGB32       = 1     /* 16 entry, 32 bit/pixel, R=23:16, G=15:8, B=7:0 */
};
typedef enum TQAColorTableType TQAColorTableType;

/* Selects target device type */
enum TQADeviceType {
  kQADeviceMemory               = 0,    /* Memory draw context */
  kQADeviceGDevice              = 1,    /* Macintosh GDevice draw context */
  kQADeviceWin32DC              = 2,    /* Win32 DC */
  kQADeviceDDSurface            = 3     /* Win32 DirectDraw Surface */
};
typedef enum TQADeviceType TQADeviceType;

/* Generic memory pixmap device */
struct TQADeviceMemory {
  long                rowBytes;               /* Rowbytes */
  TQAImagePixelType   pixelType;              /* Depth, color space, etc. */
  long                width;                  /* Width in pixels */
  long                height;                 /* Height in pixels */
  void *              baseAddr;               /* Base address of pixmap */
};
typedef struct TQADeviceMemory          TQADeviceMemory;
/* Offscreen Device */
struct TQADeviceOffscreen {
  TQAImagePixelType   pixelType;              /* Depth, color space, etc. */
};
typedef struct TQADeviceOffscreen       TQADeviceOffscreen;
/* Selects target clip type */
enum TQAClipType {
  kQAClipRgn                    = 0,    /* Macintosh clipRgn with serial number */
  kQAClipWin32Rgn               = 1     /* Win32 clip region */
};
typedef enum TQAClipType TQAClipType;

struct TQARect {
  long                left;
  long                right;
  long                top;
  long                bottom;
};
typedef struct TQARect                  TQARect;
#if TARGET_OS_MAC
union TQAPlatformDevice {
  TQADeviceMemory     memoryDevice;
  GDHandle            gDevice;
};
typedef union TQAPlatformDevice         TQAPlatformDevice;
union TQAPlatformClip {
  RgnHandle           clipRgn;
};
typedef union TQAPlatformClip           TQAPlatformClip;
typedef CALLBACK_API( void , TQADrawNotificationProcPtr )(short left, short top, short right, short bottom, long refCon);

typedef long                            TQADrawNotificationProcRefNum;
/* used to unregister your proc */
#elif TARGET_OS_WIN32

#if !defined(RAVE_NO_DIRECTDRAW)

 enum TQADirectDrawObjectSelector
   {
      kQADirectDrawObject     = 1,
       kQADirectDrawObject2    = 2
    };
 typedef enum TQADirectDrawObjectSelector TQADirectDrawObjectSelector;

 enum TQADirectDrawSurfaceSelector
  {
      kQADirectDrawSurface    = 1,
       kQADirectDrawSurface2   = 2
    };
 typedef enum TQADirectDrawSurfaceSelector TQADirectDrawSurfaceSelector;

#endif /* !RAVE_NO_DIRECTDRAW */

 union TQAPlatformDevice
    {
      TQADeviceMemory         memoryDevice;
      HDC                     hdc;
#if !defined(RAVE_NO_DIRECTDRAW)
      struct
     {
          TQADirectDrawObjectSelector     objectSelector;
            union
          {
              LPDIRECTDRAW                lpDirectDraw;
              LPDIRECTDRAW2               lpDirectDraw2;
         };

            TQADirectDrawSurfaceSelector    surfaceSelector;
           union
          {
              LPDIRECTDRAWSURFACE         lpDirectDrawSurface;
               LPDIRECTDRAWSURFACE2        lpDirectDrawSurface2;
          };
     };
#endif /* RAVE_NO_DIRECTDRAW */
 };
 typedef union TQAPlatformDevice TQAPlatformDevice;
 
   union TQAPlatformClip
  {
      HRGN            clipRgn;
   };
 typedef union TQAPlatformClip TQAPlatformClip;

#else
/*
     * Generic platform supports memory device only. TQARect is generic. TQAClip is ???.
     */
union TQAPlatformDevice {
  TQADeviceMemory     memoryDevice;
};
typedef union TQAPlatformDevice         TQAPlatformDevice;
union TQAPlatformClip {
  void *              region;                 /* ??? */
};
typedef union TQAPlatformClip           TQAPlatformClip;
#endif  /*  */

struct TQADevice {
  TQADeviceType       deviceType;
  TQAPlatformDevice   device;
};
typedef struct TQADevice                TQADevice;
struct TQAClip {
  TQAClipType         clipType;
  TQAPlatformClip     clip;
};
typedef struct TQAClip                  TQAClip;
/******************************************************************************
 *
 * Basic data types.
 *
 *****************************************************************************/

/* Pointer to a drawing engine */
typedef struct TQAEngine TQAEngine;
/* Pointer to an allocated texture */
typedef struct TQATexture TQATexture;
/* Pointer to an allocated bitmap */
typedef struct TQABitmap TQABitmap;
/* Engine's private draw context pointer */
typedef struct TQADrawPrivate TQADrawPrivate;
/* An engine specific color table structure */
typedef struct TQAColorTable TQAColorTable;
/* A single triangle element for QADrawTriMesh */
struct TQAIndexedTriangle {
  unsigned long       triangleFlags;          /* Triangle flags, see kQATriFlags_ */
  unsigned long       vertices[3];            /* Indices into a vertex array */
};
typedef struct TQAIndexedTriangle       TQAIndexedTriangle;
/* An image for use as texture or bitmap */
struct TQAImage {
  long                width;                  /* Width of pixmap */
  long                height;                 /* Height of pixmap */
  long                rowBytes;               /* Rowbytes of pixmap */
  void *              pixmap;                 /* Pixmap */
};
typedef struct TQAImage                 TQAImage;
/* a pixel buffer */

typedef TQADeviceMemory                 TQAPixelBuffer;
/* a zbuffer */
struct TQAZBuffer {
  long                width;                  /* Width of pixmap */
  long                height;                 /* Height of pixmap */
  long                rowBytes;               /* Rowbytes of pixmap */
  void *              zbuffer;                /* pointer to the zbuffer data */
  long                zDepth;                 /* bit depth of zbuffer (16,24,32...) */
  long                isBigEndian;            /* true if zbuffer values are in big-endian format, false if little-endian */
};
typedef struct TQAZBuffer               TQAZBuffer;
/* Standard error type */
enum TQAError {
  kQANoErr                      = 0,    /* No error */
  kQAError                      = 1,    /* Generic error flag */
  kQAOutOfMemory                = 2,    /* Insufficient memory */
  kQANotSupported               = 3,    /* Requested feature is not supported */
  kQAOutOfDate                  = 4,    /* A newer drawing engine was registered */
  kQAParamErr                   = 5,    /* Error in passed parameters */
  kQAGestaltUnknown             = 6,    /* Requested gestalt type isn't available */
  kQADisplayModeUnsupported     = 7,    /* Engine cannot render to the display in its current , */
                                        /* mode, but could if it were in some other mode */
  kQAOutOfVideoMemory           = 8     /* There is not enough VRAM to support the desired context dimensions */
};
typedef enum TQAError TQAError;

/* TQABoolean */

typedef unsigned char                   TQABoolean;
/************************************************************************************************
 *
 * Vertex data types.
 *
 ***********************************************************************************************/
/*
 * TQAVGouraud is used for Gouraud shading. Each vertex specifies position, color and Z.
 *
 * Alpha is always treated as indicating transparency. Drawing engines which don't
 * support Z-sorted rendering use the back-to-front transparency blending functions
 * shown below. (ARGBsrc are the source (new) values, ARGBdest are  the destination
 * (previous) pixel values.)
 *
 *      Premultiplied                           Interpolated
 *
 *      A = 1 - (1 - Asrc) * (1 - Adest)        A = 1 - (1 - Asrc) * (1 - Adest) 
 *      R = (1 - Asrc) * Rdest + Rsrc           R = (1 - Asrc) * Rdest + Asrc * Rsrc
 *      G = (1 - Asrc) * Gdest + Gsrc           G = (1 - Asrc) * Gdest + Asrc * Gsrc
 *      B = (1 - Asrc) * Bdest + Bsrc           B = (1 - Asrc) * Bdest + Asrc * Bsrc
 *
 * Note that the use of other blending modes to implement antialiasing is performed
 * automatically by the drawing engine when the kQATag_Antialias variable !=
 * kQAAntiAlias_Fast. The driving software should continue to use the alpha fields
 * for transparency even when antialiasing is being used (the drawing engine will
 * resolve the multiple blending requirements as best as it can).
 *
 * Drawing engines which perform front-to-back Z-sorted rendering should replace
 * the blending function shown above with the equivalent front-to-back formula.
 */
struct TQAVGouraud {
  float               x;                      /* X pixel coordinate, 0.0 <= x < width */
  float               y;                      /* Y pixel coordinate, 0.0 <= y < height */
  float               z;                      /* Z coordinate, 0.0 <= z <= 1.0 */
  float               invW;                   /* 1 / w; required only when kQAPerspectiveZ_On is set */

  float               r;                      /* Red, 0.0 <= r <= 1.0 */
  float               g;                      /* Green, 0.0 <= g <= 1.0 */
  float               b;                      /* Blue, 0.0 <= b <= 1.0 */
  float               a;                      /* Alpha, 0.0 <= a <= 1.0, 1.0 is opaque */
};
typedef struct TQAVGouraud              TQAVGouraud;
/*
 * TQAVTexture is used for texture mapping. The texture mapping operation
 * is controlled by the kQATag_TextureOp variable, which is a mask of
 * kQATextureOp_None/Modulate/Highlight/Decal. Below is pseudo-code for the
 * texture shading operation:
 *
 *      texPix = TextureLookup (uq/q, vq/q);
 *      if (kQATextureOp_Decal)
 *      {
 *          texPix.r = texPix.a * texPix.r + (1 - texPix.a) * r;
 *          texPix.g = texPix.a * texPix.g + (1 - texPix.a) * g;
 *          texPix.b = texPix.a * texPix.b + (1 - texPix.a) * b;
 *          texPix.a = a;
 *      }
 *      else
 *      {
 *          texPix.a = texPix.a * a;
 *      }
 *      if (kQATextureOp_Modulate)
 *      {
 *          texPix.r *= kd_r;       // Clamped to prevent overflow
 *          texPix.g *= kd_g;       // Clamped to prevent overflow
 *          texPix.b *= kd_b;       // Clamped to prevent overflow
 *      }
 *      if (kQATextureOp_Highlight)
 *      {
 *          texPix.r += ks_r;       // Clamped to prevent overflow
 *          texPix.g += ks_g;       // Clamped to prevent overflow
 *          texPix.b += ks_b;       // Clamped to prevent overflow
 *      }
 *
 * After computation of texPix, transparency blending (as shown
 * above for TQAVGouraud) is performed.
 */
struct TQAVTexture {
  float               x;                      /* X pixel coordinate, 0.0 <= x < width */
  float               y;                      /* Y pixel coordinate, 0.0 <= y < height */
  float               z;                      /* Z coordinate, 0.0 <= z <= 1.0 */
  float               invW;                   /* 1 / w (always required) */

                                              /* rgb are used only when kQATextureOp_Decal is set. a is always required */

  float               r;                      /* Red, 0.0 <= r <= 1.0 */
  float               g;                      /* Green, 0.0 <= g <= 1.0 */
  float               b;                      /* Blue, 0.0 <= b <= 1.0 */
  float               a;                      /* Alpha, 0.0 <= a <= 1.0, 1.0 is opaque */

                                              /* uOverW and vOverW are required by all modes */

  float               uOverW;                 /* u / w */
  float               vOverW;                 /* v / w */

                                              /* kd_r/g/b are used only when kQATextureOp_Modulate is set */

  float               kd_r;                   /* Scale factor for texture red, 0.0 <= kd_r */
  float               kd_g;                   /* Scale factor for texture green, 0.0 <= kd_g */
  float               kd_b;                   /* Scale factor for texture blue, 0.0 <= kd_b */

                                              /* ks_r/g/b are used only when kQATextureOp_Highlight is set */

  float               ks_r;                   /* Red specular highlight, 0.0 <= ks_r <= 1.0 */
  float               ks_g;                   /* Green specular highlight, 0.0 <= ks_g <= 1.0 */
  float               ks_b;                   /* Blue specular highlight, 0.0 <= ks_b <= 1.0 */
};
typedef struct TQAVTexture              TQAVTexture;
/*
*  TQAVMultiTexture allows you to specify the uv and invW values
*  for secondary textures.  This data is submitted with the
*  QASubmitMultiTextureParams() call.
*/
struct TQAVMultiTexture {
  float               invW;
  float               uOverW;
  float               vOverW;
};
typedef struct TQAVMultiTexture         TQAVMultiTexture;

/************************************************************************************************
 *
 * Constants used for the state variables.
 *
 ***********************************************************************************************/
/*
 * kQATag_xxx is used to select a state variable when calling QASetFloat(), QASetInt(),
 * QAGetFloat() and QAGetInt(). The kQATag values are split into three separate enumerated
 * types: TQATagInt, TQATagPtr and TQATagFloat. TQATagInt is used for the QASet/GetInt()
 * functions, TQATagPtr is used for the QASet/GetPtr() functions, and TQATagFloat is used for 
 * the QASet/GetFloat() functions. (This is so that a compiler that typechecks enums can flag
 * a float/int tag mismatch during compile.)
 *
 * -=- All tag values must be unique even across all three types. -=-
 *
 * These variables are required by all drawing engines:
 *      kQATag_ZFunction            (Int)   One of kQAZFunction_xxx
 *      kQATag_ColorBG_a            (Float) Background color alpha
 *      kQATag_ColorBG_r            (Float) Background color red
 *      kQATag_ColorBG_g            (Float) Background color green
 *      kQATag_ColorBG_b            (Float) Background color blue
 *      kQATag_Width                (Float) Line and point width (pixels)
 *      kQATag_ZMinOffset           (Float) Min offset to Z to guarantee visibility (Read only!)
 *      kQATag_ZMinScale            (Float) Min scale to Z to guarantee visibility (Read only!)
 
 * These variables are used for optional features:
 *      kQATag_Antialias            (Int)   One of kQAAntiAlias_xxx
 *      kQATag_Blend                (Int)   One of kQABlend_xxx
 *      kQATag_PerspectiveZ         (Int)   One of kQAPerspectiveZ_xxx
 *      kQATag_TextureFilter        (Int)   One of kQATextureFilter_xxx
 *      kQATag_TextureOp            (Int)   Mask of kQATextureOp_xxx
 *      kQATag_Texture              (Ptr)   Pointer to current TQATexture
 *      kQATag_CSGTag               (Int)   One of kQACSGTag_xxx
 *      kQATag_CSGEquation          (Int)   32 bit CSG truth table
 *      kQATag_FogMode              (Int)   One of kQAFogMode_xxxx
 *      kQATag_FogColor_a           (Float) Fog color alpha
 *      kQATag_FogColor_r           (Float) Fog color red
 *      kQATag_FogColor_g           (Float) Fog color green
 *      kQATag_FogColor_b           (Float) Fog color blue
 *      kQATag_FogStart             (Float) Fog start
 *      kQATag_FogEnd               (Float) Fog end
 *      kQATag_FogDensity           (Float) Fog density
 *      kQATag_FogMaxDepth          (Float) Maximun value for 1.0 / invW
 *      kQATag_MipmapBias           (Float) The mipmap page bias factor
 *      kQATag_ChannelMask          (Int) one of kQAChannelMask_xxx
 *      kQATag_ZBufferMask          (Int) one of kQAZBufferMask_xxx
 *      kQATag_ZSortedHint          (Int) 1 = depth sort transparent triangles, 0 = do not sort.
 *      kQATag_Chromakey_r          (Float) chroma key red
 *      kQATag_Chromakey_g          (Float) chroma key green
 *      kQATag_Chromakey_b          (Float) chroma key blue
 *      kQATag_ChromakeyEnable      (Int) 1 = enable chroma keying, 0 = disable chroma keying
 *      kQATag_AlphaTestFunc        (Int) one of kQAAlphaTest_xxx
 *      kQATag_AlphaTestRef         (Float) from 0 to 1
 *      kQATag_DontSwap             (Int) 1 = dont swap buffers during QARenderEnd, 0 = do swap buffers during QARenderEnd.

 *      kQATag_MultiTextureOp       (Int) One of kQAMultiTexture_xxx
 *      kQATag_MultiTextureFilter   (Int) One of kQATextureFilter_xxx
 *      kQATag_MultiTextureCurrent  (Int) which multitexture layer to use for all other multitexture funcs
 *      kQATag_MultiTextureEnable   (Int) how many multitexture layers to use (0 = no multitexturing).
 *      kQATag_MultiTextureWrapU    (Int)
 *      kQATag_MultiTextureWrapV    (Int)
 *      kQATag_MultiTextureMagFilter (Int)
 *      kQATag_MultiTextureMinFilter (Int)
 *      kQATag_MultiTextureBorder_a (Float)
 *      kQATag_MultiTextureBorder_r (Float)
 *      kQATag_MultiTextureBorder_g (Float)
 *      kQATag_MultiTextureBorder_b (Float)
 *      kQATag_MultiTextureMipmapBias (Float)
 *      kQATag_MultiTextureFactor    (Float) used with kQAMultiTexture_Fixed to determine blending factor
 *
 * These variables are used for OpenGL(tm) support:
 *      kQATagGL_DrawBuffer         (Int)   Mask of kQAGL_DrawBuffer_xxx
 *      kQATagGL_TextureWrapU       (Int)   kQAGL_Clamp or kQAGL_Repeat
 *      kQATagGL_TextureWrapV       (Int)   kQAGL_Clamp or kQAGL_Repeat
 *      kQATagGL_TextureMagFilter   (Int)   kQAGL_Nearest or kQAGL_Linear
 *      kQATagGL_TextureMinFilter   (Int)   kQAGL_Nearest, etc.
 *      kQATagGL_ScissorXMin        (Int)   Minimum X value for scissor rectangle
 *      kQATagGL_ScissorYMin        (Int)   Minimum Y value for scissor rectangle
 *      kQATagGL_ScissorXMax        (Int)   Maximum X value for scissor rectangle
 *      kQATagGL_ScissorYMax        (Int)   Maximum Y value for scissor rectangle
 *      kQATagGL_BlendSrc           (Int)   Source blending operation
 *      kQATagGL_BlendDst           (Int)   Destination blending operation
 *      kQATagGL_LinePattern        (Int)   Line rasterization pattern
 *      kQATagGL_AreaPattern0       (Int)   First of 32 area pattern registers
 *      kQATagGL_AreaPattern31      (Int)   Last of 32 area pattern registers
 *
 *      kQATagGL_DepthBG            (Float) Background Z
 *      kQATagGL_TextureBorder_a    (Float) Texture border color alpha
 *      kQATagGL_TextureBorder_r    (Float) Texture border color red
 *      kQATagGL_TextureBorder_g    (Float) Texture border color green
 *      kQATagGL_TextureBorder_b    (Float) Texture border color blue
 *
 * Tags >= kQATag_EngineSpecific_Minimum may be assigned by the vendor for use as
 * engine-specific variables. NOTE: These should be used only in exceptional circumstances,
 * as functions performed by these variables won't be generally accessible. All other tag
 * values are reserved.
 *
 *      kQATag_EngineSpecific_Minimum   Minimum tag value for drawing-engine specific variables
 */
enum TQATagInt {
  kQATag_ZFunction              = 0,
  kQATag_Antialias              = 8,
  kQATag_Blend                  = 9,
  kQATag_PerspectiveZ           = 10,
  kQATag_TextureFilter          = 11,
  kQATag_TextureOp              = 12,
  kQATag_CSGTag                 = 14,
  kQATag_CSGEquation            = 15,
  kQATag_BufferComposite        = 16,
  kQATag_FogMode                = 17,
  kQATag_ChannelMask            = 27,
  kQATag_ZBufferMask            = 28,
  kQATag_ZSortedHint            = 29,
  kQATag_ChromakeyEnable        = 30,
  kQATag_AlphaTestFunc          = 31,
  kQATag_DontSwap               = 32,
  kQATag_MultiTextureEnable     = 33,
  kQATag_MultiTextureCurrent    = 34,
  kQATag_MultiTextureOp         = 35,
  kQATag_MultiTextureFilter     = 36,
  kQATag_MultiTextureWrapU      = 37,
  kQATag_MultiTextureWrapV      = 38,
  kQATag_MultiTextureMagFilter  = 39,
  kQATag_MultiTextureMinFilter  = 40,
  kQATag_BitmapFilter           = 54,   /* filter to use while scaling bitmaps, one of kQAFilter_xxx */
  kQATag_DrawContextFilter      = 55,   /* filter to use while scaling draw contexts, one of kQAFilter_xxx */
  kQATagGL_DrawBuffer           = 100,
  kQATagGL_TextureWrapU         = 101,
  kQATagGL_TextureWrapV         = 102,
  kQATagGL_TextureMagFilter     = 103,
  kQATagGL_TextureMinFilter     = 104,
  kQATagGL_ScissorXMin          = 105,
  kQATagGL_ScissorYMin          = 106,
  kQATagGL_ScissorXMax          = 107,
  kQATagGL_ScissorYMax          = 108,
  kQATagGL_BlendSrc             = 109,
  kQATagGL_BlendDst             = 110,
  kQATagGL_LinePattern          = 111,
  kQATagGL_AreaPattern0         = 117,  /* ...kQATagGL_AreaPattern1-30 */
  kQATagGL_AreaPattern31        = 148,
  kQATagGL_LinePatternFactor    = 149,  /* equivalent to GL_LINE_STIPPLE_REPEAT */
  kQATag_EngineSpecific_Minimum = 1000
};
typedef enum TQATagInt TQATagInt;

enum TQATagPtr {
  kQATag_Texture                = 13,
  kQATag_MultiTexture           = 26
};
typedef enum TQATagPtr TQATagPtr;

enum TQATagFloat {
  kQATag_ColorBG_a              = 1,
  kQATag_ColorBG_r              = 2,
  kQATag_ColorBG_g              = 3,
  kQATag_ColorBG_b              = 4,
  kQATag_Width                  = 5,
  kQATag_ZMinOffset             = 6,
  kQATag_ZMinScale              = 7,
  kQATag_FogColor_a             = 18,
  kQATag_FogColor_r             = 19,
  kQATag_FogColor_g             = 20,
  kQATag_FogColor_b             = 21,
  kQATag_FogStart               = 22,
  kQATag_FogEnd                 = 23,
  kQATag_FogDensity             = 24,
  kQATag_FogMaxDepth            = 25,
  kQATag_MipmapBias             = 41,
  kQATag_MultiTextureMipmapBias = 42,
  kQATag_Chromakey_r            = 43,
  kQATag_Chromakey_g            = 44,
  kQATag_Chromakey_b            = 45,
  kQATag_AlphaTestRef           = 46,
  kQATag_MultiTextureBorder_a   = 47,
  kQATag_MultiTextureBorder_r   = 48,
  kQATag_MultiTextureBorder_g   = 49,
  kQATag_MultiTextureBorder_b   = 50,
  kQATag_MultiTextureFactor     = 51,
  kQATag_BitmapScale_x          = 52,   /* horizontal bitmap scale factor, default value is 1.0 */
  kQATag_BitmapScale_y          = 53,   /* vertical bitmap scale factor, default value is 1.0 */
  kQATag_MultiTextureEnvColor_a = 56,
  kQATag_MultiTextureEnvColor_r = 57,
  kQATag_MultiTextureEnvColor_g = 58,
  kQATag_MultiTextureEnvColor_b = 59,
  kQATagGL_DepthBG              = 112,
  kQATagGL_TextureBorder_a      = 113,
  kQATagGL_TextureBorder_r      = 114,
  kQATagGL_TextureBorder_g      = 115,
  kQATagGL_TextureBorder_b      = 116,
  kQATagGL_TextureEnvColor_a    = 150,
  kQATagGL_TextureEnvColor_r    = 151,
  kQATagGL_TextureEnvColor_g    = 152,
  kQATagGL_TextureEnvColor_b    = 153
};
typedef enum TQATagFloat TQATagFloat;


/* kQATag_ZFunction */
enum {
  kQAZFunction_None             = 0,    /* Z is neither tested nor written (same as no Z buffer) */
  kQAZFunction_LT               = 1,    /* Znew < Zbuffer is visible */
  kQAZFunction_EQ               = 2,    /* Znew == Zbuffer is visible */
  kQAZFunction_LE               = 3,    /* Znew <= Zbuffer is visible */
  kQAZFunction_GT               = 4,    /* Znew > Zbuffer is visible */
  kQAZFunction_NE               = 5,    /* Znew != Zbuffer is visible */
  kQAZFunction_GE               = 6,    /* Znew >= Zbuffer is visible */
  kQAZFunction_True             = 7,    /* Znew is always visible */
  kQAZFunction_False            = 8     /* Znew is never visible */
};

/* kQATag_Width */
#define kQAMaxWidth 128.0
/* kQATag_Antialias */
enum {
  kQAAntiAlias_Off              = 0,
  kQAAntiAlias_Fast             = 1,
  kQAAntiAlias_Mid              = 2,
  kQAAntiAlias_Best             = 3
};

/* kQATag_Blend */
enum {
  kQABlend_PreMultiply          = 0,
  kQABlend_Interpolate          = 1,
  kQABlend_OpenGL               = 2
};

/* kQATag_BufferComposite */
enum {
  kQABufferComposite_None       = 0,    /* Default: New pixels overwrite initial buffer contents */
  kQABufferComposite_PreMultiply = 1,   /* New pixels are blended with initial buffer contents via PreMultiply */
  kQABufferComposite_Interpolate = 2    /* New pixels are blended with initial buffer contents via Interpolate */
};

/* kQATag_PerspectiveZ */
enum {
  kQAPerspectiveZ_Off           = 0,    /* Use Z for hidden surface removal */
  kQAPerspectiveZ_On            = 1     /* Use InvW for hidden surface removal */
};

/* kQATag_TextureFilter */
enum {
                                        /* suggested meanings of these values */
  kQATextureFilter_Fast         = 0,    /* No filtering, pick nearest */
  kQATextureFilter_Mid          = 1,    /* Fastest method that does some filtering */
  kQATextureFilter_Best         = 2     /* Highest quality renderer can do */
};

/* filter tag values */
enum {
                                        /* suggested meanings of these values */
  kQAFilter_Fast                = 0,    /* No filtering, pick nearest */
  kQAFilter_Mid                 = 1,    /* Fastest method that does some filtering */
  kQAFilter_Best                = 2     /* Highest quality renderer can do */
};

/* kQATag_TextureOp (mask of one or more) */
enum {
  kQATextureOp_None             = 0,    /* Default texture mapping mode */
  kQATextureOp_Modulate         = (1 << 0), /* Modulate texture color with kd_r/g/b */
  kQATextureOp_Highlight        = (1 << 1), /* Add highlight value ks_r/g/b */
  kQATextureOp_Decal            = (1 << 2), /* When texture alpha == 0, use rgb instead */
  kQATextureOp_Shrink           = (1 << 3), /* This is a non-wrapping texture, so the ??? */
  kQATextureOp_Blend            = (1 << 4) /* Same as GL_TEXTURE_ENV_MODE GL_BLEND */
};

/* kQATag_MultiTextureOp */
enum {
  kQAMultiTexture_Add           = 0,    /* texels are added to form final pixel */
  kQAMultiTexture_Modulate      = 1,    /* texels are multiplied to form final pixel */
  kQAMultiTexture_BlendAlpha    = 2,    /* texels are blended according to 2nd texel's alpha */
  kQAMultiTexture_Fixed         = 3     /* texels are blended by a fixed factor via kQATag_MultiTextureFactor  */
};

/* kQATag_CSGTag */
#define kQACSGTag_None 0xffffffffUL
enum {
  kQACSGTag_0                   = 0,    /* Submitted tris have CSG ID 0 */
  kQACSGTag_1                   = 1,    /* Submitted tris have CSG ID 1 */
  kQACSGTag_2                   = 2,    /* Submitted tris have CSG ID 2 */
  kQACSGTag_3                   = 3,    /* Submitted tris have CSG ID 3 */
  kQACSGTag_4                   = 4     /* Submitted tris have CSG ID 4 */
};

/* kQATagGL_TextureWrapU/V */
enum {
  kQAGL_Repeat                  = 0,
  kQAGL_Clamp                   = 1
};

/* kQATagGL_BlendSrc */
enum {
  kQAGL_SourceBlend_XXX         = 0
};

/* kQATagGL_BlendDst */
enum {
  kQAGL_DestBlend_XXX           = 0
};

/* kQATagGL_DrawBuffer (mask of one or more) */
enum {
  kQAGL_DrawBuffer_None         = 0,
  kQAGL_DrawBuffer_FrontLeft    = (1 << 0),
  kQAGL_DrawBuffer_FrontRight   = (1 << 1),
  kQAGL_DrawBuffer_BackLeft     = (1 << 2),
  kQAGL_DrawBuffer_BackRight    = (1 << 3),
  kQAGL_DrawBuffer_Front        = (kQAGL_DrawBuffer_FrontLeft | kQAGL_DrawBuffer_FrontRight),
  kQAGL_DrawBuffer_Back         = (kQAGL_DrawBuffer_BackLeft | kQAGL_DrawBuffer_BackRight)
};

/* kQATag_FogMode */
enum {
  kQAFogMode_None               = 0,    /* no fog                     */
  kQAFogMode_Alpha              = 1,    /* fog value is alpha               */
  kQAFogMode_Linear             = 2,    /* fog = (end - z) / (end - start)         */
  kQAFogMode_Exponential        = 3,    /* fog = exp(-density * z)              */
  kQAFogMode_ExponentialSquared = 4     /* fog = exp(-density * z * density * z)  */
};


/* kQATag_ChannelMask */
enum {
  kQAChannelMask_r              = (1 << 0),
  kQAChannelMask_g              = (1 << 1),
  kQAChannelMask_b              = (1 << 2),
  kQAChannelMask_a              = (1 << 3)
};


/* kQATag_ZBufferMask */
enum {
  kQAZBufferMask_Disable        = 0,
  kQAZBufferMask_Enable         = 1
};

/* kQATag_AlphaTestFunc */
enum {
  kQAAlphaTest_None             = 0,
  kQAAlphaTest_LT               = 1,
  kQAAlphaTest_EQ               = 2,
  kQAAlphaTest_LE               = 3,
  kQAAlphaTest_GT               = 4,
  kQAAlphaTest_NE               = 5,
  kQAAlphaTest_GE               = 6,
  kQAAlphaTest_True             = 7
};


/* flags for QAAccess__xxx */
enum {
  kQANoCopyNeeded               = (1 << 0)
};


/************************************************************************************************
 *
 * Constants used as function parameters.
 *
 ***********************************************************************************************/
/*
 * TQAVertexMode is a parameter to QADrawVGouraud() and QADrawVTexture() that specifies how
 * to interpret and draw the vertex array.
 */
enum TQAVertexMode {
  kQAVertexMode_Point           = 0,    /* Draw nVertices points */
  kQAVertexMode_Line            = 1,    /* Draw nVertices/2 line segments */
  kQAVertexMode_Polyline        = 2,    /* Draw nVertices-1 connected line segments */
  kQAVertexMode_Tri             = 3,    /* Draw nVertices/3 triangles */
  kQAVertexMode_Strip           = 4,    /* Draw nVertices-2 triangles as a strip */
  kQAVertexMode_Fan             = 5,    /* Draw nVertices-2 triangles as a fan from v0 */
  kQAVertexMode_NumModes        = 6
};
typedef enum TQAVertexMode TQAVertexMode;

/*
 * TQAGestaltSelector is a parameter to QAEngineGestalt(). It selects which gestalt
 * parameter will be copied into 'response'.
 */
enum TQAGestaltSelector {
  kQAGestalt_OptionalFeatures   = 0,    /* Mask of one or more kQAOptional_xxx */
  kQAGestalt_FastFeatures       = 1,    /* Mask of one or more kQAFast_xxx */
  kQAGestalt_VendorID           = 2,    /* Vendor ID */
  kQAGestalt_EngineID           = 3,    /* Engine ID */
  kQAGestalt_Revision           = 4,    /* Revision number of this engine */
  kQAGestalt_ASCIINameLength    = 5,    /* strlen (asciiName) */
  kQAGestalt_ASCIIName          = 6,    /* Causes strcpy (response, asciiName) */
  kQAGestalt_TextureMemory      = 7,    /* amount of texture RAM currently available */
  kQAGestalt_FastTextureMemory  = 8,    /* amount of texture RAM currently available */
  kQAGestalt_DrawContextPixelTypesAllowed = 9, /* returns all the draw context pixel types supported by the RAVE engine */
  kQAGestalt_DrawContextPixelTypesPreferred = 10, /* returns all the draw context pixel types that are preferred by the RAVE engine. */
  kQAGestalt_TexturePixelTypesAllowed = 11, /* returns all the texture pixel types that are supported by the RAVE engine */
  kQAGestalt_TexturePixelTypesPreferred = 12, /* returns all the texture pixel types that are preferred by the RAVE engine.*/
  kQAGestalt_BitmapPixelTypesAllowed = 13, /* returns all the bitmap pixel types that are supported by the RAVE engine. */
  kQAGestalt_BitmapPixelTypesPreferred = 14, /* returns all the bitmap pixel types that are preferred by the RAVE engine. */
  kQAGestalt_OptionalFeatures2  = 15,   /* Mask of one or more kQAOptional2_xxx */
  kQAGestalt_MultiTextureMax    = 16,   /* max number of multi textures supported by this engine */
  kQAGestalt_NumSelectors       = 17,
  kQAGestalt_EngineSpecific_Minimum = 1000 /* all gestalts here and above are for engine specific purposes */
};
typedef enum TQAGestaltSelector TQAGestaltSelector;

/*
 * TQAMethodSelector is a parameter to QASetNoticeMethod to select the notice method
 */
#if RAVE_OBSOLETE
enum TQAMethodSelector {
  kQAMethod_RenderCompletion    = 0,    /* Called when rendering has completed and buffers swapped */
  kQAMethod_DisplayModeChanged  = 1,    /* Called when a display mode has changed */
  kQAMethod_ReloadTextures      = 2,    /* Called when texture memory has been invalidated */
  kQAMethod_BufferInitialize    = 3,    /* Called when a buffer needs to be initialized */
  kQAMethod_BufferComposite     = 4,    /* Called when rendering is finished and its safe to composite */
  kQAMethod_NumSelectors        = 5
};
typedef enum TQAMethodSelector TQAMethodSelector;

#else
enum TQAMethodSelector {
  kQAMethod_RenderCompletion    = 0,    /* Called when rendering has completed and buffers swapped */
  kQAMethod_DisplayModeChanged  = 1,    /* Called when a display mode has changed */
  kQAMethod_ReloadTextures      = 2,    /* Called when texture memory has been invalidated */
  kQAMethod_ImageBufferInitialize = 3,  /* Called when a buffer needs to be initialized */
  kQAMethod_ImageBuffer2DComposite = 4, /* Called when rendering is finished and its safe to composite */
  kQAMethod_NumSelectors        = 5
};
typedef enum TQAMethodSelector TQAMethodSelector;

#endif  /* RAVE_OBSOLETE */

/*
 * kQATriFlags_xxx are ORed together to generate the 'flags' parameter
 * to QADrawTriGouraud() and QADrawTriTexture().
 */
enum {
  kQATriFlags_None              = 0,    /* No flags (triangle is front-facing or don't care) */
  kQATriFlags_Backfacing        = (1 << 0) /* Triangle is back-facing */
};

/*
 * kQATexture_xxx are ORed together to generate the 'flags' parameter to QATextureNew().
 */
enum {
  kQATexture_None               = 0,    /* No flags */
  kQATexture_Lock               = (1 << 0), /* Don't swap this texture out */
  kQATexture_Mipmap             = (1 << 1), /* This texture is mipmapped */
  kQATexture_NoCompression      = (1 << 2), /* Do not compress this texture */
  kQATexture_HighCompression    = (1 << 3), /* Compress texture, even if it takes a while */
  kQATexture_NonRelocatable     = (1 << 4), /* Image buffer in VRAM should be non-relocatable */
  kQATexture_NoCopy             = (1 << 5), /* Don't copy image to VRAM when creating it */
  kQATexture_FlipOrigin         = (1 << 6), /* The image(s) is(are) in a bottom-up format. (The image(s) is(are) flipped vertically.) */
  kQATexture_PriorityBits       = (1 << 31) | (1 << 30) | (1 << 29) | (1 << 28) /* Texture priority: 4 upper bits for 16 levels of priority */
};

/*
 * kQABitmap_xxx are ORed together to generate the 'flags' parameter to QABitmapNew().
 */
enum {
  kQABitmap_None                = 0,    /* No flags */
  kQABitmap_Lock                = (1 << 1), /* Don't swap this bitmap out */
  kQABitmap_NoCompression       = (1 << 2), /* Do not compress this bitmap */
  kQABitmap_HighCompression     = (1 << 3), /* Compress bitmap, even if it takes a while */
  kQABitmap_NonRelocatable      = (1 << 4), /* Image buffer in VRAM should be non-relocatable */
  kQABitmap_NoCopy              = (1 << 5), /* Don't copy image to VRAM when creating it */
  kQABitmap_FlipOrigin          = (1 << 6), /* The image is in a bottom-up format. (The image is flipped vertically.) */
  kQABitmap_PriorityBits        = (1 << 31) | (1 << 30) | (1 << 29) | (1 << 28) /* Bitmap priority: 4 upper bits for 16 levels of priority */
};

/*
 * kQAContext_xxx are ORed together to generate the 'flags' parameter for QADrawContextNew().
 */
enum {
  kQAContext_None               = 0,    /* No flags */
  kQAContext_NoZBuffer          = (1 << 0), /* No hidden surface removal */
  kQAContext_DeepZ              = (1 << 1), /* Hidden surface precision >= 24 bits */
  kQAContext_DoubleBuffer       = (1 << 2), /* Double buffered window */
  kQAContext_Cache              = (1 << 3), /* This is a cache context */
  kQAContext_NoDither           = (1 << 4), /* No dithering, straight color banding */
  kQAContext_Scale              = (1 << 5), /* The draw context is to be scaled.  The front buffer is a different size than the back buffer. */
  kQAContext_NonRelocatable     = (1 << 6), /* The back buffer and the z buffer must not move in memory */
  kQAContext_EngineSpecific1    = (1 << 28), /* engine specific flag # 1 */
  kQAContext_EngineSpecific2    = (1 << 29), /* engine specific flag # 2 */
  kQAContext_EngineSpecific3    = (1 << 30), /* engine specific flag # 3 */
  kQAContext_EngineSpecific4    = (1 << 31) /* engine specific flag # 4 */
};

/*
 * kQAOptional_xxx are ORed together to generate the kQAGestalt_OptionalFeatures response
 * from QAEngineGestalt().
 */
enum {
  kQAOptional_None              = 0,    /* No optional features */
  kQAOptional_DeepZ             = (1 << 0), /* Hidden surface precision >= 24 bits */
  kQAOptional_Texture           = (1 << 1), /* Texture mapping */
  kQAOptional_TextureHQ         = (1 << 2), /* High quality texture (tri-linear mip or better) */
  kQAOptional_TextureColor      = (1 << 3), /* Full color modulation and highlight of textures */
  kQAOptional_Blend             = (1 << 4), /* Transparency blending of RGB */
  kQAOptional_BlendAlpha        = (1 << 5), /* Transparency blending includes alpha channel */
  kQAOptional_Antialias         = (1 << 6), /* Antialiased rendering */
  kQAOptional_ZSorted           = (1 << 7), /* Z sorted rendering (for transparency, etc.) */
  kQAOptional_PerspectiveZ      = (1 << 8), /* Hidden surface removal using InvW instead of Z */
  kQAOptional_OpenGL            = (1 << 9), /* Extended rasterization features for OpenGL(tm) */
  kQAOptional_NoClear           = (1 << 10), /* This drawing engine doesn't clear before drawing */
  kQAOptional_CSG               = (1 << 11), /* kQATag_CSGxxx are implemented */
  kQAOptional_BoundToDevice     = (1 << 12), /* This engine is tightly bound to GDevice */
  kQAOptional_CL4               = (1 << 13), /* This engine suports kQAPixel_CL4 */
  kQAOptional_CL8               = (1 << 14), /* This engine suports kQAPixel_CL8 */
  kQAOptional_BufferComposite   = (1 << 15), /* This engine can composite with initial buffer contents */
  kQAOptional_NoDither          = (1 << 16), /* This engine can draw with no dithering */
  kQAOptional_FogAlpha          = (1 << 17), /* This engine suports alpha based fog */
  kQAOptional_FogDepth          = (1 << 18), /* This engine suports depth based fog */
  kQAOptional_MultiTextures     = (1 << 19), /* This bit set if engine supports texture compositing */
  kQAOptional_MipmapBias        = (1 << 20), /* This bit is set if the engine supports mipmap selection bias */
  kQAOptional_ChannelMask       = (1 << 21),
  kQAOptional_ZBufferMask       = (1 << 22),
  kQAOptional_AlphaTest         = (1 << 23), /* this engine supports alpha testing */
  kQAOptional_AccessTexture     = (1 << 24), /* if engine supports access to texture */
  kQAOptional_AccessBitmap      = (1 << 25), /* if engine supports access to bitmaps */
  kQAOptional_AccessDrawBuffer  = (1 << 26), /* if engine supports access to draw buffer */
  kQAOptional_AccessZBuffer     = (1 << 27), /* if engine supports access to zbuffer */
  kQAOptional_ClearDrawBuffer   = (1 << 28), /* if engine supports QAClearDrawBuffer() */
  kQAOptional_ClearZBuffer      = (1 << 29), /* if engine supports QAClearZBuffer() */
  kQAOptional_OffscreenDrawContexts = (1 << 30) /* if engine supports TQADeviceOffscreen */
};

/*
 * kQAOptional2_xxx are ORed together to generate the kQAGestalt_OptionalFeatures2 response
 * from QAEngineGestalt().
 */
enum {
  kQAOptional2_None             = 0,
  kQAOptional2_TextureDrawContexts = (1 << 1), /* if engine supports QATextureNewFromDrawContext() */
  kQAOptional2_BitmapDrawContexts = (1 << 2), /* if engine supports QABitmapNewFromDrawContext() */
  kQAOptional2_Busy             = (1 << 3), /* if engine supports QABusy() */
  kQAOptional2_SwapBuffers      = (1 << 4), /* if engine supports QASwapBuffers() */
  kQAOptional2_Chromakey        = (1 << 5), /* if engine supports chromakeying via kQATag_Chromakey_xxx */
  kQAOptional2_NonRelocatable   = (1 << 6), /* if engine supports nonrelocatable texture & bitmap image buffers in VRAM */
  kQAOptional2_NoCopy           = (1 << 7), /* if engine supports ability to not copy texture & bitmap image to VRAM */
  kQAOptional2_PriorityBits     = (1 << 8), /* if engine supports texture & bitmap priority levels */
  kQAOptional2_FlipOrigin       = (1 << 9), /* if engine supports textures & bitmaps that are vertically flipped */
  kQAOptional2_BitmapScale      = (1 << 10), /* if engine supports scaled bitmap drawing */
  kQAOptional2_DrawContextScale = (1 << 11), /* if engine supports scaled draw contexts */
  kQAOptional2_DrawContextNonRelocatable = (1 << 12) /* if engine supports draw contexts with non relocatable buffers */
};


/*
 * kQAFast_xxx are ORed together to generate the kQAGestalt_FastFeatures response
 * from QAEngineGestalt().
 */
enum {
  kQAFast_None                  = 0,    /* No accelerated features */
  kQAFast_Line                  = (1 << 0), /* Line drawing */
  kQAFast_Gouraud               = (1 << 1), /* Gouraud shaded triangles */
  kQAFast_Texture               = (1 << 2), /* Texture mapped triangles */
  kQAFast_TextureHQ             = (1 << 3), /* High quality texture (tri-linear mip or better) */
  kQAFast_Blend                 = (1 << 4), /* Transparency blending */
  kQAFast_Antialiasing          = (1 << 5), /* Antialiased rendering */
  kQAFast_ZSorted               = (1 << 6), /* Z sorted rendering of non-opaque objects */
  kQAFast_CL4                   = (1 << 7), /* This engine accelerates kQAPixel_CL4 */
  kQAFast_CL8                   = (1 << 8), /* This engine accelerates kQAPixel_CL8 */
  kQAFast_FogAlpha              = (1 << 9), /* This engine accelerates alpha based fog */
  kQAFast_FogDepth              = (1 << 10), /* This engine accelerates depth based fog */
  kQAFast_MultiTextures         = (1 << 11), /* This engine accelerates texture compositing */
  kQAFast_BitmapScale           = (1 << 12), /* This engine accelerates scaled bitmap drawing */
  kQAFast_DrawContextScale      = (1 << 13) /* This engine accelerates scaled draw contexts */
};



/************************************************************************************************
 *
 * Macro definition for easily setting the texture priority bits in the flags field of
 * QATextureNew(), and QABitMapNew().
 *
 * The priority value must be a number between 0 and 15.  0 is top priority, and 15 is lowest
 * priority. Note that this is different than OpenGL which uses floats from 0.0 to 1.0 where
 * 1.0 is top priority. In RAVE, this system is more like texture ranking, thus 0 is top rank,
 * and 15 is the last ranking.
 *
 * Texture prioritization is mainly used for systems which support AGP memory.  This allows the
 * hardware driver to determine which textures to put into faster VRAM and which to put into
 * slower AGP RAM. If you dont care about texture priority, then you dont need to worry about
 * this macro or the priority bits since the default will always be top priority when all 4 bits
 * of this flag field are 0's.
 *
 * To upload a texture with high priority, do the following:
 *
 *         unsigned long flags = kQATexture_Mipmap;            // Initialize flags
 *
 *       flags |= QACalculatePriorityBits(0);                // Setting top priority (this actually does
 *                                                          // nothing since the bits are still 0000)
 *        QATextureNew(myEngine, flags, pixelType, image, &raveTexture);
 *
 *
 * To do a texture with a middle priority of 8, do the following:
 *
 *        unsigned long flags = kQATexture_HighCompression;   // Initialize flags
 *
 *       flags |= QACalculatePriorityBits(8);                // Setting middle priority
 *
 *        QATextureNew(myEngine, flags, pixelType, image, &raveTexture);
 *
 ***********************************************************************************************/

#define QACalculatePriorityBits(_priority)  (((unsigned long) (_priority)) << 28)



/************************************************************************************************
 *
 * Macro definitions for the drawing engine methods included in TQADrawContext. These
 * macros are the recommended means of accessing the engine's draw methods, e.g:
 *
 *      TQADrawContext  *drawContext;
 *        TQAVTexture     vertices[3];
 *
 *      drawContext = QADrawContextNew (rect, gdevice, engine, kQAContext_ZBuffer);
 *      ...
 *      QASetInt (drawContext, kQATag_ZFunction, kQAZFunction_LT);
 *       QADrawTriGouraud (drawContext, &vertices[0], &vertices[1], &vertices[2], kQATriFlags_None);
 *
 * Note that QARenderStart(), QARenderEnd(), QAFlush() and QASync() have real function
 * definitions instead of macros. This is because these functions can afford the extra
 * per-call overhead of a function layer (which makes application code a little smaller),
 * and to allow a cleaner implementation of handling NULL parameters to QARenderStart().
 *
 ***********************************************************************************************/


#define QASetFloat(drawContext,tag,newValue) \
        (drawContext)->setFloat (drawContext,tag,newValue)

#define QASetInt(drawContext,tag,newValue) \
       (drawContext)->setInt (drawContext,tag,newValue)

#define QASetPtr(drawContext,tag,newValue) \
     (drawContext)->setPtr (drawContext,tag,newValue)

#define QAGetFloat(drawContext,tag) \
        (drawContext)->getFloat (drawContext,tag)

#define QAGetInt(drawContext,tag) \
     (drawContext)->getInt (drawContext,tag)

#define QAGetPtr(drawContext,tag) \
       (drawContext)->getPtr (drawContext,tag)

#define QADrawPoint(drawContext,v) \
      (drawContext)->drawPoint (drawContext,v)

#define QADrawLine(drawContext,v0,v1) \
      (drawContext)->drawLine (drawContext,v0,v1)

#define QADrawTriGouraud(drawContext,v0,v1,v2,flags) \
        (drawContext)->drawTriGouraud (drawContext,v0,v1,v2,flags)

#define QADrawTriTexture(drawContext,v0,v1,v2,flags) \
     (drawContext)->drawTriTexture (drawContext,v0,v1,v2,flags)

#define QASubmitVerticesGouraud(drawContext,nVertices,vertices) \
      (drawContext)->submitVerticesGouraud(drawContext,nVertices,vertices)
       
#define QASubmitVerticesTexture(drawContext,nVertices,vertices) \
     (drawContext)->submitVerticesTexture(drawContext,nVertices,vertices)
       
#define QASubmitMultiTextureParams(drawContext,nParams,params) \
      (drawContext)->submitMultiTextureParams(drawContext,nParams,params)


        
#define QADrawTriMeshGouraud(drawContext,nTriangle,triangles) \
       (drawContext)->drawTriMeshGouraud (drawContext,nTriangle,triangles)

#define QADrawTriMeshTexture(drawContext,nTriangle,triangles) \
       (drawContext)->drawTriMeshTexture (drawContext,nTriangle,triangles)

#define QADrawVGouraud(drawContext,nVertices,vertexMode,vertices,flags) \
     (drawContext)->drawVGouraud (drawContext,nVertices,vertexMode,vertices,flags)

#define QADrawVTexture(drawContext,nVertices,vertexMode,vertices,flags) \
       (drawContext)->drawVTexture (drawContext,nVertices,vertexMode,vertices,flags)

#define QADrawBitmap(drawContext,v,bitmap) \
        (drawContext)->drawBitmap (drawContext,v,bitmap)

#define QARenderStart(drawContext,dirtyRect,initialContext) \
        (drawContext)->renderStart (drawContext,dirtyRect,initialContext)

#define QARenderEnd(drawContext,modifiedRect) \
     (drawContext)->renderEnd (drawContext,modifiedRect)

#define QARenderAbort(drawContext) \
      (drawContext)->renderAbort (drawContext)

#define QAFlush(drawContext) \
       (drawContext)->flush (drawContext)

#define QASync(drawContext) \
      (drawContext)->sync (drawContext)

#define QASetNoticeMethod(drawContext, method, completionCallBack, refCon) \
        (drawContext)->setNoticeMethod (drawContext, method, completionCallBack, refCon)

#define QAGetNoticeMethod(drawContext, method, completionCallBack, refCon) \
     (drawContext)->getNoticeMethod (drawContext, method, completionCallBack, refCon)
       
#define QAAccessDrawBuffer(drawContext, pixelBuffer) \
        (drawContext)->accessDrawBuffer(drawContext, pixelBuffer)

#define QAAccessDrawBufferEnd(drawContext, dirtyRect) \
     (drawContext)->accessDrawBufferEnd(drawContext, dirtyRect)

#define QAAccessZBuffer(drawContext, zBuffer) \
        (drawContext)->accessZBuffer(drawContext, zBuffer)

#define QAAccessZBufferEnd(drawContext, dirtyRect) \
       (drawContext)->accessZBufferEnd(drawContext, dirtyRect)


        
#define QAClearDrawBuffer(drawContext, rect, initialContext) \
        (drawContext)->clearDrawBuffer(drawContext, rect, initialContext)

#define QAClearZBuffer(drawContext, rect, initialContext) \
     (drawContext)->clearZBuffer(drawContext, rect, initialContext)

#define QATextureNewFromDrawContext(drawContext, flags, newTexture) \
      (drawContext)->textureFromContext(drawContext, flags, newTexture)

#define QABitmapNewFromDrawContext(drawContext, flags, newBitmap) \
     (drawContext)->bitmapFromContext(drawContext, flags, newBitmap)

#define QABusy(drawContext) \
     (drawContext)->busy(drawContext)

#define QASwapBuffers(drawContext, dirtyRect) \
      (drawContext)->swapBuffers(drawContext, dirtyRect)





/********************************************************************
 * TQAVersion sets the TQADrawContext 'version' field. It is set by
 * the manager to indicate the version of the TQADrawContext structure.
 *******************************************************************/
enum TQAVersion {
  kQAVersion_Prerelease         = 0,
  kQAVersion_1_0                = 1,
  kQAVersion_1_0_5              = 2,    /* Added tri mesh functions, color tables */
  kQAVersion_1_5                = 3,    /* Added call backs, texture compression, and new error return code */
  kQAVersion_1_6                = 4     /* Added QAAccess_xxx, fog, _Options2, Clear_xxx, etc. */
};
typedef enum TQAVersion TQAVersion;



/***********************************************************************
 * TQADrawContext structure holds method pointers.
 * This is a forward refrence. The structure is defined later.
 **********************************************************************/
typedef struct TQADrawContext           TQADrawContext;
/************************************************************************************************
 *
 * Typedefs of draw method functions provided by the drawing engine. One function pointer
 * for each of these function types in stored in the TQADrawContext public data structure.
 *
 * These functions should be accessed through the QA<function>(context,...) macros,
 * defined above.
 *
 ***********************************************************************************************/
typedef CALLBACK_API_C( void , TQAStandardNoticeMethod )(const TQADrawContext *drawContext, void *refCon);
typedef CALLBACK_API_C( void , TQABufferNoticeMethod )(const TQADrawContext *drawContext, const TQADevice *buffer, const TQARect *dirtyRect, void *refCon);
union TQANoticeMethod {
  TQAStandardNoticeMethod  standardNoticeMethod; /* Used for non-buffer related methods */
  TQABufferNoticeMethod  bufferNoticeMethod;  /* Used for buffer handling methods */
};
typedef union TQANoticeMethod           TQANoticeMethod;
typedef CALLBACK_API_C( void , TQASetFloat )(TQADrawContext *drawContext, TQATagFloat tag, float newValue);
typedef CALLBACK_API_C( void , TQASetInt )(TQADrawContext *drawContext, TQATagInt tag, unsigned long newValue);
typedef CALLBACK_API_C( void , TQASetPtr )(TQADrawContext *drawContext, TQATagPtr tag, const void *newValue);
typedef CALLBACK_API_C( float , TQAGetFloat )(const TQADrawContext *drawContext, TQATagFloat tag);
typedef CALLBACK_API_C( unsigned long , TQAGetInt )(const TQADrawContext *drawContext, TQATagInt tag);
typedef CALLBACK_API_C( void *, TQAGetPtr )(const TQADrawContext *drawContext, TQATagPtr tag);
typedef CALLBACK_API_C( void , TQADrawPoint )(const TQADrawContext *drawContext, const TQAVGouraud *v);
typedef CALLBACK_API_C( void , TQADrawLine )(const TQADrawContext *drawContext, const TQAVGouraud *v0, const TQAVGouraud *v1);
typedef CALLBACK_API_C( void , TQADrawTriGouraud )(const TQADrawContext *drawContext, const TQAVGouraud *v0, const TQAVGouraud *v1, const TQAVGouraud *v2, unsigned long flags);
typedef CALLBACK_API_C( void , TQADrawTriTexture )(const TQADrawContext *drawContext, const TQAVTexture *v0, const TQAVTexture *v1, const TQAVTexture *v2, unsigned long flags);
typedef CALLBACK_API_C( void , TQASubmitVerticesGouraud )(const TQADrawContext *drawContext, unsigned long nVertices, const TQAVGouraud *vertices);
typedef CALLBACK_API_C( void , TQASubmitVerticesTexture )(const TQADrawContext *drawContext, unsigned long nVertices, const TQAVTexture *vertices);
typedef CALLBACK_API_C( void , TQADrawTriMeshGouraud )(const TQADrawContext *drawContext, unsigned long nTriangles, const TQAIndexedTriangle *triangles);
typedef CALLBACK_API_C( void , TQADrawTriMeshTexture )(const TQADrawContext *drawContext, unsigned long nTriangles, const TQAIndexedTriangle *triangles);
typedef CALLBACK_API_C( void , TQADrawVGouraud )(const TQADrawContext *drawContext, unsigned long nVertices, TQAVertexMode vertexMode, const TQAVGouraud vertices[], const unsigned long flags[]);
typedef CALLBACK_API_C( void , TQADrawVTexture )(const TQADrawContext *drawContext, unsigned long nVertices, TQAVertexMode vertexMode, const TQAVTexture vertices[], const unsigned long flags[]);
typedef CALLBACK_API_C( void , TQADrawBitmap )(const TQADrawContext *drawContext, const TQAVGouraud *v, TQABitmap *bitmap);
typedef CALLBACK_API_C( void , TQARenderStart )(const TQADrawContext *drawContext, const TQARect *dirtyRect, const TQADrawContext *initialContext);
typedef CALLBACK_API_C( TQAError , TQARenderEnd )(const TQADrawContext *drawContext, const TQARect *modifiedRect);
typedef CALLBACK_API_C( TQAError , TQARenderAbort )(const TQADrawContext * drawContext);
typedef CALLBACK_API_C( TQAError , TQAFlush )(const TQADrawContext * drawContext);
typedef CALLBACK_API_C( TQAError , TQASync )(const TQADrawContext * drawContext);
typedef CALLBACK_API_C( TQAError , TQASetNoticeMethod )(const TQADrawContext *drawContext, TQAMethodSelector method, TQANoticeMethod completionCallBack, void *refCon);
typedef CALLBACK_API_C( TQAError , TQAGetNoticeMethod )(const TQADrawContext *drawContext, TQAMethodSelector method, TQANoticeMethod *completionCallBack, void **refCon);
typedef CALLBACK_API_C( void , TQASubmitMultiTextureParams )(const TQADrawContext *drawContext, unsigned long nParams, const TQAVMultiTexture *params);
typedef CALLBACK_API_C( TQAError , TQAAccessDrawBuffer )(const TQADrawContext *drawContext, TQAPixelBuffer *buffer);
typedef CALLBACK_API_C( TQAError , TQAAccessDrawBufferEnd )(const TQADrawContext *drawContext, const TQARect *dirtyRect);
typedef CALLBACK_API_C( TQAError , TQAAccessZBuffer )(const TQADrawContext *drawContext, TQAZBuffer *buffer);
typedef CALLBACK_API_C( TQAError , TQAAccessZBufferEnd )(const TQADrawContext *drawContext, const TQARect *dirtyRect);
typedef CALLBACK_API_C( TQAError , TQAClearDrawBuffer )(const TQADrawContext *drawContext, const TQARect *rect, const TQADrawContext *initialContext);
typedef CALLBACK_API_C( TQAError , TQAClearZBuffer )(const TQADrawContext *drawContext, const TQARect *rect, const TQADrawContext *initialContext);
typedef CALLBACK_API_C( TQAError , TQATextureNewFromDrawContext )(const TQADrawContext *drawContext, unsigned long flags, TQATexture **newTexture);
typedef CALLBACK_API_C( TQAError , TQABitmapNewFromDrawContext )(const TQADrawContext *drawContext, unsigned long flags, TQABitmap **newBitmap);
typedef CALLBACK_API_C( TQABoolean , TQABusy )(const TQADrawContext * drawContext);
typedef CALLBACK_API_C( TQAError , TQASwapBuffers )(const TQADrawContext *drawContext, const TQARect *dirtyRect);
/************************************************************************************************
 *
 * Public TQADrawContext structure. This contains function pointers for the chosen
 * drawing engine.
 *
 ***********************************************************************************************/
struct TQADrawContext {
  TQADrawPrivate *    drawPrivate;            /* Engine's private data for this context */
  TQAVersion          version;                /* Version number */
  TQASetFloat         setFloat;               /* Method: Set a float state variable */
  TQASetInt           setInt;                 /* Method: Set an unsigned long state variable */
  TQASetPtr           setPtr;                 /* Method: Set an unsigned long state variable */
  TQAGetFloat         getFloat;               /* Method: Get a float state variable */
  TQAGetInt           getInt;                 /* Method: Get an unsigned long state variable */
  TQAGetPtr           getPtr;                 /* Method: Get an pointer state variable */
  TQADrawPoint        drawPoint;              /* Method: Draw a point */
  TQADrawLine         drawLine;               /* Method: Draw a line */
  TQADrawTriGouraud   drawTriGouraud;         /* Method: Draw a Gouraud shaded triangle */
  TQADrawTriTexture   drawTriTexture;         /* Method: Draw a texture mapped triangle */
  TQADrawVGouraud     drawVGouraud;           /* Method: Draw Gouraud vertices */
  TQADrawVTexture     drawVTexture;           /* Method: Draw texture vertices */
  TQADrawBitmap       drawBitmap;             /* Method: Draw a bitmap */
  TQARenderStart      renderStart;            /* Method: Initialize for rendering */
  TQARenderEnd        renderEnd;              /* Method: Complete rendering and display */
  TQARenderAbort      renderAbort;            /* Method: Abort any outstanding rendering (blocking) */
  TQAFlush            flush;                  /* Method: Start render of any queued commands (non-blocking) */
  TQASync             sync;                   /* Method: Wait for completion of all rendering (blocking) */
  TQASubmitVerticesGouraud  submitVerticesGouraud; /* Method: Submit Gouraud vertices for trimesh */
  TQASubmitVerticesTexture  submitVerticesTexture; /* Method: Submit Texture vertices for trimesh */
  TQADrawTriMeshGouraud  drawTriMeshGouraud;  /* Method: Draw a Gouraud triangle mesh */
  TQADrawTriMeshTexture  drawTriMeshTexture;  /* Method: Draw a Texture triangle mesh */
  TQASetNoticeMethod  setNoticeMethod;        /* Method: Set a notice method */
  TQAGetNoticeMethod  getNoticeMethod;        /* Method: Get a notice method */
  TQASubmitMultiTextureParams  submitMultiTextureParams; /* Method: Submit Secondary texture params */
  TQAAccessDrawBuffer  accessDrawBuffer;
  TQAAccessDrawBufferEnd  accessDrawBufferEnd;
  TQAAccessZBuffer    accessZBuffer;
  TQAAccessZBufferEnd  accessZBufferEnd;
  TQAClearDrawBuffer  clearDrawBuffer;
  TQAClearZBuffer     clearZBuffer;
  TQATextureNewFromDrawContext  textureFromContext;
  TQABitmapNewFromDrawContext  bitmapFromContext;
  TQABusy             busy;
  TQASwapBuffers      swapBuffers;
};

/************************************************************************************************
 *
 * Acceleration manager function prototypes.
 *
 ***********************************************************************************************/
#if CALL_NOT_IN_CARBON
/*
 *  QADrawContextNew()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QADrawContextNew(
  const TQADevice *  device,
  const TQARect *    rect,
  const TQAClip *    clip,
  const TQAEngine *  engine,
  unsigned long      flags,
  TQADrawContext **  newDrawContext);


/*
 *  QADrawContextDelete()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( void )
QADrawContextDelete(TQADrawContext * drawContext);


/*
 *  QAColorTableNew()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QAColorTableNew(
  const TQAEngine *   engine,
  TQAColorTableType   tableType,
  void *              pixelData,
  long                transparentIndexFlag,
  TQAColorTable **    newTable);


/*
 *  QAColorTableDelete()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( void )
QAColorTableDelete(
  const TQAEngine *  engine,
  TQAColorTable *    colorTable);


/*
 *  QATextureNew()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QATextureNew(
  const TQAEngine *   engine,
  unsigned long       flags,
  TQAImagePixelType   pixelType,
  const TQAImage      images[],
  TQATexture **       newTexture);


/*
 *  QATextureDetach()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QATextureDetach(
  const TQAEngine *  engine,
  TQATexture *       texture);


/*
 *  QATextureDelete()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( void )
QATextureDelete(
  const TQAEngine *  engine,
  TQATexture *       texture);


/*
 *  QATextureBindColorTable()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QATextureBindColorTable(
  const TQAEngine *  engine,
  TQATexture *       texture,
  TQAColorTable *    colorTable);


/*
 *  QABitmapNew()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QABitmapNew(
  const TQAEngine *   engine,
  unsigned long       flags,
  TQAImagePixelType   pixelType,
  const TQAImage *    image,
  TQABitmap **        newBitmap);


/*
 *  QABitmapDetach()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QABitmapDetach(
  const TQAEngine *  engine,
  TQABitmap *        bitmap);


/*
 *  QABitmapDelete()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( void )
QABitmapDelete(
  const TQAEngine *  engine,
  TQABitmap *        bitmap);


/*
 *  QABitmapBindColorTable()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QABitmapBindColorTable(
  const TQAEngine *  engine,
  TQABitmap *        bitmap,
  TQAColorTable *    colorTable);


/*
 *  QADeviceGetFirstEngine()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAEngine * )
QADeviceGetFirstEngine(const TQADevice * device);


/*
 *  QADeviceGetNextEngine()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAEngine * )
QADeviceGetNextEngine(
  const TQADevice *  device,
  const TQAEngine *  currentEngine);


/*
 *  QAEngineCheckDevice()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QAEngineCheckDevice(
  const TQAEngine *  engine,
  const TQADevice *  device);


/*
 *  QAEngineGestalt()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QAEngineGestalt(
  const TQAEngine *    engine,
  TQAGestaltSelector   selector,
  void *               response);


/*
 *  QAEngineEnable()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QAEngineEnable(
  long   vendorID,
  long   engineID);


/*
 *  QAEngineDisable()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QAEngineDisable(
  long   vendorID,
  long   engineID);



/*
 *  QAAccessTexture()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QAAccessTexture(
  const TQAEngine *  engine,
  TQATexture *       texture,
  long               mipmapLevel,
  long               flags,
  TQAPixelBuffer *   buffer);


/*
 *  QAAccessTextureEnd()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QAAccessTextureEnd(
  const TQAEngine *  engine,
  TQATexture *       texture,
  const TQARect *    dirtyRect);


/*
 *  QAAccessBitmap()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QAAccessBitmap(
  const TQAEngine *  engine,
  TQABitmap *        bitmap,
  long               flags,
  TQAPixelBuffer *   buffer);


/*
 *  QAAccessBitmapEnd()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QAAccessBitmapEnd(
  const TQAEngine *  engine,
  TQABitmap *        bitmap,
  const TQARect *    dirtyRect);





#endif  /* CALL_NOT_IN_CARBON */

#if TARGET_OS_MAC
#if CALL_NOT_IN_CARBON
/*
 *  QARegisterDrawNotificationProc()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QARegisterDrawNotificationProc(
  Rect *                           globalRect,
  TQADrawNotificationProcPtr       proc,
  long                             refCon,
  TQADrawNotificationProcRefNum *  refNum);


/*
 *  QAUnregisterDrawNotificationProc()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQAError )
QAUnregisterDrawNotificationProc(TQADrawNotificationProcRefNum refNum);


#endif  /* CALL_NOT_IN_CARBON */

#endif  /* TARGET_OS_MAC */








#if PRAGMA_ENUM_ALWAYSINT
    #pragma enumsalwaysint reset
    #ifdef __RAVE__RESTORE_TWOBYTEINTS
        #pragma fourbyteints off
    #endif
#elif PRAGMA_ENUM_OPTIONS
    #pragma option enum=reset
#elif defined(__RAVE__RESTORE_PACKED_ENUMS)
    #pragma options(pack_enums)
#endif

#if PRAGMA_STRUCT_ALIGN
    #pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
    #pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
    #pragma pack()
#endif

#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif

#ifdef __cplusplus
}
#endif

#endif /* __RAVE__ */

