838 lines
30 KiB
C
838 lines
30 KiB
C
/*
|
|
** 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 <winddi.h>
|
|
#include "mcdrv.h"
|
|
#include "mcd2hack.h"
|
|
#include "mcd.h"
|
|
#endif
|
|
|
|
// Re-enable long to float conversion warning. see also context.h
|
|
#pragma warning (default:4244)
|
|
|
|
#ifdef _CLIENTSIDE_
|
|
#include "glscreen.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_SUBPIXEL_BITS 3
|
|
|
|
#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_MAX_INV_TABLE 31
|
|
|
|
#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 BOOL (APIENTRY *PIXVISPROC)(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
|
|
GLWINDOWID gwidCurrent; // Surface made current
|
|
DWORD dwCurrentFlags; // GLSURF flags for current surface
|
|
GLDDSURF *pgddsFront; // Current DirectDraw surface for
|
|
// front buffer
|
|
|
|
GLuint flags; // misc. state flags
|
|
|
|
// Window that this context was made current to. Set in MakeCurrent and
|
|
// kept to validate that attentions are taking place on the same
|
|
// window as was made current.
|
|
GLGENwindow *pwndMakeCur;
|
|
|
|
// Window that this context current is holding a lock on. While
|
|
// locked, this must always match pwndMakeCur. When outside the
|
|
// lock it will be NULL. Any context-derived window access must
|
|
// use this field rather than pwndMakeCur to ensure that access
|
|
// only takes place while the window lock is held.
|
|
GLGENwindow *pwndLocked;
|
|
|
|
GLint WndUniq;
|
|
GLint WndSizeUniq;
|
|
ULONG PaletteTimestamp;
|
|
GLint errorcode;
|
|
|
|
// info for render DC, surface
|
|
GLSURF gsurf;
|
|
int ipfdCurrent;
|
|
|
|
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;
|
|
|
|
// 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
|
|
|
|
// Locks held by OpenGL while drawing to this context (see values
|
|
// below).
|
|
|
|
FSHORT fsGenLocks; // locks needed for generic code
|
|
FSHORT fsLocks; // locks actually held
|
|
|
|
HANDLE hTexture; // 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
|
|
// the window 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
|
|
|
|
/*
|
|
* Locks that can be held during operation.
|
|
*
|
|
* Value Description
|
|
* ------------------------------------------------------------------
|
|
* LOCKFLAG_WINDOW Window information semaphore.
|
|
* LOCKFLAG_MCD MCD lock.
|
|
* LOCKFLAG_FRONT_BUFFER Primary surface lock.
|
|
* LOCKFLAG_DD_DEPTH DirectDraw depth buffer surface lock.
|
|
* LOCKFLAG_DD_TEXTURE DirectDraw texture mipmap surface locks.
|
|
*
|
|
* __GLGENcontext.fsLocks indicates the locks currently held by the context.
|
|
* __GLGENcontext.fsGenLocks indicates the locks that need to be held
|
|
* if generic code is going to be executed. The two fields allow
|
|
* lazy acquisition of locks by deferring actual locking until just
|
|
* before generic code is executed.
|
|
*
|
|
*/
|
|
#define LOCKFLAG_WINDOW 0x0001
|
|
#define LOCKFLAG_MCD 0x0002
|
|
#define LOCKFLAG_FRONT_BUFFER 0x0004
|
|
#define LOCKFLAG_DD_DEPTH 0x0008
|
|
#define LOCKFLAG_DD_TEXTURE 0x0010
|
|
|
|
// All lock flags that can be lazily acquired.
|
|
#define LAZY_LOCK_FLAGS \
|
|
(LOCKFLAG_MCD | LOCKFLAG_FRONT_BUFFER | LOCKFLAG_DD_DEPTH | \
|
|
LOCKFLAG_DD_TEXTURE)
|
|
|
|
// All lock flags for surfaces.
|
|
#define SURFACE_LOCK_FLAGS \
|
|
(LOCKFLAG_FRONT_BUFFER | LOCKFLAG_DD_DEPTH | LOCKFLAG_DD_TEXTURE)
|
|
|
|
// All lock flags for color buffer access.
|
|
#define COLOR_LOCK_FLAGS (LOCKFLAG_MCD | LOCKFLAG_FRONT_BUFFER)
|
|
|
|
// All lock flags for depth buffer access.
|
|
#define DEPTH_LOCK_FLAGS (LOCKFLAG_MCD | LOCKFLAG_DD_DEPTH)
|
|
|
|
// All lock flags for texture access.
|
|
#define TEXTURE_LOCK_FLAGS LOCKFLAG_DD_TEXTURE
|
|
|
|
// Accesses required for fragment rendering.
|
|
#define RENDER_LOCK_FLAGS (COLOR_LOCK_FLAGS | DEPTH_LOCK_FLAGS | \
|
|
TEXTURE_LOCK_FLAGS)
|
|
|
|
/*
|
|
* Screen lock testing functions. GDI drawing calls should not be made
|
|
* when the screen lock is held. These are for
|
|
* use on a checked (debug system) to assert the state of the lock.
|
|
*/
|
|
#if DBG
|
|
#define GENGC_LOCK \
|
|
(((__GLGENcontext *)GLTEB_SRVCONTEXT())->fsLocks)
|
|
#define PWNDFLAGS \
|
|
((((__GLGENcontext *)GLTEB_SRVCONTEXT())->pwndLocked)->ulFlags)
|
|
#define CHECKSCREENLOCKOUT() \
|
|
ASSERTOPENGL(GLTEB_SRVCONTEXT() == NULL || \
|
|
!(GENGC_LOCK & LOCKFLAG_FRONT_BUFFER) || \
|
|
!(PWNDFLAGS & GLGENWIN_DIRECTSCREEN), \
|
|
"Screen lock held\n")
|
|
|
|
#define CHECKSCREENLOCKIN() \
|
|
ASSERTOPENGL(GLTEB_SRVCONTEXT() != NULL && \
|
|
(GENGC_LOCK & LOCKFLAG_FRONT_BUFFER) && \
|
|
(PWNDFLAGS & GLGENWIN_DIRECTSCREEN), \
|
|
"Screen lock not held\n")
|
|
#else
|
|
#define CHECKSCREENLOCKOUT()
|
|
#define CHECKSCREENLOCKIN()
|
|
#endif
|
|
|
|
/*
|
|
* Structure to keep track of ancillary buffers for a window/drawable
|
|
* All RCs/threads must share the ancillary buffers, including fake back buffer
|
|
*/
|
|
|
|
typedef struct __GLGENbitmapRec {
|
|
GLGENwindow *pwnd; // This must be the first member in this structure
|
|
GLGENwindow wnd;
|
|
HBITMAP hbm;
|
|
HDC hdc;
|
|
PVOID pvBits;
|
|
} __GLGENbitmap;
|
|
|
|
#define CURRENT_DC_CFB(cfb) ((cfb)->bitmap->hdc)
|
|
#define CURRENT_DC CURRENT_DC_CFB(cfb)
|
|
#define CURRENT_DC_GC(gc) CURRENT_DC_CFB(gc->drawBuffer)
|
|
#define CURRENT_DC_FRONT_GC(gc) CURRENT_DC_CFB(gc->front)
|
|
|
|
/*
|
|
* Structure used to cache clip rectangles enumerated from window clip region.
|
|
*/
|
|
|
|
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"
|
|
|
|
/****************************************************************************/
|
|
|
|
// Comment it out if the __glDoPolygonClip stack allocation fix is not
|
|
// wanted
|
|
#define __CLIP_FIX
|
|
|
|
#ifdef __CLIP_FIX
|
|
#define __GL_TOTAL_CLIP_PLANES 20 /*XXX*/
|
|
#define __GL_MAX_CLIP_VERTEX (__GL_TOTAL_CLIP_PLANES + __GL_MAX_POLYGON_CLIP_SIZE)
|
|
#endif
|
|
|
|
/*
|
|
* This structure contains the buffers shared by all gc's using the
|
|
* same window.
|
|
*/
|
|
|
|
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, accum, 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;
|
|
GLint alphaBits;
|
|
__GLbuffer alphaBuffer0;
|
|
__GLbuffer alphaBuffer1;
|
|
__GLbuffer *alphaFrontBuffer;
|
|
__GLbuffer *alphaBackBuffer;
|
|
|
|
// Back buffer.
|
|
|
|
__GLbuffer backBuffer;
|
|
__GLGENbitmap backBitmap;
|
|
|
|
// Ancillary buffer resize functions.
|
|
|
|
GLboolean (*resize)(__GLGENbuffers *, __GLbuffer *, GLint, GLint);
|
|
GLboolean (*resizeDepth)(__GLGENbuffers *, __GLbuffer *, GLint, GLint);
|
|
|
|
// Clip rectangle cache.
|
|
|
|
__GLGENclipCache clip;
|
|
|
|
// 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 window lock)
|
|
#endif
|
|
|
|
#ifdef __CLIP_FIX
|
|
__GLvertex *clip_verts[__GL_TOTAL_CLIP_PLANES][__GL_MAX_CLIP_VERTEX];
|
|
#endif
|
|
};
|
|
|
|
/* 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);
|
|
|
|
/****************************************************************************/
|
|
|
|
/* colorbuffer flags */
|
|
#define COLORMASK_ON 0x0001 // glColorMask() not all true for r,g,b
|
|
#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)
|
|
#define NO_CLIP 0x0010 // Set if surface never requires clip
|
|
#define ALPHA_ON 0x0020 // have alphaBits, alphaMask is true
|
|
#define ALPHA_IN_PIXEL_BIT 0x0040 // alpha is part of the pixel
|
|
|
|
#define ALPHA_WRITE_ENABLED( cfb ) \
|
|
( (cfb)->buf.flags & ALPHA_ON )
|
|
|
|
// These next macros take into account the fact that alpha values can either be
|
|
// part of the pixel (e.g. MCD color buffer), or are kept in a separate software
|
|
// buffer (generic software implementation). They are mostly used by the span
|
|
// routines in genrgb.c to determine where to store/fetch alpha values.
|
|
|
|
#define ALPHA_IN_PIXEL( cfb ) \
|
|
( (cfb)->buf.flags & ALPHA_IN_PIXEL_BIT )
|
|
|
|
#define ALPHA_BUFFER_WRITE( cfb ) \
|
|
(((cfb)->buf.flags & (ALPHA_ON | ALPHA_IN_PIXEL_BIT)) == ALPHA_ON)
|
|
|
|
#define ALPHA_PIXEL_WRITE( cfb ) \
|
|
(((cfb)->buf.flags & (ALPHA_ON | ALPHA_IN_PIXEL_BIT)) == \
|
|
(ALPHA_ON | ALPHA_IN_PIXEL_BIT))
|
|
|
|
|
|
/*
|
|
* 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))
|
|
|
|
// 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)
|
|
|
|
BOOL FASTCALL __glGenCreateAccelContext(__GLcontext *gc);
|
|
void FASTCALL __glGenDestroyAccelContext(__GLcontext *gc);
|
|
|
|
#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(__GLGENbuffers *, __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 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(__GLGENbuffers *, __GLbuffer *, GLint, GLint);
|
|
GLboolean ResizeUnownedDepthBuffer(__GLGENbuffers *, __GLbuffer *, GLint, GLint);
|
|
VOID wglResizeBuffers(__GLGENcontext *gengc, GLint width, GLint height);
|
|
BOOL wglUpdateBuffers(__GLGENcontext *gengc, __GLGENbuffers *buffers);
|
|
|
|
extern void APIPRIVATE glsrvFlushDrawPolyArray(struct _POLYARRAY *, BOOL);
|
|
|
|
MCDHANDLE FASTCALL __glGenLoadTexture(__GLcontext *gc, __GLtexture *tex, ULONG flags);
|
|
BOOL FASTCALL __glGenUpdateTexture(__GLcontext *gc, __GLtexture *tex, MCDHANDLE loadKey);
|
|
void FASTCALL __glGenFreeTexture(__GLcontext *gc, __GLtexture *tex, MCDHANDLE loadKey);
|
|
BOOL FASTCALL __glGenMakeTextureCurrent(__GLcontext *gc, __GLtexture *tex, MCDHANDLE loadKey);
|
|
void FASTCALL __glGenUpdateTexturePalette(__GLcontext *gc, __GLtexture *tex, MCDHANDLE loadKey,
|
|
ULONG start, ULONG count);
|
|
#ifdef GL_EXT_flat_paletted_lighting
|
|
void FASTCALL __glGenSetPaletteOffset(__GLcontext *gc, __GLtexture *tex,
|
|
GLint offset);
|
|
#endif
|
|
|
|
/*
|
|
* 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 __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 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 invTable[];
|
|
|
|
extern __GLfloat fDitherIncTable[]; // defined in genrgb.c
|
|
|
|
void FASTCALL __glGenFreeBuffers( __GLGENbuffers *buffers );
|
|
|
|
#endif /* __GLGENCONTXT_H__ */
|