| /**************************************************************************** |
| * |
| * Mesa 3-D graphics library |
| * Direct3D Driver Interface |
| * |
| * ======================================================================== |
| * |
| * Copyright (C) 1991-2004 SciTech Software, Inc. All rights reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included |
| * in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * SCITECH SOFTWARE INC BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF |
| * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| * SOFTWARE. |
| * |
| * ======================================================================== |
| * |
| * Language: ANSI C |
| * Environment: Windows 9x (Win32) |
| * |
| * Description: Pixel Formats. |
| * |
| ****************************************************************************/ |
| |
| #include "dglpf.h" |
| |
| #ifdef _USE_GLD3_WGL |
| #include "gld_driver.h" |
| #endif |
| |
| // *********************************************************************** |
| |
| char szColorDepthWarning[] = |
| "GLDirect does not support the current desktop\n\ |
| color depth.\n\n\ |
| You may need to change the display resolution to\n\ |
| 16 bits per pixel or higher color depth using\n\ |
| the Windows Display Settings control panel\n\ |
| before running this OpenGL application.\n"; |
| |
| // *********************************************************************** |
| // This pixel format will be used as a template when compiling the list |
| // of pixel formats supported by the hardware. Many fields will be |
| // filled in at runtime. |
| // PFD flag defaults are upgraded to match ChoosePixelFormat() -- DaveM |
| DGL_pixelFormat pfTemplateHW = |
| { |
| { |
| sizeof(PIXELFORMATDESCRIPTOR), // Size of the data structure |
| 1, // Structure version - should be 1 |
| // Flags: |
| PFD_DRAW_TO_WINDOW | // The buffer can draw to a window or device surface. |
| PFD_DRAW_TO_BITMAP | // The buffer can draw to a bitmap. (DaveM) |
| PFD_SUPPORT_GDI | // The buffer supports GDI drawing. (DaveM) |
| PFD_SUPPORT_OPENGL | // The buffer supports OpenGL drawing. |
| PFD_DOUBLEBUFFER | // The buffer is double-buffered. |
| 0, // Placeholder for easy commenting of above flags |
| PFD_TYPE_RGBA, // Pixel type RGBA. |
| 16, // Total colour bitplanes (excluding alpha bitplanes) |
| 5, 0, // Red bits, shift |
| 5, 5, // Green bits, shift |
| 5, 10, // Blue bits, shift |
| 0, 0, // Alpha bits, shift (destination alpha) |
| 0, // Accumulator bits (total) |
| 0, 0, 0, 0, // Accumulator bits: Red, Green, Blue, Alpha |
| 0, // Depth bits |
| 0, // Stencil bits |
| 0, // Number of auxiliary buffers |
| 0, // Layer type |
| 0, // Specifies the number of overlay and underlay planes. |
| 0, // Layer mask |
| 0, // Specifies the transparent color or index of an underlay plane. |
| 0 // Damage mask |
| }, |
| -1, // No depth/stencil buffer |
| }; |
| |
| // *********************************************************************** |
| // Return the count of the number of bits in a Bit Mask. |
| int BitCount( |
| DWORD dw) |
| { |
| int i; |
| |
| if (dw == 0) |
| return 0; // account for non-RGB mode |
| |
| for (i=0; dw; dw=dw>>1) |
| i += (dw & 1); |
| return i; |
| } |
| |
| // *********************************************************************** |
| |
| DWORD BitShift( |
| DWORD dwMaskIn) |
| { |
| DWORD dwShift, dwMask; |
| |
| if (dwMaskIn == 0) |
| return 0; // account for non-RGB mode |
| |
| for (dwShift=0, dwMask=dwMaskIn; !(dwMask&1); dwShift++, dwMask>>=1); |
| |
| return dwShift; |
| } |
| |
| // *********************************************************************** |
| |
| BOOL IsValidPFD(int iPFD) |
| { |
| DGL_pixelFormat *lpPF; |
| |
| // Validate license |
| if (!dglValidate()) |
| return FALSE; |
| |
| if ((glb.lpPF == NULL) || |
| (glb.nPixelFormatCount == 0)) |
| return FALSE; |
| |
| // Check PFD range |
| if ( (iPFD < 1) || (iPFD > glb.nPixelFormatCount) ) { |
| ddlogMessage(DDLOG_ERROR, "PFD out of range\n"); |
| return FALSE; // PFD is invalid |
| } |
| |
| // Make a pointer to the pixel format |
| lpPF = &glb.lpPF[iPFD-1]; |
| |
| // Check size |
| if (lpPF->pfd.nSize != sizeof(PIXELFORMATDESCRIPTOR)) { |
| ddlogMessage(DDLOG_ERROR, "Bad PFD size\n"); |
| return FALSE; // PFD is invalid |
| } |
| |
| // Check version |
| if (lpPF->pfd.nVersion != 1) { |
| ddlogMessage(DDLOG_ERROR, "PFD is not Version 1\n"); |
| return FALSE; // PFD is invalid |
| } |
| |
| return TRUE; // PFD is valid |
| } |
| |
| // *********************************************************************** |
| |
| #ifndef _USE_GLD3_WGL |
| |
| int iEnumCount; // Enumeration count |
| DWORD dwDisplayBitDepth; // Bit depth of current display mode |
| |
| // *********************************************************************** |
| |
| HRESULT WINAPI EnumDisplayModesCallback( |
| DDSURFACEDESC2* pddsd, |
| void *pvContext) |
| { |
| DWORD dwModeDepth; |
| DDSURFACEDESC2 *lpDisplayMode; |
| char buf[32]; |
| |
| // Check parameters |
| if (pddsd == NULL) |
| return DDENUMRET_CANCEL; |
| |
| dwModeDepth = pddsd->ddpfPixelFormat.dwRGBBitCount; |
| lpDisplayMode = (DDSURFACEDESC2 *)pvContext; |
| |
| // Check mode for compatability with device. |
| if (dwModeDepth != dwDisplayBitDepth) |
| return DDENUMRET_OK; |
| |
| if (lpDisplayMode != NULL) { |
| memcpy(&lpDisplayMode[iEnumCount], pddsd, sizeof(DDSURFACEDESC2)); |
| sprintf(buf, TEXT("Mode: %ld x %ld x %ld\n"), |
| pddsd->dwWidth, pddsd->dwHeight, dwModeDepth); |
| ddlogMessage(DDLOG_INFO, buf); |
| } |
| |
| iEnumCount++; |
| |
| return DDENUMRET_OK; |
| } |
| |
| // *********************************************************************** |
| |
| HRESULT CALLBACK d3dEnumZBufferFormatsCallback( |
| DDPIXELFORMAT* pddpf, |
| VOID* lpZBufferPF ) |
| { |
| char buf[64]; |
| |
| if(pddpf == NULL) |
| return D3DENUMRET_CANCEL; |
| |
| if (pddpf->dwFlags & DDPF_ZBUFFER) { |
| if (lpZBufferPF == NULL) { |
| // Pass 1. Merely counting the PF |
| glb.nZBufferPFCount++; |
| } else { |
| // Pass 2. Save the PF |
| if (pddpf->dwFlags & DDPF_STENCILBUFFER) { |
| sprintf(buf, " %d: Z=%d S=%d\n", |
| iEnumCount, |
| pddpf->dwZBufferBitDepth, |
| pddpf->dwStencilBitDepth); |
| } else { |
| sprintf(buf, " %d: Z=%d S=0\n", |
| iEnumCount, |
| pddpf->dwZBufferBitDepth); |
| } |
| ddlogMessage(DDLOG_INFO, buf); |
| |
| memcpy(&glb.lpZBufferPF[iEnumCount++], |
| pddpf, |
| sizeof(DDPIXELFORMAT)); |
| } |
| } |
| |
| return D3DENUMRET_OK; |
| } |
| #endif // _USE_GLD3_WGL |
| |
| // *********************************************************************** |
| |
| BOOL IsStencilSupportBroken(LPDIRECTDRAW4 lpDD4) |
| { |
| DDDEVICEIDENTIFIER dddi; // DX6 device identifier |
| BOOL bBroken = FALSE; |
| |
| // Microsoft really fucked up with the GetDeviceIdentifier function |
| // on Windows 2000, since it locks up on stock driers on the CD. Updated |
| // drivers from vendors appear to work, but we can't identify the drivers |
| // without this function!!! For now we skip these tests on Windows 2000. |
| if ((GetVersion() & 0x80000000UL) == 0) |
| return FALSE; |
| |
| // Obtain device info |
| if (FAILED(IDirectDraw4_GetDeviceIdentifier(lpDD4, &dddi, 0))) |
| return FALSE; |
| |
| // Matrox G400 stencil buffer support does not draw anything in AutoCAD, |
| // but ordinary Z buffers draw shaded models fine. (DaveM) |
| if (dddi.dwVendorId == 0x102B) { // Matrox |
| if (dddi.dwDeviceId == 0x0525) { // G400 |
| bBroken = TRUE; |
| } |
| } |
| |
| return bBroken; |
| } |
| |
| // *********************************************************************** |
| |
| void dglBuildPixelFormatList() |
| { |
| int i; |
| char buf[128]; |
| char cat[8]; |
| DGL_pixelFormat *lpPF; |
| |
| #ifdef _USE_GLD3_WGL |
| _gldDriver.BuildPixelformatList(); |
| #else |
| HRESULT hRes; |
| IDirectDraw *lpDD1 = NULL; |
| IDirectDraw4 *lpDD4 = NULL; |
| IDirect3D3 *lpD3D3 = NULL; |
| DDSURFACEDESC2 ddsdDisplayMode; |
| |
| DWORD dwRb, dwGb, dwBb, dwAb; // Bit counts |
| DWORD dwRs, dwGs, dwBs, dwAs; // Bit shifts |
| DWORD dwPixelType; // RGB or color index |
| |
| // Set defaults |
| glb.nPixelFormatCount = 0; |
| glb.lpPF = NULL; |
| glb.nZBufferPFCount = 0; |
| glb.lpZBufferPF = NULL; |
| glb.nDisplayModeCount = 0; |
| glb.lpDisplayModes = NULL; |
| |
| // |
| // Examine the hardware for depth and stencil |
| // |
| |
| if (glb.bPrimary) |
| hRes = DirectDrawCreate(NULL, &lpDD1, NULL); |
| else |
| hRes = DirectDrawCreate(&glb.ddGuid, &lpDD1, NULL); |
| |
| if (FAILED(hRes)) { |
| ddlogError(DDLOG_ERROR, "dglBPFL: DirectDrawCreate failed", hRes); |
| return; |
| } |
| |
| // Query for DX6 IDirectDraw4. |
| hRes = IDirectDraw_QueryInterface( |
| lpDD1, |
| &IID_IDirectDraw4, |
| (void**)&lpDD4); |
| if (FAILED(hRes)) { |
| ddlogError(DDLOG_ERROR, "dglBPFL: QueryInterface (DD4) failed", hRes); |
| goto clean_up; |
| } |
| |
| |
| // Retrieve caps of current display mode |
| ZeroMemory(&ddsdDisplayMode, sizeof(ddsdDisplayMode)); |
| ddsdDisplayMode.dwSize = sizeof(ddsdDisplayMode); |
| hRes = IDirectDraw4_GetDisplayMode(lpDD4, &ddsdDisplayMode); |
| if (FAILED(hRes)) |
| goto clean_up; |
| |
| dwDisplayBitDepth = ddsdDisplayMode.ddpfPixelFormat.dwRGBBitCount; |
| dwPixelType = (dwDisplayBitDepth <= 8) ? PFD_TYPE_COLORINDEX : PFD_TYPE_RGBA; |
| dwRb = BitCount(ddsdDisplayMode.ddpfPixelFormat.dwRBitMask); |
| dwGb = BitCount(ddsdDisplayMode.ddpfPixelFormat.dwGBitMask); |
| dwBb = BitCount(ddsdDisplayMode.ddpfPixelFormat.dwBBitMask); |
| dwRs = BitShift(ddsdDisplayMode.ddpfPixelFormat.dwRBitMask); |
| dwGs = BitShift(ddsdDisplayMode.ddpfPixelFormat.dwGBitMask); |
| dwBs = BitShift(ddsdDisplayMode.ddpfPixelFormat.dwBBitMask); |
| |
| if (BitCount(ddsdDisplayMode.ddpfPixelFormat.dwRGBAlphaBitMask)) { |
| dwAb = BitCount(ddsdDisplayMode.ddpfPixelFormat.dwRGBAlphaBitMask); |
| dwAs = BitShift(ddsdDisplayMode.ddpfPixelFormat.dwRGBAlphaBitMask); |
| } else { |
| dwAb = 0; |
| dwAs = 0; |
| } |
| |
| // Query for available display modes |
| ddlogMessage(DDLOG_INFO, "\n"); |
| ddlogMessage(DDLOG_INFO, "Display Modes:\n"); |
| |
| // Pass 1: Determine count |
| iEnumCount = 0; |
| hRes = IDirectDraw4_EnumDisplayModes( |
| lpDD4, |
| 0, |
| NULL, |
| NULL, |
| EnumDisplayModesCallback); |
| if (FAILED(hRes)) { |
| ddlogError(DDLOG_ERROR, "dglBPFL: EnumDisplayModes failed", hRes); |
| goto clean_up; |
| } |
| if (iEnumCount == 0) { |
| ddlogMessage(DDLOG_ERROR, "dglBPFL: No display modes found"); |
| goto clean_up; |
| } |
| glb.lpDisplayModes = (DDSURFACEDESC2 *)calloc(iEnumCount, |
| sizeof(DDSURFACEDESC2)); |
| if (glb.lpDisplayModes == NULL) { |
| ddlogMessage(DDLOG_ERROR, "dglBPFL: DDSURFACEDESC2 calloc failed"); |
| goto clean_up; |
| } |
| glb.nDisplayModeCount = iEnumCount; |
| // Pass 2: Save modes |
| iEnumCount = 0; |
| hRes = IDirectDraw4_EnumDisplayModes( |
| lpDD4, |
| 0, |
| NULL, |
| (void *)glb.lpDisplayModes, |
| EnumDisplayModesCallback); |
| if (FAILED(hRes)) { |
| ddlogError(DDLOG_ERROR, "dglBPFL: EnumDisplayModes failed", hRes); |
| goto clean_up; |
| } |
| // Query for IDirect3D3 interface |
| hRes = IDirectDraw4_QueryInterface( |
| lpDD4, |
| &IID_IDirect3D3, |
| (void**)&lpD3D3); |
| if (FAILED(hRes)) { |
| ddlogError(DDLOG_ERROR, "dglBPFL: QueryInterface (D3D3) failed", hRes); |
| goto clean_up; |
| } |
| |
| ddlogMessage(DDLOG_INFO, "\n"); |
| ddlogMessage(DDLOG_INFO, "ZBuffer formats:\n"); |
| |
| // Pass 1. Count the ZBuffer pixel formats |
| hRes = IDirect3D3_EnumZBufferFormats( |
| lpD3D3, |
| &glb.d3dGuid, |
| d3dEnumZBufferFormatsCallback, |
| NULL); |
| |
| if (FAILED(hRes)) |
| goto clean_up; |
| |
| if (glb.nZBufferPFCount) { |
| glb.lpZBufferPF = (DDPIXELFORMAT *)calloc(glb.nZBufferPFCount, |
| sizeof(DDPIXELFORMAT)); |
| if(glb.lpZBufferPF == NULL) |
| goto clean_up; |
| |
| // Pass 2. Cache the ZBuffer pixel formats |
| iEnumCount = 0; // (Used by the enum function) |
| hRes = IDirect3D3_EnumZBufferFormats( |
| lpD3D3, |
| &glb.d3dGuid, |
| d3dEnumZBufferFormatsCallback, |
| glb.lpZBufferPF); |
| |
| if (FAILED(hRes)) |
| goto clean_up; |
| } |
| |
| // Remove stencil support for boards which don't work for AutoCAD; |
| // Matrox G400 does not work, but NVidia TNT2 and ATI Rage128 do... (DaveM) |
| if (IsStencilSupportBroken(lpDD4)) { |
| for (i=0; i<iEnumCount; i++) |
| if (glb.lpZBufferPF[i].dwFlags & DDPF_STENCILBUFFER) |
| glb.nZBufferPFCount--; |
| } |
| |
| // One each for every ZBuffer pixel format (including no depth buffer) |
| // Times-two because duplicated for single buffering (as opposed to double) |
| glb.nPixelFormatCount = 2 * (glb.nZBufferPFCount + 1); |
| glb.lpPF = (DGL_pixelFormat *)calloc(glb.nPixelFormatCount, |
| sizeof(DGL_pixelFormat)); |
| if (glb.lpPF == NULL) |
| goto clean_up; |
| // |
| // Fill in the pixel formats |
| // Note: Depth buffer bits are really (dwZBufferBitDepth-dwStencilBitDepth) |
| // but this will pass wierd numbers to the OpenGL app. (?) |
| // |
| |
| pfTemplateHW.pfd.iPixelType = dwPixelType; |
| pfTemplateHW.pfd.cColorBits = dwDisplayBitDepth; |
| pfTemplateHW.pfd.cRedBits = dwRb; |
| pfTemplateHW.pfd.cGreenBits = dwGb; |
| pfTemplateHW.pfd.cBlueBits = dwBb; |
| pfTemplateHW.pfd.cAlphaBits = dwAb; |
| pfTemplateHW.pfd.cRedShift = dwRs; |
| pfTemplateHW.pfd.cGreenShift = dwGs; |
| pfTemplateHW.pfd.cBlueShift = dwBs; |
| pfTemplateHW.pfd.cAlphaShift = dwAs; |
| |
| lpPF = glb.lpPF; |
| |
| // Fill in the double-buffered pixel formats |
| for (i=0; i<(glb.nZBufferPFCount + 1); i++, lpPF++) { |
| memcpy(lpPF, &pfTemplateHW, sizeof(DGL_pixelFormat)); |
| if (i) { |
| lpPF->iZBufferPF = i-1; |
| lpPF->pfd.cDepthBits = glb.lpZBufferPF[i-1].dwZBufferBitDepth; |
| lpPF->pfd.cStencilBits = glb.lpZBufferPF[i-1].dwStencilBitDepth; |
| } |
| } |
| // Fill in the single-buffered pixel formats |
| for (i=0; i<(glb.nZBufferPFCount + 1); i++, lpPF++) { |
| memcpy(lpPF, &pfTemplateHW, sizeof(DGL_pixelFormat)); |
| if (i) { |
| lpPF->iZBufferPF = i-1; |
| lpPF->pfd.cDepthBits = glb.lpZBufferPF[i-1].dwZBufferBitDepth; |
| lpPF->pfd.cStencilBits = glb.lpZBufferPF[i-1].dwStencilBitDepth; |
| } |
| // Remove double-buffer flag. Could use XOR instead... |
| lpPF->pfd.dwFlags &= (~(PFD_DOUBLEBUFFER)); |
| // Insert GDI flag for single buffered format only. |
| lpPF->pfd.dwFlags |= PFD_SUPPORT_GDI; |
| } |
| #endif // _USE_GLD3_WGL |
| |
| // Lets dump the list to the log |
| // ** Based on "wglinfo" by Nate Robins ** |
| ddlogMessage(DDLOG_INFO, "\n"); |
| ddlogMessage(DDLOG_INFO, "Pixel Formats:\n"); |
| ddlogMessage(DDLOG_INFO, |
| " visual x bf lv rg d st r g b a ax dp st accum buffs ms\n"); |
| ddlogMessage(DDLOG_INFO, |
| " id dep cl sp sz l ci b ro sz sz sz sz bf th cl r g b a ns b\n"); |
| ddlogMessage(DDLOG_INFO, |
| "-----------------------------------------------------------------\n"); |
| for (i=0, lpPF = glb.lpPF; i<glb.nPixelFormatCount; i++, lpPF++) { |
| sprintf(buf, "0x%02x ", i+1); |
| |
| sprintf(cat, "%2d ", lpPF->pfd.cColorBits); |
| strcat(buf, cat); |
| if(lpPF->pfd.dwFlags & PFD_DRAW_TO_WINDOW) sprintf(cat, "wn "); |
| else if(lpPF->pfd.dwFlags & PFD_DRAW_TO_BITMAP) sprintf(cat, "bm "); |
| else sprintf(cat, ". "); |
| strcat(buf, cat); |
| |
| /* should find transparent pixel from LAYERPLANEDESCRIPTOR */ |
| sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| sprintf(cat, "%2d ", lpPF->pfd.cColorBits); |
| strcat(buf, cat); |
| |
| /* bReserved field indicates number of over/underlays */ |
| if(lpPF->pfd.bReserved) sprintf(cat, " %d ", lpPF->pfd.bReserved); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| sprintf(cat, " %c ", lpPF->pfd.iPixelType == PFD_TYPE_RGBA ? 'r' : 'c'); |
| strcat(buf, cat); |
| |
| sprintf(cat, "%c ", lpPF->pfd.dwFlags & PFD_DOUBLEBUFFER ? 'y' : '.'); |
| strcat(buf, cat); |
| |
| sprintf(cat, " %c ", lpPF->pfd.dwFlags & PFD_STEREO ? 'y' : '.'); |
| strcat(buf, cat); |
| |
| if(lpPF->pfd.cRedBits && lpPF->pfd.iPixelType == PFD_TYPE_RGBA) |
| sprintf(cat, "%2d ", lpPF->pfd.cRedBits); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| if(lpPF->pfd.cGreenBits && lpPF->pfd.iPixelType == PFD_TYPE_RGBA) |
| sprintf(cat, "%2d ", lpPF->pfd.cGreenBits); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| if(lpPF->pfd.cBlueBits && lpPF->pfd.iPixelType == PFD_TYPE_RGBA) |
| sprintf(cat, "%2d ", lpPF->pfd.cBlueBits); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| if(lpPF->pfd.cAlphaBits && lpPF->pfd.iPixelType == PFD_TYPE_RGBA) |
| sprintf(cat, "%2d ", lpPF->pfd.cAlphaBits); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| if(lpPF->pfd.cAuxBuffers) sprintf(cat, "%2d ", lpPF->pfd.cAuxBuffers); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| if(lpPF->pfd.cDepthBits) sprintf(cat, "%2d ", lpPF->pfd.cDepthBits); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| if(lpPF->pfd.cStencilBits) sprintf(cat, "%2d ", lpPF->pfd.cStencilBits); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| if(lpPF->pfd.cAccumRedBits) sprintf(cat, "%2d ", lpPF->pfd.cAccumRedBits); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| if(lpPF->pfd.cAccumGreenBits) sprintf(cat, "%2d ", lpPF->pfd.cAccumGreenBits); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| if(lpPF->pfd.cAccumBlueBits) sprintf(cat, "%2d ", lpPF->pfd.cAccumBlueBits); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| if(lpPF->pfd.cAccumAlphaBits) sprintf(cat, "%2d ", lpPF->pfd.cAccumAlphaBits); |
| else sprintf(cat, " . "); |
| strcat(buf, cat); |
| |
| /* no multisample in Win32 */ |
| sprintf(cat, " . .\n"); |
| strcat(buf, cat); |
| |
| ddlogMessage(DDLOG_INFO, buf); |
| } |
| ddlogMessage(DDLOG_INFO, |
| "-----------------------------------------------------------------\n"); |
| ddlogMessage(DDLOG_INFO, "\n"); |
| |
| #ifndef _USE_GLD3_WGL |
| clean_up: |
| // Release COM objects |
| RELEASE(lpD3D3); |
| RELEASE(lpDD4); |
| RELEASE(lpDD1); |
| |
| // Popup warning message if non RGB color mode |
| if (dwDisplayBitDepth <= 8) { |
| ddlogPrintf(DDLOG_WARN, "Current Color Depth %d bpp is not supported", dwDisplayBitDepth); |
| MessageBox(NULL, szColorDepthWarning, "GLDirect", MB_OK | MB_ICONWARNING); |
| } |
| #endif // _USE_GLD3_WGL |
| } |
| |
| // *********************************************************************** |
| |
| void dglReleasePixelFormatList() |
| { |
| glb.nPixelFormatCount = 0; |
| if (glb.lpPF) { |
| free(glb.lpPF); |
| glb.lpPF = NULL; |
| } |
| #ifndef _USE_GLD3_WGL |
| glb.nZBufferPFCount = 0; |
| if (glb.lpZBufferPF) { |
| free(glb.lpZBufferPF); |
| glb.lpZBufferPF = NULL; |
| } |
| glb.nDisplayModeCount = 0; |
| if (glb.lpDisplayModes) { |
| free(glb.lpDisplayModes); |
| glb.lpDisplayModes = NULL; |
| } |
| #endif // _USE_GLD3_WGL |
| } |
| |
| // *********************************************************************** |