/**************************************************************************** * * 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; iiZBufferPF = 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; ipfd.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 } // ***********************************************************************