RE/RE_Types.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        RE_Types.h ( UI Library, C++)
 *
 * COMMENTS:
 *      Common enums and defines for Open GL.
 */
#ifndef __RE_Types__
#define __RE_Types__

#include "RE_API.h"
#include "RE_Platform.h"

// Setting for transition to one context/window
#ifdef MBSD
#   define RE_OGL_SINGLE_CONTEXT 0
#elif defined(CELLBE)
#   define RE_OGL_SINGLE_CONTEXT 1
#elif defined(LINUX)
#   define RE_OGL_SINGLE_CONTEXT 0
#else
#   define RE_OGL_SINGLE_CONTEXT 0
#endif

// This is also directly written in UI_DeviceEvent.h as we don't want to
// import windows.h there.
#ifdef WIN32
typedef void *RE_IDType;
#elif defined(MBSD_COCOA)
#include <UT/UT_MBSDUtil.h>
typedef UT_ObjCRef    RE_IDType;
#elif defined(CELLBE)
typedef void *        RE_IDType;
#else
typedef unsigned long RE_IDType;
#endif

enum RE_WindowVisibility
{
    RE_WINDOW_VISIBLE,
    RE_WINDOW_OFFSCREEN
};

// The type of a window. Used to set hints for the windowing system
// to treat the window differently, and to set up borders and icon settings.
enum RE_WindowType
{
    RE_WINDOW_MAIN,             // An app window. App exits when all are closed.
    RE_WINDOW_NORMAL,           // A dialog window with min/max-imize buttons.
    RE_WINDOW_DIALOG,           // A transient dialog that should be on top 
                                // of its parent window.
    RE_WINDOW_UTILITY,          // A non-transient (i.e., persistent) dialog
                                // like a toolbox or palette.
    RE_WINDOW_SPLASH,           // A splash screen window.
    RE_WINDOW_TRANSIENT,        // A *very* transient window displayed
                                // temporarily (like a tooltip or XCF slider).
                                // Grabs the pointer & is not managed.
    RE_WINDOW_CHILD,            // A child of a window (probably a child of a
                                // NORMAL window). Isn't managed.
    RE_WINDOW_MENU,             // A window for popup menus.
    RE_WINDOW_HELPTIP,          // Same as TRANSIENT, but without focus lock.
    RE_WINDOW_INVALID_TYPE      // Not a type. Used to mean "uninitialized."
};


// Data type abtractions for OpenGL types.
enum RE_GPUType
{
    RE_GPU_UINT1, // corresponds to GL_STENCIL_INDEX1
    RE_GPU_UINT4, // corresponds to GL_STENCIL_INDEX4
    RE_GPU_UINT8,
    RE_GPU_UINT16,
    RE_GPU_UINT32,
        
    RE_GPU_INT8,
    RE_GPU_INT16,
    RE_GPU_INT32,

    RE_GPU_FLOAT16,
    RE_GPU_FLOAT24, // corresponds to GL_DEPTH_COMPONENT24
    RE_GPU_FLOAT32,

    // These can only be used in the context of a GLSL shader.
    RE_GPU_MATRIX2,
    RE_GPU_MATRIX3,
    RE_GPU_MATRIX4
};

// should always point to the last type.
#define RE_NUM_WINDOW_TYPES RE_WINDOW_INVALID_TYPE

#include <UT/UT_Color.h>
#include <UT/UT_Matrix4.h>

#if defined(WIN32) || defined(MBSD_COCOA)
typedef void * Display;
#elif defined(CELLBE)
#include </usr/local/sony-cell-sdk/target/ppu/include/GL/egl.h>
typedef EGLDisplay Display;
#endif

#define RE_DEFAULT_DPI 85.0

#define X_ICON_WIDTH            85      // Icon size under Motif.
#define X_ICON_HEIGHT           66

#define RE_MAXGLVTX             65535   // No max in open GL?

#define MAX_DISPLAY_MODES       5

#define MED_RES                 90

#define MM_TO_INCHES(mm)        ((mm) / 25.4)

#define GL_DRAW_NORMAL          0
#define GL_DRAW_POPUP           1
#define GL_DRAW_OVERLAY         2
#define GL_DRAW_UNDERLAY        3
#define GL_DRAW_CURSOR          4

typedef float            RE_CMMatrix[16];


enum RE_RenderBuf
{
    RE_FRONT = 1,
    RE_BACK  = 2
    // RE_BOTH has been removed because the back buffer is no longer valid
    // after swapping, so you shouldn't need to write to both ever.
};

enum RE_MatrixMode
{
    RE_MATRIX_SINGLE,
    RE_MATRIX_VIEWING,
    RE_MATRIX_PROJECTION,
    RE_MATRIX_TEXTURE   
};

enum RE_FillPattern
{
    RE_NO_PATTERN,
    RE_QUARTER_TONE,
    RE_HALF_TONE,
    RE_3QUARTER_TONE,
    RE_QUARTER_HASH,
    RE_QUARTER_FORE_HASH,
    RE_QUARTER_BACK_HASH
};

enum RE_LineStyle
{
    RE_LINE_SOLID       = 0,
    RE_LINE_DASH_LONG   = 1,
    RE_LINE_DASH_SHORT  = 2,
    RE_LINE_DOTTED      = 3
};

enum RE_InterpMode
{
    RE_INTERP_FLAT,
    RE_INTERP_GOURAUD,
    RE_INTERP_PHONG
};

enum RE_SmoothMode
{
    RE_SMOOTH_OFF  = 0,
    RE_SMOOTH_ON   = 1
};

enum RE_LightIndex
{
    RE_LIGHT0   = 0,
    RE_LIGHT1   = 1,
    RE_LIGHT2   = 2,
    RE_LIGHT3   = 3,
    RE_LIGHT4   = 4,
    RE_LIGHT5   = 5,
    RE_LIGHT6   = 6,
    RE_LIGHT7   = 7
};

enum RE_ZFunction
{
    RE_ZNEVER,
    RE_ZLESS,
    RE_ZEQUAL,
    RE_ZLEQUAL,
    RE_ZGREATER,
    RE_ZNOTEQUAL,
    RE_ZGEQUAL,
    RE_ZALWAYS
};

enum RE_SFunction
{
    RE_SNEVER,
    RE_SLESS,
    RE_SEQUAL,
    RE_SLEQUAL,
    RE_SGREATER,
    RE_SNOTEQUAL,
    RE_SGEQUAL,
    RE_SALWAYS
};

enum RE_SOperation
{
    RE_SKEEP,
    RE_SZERO,
    RE_SREPLACE,
    RE_SINCR,
    RE_SDECR,
/* These modes are only available in OpenGL 1.4 and up
    RE_SINCR_WRAP,
    RE_SDECR_WRAP,
*/
    RE_SINVERT
};

enum RE_BlendSourceFactor
{
    RE_SBLEND_ZERO,
    RE_SBLEND_DST_COLOR,
    RE_SBLEND_ONE_MINUS_DST_COLOR,
    RE_SBLEND_SRC_ALPHA,
    RE_SBLEND_ONE_MINUS_SRC_ALPHA,
    RE_SBLEND_DST_ALPHA,
    RE_SBLEND_ONE_MINUS_DST_ALPHA,
    RE_SBLEND_SRC_ALPHA_SATURATE,
    RE_SBLEND_ONE
};

enum RE_BlendDestFactor
{
    RE_DBLEND_ONE,
    RE_DBLEND_SRC_COLOR,
    RE_DBLEND_ONE_MINUS_SRC_COLOR,
    RE_DBLEND_SRC_ALPHA,
    RE_DBLEND_ONE_MINUS_SRC_ALPHA,
    RE_DBLEND_DST_ALPHA,
    RE_DBLEND_ONE_MINUS_DST_ALPHA,
    RE_DBLEND_ZERO
};

#define RE_MODE_MULTISAMPLE_MASK  0x60
#define RE_MODE_MULTISAMPLE_SHIFT 5

enum RE_DisplayMode
{
    // The mode components
    RE_MODE_NONE                = 0x000,
    RE_MODE_RGB                 = 0x001,        // RGB mode (req'd)
    RE_MODE_DOUBLE              = 0x002,        // Double buffer
    RE_MODE_ZBUFFER             = 0x004,        // Depth buffer
    RE_MODE_ALPHA               = 0x008,        // Alpha buffer (RGBA)
    RE_MODE_STENCIL             = 0x010,        // Stencil buffer
    RE_MODE_MULTISAMPLE_LOW     = 0x020,        // 2x Full Scene AA
    RE_MODE_MULTISAMPLE_MED     = 0x040,        // 4x Full Scene AA
    RE_MODE_MULTISAMPLE_HIGH    = 0x060,        // 8x (NV) / 6x (ATI) FS AA
    RE_MODE_ACCUM               = 0x080,        // Color Accumulation buffer
    RE_MODE_ACCUM_ALPHA         = 0x100,        // Alpha accum (needs color acc)

    // The actual modes themselves; convenience enums.
    RE_MODE_RGB_SINGLE          = RE_MODE_RGB,
    RE_MODE_RGB_DOUBLE          = RE_MODE_RGB | RE_MODE_DOUBLE,
    
    RE_MODE_RGBA_SINGLE         = RE_MODE_RGB | RE_MODE_ALPHA,
    RE_MODE_RGBA_DOUBLE         = RE_MODE_RGB | RE_MODE_DOUBLE | RE_MODE_ALPHA,
    
    RE_MODE_RGBZ_SINGLE         = RE_MODE_RGB | RE_MODE_ZBUFFER,
    RE_MODE_RGBZ_DOUBLE         = RE_MODE_RGB | RE_MODE_DOUBLE|RE_MODE_ZBUFFER,

    RE_MODE_RGBSZ_SINGLE        = RE_MODE_RGBZ_SINGLE | RE_MODE_STENCIL,
    RE_MODE_RGBSZ_DOUBLE        = RE_MODE_RGBZ_DOUBLE | RE_MODE_STENCIL,
    
    RE_MODE_RGBAZ_SINGLE        = RE_MODE_RGB | RE_MODE_ALPHA |RE_MODE_ZBUFFER,
    RE_MODE_RGBAZ_DOUBLE        = RE_MODE_RGB | RE_MODE_DOUBLE |RE_MODE_ALPHA |
                                  RE_MODE_ZBUFFER,

    RE_MODE_RGBS_SINGLE         = RE_MODE_RGB | RE_MODE_STENCIL,
    RE_MODE_RGBS_DOUBLE         = RE_MODE_RGB | RE_MODE_DOUBLE|RE_MODE_STENCIL,

    RE_MODE_RGBAS_SINGLE        = RE_MODE_RGB | RE_MODE_ALPHA |RE_MODE_STENCIL,
    RE_MODE_RGBAS_DOUBLE        = RE_MODE_RGB | RE_MODE_DOUBLE |RE_MODE_ALPHA |
                                  RE_MODE_STENCIL,

    RE_MODE_RGB_BEST            = RE_MODE_RGB_DOUBLE,
    RE_MODE_RGBA_BEST           = RE_MODE_RGBA_DOUBLE,
    RE_MODE_RGBZ_BEST           = RE_MODE_RGBZ_DOUBLE,
    RE_MODE_RGBAZ_BEST          = RE_MODE_RGBAZ_DOUBLE,
    RE_MODE_RGBS_BEST           = RE_MODE_RGBS_DOUBLE,
    RE_MODE_RGBAS_BEST          = RE_MODE_RGBAS_DOUBLE
};

enum    RE_VisualType
{
    RE_NORMAL_VIS,
    RE_OVERLAY_VIS,
    RE_FULLSCREEN_OVERLAY_VIS
};

enum RE_PolyOffStrategy 
{
    RE_POLYOFF_GL11,
    RE_POLYOFF_GL10_EXT,
    RE_POLYOFF_NONE
};

enum RE_DrawPixelsMode
{
    RE_PM_ABGR,
    RE_PM_RGBA,
    RE_PM_RGB
};

// This is a bitmask.
enum RE_GraphicsDevice
{
    RE_DEVICE_UNKNOWN       = 0x0,
    
    RE_DEVICE_ATI           = 0x1,
    RE_DEVICE_NVIDIA        = 0x2,
    RE_DEVICE_INTEL         = 0x4,
    RE_DEVICE_GDI           = 0x8,      // Software OGL on Windows
    
    RE_DEVICE_PRO           = 0x100,    // Professional series
    
    RE_DEVICE_ATI_PRO       = (RE_DEVICE_PRO|RE_DEVICE_ATI),    // FireGL
    RE_DEVICE_NVIDIA_PRO    = (RE_DEVICE_PRO|RE_DEVICE_NVIDIA), // Quadro
    RE_DEVICE_INTEL_PRO     = (RE_DEVICE_PRO|RE_DEVICE_INTEL)   // n/a?
};

inline bool REisProfessionalDevice(RE_GraphicsDevice dev)
{
    return (dev & RE_DEVICE_PRO);
}

inline bool REisConsumerDevice(RE_GraphicsDevice dev)
{
    return !(dev & RE_DEVICE_PRO);
}

inline const char *REgetDeviceName(RE_GraphicsDevice dev)
{
    switch(dev)
    {
    case RE_DEVICE_ATI:         return "ATI Consumer";
    case RE_DEVICE_NVIDIA:      return "NVidia Consumer";
    case RE_DEVICE_INTEL:       return "Intel Consumer";
    case RE_DEVICE_GDI:         return "GDI Generic";
    case RE_DEVICE_ATI_PRO:     return "ATI Professional";
    case RE_DEVICE_NVIDIA_PRO:  return "NVidia Professional";
    case RE_DEVICE_INTEL_PRO:   return "Intel Professional";
    default:
        break;
    }
    return "Unknown";
}
        


typedef unsigned char   RE_State;       // Used for internal state flags.

class IMG_Raster;
typedef IMG_Raster      *(*RE_IconLoader)(int, int);

class PXL_Lookup;

class RE_API RE_RasterOpts
{
public:
    RE_RasterOpts() : myZoomX(-1), myZoomY(-1),
                      myColorScale(1.0f), myColorShift(0.0f),
                      myColorBlack(0.0f), myColorWhite(1.0f),
                      myAlphaScale(1.0f), myAlphaShift(0.0f),
                      myGamma(1.0f), myAspectRatio(1.0f), myVScale(1.0f),
                      myLUTSize(0), myComponent(-1), myModifyAlpha(false),
                      myDither(true), myComponentsAsGrey(true),
                      myLUTObject(0), myTransparent(0), myPremultiplyFlag(0),
                      myFragment16bit(0)
        { myLUT[0] = myLUT[1] = myLUT[2] = myLUT[3] = 0; }

    float myZoomX;
    float myZoomY;
    float myColorScale;
    float myColorShift;
    float myColorBlack;
    float myColorWhite;
    float myAlphaScale;
    float myAlphaShift;
    float myGamma;
    float myAspectRatio;
    float myVScale;
    float *myLUT[4];
    int   myLUTSize;
    int   myComponent;
    unsigned  myModifyAlpha :1,
              myDither : 1,
              myComponentsAsGrey :1,
              myTransparent :1,
              myPremultiplyFlag:1,
              myFragment16bit : 2;
    PXL_Lookup *myLUTObject;
};


class RE_API RE_ColorStack
{
public:
    float r, g, b, a;
};

class RE_API RE_StateInfo
{
public:
    RE_StateInfo()
        {
            concave  = 0;
            backface = 0;
            picking  = 0;
            blending = 0;
            reverse_winding = 0;
        };
    unsigned    concave:1,
                backface:1,
                picking:1,
                blending:1,
                reverse_winding;
};

// Stack item for blending
class RE_API re_BlendState
{
public:
    re_BlendState()
        {
            myBlend = 0;
            mySourceFactor = RE_SBLEND_ONE;
            myDestFactor = RE_DBLEND_ZERO;
            myZBufferWrite = false;
        }
    
    void set(bool blend, RE_BlendSourceFactor s, RE_BlendDestFactor d,
             bool zbuf)
        { myBlend = blend;  mySourceFactor = s;  myDestFactor = d;
            myZBufferWrite = zbuf; }
    
    void get(bool &blend, RE_BlendSourceFactor &s, RE_BlendDestFactor &d,
             bool &zbuf) const
        { blend = myBlend;  s = mySourceFactor; d = myDestFactor;
            zbuf = myZBufferWrite; }
    
    bool                 myBlend;
    RE_BlendSourceFactor mySourceFactor;
    RE_BlendDestFactor   myDestFactor;
    bool                 myZBufferWrite; 
};

// stack item for smoothing (which also modifies the blend state)
class RE_API re_SmoothState : public re_BlendState
{
public:
    re_SmoothState()
        {
            mySmooth = 0;
            myAllowSmooth = 0;
        }
    
    void set(bool smooth, bool allow, bool blend,
             RE_BlendSourceFactor s, RE_BlendDestFactor d, bool zbuf)
        { mySmooth = smooth; myAllowSmooth = allow;
            re_BlendState::set(blend, s, d, zbuf); }
    
    void get(bool &smooth, bool &allow, bool &blend,
             RE_BlendSourceFactor &s, RE_BlendDestFactor &d, bool &zbuf) const
        { smooth = mySmooth; allow = myAllowSmooth;
            re_BlendState::get(blend, s,d, zbuf); }
    
    bool mySmooth;
    bool myAllowSmooth;
};

// Stack item for stenciling
class RE_API re_StencilState
{
public:
    re_StencilState()
        {
            myEnable = false;
            myClearValue = 0;
            myWriteMask = 1;
            myFunc = RE_SALWAYS;
            myRef = 0;
            myValueMask = 1;
            myFailOperation = RE_SKEEP;
            myPassDepthFailOperation = RE_SKEEP;
            myPassDepthPassOperation = RE_SKEEP;
        }
    
    void set(bool           enable,
             int            clearValue,
             int            writeMask,
             RE_SFunction   func,
             int            ref,
             int            valueMask,
             RE_SOperation  failOperation,
             RE_SOperation  passDepthFailOperation,
             RE_SOperation  passDepthPassOperation)
        {
            myEnable = enable;
            myClearValue = clearValue;
            myWriteMask = writeMask;
            myFunc = func;
            myRef = ref;
            myValueMask = valueMask;
            myFailOperation = failOperation;
            myPassDepthFailOperation = passDepthFailOperation;
            myPassDepthPassOperation = passDepthPassOperation;
        }
    
    void get(bool           &enable,
             int            &clearValue,
             int            &writeMask,
             RE_SFunction   &func,
             int            &ref,
             int            &valueMask,
             RE_SOperation  &failOperation,
             RE_SOperation  &passDepthFailOperation,
             RE_SOperation  &passDepthPassOperation) const
        {
            enable = myEnable;
            clearValue = myClearValue;
            writeMask = myWriteMask;
            func = myFunc;
            ref = myRef;
            valueMask = myValueMask;
            failOperation = myFailOperation;
            passDepthFailOperation = myPassDepthFailOperation;
            passDepthPassOperation = myPassDepthPassOperation;
        }
    
    bool            myEnable;
    int             myClearValue;
    int             myWriteMask;
    RE_SFunction    myFunc;
    int             myRef;
    int             myValueMask;
    RE_SOperation   myFailOperation;
    RE_SOperation   myPassDepthFailOperation;
    RE_SOperation   myPassDepthPassOperation;
};

#define CONTEXT_STACK_SIZE      5
#define PATTERN_STACK_SIZE      7
#define RE_COLOR_STACK_SIZE     32
#define PROJECTION_STACK_SIZE   32
#define RE_SMOOTH_STACK_SIZE    16
#define RE_BLEND_STACK_SIZE     16
#define RE_STENCIL_STACK_SIZE   16

#define RE_STACK_DEPTH          256

// We use RE_OGLContext and only cast at the last possible minute,
// to avoid problems compiling against certain OpenGL drivers.
#if defined(MBSD_COCOA) && RE_OGL_SINGLE_CONTEXT
    // Need these to be garbage collected
    typedef UT_ObjCRef       RE_OGLContext;
#else
    typedef void            *RE_OGLContext;
#endif

#ifdef WIN32
    #include <windows.h>
    #include <GL/glu.h>

#ifndef GL_ABGR_EXT
    #define GL_ABGR_EXT         0x8000
#endif
    #define False               0
    #define True                1

    typedef unsigned short              ColorIndexType;
    typedef HGLRC                       OGLContext;
    typedef HWND                        OGLWindow;
    typedef HDC                         OGLDrawable;

    #define NewRE_Server()              (new RE_NTServer())
    #define NewRE_Cursor(a,b)           (new RE_NTCursor(a,b))
    #define NewRE_Visual(a,b)           (new RE_NTVisual(a,b))

#elif defined(MBSD_COCOA)

    #include <OpenGL/glu.h>

    #define False                       0
    #define True                        1
    
    // We use a wrapper to store pointers to Objective-C
    // objects so that we can turn off garbage collection 
    // for as long as we are referencing them.
    typedef unsigned short              ColorIndexType;
    typedef UT_ObjCRef                  OGLContext;  // NSOpenGLContext
    typedef UT_ObjCRef                  OGLWindow;   // NSWindow
    typedef UT_ObjCRef                  OGLDrawable; // NSView

    #define NewRE_Server()              (new RE_OSXServer())
    #define NewRE_Cursor(a,b)           (new RE_OSXCursor(a,b))
    #define NewRE_Visual(a,b)           (new RE_OSXVisual(a,b))
    
#elif defined(CELLBE)

    #include <GL/gl.h>
    #include <GL/egl.h>

    #define False                       0
    #define True                        1
    
    typedef EGLContext                  OGLContext;  
    typedef EGLSurface                  OGLWindow;   
    typedef EGLSurface                  OGLDrawable; 

    #define NewRE_Server()              (new RE_EGLServer())
    #define NewRE_Cursor(a,b)           (new RE_EGLCursor(a,b))
    #define NewRE_Visual(a,b)           (new RE_EGLVisual(a,b))
    
#else // X11

    #include <GL/glu.h>
    #include <GL/glx.h>

    typedef unsigned short              ColorIndexType;
    typedef GLXContext                  OGLContext;
    typedef Window                      OGLWindow;
    typedef GLXDrawable                 OGLDrawable;

#if defined(LINUX) || defined(SOLARIS)
    typedef GLXDrawable                  GLXPbufferSGIX;
#if defined(LINUX) && !defined(GLX_SGIX_fbconfig)
    // This isn't defined for XFree86 versions below 4.3
    typedef void                        *GLXFBConfigSGIX;
#endif
#endif

    #define NewRE_Server()              (new RE_XServer())
    #define NewRE_Cursor(a,b)           (new RE_XCursor((RE_XServer *)a,b))
    #define NewRE_Visual(a,b)           (new RE_XVisual((RE_XServer *)a,b))
#endif

#endif

---