/* File: RAVE.h Contains: Interface for RAVE (Renderer Acceleration Virtual Engine) Version: Technology: Quickdraw 3D 1.6 Release: QuickTime 4.0 Copyright: (c) 1995-1998 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 #endif #if TARGET_OS_MAC #ifndef __MACTYPES__ #include #endif #ifndef __QUICKDRAW__ #include #endif #ifndef __QDOFFSCREEN__ #include #endif #endif /* TARGET_OS_MAC */ #if TARGET_OS_WIN32 #include #ifndef RAVE_NO_DIRECTDRAW #include #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 #pragma enumsalwaysint on #elif PRAGMA_ENUM_OPTIONS #pragma option enum=int #elif PRAGMA_ENUM_PACK #if __option(pack_enums) #define PRAGMA_ENUM_PACK__RAVE__ #endif #pragma options(!pack_enums) #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 */ kQATagGL_DepthBG = 112, kQATagGL_TextureBorder_a = 113, kQATagGL_TextureBorder_r = 114, kQATagGL_TextureBorder_g = 115, kQATagGL_TextureBorder_b = 116 }; 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, /* OpenGL Only: Znew == Zbuffer is visible */ kQAZFunction_LE = 3, /* OpenGL Only: Znew <= Zbuffer is visible */ kQAZFunction_GT = 4, /* OpenGL Only: Znew > Zbuffer is visible */ kQAZFunction_NE = 5, /* OpenGL Only: Znew != Zbuffer is visible */ kQAZFunction_GE = 6, /* OpenGL Only: Znew >= Zbuffer is visible */ kQAZFunction_True = 7 /* Znew is always 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 ??? */ }; /* 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, newTexture) \ (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(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, TQATexture **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. * ***********************************************************************************************/ EXTERN_API_C( TQAError ) QADrawContextNew (const TQADevice * device, const TQARect * rect, const TQAClip * clip, const TQAEngine * engine, unsigned long flags, TQADrawContext ** newDrawContext); EXTERN_API_C( void ) QADrawContextDelete (TQADrawContext * drawContext); EXTERN_API_C( TQAError ) QAColorTableNew (const TQAEngine * engine, TQAColorTableType tableType, void * pixelData, long transparentIndexFlag, TQAColorTable ** newTable); EXTERN_API_C( void ) QAColorTableDelete (const TQAEngine * engine, TQAColorTable * colorTable); EXTERN_API_C( TQAError ) QATextureNew (const TQAEngine * engine, unsigned long flags, TQAImagePixelType pixelType, const TQAImage images[], TQATexture ** newTexture); EXTERN_API_C( TQAError ) QATextureDetach (const TQAEngine * engine, TQATexture * texture); EXTERN_API_C( void ) QATextureDelete (const TQAEngine * engine, TQATexture * texture); EXTERN_API_C( TQAError ) QATextureBindColorTable (const TQAEngine * engine, TQATexture * texture, TQAColorTable * colorTable); EXTERN_API_C( TQAError ) QABitmapNew (const TQAEngine * engine, unsigned long flags, TQAImagePixelType pixelType, const TQAImage * image, TQABitmap ** newBitmap); EXTERN_API_C( TQAError ) QABitmapDetach (const TQAEngine * engine, TQABitmap * bitmap); EXTERN_API_C( void ) QABitmapDelete (const TQAEngine * engine, TQABitmap * bitmap); EXTERN_API_C( TQAError ) QABitmapBindColorTable (const TQAEngine * engine, TQABitmap * bitmap, TQAColorTable * colorTable); EXTERN_API_C( TQAEngine *) QADeviceGetFirstEngine (const TQADevice * device); EXTERN_API_C( TQAEngine *) QADeviceGetNextEngine (const TQADevice * device, const TQAEngine * currentEngine); EXTERN_API_C( TQAError ) QAEngineCheckDevice (const TQAEngine * engine, const TQADevice * device); EXTERN_API_C( TQAError ) QAEngineGestalt (const TQAEngine * engine, TQAGestaltSelector selector, void * response); EXTERN_API_C( TQAError ) QAEngineEnable (long vendorID, long engineID); EXTERN_API_C( TQAError ) QAEngineDisable (long vendorID, long engineID); EXTERN_API_C( TQAError ) QAAccessTexture (const TQAEngine * engine, TQATexture * texture, long mipmapLevel, long flags, TQAPixelBuffer * buffer); EXTERN_API_C( TQAError ) QAAccessTextureEnd (const TQAEngine * engine, TQATexture * texture, const TQARect * dirtyRect); EXTERN_API_C( TQAError ) QAAccessBitmap (const TQAEngine * engine, TQABitmap * bitmap, long flags, TQAPixelBuffer * buffer); EXTERN_API_C( TQAError ) QAAccessBitmapEnd (const TQAEngine * engine, TQABitmap * bitmap, const TQARect * dirtyRect); #if TARGET_OS_MAC EXTERN_API_C( TQAError ) QARegisterDrawNotificationProc (Rect * globalRect, TQADrawNotificationProcPtr proc, long refCon, TQADrawNotificationProcRefNum * refNum); EXTERN_API_C( TQAError ) QAUnregisterDrawNotificationProc (TQADrawNotificationProcRefNum refNum); #endif /* TARGET_OS_MAC */ #if PRAGMA_ENUM_ALWAYSINT #pragma enumsalwaysint reset #elif PRAGMA_ENUM_OPTIONS #pragma option enum=reset #elif defined(PRAGMA_ENUM_PACK__RAVE__) #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__ */