tf2/tf2_src/common/quicktime_win32/QD3DRenderer.h

/*
     File:       QD3DRenderer.h
 
     Contains:   Q3Renderer types and routines
 
     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 __QD3DRENDERER__
#define __QD3DRENDERER__

#ifndef __QD3D__
#include <QD3D.h>
#endif

#ifndef __QD3DSET__
#include <QD3DSet.h>
#endif

#ifndef __QD3DVIEW__
#include <QD3DView.h>
#endif

#ifndef __RAVE__
#include <RAVE.h>
#endif


#if TARGET_OS_MAC
#ifndef __EVENTS__
#include <Events.h>
#endif

#endif  /* TARGET_OS_MAC */



#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 __QD3DRENDERER__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 __QD3DRENDERER__RESTORE_PACKED_ENUMS
        #pragma options(!pack_enums)
    #endif
#endif

/******************************************************************************
 **                                                                          **
 **                         User Interface Things                            **
 **                                                                          **
 *****************************************************************************/
#if TARGET_OS_MAC
/*
 *  A callback to an application's event handling code. This is needed to    
 *  support movable modal dialogs. The dialog's event filter calls this      
 *  callback with events it does not handle.                                 
 *  If an application handles the event it should return kQ3True.            
 *  If the application does not handle the event it must return kQ3False and 
 *  the dialog's event filter will pass the event to the system unhandled.   
 */
typedef CALLBACK_API_C( TQ3Boolean , TQ3MacOSDialogEventHandler )(const EventRecord * event);
struct TQ3DialogAnchor {
  TQ3MacOSDialogEventHandler  clientEventHandler;
};
typedef struct TQ3DialogAnchor          TQ3DialogAnchor;
#endif  /* TARGET_OS_MAC */

#if TARGET_OS_WIN32
struct TQ3DialogAnchor {
  HWND                ownerWindow;
};
typedef struct TQ3DialogAnchor          TQ3DialogAnchor;
#endif  /* TARGET_OS_WIN32 */

#if TARGET_OS_UNIX
struct TQ3DialogAnchor {
  void *              notUsed;                /* place holder */
};
typedef struct TQ3DialogAnchor          TQ3DialogAnchor;
#endif  /* TARGET_OS_UNIX */

/******************************************************************************
 **                                                                          **
 **                         Renderer Functions                               **
 **                                                                          **
 *****************************************************************************/
#if CALL_NOT_IN_CARBON
/*
 *  Q3Renderer_NewFromType()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3RendererObject )
Q3Renderer_NewFromType(TQ3ObjectType rendererObjectType);


/*
 *  Q3Renderer_GetType()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3ObjectType )
Q3Renderer_GetType(TQ3RendererObject renderer);



/* Q3Renderer_Flush has been replaced by Q3View_Flush */
/* Q3Renderer_Sync has been replaced by Q3View_Sync */
#endif  /* CALL_NOT_IN_CARBON */


/*
 *  Q3Renderer_IsInteractive
 *      Determine if this renderer is intended to be used interactively.
 */
#if CALL_NOT_IN_CARBON
/*
 *  Q3Renderer_IsInteractive()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Boolean )
Q3Renderer_IsInteractive(TQ3RendererObject renderer);



/*
 *  Q3Renderer_HasModalConfigure
 *      Determine if this renderer has a modal settings dialog.
 *
 *  Q3Renderer_ModalConfigure
 *      Have the renderer pop up a modal dialog box to configure its settings.
 *  dialogAnchor - is platform specific data passed by the client to support
 *      movable modal dialogs. 
 *    MacOS: this is a callback to the calling application's event handler.
 *      The renderer calls this function with events not handled by the 
 *      settings dialog. This is necessary in order to support movable modal 
 *      dialogs. An application's event handler must return kQ3True if it 
 *      handles the event passed to the callback or kQ3False if not. 
 *      An application which doesn't want to support a movable modal configure
 *      dialog should pass NULL for the clientEventHandler of TQ3DialogAnchor.
 *    Win32: this is the HWND of the owning window (typically an application's
 *      main window).
 *  canceled - returns a boolean inditacating that the user canceled the 
 *  dialog.
 *      
 */
/*
 *  Q3Renderer_HasModalConfigure()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Boolean )
Q3Renderer_HasModalConfigure(TQ3RendererObject renderer);


/*
 *  Q3Renderer_ModalConfigure()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3Renderer_ModalConfigure(
  TQ3RendererObject   renderer,
  TQ3DialogAnchor     dialogAnchor,
  TQ3Boolean *        canceled);


/*
 *  Q3RendererClass_GetNickNameString
 *      Allows an application to get a renderers name string, the 
 *      renderer is responsible for storing this in a localizable format
 *      for example as a resource.  This string can then be used to provide
 *      a selection mechanism for an application (for example in a menu).
 *
 *      If this call returns nil in the supplied string, then the App may 
 *      choose to use the class name for the renderer.  You should always 
 *      try to get the name string before using the class name, since the
 *      class name is not localizable.
 */
/*
 *  Q3RendererClass_GetNickNameString()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3RendererClass_GetNickNameString(
  TQ3ObjectType              rendererClassType,
  TQ3ObjectClassNameString   rendererClassString);



/*
 *  Q3Renderer_GetConfigurationData
 *      Allows an application to collect private renderer configuration data
 *      which it will then save. For example in a preference file or in a 
 *      style template. An application should tag this data with the 
 *      Renderer's object  name.
 *  
 *      if dataBuffer is NULL actualDataSize returns the required size in 
 *      bytes of a data buffer large enough to store private data. 
 *
 *      bufferSize is the actual size of the memory block pointed to by 
 *      dataBuffer
 *
 *      actualDataSize - on return the actual number of bytes written to the 
 *      buffer or if dataBuffer is NULL the required size of dataBuffer
 * 
 */
/*
 *  Q3Renderer_GetConfigurationData()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3Renderer_GetConfigurationData(
  TQ3RendererObject   renderer,
  unsigned char *     dataBuffer,
  unsigned long       bufferSize,
  unsigned long *     actualDataSize);


/*
 *  Q3Renderer_SetConfigurationData()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3Renderer_SetConfigurationData(
  TQ3RendererObject   renderer,
  unsigned char *     dataBuffer,
  unsigned long       bufferSize);




/******************************************************************************
 **                                                                          **
 **                     Interactive Renderer Specific Functions              **
 **                                                                          **
 *****************************************************************************/
/* CSG IDs attribute */
#define kQ3AttributeTypeConstructiveSolidGeometryID     Q3_OBJECT_TYPE('c','s','g','i')
/* Object IDs, to be applied as attributes on geometries */
#endif  /* CALL_NOT_IN_CARBON */

#define kQ3SolidGeometryObjNone (-1)
#define kQ3SolidGeometryObjA    0
#define kQ3SolidGeometryObjB    1
#define kQ3SolidGeometryObjC    2
#define kQ3SolidGeometryObjD    3
#define kQ3SolidGeometryObjE    4
/* Possible CSG equations */
enum TQ3CSGEquation {
  kQ3CSGEquationAandB           = (long)0x88888888,
  kQ3CSGEquationAandnotB        = 0x22222222,
  kQ3CSGEquationAanBonCad       = 0x2F222F22,
  kQ3CSGEquationnotAandB        = 0x44444444,
  kQ3CSGEquationnAaBorCanB      = 0x74747474
};
typedef enum TQ3CSGEquation TQ3CSGEquation;

#if CALL_NOT_IN_CARBON
/*
 *  Q3InteractiveRenderer_SetCSGEquation()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_SetCSGEquation(
  TQ3RendererObject   renderer,
  TQ3CSGEquation      equation);


/*
 *  Q3InteractiveRenderer_GetCSGEquation()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_GetCSGEquation(
  TQ3RendererObject   renderer,
  TQ3CSGEquation *    equation);


/*
 *  Q3InteractiveRenderer_SetPreferences()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_SetPreferences(
  TQ3RendererObject   renderer,
  long                vendorID,
  long                engineID);


/*
 *  Q3InteractiveRenderer_GetPreferences()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_GetPreferences(
  TQ3RendererObject   renderer,
  long *              vendorID,
  long *              engineID);


/*
 *  Q3InteractiveRenderer_SetDoubleBufferBypass()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_SetDoubleBufferBypass(
  TQ3RendererObject   renderer,
  TQ3Boolean          bypass);


/*
 *  Q3InteractiveRenderer_GetDoubleBufferBypass()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_GetDoubleBufferBypass(
  TQ3RendererObject   renderer,
  TQ3Boolean *        bypass);


/*
 *  Q3InteractiveRenderer_SetRAVEContextHints()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_SetRAVEContextHints(
  TQ3RendererObject   renderer,
  unsigned long       RAVEContextHints);


/*
 *  Q3InteractiveRenderer_GetRAVEContextHints()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_GetRAVEContextHints(
  TQ3RendererObject   renderer,
  unsigned long *     RAVEContextHints);


/*
 *  Q3InteractiveRenderer_SetRAVETextureFilter()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_SetRAVETextureFilter(
  TQ3RendererObject   renderer,
  unsigned long       RAVEtextureFilterValue);


/*
 *  Q3InteractiveRenderer_GetRAVETextureFilter()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_GetRAVETextureFilter(
  TQ3RendererObject   renderer,
  unsigned long *     RAVEtextureFilterValue);


/*
 *  Q3InteractiveRenderer_CountRAVEDrawContexts()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_CountRAVEDrawContexts(
  TQ3RendererObject   renderer,
  unsigned long *     numRAVEContexts);


#endif  /* CALL_NOT_IN_CARBON */

typedef CALLBACK_API_C( void , TQ3RaveDestroyCallback )(TQ3RendererObject renderer);
#if CALL_NOT_IN_CARBON
/*
 *  Q3InteractiveRenderer_GetRAVEDrawContexts()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3InteractiveRenderer_GetRAVEDrawContexts(
  TQ3RendererObject        renderer,
  TQADrawContext **        raveDrawContextList,
  TQAEngine **             raveDrawingEnginesList,
  unsigned long *          numRAVEContexts,
  TQ3RaveDestroyCallback   raveDestroyCallback);





/******************************************************************************
 **                                                                          **
 **                         Renderer View Tools                              **
 **                                                                          **
 **                 You may only call these methods from a plug-in           **
 **                                                                          **
 *****************************************************************************/
/*
 *  Call by a renderer to call the user "idle" method, with progress 
 *  information.
 *  
 *  Pass in (view, 0, n) on first call
 *  Pass in (view, 1..n-1, n) during rendering
 *  Pass in (view, n, n) upon completion
 *  
 *  Note: The user must have supplied an idleProgress method with 
 *  Q3XView_SetIdleProgressMethod. Otherwise, the generic idle method is
 *  called with no progress data. e.g. the Q3View_SetIdleMethod method
 *  is called instead. (current and final are ignored, essentially.)
 *
 *  Returns kQ3Failure if rendering is cancelled.
 */
/*
 *  Q3XView_IdleProgress()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XView_IdleProgress(
  TQ3ViewObject   view,
  unsigned long   current,
  unsigned long   completed);


/*
 *  Called by an asynchronous renderer when it completes a frame.
 */
/*
 *  Q3XView_EndFrame()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XView_EndFrame(TQ3ViewObject view);



/******************************************************************************
 **                                                                          **
 **                         Renderer AttributeSet Tools                      **
 **                                                                          **
 **                 You may only call these methods from a plug-in           **
 **                                                                          **
 *****************************************************************************/
/*
 *  Faster access to geometry attribute sets.
 *  
 *  Returns pointer to INTERNAL data structure for elements and attributes
 *  in an attributeSet, or NULL if no attribute exists.
 *  
 *  For attributes of type kQ3AttributeType..., the internal data structure
 *  is identical to the data structure used in Q3AttributeSet_Add.
 */
/*
 *  Q3XAttributeSet_GetPointer()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( void * )
Q3XAttributeSet_GetPointer(
  TQ3AttributeSet    attributeSet,
  TQ3AttributeType   attributeType);



#endif  /* CALL_NOT_IN_CARBON */

enum {
  kQ3XAttributeMaskNone         = 0L,
  kQ3XAttributeMaskSurfaceUV    = 1 << (kQ3AttributeTypeSurfaceUV - 1),
  kQ3XAttributeMaskShadingUV    = 1 << (kQ3AttributeTypeShadingUV - 1),
  kQ3XAttributeMaskNormal       = 1 << (kQ3AttributeTypeNormal - 1),
  kQ3XAttributeMaskAmbientCoefficient = 1 << (kQ3AttributeTypeAmbientCoefficient - 1),
  kQ3XAttributeMaskDiffuseColor = 1 << (kQ3AttributeTypeDiffuseColor - 1),
  kQ3XAttributeMaskSpecularColor = 1 << (kQ3AttributeTypeSpecularColor - 1),
  kQ3XAttributeMaskSpecularControl = 1 << (kQ3AttributeTypeSpecularControl - 1),
  kQ3XAttributeMaskTransparencyColor = 1 << (kQ3AttributeTypeTransparencyColor - 1),
  kQ3XAttributeMaskSurfaceTangent = 1 << (kQ3AttributeTypeSurfaceTangent - 1),
  kQ3XAttributeMaskHighlightState = 1 << (kQ3AttributeTypeHighlightState - 1),
  kQ3XAttributeMaskSurfaceShader = 1 << (kQ3AttributeTypeSurfaceShader - 1),
  kQ3XAttributeMaskCustomAttribute = (long)0x80000000,
  kQ3XAttributeMaskAll          = 0x800007FF,
  kQ3XAttributeMaskInherited    = 0x03FF,
  kQ3XAttributeMaskInterpolated = kQ3XAttributeMaskSurfaceUV | kQ3XAttributeMaskShadingUV | kQ3XAttributeMaskNormal | kQ3XAttributeMaskAmbientCoefficient | kQ3XAttributeMaskDiffuseColor | kQ3XAttributeMaskSpecularColor | kQ3XAttributeMaskSpecularControl | kQ3XAttributeMaskTransparencyColor | kQ3XAttributeMaskSurfaceTangent
};


typedef unsigned long                   TQ3XAttributeMask;
#if CALL_NOT_IN_CARBON
/*
 *  Q3XAttributeSet_GetMask()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3XAttributeMask )
Q3XAttributeSet_GetMask(TQ3AttributeSet attributeSet);



/******************************************************************************
 **                                                                          **
 **                         Renderer Draw Context Tools                      **
 **                                                                          **
 *****************************************************************************/
#endif  /* CALL_NOT_IN_CARBON */

typedef struct OpaqueTQ3XDrawRegion*    TQ3XDrawRegion;
#if CALL_NOT_IN_CARBON
/*
 *  Q3XDrawContext_GetDrawRegion()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawContext_GetDrawRegion(
  TQ3DrawContextObject   drawContext,
  TQ3XDrawRegion *       drawRegion);


#endif  /* CALL_NOT_IN_CARBON */

enum TQ3XDrawContextValidationMasks {
  kQ3XDrawContextValidationClearFlags = 0x00000000,
  kQ3XDrawContextValidationDoubleBuffer = 1 << 0,
  kQ3XDrawContextValidationShader = 1 << 1,
  kQ3XDrawContextValidationClearFunction = 1 << 2,
  kQ3XDrawContextValidationActiveBuffer = 1 << 3,
  kQ3XDrawContextValidationInternalOffScreen = 1 << 4,
  kQ3XDrawContextValidationPane = 1 << 5,
  kQ3XDrawContextValidationMask = 1 << 6,
  kQ3XDrawContextValidationDevice = 1 << 7,
  kQ3XDrawContextValidationWindow = 1 << 8,
  kQ3XDrawContextValidationWindowSize = 1 << 9,
  kQ3XDrawContextValidationWindowClip = 1 << 10,
  kQ3XDrawContextValidationWindowPosition = 1 << 11,
  kQ3XDrawContextValidationPlatformAttributes = 1 << 12,
  kQ3XDrawContextValidationForegroundShader = 1 << 13,
  kQ3XDrawContextValidationBackgroundShader = 1 << 14,
  kQ3XDrawContextValidationColorPalette = 1 << 15,
  kQ3XDrawContextValidationAll  = (long)0xFFFFFFFF
};
typedef enum TQ3XDrawContextValidationMasks TQ3XDrawContextValidationMasks;

typedef unsigned long                   TQ3XDrawContextValidation;
#if CALL_NOT_IN_CARBON
/*
 *  Q3XDrawContext_ClearValidationFlags()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawContext_ClearValidationFlags(TQ3DrawContextObject drawContext);


/*
 *  Q3XDrawContext_GetValidationFlags()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawContext_GetValidationFlags(
  TQ3DrawContextObject         drawContext,
  TQ3XDrawContextValidation *  validationFlags);



/******************************************************************************
 **                                                                          **
 **                         Renderer Draw Region Tools                       **
 **                                                                          **
 *****************************************************************************/
#endif  /* CALL_NOT_IN_CARBON */

enum TQ3XDevicePixelType {
                                        /* These do not indicate byte ordering   */
  kQ3XDevicePixelTypeInvalid    = 0,    /* Unknown, un-initialized type    */
  kQ3XDevicePixelTypeRGB32      = 1,    /* Alpha:8 (ignored), R:8, G:8, B:8 */
  kQ3XDevicePixelTypeARGB32     = 2,    /* Alpha:8, R:8, G:8, B:8           */
  kQ3XDevicePixelTypeRGB24      = 3,    /* 24 bits/pixel, R:8, G:8, B:8    */
  kQ3XDevicePixelTypeRGB16      = 4,    /* Alpha:1 (ignored), R:5, G:5, B:5 */
  kQ3XDevicePixelTypeARGB16     = 5,    /* Alpha:1, R:5, G:5, B:5           */
  kQ3XDevicePixelTypeRGB16_565  = 6,    /* 16 bits/pixel, R:5, G:6, B:5    */
  kQ3XDevicePixelTypeIndexed8   = 7,    /* 8-bit color table index          */
  kQ3XDevicePixelTypeIndexed4   = 8,    /* 4-bit color table index          */
  kQ3XDevicePixelTypeIndexed2   = 9,    /* 2-bit color table index          */
  kQ3XDevicePixelTypeIndexed1   = 10    /* 1-bit color table index          */
};
typedef enum TQ3XDevicePixelType TQ3XDevicePixelType;

enum TQ3XClipMaskState {
  kQ3XClipMaskFullyExposed      = 0,
  kQ3XClipMaskPartiallyExposed  = 1,
  kQ3XClipMaskNotExposed        = 2
};
typedef enum TQ3XClipMaskState TQ3XClipMaskState;

struct TQ3XColorDescriptor {
  unsigned long       redShift;
  unsigned long       redMask;
  unsigned long       greenShift;
  unsigned long       greenMask;
  unsigned long       blueShift;
  unsigned long       blueMask;
  unsigned long       alphaShift;
  unsigned long       alphaMask;
};
typedef struct TQ3XColorDescriptor      TQ3XColorDescriptor;
struct TQ3XDrawRegionDescriptor {
  unsigned long       width;
  unsigned long       height;
  unsigned long       rowBytes;
  unsigned long       pixelSize;
  TQ3XDevicePixelType  pixelType;
  TQ3XColorDescriptor  colorDescriptor;
  TQ3Endian           bitOrder;
  TQ3Endian           byteOrder;
  TQ3Bitmap *         clipMask;
};
typedef struct TQ3XDrawRegionDescriptor TQ3XDrawRegionDescriptor;
enum TQ3XDrawRegionServicesMasks {
  kQ3XDrawRegionServicesNoneFlag = 0L,
  kQ3XDrawRegionServicesClearFlag = 1 << 0,
  kQ3XDrawRegionServicesDontLockDDSurfaceFlag = 1 << 1
};
typedef enum TQ3XDrawRegionServicesMasks TQ3XDrawRegionServicesMasks;


typedef unsigned long                   TQ3XDrawRegionServices;
typedef CALLBACK_API_C( void , TQ3XDrawRegionRendererPrivateDeleteMethod )(void * rendererPrivate);
#if CALL_NOT_IN_CARBON
/*
 *  Q3XDrawRegion_GetDeviceScaleX()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetDeviceScaleX(
  TQ3XDrawRegion   drawRegion,
  float *          deviceScaleX);


/*
 *  Q3XDrawRegion_GetDeviceScaleY()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetDeviceScaleY(
  TQ3XDrawRegion   drawRegion,
  float *          deviceScaleY);



/*
 *  Q3XDrawRegion_GetDeviceOffsetX()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetDeviceOffsetX(
  TQ3XDrawRegion   drawRegion,
  float *          deviceOffsetX);


/*
 *  Q3XDrawRegion_GetDeviceOffsetY()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetDeviceOffsetY(
  TQ3XDrawRegion   drawRegion,
  float *          deviceOffsetX);



/*
 *  Q3XDrawRegion_GetWindowScaleX()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetWindowScaleX(
  TQ3XDrawRegion   drawRegion,
  float *          windowScaleX);


/*
 *  Q3XDrawRegion_GetWindowScaleY()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetWindowScaleY(
  TQ3XDrawRegion   drawRegion,
  float *          windowScaleY);



/*
 *  Q3XDrawRegion_GetWindowOffsetX()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetWindowOffsetX(
  TQ3XDrawRegion   drawRegion,
  float *          windowOffsetX);


/*
 *  Q3XDrawRegion_GetWindowOffsetY()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetWindowOffsetY(
  TQ3XDrawRegion   drawRegion,
  float *          windowOffsetY);


/*
 *  Q3XDrawRegion_IsActive()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_IsActive(
  TQ3XDrawRegion   drawRegion,
  TQ3Boolean *     isActive);



/*
 *  Q3XDrawRegion_GetNextRegion()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetNextRegion(
  TQ3XDrawRegion    drawRegion,
  TQ3XDrawRegion *  nextDrawRegion);


/* 
 *  One of the next two functions must be called before using a draw region 
 */
/*
 *  Use this Start function if double buffering/image access services from the
 *  Draw Context are not needed, you may still request clear for example
 */
/*
 *  Q3XDrawRegion_Start()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_Start(
  TQ3XDrawRegion               drawRegion,
  TQ3XDrawRegionServices       services,
  TQ3XDrawRegionDescriptor **  descriptor);


/*
 *  Use this Start function if double buffering or image access services from 
 *  the Draw Context are needed.
 */
/*
 *  Q3XDrawRegion_StartAccessToImageBuffer()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_StartAccessToImageBuffer(
  TQ3XDrawRegion               drawRegion,
  TQ3XDrawRegionServices       services,
  TQ3XDrawRegionDescriptor **  descriptor,
  void **                      image);


/*
 *  This function is used to indicate that access to a DrawRegion is ended.
 */
/*
 *  Q3XDrawRegion_End()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_End(TQ3XDrawRegion drawRegion);


/*
 *  Q3XDrawRegion_GetDeviceTransform()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetDeviceTransform(
  TQ3XDrawRegion   drawRegion,
  TQ3Matrix4x4 **  deviceTransform);


/*
 *  Q3XDrawRegion_GetClipFlags()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetClipFlags(
  TQ3XDrawRegion       drawRegion,
  TQ3XClipMaskState *  clipMaskState);


/*
 *  Q3XDrawRegion_GetClipMask()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetClipMask(
  TQ3XDrawRegion   drawRegion,
  TQ3Bitmap **     clipMask);


#endif  /* CALL_NOT_IN_CARBON */

#if TARGET_OS_MAC
#if CALL_NOT_IN_CARBON
/*
 *  Q3XDrawRegion_GetClipRegion()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetClipRegion(
  TQ3XDrawRegion   drawRegion,
  RgnHandle *      rgnHandle);


/*
 *  Q3XDrawRegion_GetGDHandle()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetGDHandle(
  TQ3XDrawRegion   drawRegion,
  GDHandle *       gdHandle);


#endif  /* CALL_NOT_IN_CARBON */

#endif  /* TARGET_OS_MAC */

#if CALL_NOT_IN_CARBON
/*
 *  Q3XDrawRegion_GetRendererPrivate()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetRendererPrivate(
  TQ3XDrawRegion   drawRegion,
  void **          rendererPrivate);


/*
 *  Q3XDrawRegion_SetRendererPrivate()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_SetRendererPrivate(
  TQ3XDrawRegion                              drawRegion,
  const void *                                rendererPrivate,
  TQ3XDrawRegionRendererPrivateDeleteMethod   deleteMethod);


/*
 *  Q3XDrawRegion_SetUseDefaultRendererFlag()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_SetUseDefaultRendererFlag(
  TQ3XDrawRegion   drawRegion,
  TQ3Boolean       flag);


/*
 *  Q3XDrawRegion_GetUseDefaultRendererFlag()
 *  
 *  Availability:
 *    Non-Carbon CFM:   not available
 *    CarbonLib:        not available
 *    Mac OS X:         not available
 */
EXTERN_API_C( TQ3Status )
Q3XDrawRegion_GetUseDefaultRendererFlag(
  TQ3XDrawRegion   drawRegion,
  TQ3Boolean *     useDefaultRenderingFlag);




/******************************************************************************
 **                                                                          **
 **                         Renderer Class Methods                           **
 **                                                                          **
 *****************************************************************************/
/*
 *  Methods from Object
 *      kQ3XMethodTypeObjectClassRegister
 *      kQ3XMethodTypeObjectClassUnregister
 *      kQ3XMethodTypeObjectNew
 *      kQ3XMethodTypeObjectDelete
 *      kQ3XMethodTypeObjectRead
 *      kQ3XMethodTypeObjectTraverse
 *      kQ3XMethodTypeObjectWrite
 *      
 *  Methods from Shared
 *      kQ3MethodTypeSharedEdited
 *
 *  Renderer Methods
 *  
 *  The renderer methods should be implemented according to the type
 *  of renderer being written.
 *
 *  For the purposes of documentation, there are two basic types of
 *  renderers: 
 *
 *      Interactive
 *          Interactive Renderer
 *          WireFrame Renderer
 *      
 *      Deferred
 *          a ray-tracer
 *          painter's algorithm renderer (cached in a BSP triangle tree)
 *          an artistic renderer (simulates a pencil drawing, etc.)
 *
 *  The main difference is how each renderer handles incoming state and 
 *  geometry.
 *
 *  An interactive renderer immediately transforms, culls, and shades
 *  incoming geometry and performs rasterization. For example, in a 
 *  single-buffered WireFrame renderer, you will see a new triangle
 *  immediately after Q3Triangle_Draw (if it's visible, of course).
 *
 *  A deferred renderer caches the view state and each geometry, 
 *  converting into any internal queue of drawing commands. Rasterization
 *  is not actually performed until all data has been submitted.
 *  
 *  For example, a ray-tracer may not rasterize anything until the
 *  end of the rendering loop, or until an EndFrame call is made.
 */

/******************************************************************************
 **                                                                          **
 **                     Renderer User Interface Methods                      **
 **                                                                          **
 *****************************************************************************/
/*
 *  kQ3XMethodTypeRendererIsInteractive
 *  
 *  There is no actual method with this - the metahandler simply returns
 *  "(TQ3XFunctionPointer)kQ3True" for this "method" if the renderer is 
 *  intended to be used in interactive settings, and   
 *  "(TQ3XFunctionPointer)kQ3False" otherwise. 
 *  
 *  If neither value is specified in the metahandler, the renderer 
 *  is *assumed to be non-interactive*!!!
 *  
 *  OPTIONAL
 */
#endif  /* CALL_NOT_IN_CARBON */

enum {
  kQ3XMethodTypeRendererIsInteractive = FOUR_CHAR_CODE('isin')
};


/*
 *  TQ3XRendererModalConfigureMethod
 *  
 *  This method should pop up a modal dialog to edit the renderer settings 
 *  found in the renderer private. 
 *  
 *  dialogAnchor - is platform specific data passed by the client to support
 *      movable modal dialogs. 
 *    MacOS: this is a callback to the calling application's event handler.
 *      The renderer calls this function with events not handled by the 
 *      settings dialog. This is necessary in order to support movable modal 
 *      dialogs. An application's event handler must return kQ3True if it 
 *      handles the event passed to the callback or kQ3False if not. 
 *      An application which doesn't want to support a movable modal configure
 *      dialog should pass NULL for the clientEventHandler of TQ3DialogAnchor.
 *      A renderer should implement a non-movable style dialog in that case.
 *    Win32: this is the HWND of the owning window (typically an application's
 *      main window).  (Win32 application modal dialogs are always movable.)
 *  canceled - returns a boolean inditacating that the user canceled the 
 *  dialog.
 *  
 *  OPTIONAL
 */
enum {
  kQ3XMethodTypeRendererModalConfigure = FOUR_CHAR_CODE('rdmc')
};

typedef CALLBACK_API_C( TQ3Status , TQ3XRendererModalConfigureMethod )(TQ3RendererObject renderer, TQ3DialogAnchor dialogAnchor, TQ3Boolean *canceled, void *rendererPrivate);
/*
 *  kQ3XMethodTypeRendererGetNickNameString
 *  
 *      Allows an application to collect the name of the renderer for
 *      display in a user interface item such as a menu.
 *  
 *      If dataBuffer is NULL actualDataSize returns the required size in 
 *      bytes of a data buffer large enough to store the renderer name. 
 *
 *      bufferSize is the actual size of the memory block pointed to by 
 *      dataBuffer
 *
 *      actualDataSize - on return the actual number of bytes written to the
 *      buffer or if dataBuffer is NULL the required size of dataBuffer
 *
 *  OPTIONAL
 */
enum {
  kQ3XMethodTypeRendererGetNickNameString = FOUR_CHAR_CODE('rdns')
};

typedef CALLBACK_API_C( TQ3Status , TQ3XRendererGetNickNameStringMethod )(unsigned char *dataBuffer, unsigned long bufferSize, unsigned long *actualDataSize);
/*
 *  kQ3XMethodTypeRendererGetConfigurationData
 *  
 *      Allows an application to collect private configuration data from the
 *      renderer which it will then save. For example in a preference file, 
 *      a registry key (on Windows) or in a style template. An application 
 *      should tag this data with the renderer's object name.
 *  
 *      If dataBuffer is NULL actualDataSize returns the required size in 
 *      bytes of a data buffer large enough to store private data. 
 *
 *      bufferSize is the actual size of the memory block pointed to by 
 *      dataBuffer
 *
 *      actualDataSize - on return the actual number of bytes written to the
 *      buffer or if dataBuffer is NULL the required size of dataBuffer
 *
 *  OPTIONAL
 */
enum {
  kQ3XMethodTypeRendererGetConfigurationData = FOUR_CHAR_CODE('rdgp')
};

typedef CALLBACK_API_C( TQ3Status , TQ3XRendererGetConfigurationDataMethod )(TQ3RendererObject renderer, unsigned char *dataBuffer, unsigned long bufferSize, unsigned long *actualDataSize, void *rendererPrivate);
/*
 *  TQ3XRendererSetConfigurationDataMethod
 *  
 *      Allows an application to pass private configuration data which has
 *      previously  been obtained from a renderer via 
 *      Q3Renderer_GetConfigurationData. For example in a preference file or 
 *      in a style template. An application should tag this data with the 
 *      renderer's object name.
 *  
 *      bufferSize is the actual size of the memory block pointed to by 
 *      dataBuffer
 *
 *  OPTIONAL
 */
enum {
  kQ3XMethodTypeRendererSetConfigurationData = FOUR_CHAR_CODE('rdsp')
};

typedef CALLBACK_API_C( TQ3Status , TQ3XRendererSetConfigurationDataMethod )(TQ3RendererObject renderer, unsigned char *dataBuffer, unsigned long bufferSize, void *rendererPrivate);
/******************************************************************************
 **                                                                          **
 **                     Renderer Drawing State Methods                       **
 **                                                                          **
 *****************************************************************************/
/*
 *  TQ3RendererStartFrame
 *  
 *  The StartFrame method is called first at Q3View_StartRendering
 *  and should:
 *      - initialize any renderer state to defaults
 *      - extract any and all useful data from the drawContext
 *
 *  If your renderer passed in kQ3RendererFlagClearBuffer at 
 *  registration, then it should also:
 *      - clear the drawContext 
 *  
 *      When clearing, your renderer may opt to:
 *      - NOT clear anything (if you touch every pixel, for example)
 *      - to clear with your own routine, or
 *      - to use the draw context default clear method by calling 
 *      Q3DrawContext_Clear. Q3DrawContext_Clear takes advantage of
 *      any available hardware in the system for clearing.
 *  
 *  This call also signals the start of all default submit commands from
 *  the view. The renderer will receive updates for the default view
 *  state via its Update methods before StartPass is called.
 *  
 *  REQUIRED
 */
enum {
  kQ3XMethodTypeRendererStartFrame = FOUR_CHAR_CODE('rdcl')
};

typedef CALLBACK_API_C( TQ3Status , TQ3XRendererStartFrameMethod )(TQ3ViewObject view, void *rendererPrivate, TQ3DrawContextObject drawContext);
/*
 *  kQ3XMethodTypeRendererStartPass
 *  TQ3XRendererStartPassMethod
 *  
 *  The StartPass method is called during Q3View_StartRendering but after
 *  the StartFrame command. It should:
 *      - collect camera and light information
 *  
 *  If your renderer supports deferred camera transformation, camera is the
 *  main camera which will be submitted in the hierarchy somewhere. It
 *  is never NULL.
 *
 *  If your renderer does not support deferred camera transformation, camera
 *  is the transformed camera.
 *
 *  If your renderer supports deferred light transformation, lights will be
 *  NULL, and will be submitted to your light draw methods instead.
 *
 *  This call signals the end of the default update state, and the start of 
 *  submit commands from the user to the view.
 *
 *  REQUIRED
 */
enum {
  kQ3XMethodTypeRendererStartPass = FOUR_CHAR_CODE('rdst')
};

typedef CALLBACK_API_C( TQ3Status , TQ3XRendererStartPassMethod )(TQ3ViewObject view, void *rendererPrivate, TQ3CameraObject camera, TQ3GroupObject lightGroup);
/*
 *  kQ3XMethodTypeRendererFlushFrame
 *  TQ3XRendererFlushFrameMethod
 *  
 *  This call is only implemented by asynchronous renderers.
 *  
 *  The FlushFrame method is called between the StartPass and EndPass
 *  methods and is called when the user wishes to flush any asynchronous
 *  drawing tasks (which draw to the drawcontext), but does not want 
 *  to block.
 *  
 *  The result of this call is that an image should "eventually" appear
 *  asynchronously.
 *  
 *  For asynchronous rendering, this call is non-blocking.
 *  
 *  An interactive renderer should ensure that all received
 *  geometries are drawn in the image.
 *  
 *  An interactive renderer that talks to hardware should force
 *  the hardware to generate an image.
 *  
 *  A deferred renderer should exhibit a similar behaviour,
 *  though it is not required.  A deferred renderer should spawn
 *  a process that generates a partial image from the currently
 *  accumulated drawing state. 
 *  
 *  However, for renderers such as ray-tracers which generally are
 *  quite compute-intensive, FlushFrame is not required and is a no-op.
 *
 *  OPTIONAL
 */
enum {
  kQ3XMethodTypeRendererFlushFrame = FOUR_CHAR_CODE('rdfl')
};

typedef CALLBACK_API_C( TQ3Status , TQ3XRendererFlushFrameMethod )(TQ3ViewObject view, void *rendererPrivate, TQ3DrawContextObject drawContext);
/*
 *  kQ3XMethodTypeRendererEndPass
 *  TQ3XRendererEndPassMethod
 *  
 *  The EndPass method is called at Q3View_EndRendering and signals
 *  the end of submit commands to the view.
 *
 *  If an error occurs, the renderer should call Q3XError_Post and
 *  return kQ3ViewStatusError.
 *  
 *  If a renderer requires another pass on the renderering data,
 *  it should return kQ3ViewStatusRetraverse.
 *  
 *  If rendering was cancelled, this function will not be called
 *  and the view will handle returning kQ3ViewStatusCancelled;
 *  
 *  Otherwise, your renderer should begin completing the process of 
 *  generating the image in the drawcontext. If you have buffered
 *  any drawing data, flush it. RendererEnd should have a similar
 *  effect as RendererFlushFrame.
 *  
 *  If the renderer is synchronous:
 *      - complete rendering of the entire frame
 *      if the renderer supports kQ3RendererClassSupportDoubleBuffer
 *          - Update the front buffer
 *      else
 *          - DrawContext will update the front buffer after returning
 *
 *  If the renderer is asynchronous
 *      - spawn rendering thread for entire frame
 *      if the renderer supports kQ3RendererClassSupportDoubleBuffer,
 *          - you must eventually update the front buffer asynchronously
 *      else
 *          - you must eventually update the back buffer asynchronously
 *          
 *  REQUIRED
 */
enum {
  kQ3XMethodTypeRendererEndPass = FOUR_CHAR_CODE('rded')
};

typedef CALLBACK_API_C( TQ3ViewStatus , TQ3XRendererEndPassMethod )(TQ3ViewObject view, void *rendererPrivate);
/*
 *  kQ3XMethodTypeRendererEndFrame
 *  TQ3XRendererEndFrame
 *  
 *  This call is only implemented by asynchronous renderers.
 *
 *  The EndFrame method is called from Q3View_Sync, which is
 *  called after Q3View_EndRendering and signals that the user
 *  wishes to see the completed image and is willing to block.
 *  
 *  If your renderer supports kQ3RendererFlagDoubleBuffer
 *      - update the front buffer completely 
 *  else
 *      - update the back buffer completely
 *
 *  This call is equivalent in functionality to RendererFlushFrame
 *  but blocks until the image is completed.
 *  
 *  If no method is supplied, the default is a no-op.
 *  
 *  NOTE: Registering a method of this type indicates that your renderer will
 *  be rendering after Q3View_EndRendering has been called.
 *  
 *  OPTIONAL
 */
enum {
  kQ3XMethodTypeRendererEndFrame = FOUR_CHAR_CODE('rdsy')
};

typedef CALLBACK_API_C( TQ3Status , TQ3XRendererEndFrameMethod )(TQ3ViewObject view, void *rendererPrivate, TQ3DrawContextObject drawContext);
/*
 *  The RendererCancel method is called after Q3View_StartRendering
 *  and signals the termination of all rendering operations.
 *
 *  A renderer should clean up any cached data, and cancel all 
 *  rendering operations.
 *  
 *  If called before Q3View_EndRendering, the RendererEnd method
 *  is NOT called.
 *  
 *  If called after Q3View_EndRendering, the renderer should kill
 *  any threads and terminate any further rendering.
 *  
 *  REQUIRED
 */
enum {
  kQ3XMethodTypeRendererCancel  = FOUR_CHAR_CODE('rdab')
};

typedef CALLBACK_API_C( void , TQ3XRendererCancelMethod )(TQ3ViewObject view, void *rendererPrivate);
/******************************************************************************
 **                                                                          **
 **                     Renderer DrawContext Methods                         **
 **                                                                          **
 *****************************************************************************/
/*
 *  kQ3XMethodTypeRendererPush
 *  TQ3XRendererPushMethod
 *  
 *  kQ3XMethodTypeRendererPop
 *  TQ3XRendererPopMethod
 *  
 *  These methods are called whenever the graphics state in the view
 *  is pushed or popped. The user may isolate state by calling:
 *  
 *  Q3Attribute_Submit(kQ3AttributeTypeDiffuseColor, &red, view);
 *  Q3Attribute_Submit(kQ3AttributeTypeTransparencyColor, &blue, view);
 *  Q3Attribute_Submit(kQ3AttributeTypeSpecularColor, &white, view);
 *  Q3Box_Submit(&unitBox, view);
 *  Q3TranslateTransform_Submit(&unitVector, view);
 *  Q3Push_Submit(view);
 *      Q3Attribute_Submit(kQ3AttributeTypeDiffuseColor, &blue, view);
 *      Q3Attribute_Submit(kQ3AttributeTypeTransparencyColor, &green, view);
 *      Q3Box_Submit(&unitBox, view);
 *  Q3Pop_Submit(view); 
 *  Q3TranslateTransform_Submit(&unitVector, view);
 *  Q3Box_Submit(&unitBox, view);
 *  
 *  or by submitting a display group which pushes and pops.
 *  
 *  If you support RendererPush and RendererPop in your renderer:
 *      - you must maintain your drawing state as a stack, as well.
 *      - you will not be updated with the popped state after
 *          RendererPop is called.
 *
 *  If you do not support Push and Pop in your renderer:
 *      - you may maintain a single copy of the drawing state.
 *      - you will be updated with changed fields after the view stack is
 *          popped.
 *
 *  A renderer that supports Push and Pop gets called in the following
 *  sequence (from example above):
 *  
 *  RendererUpdateAttributeDiffuseColor(&red,...)
 *  RendererUpdateAttributeTransparencyColor(&blue,...)
 *  RendererUpdateAttributeSpecularColor(&white,...)
 *  RendererUpdateMatrixLocalToWorld(...)
 *  RendererSubmitGeometryBox(...)
 *  RendererPush(...)
 *      RendererUpdateAttributeDiffuseColor(&blue,...)
 *      RendererUpdateAttributeTransparencyColor(&green,...)
 *      RendererSubmitGeometryBox(...)
 *  RendererPop(...)
 *  RendererUpdateMatrixLocalToWorld(...)
 *  RendererSubmitGeometryBox(...)
 *
 *  A renderer that does not supports Push and Pop gets called in the
 *  following sequence:
 *  
 *  RendererUpdateAttributeDiffuseColor(&red,...)
 *  RendererUpdateAttributeTransparencyColor(&blue,...)
 *  RendererUpdateAttributeSpecularColor(&white,...)
 *  RendererUpdateMatrixLocalToWorld(...)
 *  RendererSubmitGeometryBox(...)
 *      RendererUpdateAttributeDiffuseColor(&blue,...)
 *      RendererUpdateAttributeTransparencyColor(&green,...)
 *      RendererSubmitGeometryBox(...)
 *  RendererUpdateAttributeDiffuseColor(&red,...)
 *  RendererUpdateAttributeTransparencyColor(&blue,...)
 *  RendererUpdateMatrixLocalToWorld(...)
 *  RendererSubmitGeometryBox(...)
 *  
 */
enum {
  kQ3XMethodTypeRendererPush    = FOUR_CHAR_CODE('rdps')
};

typedef CALLBACK_API_C( TQ3Status , TQ3XRendererPushMethod )(TQ3ViewObject view, void *rendererPrivate);
enum {
  kQ3XMethodTypeRendererPop     = FOUR_CHAR_CODE('rdpo')
};

typedef CALLBACK_API_C( TQ3Status , TQ3XRendererPopMethod )(TQ3ViewObject view, void *rendererPrivate);
/******************************************************************************
 **                                                                          **
 **                         Renderer Cull Methods                            **
 **                                                                          **
 *****************************************************************************/
/*
 *  kQ3XMethodTypeRendererIsBoundingBoxVisible
 *  TQ3XRendererIsBoundingBoxVisibleMethod
 *  
 *  This method is called to cull complex groups and geometries 
 *  given their bounding box in local space.
 *  
 *  It should transform the local-space bounding box coordinates to
 *  frustum space and return a TQ3Boolean return value indicating
 *  whether the box appears within the viewing frustum.
 *  
 *  If no method is supplied, the default behavior is to return
 *  kQ3True.
 *  
 */
enum {
  kQ3XMethodTypeRendererIsBoundingBoxVisible = FOUR_CHAR_CODE('rdbx')
};

typedef CALLBACK_API_C( TQ3Boolean , TQ3XRendererIsBoundingBoxVisibleMethod )(TQ3ViewObject view, void *rendererPrivate, const TQ3BoundingBox *bBox);

/******************************************************************************
 **                                                                          **
 **                     Renderer Object Support Methods                      **
 **                                                                          **
 *****************************************************************************/
/*
 *  Drawing methods (Geometry, Camera, Lights)
 *
 */
/*
 *  Geometry MetaHandler
 *  
 *  This metaHandler is required to support 
 *  
 *  kQ3GeometryTypeTriangle
 *  kQ3GeometryTypeLine
 *  kQ3GeometryTypePoint
 *  kQ3GeometryTypeMarker
 *  kQ3GeometryTypePixmapMarker
 *  
 *  REQUIRED
 */
enum {
  kQ3XMethodTypeRendererSubmitGeometryMetaHandler = FOUR_CHAR_CODE('rdgm')
};

typedef CALLBACK_API_C( TQ3XFunctionPointer , TQ3XRendererSubmitGeometryMetaHandlerMethod )(TQ3ObjectType geometryType);
/*
 *  The TQ3XRendererSubmitGeometryMetaHandlerMethod switches on geometryType
 *  of kQ3GeometryTypeFoo and returns methods of type:
 */
typedef CALLBACK_API_C( TQ3Status , TQ3XRendererSubmitGeometryMethod )(TQ3ViewObject view, void *rendererPrivate, TQ3GeometryObject geometry, const void *publicData);
/*
 *  Camera MetaHandler
 *  
 *  This metaHandler, if supplied, indicates that your renderer
 *  handles deferred transformation of the main camera within a scene.
 *  
 *  If not supplied, or an unsupported camera is used, the view will do
 *  the transformation for the renderer and pass in a camera in the 
 *  StartPass method.
 *  
 *  OPTIONAL
 */
enum {
  kQ3XMethodTypeRendererSubmitCameraMetaHandler = FOUR_CHAR_CODE('rdcm')
};

typedef CALLBACK_API_C( TQ3XFunctionPointer , TQ3XRendererSubmitCameraMetaHandlerMethod )(TQ3ObjectType cameraType);
/*
 *  The TQ3XRendererSubmitCameraMetaHandlerMethod switches on cameraType
 *  of kQ3CameraTypeFoo and returns methods of type:
 */
typedef CALLBACK_API_C( TQ3Status , TQ3XRendererSubmitCameraMethod )(TQ3ViewObject view, void *rendererPrivate, TQ3CameraObject camera, const void *publicData);
/*
 *  Light MetaHandler
 *  
 *  This metaHandler, if supplied, indicates that your renderer
 *  handles deferred transformation of lights within a scene.
 *  
 *  If an unsupported light is encountered, it is ignored.
 *
 *  OPTIONAL
 */
enum {
  kQ3XMethodTypeRendererSubmitLightMetaHandler = FOUR_CHAR_CODE('rdlg')
};

typedef CALLBACK_API_C( TQ3XFunctionPointer , TQ3XRendererSubmitLightMetaHandlerMethod )(TQ3ObjectType lightType);
/*
 *  The TQ3XRendererSubmitLightMetaHandlerMethod switches on lightType
 *  of kQ3LightTypeFoo and returns methods of type:
 */
typedef CALLBACK_API_C( TQ3Status , TQ3XRendererSubmitLightMethod )(TQ3ViewObject view, void *rendererPrivate, TQ3LightObject light, const void *publicData);
/*
 *
 *  Update methods
 *
 *  They are called whenever the state has changed. If the renderer supports
 *  the RendererPush and RendererPop methods, it must maintain its own state
 *  stack. Updates are not called for changed data when the view stack is
 *  popped.
 *
 *  See the comments for the RendererPush and RendererPop methods above
 *  for an example of how data is updated.
 *
 */
/*
 *  Style
 */
enum {
  kQ3XMethodTypeRendererUpdateStyleMetaHandler = FOUR_CHAR_CODE('rdyu')
};

typedef CALLBACK_API_C( TQ3XFunctionPointer , TQ3XRendererUpdateStyleMetaHandlerMethod )(TQ3ObjectType styleType);
/*
 *  The TQ3XRendererUpdateStyleMetaHandlerMethod switches on styleType
 *  of kQ3StyleTypeFoo and returns methods of type:
 */
typedef CALLBACK_API_C( TQ3Status , TQ3XRendererUpdateStyleMethod )(TQ3ViewObject view, void *rendererPrivate, const void *publicData);
/*
 *  Attributes
 */
enum {
  kQ3XMethodTypeRendererUpdateAttributeMetaHandler = FOUR_CHAR_CODE('rdau')
};

typedef CALLBACK_API_C( TQ3XFunctionPointer , TQ3XRendererUpdateAttributeMetaHandlerMethod )(TQ3AttributeType attributeType);
/*
 *  The TQ3XRendererUpdateStyleMetaHandlerMethod switches on attributeType
 *  of kQ3AttributeTypeFoo and returns methods of type:
 */
typedef CALLBACK_API_C( TQ3Status , TQ3XRendererUpdateAttributeMethod )(TQ3ViewObject view, void *rendererPrivate, const void *publicData);
/*
 *  Shaders
 */
enum {
  kQ3XMethodTypeRendererUpdateShaderMetaHandler = FOUR_CHAR_CODE('rdsu')
};

typedef CALLBACK_API_C( TQ3XFunctionPointer , TQ3XRendererUpdateShaderMetaHandlerMethod )(TQ3ObjectType shaderType);
/*
 *  The TQ3XRendererUpdateShaderMetaHandlerMethod switches on shaderType
 *  of kQ3ShaderTypeFoo and returns methods of type:
 */
typedef CALLBACK_API_C( TQ3Status , TQ3XRendererUpdateShaderMethod )(TQ3ViewObject view, void *rendererPrivate, TQ3Object *shaderObject);
/*
 *  Matrices
 */
enum {
  kQ3XMethodTypeRendererUpdateMatrixMetaHandler = FOUR_CHAR_CODE('rdxu')
};

typedef TQ3XMetaHandler                 TQ3XRendererUpdateMatrixMetaHandlerMethod;
/*
 *  The TQ3XRendererUpdateShaderMetaHandlerMethod switches on methods
 *  of the form kQ3MethodTypeRendererUpdateMatrixFoo:
 */
enum {
  kQ3XMethodTypeRendererUpdateMatrixLocalToWorld = FOUR_CHAR_CODE('ulwx')
};

enum {
  kQ3XMethodTypeRendererUpdateMatrixLocalToWorldInverse = FOUR_CHAR_CODE('ulwi')
};

enum {
  kQ3XMethodTypeRendererUpdateMatrixLocalToWorldInverseTranspose = FOUR_CHAR_CODE('ulwt')
};

enum {
  kQ3XMethodTypeRendererUpdateMatrixLocalToCamera = FOUR_CHAR_CODE('ulcx')
};

enum {
  kQ3XMethodTypeRendererUpdateMatrixLocalToFrustum = FOUR_CHAR_CODE('ulfx')
};

enum {
  kQ3XMethodTypeRendererUpdateMatrixWorldToFrustum = FOUR_CHAR_CODE('uwfx')
};

/*
 *  and returns methods of type:
 */
typedef CALLBACK_API_C( TQ3Status , TQ3XRendererUpdateMatrixMethod )(TQ3ViewObject view, void *rendererPrivate, const TQ3Matrix4x4 *matrix);


#if PRAGMA_ENUM_ALWAYSINT
    #pragma enumsalwaysint reset
    #ifdef __QD3DRENDERER__RESTORE_TWOBYTEINTS
        #pragma fourbyteints off
    #endif
#elif PRAGMA_ENUM_OPTIONS
    #pragma option enum=reset
#elif defined(__QD3DRENDERER__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 /* __QD3DRENDERER__ */