/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/

//#define DYNAHEADER_CREATE_STORAGE

#include "hsTypes.h"

#include <time.h>

#include "hsWindows.h"

#include "hsG3DDeviceSelector.h"
#include "hsStream.h"
#include "hsUtils.h"
#include "plPipeline.h"

#ifdef HS_OPEN_GL
#if HS_BUILD_FOR_WIN32
#include "gls.h"
#include "glswgl.h"
#include "glext.h"
#endif
#endif

///////////////////////////////////////////////////
///////////////////////////////////////////////////
///////////////////////////////////////////////////
hsG3DDeviceMode::hsG3DDeviceMode()
:	fWidth(0), fHeight(0), 
	fDepth(0),
	fFlags(kNone)
{
}

hsG3DDeviceMode::~hsG3DDeviceMode()
{
	Clear();
}

hsBool hsG3DDeviceMode::operator< (const hsG3DDeviceMode &mode) const
{
	// Color depth overrides everything else
	if (fDepth < mode.GetColorDepth())
		return true;
	// Only compare width and height if the color depth is the same
	else if (fDepth == mode.GetColorDepth() )
	{
		if( fWidth < mode.GetWidth() )
			return true;
		else if( fWidth == mode.GetWidth() && fHeight < mode.GetHeight() )
			return true;
	}

	return false;
}

void hsG3DDeviceMode::Clear()
{
	fFlags = kNone;
	fWidth = 0;
	fHeight = 0;
	fDepth = 0;
	fZStencilDepths.Reset();
	fFSAATypes.Reset();
}

void hsG3DDeviceMode::Read( hsStream* s )
{
	Clear();

	fFlags = s->ReadSwap32();
	fWidth = s->ReadSwap32();
	fHeight = s->ReadSwap32();
	fDepth = s->ReadSwap32();

	fZStencilDepths.Reset();
	UInt8	count= s->ReadByte();
	while( count-- )
		fZStencilDepths.Append( s->ReadSwap16() );

	/// Version 9
	fFSAATypes.Reset();
	count = s->ReadByte();
	while( count-- )
		fFSAATypes.Append( s->ReadByte() );

	fCanRenderToCubics = s->ReadBool();
}

void hsG3DDeviceMode::Write( hsStream* s ) const
{
	s->WriteSwap32(fFlags);
	s->WriteSwap32(fWidth);
	s->WriteSwap32(fHeight);
	s->WriteSwap32(fDepth);

	UInt8	i, count = (UInt8)fZStencilDepths.GetCount();
	s->WriteByte( count );
	for( i = 0; i < count; i++ )
		s->WriteSwap16( fZStencilDepths[ i ] );

	/// Version 9
	count = (UInt8)fFSAATypes.GetCount();
	s->WriteByte( count );
	for( i = 0; i < count; i++ )
		s->WriteByte( fFSAATypes[ i ] );

	s->WriteBool( fCanRenderToCubics );
}

///////////////////////////////////////////////////
///////////////////////////////////////////////////
///////////////////////////////////////////////////

hsG3DDeviceRecord::hsG3DDeviceRecord()
:	fFlags(kNone),
	fG3DDeviceType(hsG3DDeviceSelector::kDevTypeUnknown),
	fG3DDriverDesc(nil), fG3DDriverName(nil), fG3DDriverVersion(nil), fG3DDeviceDesc(nil),
	fLayersAtOnce(0), fMemoryBytes(0),
	fG3DHALorHEL(hsG3DDeviceSelector::kHHTypeUnknown),
	fZBiasRating( 0 ), fRecordVersion( kCurrRecordVersion ), fLODBiasRating( 0 ),
	fFogExpApproxStart( 0.0 ), fFogExp2ApproxStart( 0.0 ), fFogEndBias( 0.0 ), fMaxAnisotropicSamples( 1 )
{
	SetFogKneeParams( kFogExp, 0, 0 );
	SetFogKneeParams( kFogExp2, 0, 0 );
}

hsG3DDeviceRecord::~hsG3DDeviceRecord()
{
	Clear();
}

hsG3DDeviceRecord::hsG3DDeviceRecord(const hsG3DDeviceRecord& src)
:	fFlags(kNone),
	fG3DDeviceType(hsG3DDeviceSelector::kDevTypeUnknown),
	fG3DDriverDesc(nil), fG3DDriverName(nil), fG3DDriverVersion(nil), fG3DDeviceDesc(nil),
	fG3DHALorHEL(hsG3DDeviceSelector::kHHTypeUnknown),
	fZBiasRating( src.fZBiasRating ), fRecordVersion( kCurrRecordVersion ), fLODBiasRating( 0 ),
	fFogExpApproxStart( src.fFogExpApproxStart ), fFogExp2ApproxStart( src.fFogExp2ApproxStart ), 
	fFogEndBias( src.fFogEndBias ), fMaxAnisotropicSamples( src.fMaxAnisotropicSamples )
{
	*this = src;
}

hsG3DDeviceRecord& hsG3DDeviceRecord::operator=(const hsG3DDeviceRecord& src)
{
	fFlags = src.fFlags;

	SetG3DDeviceType(src.GetG3DDeviceType());
	SetG3DHALorHEL(src.GetG3DHALorHEL());

	SetDriverDesc(src.GetDriverDesc());
	SetDriverName(src.GetDriverName());
	SetDriverVersion(src.GetDriverVersion());
	SetDeviceDesc(src.GetDeviceDesc());

	fCaps = src.fCaps;
	fLayersAtOnce = src.fLayersAtOnce;
	fMemoryBytes = src.fMemoryBytes;
	fZBiasRating = src.fZBiasRating;
	fLODBiasRating = src.fLODBiasRating;
	fFogExpApproxStart = src.fFogExpApproxStart;
	fFogExp2ApproxStart = src.fFogExp2ApproxStart;
	fFogEndBias = src.fFogEndBias;

	fModes.SetCount(src.fModes.GetCount());
	int i;
	for( i = 0; i < fModes.GetCount(); i++ )
		fModes[i] = src.fModes[i];

	fFogKnees[ 0 ] = src.fFogKnees[ 0 ];
	fFogKnees[ 1 ] = src.fFogKnees[ 1 ];
	fFogKneeVals[ 0 ] = src.fFogKneeVals[ 0 ];
	fFogKneeVals[ 1 ] = src.fFogKneeVals[ 1 ];

	fAASetting = src.fAASetting;

	fMaxAnisotropicSamples = src.fMaxAnisotropicSamples;

	return *this;
}

void hsG3DDeviceRecord::SetDriverDesc( const char *s )
{
	delete [] fG3DDriverDesc; 
	fG3DDriverDesc = s ? hsStrcpy(s) : nil; 
}

void hsG3DDeviceRecord::SetDriverName( const char *s )
{
	delete [] fG3DDriverName; 
	fG3DDriverName = s ? hsStrcpy(s) : nil; 
}

void hsG3DDeviceRecord::SetDriverVersion( const char *s )
{
	delete [] fG3DDriverVersion; 
	fG3DDriverVersion = s ? hsStrcpy(s) : nil; 
}

void hsG3DDeviceRecord::SetDeviceDesc( const char *s )
{ 
	delete [] fG3DDeviceDesc; 
	fG3DDeviceDesc = s ? hsStrcpy(s) : nil; 
}

const char* hsG3DDeviceRecord::GetG3DDeviceTypeName() const
{
	static char* deviceNames[hsG3DDeviceSelector::kNumDevTypes] = {
		"Unknown",
		"Glide",
		"Direct3D",
		"OpenGL"
	};

	UInt32 devType = GetG3DDeviceType();
	if( devType > hsG3DDeviceSelector::kNumDevTypes )
		devType = hsG3DDeviceSelector::kDevTypeUnknown;
	
	return deviceNames[devType];
}

void hsG3DDeviceRecord::RemoveDiscarded()
{
	int i;
	for( i = 0; i < fModes.GetCount(); )
	{
		if( fModes[i].GetDiscarded() )
		{
			fModes[i].Clear();
			fModes.Remove(i);
		}
		else
			i++;
	}
	if( !fModes.GetCount() )
		SetDiscarded(true);
}

void hsG3DDeviceRecord::ClearModes()
{
	int i;
	for( i = 0; i < fModes.GetCount(); i++ )
		fModes[i].Clear();
	fModes.Reset();
}

void hsG3DDeviceRecord::Clear()
{
	fFlags = kNone;

	delete [] fG3DDriverDesc;
	fG3DDriverDesc = nil;

	delete [] fG3DDriverName;
	fG3DDriverName = nil;

	delete [] fG3DDriverVersion;
	fG3DDriverVersion = nil;

	delete [] fG3DDeviceDesc;
	fG3DDeviceDesc = nil;

	fCaps.Clear();
	fLayersAtOnce = 0;

	int i;
	for( i = 0; i < fModes.GetCount(); i++ )
		fModes[i].Clear();
	fModes.Reset();

	fZBiasRating = 0;
	fLODBiasRating = 0;
	fFogExpApproxStart = 0;
	fFogExp2ApproxStart = 0;
	fFogEndBias = 0;

	SetFogKneeParams( kFogExp, 0, 0 );
	SetFogKneeParams( kFogExp2, 0, 0 );

	fAASetting = 0;
	fMaxAnisotropicSamples = 1;
}

//// Read /////////////////////////////////////////////////////////////////////
//	9.6.2000 mcn - Updated to reflect version 2 format
//	9.8.2000 mcn - (temporary?) set to invalid on old (<2) versions

void hsG3DDeviceRecord::Read(hsStream* s)
{
	Clear();

	/// Read version
	fRecordVersion = s->ReadSwap32();
	hsAssert( fRecordVersion <= kCurrRecordVersion, "Invalid version number in hsG3DDeviceRecord::Read()" );
	if( fRecordVersion == kCurrRecordVersion )
	{
		fFlags = s->ReadSwap32();
	}
	else
	{
		SetInvalid();
		return;
//		fFlags = fRecordVersion;
//		fRecordVersion = 1;
//		hsStatusMessage( "WARNING: Old version of hsG3DDeviceRecord found. Attempting to read." );
	}

	/// Now read everything else in as normal
	fG3DDeviceType = s->ReadSwap32();

	int len;

	len = s->ReadSwap32();
	fG3DDriverDesc = TRACKED_NEW char[len + 1];
	s->Read(len, fG3DDriverDesc);
	fG3DDriverDesc[len] = 0;

	len = s->ReadSwap32();
	fG3DDriverName = TRACKED_NEW char[len + 1];
	s->Read(len, fG3DDriverName);
	fG3DDriverName[len] = 0;

	len = s->ReadSwap32();
	fG3DDriverVersion = TRACKED_NEW char[len + 1];
	s->Read(len, fG3DDriverVersion);
	fG3DDriverVersion[len] = 0;

	len = s->ReadSwap32();
	fG3DDeviceDesc = TRACKED_NEW char[len + 1];
	s->Read(len, fG3DDeviceDesc);
	fG3DDeviceDesc[len] = 0;


	fCaps.Read(s);
	fLayersAtOnce = s->ReadSwap32();
	fMemoryBytes = s->ReadSwap32();

	len = s->ReadSwap32();
	fModes.SetCount(len);
	int i;
	for( i = 0; i < len; i++ )
		fModes[i].Read( s );

	/// Version 3 stuff
	fZBiasRating = s->ReadSwapFloat();
	fLODBiasRating = s->ReadSwapFloat();
	fFogExpApproxStart = s->ReadSwapFloat();
	fFogExp2ApproxStart = s->ReadSwapFloat();
	fFogEndBias = s->ReadSwapFloat();

	/// Version 7 stuff
	float		knee, kneeVal;
	knee = s->ReadSwapFloat(); kneeVal = s->ReadSwapFloat();
	SetFogKneeParams( kFogExp, knee, kneeVal );
	knee = s->ReadSwapFloat(); kneeVal = s->ReadSwapFloat();
	SetFogKneeParams( kFogExp2, knee, kneeVal );

	/// Version 9 stuff
	fAASetting = s->ReadByte();

	/// Version A stuff
	fMaxAnisotropicSamples = s->ReadByte();

	/// Reset record version now
	fRecordVersion = kCurrRecordVersion;
}

void hsG3DDeviceRecord::Write(hsStream* s) const
{
	s->WriteSwap32( fRecordVersion );

	s->WriteSwap32(fFlags);

	s->WriteSwap32(fG3DDeviceType);

	int len;

	len = hsStrlen(fG3DDriverDesc);
	s->WriteSwap32(len);
	s->Write(len, fG3DDriverDesc);

	len = hsStrlen(fG3DDriverName);
	s->WriteSwap32(len);
	s->Write(len, fG3DDriverName);

	len = hsStrlen(fG3DDriverVersion);
	s->WriteSwap32(len);
	s->Write(len, fG3DDriverVersion);

	len = hsStrlen(fG3DDeviceDesc);
	s->WriteSwap32(len);
	s->Write(len, fG3DDeviceDesc);

	fCaps.Write(s);
	s->WriteSwap32(fLayersAtOnce);
	s->WriteSwap32(fMemoryBytes);

	s->WriteSwap32(fModes.GetCount());
	int i;
	for( i = 0; i < fModes.GetCount(); i++ )
		fModes[i].Write( s );

	/// Version 3 data
	s->WriteSwapFloat( fZBiasRating );
	s->WriteSwapFloat( fLODBiasRating );
	s->WriteSwapFloat( fFogExpApproxStart );
	s->WriteSwapFloat( fFogExp2ApproxStart );
	s->WriteSwapFloat( fFogEndBias );

	/// Version 7 data
	s->WriteSwapFloat( fFogKnees[ kFogExp ] );
	s->WriteSwapFloat( fFogKneeVals[ kFogExp ] );
	s->WriteSwapFloat( fFogKnees[ kFogExp2 ] );
	s->WriteSwapFloat( fFogKneeVals[ kFogExp2 ] );

	/// Version 9 data
	s->WriteByte( fAASetting );

	/// Version A stuff
	s->WriteByte( fMaxAnisotropicSamples );
}

///////////////////////////////////////////////////
///////////////////////////////////////////////////
///////////////////////////////////////////////////

hsG3DDeviceModeRecord::hsG3DDeviceModeRecord(const hsG3DDeviceRecord& devRec, const hsG3DDeviceMode& devMode)
: fDevice(devRec), fMode(devMode)
{
}

hsG3DDeviceModeRecord::hsG3DDeviceModeRecord()
{
}

hsG3DDeviceModeRecord::~hsG3DDeviceModeRecord()
{
}

hsG3DDeviceModeRecord::hsG3DDeviceModeRecord(const hsG3DDeviceModeRecord& src)
{
	*this = src;
}

hsG3DDeviceModeRecord& hsG3DDeviceModeRecord::operator=(const hsG3DDeviceModeRecord& src)
{
	fDevice = src.fDevice;
	fMode = src.fMode;
	return *this;
}
///////////////////////////////////////////////////
///////////////////////////////////////////////////
///////////////////////////////////////////////////

hsG3DDeviceSelector::hsG3DDeviceSelector()
{
}

hsG3DDeviceSelector::~hsG3DDeviceSelector()
{
	Clear();
}

void hsG3DDeviceSelector::RemoveDiscarded()
{
	int i;
	for( i = 0; i < fRecords.GetCount(); )
	{
		fRecords[i].RemoveDiscarded();

		if( fRecords[i].GetDiscarded() )
		{
			fRecords[i].Clear();
			fRecords.Remove(i);
		}
		else
			i++;
	}
}

void hsG3DDeviceSelector::Clear()
{
	int i;
	for( i = 0; i < fRecords.GetCount(); i++ )
		fRecords[i].Clear();
	fRecords.Reset();
}

void hsG3DDeviceSelector::RemoveUnusableDevModes(hsBool bTough)
{
	plDemoDebugFile::Write( "Removing unusable devices and modes..." );
	for (int i = 0; i < fRecords.GetCount(); i++)
	{
		//
		// Remove modes
		//
		hsTArray<hsG3DDeviceMode>& modes = fRecords[i].GetModes();
		for (int j = 0; j < modes.GetCount(); j++)
		{
			// Remove windowed modes
			if ((modes[j].GetWidth() == 0) &&
				(modes[j].GetHeight() == 0) &&
				(modes[j].GetColorDepth() == 0))
			{
				plDemoDebugFile::Write( "   Removing windowed mode on ", (char *)fRecords[ i ].GetDriverDesc() );
				modes[j].SetDiscarded(true);
			}
			// If tough, remove modes less than 640x480
			else if (bTough && ((modes[j].GetWidth() < 640) || (modes[j].GetHeight() < 480)))
			{
				plDemoDebugFile::Write( "   Removing mode < 640x480 on ", (char *)fRecords[ i ].GetDriverDesc() );
				modes[j].SetDiscarded(true);
			}
			else
			{
				char str[ 256 ];
				sprintf( str, "   Keeping mode (%dx%d) on device %s", modes[j].GetWidth(), modes[j].GetHeight(), fRecords[ i ].GetDriverDesc() );
				plDemoDebugFile::Write( str );
			}
		}

		//
		// Remove devices
		//
		if (fRecords[i].GetG3DDeviceType() == hsG3DDeviceSelector::kDevTypeUnknown)
		{
			plDemoDebugFile::Write( "   Removing unknown device. Description", (char *)fRecords[ i ].GetDriverDesc() );
			fRecords[i].SetDiscarded(true);
		}
		else if( fRecords[i].GetG3DDeviceType() == hsG3DDeviceSelector::kDevTypeDirect3D ||
				 fRecords[i].GetG3DDeviceType() == hsG3DDeviceSelector::kDevTypeDirect3DTnL )
		{
			UInt32		totalMem;
			char		devDesc[ 256 ];


			// For our 3dfx test later
			strncpy( devDesc, fRecords[i].GetDriverDesc(), sizeof( devDesc ) - 1 );
			hsStrLower( devDesc );		

			// Remove software Direct3D devices
			if ((fRecords[i].GetG3DHALorHEL() != hsG3DDeviceSelector::kHHD3DHALDev) &&
			    (fRecords[i].GetG3DHALorHEL() != hsG3DDeviceSelector::kHHD3DTnLHalDev) &&
				(fRecords[i].GetG3DHALorHEL() != hsG3DDeviceSelector::kHHD3D3dfxDev) &&
				(fRecords[i].GetG3DHALorHEL() != hsG3DDeviceSelector::kHHD3D3dfxVoodoo5Dev) 
#ifdef HS_ALLOW_D3D_REF_DRIVER
				&& (fRecords[i].GetG3DHALorHEL() != hsG3DDeviceSelector::kHHD3DRefDev) 
#endif
				)
			{
				plDemoDebugFile::Write( "   Removing software Direct3D device. Description", (char *)fRecords[ i ].GetDriverDesc() );
				fRecords[i].SetDiscarded(true);
			}
			// Remove 3Dfx Direct3D devices, take 2
			// 10.13.2000 mcn - Now we do it even when we're wimpy
			// 10.25.2000 mcn - Think again.
			// 11.3.2000 mcn - Shesh, is this EVER going to be stable??
			else if( bTough && fRecords[i].GetG3DHALorHEL() == hsG3DDeviceSelector::kHHD3D3dfxDev )
//			else if( bTough && ( strstr( devDesc, "3dfx" ) || strstr( devDesc, "voodoo" ) ) )
			{
				plDemoDebugFile::Write( "   Removing 3Dfx non-Voodoo5 Direct3D device (We only support Glide on 3Dfx). Description", (char *)fRecords[ i ].GetDriverDesc() );
				fRecords[i].SetDiscarded(true);
			}
			// Remove Direct3D devices with less than 11 megs of RAM
			else if (bTough && ( totalMem = IAdjustDirectXMemory( fRecords[i].GetMemoryBytes() ) ) < 11*1024*1024 )
			{
				char str[ 256 ];
				sprintf( str, "   Removing Direct3D device with < 11MB RAM. Device RAM (in kB): %d (Description: %s)",
										totalMem / 1024, fRecords[ i ].GetDriverDesc() );
				plDemoDebugFile::Write( str );
				fRecords[i].SetDiscarded(true);
			}
			else
			{
				if( fRecords[i].GetG3DDeviceType() == hsG3DDeviceSelector::kDevTypeDirect3DTnL )
					plDemoDebugFile::Write( "   Keeping DX8 Direct3D device", (char *)fRecords[ i ].GetDriverDesc() );
				else
					plDemoDebugFile::Write( "   Keeping Direct3D device", (char *)fRecords[ i ].GetDriverDesc() );
			}
		}
		else
			plDemoDebugFile::Write( "   Keeping device", (char *)fRecords[ i ].GetDriverDesc() );
	}

	RemoveDiscarded();
}

//// IAdjustDirectXMemory /////////////////////////////////////////////////////
//	Adjusts the number coming off of the DirectX caps for "total video memory"
//	to be more reflective of what is really on the board. According to
//	Microsoft, the best way to do this is to add in the memory necessary for
//	the entire desktop. Okay, whatever...

UInt32	hsG3DDeviceSelector::IAdjustDirectXMemory( UInt32 cardMem )
{
#if HS_BUILD_FOR_WIN32
	HDC			deskDC;
	int			width, height, bpp, total;

	deskDC = GetDC( nil );
	width = GetDeviceCaps( deskDC, HORZRES );
	height = GetDeviceCaps( deskDC, VERTRES );
	bpp = GetDeviceCaps( deskDC, BITSPIXEL );
	
	total = width * height;
	if( bpp > 8 )
		total *= ( bpp >> 3 );

	return cardMem + total;
#else
	return	cardMem;
#endif
}

hsBool	hsG3DDeviceSelector::Init( void )
{
	// See if we're all capable of initing
	if( !IInitDirect3D() )
	{
		return false;
	}

	return true;
}

void hsG3DDeviceSelector::Enumerate(hsWinRef winRef)
{
	Clear();

#ifdef HS_BUILD_FOR_WIN32
	/// 9.6.2000 - Create the class to use as our temporary window class
	WNDCLASS	tempClass;

	strcpy( fTempWinClass, "DSTestClass" );
	memset( &tempClass, 0, sizeof( tempClass ) );
	tempClass.lpfnWndProc = DefWindowProc;
	tempClass.hInstance = GetModuleHandle( nil );
	tempClass.hbrBackground = (HBRUSH)GetStockObject( BLACK_BRUSH );
	tempClass.lpszClassName = fTempWinClass;
	UInt16 ret = RegisterClass(&tempClass);
	hsAssert(ret, "Cannot create temporary window class to test for device modes" );
#endif

	/// Now try our devices
#ifdef HS_SELECT_DX7
	ITryDirect3D(winRef);
#endif // HS_SELECT_DX7

	ITryDirect3DTnL(winRef);

//	ITryOpenGL(winRef);

#ifdef HS_BUILD_FOR_WIN32
	/// Get rid of the class
	UnregisterClass( fTempWinClass, GetModuleHandle( nil ) );
#endif
}

hsBool hsG3DDeviceSelector::GetDefault (hsG3DDeviceModeRecord *dmr)
{
	Int32 iTnL, iD3D, iOpenGL, device, mode, i;
	device = iTnL = iD3D = iOpenGL = mode = -1;

	if (device == -1)
	{
		// Get an index for any 3D devices
		for (i = 0; i < fRecords.GetCount(); i++)
		{
			switch (fRecords[i].GetG3DDeviceType())
			{
			case kDevTypeDirect3D:
			case kDevTypeDirect3DTnL:
				if (fRecords[i].GetG3DHALorHEL() == kHHD3DTnLHalDev)
				{
					if (iTnL == -1 
#ifndef PLASMA_EXTERNAL_RELEASE
						|| plPipeline::fInitialPipeParams.ForceSecondMonitor
#endif // PLASMA_EXTERNAL_RELEASE
						)
					{
						iTnL = i;
					}
				}
				else if (fRecords[i].GetG3DHALorHEL() == kHHD3DHALDev || fRecords[i].GetG3DHALorHEL() == kHHD3D3dfxVoodoo5Dev )
				{
					if (iD3D == -1
#ifndef PLASMA_EXTERNAL_RELEASE
						|| plPipeline::fInitialPipeParams.ForceSecondMonitor
#endif // PLASMA_EXTERNAL_RELEASE
						)
					{
						iD3D = i;
					}
				}
				break;

			case kDevTypeOpenGL:
				if (iOpenGL == -1 
#ifndef PLASMA_EXTERNAL_RELEASE					
					|| plPipeline::fInitialPipeParams.ForceSecondMonitor
#endif // PLASMA_EXTERNAL_RELEASE					
					)
				{
					iOpenGL = i;
				}
				break;
			}
		}

		// Pick a default device (Priority D3D T&L, D3D HAL, OpenGL)
		if (iTnL != -1)
			device = iTnL;
		else if (iD3D != -1)
			device = iD3D;
		else if (iOpenGL != -1)
			device = iOpenGL;
		else
			return false;
	}

	//
	// Try and find the default mode
	//
	hsTArray<hsG3DDeviceMode>& modes = fRecords[device].GetModes();

	// If there are no modes (for some insane reason), fail
	if (modes.GetCount() == 0)
		return false;

	for (i = 0; i < modes.GetCount(); i++)
	{
		if ((modes[i].GetWidth()	== kDefaultWidth) &&
		    (modes[i].GetHeight()	== kDefaultHeight) &&
			(modes[i].GetNumZStencilDepths() > 0))
		{
			// Don't be too picky about the depth, use what's available if the
			// default isn't found.
			if (mode == -1 || modes[mode].GetColorDepth() != kDefaultDepth)
				mode = i;
		}
	}
	// Default mode not found, what kind of card is this?!
	// Regardless, just use the first mode since this isn't a fatal error.
	if (mode == -1)
		mode = 0;

	*dmr = hsG3DDeviceModeRecord(fRecords[device], modes[mode]);

	return true;
}

//// ITryOpenGL ///////////////////////////////////////////////////////////////
//	Updated 8.24.2000 mcn to (hopefully) detect OpenGL drivers.

void hsG3DDeviceSelector::ITryOpenGL(hsWinRef winRef)
{
#ifdef HS_OPEN_GL
#if HS_BUILD_FOR_WIN32
	int					i, numDrivers;
	int					modeRes[ 6 ][ 3 ] = { { 640, 480, 16 }, { 800, 600, 16 }, { 1024, 768, 16 }, 
												{ 1152, 864, 16 }, { 1280, 1024, 16 }, { 1600, 1200, 16 } };
	gls_driver_info		driverInfo;
	hsG3DDeviceRecord	devRec;
	hsG3DDeviceMode		devMode;
	char				str[ 128 ];
	HDC					hDC;
	HGLRC				tempContext;
	HWND				testWindow = nil, testWindow2 = nil;

	WINDOWPLACEMENT			oldWindowPlace;


	/// Save old window position
	oldWindowPlace.length = sizeof( oldWindowPlace );
	GetWindowPlacement( (HWND)winRef, &oldWindowPlace );

	/// Use the GLS API to get us a list of all OpenGL drivers available on
	/// this system and their capabilities
	numDrivers = glsGetNumberOfDrivers();
	for( i = 0; i < numDrivers; i++ )
	{
		/// Get main driver info
		glsGetDriverInfo( i, &driverInfo );

		devRec.SetG3DDeviceType( kDevTypeOpenGL );

		devRec.SetDriverDesc( driverInfo.aDriverDescription );
		devRec.SetDriverName( driverInfo.GLDriver.aDriverFilePath );

		sprintf( str, "%d.%d", driverInfo.GLDriver.DriverFileVersionHigh, 
								driverInfo.GLDriver.DriverFileVersionLow );
		devRec.SetDriverVersion( str );
		
		devRec.SetCap( kCapsMipmap );
		devRec.SetCap( kCapsMipmap );
		devRec.SetCap( kCapsPerspective );

		if( driverInfo.DriverFlags & GLS_FLAGS_FULLSCREEN_ONLY )
			devRec.SetCap( kCapsNoWindow );
		if( !( driverInfo.DriverFlags & GLS_FLAGS_SOFTWARE_ONLY ) )
			devRec.SetCap( kCapsHardware );
		devRec.SetCap( kCapsDoesSmallTextures );

		/// We have a problem here--OpenGL has no way of detecting the rest of
		/// the information we want, so we'll have to guess/kludge on most of it.

		glsLoadDriver( i );
		sprintf( str, "ITryOpenGL(): FOUND OpenGL Driver: %s (%s)\n", driverInfo.aDriverDescription,
						driverInfo.GLDriver.aDriverFilePath );
		hsStatusMessage( str );

		/// (and of COURSE we have to open a bloody rendering context for 
		///  glGetString to work...whose bright idea was THAT?)
		testWindow = CreateWindowEx( WS_EX_APPWINDOW, fTempWinClass, "OpenGL Screen Test Window", 
										WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE,
										0, 0, 640, 480, nil, nil, GetModuleHandle( nil ), 0 );
		hDC = GetDC( testWindow );
		tempContext = (HGLRC)ICreateTempOpenGLContext( hDC, 
								driverInfo.DriverFlags & GLS_FLAGS_FULLSCREEN_ONLY ); 
		if( tempContext != nil )
		{
			wglMakeCurrent( hDC, tempContext );

			IGetExtOpenGLInfo( devRec );

			/// Reset everything back now
			wglMakeCurrent( nil, nil );
			wglDeleteContext( tempContext );
			ReleaseDC( testWindow, hDC );
		}

		/// Resize window to hide what we're about to do
		SetWindowPos( testWindow, nil, 0, 0, 1600, 1200, SWP_NOZORDER | SWP_NOMOVE );

		/// Check for windowed screen mode (which SOMEBODY decided to test for
		/// bitdepth of 0 instead of the caps flag we're setting....hmmmm wasn't me....)
		if( !( driverInfo.DriverFlags & GLS_FLAGS_FULLSCREEN_ONLY ) )
		{
			devMode.Clear();
			devMode.SetWidth( 0 );
			devMode.SetHeight( 0 );
			devMode.SetColorDepth( 0 );
			devRec.GetModes().Append( devMode );
		}
		
		/// Go get the screen modes
		IGetOpenGLModes( devRec, driverInfo.aDriverDescription );

		/// Get rid of the window now
		DestroyWindow( testWindow );

		/// Unload this driver now
		glsUnloadDriver();
	}

	/// Restore old window position
	SetWindowPlacement( (HWND)winRef, &oldWindowPlace );
#endif
#endif
}

//// IGetOpenGLModes //////////////////////////////////////////////////////////
//	Scans through all the possible imaginable combinations of screen modes,
//	pixel formats whatnot and adds the final, culled-down list of graphics
//	modes to the given device record.

void	hsG3DDeviceSelector::IGetOpenGLModes( hsG3DDeviceRecord &devRec, char *driverName )
{
#ifdef HS_OPEN_GL
#if HS_BUILD_FOR_WIN32
	int					j;
	int					maxMode, mode;
	int					modeRes[ 6 ][ 3 ] = { { 640, 480, 16 }, { 800, 600, 16 }, { 1024, 768, 16 }, 
												{ 1152, 864, 16 }, { 1280, 1024, 16 }, { 1600, 1200, 16 } };
	int					bitDepths[ 3 ] = { 32, 24, 16 }, bitDepth;
	hsG3DDeviceMode		devMode;
	DEVMODE				modeInfo;
	HWND				testWindow = nil, testWindow2 = nil;
	char				str[ 128 ];

	
	/// Find the maximum resolution that we can support on this monitor--then
	/// we'll start there and work down until we find a mode supported by OpenGL
	modeInfo.dmSize = sizeof( modeInfo );
	maxMode = -1;
	for( j = 0; EnumDisplaySettings( nil, j, &modeInfo ) != 0; j++ )
	{
		for( mode = 0; mode < sizeof( modeRes ) / sizeof( modeRes[ 0 ] ); mode++ )
		{
			if( modeRes[ mode ][ 0 ] == modeInfo.dmPelsWidth &&
				modeRes[ mode ][ 1 ] == modeInfo.dmPelsHeight )
			{
				if( modeInfo.dmBitsPerPel > modeRes[ mode ][ 2 ] )
					modeRes[ mode ][ 2 ] = modeInfo.dmBitsPerPel;

				if( mode > maxMode )
				{
					maxMode = mode;
					break;
				}
			}
		}
	}
	if( maxMode != -1 )
	{
		/// Outer loop: loop through color depths
		for( bitDepth = 0; bitDepth < 3; bitDepth++ )
		{
			/// Loop through each of the display settings, starting at
			/// the maxMode and going down, happily get pixel formats for each
			modeInfo.dmSize = sizeof( modeInfo );
			modeInfo.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
			for( mode = maxMode; mode >= 0; mode-- )
			{
				/// Does this resolution work at this bit depth?
				if( modeRes[ mode ][ 2 ] < bitDepths[ bitDepth ] )
					continue;

				/// Attempt to set this screen mode
				modeInfo.dmPelsWidth = modeRes[ mode ][ 0 ];
				modeInfo.dmPelsHeight = modeRes[ mode ][ 1 ];
				modeInfo.dmBitsPerPel = bitDepths[ bitDepth ];
				if( ChangeDisplaySettings( &modeInfo, CDS_FULLSCREEN ) == DISP_CHANGE_SUCCESSFUL )
				{
					if( ITestOpenGLRes( modeRes[ mode ][ 0 ], modeRes[ mode ][ 1 ],
									bitDepths[ bitDepth ],
									devRec, driverName ) )
					{
						/// Go and add the rest of 'em (we just assume that we can get
						/// lower resolutions if we got this one)
						for( mode--; mode >= 0; mode-- )
						{
							devMode.SetWidth( modeRes[ mode ][ 0 ] );
							devMode.SetHeight( modeRes[ mode ][ 1 ] );
							devMode.SetColorDepth( bitDepths[ bitDepth ] );
							devRec.GetModes().Append( devMode );

							sprintf( str, "ITryOpenGL(): Assuming mode: %dx%dx%dbpp, %s\n", 
										modeRes[ mode ][ 0 ], modeRes[ mode ][ 1 ], bitDepths[ bitDepth ], driverName );
							hsStatusMessage( str );
						}
					}
				}
			}
		}

		/// Note: this will also reset the screen after any mode changes from
		/// creating our context
		ChangeDisplaySettings( nil, 0 );

		if( devRec.GetModes().GetCount() )
			fRecords.Append( devRec );
	}
#endif
#endif
}

//// ITestOpenGLRes ///////////////////////////////////////////////////////////
//	Tests all the possible OpenGL settings once the screen has been set
//	to a given test resolution.

hsBool hsG3DDeviceSelector::ITestOpenGLRes( int width, int height, int bitDepth,
											hsG3DDeviceRecord &devRec, char *driverName )
{
	hsBool				retValue = false;

#ifdef HS_OPEN_GL
#if HS_BUILD_FOR_WIN32
	int					j, bitDepthFlags, myBitDepth;
	hsG3DDeviceMode		devMode;
	char				str[ 128 ];
	HDC					hDC, hDC2;
	HGLRC				tempContext;
	HWND				testWindow = nil, testWindow2 = nil;

	PIXELFORMATDESCRIPTOR	pfd;

	
	/// Create test window #1
	testWindow = CreateWindowEx( WS_EX_APPWINDOW, fTempWinClass, "OpenGL Screen Test Window", 
								WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE,
								0, 0, width, height,
								nil, nil, GetModuleHandle( nil ), 0 );
	hDC = GetDC( testWindow );

	/// Loop through using DescribePixelFormat in an attempt to find all the
	/// pixel formats we actually do support using this OpenGL driver
	devMode.Clear();
	pfd.nSize = sizeof( pfd );
	bitDepthFlags = 0;
	for( j = 1; retValue == false && DescribePixelFormat( hDC, j, sizeof( pfd ), &pfd ) != 0; j++ )
	{
		/// Can we use this one?
		if( pfd.cColorBits != bitDepth )
			continue;

		myBitDepth = ( pfd.cColorBits == 32 ) ? 0x04 : ( pfd.cColorBits == 24 ) ? 0x02 : 0x01;

		if( ( pfd.dwFlags & PFD_SUPPORT_OPENGL ) &&
			( pfd.dwFlags & PFD_DRAW_TO_WINDOW ) &&
			( pfd.dwFlags & PFD_DOUBLEBUFFER ) &&
			( pfd.iPixelType == PFD_TYPE_RGBA ) &&
			( pfd.iLayerType == PFD_MAIN_PLANE ) &&
			( ( bitDepthFlags & myBitDepth ) == 0 ) )
		{
			/// Looks like it! But is it REALLY?
			testWindow2 = CreateWindowEx( WS_EX_APPWINDOW, fTempWinClass, "OpenGL Screen Test Window #2", 
										WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE,
										0, 0, width, height,
										nil, nil, GetModuleHandle( nil ), 0 );
			hDC2 = GetDC( testWindow2 );

			if( SetPixelFormat( hDC2, j, &pfd ) )
			{
				tempContext = wglCreateContext( hDC2 );
				if( tempContext != nil )
				{
					if( wglMakeCurrent( hDC2, tempContext ) )
					{
						/// Guess it really does work...
						devMode.SetWidth( width );
						devMode.SetHeight( height );
						devMode.SetColorDepth( pfd.cColorBits );
						devRec.GetModes().Append( devMode );
						bitDepthFlags |= myBitDepth;

						sprintf( str, "ITryOpenGL(): Adding mode: %dx%dx%dbpp, %s\n", 
										width, height, pfd.cColorBits, driverName );
						hsStatusMessage( str );

						wglMakeCurrent( nil, nil );
						retValue = true;		/// Break us out
					}
					wglDeleteContext( tempContext );
				}
			}
			ReleaseDC( testWindow2, hDC2 );
			DestroyWindow( testWindow2 );
		}
	}
	ReleaseDC( testWindow, hDC );
	DestroyWindow( testWindow );

#endif
#endif
	return retValue;
}


//// IGetExtOpenGLInfo ////////////////////////////////////////////////////////
//	Gets extended info--i.e. info requiring an OpenGL context. Assumes the
//	said context is already created and active.

void	hsG3DDeviceSelector::IGetExtOpenGLInfo( hsG3DDeviceRecord &devRec )
{
#ifdef HS_OPEN_GL
#if HS_BUILD_FOR_WIN32
	GLint	numTMUs;
	char	*extString, *c, *c2;
	char	str[ 128 ];
	int		j;


	if( ( extString = (char *)glGetString( GL_RENDERER ) ) != nil )
	{
		devRec.SetDeviceDesc( extString );

		/// Can we guess at the amount of texture memory?
		c = strstr( extString, "MB" );
		if( c != nil && c != extString && ( isdigit( *( c - 1 ) ) || isspace( *( c - 1 ) ) ) )
		{
			/// Looks like we found a "xxMB" texture memory specification--use it
			/// as our guess
			c2 = c;
			do {
				c2--;
			} while( c2 >= extString && ( isdigit( *c2 ) || isspace( *c2 ) ) );
			c2++;
			
			strncpy( str, c2, (UInt32)c - (UInt32)c2 );
			j = atoi( str );
			sprintf( str, "ITryOpenGL():   Device has %d MB texture memory\n", j );
			hsStatusMessage( str );

			j *= 1024 * 1024;		/// Translate to bytes
			devRec.SetMemoryBytes( j );
		}
		else
		{
			devRec.SetMemoryBytes( 4 * 1024 * 1024 );
			hsStatusMessage( "ITryOpenGL():   WARNING: Cannot determine texture memory for this card, assuming 4MB\n" );
		}
	}
	else
	{
		devRec.SetDeviceDesc( "" );
		devRec.SetMemoryBytes( 4 * 1024 * 1024 );
		hsStatusMessage( "ITryOpenGL():   WARNING: Cannot determine texture memory for this card, assuming 4MB\n" );
	}


	if( ( extString = (char *)glGetString( GL_EXTENSIONS ) ) != nil )
	{
		/// For the number of TMUs, we'll detect for the availability of the 
		/// multitexture extension--if it's there, we'll assume we have two TMUs
		/// (if we don't, OpenGL will probably handle it for us--or rather, it BETTER).
		if( strstr( extString, "ARB_multitexture" ) )
			devRec.SetLayersAtOnce( 2 );
		else
			devRec.SetLayersAtOnce( 1 );

		/// Can we use compressed textures?
		if( strstr( extString, "ARB_texture_compression" ) )
			devRec.SetCap( kCapsCompressTextures );
	}

	/// Get TMU count
	glGetIntegerv( GL_MAX_TEXTURE_UNITS_ARB, &numTMUs );	
	if( numTMUs <= 0 )
		numTMUs = 0;
	devRec.SetLayersAtOnce( numTMUs );
#endif
#endif
}

//// ICreateTempOpenGLContext /////////////////////////////////////////////////
//	Creates a temporary context for testing OpenGL stuff with.

#ifdef HS_OPEN_GL
#if HS_BUILD_FOR_WIN32

UInt32	hsG3DDeviceSelector::ICreateTempOpenGLContext( HDC hDC, hsBool32 makeItFull )
{
	DEVMODE		modeInfo;
	int			pixFmt;


	if( makeItFull )
	{
		/// Attempt resolution change to 640x480x32bpp
		memset( &modeInfo, 0, sizeof( modeInfo ) );
		modeInfo.dmSize = sizeof( modeInfo );
		modeInfo.dmBitsPerPel = 16;
		modeInfo.dmPelsWidth = 640;
		modeInfo.dmPelsHeight = 480;
		if( ChangeDisplaySettings( &modeInfo, CDS_FULLSCREEN ) != DISP_CHANGE_SUCCESSFUL )
		{
			return nil;			/// We want fullscreen, can't get it, oops.
		}
	}

	/// Now try to set a pixel format
	PIXELFORMATDESCRIPTOR pfd = { 
		sizeof(PIXELFORMATDESCRIPTOR),    // size of this pfd 
		1,                                // version number 
		PFD_DRAW_TO_WINDOW |              // support window 
		PFD_SUPPORT_OPENGL |              // support OpenGL 
		PFD_DOUBLEBUFFER,                 // double buffered 
		PFD_TYPE_RGBA,                    // RGBA type 
		16,                               // 24-bit color depth 
		0, 0, 0, 0, 0, 0,                 // color bits ignored 
		0,                                // no alpha buffer 
		0,                                // shift bit ignored 
		0,                                // no accumulation buffer 
		0, 0, 0, 0,                       // accum bits ignored 
		0,                                // 32-bit z-buffer     
		0,                                // no stencil buffer 
		0,								  // no auxiliary buffer 
		PFD_MAIN_PLANE,        // main layer 
		0,                     // reserved 
		0, 0, 0                // layer masks ignored 
		}; 

	pixFmt = ChoosePixelFormat( hDC, &pfd );
	if( pixFmt > 0 && SetPixelFormat( hDC, pixFmt, &pfd ) )
		return (UInt32)wglCreateContext( hDC );

	return 0;
}
#endif
#endif

///////////////////////////////////////////////////////////////////////////////
//// Fudging Routines /////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

namespace
{
	/// Here's our CFT--Chipset Fudgefactor Table
	/// The table consists of entries for each of our supported chipsets in the table,
	/// plus, flags to be forced set and flags to be forced cleared. Also included
	/// is a Z-buffer suckiness rating, which represents how badly we need to bias
	/// the z and w values to avoid z-buffer artifacts, stored as an hsScalar (i.e
	///	a float). A rating of 0 means very good/default (read: Nvidia), while, say, 
	///	a 9.0 (i.e. shift the scale 9 times above normal) means s****y, like, say, 
	///	a Savage4. Also also included is a forced value for max # of layers (0 means 
	///	to use default). Also also also included is an LOD rating indicating how much 
	///	(and in which direction) to alter the base LOD bias value for this device. General
	///	interpretation of this value is to add (-lodRating) to the LOD bias value.
	///	This is because the LOD bias starts out negative and typically goes in 0.25
	///	increments.
	/// Also also ALSO included are three new values for fog tweaking. The first two--
	///	fFogExp/Exp2ApproxStart, are the start of the linear approximation of exponential
	///	fog. Tweak these to adjust the linear approximation on any cards that don't support
	///	exponential and exponential-squared fog natively. The third value is the fFogEndBias--
	///	this is a value (stored as a percentage of the max possible fog value) to add on to
	///	to the linear fog-end parameter AFTER ALL CALCULATIONS. This is so we can, for
	///	example, tweak the end of the fog on the ATI Rage cards to not fog out as quickly.
	///	9.14.2000 - fog end bias now has a new meaning. What it *really* represents is the
	/// quantization of fog on a particular card, where the end bias = ( 2^bitdepth - 2 ) / ( 2^bitdepth - 1 )
	/// So, for 8 bit fog, we end up with 254 / 255, etc. So far, everything is set to 8
	/// bit fog, but we have it here just in case we need to change it in the future.

	enum {
		kDefaultChipset = 0x00,
		kSavage4Chipset,
		kATIRageFuryChipset,
		kATIRageProChipset,
		kNVidiaTNTChipset,
		kNVidiaGeForceChipset,
		kMatroxG400Chipset,
		kIntelI810Chipset,
		kSavage2000Chipset,
		kS3GenericChipset,
		kATIGenericChipset,
		kMatroxGenericChipset,
		kKYROChipset,
		k3dfxV5Chipset,
		kSavage3DChipset,
		kATIRadeonChipset,
		kATIR7X00Chipset,
		kATIR7500Chipset,
		kATIR8X00Chipset,
		kMatroxParhelia,
		kNVidiaGeForce2Chipset,
		kNVidiaGeForce3Chipset,
		kNVidiaGeForce4MXChipset,
		kNVidiaGeForce4Chipset,
		kNVidiaGeForceFXChipset
	};

	typedef struct
	{
		hsScalar	fFogExpApproxStart;
		hsScalar	fFogExp2ApproxStart;
		hsScalar	fFogEndBias;
		hsScalar	fFogExpKnee;		// Fog knees
		hsScalar	fFogExpKneeVal;
		hsScalar	fFogExp2Knee;
		hsScalar	fFogExp2KneeVal;
	} FogTweakTable;

	FogTweakTable	dsDefaultFogVals =	{ 0,	0,		254.0 / 255.0,	0.5f, 0.15f, 0.5f, 0.15f };
	FogTweakTable	dsATIFogVals =		{ 0.1f, 0.1f,	254.0 / 255.0,	0.85f, 0.15f, 0.5f, 0.15f };
	FogTweakTable	dsS3DFogVals =		{ 0,	0,		254.0 / 255.0,	1.0f, 1.0f,	 1.0f, 1.0f  };
	FogTweakTable	dsi810FogVals =		{ 0,	0,		254.0 / 255.0,	0.6f, 0.15f, 0.4f, 0.15f };
	FogTweakTable	dsRadeonFogVals =	{ 0,	0,		254.0 / 255.0,	0.7f, 0.15f, 0.5f, 0.2f };


	typedef struct {
		UInt8			fType;				// Our chipset ID
		UInt32			*fFlagsToSet;		
		UInt32			*fFlagsToClear;
		hsScalar		fZSuckiness;		// See above
		UInt32			fForceMaxLayers;	// The max # of layers we REALLY want (0 to not force)
		hsScalar		fLODRating;
		FogTweakTable	*fFogTweaks;
	} CFTable;

	UInt32	dsSavageCapsClr[] = {
					4,				// First integer is always the length
					hsG3DDeviceSelector::kCapsCompressTextures,
					hsG3DDeviceSelector::kCapsFogExp,
					hsG3DDeviceSelector::kCapsFogExp2,
					hsG3DDeviceSelector::kCapsDoesSmallTextures };

	UInt32	dsSavageCapsSet[] = {
					1,				// First integer is always the length
					hsG3DDeviceSelector::kCapsBadYonStuff };
					
	UInt32	dsSavage2kCapsClr[] = {
					5,				// First integer is always the length
					hsG3DDeviceSelector::kCapsCompressTextures,
					hsG3DDeviceSelector::kCapsPixelFog,
					hsG3DDeviceSelector::kCapsFogExp,
					hsG3DDeviceSelector::kCapsFogExp2,
					hsG3DDeviceSelector::kCapsDoesSmallTextures };

	UInt32	dsS3GenerCapsClr[] = {
					4,				// First integer is always the length
					hsG3DDeviceSelector::kCapsCompressTextures,
					hsG3DDeviceSelector::kCapsFogExp,
					hsG3DDeviceSelector::kCapsFogExp2,
					hsG3DDeviceSelector::kCapsDoesSmallTextures };

	UInt32	dsATIFuryCapsClr[] = {
					3,				// First integer is always the length
					hsG3DDeviceSelector::kCapsFogExp,
					hsG3DDeviceSelector::kCapsFogExp2,
					hsG3DDeviceSelector::kCapsPixelFog };

	UInt32	dsATIRageCapsClr[] = {
					4,				// First integer is always the length
					hsG3DDeviceSelector::kCapsFogExp,
					hsG3DDeviceSelector::kCapsFogExp2,
					hsG3DDeviceSelector::kCapsDoesSmallTextures,
					hsG3DDeviceSelector::kCapsPixelFog };

	UInt32	dsATIGenerCapsClr[] = {
					4,				// First integer is always the length
					hsG3DDeviceSelector::kCapsPixelFog,
					hsG3DDeviceSelector::kCapsFogExp,
					hsG3DDeviceSelector::kCapsFogExp2,
					hsG3DDeviceSelector::kCapsDoesSmallTextures };

	UInt32	dsATIRadeonCapsSet[] = {
					2,				// First integer is always the length
						hsG3DDeviceSelector::kCapsBadManaged,
						hsG3DDeviceSelector::kCapsShareDepth
					};

	UInt32	dsATIRadeonCapsClr[] = {
					2,				// First integer is always the length
					hsG3DDeviceSelector::kCapsWBuffer,
					hsG3DDeviceSelector::kCapsDoesSmallTextures };

	UInt32	dsATIR7X00CapsSet[] = {
					4,				// First integer is always the length
						hsG3DDeviceSelector::kCapsCantShadow,
						hsG3DDeviceSelector::kCapsBadManaged,
						hsG3DDeviceSelector::kCapsShareDepth,
						hsG3DDeviceSelector::kCapsNoAniso
					};

	UInt32	dsATIR7500CapsSet[] = {
					5,				// First integer is always the length
						hsG3DDeviceSelector::kCapsMaxUVWSrc2,
						hsG3DDeviceSelector::kCapsCantShadow,
						hsG3DDeviceSelector::kCapsBadManaged,
						hsG3DDeviceSelector::kCapsShareDepth,
						hsG3DDeviceSelector::kCapsNoAniso
					};

	UInt32	dsATIR7X00CapsClr[] = {
					2,				// First integer is always the length
					hsG3DDeviceSelector::kCapsWBuffer,
					hsG3DDeviceSelector::kCapsDoesSmallTextures };

	UInt32	dsATIR8X00CapsSet[] = {
					2,				// First integer is always the length
						hsG3DDeviceSelector::kCapsBadManaged,
						hsG3DDeviceSelector::kCapsShareDepth
					};

	UInt32	dsATIR8X00CapsClr[] = {
					2,				// First integer is always the length
					hsG3DDeviceSelector::kCapsWBuffer,
					hsG3DDeviceSelector::kCapsDoesSmallTextures };

	UInt32	dsTNTCapsClr[] = {
					1,				// First integer is always the length
					hsG3DDeviceSelector::kCapsDoesSmallTextures };

	UInt32	dsDefaultCapsClr[] = {
					1,				// First integer is always the length
					hsG3DDeviceSelector::kCapsDoesSmallTextures };

	UInt32	dsMG400CapsClr[] = {
					1,				// First integer is always the length
					hsG3DDeviceSelector::kCapsDoesSmallTextures };

	UInt32	dsKYROCapsClr[] = {
					2,				// First integer is always the length
					hsG3DDeviceSelector::kCapsDoesSmallTextures,
					hsG3DDeviceSelector::kCapsPixelFog };

	UInt32	dsKYROCapsSet[] = {
					1,				// First integer is always the length
					hsG3DDeviceSelector::kCapsNoKindaSmallTexs };

	UInt32	ds3dfxV5CapsClr[] = {
					2,				// First integer is always the length
					hsG3DDeviceSelector::kCapsFogExp,
					hsG3DDeviceSelector::kCapsFogExp2 };

	UInt32	dsMatroxParheliaSet[] = {
					1,
						hsG3DDeviceSelector::kCapsNoAA };

	UInt32	dsGeForceSet[] = {
					2,
						hsG3DDeviceSelector::kCapsCantProj,
						hsG3DDeviceSelector::kCapsDoubleFlush };

	UInt32	dsGeForce2Set[] = {
					1,
						hsG3DDeviceSelector::kCapsDoubleFlush };

	UInt32	dsGeForce3Set[] = {
					1,
						hsG3DDeviceSelector::kCapsSingleFlush };

	UInt32	dsGeForce4MXSet[] = {
					1,
						hsG3DDeviceSelector::kCapsSingleFlush };

	UInt32	dsGeForce4Set[] = {
					1,
						hsG3DDeviceSelector::kCapsSingleFlush
					};

	CFTable	dsCFTable[] = 
		{ 
			// Chipset ID			// F2Set			// F2Clear			// ZSuck	// MaxLayers	// LODBias		// Fog Value Tables
			{ kDefaultChipset,		nil,				dsDefaultCapsClr,	0,			0,				0,				&dsDefaultFogVals },
			{ kATIRageFuryChipset,	nil,				dsATIFuryCapsClr,	4.25f,		1,				0,				&dsATIFogVals },
			{ kATIRageProChipset,	nil,				dsATIRageCapsClr,	4.25f,		1,				0,				&dsATIFogVals },
			{ kATIGenericChipset,	nil,				dsATIGenerCapsClr,	4.25f,		1,				0,				&dsATIFogVals },
			{ kNVidiaTNTChipset,	nil,				dsTNTCapsClr,		0,			0,				0,				&dsDefaultFogVals },
			{ kNVidiaGeForce2Chipset,dsGeForce2Set,		nil,				0,			0,				0,				&dsDefaultFogVals },
			{ kNVidiaGeForce3Chipset,dsGeForce3Set,		nil,				0,			0,				0,				&dsDefaultFogVals },
			{ kNVidiaGeForce4MXChipset,dsGeForce4MXSet,	nil,				0,			0,				0,				&dsDefaultFogVals },
			{ kNVidiaGeForce4Chipset,dsGeForce4Set,		nil,				0,			0,				0,				&dsDefaultFogVals },
			{ kNVidiaGeForceChipset,dsGeForceSet,		nil,				0,			0,				0,				&dsDefaultFogVals },
			{ kNVidiaGeForceFXChipset,nil,				nil,				0,			0,				0,				&dsDefaultFogVals },
			{ kMatroxG400Chipset,	nil,				dsMG400CapsClr,		3.25f,		0,				0,				&dsDefaultFogVals },
			{ kMatroxParhelia,		dsMatroxParheliaSet,nil,				0,			0,				0,				&dsDefaultFogVals },
			{ kMatroxGenericChipset,nil,				dsMG400CapsClr,		3.25f,		0,				0,				&dsDefaultFogVals },
			{ kIntelI810Chipset,	nil,				dsDefaultCapsClr,	4.5f,		1,				-0.5f,			&dsi810FogVals },
			{ kSavage4Chipset,		dsSavageCapsSet,	dsSavageCapsClr,	4.0f,		1,				0,				&dsDefaultFogVals },		// LOD bias should be -0.5 here
			{ kSavage2000Chipset,	dsSavageCapsSet,	dsSavage2kCapsClr,	4.0f,		1,				0,				&dsDefaultFogVals },
			{ kS3GenericChipset,	dsSavageCapsSet,	dsS3GenerCapsClr,	4.0f,		1,				0,				&dsDefaultFogVals },
			{ kKYROChipset,			dsKYROCapsSet,		dsKYROCapsClr,		-151.0f,	1,				0,				&dsDefaultFogVals },
			{ k3dfxV5Chipset,		nil,				ds3dfxV5CapsClr,	3.5f,		0,				0,				&dsDefaultFogVals },
			{ kSavage3DChipset,		nil,				dsDefaultCapsClr,	0,			0,				0,				&dsS3DFogVals },
			{ kATIRadeonChipset,	dsATIRadeonCapsSet,	dsATIRadeonCapsClr,	0,			0,				0,				&dsRadeonFogVals },
			{ kATIR7X00Chipset,		dsATIR7X00CapsSet,	dsATIR7X00CapsClr,	3.f,		2,				0,				&dsRadeonFogVals  },
			{ kATIR7500Chipset,		dsATIR7500CapsSet,	dsATIR7X00CapsClr,	3.f,		2,				0,				&dsRadeonFogVals  },
			{ kATIR8X00Chipset,		dsATIR8X00CapsSet,	dsATIR8X00CapsClr,	0,			0,				0,				&dsRadeonFogVals  },
		};

};

//// IFudgeDirectXDevice //////////////////////////////////////////////////////
//	Checks this DirectX device against all our known types and fudges our caps 
//	flags and bias values, etc, accordingly

#ifdef HS_SELECT_DIRECT3D
void	hsG3DDeviceSelector::IFudgeDirectXDevice( hsG3DDeviceRecord &record,
													D3DEnum_DriverInfo *driverInfo,
													D3DEnum_DeviceInfo *deviceInfo )
{
	char		desc[ 512 ];	// Can't rely on D3D constant, since that's in another file now
	DWORD		vendorID, deviceID;
	char		*szDriver, *szDesc;


	/// Send it off to each D3D device, respectively
	if( record.GetG3DDeviceType() == kDevTypeDirect3DTnL )
	{
		if( !IGetD3DCardInfo( record, driverInfo, deviceInfo, &vendorID, &deviceID, &szDriver, &szDesc ) )
		{
			// {} to make VC6 happy in release build
			hsAssert( false, "Trying to fudge D3D device but D3D support isn't in this EXE!" );
		}
	}
#ifdef HS_SELECT_DX7
	else if( record.GetG3DDeviceType() == kDevTypeDirect3D )
	{
		if( !IGetD3D7CardInfo( record, driverInfo, deviceInfo, &vendorID, &deviceID, &szDriver, &szDesc ) )
		{
			// {} to make VC6 happy in release build
			hsAssert( false, "Trying to fudge D3D7 device but D3D7 support isn't in this EXE!" );
		}
	}
#endif // HS_SELECT_DX7
	else
	{
		hsAssert( false, "IFudgeDirectXDevice got a device type that support wasn't compiled for!" );
	}

	/// So capitalization won't matter in our tests
	hsAssert( strlen( szDesc ) < sizeof( desc ), "D3D device description longer than expected!" );
	hsStrcpy( desc, szDesc );
	hsStrLower( desc );	
		
	//// S3-based Cards ///////////////////////////////////////////////////////
	/// Detect Savage 4 chipset
	if( deviceID == 0x00008a22 || stricmp( szDriver, "s3savg4.dll" ) == 0 ||
		( strstr( desc, "diamond" ) != nil && strstr( desc, "stealth iii" ) != nil ) ||
		strstr( desc, "savage4 " ) != nil )
	{
		/// Yup, Savage 4.
		hsStatusMessage( "== Using fudge factors for a Savage 4 chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for a Savage 4 chipset" );
		ISetFudgeFactors( kSavage4Chipset, record );
	}
	/// Detect Savage 2000 chipset
	else if( deviceID == 0x00009102 || 
		stricmp( szDriver, "s3sav2k.dll" ) == 0 ||
		( strstr( desc, "diamond" ) != nil &&
	       strstr( desc, "viperii" ) != nil ) ||
		strstr( desc, "savage2000 " ) != nil )
	{
		/// Yup, Savage 2000.
		hsStatusMessage( "== Using fudge factors for a Savage 2000 chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for a Savage 2000 chipset" );
		ISetFudgeFactors( kSavage2000Chipset, record );
	}
	/// Detect Savage3D chipset
	else if( deviceID == 0x00008a20 || 
		stricmp( szDriver, "s3_6.dll" ) == 0 ||
		strstr( desc, "savage3d" ) != nil )
	{
		/// Yup, Savage3D.
		hsStatusMessage( "== Using fudge factors for a Savage3D chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for a Savage3D chipset" );
		ISetFudgeFactors( kSavage3DChipset, record );
	}
	/// Detect Generic S3 chipset
	else if( ( strncmp( szDriver, "s3", 2 ) == 0 ) || ( strstr( desc, "savage" ) != nil ) )
	{
		/// Yup, Generic S3.
		hsStatusMessage( "== Using fudge factors for a generic S3 chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for a generic S3 chipset" );
		ISetFudgeFactors( kS3GenericChipset, record );
	}

	//// ATI-based Cards //////////////////////////////////////////////////////
	/// Detect ATI Rage 128 Pro chipset
	else if( ( deviceID == 0x00005046 &&			// Normal ATI Rage 128 Pro detection
				( stricmp( szDriver, "ati2dvaa.dll" ) == 0 
		        || strstr( desc, "rage 128 pro" ) != nil ) ) ||
			( deviceID == 0x00005246 &&				// ATI All-in-wonder--same chipset, diff values
				( stricmp( szDriver, "ati3draa.dll" ) == 0
				|| strstr( desc, "all-in-wonder 128" ) != nil ) ) )
	{
		hsStatusMessage( "== Using fudge factors for an ATI Rage 128 Pro chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for an ATI Rage 128 Pro chipset" );
		ISetFudgeFactors( kATIRageProChipset, record );
	}
	/// Detect(detest?) ATI Rage FURY MAXX chipset
	else if( deviceID == 0x00005046 &&
			 ( stricmp( szDriver, "ati3drau.dll" ) == 0 
			   || strstr( desc, "rage fury" ) != nil ) )
	{
		hsStatusMessage( "== Using fudge factors for an ATI Rage Fury MAXX chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for an ATI Rage Fury MAXX chipset" );
		ISetFudgeFactors( kATIRageFuryChipset, record );
	}
	/// Detect ATI Radeon chipset
	// We will probably need to differentiate between different Radeons at some point in 
	// the future, but not now.
	else if( // deviceID == 0x00005144 && 
				( stricmp( szDriver, "ati2dvag.dll" ) == 0
					|| strstr( desc, "radeon" ) != nil ) )
	{
		int series = 0;
		const char* str = strstr(desc, "radeon");
		if( str )
			str += strlen("radeon");
		else
		{
			str = strstr(desc, "all-in-wonder");
			if( str )
				str += strlen("all-in-wonder");
		}
		if( str )
		{
			if( 1 == sscanf(str, "%d", &series) )
			{
				if( (series == 7500) || (series == 7200) )
				{
					hsStatusMessage( "== Using fudge factors for ATI Radeon 7200/7500 chipset ==\n" );
					plDemoDebugFile::Write( "   Using fudge factors for ATI Radeon 7200/7500 chipset" );
					ISetFudgeFactors( kATIR7500Chipset, record );
				}
				else
				if( (series >= 7000) && (series < 8000) )
				{
					hsStatusMessage( "== Using fudge factors for ATI Radeon 7X00 chipset ==\n" );
					plDemoDebugFile::Write( "   Using fudge factors for ATI Radeon 7X00 chipset" );
					ISetFudgeFactors( kATIR7X00Chipset, record );
				}
				else 
				if( (series >= 8000) && (series < 9000) )
				{
					hsStatusMessage( "== Using fudge factors for ATI Radeon 8X00 chipset ==\n" );
					plDemoDebugFile::Write( "   Using fudge factors for ATI Radeon 8X00 chipset" );
					ISetFudgeFactors( kATIR8X00Chipset, record );
				}
				else
				{
					series = 0;
				}
			}
			else
			{
				series = 0;

				// Skip white space
				while( *str && (*str <= 0x32) )
					str++;

				// I've still never seen either of these, so I'm just going by ATI's site.
				// Don't have the option of using device-id's.
				if( (str[0] == 'v') && (str[1] == 'e') )
				{
					// Got an alias here. If it's an All-in-Wonder VE, it's really a 7500.
					// If it's a Radeon VE, it's really a 7000.
					if( strstr(desc, "radeon") )
						series = 7000;
					else if( strstr(desc, "all-in-wonder") )
						series = 7500;
				}
			}
		}
		if( !series )
		{
			hsStatusMessage( "== Using fudge factors for ATI Radeon chipset ==\n" );
			plDemoDebugFile::Write( "   Using fudge factors for ATI Radeon chipset" );
			ISetFudgeFactors( kATIRadeonChipset, record );
		}
	}
	/// Detect generic ATI chipset
	else if( ( strncmp( szDriver, "ati", 3 ) == 0 ) || ( strstr( desc, "ati " ) != nil ) )
	{
		hsStatusMessage( "== Using fudge factors for a generic ATI chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for a generic ATI chipset" );
		ISetFudgeFactors( kATIGenericChipset, record );
	}

	//// Matrox-based Cards ///////////////////////////////////////////////////
	else if( (deviceID == 0x527)
		|| strstr(desc, "parhelia") )
	{
		hsStatusMessage( "== Using fudge factors for a Matrox Parhelia chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for a Matrox Millenium G400 chipset" );
		ISetFudgeFactors( kMatroxParhelia, record );
	}
	/// Detect Matrox G400 chipset
	else if( deviceID == 0x00000525 &&
				( stricmp( szDriver, "g400d.dll" ) == 0 
				  || ( strstr( desc, "matrox" ) != nil && strstr( desc, "g400" ) != nil ) ) )
	{
		hsStatusMessage( "== Using fudge factors for a Matrox Millenium G400 chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for a Matrox Millenium G400 chipset" );
		ISetFudgeFactors( kMatroxG400Chipset, record );
	}
	/// Detect generic Matrox chipset
	else if( strstr( desc, "matrox" ) != nil )
	{
		hsStatusMessage( "== Using fudge factors for a generic Matrox chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for a generic Matrox chipset" );
		ISetFudgeFactors( kMatroxGenericChipset, record );
	}

	//// Other Cards //////////////////////////////////////////////////////////
	/// Detect NVidia RIVA TNT chipset
	else if( deviceID == 0x00000020 &&
			 ( stricmp( szDriver, "nvdd32.dll" ) == 0 
			   || strstr( desc, "nvidia riva tnt" ) != nil ) )
	{
		hsStatusMessage( "== Using fudge factors for an NVidia RIVA TNT chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for an NVidia RIVA TNT chipset" );
		ISetFudgeFactors( kNVidiaTNTChipset, record );
		if( record.GetMemoryBytes() < 16 * 1024 * 1024 )
		{
			hsStatusMessage( "== (also fudging memory up to 16MB) ==\n" );
			plDemoDebugFile::Write( "   (also fudging memory up to 16MB)" );
			record.SetMemoryBytes( 16 * 1024 * 1024 );
		}
	}
	/// Detect Intel i810 chipset
	else if( deviceID == 0x00007125 &&
				( stricmp( szDriver, "i81xdd.dll" ) == 0 
				  || ( strstr( desc, "intel" ) != nil && strstr( desc, "810" ) != nil ) ) )
	{
		hsStatusMessage( "== Using fudge factors for an Intel i810 chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for an Intel i810 chipset" );
		ISetFudgeFactors( kIntelI810Chipset, record );
	}
	/// Detect STMicroelectronics KYRO chipset
	else if( deviceID == 0x00000010 && ( strstr( desc, "kyro" ) != nil ) )
	{
		hsStatusMessage( "== Using fudge factors for a KYRO chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for a KYRO chipset" );
		ISetFudgeFactors( kKYROChipset, record );
	}
	/// Detect for a 3dfx Voodoo5
	else if( vendorID == 0x121a && deviceID == 0x00000009 && 
			stricmp( szDriver, "3dfxvs.dll" ) == 0 )
	{
		hsStatusMessage( "== Using fudge factors for a 3dfx Voodoo5 chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for a 3dfx Voodoo5 chipset" );
		ISetFudgeFactors( k3dfxV5Chipset, record );
	}
	/// Detect for a GeForce-class card. We can be loose here because we want 
	///	to get ALL GeForce/2/256 cards
	else if( strstr( desc, "nvidia" ) != nil && strstr( desc, "geforce2" ) != nil )
	{
		hsStatusMessage( "== Using fudge factors for an NVidia GeForce2-based chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for an NVidia GeForce2-based chipset" );
		ISetFudgeFactors( kNVidiaGeForce2Chipset, record );
	}
	else if( strstr( desc, "nvidia" ) != nil && strstr( desc, "geforce3" ) != nil )
	{
		hsStatusMessage( "== Using fudge factors for an NVidia GeForce3-based chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for an NVidia GeForce3-based chipset" );
		ISetFudgeFactors( kNVidiaGeForce3Chipset, record );
	}
	else if( strstr( desc, "nvidia" ) != nil && strstr( desc, "geforce4 mx" ) != nil )
	{
		hsStatusMessage( "== Using fudge factors for an NVidia GeForce4MX-based chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for an NVidia GeForce4MX-based chipset" );
		ISetFudgeFactors( kNVidiaGeForce4MXChipset, record );
	}
	else if( strstr( desc, "nvidia" ) != nil && strstr( desc, "geforce4" ) != nil )
	{
		hsStatusMessage( "== Using fudge factors for an NVidia GeForce4-based chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for an NVidia GeForce4-based chipset" );
		ISetFudgeFactors( kNVidiaGeForce4Chipset, record );
	}
	else if( 
		strstr( desc, "nvidia" ) && strstr( desc, "geforce" )
		&& (
			(deviceID == 0x101)
			||(deviceID == 0x100)
			||strstr(desc, "256")
			)
		)
	{
		hsStatusMessage( "== Using fudge factors for an NVidia GeForce-based chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for an NVidia GeForce-based chipset" );
		ISetFudgeFactors( kNVidiaGeForceChipset, record );
	}
	else if( strstr( desc, "nvidia" ) != nil && strstr( desc, "geforce" ) != nil )
	{
		hsStatusMessage( "== Using fudge factors for an NVidia GeForceFX-based chipset ==\n" );
		plDemoDebugFile::Write( "   Using fudge factors for an NVidia GeForceFX-based chipset" );
		ISetFudgeFactors( kNVidiaGeForceFXChipset, record );
	}
	/// Detect for a TNT-based card and force it to >= 16MB memory, so we always use it
	else if( strstr( desc, "tnt" ) != nil && record.GetMemoryBytes() < 16 * 1024 * 1024 )
	{
		hsStatusMessage( "== NVidia TNT-based card detected. Fudging memory reading to 16MB ==\n" );
		plDemoDebugFile::Write( "   NVidia TNT-based card detected. Fudging memory reading to 16MB" );
		record.SetMemoryBytes( 16 * 1024 * 1024 );
	}

	/// Default fudge values
	else
	{
		hsStatusMessage( "== Using default fudge factors ==\n" );
		plDemoDebugFile::Write( "   Using default fudge factors" );
		ISetFudgeFactors( kDefaultChipset, record );
	}
}
#endif

//// ISetFudgeFactors /////////////////////////////////////////////////////////
//	Given a chipset ID, looks the values up in the CFT and sets the appropriate
//	values.

void	hsG3DDeviceSelector::ISetFudgeFactors( UInt8 chipsetID, hsG3DDeviceRecord &record )
{
	int		i, maxIDs, j;


	maxIDs = sizeof( dsCFTable ) / sizeof( dsCFTable[ 0 ] );

	/// Search for our chipset
	for( i = 0; i < maxIDs; i++ )
	{
		if( dsCFTable[ i ].fType == chipsetID )
		{
			/// Found it!

			// Flags to force set
			if( dsCFTable[ i ].fFlagsToSet != nil )
			{
				for( j = 0; j < dsCFTable[ i ].fFlagsToSet[ 0 ]; j++ )
					record.SetCap( dsCFTable[ i ].fFlagsToSet[ j + 1 ] );
			}

			// Flags to force clear
			if( dsCFTable[ i ].fFlagsToClear != nil )
			{
				for( j = 0; j < dsCFTable[ i ].fFlagsToClear[ 0 ]; j++ )
					record.SetCap( dsCFTable[ i ].fFlagsToClear[ j + 1 ], false );
			}

			// Suckiness
			record.SetZBiasRating( dsCFTable[ i ].fZSuckiness );

			// Max # of layers
			if( dsCFTable[ i ].fForceMaxLayers > 0 )
				record.SetLayersAtOnce( dsCFTable[ i ].fForceMaxLayers );

			// LOD bias rating
			record.SetLODBiasRating( dsCFTable[ i ].fLODRating );

			// Fog tweaks
			FogTweakTable	*fogTweaks = dsCFTable[ i ].fFogTweaks;

			record.SetFogApproxStarts( fogTweaks->fFogExpApproxStart, fogTweaks->fFogExp2ApproxStart );
			record.SetFogEndBias( fogTweaks->fFogEndBias );
			record.SetFogKneeParams( hsG3DDeviceRecord::kFogExp, fogTweaks->fFogExpKnee, fogTweaks->fFogExpKneeVal );
			record.SetFogKneeParams( hsG3DDeviceRecord::kFogExp2, fogTweaks->fFogExp2Knee, fogTweaks->fFogExp2KneeVal );

			if( record.GetCap(kCapsNoAA) )
			{
				int j;
				for( j = 0; j < record.GetModes().GetCount(); j++ )
					record.GetModes()[j].ClearFSAATypes();
			}

			return;
		}
	}
}



///////////////////////////////////////////////////////////////////////////////
//
//	Demo Debug File functions
//	Created 10.10.2000 by Mathew Burrack @ Cyan, Inc.
//	Modified 10.11 mcn to conform (more) to coding standards.
//
///////////////////////////////////////////////////////////////////////////////

//// Local Globals ////////////////////////////////////////////////////////////

#if M3DDEMOINFO	// Demo Debug Build
static plDemoDebugFile		sMyDDFWriter;

hsBool	plDemoDebugFile::fIsOpen = false;
FILE	*plDemoDebugFile::fDemoDebugFP = nil;
hsBool	plDemoDebugFile::fEnabled = false;
#endif


//// IDDFOpen /////////////////////////////////////////////////////////////////
//	Internal function--opens the demo debug file for writing. Returns true
//	if successful, false otherwise.

hsBool	plDemoDebugFile::IDDFOpen( void )
{
#if M3DDEMOINFO	// Demo Debug Build
	char	fileName[] = "log/debug_info.dat";
	time_t	currTime;
	struct tm	*localTime;
	char	timeString[ 27 ];		// see definition of asctime()
	char	*c;


	/// Don't open if we're not enabled
	if( !fEnabled )
		return false;

	/// Open the file
	if( fDemoDebugFP == nil )
		fDemoDebugFP = fopen( fileName, "wt" );

	if( fDemoDebugFP == nil )
		return( fIsOpen = false );

	/// Write out a header line
	time( &currTime );
	localTime = localtime( &currTime );

	// Note: asctime includes a carriage return. Gotta strip...
	strcpy( timeString, asctime( localTime ) );
	c = strchr( timeString, '\n' );
	if( c != nil )
		*c = 0;

	fprintf( fDemoDebugFP, "\n--- Demo Debug Info File (Created %s) ---\n", timeString );

	/// All done!
	return( fIsOpen = true );
#else
	return false;
#endif
}

//// IDDFClose ////////////////////////////////////////////////////////////////
//	"Whatcha gonna do when the lightning strikes and hits you...."
//							-- "Lightning Strikes", Yes, 1999


void	plDemoDebugFile::IDDFClose( void )
{
#if M3DDEMOINFO	// Demo Debug Build
	if( fDemoDebugFP != nil )
	{
		// Write an exit line (fun fun)
		fputs( "--- End of Demo Debug Info File ---\n\n", fDemoDebugFP );

		// Close
		fclose( fDemoDebugFP );
	}

	fIsOpen = false;
#endif
}

//// Write ////////////////////////////////////////////////////////////////////
//	Writes a string to the DDF. If the DDF isn't open, opens it.

void	plDemoDebugFile::Write( char *string )
{
#if M3DDEMOINFO	// Demo Debug Build
	if( !fIsOpen )
		IDDFOpen();

	if( fIsOpen )
		fprintf( fDemoDebugFP, "%s\n", string );
#endif
}

void	plDemoDebugFile::Write( char *string1, char *string2 )
{
#if M3DDEMOINFO	// Demo Debug Build
	if( !fIsOpen )
		IDDFOpen();

	if( fIsOpen )
		fprintf( fDemoDebugFP, "%s: %s\n", string1, string2 );
#endif
}

void	plDemoDebugFile::Write( char *string1, Int32 value )
{
#if M3DDEMOINFO	// Demo Debug Build
	if( !fIsOpen )
		IDDFOpen();

	if( fIsOpen )
		fprintf( fDemoDebugFP, "%s: %d (0x%x)\n", string1, value, value );
#endif
}