/****************************************************************************
*
*                        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
}

// ***********************************************************************