RAVESystem.h

Go to the documentation of this file.

 
#ifndef __RAVESYSTEM__
#define __RAVESYSTEM__
 
#ifndef __CONDITIONALMACROS__
#include <ConditionalMacros.h>
#endif
 
#ifndef __RAVE__
#include <RAVE.h>
#endif
 
#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 __RAVESYSTEM__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 __RAVESYSTEM__RESTORE_PACKED_ENUMS
#pragma options(!pack_enums)
#endif
#endif
 
    /*************************************************************************************************
     *
     * Typedefs of texture/bitmap method functions provided by the drawing engine.
     *
     ***********************************************************************************************/
    typedef CALLBACK_API_C(TQAError, TQAColorTableNew)(TQAColorTableType pixelType,
                                                       void *pixelData,
                                                       long transparentIndex,
                                                       TQAColorTable **newTable);
    typedef CALLBACK_API_C(void, TQAColorTableDelete)(TQAColorTable *colorTable);
    typedef CALLBACK_API_C(TQAError, TQATextureNew)(unsigned long flags,
                                                    TQAImagePixelType pixelType,
                                                    const TQAImage images[],
                                                    TQATexture **newTexture);
    typedef CALLBACK_API_C(TQAError, TQATextureDetach)(TQATexture *texture);
    typedef CALLBACK_API_C(void, TQATextureDelete)(TQATexture *texture);
    typedef CALLBACK_API_C(TQAError,
                           TQATextureBindColorTable)(TQATexture *texture,
                                                     TQAColorTable *colorTable);
    typedef CALLBACK_API_C(TQAError, TQABitmapNew)(unsigned long flags,
                                                   TQAImagePixelType pixelType,
                                                   const TQAImage *image,
                                                   TQABitmap **newBitmap);
    typedef CALLBACK_API_C(TQAError, TQABitmapDetach)(TQABitmap *bitmap);
    typedef CALLBACK_API_C(void, TQABitmapDelete)(TQABitmap *bitmap);
    typedef CALLBACK_API_C(TQAError,
                           TQABitmapBindColorTable)(TQABitmap *bitmap,
                                                    TQAColorTable *colorTable);
    /*************************************************************************************************
     *
     * Typedefs of private (system-only) functions provided by the drawing engine.
     *
     * The TQADrawPrivateNew function returns a TQADrawPrivate *, which points to
     *the engine-specific private data created for the context. (TQADrawPrivate is a
     *dummy type which is then cast to the correct engine-specific datatype by the
     *engine code.)
     *
     * The TQADrawPrivateDelete function deletes the engine-specific private data.
     *
     * TQAStorePrivateNew and TQAStorePrivateDelete provide the same function as
     *QADrawPrivateNew and TQADrawPrivateDelete, but for the texture and bitmap
     *storage context.
     *
     * TQADrawMethodGet and TQAStoreMethodGet are called by the RAVE manager to
     *retrieve the method pointers for a drawing engine.
     *
     * The TQAEngineCheckDevice function returns TRUE if the engine can render to
     *the indicated GDevice.
     *
     ***********************************************************************************************/
    typedef CALLBACK_API_C(TQAError, TQADrawPrivateNew)(
        TQADrawContext *newDrawContext, const TQADevice *device,
        const TQARect *rect, const TQAClip *clip, unsigned long flags);
    typedef CALLBACK_API_C(void, TQADrawPrivateDelete)(TQADrawPrivate *drawPrivate);
    typedef CALLBACK_API_C(TQAError, TQAEngineCheckDevice)(const TQADevice *device);
    typedef CALLBACK_API_C(TQAError, TQAEngineGestalt)(TQAGestaltSelector selector,
                                                       void *response);
 
    typedef CALLBACK_API_C(TQAError, TQAAccessTexture)(TQATexture *texture,
                                                       long mipmapLevel, long flags,
                                                       TQAPixelBuffer *buffer);
    typedef CALLBACK_API_C(TQAError, TQAAccessTextureEnd)(TQATexture *texture,
                                                          const TQARect *dirtyRect);
    typedef CALLBACK_API_C(TQAError, TQAAccessBitmap)(TQABitmap *bitmap, long flags,
                                                      TQAPixelBuffer *buffer);
    typedef CALLBACK_API_C(TQAError, TQAAccessBitmapEnd)(TQABitmap *bitmap,
                                                         const TQARect *dirtyRect);
    /*************************************************************************************************
     *
     * The TQAEngineMethod union is used to represent a single engine method (it's a
     * parameter to QAEngineGetMethod). TQAEngineMethodTag identifies which method
     *is being requested.
     *
     ***********************************************************************************************/
    union TQAEngineMethod
    {
        TQADrawPrivateNew drawPrivateNew; 
        TQADrawPrivateDelete
            drawPrivateDelete; 
        TQAEngineCheckDevice
            engineCheckDevice;          
        TQAEngineGestalt engineGestalt; 
        TQATextureNew
            textureNew; 
        TQATextureDetach
            textureDetach;              
        TQATextureDelete textureDelete; 
        TQABitmapNew bitmapNew;         
        TQABitmapDetach
            bitmapDetach;                     
        TQABitmapDelete bitmapDelete;         
        TQAColorTableNew colorTableNew;       
        TQAColorTableDelete colorTableDelete; 
        TQATextureBindColorTable
            textureBindColorTable; 
        TQABitmapBindColorTable
            bitmapBindColorTable; 
        TQAAccessTexture accessTexture;
        TQAAccessTextureEnd accessTextureEnd;
        TQAAccessBitmap accessBitmap;
        TQAAccessBitmapEnd accessBitmapEnd;
    };
    typedef union TQAEngineMethod TQAEngineMethod;
    enum TQAEngineMethodTag
    {
        kQADrawPrivateNew = 0,
        kQADrawPrivateDelete = 1,
        kQAEngineCheckDevice = 2,
        kQAEngineGestalt = 3,
        kQATextureNew = 4,
        kQATextureDetach = 5,
        kQATextureDelete = 6,
        kQABitmapNew = 7,
        kQABitmapDetach = 8,
        kQABitmapDelete = 9,
        kQAColorTableNew = 10,
        kQAColorTableDelete = 11,
        kQATextureBindColorTable = 12,
        kQABitmapBindColorTable = 13,
        kQAAccessTexture = 14,
        kQAAccessTextureEnd = 15,
        kQAAccessBitmap = 16,
        kQAAccessBitmapEnd = 17
    };
    typedef enum TQAEngineMethodTag TQAEngineMethodTag;
 
    /*************************************************************************************************
     *
     * QARegisterEngine() registers a new engine. This is called at boot time by the
     *drawing engine initialization code to register itself with the system. This
     *call takes only one parameter, the engine's function that allows the manager
     *to request the other methods.
     *
     ***********************************************************************************************/
    typedef CALLBACK_API_C(TQAError,
                           TQAEngineGetMethod)(TQAEngineMethodTag methodTag,
                                               TQAEngineMethod *method);
#if CALL_NOT_IN_CARBON
    TQAError
    QARegisterEngine(TQAEngineGetMethod engineGetMethod);
 
    TQAError
    QARegisterEngineWithRefCon(TQAEngineGetMethod engineGetMethod, long refCon);
 
    long
    QAGetCurrentEngineRefCon(void);
 
/*************************************************************************************************
 *
 * The TQADrawMethod union is used to represent a single draw context method
 *(it's a parameter to QARegisterDrawMethod). TQADrawMethodTag identifies which
 *method is being passed.
 *
 ***********************************************************************************************/
#endif 
    union TQADrawMethod
    {
        TQASetFloat setFloat;   
        TQASetInt setInt;       
        TQASetPtr setPtr;       
        TQAGetFloat getFloat;   
        TQAGetInt getInt;       
        TQAGetPtr getPtr;       
        TQADrawPoint drawPoint; 
        TQADrawLine drawLine;   
        TQADrawTriGouraud
            drawTriGouraud; 
        TQADrawTriTexture
            drawTriTexture;           
        TQADrawVGouraud drawVGouraud; 
        TQADrawVTexture drawVTexture; 
        TQADrawBitmap drawBitmap;     
        TQARenderStart renderStart;   
        TQARenderEnd renderEnd;       
        TQARenderAbort
            renderAbort; 
        TQAFlush
            flush;    
        TQASync sync; 
        TQASubmitVerticesGouraud
            submitVerticesGouraud; 
        TQASubmitVerticesTexture
            submitVerticesTexture; 
        TQADrawTriMeshGouraud
            drawTriMeshGouraud; 
        TQADrawTriMeshTexture
            drawTriMeshTexture;             
        TQASetNoticeMethod setNoticeMethod; 
        TQAGetNoticeMethod getNoticeMethod; 
        TQASubmitMultiTextureParams
            submitMultiTextureParams; 
        TQAAccessDrawBuffer accessDrawBuffer;
        TQAAccessDrawBufferEnd accessDrawBufferEnd;
        TQAAccessZBuffer accessZBuffer;
        TQAAccessZBufferEnd accessZBufferEnd;
        TQAClearDrawBuffer clearDrawBuffer;
        TQAClearZBuffer clearZBuffer;
        TQATextureNewFromDrawContext textureFromContext;
        TQABitmapNewFromDrawContext bitmapFromContext;
        TQABusy busy;
        TQASwapBuffers swapBuffers;
    };
    typedef union TQADrawMethod TQADrawMethod;
    enum TQADrawMethodTag
    {
        kQASetFloat = 0,
        kQASetInt = 1,
        kQASetPtr = 2,
        kQAGetFloat = 3,
        kQAGetInt = 4,
        kQAGetPtr = 5,
        kQADrawPoint = 6,
        kQADrawLine = 7,
        kQADrawTriGouraud = 8,
        kQADrawTriTexture = 9,
        kQADrawVGouraud = 10,
        kQADrawVTexture = 11,
        kQADrawBitmap = 12,
        kQARenderStart = 13,
        kQARenderEnd = 14,
        kQARenderAbort = 15,
        kQAFlush = 16,
        kQASync = 17,
        kQASubmitVerticesGouraud = 18,
        kQASubmitVerticesTexture = 19,
        kQADrawTriMeshGouraud = 20,
        kQADrawTriMeshTexture = 21,
        kQASetNoticeMethod = 22,
        kQAGetNoticeMethod = 23,
        kQSubmitMultiTextureParams = 24,
        kQAccessDrawBuffer = 25,
        kQAccessDrawBufferEnd = 26,
        kQAccessZBuffer = 27,
        kQAccessZBufferEnd = 28,
        kQClearDrawBuffer = 29,
        kQClearZBuffer = 30,
        kQTextureNewFromDrawContext = 31,
        kQBitmapNewFromDrawContext = 32,
        kQBusy = 33,
        kQSwapBuffers = 34
    };
    typedef enum TQADrawMethodTag TQADrawMethodTag;
 
/*************************************************************************************************
 *
 * System call to register a new method for an engine. This is called during the
 *engine's draw private new functions (to set the initial value of the draw
 *methods), and possibly at other times when the engine needs to change a draw
 *method.
 *
 ***********************************************************************************************/
#if CALL_NOT_IN_CARBON
    TQAError
    QARegisterDrawMethod(TQADrawContext *drawContext, TQADrawMethodTag methodTag,
                         TQADrawMethod method);
 
#endif 
#if PRAGMA_ENUM_ALWAYSINT
#pragma enumsalwaysint reset
#ifdef __RAVESYSTEM__RESTORE_TWOBYTEINTS
#pragma fourbyteints off
#endif
#elif PRAGMA_ENUM_OPTIONS
#pragma option enum =reset
#elif defined(__RAVESYSTEM__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