/* ** Copyright 1991, 1992, Silicon Graphics, Inc. ** All Rights Reserved. ** ** This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.; ** the contents of this file may not be disclosed to third parties, copied or ** duplicated in any form, in whole or in part, without the prior written ** permission of Silicon Graphics, Inc. ** ** RESTRICTED RIGHTS LEGEND: ** Use, duplication or disclosure by the Government is subject to restrictions ** as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data ** and Computer Software clause at DFARS 252.227-7013, and/or in similar or ** successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished - ** rights reserved under the Copyright Laws of the United States. */ #ifndef __GLGENCONTXT_H__ #define __GLGENCONTXT_H__ #include "context.h" #ifdef _MCD_ #include #include "mcdrv.h" #include "mcd.h" #endif // Re-enable long to float conversion warning. see also context.h #pragma warning (default:4244) #ifdef _CLIENTSIDE_ #include "gldci.h" #include "glgenwin.h" #endif #ifdef _MCD_ #include "mcdcx.h" #endif /* * Define maximum color-index table size */ #define MAXPALENTRIES 4096 /* * Machine dependent implementation limits * (stolen from gfx/lib/opengl/LIGHT/rexcx.h) */ #define __GL_WGL_NUMBER_OF_CLIP_PLANES 6 #define __GL_WGL_NUMBER_OF_LIGHTS 8 #define __GL_WGL_NUMBER_OF_TEXTURES 1 #define __GL_WGL_NUMBER_OF_TEXTURE_ENVS 1 #define __GL_WGL_MAX_MODELVIEW_STACK_DEPTH 32 #define __GL_WGL_MAX_PROJECTION_STACK_DEPTH 10 #define __GL_WGL_MAX_TEXTURE_STACK_DEPTH 10 #define __GL_WGL_MAX_ATTRIB_STACK_DEPTH 16 #define __GL_WGL_MAX_CLIENT_ATTRIB_STACK_DEPTH 16 #define __GL_WGL_MAX_NAME_STACK_DEPTH 128 #define __GL_WGL_MAX_EVAL_ORDER 30 #define __GL_WGL_MAX_MIPMAP_LEVEL 11 #define __GL_WGL_MAX_PIXEL_MAP_TABLE 65536 #define __GL_WGL_MAX_LIST_NESTING 64 #define __GL_WGL_POINT_SIZE_MINIMUM ((__GLfloat) 0.5) #define __GL_WGL_POINT_SIZE_MAXIMUM ((__GLfloat) 10.0) #define __GL_WGL_POINT_SIZE_GRANULARITY ((__GLfloat) 0.125) #define __GL_WGL_LINE_WIDTH_MINIMUM ((__GLfloat) 0.5) #define __GL_WGL_LINE_WIDTH_MAXIMUM ((__GLfloat) 10.0) #define __GL_WGL_LINE_WIDTH_GRANULARITY ((__GLfloat) 0.125) // Constants for fast accelerated texture code... #define TEX_SCALEFACT ((float)65536.0) #define TEX_SCALESHIFT 16 #define TEX_SHIFTPER4BPPTEXEL 2 #define TEX_SHIFTPER2BPPTEXEL 1 #define TEX_SHIFTPER1BPPTEXEL 0 #define TEX_T_FRAC_BITS 6 #define TEX_SUBDIV 8 #define TEX_SUBDIV_LOG2 3 // This is the largest size we support in the software-accelerated // perspective-corrected texture code. This allows 8.6 representation for // s and t, which permits shifting by constant values in the inner loop. // Note that the maximum size for paletted textures is greater than for // RGBA textures, since the number of address bits is smaller (1 byte vs // 4 bytes). #define TEX_MAX_SIZE_LOG2 10 #define __GL_UNBIAS_AND_INVERT_Y(gc, y) \ ((gc)->constants.height - __GL_UNBIAS_Y((gc), (y))) // XXX do we need to add .5? #define __GL_COLOR_TO_COLORREF(color) \ RGB( (BYTE)((color)->r), (BYTE)((color)->g), (BYTE)((color)->b)) typedef struct __RenderStateRec { GLuint *SrvSelectBuffer; // Server side address of // the selection buffer. GLuint *CltSelectBuffer; // Client address of the // Selection buffer GLuint SelectBufferSize; // Size of select buffer in bytes GLfloat *SrvFeedbackBuffer; // Server side address of the // feedback buffer GLfloat *CltFeedbackBuffer; // Client side address of the // Feedback buffer. GLuint FeedbackBufferSize; // Size of the feedback buffer GLenum FeedbackType; // Type of elements for feedback } __RenderState; typedef struct _GENDRVACCEL { __GLcontext *lastGc; // pointer to gc of last attention ULONG cmdBufferSize; char *pCmdBuffer1; // We double-buffer commands char *pCmdBuffer2; char *pStartCmd; char *pStartVertex; char *pEndVertex; char *pCmd; ULONG vertexStartOffset; ULONG vertexEndOffset; RXCMD *prxCmdBase; char *pVertex; USHORT vIndex; BOOL bScan; BOOL bLine; BOOL bIntLine; BOOL bTri; RXSURFACEINFO rxSurfaceInfo; RXCAPS rxScanCaps; RXCAPS rxLineCaps; RXCAPS rxIntLineCaps; RXCAPS rxTriCaps; RXCAPS rxGenCaps; RXHANDLE hrxRC; // Handle to 3D DDI context RXHANDLE hrxExecBuffer1; RXHANDLE hrxExecBuffer2; RXHANDLE hrxMemZ; RXHANDLE hrxMemC; RXEXECUTE rxExecute; char *pExecBuffer; char *pZDrv; char *pShMemZ; char *pCDrv; char *pZRWBase; char *pCRWBase; ULONG zShift; ULONG zBitMask; BOOL bDrvFill; BOOL bDrvLine; ULONG drvModeFlags; PVOID pso; PVOID pfnDrvEscape; ULONG vertexStride; ULONG spanStride; RXCOLOR rxSolidColor; __GLcolor solidColor; __GLspanFunc softZSpanFuncPtr; void (FASTCALL *softClearFuncPtr)(__GLcolorBuffer *); } GENDRVACCEL; typedef BOOL (APIENTRY *PIXVISPROC)(HDC, LONG, LONG); typedef void (*PIXCOPYPROC)(struct __GLGENcontextRec *, __GLcolorBuffer *, GLint, GLint, GLint, BOOL); /****************************************************************************/ typedef struct _SPANREC { LONG r; LONG g; LONG b; LONG a; ULONG z; LONG s; LONG t; } SPANREC; typedef struct __GLGENcontextRec __GLGENcontext; typedef void (FASTCALL *__genSpanFunc)(__GLGENcontext *gc); typedef ULONG (FASTCALL *__computeColorFunc)(__GLcontext *gc, __GLcolor *color); typedef struct _GENTEXCACHE { __GLcontext *gc; ULONG paletteTimeStamp; UCHAR *texImageReplace; GLenum internalFormat; LONG height; LONG width; } GENTEXCACHE; typedef GLboolean (FASTCALL *fastGenLineProc)(__GLcontext *gc); typedef struct _GENACCEL { // // stuff below here is used in the rendering inner loops // ULONG constantR; // These are used for scaling texture color values ULONG constantG; ULONG constantB; ULONG constantA; SPANREC spanValue; SPANREC spanDelta; ULONG rAccum; ULONG gAccum; ULONG bAccum; ULONG aAccum; ULONG sAccum; ULONG tAccum; ULONG sResult[2]; ULONG tResult[2]; ULONG sResultNew[2]; ULONG tResultNew[2]; ULONG sStepX; ULONG tStepX; ULONG subDs; ULONG subDt; ULONG pixAccum; ULONG ditherAccum; __GLfloat qwStepX; __GLfloat qwAccum; ULONG zAccum; PBYTE pPix; BYTE displayColor[4]; __genSpanFunc __fastSpanFuncPtr; // // stuff below here is used in the FillTriangle routine // SPANREC spanDeltaY; int xMultiplier; __genSpanFunc __fastFlatSpanFuncPtr; __genSpanFunc __fastSmoothSpanFuncPtr; __genSpanFunc __fastTexSpanFuncPtr; __GLspanFunc __fastZSpanFuncPtr; __GLspanFunc __fastStippleDepthTestSpan; __GLfloat rAccelScale; // Span scale values __GLfloat gAccelScale; __GLfloat bAccelScale; __GLfloat aAccelScale; __GLfloat zScale; void (FASTCALL *__fastFillSubTrianglePtr)(__GLcontext *, GLint, GLint); void (FASTCALL *__fastCalcDeltaPtr)(__GLcontext *gc, __GLvertex *a, __GLvertex *b, __GLvertex *c); void (*__fastSetInitParamPtr)(__GLcontext *gc, const __GLvertex *a, __GLfloat dx, __GLfloat dy); // // these things are used in the generic rendering or texture path // int bpp; ULONG flags; ULONG tShift; ULONG sMask, tMask; ULONG *texImage; ULONG *texPalette; ULONG tMaskSubDiv; ULONG tShiftSubDiv; __GLfloat texXScale; __GLfloat texYScale; UCHAR *texImageReplace; __GLtexture *tex; GLboolean (FASTCALL *__fastGenZStore)(__GLzValue z, __GLzValue *fp); fastGenLineProc __fastGenLineProc; BOOL (FASTCALL *__fastGenInitLineData)(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); // // stuff below here is not used in drawing triangles // char *buffer; FLONG flLineAccelModes; BOOL bFastLineDispAccel; BOOL bFastLineDIBAccel; __computeColorFunc fastLineComputeColor; BYTE *pFastLineBuffer; POINT *pFastLinePoint; DWORD *pFastLineCount; DWORD fastLineCounts; __GLfloat fastLineOffsetX; __GLfloat fastLineOffsetY; double zDevScale; // z scaling for MCD } GENACCEL; /* ** Secondary dispatch tables for GENENERIC implementation (eg CPU specific) */ // Define the Rendering context used by the Generic implementation // One of these structures is allocated for each wglCreateContext(). The // TEB will contain a pointer to this structure after a wglMakeCurrent() // NOTE: the TEB will also have a pointer to DispatchTables, if we need // another entry on the server side, reuse that one. Could generate code to // offset into contextRec to get a tables. typedef struct __GLGENcontextRec { // Must be first entry struct __GLcontextRec gc; HGLRC hrc; // handle from gdi code HDC CreateDC; // hdc HDC CurrentDC; // hdc made current GLuint flags; // misc. state flags int ipfdCurrent; PIXELFORMATDESCRIPTOR CurrentFormat; WNDOBJ *pwo; GLint WndUniq; GLint WndSizeUniq; ULONG PaletteTimestamp; GLint errorcode; // info for render DC, surface ULONG iDCType; ULONG iSurfType; ULONG iFormatDC; BYTE *pajTranslateVector; // Used for Logical <--> System xlate BYTE *pajInvTranslateVector; HBITMAP ColorsBitmap; // GDI dibs for device managed surfs PVOID ColorsBits; HBITMAP StippleBitmap; PVOID StippleBits; #ifdef _CLIENTSIDE_ HDC ColorsMemDC; HDC ColorsDdbDc; HBITMAP ColorsDdb; #endif // Cached GDI objects for rectangle filling and line drawing HBRUSH hbrFill; COLORREF crFill; HDC hdcFill; HPEN hpenStroke; __GLcolor cStroke; COLORREF crStroke; HDC hdcStroke; BOOL fStrokeInvalid; // A COLORREF value which isn't a legal COLORREF, used for marking // the caches as empty #define COLORREF_UNUSED 0xffffffff __RenderState RenderState; VOID *pPrivateArea; // Pointer to implementation-specific // memory area. GENACCEL genAccel; // Always have this handy... BYTE xlatPalette[256]; // goes here to save indirection GLint visibleWidth; GLint visibleHeight; // Informations used to allow OpenGL to call into the engine to grab // the DEVLOCK and/or drawable semaphore, as well as tear down the cursor. PVOID pdlo; // Pointer to DEVLOCKOBJ PVOID pdco; // Pointer to DCOBJ PVOID pdxo; // Pointer to DEVEXCLUDEOBJ HANDLE hdev; // Handle to device PDEV // Information so that OpenGL can adaptively change the amount of // time the lock is held. DWORD dwLockTick; // tick count when lock was acquired DWORD dwCalls; // tracks number of calls for this tick DWORD dwCallsPerTick; // number of calls per tick allowed DWORD dwLastTick; // last recorded tick count // Type of lock held by OpenGL while drawing to this context (see values // below). ULONG ulLockType; // type of lock // copy-bits function GENDRVACCEL *pDrvAccel; // pointer to 3D DDI state RXHANDLE hrxTexture; // current texture handle PIXCOPYPROC pfnCopyPixels; PIXVISPROC pfnPixelVisible; #ifdef _CLIENTSIDE_ // Pointers to LOGPALETTE buffers. The pointer ppalBuf is storage for // for two maximally sized (MAXPALENTRIES) LOGPALETTEs. One, pointed // to by ppalSave, is a copy of the last LOGPALETTE used. The other, // pointed to by ppalTmp, is used for temporary storage of the current // LOGPALETTE. To keep the saved copy current, rather than copy the // contents of the temp buffer, the two pointers are swapped. // // We need to do this comparison to detect LOGPALETTE changes to maintain // pwnd->ulPaletteUniq when doing >= 16bpp color index-mode drawing // (WM_PALETTECHANGED messages are not sent for this case). // // The LOGPALETTE pointers are NULL if pixelformat is RGBA or < 16bpp. LOGPALETTE *ppalBuf; // Room for both save and tmp buffers. LOGPALETTE *ppalSave; // Saved copy of LOGPALETTE LOGPALETTE *ppalTemp; // Temp storage for current LOGPALETTE // In addition, if we are rendering to a 4bpp or 8bpp DIB, we need to // track changes in the DIB color table. In this case, the ppalBuf // buffer also includes room for two 256-entry RGBQUAD tables. ULONG crgbSave; // Num of valid entries in color table RGBQUAD *prgbSave; // Saved copy of color table ULONG crgbTemp; RGBQUAD *prgbTemp; // Temp storage for color table #endif #ifdef _MCD_ // MCD state GENMCDSTATE *_pMcdState; // pointer to MCD context/state GENMCDSTATE *pMcdState; // pointer to bound MCD context/state // (implies both _pMcdState and pMcdSurf // valid; i.e., valid MCD context is // bound to a valid MCD surface) LONG iLayerPlane; #endif // Add other rc info here } __GLGENcontext; /* * Mark the gc as dirty so that pick procs will be executed when * __glGenericPickAllProcs is called (probably via gc->proc.pickAllProcs). */ #define __GL_INVALIDATE(gc) \ (gc)->dirtyMask |= __GL_DIRTY_GENERIC /* * __GLGENcontext flags * * GLGEN_MCD_CONVERTED_TO_GENERIC context used to be MCD, but now * converted to generic * * GENGC_MCD_BGR_INTO_RGB fake 233BGR format to appear internally * as 332RGB (more 332RGB fast path code) * * GENGC_GENERIC_COMPATIBLE_FORMAT pixel format is compatible with * generic code (see in pixelfmt.c * GenMcdGenericCompatibleFormat) */ #define GLGEN_MCD_CONVERTED_TO_GENERIC 0x0001 #define GENGC_MCD_BGR_INTO_RGB 0x0002 #define GENGC_GENERIC_COMPATIBLE_FORMAT 0x0004 /* * Error codes */ #define GLGEN_NO_ERROR 0 #define GLGEN_OUT_OF_MEMORY 1 #define GLGEN_GRE_FAILURE 2 #define GLGEN_DEVLOCK_FAILED 3 /* * ulLockType values: * * NO_LOCK -- neither drawable or display locks are held. * * DISPLAY_LOCK -- drawable buffers and display surface are protected; * cursor is torn down * * DRAWABLE_LOCK -- only the drawable buffers are protected; cursor is not * torn down */ #define NO_LOCK 0 #define DISPLAY_LOCK 1 #define DRAWABLE_LOCK 2 /* * DCI lock testing functions. GDI drawing calls should not be made * when the DCI lock (i.e., DCIBeginAccess) is held. These are for * use on a checked (debug system) to assert the state of the lock. */ #if DBG #define GENGC_LOCKTYPE (((__GLGENcontext *)GLTEB_SRVCONTEXT())->ulLockType) #define PWNDFLAGS (((GLGENwindow *) (((__GLGENcontext *)GLTEB_SRVCONTEXT())->pwo))->ulFlags) #define CHECKDCILOCKOUT() \ ASSERTOPENGL(GLTEB_SRVCONTEXT() == NULL || \ (GENGC_LOCKTYPE != DISPLAY_LOCK) || \ !(PWNDFLAGS & GLGENWIN_DCILOCK), \ "DCI lock held\n") #define CHECKDCILOCKIN() \ ASSERTOPENGL(GLTEB_SRVCONTEXT() != NULL && \ (GENGC_LOCKTYPE == DISPLAY_LOCK) && \ (PWNDFLAGS & GLGENWIN_DCILOCK), \ "DCI lock not held\n") #else #define CHECKDCILOCKOUT() #define CHECKDCILOCKIN() #endif /* * Structure to keep track of ancillary buffers for a window/drawable * pointer put in consumer field of WNDOBJ * All RCs/threads must share the ancillary buffers, including fake back buffer */ typedef struct __GLGENbitmapRec { WNDOBJ *pwo; // This must be the first member in this structure WNDOBJ wo; HBITMAP hbm; HDC hdc; PVOID pvBits; } __GLGENbitmap; #define CURRENT_DC (((__GLGENbitmap *)cfb->other)->hdc) #define CURRENT_DC_CFB(cfb) (((__GLGENbitmap *)((cfb)->other))->hdc) #define CURRENT_DC_GC(gc) (((__GLGENbitmap *)((gc->drawBuffer)->other))->hdc) #define CURRENT_DC_FRONT_GC(gc) (((__GLGENbitmap *)((gc->front)->other))->hdc) /* * Structure used to cache clip rectangles enumerated from WNDOBJ. */ typedef struct __GLGENclipCacheRec { GLint WndUniq; GLint crcl; RECTL *prcl; } __GLGENclipCache; /****************************************************************************/ // Make sure this header file is loaded, it contains the rectlist definition. #include "srvp.h" /****************************************************************************/ /* * This structure contains the buffers shared by all gc's using the * same window. This structure is accessed via the __GLdrawablePrivate.data * field (which in turn is available both in the gc itself and the * pvConsumer field of the WNDOBJ). */ typedef struct __GLGENbuffersRec { // Global (within this structure) state. GLint WndUniq; GLint WndSizeUniq; GLint flags; GLint width, height; // Ancillary buffers and state. // The ancillary buffers are lazily created. The createdXBuffer flags // indicate one of two states: FALSE means that the lazy allocation // function has never been called, TRUE means that it has. What this // allows us to do, in the event of an ancillary buffer allocation // failure, is temporarily disable the ancillary buffer and continue to // render. At some later time, the createdXBuffer flag serves as an // indication that the buffer SHOULD exist and that we may need to try // and retry the allocation. // // The stencil, depth, accume, and color bits must match the corresponding // bits in the context. Otherwise, glsrvMakeCurrent should not succeed. GLboolean createdStencilBuffer; GLboolean createdDepthBuffer; GLboolean createdAccumBuffer; GLint stencilBits; GLint depthBits; GLint accumBits; GLint colorBits; __GLbuffer stencilBuffer; __GLbuffer depthBuffer; __GLbuffer accumBuffer; // Back buffer. __GLbuffer backBuffer; __GLGENbitmap backBitmap; // Ancillary buffer resize functions. GLboolean (*resize)(__GLdrawablePrivate *, __GLbuffer *, GLint, GLint); GLboolean (*resizeDepth)(__GLdrawablePrivate *, __GLbuffer *, GLint, GLint); // Clip rectangle cache. __GLGENclipCache clip; GENDRVACCEL *pDrvAccel; // pointer to 3D DDI state // dirty regions data PXLIST pxlist; // free lists PYLIST pylist; RECTLIST rl; // SwapBuffers Hint Region BOOL fMax; // should we blt the entire window? #ifdef _MCD_ // MCD surface. GENMCDSURFACE *pMcdSurf; // pointer MCD surface GENMCDSTATE *pMcdState; // pointer to current MCD state // holding McdSurf for rendering // (i.e., holds the WNDOBJ lock) #endif } __GLGENbuffers; /* flags */ #define GLGENBUF_HAS_BACK_BUF 0x0001 #define GLGENBUF_MCD_LOST 0x0002 /****************************************************************************/ void RECTLISTAddRect(PRECTLIST prl, int xs, int ys, int xe, int ye); void RECTLISTSetEmpty(PRECTLIST prl); BOOL RECTLISTIsEmpty(PRECTLIST prl); void YLISTFree(__GLGENbuffers *buffers, PYLIST pylist); void XLISTFree(__GLGENbuffers *buffers, PXLIST pxlist); /****************************************************************************/ /* ** The generic implementation uses the buffer "other" and colorbuffer "other" ** fields. ** ** buf.other - Has pointer to WNDOBJ, or pointer to GLGENbitmapRec that ** can be cast to a pointer to WNDOBJ ** ** colorbuffer.other - flags */ /* colorbuffer.other flags */ #define COLORMASK_ON 0x0001 // glColorMask() not all true #define INDEXMASK_ON 0x0001 // glIndexMask() not all 1's #define DIB_FORMAT 0x0002 // surface is DIB format #define NEED_FETCH 0x0004 // fetch required #define MEMORY_DC 0x0008 // set if DIB in memory (ie !display) // No need to do window clipping /* * Structures and flags for accelerated span and line functions. */ #define SURFACE_TYPE_DIB 0x001 #define HAVE_STIPPLE 0x002 #define GEN_TEXTURE_ORTHO 0x008 #define GEN_TEXTURE 0x010 #define GEN_RGBMODE 0x020 #define GEN_DITHER 0x040 #define GEN_SHADE 0x080 #define GEN_FASTZBUFFER 0x100 #define GEN_LESS 0x200 #define ACCEL_FIX_SCALE 65536.0 #define ACCEL_COLOR_SCALE ((GLfloat)(255.0)) #define ACCEL_COLOR_SCALE_FIX ((GLfloat)(65536.0 * 255.0)) #define DRV_DATA_BUFFER_SIZE 65536 #define DRV_CMD_BUFFER_SIZE 32768 // Overall size of fast line buffer #define __FAST_LINE_BUFFER_SIZE 65536 // Number of polyline counts reserved in the fast line buffer // This is computed to roughly handle lines with eight vertices #define __FAST_LINE_BUFFER_COUNTS (__FAST_LINE_BUFFER_SIZE/64) #define GENACCEL(gc) (((__GLGENcontext *)gc)->genAccel) #define Copy3Bytes( dst, src ) \ { \ GLubyte *ps = (GLubyte *)src, *pd = (GLubyte *)dst; \ *pd++ = *ps++; \ *pd++ = *ps++; \ *pd = *ps ; \ } #define NeedLogicOpFetch( op ) \ !( (op == GL_CLEAR) || (op == GL_COPY) || (op == GL_COPY_INVERTED) || \ (op == GL_SET) ) GLuint FASTCALL DoLogicOp( GLenum logicOp, GLuint SrcColor, GLuint DstColor ); /* * Function Prototypes for Generic calls */ void FASTCALL __fastGenPickSpanProcs(__GLcontext *gc); void FASTCALL __fastGenPickZStoreProc(__GLcontext *gc); void FASTCALL __fastGenPickTriangleProcs(__GLcontext *gc); void FASTCALL __fastGenPickLineProcs(__GLcontext *gc); void FASTCALL __fastGenFillSubTriangle(__GLcontext *, GLint, GLint); void FASTCALL __fastGenFillSubTriangleTexRGBA(__GLcontext *, GLint, GLint); void FASTCALL __glGenPickStoreProcs(__GLcontext *gc); __GLcontext *__glGenCreateContext( HDC hdc, ULONG handle); void ResizeBitmapBuffer(__GLdrawablePrivate *, __GLcolorBuffer *, GLint, GLint); void FASTCALL ClearBitmapBuffer(__GLcolorBuffer *); void UpdateSharedBuffer(__GLbuffer *to, __GLbuffer *from); void FASTCALL LazyAllocateDepth(__GLcontext *gc); void FASTCALL LazyAllocateAccum(__GLcontext *gc); void FASTCALL LazyAllocateStencil(__GLcontext *gc); void FASTCALL glGenInitCommon(__GLGENcontext *gengc, __GLcolorBuffer *cfb, GLenum type); BOOL FASTCALL __glCreateAccelContext(__GLcontext *gc); void FASTCALL __glDestroyAccelContext(__GLcontext *gc); BOOL FASTCALL wglCreateScanlineBuffers(__GLGENcontext *gengc); VOID FASTCALL wglDeleteScanlineBuffers(__GLGENcontext *gengc); VOID FASTCALL wglInitializeColorBuffers(__GLGENcontext *gengc); VOID FASTCALL wglInitializeDepthBuffer(__GLGENcontext *gengc); VOID FASTCALL wglInitializePixelCopyFuncs(__GLGENcontext *gengc); GLboolean ResizeAncillaryBuffer(__GLdrawablePrivate *, __GLbuffer *, GLint, GLint); GLboolean ResizeHardwareDepthBuffer(__GLdrawablePrivate *, __GLbuffer *, GLint, GLint); VOID wglResizeBuffers(__GLGENcontext *gengc, GLint width, GLint height); BOOL wglUpdateBuffers(__GLGENcontext *gengc, __GLGENbuffers *buffers); BOOL __wglInitTempAlloc(void); void * __wglTempAlloc(__GLcontext *Gc, size_t Size); void __wglTempFree(__GLcontext *Gc, void *Addr); extern void FASTCALL GenDrvDestroy(WNDOBJ *, __GLGENbuffers *); void GenDrvFlush(__GLGENcontext *genGc); void FASTCALL GenDrvClear(__GLcolorBuffer *cfb); void FASTCALL GenDrvClearDepth(__GLdepthBuffer *); void FASTCALL GenDrvFillSubTriangle(__GLcontext *, GLint, GLint); void FASTCALL GenDrvTriangle(__GLcontext *, __GLvertex *, __GLvertex *, __GLvertex *, GLboolean); void FASTCALL GenDrvLine(__GLcontext *, __GLvertex *, __GLvertex *, GLuint); void FASTCALL GenDrvIntLine(__GLcontext *, __GLvertex *, __GLvertex *, GLuint); BOOL FASTCALL GenDrvSwapBuffers(GENDRVACCEL *, HDC, WNDOBJ *); void GenDrvCopyPixels(__GLGENcontext *, __GLcolorBuffer *, GLint, GLint, GLint, BOOL); BOOL APIENTRY GenPixelVisible(HDC, LONG, LONG); void FASTCALL GenDrvInitDepth(__GLcontext *, __GLdepthBuffer *); void GenDrvUpdateState(__GLcontext *, BOOL); void GenDrvUpdateClip(__GLcontext *); GLboolean FASTCALL GenDrvDepthTestLine(__GLcontext *); GLboolean FASTCALL GenDrvDepthTestStippledLine(__GLcontext *); GLboolean FASTCALL GenDrvDepthTestStencilLine(__GLcontext *); GLboolean FASTCALL GenDrvDepthTestStencilStippledLine(__GLcontext *); GLboolean FASTCALL GenDrvDepthTestSpan(__GLcontext *); GLboolean FASTCALL GenDrvDepthTestStippledSpan(__GLcontext *); GLboolean FASTCALL GenDrvDepthTestStencilSpan(__GLcontext *); GLboolean FASTCALL GenDrvDepthTestStencilStippledSpan(__GLcontext *); GLboolean FASTCALL bInitDrvContext(__GLcontext *); GLboolean FASTCALL GenDrvMakeCurrent(__GLGENcontext *, HWND hwnd); extern void APIPRIVATE glsrvFlushDrawPolyArray(void *); DWORD FASTCALL __glGenLoadTexture(__GLcontext *gc, __GLtexture *tex); BOOL FASTCALL __glGenUpdateTexture(__GLcontext *gc, __GLtexture *tex, DWORD loadKey); void FASTCALL __glGenFreeTexture(__GLcontext *gc, __GLtexture *tex, DWORD loadKey); BOOL FASTCALL __glGenMakeTextureCurrent(__GLcontext *gc, __GLtexture *tex, DWORD loadKey); void FASTCALL __glGenUpdateTexturePalette(__GLcontext *gc, __GLtexture *tex, DWORD loadKey, ULONG start, ULONG count); void * GenMalloc( size_t Size ); void * GenMallocAlign32( size_t Size ); void * GenCalloc( size_t NumElem, size_t SizeElem ); void GenFree( void *Addr ); void GenFreeAlign32( void *Addr ); void * GenRealloc( void *OldAddr, size_t NewSize ); void *__wglMalloc( __GLcontext *Gc, size_t Size ); void *__wglMallocAlign32( __GLcontext *Gc, size_t Size ); void *__wglCalloc( __GLcontext *Gc, size_t NumElem, size_t SizeElem ); void *__wglRealloc( __GLcontext *Gc, void *OldAddr, size_t NewSize ); void __wglFree( __GLcontext *Gc, void *Addr ); void __wglFreeAlign32( __GLcontext *Gc, void *Addr ); /* * Function Prototypes and Externs for accelerated generic calls */ extern __genSpanFunc __fastGenRGBFlatFuncs[]; extern __genSpanFunc __fastGenCIFlatFuncs[]; extern __genSpanFunc __fastGenRGBFuncs[]; extern __genSpanFunc __fastGenCIFuncs[]; extern __genSpanFunc __fastGenTexDecalFuncs[]; extern __genSpanFunc __fastGenTexFuncs[]; extern __genSpanFunc __fastGenWTexDecalFuncs[]; extern __genSpanFunc __fastGenWTexFuncs[]; extern __genSpanFunc __fastPerspTexReplaceFuncs[]; extern __genSpanFunc __fastPerspTexPalReplaceFuncs[]; extern __genSpanFunc __fastPerspTexFlatFuncs[]; extern __genSpanFunc __fastPerspTexSmoothFuncs[]; extern __GLspanFunc __fastDepthFuncs[]; extern __GLspanFunc __fastDepth16Funcs[]; extern void FASTCALL __fastGenDeltaSpan(__GLcontext *gc, SPANREC *spanDelta); extern void FASTCALL __fastGenFillTriangle(__GLcontext *gc, __GLvertex *a, __GLvertex *b, __GLvertex *c, GLboolean ccw); extern void FASTCALL __fastGenDrvFillTriangle(__GLcontext *gc, __GLvertex *a, __GLvertex *b, __GLvertex *c, GLboolean ccw); extern void FASTCALL __fastLineComputeOffsets(__GLGENcontext *gengc); extern void FASTCALL __fastGenRenderLineDIBRGB8(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineDIBRGB16(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineDIBRGB(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineDIBBGR(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineDIBRGB32(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineDIBCI8(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineDIBCI16(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineDIBCIRGB(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineDIBCIBGR(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineDIBCI32(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineWideDIBRGB8(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineWideDIBRGB16(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineWideDIBRGB(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineWideDIBBGR(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineWideDIBRGB32(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineWideDIBCI8(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineWideDIBCI16(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineWideDIBCIRGB(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineWideDIBCIBGR(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern void FASTCALL __fastGenRenderLineWideDIBCI32(__GLcontext *gc, __GLvertex *v0, __GLvertex *v1); extern BOOL FASTCALL __glGenCreateAccelContext(__GLcontext *gc); extern void FASTCALL __glGenDestroyAccelContext(__GLcontext *gc); extern void FASTCALL __glGenEndPrim(__GLcontext *gc); #ifdef NT // Primary server side dispatch table for GENERIC implementation. extern __GLsrvDispatchTable __glGenim_srvDispatchTable; #endif #ifdef NT_DEADCODE_DISPATCH /* ** Primary dispatch tables for GENERIC implementation */ extern __GLdispatchTable __glGenim_dispatchTable; extern __GLvertexDispatchTable __glGenim_vertexDispatchTable; extern __GLcolorDispatchTable __glGenim_colorDispatchTable; extern __GLnormalDispatchTable __glGenim_normalDispatchTable; extern __GLtexCoordDispatchTable __glGenim_texCoordDispatchTable; extern __GLrasterPosDispatchTable __glGenim_rasterPosDispatchTable; extern __GLrectDispatchTable __glGenim_rectDispatchTable; extern __GLdispatchTable __glGenlc_dispatchTable; extern __GLvertexDispatchTable __glGenlc_vertexDispatchTable; extern __GLcolorDispatchTable __glGenlc_colorDispatchTable; extern __GLnormalDispatchTable __glGenlc_normalDispatchTable; extern __GLtexCoordDispatchTable __glGenlc_texCoordDispatchTable; extern __GLrasterPosDispatchTable __glGenlc_rasterPosDispatchTable; extern __GLrectDispatchTable __glGenlc_rectDispatchTable; #endif // NT_DEADCODE_DISPATCH extern void gdiCopyPixels(__GLGENcontext *, __GLcolorBuffer *, GLint, GLint, GLint, BOOL); extern void dibCopyPixels(__GLGENcontext *, __GLcolorBuffer *, GLint, GLint, GLint, BOOL); typedef void (FASTCALL *PFNZIPPYSUB)(__GLcontext *gc, GLint iyBottom, GLint iyTop); void FASTCALL __ZippyFSTRGBTex(__GLcontext *gc, GLint iyBottom, GLint iyTop); void FASTCALL __ZippyFSTTex(__GLcontext *gc, GLint iyBottom, GLint iyTop); void FASTCALL __ZippyFSTRGB(__GLcontext *gc, GLint iyBottom, GLint iyTop); void FASTCALL __ZippyFSTCI(__GLcontext *gc, GLint iyBottom, GLint iyTop); void FASTCALL __ZippyFSTZ(__GLcontext *gc, GLint iyBottom, GLint iyTop); void FASTCALL __ZippyFSTCI8Flat(__GLcontext *gc, GLint iyBottom, GLint iyTop); void FASTCALL __fastGenSpan(__GLGENcontext *gengc); GLboolean FASTCALL __fastGenStippleLt32Span(__GLcontext *gc); GLboolean FASTCALL __fastGenStippleLt16Span(__GLcontext *gc); GLboolean FASTCALL __fastGenStippleAnyDepthTestSpan(__GLcontext *gc); extern BYTE gbMulTable[]; extern BYTE gbSatTable[]; extern DWORD ditherShade[]; extern DWORD ditherTexture[]; extern __GLfloat fDitherIncTable[]; // defined in genrgb.c #if DBG HLOCAL glDbgAlloc(UINT flags, UINT nbytes); HLOCAL glDbgFree(HLOCAL pv); HLOCAL glDbgReAlloc(HLOCAL pv, UINT nbytes, UINT flags); #define LOCALALLOC(f, sz) glDbgAlloc((f), (sz)) #define LOCALREALLOC(a, sz, f) glDbgReAlloc((a), (sz), (f)) #define LOCALFREE(a) glDbgFree(a) #else #define LOCALALLOC(f, sz) LocalAlloc((f), (sz)) #define LOCALREALLOC(a, sz, f) LocalReAlloc((a), (sz), (f)) #define LOCALFREE(a) LocalFree(a) #endif // DBG #endif /* __GLGENCONTXT_H__ */