You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2164 lines
69 KiB
2164 lines
69 KiB
/******************************Module*Header*******************************\
|
|
* Module Name: wglsup.c *
|
|
* *
|
|
* WGL support routines. *
|
|
* *
|
|
* Created: 15-Dec-1994 *
|
|
* Author: Gilman Wong [gilmanw] *
|
|
* *
|
|
* Copyright (c) 1994 Microsoft Corporation *
|
|
\**************************************************************************/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
#include "devlock.h"
|
|
|
|
#define DONTUSE(x) ( (x) = (x) )
|
|
|
|
//!!!XXX -- Patrick says is necessary, but so far we seem OK. I think
|
|
// it is really the apps responsibility.
|
|
//!!!dbug
|
|
#if 1
|
|
#define REALIZEPALETTE(hdc) RealizePalette((hdc))
|
|
#else
|
|
#define REALIZEPALETTE(hdc)
|
|
#endif
|
|
|
|
//!!!XXX -- BitBlt's involving DIB sections are batched.
|
|
// A GdiFlush is required, but perhaps can be taken out when
|
|
// GDI goes to kernel-mode. Can probably take out for Win95.
|
|
//#ifdef _OPENGL_NT_
|
|
#if 1
|
|
#define GDIFLUSH GdiFlush()
|
|
#else
|
|
#define GDIFLUSH
|
|
#endif
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglPixelVisible
|
|
*
|
|
* Determines if the pixel (x, y) is visible in the window associated with
|
|
* the given DC. The determination is made by checking the coordinate
|
|
* against the visible region data cached in the GLGENwindow structure for
|
|
* this winodw.
|
|
*
|
|
* Returns:
|
|
* TRUE if pixel (x, y) is visible, FALSE if clipped out.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
BOOL APIENTRY wglPixelVisible(LONG x, LONG y)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
__GLGENcontext *gengc = (__GLGENcontext *) GLTEB_SRVCONTEXT();
|
|
GLGENwindow *pwnd = gengc->pwndLocked;
|
|
|
|
// If direct screen access isn't active we shouldn't call this function
|
|
// since there's no need to do any visibility clipping ourselves
|
|
ASSERTOPENGL(GLDIRECTSCREEN,
|
|
"wglPixelVisible called without direct access\n");
|
|
|
|
// Quick test against bounds.
|
|
|
|
if (
|
|
pwnd->prgndat && pwnd->pscandat &&
|
|
x >= pwnd->prgndat->rdh.rcBound.left &&
|
|
x < pwnd->prgndat->rdh.rcBound.right &&
|
|
y >= pwnd->prgndat->rdh.rcBound.top &&
|
|
y < pwnd->prgndat->rdh.rcBound.bottom
|
|
)
|
|
{
|
|
ULONG cScans = pwnd->pscandat->cScans;
|
|
GLGENscan *pscan = pwnd->pscandat->aScans;
|
|
|
|
// Find right scan.
|
|
|
|
for ( ; cScans; cScans--, pscan = pscan->pNext )
|
|
{
|
|
// Check if point is above scan.
|
|
|
|
if ( pscan->top > y )
|
|
{
|
|
// Since scans are ordered top-down, we can conclude that
|
|
// point is also above subsequent scans. Therefore intersection
|
|
// must be NULL and we can terminate search.
|
|
|
|
break;
|
|
}
|
|
|
|
// Check if point is within scan.
|
|
|
|
else if ( pscan->bottom > y )
|
|
{
|
|
LONG *plWalls = pscan->alWalls;
|
|
LONG *plWallsEnd = plWalls + pscan->cWalls;
|
|
|
|
// Check x against each pair of walls.
|
|
|
|
for ( ; plWalls < plWallsEnd; plWalls+=2 )
|
|
{
|
|
// Each pair of walls (inclusive-exclusive) defines
|
|
// a non-NULL interval in the span that is visible.
|
|
|
|
ASSERTOPENGL(
|
|
plWalls[0] < plWalls[1],
|
|
"wglPixelVisible(): bad walls in span\n"
|
|
);
|
|
|
|
// Check if x is within current interval.
|
|
|
|
if ( x >= plWalls[0] && x < plWalls[1] )
|
|
{
|
|
bRet = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
// Point is below current scan. Try next scan.
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglSpanVisible
|
|
*
|
|
* Determines the visibility of the span [(x, y), (x+w, y)) (test is
|
|
* inclusive-exclusive) in the current window. The span is either
|
|
* completely visible, partially visible (clipped), or completely
|
|
* clipped out (WGL_SPAN_ALL, WGL_SPAN_PARTIAL, and WGL_SPAN_NONE,
|
|
* respectively).
|
|
*
|
|
* WGL_SPAN_ALL
|
|
* ------------
|
|
* The entire span is visible. *pcWalls and *ppWalls are not set.
|
|
*
|
|
* WGL_SPAN_NONE
|
|
* -------------
|
|
* The span is completely obscured (clipped out). *pcWalls and *ppWalls
|
|
* are not set.
|
|
*
|
|
* WGL_SPAN_PARTIAL
|
|
* ----------------
|
|
* If the span is WGL_SPAN_PARTIAL, the function also returns a pointer
|
|
* to the wall array (starting with the first wall actually intersected
|
|
* by the span) and a count of the walls at this pointer.
|
|
*
|
|
* If the wall count is even, then the span starts outside the visible
|
|
* region and the first wall is where the span enters a visible portion.
|
|
*
|
|
* If the wall count is odd, then the span starts inside the visible
|
|
* region and the first wall is where the span exits a visible portion.
|
|
*
|
|
* The span may or may not cross all the walls in the array, but definitely
|
|
* does cross the first wall.
|
|
*
|
|
* Return:
|
|
* Returns WGL_SPAN_ALL, WGL_SPAN_NONE, or WGL_SPAN_PARTIAL. In
|
|
* addition, if return is WGL_SPAN_PARTIAL, pcWalls and ppWalls will
|
|
* be set (see above).
|
|
*
|
|
* History:
|
|
* 06-Dec-1994 -by- Gilman Wong [gilmanw]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
ULONG APIENTRY
|
|
wglSpanVisible(LONG x, LONG y, ULONG w, LONG *pcWalls, LONG **ppWalls)
|
|
{
|
|
ULONG ulRet = WGL_SPAN_NONE;
|
|
__GLGENcontext *gengc = (__GLGENcontext *) GLTEB_SRVCONTEXT();
|
|
GLGENwindow *pwnd = gengc->pwndLocked;
|
|
LONG xRight = x + w; // Right edge of span (exclusive)
|
|
|
|
// If direct access is not active we shouldn't call this function since
|
|
// there's no need to do any visibility clipping ourselves
|
|
ASSERTOPENGL(GLDIRECTSCREEN,
|
|
"wglSpanVisible called without direct access\n");
|
|
|
|
// Quick test against bounds.
|
|
|
|
if (
|
|
pwnd->prgndat && pwnd->pscandat &&
|
|
(x < pwnd->prgndat->rdh.rcBound.right ) &&
|
|
(xRight > pwnd->prgndat->rdh.rcBound.left ) &&
|
|
(y >= pwnd->prgndat->rdh.rcBound.top ) &&
|
|
(y < pwnd->prgndat->rdh.rcBound.bottom)
|
|
)
|
|
{
|
|
ULONG cScans = pwnd->pscandat->cScans;
|
|
GLGENscan *pscan = pwnd->pscandat->aScans;
|
|
|
|
// Find right scan.
|
|
|
|
for ( ; cScans; cScans--, pscan = pscan->pNext )
|
|
{
|
|
// Check if span is above scan.
|
|
|
|
if ( pscan->top > y ) // Scans have gone past span
|
|
{
|
|
// Since scans are ordered top-down, we can conclude that
|
|
// span will aslo be above subsequent scans. Therefore
|
|
// intersection must be NULL and we can terminate search.
|
|
|
|
goto wglSpanVisible_exit;
|
|
}
|
|
|
|
// Span is below top of scan. If span is also above bottom,
|
|
// span vertically intersects this scan and only this scan.
|
|
|
|
else if ( pscan->bottom > y )
|
|
{
|
|
LONG *plWalls = pscan->alWalls;
|
|
ULONG cWalls = pscan->cWalls;
|
|
|
|
ASSERTOPENGL(
|
|
(cWalls & 0x1) == 0,
|
|
"wglSpanVisible(): wall count must be even!\n"
|
|
);
|
|
|
|
// Check span against each pair of walls. Walls are walked
|
|
// from left to right.
|
|
//
|
|
// Possible intersections where "[" is inclusive
|
|
// and ")" is exclusive:
|
|
// left wall right wall
|
|
// [ )
|
|
// case 1a [-----) [ )
|
|
// 1b [-----) )
|
|
// [ )
|
|
// case 2a [-----) ) return
|
|
// 2b [-------------------) left wall
|
|
// [ )
|
|
// case 3a [-----) )
|
|
// 3b [ [-----) )
|
|
// 3c [ [-----)
|
|
// 3d [----------------)
|
|
// [ )
|
|
// case 4a [ [-----) return
|
|
// 4b [-------------------) right wall
|
|
// [ )
|
|
// case 5a [ [-----)
|
|
// 5b [ ) [-----)
|
|
// [ )
|
|
// case 6 [----------------------) return
|
|
// [ ) left wall
|
|
|
|
for ( ; cWalls; cWalls-=2, plWalls+=2 )
|
|
{
|
|
// Each pair of walls (inclusive-exclusive) defines
|
|
// a non-NULL interval in the span that is visible.
|
|
|
|
ASSERTOPENGL(
|
|
plWalls[0] < plWalls[1],
|
|
"wglSpanVisible(): bad walls in span\n"
|
|
);
|
|
|
|
// Checking right end against left wall will partition the
|
|
// set into case 1 vs. case 2 thru 6.
|
|
|
|
if ( plWalls[0] >= xRight )
|
|
{
|
|
// Case 1 -- span outside interval on the left.
|
|
//
|
|
// The walls are ordered from left to right (i.e., low
|
|
// to high). So if span is left of this interval, it
|
|
// must also be left of all subsequent intervals and
|
|
// we can terminate the search.
|
|
|
|
goto wglSpanVisible_exit;
|
|
}
|
|
|
|
// Cases 2 thru 6.
|
|
//
|
|
// Checking left end against right wall will partition subset
|
|
// into case 5 vs. cases 2, 3, 4, 6.
|
|
|
|
else if ( plWalls[1] > x )
|
|
{
|
|
// Cases 2, 3, 4, and 6.
|
|
//
|
|
// Checking left end against left wall will partition
|
|
// subset into cases 2, 6 vs. cases 3, 4.
|
|
|
|
if ( plWalls[0] <= x )
|
|
{
|
|
// Cases 3 and 4.
|
|
//
|
|
// Checking right end against right wall will
|
|
// distinguish between the two cases.
|
|
|
|
if ( plWalls[1] >= xRight )
|
|
{
|
|
// Case 3 -- completely visible.
|
|
|
|
ulRet = WGL_SPAN_ALL;
|
|
}
|
|
else
|
|
{
|
|
// Case 4 -- partially visible, straddling the
|
|
// right wall.
|
|
|
|
ulRet = WGL_SPAN_PARTIAL;
|
|
|
|
*ppWalls = &plWalls[1];
|
|
*pcWalls = cWalls - 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Cases 2 and 6 -- in either case its a partial
|
|
// intersection where the first intersection is with
|
|
// the left wall.
|
|
|
|
ulRet = WGL_SPAN_PARTIAL;
|
|
|
|
*ppWalls = &plWalls[0];
|
|
*pcWalls = cWalls;
|
|
}
|
|
|
|
goto wglSpanVisible_exit;
|
|
}
|
|
|
|
// Case 5 -- span outside interval to the right. Try
|
|
// next pair of walls.
|
|
}
|
|
|
|
// A span can intersect only one scan. We don't need to check
|
|
// any other scans.
|
|
|
|
goto wglSpanVisible_exit;
|
|
}
|
|
|
|
// Span is below current scan. Try next scan.
|
|
}
|
|
}
|
|
|
|
wglSpanVisible_exit:
|
|
|
|
return ulRet;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* bComputeLogicalToSurfaceMap
|
|
*
|
|
* Copy logical palette to surface palette translation vector to the buffer
|
|
* pointed to by pajVector. The logical palette is specified by hpal. The
|
|
* surface is specified by hdc.
|
|
*
|
|
* Note: The hdc may identify either a direct (display) dc or a DIB memory dc.
|
|
* If hdc is a display dc, then the surface palette is the system palette.
|
|
* If hdc is a memory dc, then the surface palette is the DIB color table.
|
|
*
|
|
* History:
|
|
* 27-Jan-1996 -by- Gilman Wong [gilmanw]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
BOOL bComputeLogicalToSurfaceMap(HPALETTE hpal, HDC hdc, BYTE *pajVector)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
HPALETTE hpalSurf;
|
|
ULONG cEntries, cSysEntries;
|
|
DWORD dwDcType = wglObjectType(hdc);
|
|
LPPALETTEENTRY lppeTmp, lppeEnd;
|
|
|
|
BYTE aj[sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * 512) + (sizeof(RGBQUAD) * 256)];
|
|
LOGPALETTE *ppal = (LOGPALETTE *) aj;
|
|
LPPALETTEENTRY lppeSurf = &ppal->palPalEntry[0];
|
|
LPPALETTEENTRY lppe = lppeSurf + 256;
|
|
RGBQUAD *prgb = (RGBQUAD *) (lppe + 256);
|
|
|
|
// Determine number of colors in each palette.
|
|
|
|
cEntries = GetPaletteEntries(hpal, 0, 1, NULL);
|
|
if (dwDcType == OBJ_DC)
|
|
cSysEntries = wglGetSystemPaletteEntries(hdc, 0, 1, NULL);
|
|
else
|
|
cSysEntries = 256;
|
|
|
|
// Dynamic color depth changing can cause this.
|
|
|
|
if ((cSysEntries > 256) || (cEntries > 256))
|
|
{
|
|
WARNING("wglCopyTranslationVector(): palette on > 8BPP device\n");
|
|
|
|
// Drawing will have corrupted colors, but at least we should not crash.
|
|
|
|
cSysEntries = min(cSysEntries, 256);
|
|
cEntries = min(cEntries, 256);
|
|
}
|
|
|
|
// Get the logical palette entries.
|
|
|
|
cEntries = GetPaletteEntries(hpal, 0, cEntries, lppe);
|
|
|
|
// Get the surface palette entries.
|
|
|
|
if (dwDcType == OBJ_DC)
|
|
{
|
|
cSysEntries = wglGetSystemPaletteEntries(hdc, 0, cSysEntries, lppeSurf);
|
|
|
|
lppeTmp = lppeSurf;
|
|
lppeEnd = lppeSurf + cSysEntries;
|
|
|
|
for (; lppeTmp < lppeEnd; lppeTmp++)
|
|
lppeTmp->peFlags = 0;
|
|
}
|
|
else
|
|
{
|
|
RGBQUAD *prgbTmp;
|
|
|
|
// First get RGBQUADs from DIB color table...
|
|
|
|
cSysEntries = GetDIBColorTable(hdc, 0, cSysEntries, prgb);
|
|
|
|
// ...then convert RGBQUADs into PALETTEENTRIES.
|
|
|
|
prgbTmp = prgb;
|
|
lppeTmp = lppeSurf;
|
|
lppeEnd = lppeSurf + cSysEntries;
|
|
|
|
while (lppeTmp < lppeEnd)
|
|
{
|
|
lppeTmp->peRed = prgbTmp->rgbRed;
|
|
lppeTmp->peGreen = prgbTmp->rgbGreen;
|
|
lppeTmp->peBlue = prgbTmp->rgbBlue;
|
|
lppeTmp->peFlags = 0;
|
|
|
|
lppeTmp++;
|
|
prgbTmp++;
|
|
|
|
}
|
|
}
|
|
|
|
// Construct a translation vector by using GetNearestPaletteIndex to
|
|
// map each entry in the logical palette to the surface palette.
|
|
|
|
if (cEntries && cSysEntries)
|
|
{
|
|
// Create a temporary logical palette that matches the surface
|
|
// palette retrieved above.
|
|
|
|
ppal->palVersion = 0x300;
|
|
ppal->palNumEntries = (USHORT) cSysEntries;
|
|
|
|
if ( hpalSurf = CreatePalette(ppal) )
|
|
{
|
|
// Translate each logical palette entry into a surface palette index.
|
|
|
|
lppeTmp = lppe;
|
|
lppeEnd = lppe + cEntries;
|
|
|
|
for ( ; lppeTmp < lppeEnd; lppeTmp++, pajVector++)
|
|
{
|
|
*pajVector = (BYTE) GetNearestPaletteIndex(
|
|
hpalSurf,
|
|
RGB(lppeTmp->peRed,
|
|
lppeTmp->peGreen,
|
|
lppeTmp->peBlue)
|
|
);
|
|
|
|
ASSERTOPENGL(
|
|
*pajVector != CLR_INVALID,
|
|
"bComputeLogicalToSurfaceMap: GetNearestPaletteIndex failed\n"
|
|
);
|
|
}
|
|
|
|
bRet = TRUE;
|
|
|
|
DeleteObject(hpalSurf);
|
|
}
|
|
else
|
|
{
|
|
WARNING("bComputeLogicalToSurfaceMap: CreatePalette failed\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WARNING("bComputeLogicalToSurfaceMap: failed to get pal info\n");
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglCopyTranslateVector
|
|
*
|
|
* Create a logical palette index to system palette index translation
|
|
* vector.
|
|
*
|
|
* This is done by first reading both the logical palette and system palette
|
|
* entries. A temporary palette is created from the read system palette
|
|
* entries. This will be passed to GetNearestPaletteIndex to translate
|
|
* each logical palette entry into the desired system palette entry.
|
|
*
|
|
* Note: when GetNearestColor was called instead, very unstable results
|
|
* were obtained. GetNearestPaletteIndex is definitely the right way to go.
|
|
*
|
|
* Returns:
|
|
* TRUE if successful, FALSE otherwise.
|
|
*
|
|
* History:
|
|
* 25-Oct-1994 -by- Gilman Wong [gilmanw]
|
|
* Ported from gdi\gre\wglsup.cxx.
|
|
\**************************************************************************/
|
|
|
|
static GLubyte vubRGBtoVGA[8] = {
|
|
0x0,
|
|
0x9,
|
|
0xa,
|
|
0xb,
|
|
0xc,
|
|
0xd,
|
|
0xe,
|
|
0xf
|
|
};
|
|
|
|
BOOL APIENTRY wglCopyTranslateVector(__GLGENcontext *gengc, BYTE *pajVector,
|
|
ULONG cEntries)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
ULONG i;
|
|
HDC hdc;
|
|
|
|
CHECKSCREENLOCKOUT();
|
|
|
|
if (gengc->dwCurrentFlags & GLSURF_DIRECTDRAW)
|
|
{
|
|
// DirectDraw palettes are set directly into the hardware so
|
|
// the translation vector is always identity
|
|
for (i = 0; i < cEntries; i++)
|
|
{
|
|
*pajVector++ = (BYTE)i;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
hdc = gengc->gwidCurrent.hdc;
|
|
|
|
if (GLSURF_IS_MEMDC(gengc->dwCurrentFlags))
|
|
{
|
|
HBITMAP hbm, hbmSave;
|
|
|
|
// Technically this assert is invalid
|
|
// because we can't be sure that cEntries will be one
|
|
// of these two cases. To fix this we'd have to add
|
|
// another parameter to this function indicating the
|
|
// bit depth desired and go by that.
|
|
ASSERTOPENGL(cEntries == 16 || cEntries == 256,
|
|
"wglCopyTranslateVector: Unknown cEntries\n");
|
|
|
|
if (gengc->dwCurrentFlags & GLSURF_DIRECT_ACCESS)
|
|
{
|
|
// For compatibility, do not do this if the stock palette is
|
|
// selected. The old behavior assumed that the logical palette
|
|
// can be ignored because the bitmap will have a color table
|
|
// that exactly corresponds to the format specified by the
|
|
// pixelformat. Thus, if no palette is selected into the memdc,
|
|
// OpenGL would still render properly since it assumed 1-to-1.
|
|
//
|
|
// However, to enable using optimized DIB sections (i.e., DIBs
|
|
// whose color tables match the system palette exactly), we need
|
|
// to be able to specify the logical palette in the memdc.
|
|
//
|
|
// Therefore the hack is to assume 1-to-1 iff the stock
|
|
// palette is selected into the memdc. Otherwise, we will
|
|
// compute the logical to surface mapping.
|
|
|
|
if ( gengc->gc.modes.rgbMode &&
|
|
(GetCurrentObject(hdc, OBJ_PAL) !=
|
|
GetStockObject(DEFAULT_PALETTE)) )
|
|
{
|
|
// If an RGB DIB section, compute a mapping from logical
|
|
// palette to surface (DIB color table).
|
|
|
|
bRet = bComputeLogicalToSurfaceMap(
|
|
GetCurrentObject(hdc, OBJ_PAL),
|
|
hdc,
|
|
pajVector
|
|
);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
// 4bpp has a fixed color table so we can just copy the standard
|
|
// translation into the output vector.
|
|
|
|
if (cEntries == 16)
|
|
{
|
|
// For RGB mode, 4bpp uses a 1-1-1 format. We want to utilize
|
|
// bright versions which exist in the upper 8 entries.
|
|
|
|
if ( gengc->gc.modes.rgbMode )
|
|
{
|
|
memcpy(pajVector, vubRGBtoVGA, 8);
|
|
|
|
// Set the other mappings to white to make problems show up
|
|
memset(pajVector+8, 15, 8);
|
|
|
|
bRet = TRUE;
|
|
}
|
|
|
|
// For CI mode, just return FALSE and use the trivial vector.
|
|
|
|
return bRet;
|
|
}
|
|
|
|
// For bitmaps, we can determine the forward translation vector by
|
|
// filling a compatible bitmap with palette index specifiers from
|
|
// 1 to 255 and reading the bits back with GetBitmapBits.
|
|
|
|
hbm = CreateCompatibleBitmap(hdc, cEntries, 1);
|
|
if (hbm)
|
|
{
|
|
LONG cBytes;
|
|
|
|
hbmSave = SelectObject(hdc, hbm);
|
|
RealizePalette(hdc);
|
|
|
|
for (i = 0; i < cEntries; i++)
|
|
SetPixel(hdc, i, 0, PALETTEINDEX(i));
|
|
|
|
cBytes = 256;
|
|
|
|
if ( GetBitmapBits(hbm, cBytes, (LPVOID) pajVector) >= cBytes )
|
|
bRet = TRUE;
|
|
#if DBG
|
|
else
|
|
WARNING("wglCopyTranslateVector: GetBitmapBits failed\n");
|
|
#endif
|
|
|
|
SelectObject(hdc, hbmSave);
|
|
DeleteObject(hbm);
|
|
RealizePalette(hdc);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
// Determine number of colors in logical and system palettes, respectively.
|
|
|
|
cEntries = min(GetPaletteEntries(GetCurrentObject(hdc, OBJ_PAL),
|
|
0, cEntries, NULL),
|
|
cEntries);
|
|
|
|
if (cEntries == 16)
|
|
{
|
|
// For 16-color displays we are using RGB 1-1-1 since the
|
|
// full 16-color palette doesn't make for very good mappings
|
|
// Since we're only using the first eight of the colors we
|
|
// want to map them to the bright colors in the VGA palette
|
|
// rather than having them map to the dark colors as they would
|
|
// if we ran the loop below
|
|
|
|
if ( gengc->gc.modes.rgbMode )
|
|
{
|
|
memcpy(pajVector, vubRGBtoVGA, 8);
|
|
|
|
// Set the other mappings to white to make problems show up
|
|
memset(pajVector+8, 15, 8);
|
|
|
|
bRet = TRUE;
|
|
}
|
|
|
|
// For CI mode, return FALSE and use the trivial translation vector.
|
|
|
|
return bRet;
|
|
}
|
|
|
|
// Compute logical to surface palette mapping.
|
|
|
|
bRet = bComputeLogicalToSurfaceMap(GetCurrentObject(hdc, OBJ_PAL), hdc,
|
|
pajVector);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglCopyBits
|
|
*
|
|
* Calls DrvCopyBits to copy scanline bits into or out of the driver surface.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID APIENTRY wglCopyBits(
|
|
__GLGENcontext *gengc,
|
|
GLGENwindow *pwnd,
|
|
HBITMAP hbm, // ignore
|
|
LONG x, // screen coordinate of scan
|
|
LONG y,
|
|
ULONG cx, // width of scan
|
|
BOOL bIn) // if TRUE, copy from bm to dev; otherwise, dev to bm
|
|
{
|
|
CHECKSCREENLOCKOUT();
|
|
|
|
// Convert screen coordinates to window coordinates.
|
|
|
|
x -= pwnd->rclClient.left;
|
|
y -= pwnd->rclClient.top;
|
|
|
|
// this shouldn't happen, but better safe than sorry
|
|
|
|
if (y < 0)
|
|
return;
|
|
|
|
//!!!XXX
|
|
REALIZEPALETTE(gengc->gwidCurrent.hdc);
|
|
|
|
// Copy from bitmap to device.
|
|
|
|
if (bIn)
|
|
{
|
|
LONG xSrc, x0Dst, x1Dst;
|
|
if (x < 0)
|
|
{
|
|
xSrc = -x;
|
|
x0Dst = 0;
|
|
x1Dst = x + (LONG)cx;
|
|
}
|
|
else
|
|
{
|
|
xSrc = 0;
|
|
x0Dst = x;
|
|
x1Dst = x + (LONG)cx;
|
|
}
|
|
if (x1Dst <= x0Dst)
|
|
return;
|
|
|
|
BitBlt(gengc->gwidCurrent.hdc, x0Dst, y, cx, 1,
|
|
gengc->ColorsMemDC, xSrc, 0, SRCCOPY);
|
|
}
|
|
|
|
// Copy from device to bitmap.
|
|
|
|
else
|
|
{
|
|
LONG xSrc, x0Dst, x1Dst;
|
|
|
|
if (x < 0)
|
|
{
|
|
xSrc = 0;
|
|
x0Dst = -x;
|
|
x1Dst = (LONG)cx;
|
|
}
|
|
else
|
|
{
|
|
xSrc = x;
|
|
x0Dst = 0;
|
|
x1Dst = (LONG)cx;
|
|
}
|
|
if (x1Dst <= x0Dst)
|
|
return;
|
|
|
|
if (dwPlatformId == VER_PLATFORM_WIN32_NT ||
|
|
GLSURF_IS_MEMDC(gengc->dwCurrentFlags))
|
|
{
|
|
BitBlt(gengc->ColorsMemDC, x0Dst, 0, cx, 1,
|
|
gengc->gwidCurrent.hdc, xSrc, y, SRCCOPY);
|
|
}
|
|
else
|
|
{
|
|
/* If we're copying from the screen,
|
|
copy through a DDB to avoid some layers of unnecessary
|
|
code in Win95 that deals with translating between
|
|
different bitmap layouts */
|
|
if (gengc->ColorsDdbDc)
|
|
{
|
|
BitBlt(gengc->ColorsDdbDc, 0, 0, cx, 1,
|
|
gengc->gwidCurrent.hdc, xSrc, y, SRCCOPY);
|
|
|
|
BitBlt(gengc->ColorsMemDC, x0Dst, 0, cx, 1,
|
|
gengc->ColorsDdbDc, 0, 0, SRCCOPY);
|
|
}
|
|
else
|
|
{
|
|
//!!!Viper fix -- Diamond Viper (Weitek 9000) fails
|
|
//!!! CreateCompatibleBitmap for some
|
|
//!!! (currently unknown) reason. Thus,
|
|
//!!! the DDB does not exist and we will
|
|
//!!! have to incur the perf. hit.
|
|
|
|
BitBlt(gengc->ColorsMemDC, x0Dst, 0, cx, 1,
|
|
gengc->gwidCurrent.hdc, xSrc, y, SRCCOPY);
|
|
}
|
|
}
|
|
}
|
|
|
|
GDIFLUSH;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglCopyBits2
|
|
*
|
|
* Calls DrvCopyBits to copy scanline bits into or out of the driver surface.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID APIENTRY wglCopyBits2(
|
|
HDC hdc, // dst/src device
|
|
GLGENwindow *pwnd, // clipping
|
|
__GLGENcontext *gengc,
|
|
LONG x, // screen coordinate of scan
|
|
LONG y,
|
|
ULONG cx, // width of scan
|
|
BOOL bIn) // if TRUE, copy from bm to dev; otherwise, dev to bm
|
|
{
|
|
CHECKSCREENLOCKOUT();
|
|
|
|
// Convert screen coordinates to window coordinates.
|
|
|
|
x -= pwnd->rclClient.left;
|
|
y -= pwnd->rclClient.top;
|
|
|
|
// this shouldn't happen, but better safe than sorry
|
|
|
|
if (y < 0)
|
|
return;
|
|
|
|
//!!!XXX
|
|
REALIZEPALETTE(hdc);
|
|
|
|
// Copy from bitmap to device.
|
|
|
|
if (bIn)
|
|
{
|
|
LONG xSrc, x0Dst, x1Dst;
|
|
if (x < 0)
|
|
{
|
|
xSrc = -x;
|
|
x0Dst = 0;
|
|
x1Dst = x + (LONG)cx;
|
|
}
|
|
else
|
|
{
|
|
xSrc = 0;
|
|
x0Dst = x;
|
|
x1Dst = x + (LONG)cx;
|
|
}
|
|
if (x1Dst <= x0Dst)
|
|
return;
|
|
|
|
BitBlt(hdc, x0Dst, y, cx, 1,
|
|
gengc->ColorsMemDC, xSrc, 0, SRCCOPY);
|
|
}
|
|
|
|
// Copy from device to bitmap.
|
|
|
|
else
|
|
{
|
|
LONG xSrc, x0Dst, x1Dst;
|
|
|
|
if (x < 0)
|
|
{
|
|
xSrc = 0;
|
|
x0Dst = -x;
|
|
x1Dst = (LONG)cx;
|
|
}
|
|
else
|
|
{
|
|
xSrc = x;
|
|
x0Dst = 0;
|
|
x1Dst = (LONG)cx;
|
|
}
|
|
if (x1Dst <= x0Dst)
|
|
return;
|
|
|
|
if (dwPlatformId == VER_PLATFORM_WIN32_NT ||
|
|
GLSURF_IS_MEMDC(gengc->dwCurrentFlags))
|
|
{
|
|
BitBlt(gengc->ColorsMemDC, x0Dst, 0, cx, 1,
|
|
hdc, xSrc, y, SRCCOPY);
|
|
}
|
|
else
|
|
{
|
|
/* If we're copying from the screen,
|
|
copy through a DDB to avoid some layers of unnecessary
|
|
code in Win95 that deals with translating between
|
|
different bitmap layouts */
|
|
if (gengc->ColorsDdbDc)
|
|
{
|
|
BitBlt(gengc->ColorsDdbDc, 0, 0, cx, 1,
|
|
hdc, xSrc, y, SRCCOPY);
|
|
BitBlt(gengc->ColorsMemDC, x0Dst, 0, cx, 1,
|
|
gengc->ColorsDdbDc, 0, 0, SRCCOPY);
|
|
}
|
|
else
|
|
{
|
|
//!!!Viper fix -- Diamond Viper (Weitek 9000) fails
|
|
//!!! CreateCompatibleBitmap for some
|
|
//!!! (currently unknown) reason. Thus,
|
|
//!!! the DDB does not exist and we will
|
|
//!!! have to incur the perf. hit.
|
|
|
|
BitBlt(gengc->ColorsMemDC, x0Dst, 0, cx, 1,
|
|
hdc, xSrc, y, SRCCOPY);
|
|
}
|
|
}
|
|
}
|
|
|
|
GDIFLUSH;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
*
|
|
* wglTranslateColor
|
|
*
|
|
* Transforms a GL logical color into a Windows COLORREF
|
|
*
|
|
* Note: This is relatively expensive so it should be avoided if possible
|
|
*
|
|
* History:
|
|
* Tue Aug 15 15:23:29 1995 -by- Drew Bliss [drewb]
|
|
* Created
|
|
*
|
|
\**************************************************************************/
|
|
|
|
COLORREF wglTranslateColor(COLORREF crColor,
|
|
HDC hdc,
|
|
__GLGENcontext *gengc,
|
|
PIXELFORMATDESCRIPTOR *ppfd)
|
|
{
|
|
//!!!XXX
|
|
REALIZEPALETTE(hdc);
|
|
|
|
// If palette managed, then crColor is actually a palette index.
|
|
|
|
if ( ppfd->cColorBits <= 8 )
|
|
{
|
|
PALETTEENTRY peTmp;
|
|
|
|
ASSERTOPENGL(
|
|
crColor < (COLORREF) (1 << ppfd->cColorBits),
|
|
"TranslateColor(): bad color\n"
|
|
);
|
|
|
|
// If rendering to a bitmap, we need to do different things depending
|
|
// on whether it's a DIB or DDB
|
|
|
|
if ( gengc->gc.drawBuffer->buf.flags & MEMORY_DC )
|
|
{
|
|
DIBSECTION ds;
|
|
|
|
// Check whether we're drawing to a DIB or a DDB
|
|
if (GetObject(GetCurrentObject(hdc, OBJ_BITMAP),
|
|
sizeof(ds), &ds) == sizeof(ds) && ds.dsBm.bmBits)
|
|
{
|
|
RGBQUAD rgbq;
|
|
|
|
// Drawing to a DIB so retrieve the color from the
|
|
// DIB color table
|
|
if (GetDIBColorTable(hdc, crColor, 1, &rgbq))
|
|
{
|
|
crColor = RGB(rgbq.rgbRed, rgbq.rgbGreen,
|
|
rgbq.rgbBlue);
|
|
}
|
|
else
|
|
{
|
|
WARNING("TranslateColor(): GetDIBColorTable failed\n");
|
|
crColor = RGB(0, 0, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Reverse the forward translation so that we get back
|
|
// to a normal palette index
|
|
crColor = gengc->pajInvTranslateVector[crColor];
|
|
|
|
// Drawing to a DDB so we can just use the palette
|
|
// index directly since going through the inverse
|
|
// translation table has given us an index into
|
|
// the logical palette
|
|
crColor = PALETTEINDEX((WORD) crColor);
|
|
}
|
|
}
|
|
|
|
// Otherwise...
|
|
|
|
else
|
|
{
|
|
// I hate to have to confess this, but I don't really understand
|
|
// why this needs to be this way. Either way should work regardless
|
|
// of the bit depth.
|
|
//
|
|
// The reality is that 4bpp we *have* to go into the system palette
|
|
// and fetch an RGB value. At 8bpp on the MGA driver (and possibly
|
|
// others), we *have* to specify PALETTEINDEX.
|
|
|
|
if ( ppfd->cColorBits == 4 )
|
|
{
|
|
if ( wglGetSystemPaletteEntries(hdc, crColor, 1, &peTmp) )
|
|
{
|
|
crColor = RGB(peTmp.peRed, peTmp.peGreen, peTmp.peBlue);
|
|
}
|
|
else
|
|
{
|
|
WARNING("TranslateColor(): wglGetSystemPaletteEntries failed\n");
|
|
crColor = RGB(0, 0, 0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!(gengc->flags & GENGC_MCD_BGR_INTO_RGB))
|
|
crColor = gengc->pajInvTranslateVector[crColor];
|
|
crColor = PALETTEINDEX((WORD) crColor);
|
|
}
|
|
}
|
|
}
|
|
|
|
// If 24BPP DIB section, BGR ordering is implied.
|
|
|
|
else if ( ppfd->cColorBits == 24 )
|
|
{
|
|
crColor = RGB((crColor & 0xff0000) >> 16,
|
|
(crColor & 0x00ff00) >> 8,
|
|
(crColor & 0x0000ff));
|
|
}
|
|
|
|
// Win95 and 16 BPP case.
|
|
//
|
|
// On Win95, additional munging is necessary to get a COLORREF value
|
|
// that will result in a non-dithered brush.
|
|
|
|
else if ( (dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) &&
|
|
(ppfd->cColorBits == 16) )
|
|
{
|
|
HBITMAP hbmTmp;
|
|
HDC hdcTmp;
|
|
|
|
if (hdcTmp = CreateCompatibleDC(hdc))
|
|
{
|
|
if (hbmTmp = CreateCompatibleBitmap(hdc, 1, 1))
|
|
{
|
|
HBITMAP hbmOld;
|
|
|
|
hbmOld = SelectObject(hdcTmp, hbmTmp);
|
|
|
|
if (SetBitmapBits(hbmTmp, 2, (VOID *) &crColor))
|
|
{
|
|
crColor = GetPixel(hdcTmp, 0, 0);
|
|
}
|
|
else
|
|
{
|
|
WARNING("TranslateColor(): SetBitmapBits failed\n");
|
|
}
|
|
|
|
SelectObject(hdcTmp, hbmOld);
|
|
DeleteObject(hbmTmp);
|
|
}
|
|
else
|
|
{
|
|
WARNING("TranslateColor(): CreateCompatibleBitmap failed\n");
|
|
}
|
|
|
|
DeleteDC(hdcTmp);
|
|
}
|
|
else
|
|
{
|
|
WARNING("TranslateColor(): CreateCompatibleDC failed\n");
|
|
}
|
|
}
|
|
|
|
// Bitfield format (16BPP or 32BPP).
|
|
|
|
else
|
|
{
|
|
// Shift right to position bits at zero and then scale into
|
|
// an 8-bit quantity
|
|
|
|
//!!!XXX -- use rounding?!?
|
|
crColor =
|
|
RGB(((crColor & gengc->gc.modes.redMask) >> ppfd->cRedShift) *
|
|
255 / ((1 << ppfd->cRedBits) - 1),
|
|
((crColor & gengc->gc.modes.greenMask) >> ppfd->cGreenShift) *
|
|
255 / ((1 << ppfd->cGreenBits) - 1),
|
|
((crColor & gengc->gc.modes.blueMask) >> ppfd->cBlueShift) *
|
|
255 / ((1 << ppfd->cBlueBits) - 1));
|
|
|
|
}
|
|
|
|
return crColor;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglFillRect
|
|
*
|
|
* Calls DrvBitBlt to fill a rectangle area of a driver surface with a
|
|
* given color.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID APIENTRY wglFillRect(
|
|
__GLGENcontext *gengc,
|
|
GLGENwindow *pwnd,
|
|
PRECTL prcl, // screen coordinate of the rectangle area
|
|
COLORREF crColor) // color to set
|
|
{
|
|
HBRUSH hbr;
|
|
PIXELFORMATDESCRIPTOR *ppfd = &gengc->gsurf.pfd;
|
|
|
|
CHECKSCREENLOCKOUT();
|
|
|
|
// If the rectangle is empty, return.
|
|
|
|
if ( (prcl->left >= prcl->right) || (prcl->top >= prcl->bottom) )
|
|
{
|
|
WARNING("wglFillRect(): bad or empty rectangle\n");
|
|
return;
|
|
}
|
|
|
|
// Convert from screen to window coordinates.
|
|
|
|
prcl->left -= pwnd->rclClient.left;
|
|
prcl->right -= pwnd->rclClient.left;
|
|
prcl->top -= pwnd->rclClient.top;
|
|
prcl->bottom -= pwnd->rclClient.top;
|
|
|
|
// Make a solid color brush and fill the rectangle.
|
|
|
|
// If the fill color is the same as the last one, we can reuse
|
|
// the cached brush rather than creating a new one
|
|
if (crColor == gengc->crFill &&
|
|
gengc->gwidCurrent.hdc == gengc->hdcFill)
|
|
{
|
|
hbr = gengc->hbrFill;
|
|
ASSERTOPENGL(hbr != NULL, "Cached fill brush is null\n");
|
|
}
|
|
else
|
|
{
|
|
if (gengc->hbrFill != NULL)
|
|
{
|
|
DeleteObject(gengc->hbrFill);
|
|
}
|
|
|
|
gengc->crFill = crColor;
|
|
|
|
crColor = wglTranslateColor(crColor, gengc->gwidCurrent.hdc, gengc, ppfd);
|
|
hbr = CreateSolidBrush(crColor);
|
|
gengc->hbrFill = hbr;
|
|
|
|
if (hbr == NULL)
|
|
{
|
|
gengc->crFill = COLORREF_UNUSED;
|
|
return;
|
|
}
|
|
|
|
gengc->hdcFill = gengc->gwidCurrent.hdc;
|
|
}
|
|
|
|
FillRect(gengc->gwidCurrent.hdc, (RECT *) prcl, hbr);
|
|
GDIFLUSH;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglCopyBuf
|
|
*
|
|
* Calls DrvCopyBits to copy a bitmap into the driver surface.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
//!!!XXX -- change to a macro
|
|
|
|
VOID APIENTRY wglCopyBuf(
|
|
HDC hdc, // dst/src DCOBJ
|
|
HDC hdcBmp, // scr/dst bitmap
|
|
LONG x, // dst rect (UL corner) in window coord.
|
|
LONG y,
|
|
ULONG cx, // width of dest rect
|
|
ULONG cy // height of dest rect
|
|
)
|
|
{
|
|
CHECKSCREENLOCKOUT();
|
|
|
|
//!!!XXX
|
|
REALIZEPALETTE(hdc);
|
|
|
|
if (!BitBlt(hdc, x, y, cx, cy, hdcBmp, 0, 0, SRCCOPY))
|
|
{
|
|
WARNING1("wglCopyBuf BitBlt failed %d\n", GetLastError());
|
|
}
|
|
|
|
GDIFLUSH;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglCopyBufRECTLIST
|
|
*
|
|
* Calls DrvCopyBits to copy a bitmap into the driver surface.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
VOID APIENTRY wglCopyBufRECTLIST(
|
|
HDC hdc, // dst/src DCOBJ
|
|
HDC hdcBmp, // scr/dst bitmap
|
|
LONG x, // dst rect (UL corner) in window coord.
|
|
LONG y,
|
|
ULONG cx, // width of dest rect
|
|
ULONG cy, // height of dest rect
|
|
PRECTLIST prl
|
|
)
|
|
{
|
|
PYLIST pylist;
|
|
|
|
CHECKSCREENLOCKOUT();
|
|
|
|
//!!!XXX
|
|
REALIZEPALETTE(hdc);
|
|
|
|
for (pylist = prl->pylist; pylist != NULL; pylist = pylist->pnext)
|
|
{
|
|
PXLIST pxlist;
|
|
|
|
for (pxlist = pylist->pxlist; pxlist != NULL; pxlist = pxlist->pnext)
|
|
{
|
|
int xx = pxlist->s;
|
|
int cxx = pxlist->e - pxlist->s;
|
|
int yy = pylist->s;
|
|
int cyy = pylist->e - pylist->s;
|
|
|
|
if (!BitBlt(hdc, xx, yy, cxx, cyy, hdcBmp, xx, yy, SRCCOPY))
|
|
{
|
|
WARNING1("wglCopyBufRL BitBlt failed %d\n", GetLastError());
|
|
}
|
|
}
|
|
}
|
|
|
|
GDIFLUSH;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglPaletteChanged
|
|
*
|
|
* Check if the palette changed.
|
|
*
|
|
* If the surface for the DC is palette managed we care about the
|
|
* foreground realization, so, return iUniq
|
|
*
|
|
* If the surface is not palette managed, return ulTime
|
|
*
|
|
\**************************************************************************/
|
|
|
|
ULONG APIENTRY wglPaletteChanged(__GLGENcontext *gengc,
|
|
GLGENwindow *pwnd)
|
|
{
|
|
ULONG ulRet = 0;
|
|
HDC hdc;
|
|
|
|
// Palette must stay fixed for DirectDraw after initialization
|
|
if (gengc->dwCurrentFlags & GLSURF_DIRECTDRAW)
|
|
{
|
|
if (gengc->PaletteTimestamp == 0xffffffff)
|
|
{
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return gengc->PaletteTimestamp;
|
|
}
|
|
}
|
|
|
|
hdc = gengc->gwidCurrent.hdc;
|
|
|
|
// Technically we shouldn't be making these GDI calls while we
|
|
// have a screen lock but currently it would be very difficult
|
|
// to fix because we're actually invoking this routine in
|
|
// glsrvGrabLock in order to ensure that we have stable information
|
|
// while we have the lock
|
|
// We don't seem to be having too many problems so for the moment
|
|
// this will be commented out
|
|
// CHECKSCREENLOCKOUT();
|
|
|
|
if (pwnd)
|
|
{
|
|
PIXELFORMATDESCRIPTOR *ppfd = &gengc->gsurf.pfd;
|
|
BYTE cBitsThreshold;
|
|
|
|
// WM_PALETTECHANGED messages are sent for 8bpp on Win95 when the
|
|
// palette is realized. This allows us to update the palette time.
|
|
//
|
|
// When running WinNT on >= 8bpp or running Win95 on >= 16bpp,
|
|
// WM_PALETTECHANGED is not sent so we need to manually examine
|
|
// the contents of the logical palette and compare it with a previously
|
|
// cached copy to look for a palette change.
|
|
|
|
cBitsThreshold = ( dwPlatformId == VER_PLATFORM_WIN32_NT ) ? 8 : 16;
|
|
|
|
if (((ppfd->cColorBits >= cBitsThreshold) &&
|
|
(ppfd->iPixelType == PFD_TYPE_COLORINDEX)) )
|
|
{
|
|
if ( !gengc->ppalBuf )
|
|
{
|
|
UINT cjPal, cjRgb;
|
|
|
|
// Allocate buffer space for *two* copies of the palette.
|
|
// That way we don't need to dynamically allocate space
|
|
// for temp storage of the palette. Also,we don't need
|
|
// to copy the current palette to the save buffer if we
|
|
// keep two pointers (one for the temp storage and one for
|
|
// the saved copy) and swap them.
|
|
|
|
cjRgb = 0;
|
|
cjPal = sizeof(LOGPALETTE) +
|
|
(MAXPALENTRIES * sizeof(PALETTEENTRY));
|
|
|
|
gengc->ppalBuf = (LOGPALETTE *)
|
|
ALLOC((cjPal + cjRgb) * 2);
|
|
|
|
if ( gengc->ppalBuf )
|
|
{
|
|
// Setup the logical palette buffers.
|
|
|
|
gengc->ppalSave = gengc->ppalBuf;
|
|
gengc->ppalTemp = (LOGPALETTE *)
|
|
(((BYTE *) gengc->ppalBuf) + cjPal);
|
|
gengc->ppalSave->palVersion = 0x300;
|
|
gengc->ppalTemp->palVersion = 0x300;
|
|
|
|
// How many palette entries? Note that only the first
|
|
// MAXPALENTRIES are significant to generic OpenGL. The
|
|
// rest are ignored.
|
|
|
|
gengc->ppalSave->palNumEntries =
|
|
(WORD) GetPaletteEntries(
|
|
GetCurrentObject(hdc, OBJ_PAL),
|
|
0, 0, (LPPALETTEENTRY) NULL
|
|
);
|
|
gengc->ppalSave->palNumEntries =
|
|
min(gengc->ppalSave->palNumEntries, MAXPALENTRIES);
|
|
|
|
gengc->ppalSave->palNumEntries =
|
|
(WORD) GetPaletteEntries(
|
|
GetCurrentObject(hdc, OBJ_PAL),
|
|
0, gengc->ppalSave->palNumEntries,
|
|
gengc->ppalSave->palPalEntry
|
|
);
|
|
|
|
// Since we had to allocate buffer, this must be the
|
|
// first time wglPaletteChanged was called for this
|
|
// context.
|
|
|
|
pwnd->ulPaletteUniq++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BOOL bNewPal = FALSE; // TRUE if log palette is different
|
|
|
|
// How many palette entries? Note that only the first
|
|
// MAXPALENTRIES are significant to generic OpenGL. The
|
|
// rest are ignored.
|
|
|
|
gengc->ppalTemp->palNumEntries =
|
|
(WORD) GetPaletteEntries(
|
|
GetCurrentObject(hdc, OBJ_PAL),
|
|
0, 0, (LPPALETTEENTRY) NULL
|
|
);
|
|
gengc->ppalTemp->palNumEntries =
|
|
min(gengc->ppalTemp->palNumEntries, MAXPALENTRIES);
|
|
|
|
gengc->ppalTemp->palNumEntries =
|
|
(WORD) GetPaletteEntries(
|
|
GetCurrentObject(hdc, OBJ_PAL),
|
|
0, gengc->ppalTemp->palNumEntries,
|
|
gengc->ppalTemp->palPalEntry
|
|
);
|
|
|
|
// If number of entries differ, know the palette has changed.
|
|
// Otherwise, need to do the hard word of comparing each entry.
|
|
|
|
ASSERTOPENGL(
|
|
sizeof(PALETTEENTRY) == sizeof(ULONG),
|
|
"wglPaletteChanged(): PALETTEENTRY should be 4 bytes\n"
|
|
);
|
|
|
|
// If color table comparison already detected a change, no
|
|
// need to do logpal comparison.
|
|
//
|
|
// However, we will still go ahead and swap logpal pointers
|
|
// below because we want the palette cache to stay current.
|
|
|
|
if ( !bNewPal )
|
|
{
|
|
bNewPal = (gengc->ppalSave->palNumEntries != gengc->ppalTemp->palNumEntries);
|
|
if ( !bNewPal )
|
|
{
|
|
bNewPal = !LocalCompareUlongMemory(
|
|
gengc->ppalSave->palPalEntry,
|
|
gengc->ppalTemp->palPalEntry,
|
|
gengc->ppalSave->palNumEntries * sizeof(PALETTEENTRY)
|
|
);
|
|
}
|
|
}
|
|
|
|
// So, if palette is different, increment uniqueness and
|
|
// update the saved copy.
|
|
|
|
if ( bNewPal )
|
|
{
|
|
LOGPALETTE *ppal;
|
|
|
|
pwnd->ulPaletteUniq++;
|
|
|
|
// Update saved palette by swapping pointers.
|
|
|
|
ppal = gengc->ppalSave;
|
|
gengc->ppalSave = gengc->ppalTemp;
|
|
gengc->ppalTemp = ppal;
|
|
}
|
|
}
|
|
}
|
|
|
|
ulRet = pwnd->ulPaletteUniq;
|
|
}
|
|
|
|
return ulRet;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglPaletteSize
|
|
*
|
|
* Return the size of the current palette
|
|
*
|
|
\**************************************************************************/
|
|
|
|
//!!!XXX -- make into a macro?
|
|
ULONG APIENTRY wglPaletteSize(__GLGENcontext *gengc)
|
|
{
|
|
CHECKSCREENLOCKOUT();
|
|
|
|
if (gengc->dwCurrentFlags & GLSURF_DIRECTDRAW)
|
|
{
|
|
DWORD dwCaps;
|
|
LPDIRECTDRAWPALETTE pddp = NULL;
|
|
HRESULT hr;
|
|
|
|
if (gengc->gsurf.dd.gddsFront.pdds->lpVtbl->
|
|
GetPalette(gengc->gsurf.dd.gddsFront.pdds, &pddp) != DD_OK ||
|
|
pddp == NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
hr = pddp->lpVtbl->GetCaps(pddp, &dwCaps);
|
|
|
|
pddp->lpVtbl->Release(pddp);
|
|
|
|
if (hr != DD_OK)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (dwCaps & DDPCAPS_1BIT)
|
|
{
|
|
return 1;
|
|
}
|
|
else if (dwCaps & DDPCAPS_2BIT)
|
|
{
|
|
return 4;
|
|
}
|
|
else if (dwCaps & DDPCAPS_4BIT)
|
|
{
|
|
return 16;
|
|
}
|
|
else if (dwCaps & DDPCAPS_8BIT)
|
|
{
|
|
return 256;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
return GetPaletteEntries(GetCurrentObject(gengc->gwidCurrent.hdc,
|
|
OBJ_PAL), 0, 0, NULL);
|
|
}
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglComputeIndexedColors
|
|
*
|
|
* Copy current index-to-color table to the supplied array. Colors are
|
|
* formatted as specified in the current pixelformat and are put into the
|
|
* table as DWORDs (i.e., DWORD alignment) starting at the second DWORD.
|
|
* The first DWORD in the table is the number of colors in the table.
|
|
*
|
|
* History:
|
|
* 15-Dec-1994 -by- Gilman Wong [gilmanw]
|
|
* Ported from gdi\gre\wglsup.cxx.
|
|
\**************************************************************************/
|
|
|
|
BOOL APIENTRY wglComputeIndexedColors(__GLGENcontext *gengc, ULONG *rgbTable,
|
|
ULONG cEntries)
|
|
{
|
|
UINT cColors = 0;
|
|
LPPALETTEENTRY lppe, lppeTable;
|
|
UINT i;
|
|
LPDIRECTDRAWPALETTE pddp = NULL;
|
|
|
|
CHECKSCREENLOCKOUT();
|
|
|
|
// first element in table is number of entries
|
|
rgbTable[0] = min(wglPaletteSize(gengc), cEntries);
|
|
|
|
lppeTable = (LPPALETTEENTRY)
|
|
ALLOC(sizeof(PALETTEENTRY) * rgbTable[0]);
|
|
|
|
if (lppeTable)
|
|
{
|
|
int rScale, gScale, bScale;
|
|
int rShift, gShift, bShift;
|
|
|
|
rScale = (1 << gengc->gsurf.pfd.cRedBits ) - 1;
|
|
gScale = (1 << gengc->gsurf.pfd.cGreenBits) - 1;
|
|
bScale = (1 << gengc->gsurf.pfd.cBlueBits ) - 1;
|
|
rShift = gengc->gsurf.pfd.cRedShift ;
|
|
gShift = gengc->gsurf.pfd.cGreenShift;
|
|
bShift = gengc->gsurf.pfd.cBlueShift ;
|
|
|
|
if (gengc->dwCurrentFlags & GLSURF_DIRECTDRAW)
|
|
{
|
|
if (gengc->gsurf.dd.gddsFront.pdds->lpVtbl->
|
|
GetPalette(gengc->gsurf.dd.gddsFront.pdds, &pddp) != DD_OK ||
|
|
pddp == NULL)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
if (pddp->lpVtbl->GetEntries(pddp, 0, 0,
|
|
rgbTable[0], lppeTable) != DD_OK)
|
|
{
|
|
cColors = 0;
|
|
}
|
|
else
|
|
{
|
|
cColors = rgbTable[0];
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cColors = GetPaletteEntries(GetCurrentObject(gengc->gwidCurrent.hdc,
|
|
OBJ_PAL),
|
|
0, rgbTable[0], lppeTable);
|
|
}
|
|
|
|
for (i = 1, lppe = lppeTable; i <= cColors; i++, lppe++)
|
|
{
|
|
// Whack the PALETTEENTRY color into proper color format. Store as
|
|
// ULONG.
|
|
|
|
//!!!XXX -- use rounding?!?
|
|
rgbTable[i] = (((ULONG)lppe->peRed * rScale / 255) << rShift) |
|
|
(((ULONG)lppe->peGreen * gScale / 255) << gShift) |
|
|
(((ULONG)lppe->peBlue * bScale / 255) << bShift);
|
|
}
|
|
|
|
FREE(lppeTable);
|
|
}
|
|
|
|
if (pddp != NULL)
|
|
{
|
|
pddp->lpVtbl->Release(pddp);
|
|
}
|
|
|
|
return(cColors != 0);
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglValidPixelFormat
|
|
*
|
|
* Determines if a pixelformat is usable with the DC specified.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
BOOL APIENTRY wglValidPixelFormat(HDC hdc, int ipfd, DWORD dwObjectType,
|
|
LPDIRECTDRAWSURFACE pdds,
|
|
DDSURFACEDESC *pddsd)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
PIXELFORMATDESCRIPTOR pfd, pfdDC;
|
|
|
|
if ( wglDescribePixelFormat(hdc, ipfd, sizeof(pfd), &pfd) )
|
|
{
|
|
if ( dwObjectType == OBJ_DC )
|
|
{
|
|
// We have a display DC; make sure the pixelformat allows drawing
|
|
// to the window.
|
|
|
|
bRet = ( (pfd.dwFlags & PFD_DRAW_TO_WINDOW) != 0 );
|
|
if (!bRet)
|
|
{
|
|
SetLastError(ERROR_INVALID_FLAGS);
|
|
}
|
|
}
|
|
else if ( dwObjectType == OBJ_MEMDC )
|
|
{
|
|
// We have a memory DC. Make sure pixelformat allows drawing
|
|
// to a bitmap.
|
|
|
|
if ( pfd.dwFlags & PFD_DRAW_TO_BITMAP )
|
|
{
|
|
// Make sure that the bitmap and pixelformat have the same
|
|
// color depth.
|
|
|
|
HBITMAP hbm;
|
|
BITMAP bm;
|
|
ULONG cBitmapColorBits;
|
|
|
|
hbm = CreateCompatibleBitmap(hdc, 1, 1);
|
|
if ( hbm )
|
|
{
|
|
if ( GetObject(hbm, sizeof(bm), &bm) )
|
|
{
|
|
cBitmapColorBits = bm.bmPlanes * bm.bmBitsPixel;
|
|
|
|
bRet = ( cBitmapColorBits == pfd.cColorBits );
|
|
if (!bRet)
|
|
{
|
|
SetLastError(ERROR_INVALID_FUNCTION);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WARNING("wglValidPixelFormat: GetObject failed\n");
|
|
}
|
|
|
|
DeleteObject(hbm);
|
|
}
|
|
else
|
|
{
|
|
WARNING("wglValidPixelFormat: Unable to create cbm\n");
|
|
}
|
|
}
|
|
}
|
|
else if (dwObjectType == OBJ_ENHMETADC)
|
|
{
|
|
// We don't know anything about what surfaces this
|
|
// metafile will be played back on so allow any kind
|
|
// of pixel format
|
|
bRet = TRUE;
|
|
}
|
|
else if (dwObjectType == OBJ_DDRAW)
|
|
{
|
|
DDSCAPS ddscaps;
|
|
LPDIRECTDRAWSURFACE pddsZ;
|
|
DDSURFACEDESC ddsdZ;
|
|
|
|
// We have a DDraw surface.
|
|
|
|
// Check that DDraw is supported and that double buffering
|
|
// is not defined.
|
|
if ((pfd.dwFlags & PFD_SUPPORT_DIRECTDRAW) == 0 ||
|
|
(pfd.dwFlags & PFD_DOUBLEBUFFER))
|
|
{
|
|
WARNING1("DDSurf pfd has bad flags 0x%08lX\n", pfd.dwFlags);
|
|
SetLastError(ERROR_INVALID_FLAGS);
|
|
return FALSE;
|
|
}
|
|
|
|
// We only understand 4 and 8bpp paletted formats plus RGB
|
|
// We don't support alpha-only or Z-only surfaces
|
|
if ((pddsd->ddpfPixelFormat.dwFlags & (DDPF_PALETTEINDEXED4 |
|
|
DDPF_PALETTEINDEXED8 |
|
|
DDPF_RGB)) == 0 ||
|
|
(pddsd->ddpfPixelFormat.dwFlags & (DDPF_ALPHA |
|
|
DDPF_ZBUFFER)) != 0)
|
|
{
|
|
WARNING1("DDSurf ddpf has bad flags, 0x%08lX\n",
|
|
pddsd->ddpfPixelFormat.dwFlags);
|
|
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
|
return FALSE;
|
|
}
|
|
|
|
if (DdPixelDepth(pddsd) != pfd.cColorBits)
|
|
{
|
|
WARNING2("DDSurf pfd cColorBits %d "
|
|
"doesn't match ddsd depth %d\n",
|
|
pfd.cColorBits, DdPixelDepth(pddsd));
|
|
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
|
return FALSE;
|
|
}
|
|
|
|
// Check for alpha
|
|
if (pfd.cAlphaBits > 0)
|
|
{
|
|
// Interleaved destination alpha is not supported.
|
|
if (pddsd->ddpfPixelFormat.dwFlags & DDPF_ALPHAPIXELS)
|
|
{
|
|
WARNING("DDSurf has alpha pixels\n");
|
|
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Check for an attached Z buffer
|
|
memset(&ddscaps, 0, sizeof(ddscaps));
|
|
ddscaps.dwCaps = DDSCAPS_ZBUFFER;
|
|
if (pdds->lpVtbl->
|
|
GetAttachedSurface(pdds, &ddscaps, &pddsZ) == DD_OK)
|
|
{
|
|
HRESULT hr;
|
|
|
|
memset(&ddsdZ, 0, sizeof(ddsdZ));
|
|
ddsdZ.dwSize = sizeof(ddsdZ);
|
|
|
|
hr = pddsZ->lpVtbl->GetSurfaceDesc(pddsZ, &ddsdZ);
|
|
|
|
pddsZ->lpVtbl->Release(pddsZ);
|
|
|
|
if (hr != DD_OK)
|
|
{
|
|
WARNING("Unable to get Z ddsd\n");
|
|
return FALSE;
|
|
}
|
|
|
|
// Ensure that the Z surface depth is the same as the
|
|
// one in the pixel format
|
|
if (pfd.cDepthBits !=
|
|
(BYTE)DdPixDepthToCount(ddsdZ.ddpfPixelFormat.
|
|
dwZBufferBitDepth))
|
|
{
|
|
WARNING2("DDSurf pfd cDepthBits %d doesn't match "
|
|
"Z ddsd depth %d\n", pfd.cDepthBits,
|
|
DdPixDepthToCount(ddsdZ.ddpfPixelFormat.
|
|
dwZBufferBitDepth));
|
|
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No Z so make sure the pfd doesn't ask for it
|
|
if (pfd.cDepthBits > 0)
|
|
{
|
|
WARNING("DDSurf pfd wants depth with no Z attached\n");
|
|
SetLastError(ERROR_INVALID_PIXEL_FORMAT);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
bRet = TRUE;
|
|
}
|
|
else
|
|
{
|
|
WARNING("wglValidPixelFormat: not a valid DC!\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WARNING("wglValidPixelFormat: wglDescribePixelFormat failed\n");
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglMakeScans
|
|
*
|
|
* Converts the visible rectangle list in the provided GLGENwindow to a
|
|
* scan-based data structure. The scan-data is put into the GLGENwindow
|
|
* structure.
|
|
*
|
|
* Note: this function assumes that the rectangles are already organized
|
|
* top-down, left-right in scans. This is true for Windows NT 3.5 and
|
|
* Windows 95. This is because the internal representation of regions
|
|
* in both systems is already a scan-based structure. When the APIs
|
|
* (such as GetRegionData) convert the scans to rectangles, the rectangles
|
|
* automatically have this property.
|
|
*
|
|
* Returns:
|
|
* TRUE if successful, FALSE otherwise.
|
|
* Note: if failure, clipping info is invalid.
|
|
*
|
|
* History:
|
|
* 05-Dec-1994 -by- Gilman Wong [gilmanw]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
BOOL APIENTRY wglMakeScans(GLGENwindow *pwnd)
|
|
{
|
|
RECT *prc, *prcEnd;
|
|
LONG lPrevScanTop;
|
|
ULONG cScans = 0;
|
|
UINT cjNeed;
|
|
GLGENscan *pscan;
|
|
LONG *plWalls;
|
|
|
|
ASSERTOPENGL(
|
|
pwnd->prgndat,
|
|
"wglMakeScans(): NULL region data\n"
|
|
);
|
|
|
|
ASSERTOPENGL(
|
|
pwnd->prgndat->rdh.iType == RDH_RECTANGLES,
|
|
"wglMakeScans(): not RDH_RECTANGLES!\n"
|
|
);
|
|
|
|
// Bail out if no rectangles.
|
|
|
|
if (pwnd->prgndat->rdh.nCount == 0)
|
|
return TRUE;
|
|
|
|
// First pass: determine the number of scans.
|
|
|
|
lPrevScanTop = -(LONG) 0x7FFFFFFF;
|
|
prc = (RECT *) pwnd->prgndat->Buffer;
|
|
prcEnd = prc + pwnd->prgndat->rdh.nCount;
|
|
|
|
for ( ; prc < prcEnd; prc++)
|
|
{
|
|
if (prc->top != lPrevScanTop)
|
|
{
|
|
lPrevScanTop = prc->top;
|
|
cScans++;
|
|
}
|
|
}
|
|
|
|
// Determine the size needed: 1 GLGENscanData PLUS a GLGENscan per scan PLUS
|
|
// two walls per rectangle.
|
|
|
|
cjNeed = offsetof(GLGENscanData, aScans) +
|
|
cScans * offsetof(GLGENscan, alWalls) +
|
|
pwnd->prgndat->rdh.nCount * sizeof(LONG) * 2;
|
|
|
|
// Allocate the scan structure.
|
|
|
|
if ( cjNeed > pwnd->cjscandat || !pwnd->pscandat )
|
|
{
|
|
if ( pwnd->pscandat )
|
|
FREE(pwnd->pscandat);
|
|
|
|
pwnd->pscandat = ALLOC(pwnd->cjscandat = cjNeed);
|
|
if ( !pwnd->pscandat )
|
|
{
|
|
WARNING("wglMakeScans(): memory failure\n");
|
|
pwnd->cjscandat = 0;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Second pass: fill the scan structure.
|
|
|
|
pwnd->pscandat->cScans = cScans;
|
|
|
|
lPrevScanTop = -(LONG) 0x7FFFFFFF;
|
|
prc = (RECT *) pwnd->prgndat->Buffer; // need to reset prc but prcEnd OK
|
|
plWalls = (LONG *) pwnd->pscandat->aScans;
|
|
pscan = (GLGENscan *) NULL;
|
|
|
|
for ( ; prc < prcEnd; prc++ )
|
|
{
|
|
// Do we need to start a new scan?
|
|
|
|
if ( prc->top != lPrevScanTop )
|
|
{
|
|
// Scan we just finished needs pointer to the next scan. Next
|
|
// will start just after this scan (which, conveniently enough,
|
|
// plWalls is pointing at).
|
|
|
|
if ( pscan )
|
|
pscan->pNext = (GLGENscan *) plWalls;
|
|
|
|
lPrevScanTop = prc->top;
|
|
|
|
// Start the new span.
|
|
|
|
pscan = (GLGENscan *) plWalls;
|
|
pscan->cWalls = 0;
|
|
pscan->top = prc->top;
|
|
pscan->bottom = prc->bottom;
|
|
plWalls = pscan->alWalls;
|
|
}
|
|
|
|
pscan->cWalls+=2;
|
|
*plWalls++ = prc->left;
|
|
*plWalls++ = prc->right;
|
|
}
|
|
|
|
if ( pscan )
|
|
pscan->pNext = (GLGENscan *) NULL; // don't leave ptr unitialized in
|
|
// the last scan
|
|
|
|
#if DBG
|
|
DBGLEVEL1(LEVEL_INFO, "\n-----\nwglMakeScans(): cScans = %ld\n", pwnd->pscandat->cScans);
|
|
|
|
cScans = pwnd->pscandat->cScans;
|
|
pscan = pwnd->pscandat->aScans;
|
|
|
|
for ( ; cScans; cScans--, pscan = pscan->pNext )
|
|
{
|
|
LONG *plWalls = pscan->alWalls;
|
|
LONG *plWallsEnd = plWalls + pscan->cWalls;
|
|
|
|
DBGLEVEL3(LEVEL_INFO, "Scan: top = %ld, bottom = %ld, walls = %ld\n", pscan->top, pscan->bottom, pscan->cWalls);
|
|
|
|
for ( ; plWalls < plWallsEnd; plWalls+=2 )
|
|
{
|
|
DBGLEVEL2(LEVEL_INFO, "\t%ld, %ld\n", plWalls[0], plWalls[1]);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglGetClipList
|
|
*
|
|
* Gets the visible region in the form of a list of rectangles,
|
|
* for the window associated with the given window. The data is placed
|
|
* in the GLGENwindow structure.
|
|
*
|
|
* Returns:
|
|
* TRUE if successful, FALSE otherwise.
|
|
*
|
|
* History:
|
|
* 01-Dec-1994 -by- Gilman Wong [gilmanw]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
BOOL APIENTRY wglGetClipList(GLGENwindow *pwnd)
|
|
{
|
|
UINT cj;
|
|
RECT rc;
|
|
|
|
// Set clipping to empty. If an error occurs getting clip information,
|
|
// all drawing will be clipped.
|
|
|
|
pwnd->clipComplexity = CLC_RECT;
|
|
pwnd->rclBounds.left = 0;
|
|
pwnd->rclBounds.top = 0;
|
|
pwnd->rclBounds.right = 0;
|
|
pwnd->rclBounds.bottom = 0;
|
|
|
|
// Make sure we have enough memory to cache the clip list.
|
|
|
|
if (pwnd->pddClip->lpVtbl->
|
|
GetClipList(pwnd->pddClip, NULL, NULL, &cj) == DD_OK)
|
|
{
|
|
if ( cj > pwnd->cjrgndat || !pwnd->prgndat )
|
|
{
|
|
if ( pwnd->prgndat )
|
|
FREE(pwnd->prgndat);
|
|
|
|
pwnd->prgndat = ALLOC(pwnd->cjrgndat = cj);
|
|
if ( !pwnd->prgndat )
|
|
{
|
|
WARNING("wglGetClipList(): memory failure\n");
|
|
pwnd->cjrgndat = 0;
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WARNING("wglGetClipList(): clipper failed to return size\n");
|
|
return FALSE;
|
|
}
|
|
|
|
// Get the clip list (RGNDATA format).
|
|
|
|
if ( pwnd->pddClip->lpVtbl->
|
|
GetClipList(pwnd->pddClip, NULL, pwnd->prgndat, &cj) == DD_OK )
|
|
{
|
|
// Compose the scan version of the clip list.
|
|
|
|
if (!wglMakeScans(pwnd))
|
|
{
|
|
WARNING("wglGetClipList(): scan conversion failed\n");
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
WARNING("wglGetClipList(): clipper failed\n");
|
|
return FALSE;
|
|
}
|
|
|
|
// Fixup the protected portions of the window.
|
|
|
|
ASSERT_WINCRIT(pwnd);
|
|
|
|
{
|
|
__GLGENbuffers *buffers;
|
|
|
|
// Update rclBounds to match RGNDATA bounds.
|
|
|
|
pwnd->rclBounds = *(RECTL *) &pwnd->prgndat->rdh.rcBound;
|
|
|
|
// Update rclClient to match client area. We cannot do this from the
|
|
// information in RGNDATA as the bounds may be smaller than the window
|
|
// client area. We will have to call GetClientRect().
|
|
|
|
GetClientRect(pwnd->gwid.hwnd, (LPRECT) &pwnd->rclClient);
|
|
ClientToScreen(pwnd->gwid.hwnd, (LPPOINT) &pwnd->rclClient);
|
|
pwnd->rclClient.right += pwnd->rclClient.left;
|
|
pwnd->rclClient.bottom += pwnd->rclClient.top;
|
|
|
|
//
|
|
// Setup window clip complexity
|
|
//
|
|
if ( pwnd->prgndat->rdh.nCount > 1 )
|
|
{
|
|
// Clip list will be used for clipping.
|
|
pwnd->clipComplexity = CLC_COMPLEX;
|
|
}
|
|
else if ( pwnd->prgndat->rdh.nCount == 1 )
|
|
{
|
|
RECT *prc = (RECT *) pwnd->prgndat->Buffer;
|
|
|
|
// Recently, DirectDraw has been occasionally returning rclBounds
|
|
// set to the screen dimensions. This is being investigated as a
|
|
// bug on DDraw's part, but let us protect ourselves in any case.
|
|
//
|
|
// When there is only a single clip rectangle, it should be
|
|
// the same as the bounds.
|
|
|
|
pwnd->rclBounds = *((RECTL *) prc);
|
|
|
|
// If bounds rectangle is smaller than client area, we need to
|
|
// clip to the bounds rectangle. Otherwise, clip to the window
|
|
// client area.
|
|
|
|
if ( (pwnd->rclBounds.left <= pwnd->rclClient.left ) &&
|
|
(pwnd->rclBounds.right >= pwnd->rclClient.right ) &&
|
|
(pwnd->rclBounds.top <= pwnd->rclClient.top ) &&
|
|
(pwnd->rclBounds.bottom >= pwnd->rclClient.bottom) )
|
|
pwnd->clipComplexity = CLC_TRIVIAL;
|
|
else
|
|
pwnd->clipComplexity = CLC_RECT;
|
|
}
|
|
else
|
|
{
|
|
// Clip count is zero. Bounds should be an empty rectangle.
|
|
|
|
pwnd->clipComplexity = CLC_RECT;
|
|
|
|
pwnd->rclBounds.left = 0;
|
|
pwnd->rclBounds.top = 0;
|
|
pwnd->rclBounds.right = 0;
|
|
pwnd->rclBounds.bottom = 0;
|
|
}
|
|
|
|
// Finally, the window has changed, so change the uniqueness number.
|
|
|
|
if ((buffers = pwnd->buffers))
|
|
{
|
|
buffers->WndUniq++;
|
|
|
|
// Don't let it hit -1. -1 is special and is used by
|
|
// MakeCurrent to signal that an update is required
|
|
|
|
if (buffers->WndUniq == -1)
|
|
buffers->WndUniq = 0;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglCleanupWindow
|
|
*
|
|
* Removes references to the specified window from
|
|
* all contexts by running through the list of RCs in the handle manager
|
|
* table.
|
|
*
|
|
* History:
|
|
* 05-Jul-1994 -by- Gilman Wong [gilmanw]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
VOID APIENTRY wglCleanupWindow(GLGENwindow *pwnd)
|
|
{
|
|
if (pwnd)
|
|
{
|
|
//!!!XXX -- For now remove reference from current context. Need to
|
|
//!!!XXX scrub all contexts for multi-threaded cleanup to work.
|
|
//!!!XXX We need to implement a gengc tracking mechanism.
|
|
|
|
__GLGENcontext *gengc = (__GLGENcontext *) GLTEB_SRVCONTEXT();
|
|
|
|
if ( gengc && (gengc->pwndMakeCur == pwnd) )
|
|
{
|
|
// Found a victim. Must NULL out the pointer both in the RC
|
|
// and in the generic context.
|
|
|
|
glsrvCleanupWindow(gengc, pwnd);
|
|
}
|
|
}
|
|
}
|
|
|
|
/******************************Public*Routine******************************\
|
|
* wglGetSystemPaletteEntries
|
|
*
|
|
* Internal version of GetSystemPaletteEntries.
|
|
*
|
|
* GetSystemPaletteEntries fails on some 4bpp devices. This wgl version
|
|
* will detect the 4bpp case and supply the hardcoded 16-color VGA palette.
|
|
* Otherwise, it will pass the call on to GDI's GetSystemPaletteEntries.
|
|
*
|
|
* It is expected that this call will only be called in the 4bpp and 8bpp
|
|
* cases as it is not necessary for OpenGL to query the system palette
|
|
* for > 8bpp devices.
|
|
*
|
|
* History:
|
|
* 17-Aug-1995 -by- Gilman Wong [gilmanw]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
static PALETTEENTRY gapeVgaPalette[16] =
|
|
{
|
|
{ 0, 0, 0, 0 },
|
|
{ 0x80,0, 0, 0 },
|
|
{ 0, 0x80,0, 0 },
|
|
{ 0x80,0x80,0, 0 },
|
|
{ 0, 0, 0x80, 0 },
|
|
{ 0x80,0, 0x80, 0 },
|
|
{ 0, 0x80,0x80, 0 },
|
|
{ 0x80,0x80,0x80, 0 },
|
|
{ 0xC0,0xC0,0xC0, 0 },
|
|
{ 0xFF,0, 0, 0 },
|
|
{ 0, 0xFF,0, 0 },
|
|
{ 0xFF,0xFF,0, 0 },
|
|
{ 0, 0, 0xFF, 0 },
|
|
{ 0xFF,0, 0xFF, 0 },
|
|
{ 0, 0xFF,0xFF, 0 },
|
|
{ 0xFF,0xFF,0xFF, 0 }
|
|
};
|
|
|
|
UINT APIENTRY wglGetSystemPaletteEntries(
|
|
HDC hdc,
|
|
UINT iStartIndex,
|
|
UINT nEntries,
|
|
LPPALETTEENTRY lppe)
|
|
{
|
|
int nDeviceBits;
|
|
|
|
nDeviceBits = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
|
|
|
|
if ( nDeviceBits == 4 )
|
|
{
|
|
if ( lppe )
|
|
{
|
|
nEntries = min(nEntries, (16 - iStartIndex));
|
|
|
|
memcpy(lppe, &gapeVgaPalette[iStartIndex],
|
|
nEntries * sizeof(PALETTEENTRY));
|
|
}
|
|
else
|
|
nEntries = 16;
|
|
|
|
return nEntries;
|
|
}
|
|
else
|
|
{
|
|
return GetSystemPaletteEntries(hdc, iStartIndex, nEntries, lppe);
|
|
}
|
|
}
|