1HEADmaster

1 files changed, 1583 insertions, 0 deletions

diff --git a/appframework/glmrendererinfo_osx.mm b/appframework/glmrendererinfo_osx.mm
new file mode 100644
index 0000000..fbaf315
--- /dev/null
+++ b/appframework/glmrendererinfo_osx.mm
@@ -0,0 +1,1583 @@
+//========= Copyright  1996-2009, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Defines a group of app systems that all have the same lifetime
+// that need to be connected/initialized, etc. in a well-defined order
+//
+// $Revision: $
+// $NoKeywords: $
+//=============================================================================//
+
+#include <Cocoa/Cocoa.h>
+#include <OpenGL/OpenGL.h>
+#include <OpenGL/gl.h>
+#include <OpenGL/glext.h>
+#include <IOKit/IOKitLib.h>
+
+
+#undef MIN
+#undef MAX
+#define DONT_DEFINE_BOOL	// Don't define BOOL!
+#include "tier0/threadtools.h"
+#include "tier0/icommandline.h"
+#include "tier1/interface.h"
+#include "tier1/strtools.h"
+#include "tier1/utllinkedlist.h"
+#include "togl/rendermechanism.h"
+#include "appframework/ilaunchermgr.h"	// gets pulled in from glmgr.h
+#include "appframework/iappsystemgroup.h"
+#include "inputsystem/ButtonCode.h"
+
+
+// some helper functions, relocated out of GLM since they are used here
+
+// this one makes a new context
+bool	GLMDetectSLGU( void );
+bool	GLMDetectSLGU( void )
+{
+	CGLError	cgl_error = (CGLError)0;
+	bool		result = false;
+	
+	CGLContextObj oldctx = CGLGetCurrentContext();
+
+	static CGLPixelFormatAttribute attribs[] = 
+	{
+		kCGLPFADoubleBuffer,
+		kCGLPFANoRecovery,
+		kCGLPFAAccelerated,
+		kCGLPFADepthSize,
+			(CGLPixelFormatAttribute)0,
+		kCGLPFAColorSize,
+			(CGLPixelFormatAttribute)32,
+
+		(CGLPixelFormatAttribute)0	// list term
+	};
+
+	CGLPixelFormatObj	pixfmtobj = NULL;
+	GLint				npix;
+	
+	CGLContextObj		ctxobj = NULL;
+	
+	cgl_error = CGLChoosePixelFormat( attribs, &pixfmtobj, &npix );
+	if (!cgl_error)
+	{
+		// got pixel format, make a context
+		
+		cgl_error = CGLCreateContext( pixfmtobj, NULL, &ctxobj );
+		if (!cgl_error)
+		{
+			CGLSetCurrentContext( ctxobj );
+
+			// now do the test
+
+			_CGLContextParameter	kCGLCPGCDMPEngine = ((_CGLContextParameter)1314);
+
+			GLint dummyval = 0;
+			cgl_error = CGLGetParameter( CGLGetCurrentContext(), kCGLCPGCDMPEngine, &dummyval );
+
+			result = (!cgl_error);
+			
+			// all done, go back to old context, and destroy the temp one
+			CGLSetCurrentContext( oldctx );
+			CGLDestroyContext( ctxobj );
+		}
+		
+		// destroy the pixel format obj
+		CGLDestroyPixelFormat( pixfmtobj );
+	}
+
+	return result;
+}
+
+
+bool	GLMDetectScaledResolveMode( uint osComboVersion, bool hasSLGU );
+bool	GLMDetectScaledResolveMode( uint osComboVersion, bool hasSLGU )
+{
+	bool result = false;
+	
+	// note this function assumes a current context on the renderer in question
+	// and that FB blit and SLGU are present..
+	
+	if (!hasSLGU)
+		return false;
+		
+	if (osComboVersion <= 0x000A0604)	// we know no one has it before 10.6.5
+		return false;
+	
+	// in 10.6.6 and later, just check for the ext string.
+	char *gl_ext_string = (char*)glGetString(GL_EXTENSIONS);
+	// avoid crashing due to strstr'ing NULL pointer returned from glGetString
+	if (!gl_ext_string)
+		gl_ext_string = "";
+	
+	result = strstr(gl_ext_string, "GL_EXT_framebuffer_multisample_blit_scaled") != NULL;
+	
+	if ( !result )
+	{
+		// make two FBO's
+		GLuint	fbos[2];
+		GLuint	rbos[2];
+		int extent = 64;
+		
+		// make two render buffers
+
+		for( int fbi = 0; fbi < 2; fbi++ )
+		{
+			glGenFramebuffersEXT( 1, &fbos[fbi] ); CheckGLError( __LINE__ );
+			glBindFramebufferEXT( fbi ? GL_DRAW_FRAMEBUFFER_EXT : GL_READ_FRAMEBUFFER_EXT , fbos[fbi] );  CheckGLError( __LINE__ );
+			
+			glGenRenderbuffersEXT( 1, &rbos[fbi] ); CheckGLError( __LINE__ );
+			glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, rbos[fbi] ); CheckGLError( __LINE__ );
+
+			// make it multisampled if 0
+			if (!fbi)
+			{
+				glRenderbufferStorageMultisampleEXT( GL_RENDERBUFFER_EXT, 2, GL_RGBA8, extent,extent );	  CheckGLError( __LINE__ );
+			}
+			else
+			{
+				glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_RGBA8, extent,extent ); CheckGLError( __LINE__ );
+			}
+
+			// attach it 
+			// #0 gets to be read and multisampled
+			// #1 gets to be draw and multisampled
+			glFramebufferRenderbufferEXT( fbi ? GL_DRAW_FRAMEBUFFER_EXT : GL_READ_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, rbos[fbi] ); CheckGLError( __LINE__ );
+		}
+		// now test
+		while( glGetError() )	// clear error queue
+		{
+			;
+		}
+
+		// now do the dummy blit
+		glBlitFramebufferEXT(	0,0,extent,extent, 0,0,extent,extent, GL_COLOR_BUFFER_BIT, XGL_SCALED_RESOLVE_FASTEST_EXT );
+
+		// type of error we get back lets us know what the outcome is.
+		// invalid enum error								-> unsupported
+		// no error or invalid op							-> supported
+
+		GLenum errorcode = (GLenum)glGetError();
+		switch(errorcode)
+		{
+			// expected outcomes.
+			
+			// positive
+			case GL_NO_ERROR:
+			case GL_INVALID_OPERATION:
+				result = true;			// new scaled resolve detected
+				break;
+				
+			default:
+				result = false;			// no scaled resolve
+				break;
+		}
+		
+		// unbind and wipe stuff
+		
+		glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, 0 ); CheckGLError( __LINE__ );
+		
+		for( int xfbi = 0; xfbi < 2; xfbi++ )
+		{
+			// unbind FBO
+			glBindFramebufferEXT( xfbi ? GL_DRAW_FRAMEBUFFER_EXT : GL_READ_FRAMEBUFFER_EXT , 0 ); CheckGLError( __LINE__ );
+
+			// del FBO and RBO
+			glDeleteFramebuffersEXT( 1, &fbos[xfbi] ); CheckGLError( __LINE__ );
+			glDeleteRenderbuffersEXT( 1, &rbos[xfbi] ); CheckGLError( __LINE__ );
+		}
+	}
+
+	return result; // no SLGU, no scaled resolve blit even possible
+}
+
+//===============================================================================
+
+GLMRendererInfo::GLMRendererInfo( GLMRendererInfoFields *info )
+{
+	NSAutoreleasePool	*tempPool = [[NSAutoreleasePool alloc] init ];
+
+	// absorb info obtained so far by caller
+	m_info = *info;
+	m_displays = NULL;
+
+	// gather more info using a dummy context
+	unsigned int attribs[] = 
+	{
+		kCGLPFADoubleBuffer, kCGLPFANoRecovery, kCGLPFAAccelerated,
+		kCGLPFADepthSize, 0,
+		kCGLPFAColorSize, 32,
+		kCGLPFARendererID, info->m_rendererID,
+		0
+	};
+
+	NSOpenGLPixelFormat	*pixFmt		=	[[NSOpenGLPixelFormat alloc] initWithAttributes:(NSOpenGLPixelFormatAttribute*)attribs]; 
+	NSOpenGLContext		*nsglCtx	=	[[NSOpenGLContext alloc] initWithFormat: pixFmt shareContext: NULL ];
+
+	[nsglCtx makeCurrentContext];
+		
+	// run queries.
+	char *gl_ext_string = (char*)glGetString(GL_EXTENSIONS);
+
+	uint vers = m_info.m_osComboVersion;
+	// avoid crashing due to strstr'ing NULL pointer returned from glGetString
+	if (!gl_ext_string)
+	  gl_ext_string = "";
+
+	// effectively blacklist the renderer if it doesn't actually work; sort it to back of list
+	if ( !nsglCtx )
+	{
+		m_info.m_vidMemory = 1;
+		m_info.m_texMemory = 1;
+	}
+	
+	//-------------------------------------------------------------------
+	// booleans
+	//-------------------------------------------------------------------
+	// gamma writes.
+	m_info.m_hasGammaWrites = true;
+	if ( vers < 0x000A0600 )				// pre 10.6.0, no SRGB write - see http://developer.apple.com/graphicsimaging/opengl/capabilities/GLInfo_1058.html
+	{
+		m_info.m_hasGammaWrites = false;
+	}
+	
+	if (m_info.m_atiR5xx)
+	{
+		m_info.m_hasGammaWrites = false;	// it just don't, even post 10.6.3
+	}
+	
+	// if CLI option for fake SRGB mode is enabled, turn off this cap, act like we do not have EXT FB SRGB
+	if (CommandLine()->FindParm("-glmenablefakesrgb"))
+	{
+		m_info.m_hasGammaWrites = false;
+	}
+	
+	// extension string *could* be checked, but on 10.6.3 the ext string is not there, but the func *is*
+
+	//-------------------------------------------------------------------
+	// mixed attach sizes for FBO
+	m_info.m_hasMixedAttachmentSizes = true;
+	if ( vers < 0x000A0603 )	// pre 10.6.3, no mixed attach sizes
+	{
+		m_info.m_hasMixedAttachmentSizes = false;
+	}
+	else
+	{
+		if (!strstr(gl_ext_string, "GL_ARB_framebuffer_object"))
+		{
+			// ARB_framebuffer_object not available
+			m_info.m_hasMixedAttachmentSizes = false;
+		}
+	}
+	// also check ext string
+
+	//-------------------------------------------------------------------
+	// BGRA vert attribs
+	m_info.m_hasBGRA = true;
+	if ( vers < 0x000A0603 )	// pre 10.6.3, no BGRA attribs
+	{
+		m_info.m_hasBGRA = false;
+	}
+	else
+	{
+		if (!strstr(gl_ext_string, "EXT_vertex_array_bgra"))
+		{
+			// EXT_vertex_array_bgra not available
+			m_info.m_hasBGRA = false;
+		}
+	}
+
+	//-------------------------------------------------------------------
+	m_info.m_hasNewFullscreenMode = true;
+	if ( vers < 0x000A0600 )	// pre 10.6.0, no clever window server full screen mode
+	{
+		m_info.m_hasNewFullscreenMode = false;
+	}
+	
+	//-------------------------------------------------------------------
+	m_info.m_hasNativeClipVertexMode = true;
+	// this one uses a heuristic, and allows overrides in case the heuristic is wrong
+	// or someone wants to try a beta driver or something.
+
+	// known bad combinations get turned off here..
+	
+	// any ATI hardware...
+	// TURNED OFF OS CHECK if (m_info.m_osComboVersion <= 0x000A0603)
+	// still believe to be broken in 10.6.4
+	{
+		if (m_info.m_ati)
+		{
+			m_info.m_hasNativeClipVertexMode = false;
+		}
+	}
+	
+	// R500, forever..
+	if (m_info.m_atiR5xx)
+	{
+		m_info.m_hasNativeClipVertexMode = false;
+	}
+
+	// if user disabled them
+	if (CommandLine()->FindParm("-glmdisableclipplanes"))
+	{
+		m_info.m_hasNativeClipVertexMode = false;
+	}
+	
+	// or maybe enabled them..
+	if (CommandLine()->FindParm("-glmenableclipplanes"))
+	{
+		m_info.m_hasNativeClipVertexMode = true;
+	}
+	
+	//-------------------------------------------------------------------
+	m_info.m_hasOcclusionQuery = true;
+	if (!strstr(gl_ext_string, "ARB_occlusion_query"))
+	{
+		m_info.m_hasOcclusionQuery = false;		// you don't got it!
+	}
+	
+	//-------------------------------------------------------------------
+	m_info.m_hasFramebufferBlit = true;
+	if (!strstr(gl_ext_string, "EXT_framebuffer_blit"))
+	{
+		m_info.m_hasFramebufferBlit = false;	// you know you don't got it!
+	}
+	
+	//-------------------------------------------------------------------
+	m_info.m_maxAniso = 4;			//FIXME needs real query
+	
+	//-------------------------------------------------------------------
+	m_info.m_hasBindableUniforms = true;
+	if (!strstr(gl_ext_string, "EXT_bindable_uniform"))
+	{
+		m_info.m_hasBindableUniforms = false;
+	}
+	m_info.m_hasBindableUniforms = false;		// hardwiring this path to false until we see how to accelerate it properly
+	
+	//-------------------------------------------------------------------
+	m_info.m_hasUniformBuffers = true;
+	if (!strstr(gl_ext_string, "ARB_uniform_buffer"))
+	{
+		m_info.m_hasUniformBuffers = false;
+	}
+
+	//-------------------------------------------------------------------
+	// test for performance pack (10.6.4+)
+
+	bool perfPackageDetected = GLMDetectSLGU();
+	
+	if (perfPackageDetected)
+	{
+		m_info.m_hasPerfPackage1 = true;
+	}	
+
+	if (CommandLine()->FindParm("-glmenableperfpackage"))	// force it on
+	{
+		m_info.m_hasPerfPackage1 = true;
+	}
+	
+	if (CommandLine()->FindParm("-glmdisableperfpackage"))	// force it off
+	{
+		m_info.m_hasPerfPackage1 = false;
+	}
+
+
+	//-------------------------------------------------------------------
+	// runtime options that aren't negotiable once set
+
+	m_info.m_hasDualShaders = CommandLine()->FindParm("-glmdualshaders");
+
+	//-------------------------------------------------------------------
+	// "can'ts "
+	
+	m_info.m_cantBlitReliably = (m_info.m_osComboVersion < 0x000A0606) && m_info.m_intel;		//don't trust FBO blit on Intel before 10.6.6
+	if (CommandLine()->FindParm("-glmenabletrustblit"))
+	{
+		m_info.m_cantBlitReliably = false;			// we trust the blit, so set the cant-blit cap to false
+	}
+	if (CommandLine()->FindParm("-glmdisabletrustblit"))
+	{
+		m_info.m_cantBlitReliably = true;			// we do not trust the blit, so set the cant-blit cap to true
+	}
+
+	//m_info.m_cantAttachSRGB = (m_info.m_nv && m_info.m_osComboVersion < 0x000A0600);	//NV drivers won't accept SRGB tex on an FBO color target in 10.5.8
+	//m_info.m_cantAttachSRGB = (m_info.m_ati && m_info.m_osComboVersion < 0x000A0600);	//... does ATI have the same problem?
+	m_info.m_cantAttachSRGB = (m_info.m_osComboVersion < 0x000A0600);	// across the board on 10.5.x actually..
+
+	// MSAA resolve issues
+	m_info.m_cantResolveFlipped	= false;	// initial stance
+	
+	if (m_info.m_ati)
+	{
+		//Jan 2011 - ATI says it's better to do two step blit than to try and resolve upside down
+		m_info.m_cantResolveFlipped = true;
+	}
+	
+	if (m_info.m_nv)
+	{
+		// we're going to mark it 'broken' unless perf package 1 (10.6.4+) is present
+		if (!m_info.m_hasPerfPackage1)
+		{
+			m_info.m_cantResolveFlipped = true;
+		}
+	}
+	
+	// this is just the private assessment of whather scaled resolve is available.
+	// the activation of it will stay tied to the gl_minify_resolve_mode / gl_magnify_resolve_mode convars in glmgr
+	if 	(m_info.m_osComboVersion > 0x000A0700 || CommandLine()->FindParm("-gl_enable_scaled_resolve") )
+	{
+		bool scaledResolveDetected = GLMDetectScaledResolveMode( m_info.m_osComboVersion, m_info.m_hasPerfPackage1 );
+		m_info.m_cantResolveScaled = !scaledResolveDetected;
+	}
+	else
+	{
+		m_info.m_cantResolveScaled = true;
+	}
+
+	// and you can force it to be "available" if you really want to..
+	if ( CommandLine()->FindParm("-gl_force_enable_scaled_resolve") )
+	{
+		m_info.m_cantResolveScaled = false;
+	}
+	
+	// gamma decode impacting shader codegen
+	m_info.m_costlyGammaFlips = false;
+	if (m_info.m_osComboVersion < 0x000A0600)		// if Leopard
+		m_info.m_costlyGammaFlips = true;
+		
+	if (m_info.m_atiR5xx)							// or r5xx - always
+		m_info.m_costlyGammaFlips = true;
+
+	if ( (m_info.m_atiR6xx) && (m_info.m_osComboVersion < 0x000A0605) )	// or r6xx prior to 10.6.5
+		m_info.m_costlyGammaFlips = true;
+
+	// The OpenGL driver for Intel HD4000 on 10.8 has a bug in the GLSL compiler, which was fixed
+	// in 10.9 (and unlikely to be fixed in 10.8). See intelglmallocworkaround.h for more info.
+	bool mountainLion = (m_info.m_osComboVersion >= 0x000A0800) && (m_info.m_osComboVersion < 0x000A0900);
+	m_info.m_badDriver108Intel = mountainLion && m_info.m_intelHD4000;
+	if ( CommandLine()->FindParm("-glmenablemallocworkaround") )
+	{
+		m_info.m_badDriver108Intel = true;
+	}
+	if ( CommandLine()->FindParm("-glmdisablemallocworkaround") )
+	{
+		m_info.m_badDriver108Intel = false;
+	}
+
+	[nsglCtx release];
+	[pixFmt release];
+	
+	[tempPool release];
+}
+
+GLMRendererInfo::~GLMRendererInfo( void )
+{
+	if (m_displays)
+	{
+		// delete all the new'd renderer infos that the table tracks
+		FOR_EACH_VEC( *m_displays, i )
+		{
+			delete (*this->m_displays)[i];
+		}
+		delete m_displays;
+		m_displays = NULL;
+	}
+}
+
+extern "C" int DisplayInfoSortFunction( GLMDisplayInfo* const *A, GLMDisplayInfo* const *B )
+{
+	int bigger = -1;
+	int smaller = 1;	// adjust these to get the ordering you want
+
+	// check main-ness - main should win
+
+	uint maskOfMainDisplay = CGDisplayIDToOpenGLDisplayMask( CGMainDisplayID() );
+	//Assert( maskOfMainDisplay==1 );	// just curious
+	
+	int mainscreena = (*A)->m_info.m_glDisplayMask & maskOfMainDisplay;
+	int mainscreenb = (*B)->m_info.m_glDisplayMask & maskOfMainDisplay;
+	
+	if ( mainscreena > mainscreenb )
+	{
+		return bigger;
+	}
+	else if ( mainscreena < mainscreenb )
+	{
+		return smaller;
+	}
+	
+	// check area - larger screen should win
+	int areaa = (*A)->m_info.m_displayPixelWidth * (*A)->m_info.m_displayPixelHeight;
+	int areab = (*B)->m_info.m_displayPixelWidth * (*B)->m_info.m_displayPixelHeight;
+
+	if ( areaa > areab )
+	{	
+		return bigger;
+	}
+	else if ( areaa < areab )
+	{
+		return smaller;
+	}
+	
+	return 0;	// equal rank
+}
+
+
+void	GLMRendererInfo::PopulateDisplays( void )
+{
+	Assert( !m_displays );
+	m_displays = new CUtlVector< GLMDisplayInfo* >;
+	
+	for( int i=0; i<32; i++)
+	{
+		// check mask to see if the selected display intersects this renderer
+		CGOpenGLDisplayMask dspMask = (CGOpenGLDisplayMask)(1<<i);
+		
+		if ( m_info.m_displayMask & dspMask )
+		{
+			// exclude teeny displays (they may represent offline displays)
+			// exclude inactive displays
+			
+			CGDirectDisplayID cgid = CGOpenGLDisplayMaskToDisplayID ( dspMask );
+
+			if ( (cgid != kCGNullDirectDisplay) && CGDisplayIsActive( cgid ) && (CGDisplayPixelsWide( cgid ) >= 512) && (CGDisplayPixelsHigh( cgid ) >= 384) )
+			{
+				GLMDisplayInfo *newdisp = new GLMDisplayInfo( cgid, dspMask );
+				m_displays->AddToTail( newdisp );			
+			}
+		}
+	}
+	
+	// now sort the table of displays.
+	m_displays->Sort( DisplayInfoSortFunction );
+
+	// then go back and ask each display to populate its display mode table.
+	FOR_EACH_VEC( *m_displays, i )
+	{
+		(*this->m_displays)[i]->PopulateModes();
+	}
+}
+
+const char *CheesyRendererDecode( uint value )
+{
+	switch(value)
+	{
+		case 0x00020200 :  return "Generic";
+		case 0x00020400 :  return "GenericFloat";
+		case 0x00020600 :  return "AppleSW";
+		case 0x00021000 :  return "ATIRage128";
+		case 0x00021200 :  return "ATIRadeon";
+		case 0x00021400 :  return "ATIRagePro";
+		case 0x00021600 :  return "ATIRadeon8500";
+		case 0x00021800 :  return "ATIRadeon9700";
+		case 0x00021900 :  return "ATIRadeonX1000";
+		case 0x00021A00 :  return "ATIRadeonX2000";
+		case 0x00022000 :  return "NVGeForce2MX";
+		case 0x00022200 :  return "NVGeForce3";
+		case 0x00022400 :  return "NVGeForceFX";
+		case 0x00022600 :  return "NVGeForce8xxx";
+		case 0x00023000 :  return "VTBladeXP2";
+		case 0x00024000 :  return "Intel900";
+		case 0x00024200 :  return "IntelX3100";
+		case 0x00040000 :  return "Mesa3DFX";
+
+		default: return "UNKNOWN";
+	}
+}
+
+extern const char *GLMDecode( GLMThing_t thingtype, unsigned long value );
+
+void	GLMRendererInfo::Dump( int which )
+{
+	GLMPRINTF(("\n     #%d: GLMRendererInfo @ %08x, renderer-id=%s(%08x)  display-mask=%08x  vram=%dMB",
+		which, this,
+		CheesyRendererDecode( m_info.m_rendererID & 0x00FFFF00 ), m_info.m_rendererID,
+		m_info.m_displayMask,
+		m_info.m_vidMemory >> 20
+	));
+	GLMPRINTF(("\n       VendorID=%04x  DeviceID=%04x  Model=%s",
+		m_info.m_pciVendorID,
+		m_info.m_pciDeviceID,
+		m_info.m_pciModelString
+	));
+
+	FOR_EACH_VEC( *m_displays, i )
+	{
+		(*m_displays)[i]->Dump(i);
+	}
+}
+
+
+//===============================================================================
+
+
+GLMDisplayDB::GLMDisplayDB	( void )
+{
+	m_renderers = NULL;	
+}
+
+GLMDisplayDB::~GLMDisplayDB	( void )
+{
+	if (m_renderers)
+	{
+		// delete all the new'd renderer infos that the table tracks
+		FOR_EACH_VEC( *m_renderers, i )
+		{
+			delete (*this->m_renderers)[i];
+		}
+		delete m_renderers;
+		m_renderers = NULL;
+	}
+}
+
+extern "C" int RendererInfoSortFunction( GLMRendererInfo * const *A, GLMRendererInfo* const *B )
+{
+	int bigger = -1;
+	int smaller = 1;
+	
+	// check VRAM
+	if ( (*A)->m_info.m_vidMemory > (*B)->m_info.m_vidMemory )
+	{	
+		return bigger;
+	}
+	else if ( (*A)->m_info.m_vidMemory < (*B)->m_info.m_vidMemory )
+	{
+		return smaller;
+	}
+	
+	// check MSAA limit
+	if ( (*A)->m_info.m_maxSamples > (*B)->m_info.m_maxSamples )
+	{	
+		return bigger;
+	}
+	else if ( (*A)->m_info.m_maxSamples < (*B)->m_info.m_maxSamples )
+	{
+		return smaller;
+	}
+	
+	/*
+		// this was not a great idea here..
+		
+		// check if one has the main screen - is that index 0 in all cases?
+		uint maskOfMainDisplay = CGDisplayIDToOpenGLDisplayMask( CGMainDisplayID() );
+		Assert( maskOfMainDisplay==1 );	// just curious
+		
+		int mainscreena = (*A)->m_info.m_displayMask & maskOfMainDisplay;
+		int mainscreenb = (*B)->m_info.m_displayMask & maskOfMainDisplay;
+		
+		if ( mainscreena > mainscreenb )
+		{
+			return bigger;
+		}
+		else if ( mainscreena < mainscreenb )
+		{
+			return smaller;
+		}
+	*/
+	
+	return 0;	// equal rank
+}
+
+/** some code that NV gave us.  more generalized approach below..
+
+		static io_registry_entry_t lookup_dev_NV(char *name)
+		{
+			mach_port_t master_port = 0;
+			io_iterator_t iterator;
+			io_registry_entry_t nub = 0;
+			kern_return_t ret;
+
+			IOMasterPort(MACH_PORT_NULL, &master_port);
+
+			ret = IOServiceGetMatchingServices(master_port, IOServiceMatching(name), &iterator);
+
+			if (iterator) {
+				nub = IOIteratorNext(iterator);
+
+				if (IOIteratorNext(iterator)) {
+					printf("warning: more than one card?\n");
+				}
+				IOObjectRelease(iterator);
+			}
+			IOObjectRelease(master_port);
+
+			return nub;
+		}
+
+
+		void	GetDriverInfoString_NV( char *driverNameBuf, int driverNameBufLen )
+		{
+			// courtesy NVIDIA dev rel
+			
+			io_registry_entry_t registry;
+			kern_return_t ret;
+
+			//
+			// Get NVKernel / IOGLBundleName
+			//
+
+			registry = lookup_dev_NV("NVKernel");
+			if (!registry) {
+				fprintf(stderr, "error: could not find NVKernel IORegistry entry!\n");
+				return;
+			}
+
+			CFMutableDictionaryRef entry;
+			ret = IORegistryEntryCreateCFProperties(registry, &entry, kCFAllocatorDefault, 0);
+			if (ret != kIOReturnSuccess) {
+				fprintf(stderr, "error: could not create CFProperties dictionary!\n");
+				return;
+			}
+
+			CFStringRef bundle_name_ref = (CFStringRef) CFDictionaryGetValue(entry, CFSTR("IOGLBundleName"));
+			if (!bundle_name_ref) {
+				fprintf(stderr, "error: could not get IOGLBundleName reference!\n");
+				return;
+			}
+
+			const char *bundle_name = CFStringGetCStringPtr(bundle_name_ref, CFStringGetSystemEncoding());
+			if (!bundle_name) {
+				fprintf(stderr, "error: could not get IOGLBundleName!\n");
+				return;
+			}
+
+			CFStringRef identifier = CFStringCreateWithFormat(NULL, NULL, CFSTR("com.apple.%s"), bundle_name);
+
+			//
+			// Get bundle information
+			//
+
+			CFBundleRef bundle;
+			bundle = CFBundleGetBundleWithIdentifier(identifier);
+			if (!bundle) {
+				fprintf(stderr, "error: could not get GL driver bundle!\n");
+				return;
+			}
+
+			CFDictionaryRef dict;
+			CFStringRef info;
+
+			dict = CFBundleGetInfoDictionary(bundle);
+			if (!dict) {
+				fprintf(stderr, "error: could not get bundle info dictionary!\n");
+				return;
+			}
+
+			info = (CFStringRef) CFDictionaryGetValue(dict, CFSTR("CFBundleGetInfoString"));
+			if (!info) {
+				fprintf(stderr, "error: could not get CFBundleGetInfoString!\n");
+				return;
+			}
+
+			CFStringGetCString(info, driverNameBuf, driverNameBufLen, CFStringGetSystemEncoding());
+
+			IOObjectRelease(registry);
+		}
+**/
+
+void	GLMDisplayDB::PopulateRenderers( void )
+{
+	Assert( !m_renderers );
+	m_renderers = new CUtlVector< GLMRendererInfo* >;
+	
+	// now walk the renderer list
+	// find the eligible ones and insert them into vector
+	// if more than one, sort the vector by desirability with favorite at 0
+	// then ask each renderer object to populate its displays
+
+	// turns out how you have to do this is to walk the display mask 1<<n..
+	// and query at each one, what renderers can hit that one.
+	
+	// when you find one, see if it's already in the vector above. if not, add it.
+	// later, we sort them.
+	
+	for( int i=0; i<32; i++ )
+	{
+		CGLError			cgl_err		= (CGLError)0;
+		CGLRendererInfoObj	cgl_rend	= NULL;
+		GLint				nrend;
+	
+		CGOpenGLDisplayMask	dspMask		= (CGOpenGLDisplayMask)(1<<i);	
+		CGDirectDisplayID	cgid		= CGOpenGLDisplayMaskToDisplayID( dspMask );
+
+		bool selected = true;	// assume the best		
+
+		if (selected)
+		{
+			if ( (cgid == kCGNullDirectDisplay)  || (!CGDisplayIsActive( cgid )) )
+			{
+				selected = false;
+			}
+		}
+
+		if (selected)
+		{
+			cgl_err = CGLQueryRendererInfo( dspMask, &cgl_rend, &nrend );	// FIXME this call spams the console if you ask about an out of bounds display mask
+																			// "<Error>: unknown error code: invalid display"
+																			// we can fix that by getting the active display mask first.
+			if (!cgl_err)
+			{
+				// walk the renderers that can hit this display
+				// add to table if not already in table, and minimums met
+
+				for( int j=0; j<nrend; j++)
+				{
+					int problems = 0;
+					
+					GLMRendererInfoFields	fields;
+					memset( &fields, 0, sizeof(fields) );
+
+					// early out if renderer ID already in the table
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPRendererID, &fields.m_rendererID );			problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPDisplayMask, &fields.m_displayMask );		problems += (cgl_err != 0);
+
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPFullScreen, &fields.m_fullscreen );			problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPAccelerated, &fields.m_accelerated );		problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPWindow, &fields.m_windowed );				problems += (cgl_err != 0);
+
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPBufferModes, &fields.m_bufferModes );		problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPColorModes, &fields.m_colorModes );			problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPDepthModes, &fields.m_depthModes );			problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPStencilModes, &fields.m_stencilModes );		problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPMaxAuxBuffers, &fields.m_maxAuxBuffers );	problems += (cgl_err != 0);				
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPMaxSampleBuffers, &fields.m_maxSampleBuffers );	problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPMaxSamples, &fields.m_maxSamples );			problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPSampleModes, &fields.m_sampleModes );		problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPSampleAlpha, &fields.m_sampleAlpha );		problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPVideoMemory, &fields.m_vidMemory );			problems += (cgl_err != 0);
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPTextureMemory, &fields.m_texMemory );		problems += (cgl_err != 0);
+
+					// Make sure the renderer is attached to a display.
+					GLint online;
+					cgl_err = CGLDescribeRenderer( cgl_rend, j,   kCGLRPOnline, &online );					problems += (cgl_err != 0);
+					problems += ( online == 0 );
+
+					// decide if this renderer goes in the table.
+
+					bool	selected = !problems;
+					
+					if (selected)
+					{
+						// grab the OS version
+
+						long vMajor = 0;	long vMinor = 0;	long vMinorMinor = 0;
+						
+						OSStatus gestalt_err = 0;
+						gestalt_err = Gestalt(gestaltSystemVersionMajor, &vMajor);
+						Assert(!gestalt_err);
+						
+						gestalt_err = Gestalt(gestaltSystemVersionMinor, &vMinor);
+						Assert(!gestalt_err);
+
+						gestalt_err = Gestalt(gestaltSystemVersionBugFix, &vMinorMinor);
+						Assert(!gestalt_err);
+
+						//encode into one quantity - 10.6.3 becomes 0x000A0603
+						fields.m_osComboVersion = (vMajor << 16) | (vMinor << 8) | (vMinorMinor);
+
+						if (CommandLine()->FindParm("-fakeleopard"))
+						{
+							// lie
+							fields.m_osComboVersion = 0x000A0508;
+						}
+						
+						if (fields.m_osComboVersion < 0x000A0508)
+						{
+							// no support below 10.5.8
+							// we'll wind up with no valid renderers and give up
+							selected = false;
+						}
+					}
+					
+					if (selected)
+					{
+						// gather more info from IOKit
+						// cribbed from http://developer.apple.com/mac/library/samplecode/VideoHardwareInfo/listing3.html
+						
+						CFTypeRef typeCode;
+						CFDataRef vendorID, deviceID, model;
+						io_registry_entry_t dspPort;
+							
+						// Get the I/O Kit service port for the display
+						dspPort = CGDisplayIOServicePort( cgid );
+
+						// Get the information for the device
+						// The vendor ID, device ID, and model are all available as properties of the hardware's I/O Kit service port
+						
+						vendorID	= (CFDataRef)IORegistryEntrySearchCFProperty(dspPort,kIOServicePlane,CFSTR("vendor-id"),	kCFAllocatorDefault,kIORegistryIterateRecursively | kIORegistryIterateParents);
+						deviceID	= (CFDataRef)IORegistryEntrySearchCFProperty(dspPort,kIOServicePlane,CFSTR("device-id"),	kCFAllocatorDefault,kIORegistryIterateRecursively | kIORegistryIterateParents);
+						model		= (CFDataRef)IORegistryEntrySearchCFProperty(dspPort,kIOServicePlane,CFSTR("model"),		kCFAllocatorDefault,kIORegistryIterateRecursively | kIORegistryIterateParents);
+						
+						// Send the appropriate data to the outputs checking to validate the data
+						if(vendorID)
+						{
+							fields.m_pciVendorID = *((UInt32*)CFDataGetBytePtr(vendorID));
+						}
+						else
+						{
+							fields.m_pciVendorID = 0;
+						}
+						
+						if(deviceID)
+						{
+							fields.m_pciDeviceID = *((UInt32*)CFDataGetBytePtr(deviceID));
+						}
+						else
+						{
+							fields.m_pciDeviceID = 0;
+						}
+						
+						if(model)
+						{
+							int length = CFDataGetLength(model);
+							char *data = (char*)CFDataGetBytePtr(model);
+							Q_strncpy( fields.m_pciModelString, data, sizeof(fields.m_pciModelString) );
+						}
+						else
+						{
+							Q_strncpy( fields.m_pciModelString, "UnknownModel", sizeof(fields.m_pciModelString) );
+						}
+						
+
+						// iterate through IOAccelerators til we find one that matches the vendorid and deviceid of this renderer (ugh!)
+						// this provides the driver version string which can in turn be used to uniquely identify bad drivers and special case for them
+						// first example to date - forcing vsync on 10.6.4 + NV
+						
+						{
+							io_iterator_t	ioIterator		= (io_iterator_t)0;
+							io_service_t	ioAccelerator;
+							kern_return_t	ioResult		= 0;
+							bool			ioDone			= false;
+														
+							ioResult = IOServiceGetMatchingServices( kIOMasterPortDefault, IOServiceMatching("IOAccelerator"), &ioIterator );
+							if( ioResult == KERN_SUCCESS )
+							{
+								ioAccelerator = 0;
+
+								while( ( !ioDone ) && ( ioAccelerator = IOIteratorNext( ioIterator ) )  )
+								{
+									io_service_t ioDevice;
+									
+									ioDevice = 0;
+									ioResult = IORegistryEntryGetParentEntry( ioAccelerator, kIOServicePlane, &ioDevice);
+									
+									CFDataRef this_vendorID, this_deviceID;
+
+									if(ioResult == KERN_SUCCESS)
+									{
+										this_vendorID	=	(CFDataRef)IORegistryEntryCreateCFProperty(ioDevice, CFSTR("vendor-id"), kCFAllocatorDefault, kNilOptions );
+										this_deviceID	=	(CFDataRef)IORegistryEntryCreateCFProperty(ioDevice, CFSTR("device-id"), kCFAllocatorDefault, kNilOptions );
+										
+										if (this_vendorID && this_deviceID)	// null check..
+										{
+											// see if it matches. if so, do our business (get the extended version string), set ioDone, call it a day
+											unsigned short this_vendorIDValue = *(unsigned short*)CFDataGetBytePtr(this_vendorID);
+											unsigned short this_deviceIDValue = *(unsigned short*)CFDataGetBytePtr(this_deviceID);
+											
+											if ( (fields.m_pciVendorID == this_vendorIDValue) && (fields.m_pciDeviceID == this_deviceIDValue) )
+											{
+												// see if it matches. if so, do our business (get the extended version string), set ioDone, call it a day
+												unsigned short* this_vendorIDBytes = (unsigned short*)CFDataGetBytePtr( this_vendorID );
+												unsigned short* this_deviceIDBytes = (unsigned short*)CFDataGetBytePtr( this_deviceID );
+												
+												if (this_vendorIDBytes && this_deviceIDBytes)	// null check...
+												{
+													unsigned short this_vendorIDValue = *this_vendorIDBytes;
+													unsigned short this_deviceIDValue = *this_deviceIDBytes;
+													
+													if ( (fields.m_pciVendorID == this_vendorIDValue) && (fields.m_pciDeviceID == this_deviceIDValue) )
+													{
+														// match, stop looking
+														ioDone = true;
+														
+														// get extended info
+														CFStringRef this_ioglName = (CFStringRef)IORegistryEntryCreateCFProperty( ioAccelerator, CFSTR("IOGLBundleName"), kCFAllocatorDefault, kNilOptions );
+	
+														NSString *bundlePath = [ NSString stringWithFormat:@"/System/Library/Extensions/%@.bundle", this_ioglName ];
+														
+														NSDictionary* this_driverDict = [ [NSBundle bundleWithPath: bundlePath] infoDictionary ];
+														if (this_driverDict)
+														{
+															NSString* this_driverInfo = [ this_driverDict objectForKey:@"CFBundleGetInfoString" ];
+															if ( this_driverInfo )
+															{
+																const char* theString = [ this_driverInfo UTF8String ];
+																
+																strncpy(fields.m_driverInfoString, theString, sizeof( fields.m_driverInfoString )  );
+															}												
+														}
+														
+														// [bundlePath release];
+														
+														CFRelease(this_ioglName);
+													}
+												}
+	
+												CFRelease(this_vendorID);
+												CFRelease(this_deviceID);
+											}
+										}
+									}
+								}
+							}
+
+							IOObjectRelease(ioAccelerator);
+							IOObjectRelease(ioIterator);
+						}
+
+						// Release vendorID, deviceID, and model as appropriate
+						if(vendorID)
+							CFRelease(vendorID);
+						if(deviceID)
+							CFRelease(deviceID);
+						if(model)
+							CFRelease(model);
+
+						// generate shorthand bools
+						switch( fields.m_pciVendorID )
+						{
+							case	0x1002:	//ATI
+							{
+								fields.m_ati = true;
+
+								// http://www.pcidatabase.com/search.php?device_search_str=radeon&device_search.x=0&device_search.y=0&device_search=search+devices
+								
+								// Mac-relevant ATI R5xx PCI device ID's lie in this range: 0x7100 - 0x72FF
+								// X1600, X1900, X1950
+								if ( (fields.m_pciDeviceID >= 0x7100) && (fields.m_pciDeviceID <= 0x72ff) )
+								{
+									fields.m_atiR5xx = true;
+								}
+
+								// R6xx PCI device ID's lie in these ranges:
+									// 0x94C1 - 0x9515 ... also 0x9581 - 0x9713
+									// 2400HD, 2600HD, 3870, et al
+								if	( 
+										( (fields.m_pciDeviceID >= 0x94C1) && (fields.m_pciDeviceID <= 0x9515) )
+									||	( (fields.m_pciDeviceID >= 0x9581) && (fields.m_pciDeviceID <= 0x9713) )
+									)
+								{
+									fields.m_atiR6xx = true;
+								}
+
+								// R7xx PCI device ID's lie in: 0x9440 - 0x9460, also 9480-94b5.
+								// why there is an HD5000 at 9462, I dunno.  Don't think that's an R8xx part.
+								if	( 
+										( (fields.m_pciDeviceID >= 0x9440) && (fields.m_pciDeviceID <= 0x9460) )
+									||	( (fields.m_pciDeviceID >= 0x9480) && (fields.m_pciDeviceID <= 0x94B5) )
+									)
+								{
+									fields.m_atiR7xx = true;
+								}
+								
+								// R8xx: 0x6898-0x68BE
+								if ( (fields.m_pciDeviceID >= 0x6898) && (fields.m_pciDeviceID <= 0x68Be) )
+								{
+									fields.m_atiR8xx = true;
+								}
+
+								#if 0
+										// turned off, but we could use this for cross check.
+										// we could also use the bit encoding of the renderer ID to ferret out a geberation clue.
+										
+										// string-scan for each generation
+										// this could be a lot better if we got the precise PCI ID's used and/or cross-ref'd that against the driver name
+										if (strstr("X1600", fields.m_pciModelString) || strstr("X1900", fields.m_pciModelString) || strstr("X1950", fields.m_pciModelString) )
+										{
+											fields.m_atiR5xx = true;
+										}
+
+										if (strstr("2600", fields.m_pciModelString) || strstr("3870", fields.m_pciModelString) || strstr("X2000", fields.m_pciModelString) )
+										{
+											fields.m_atiR6xx = true;
+										}
+
+										if (strstr("4670", fields.m_pciModelString) || strstr("4650", fields.m_pciModelString) || strstr("4850", fields.m_pciModelString)|| strstr("4870", fields.m_pciModelString) )
+										{
+											fields.m_atiR7xx = true;
+										}
+								#endif
+							}
+							break;
+							
+							case	0x8086:	//INTC
+							{
+								fields.m_intel = true;
+								
+								switch( fields.m_pciDeviceID )
+								{
+									case	0x27A6:	fields.m_intel95x = true;		break;	// GMA 950
+									case	0x2A02:	fields.m_intel3100 = true;		break;	// X3100
+									case	0x0166: fields.m_intelHD4000 = true;	break;	// HD4000
+								}
+							}
+							break;
+							
+							case	0x10DE:	//NV
+							{
+								fields.m_nv = true;
+
+								// G7x: 0x0391 0x393 0x0395 (7300/7600 GT)  0x009D (Quadro FX)
+								if	( (fields.m_pciDeviceID == 0x0391) || (fields.m_pciDeviceID == 0x0393) || (fields.m_pciDeviceID == 0x0395) || (fields.m_pciDeviceID == 0x009D) )
+								{
+									fields.m_nvG7x = true;
+								}
+								
+								// G8x: 0400-04ff, also 0x5E1 (GTX280) through 0x08FF
+								if	(
+										( (fields.m_pciDeviceID >= 0x0400) && (fields.m_pciDeviceID <= 0x04ff) )
+									||	( (fields.m_pciDeviceID >= 0x05E1) && (fields.m_pciDeviceID <= 0x08ff) )
+									)
+								{
+									fields.m_nvG8x = true;
+								}
+
+								if ( fields.m_pciDeviceID > 0x0900 )
+								{
+									fields.m_nvNewer = true;
+								}
+								
+								// detect the specific revision of NV driver in 10.6.4 that caused all the grief
+								if (strstr(fields.m_driverInfoString, "1.6.16.11 (19.5.8f01)"))
+								{
+									fields.m_badDriver1064NV = true;
+								}
+							}
+							break;
+						}						
+					}
+					
+					if (selected)
+					{
+						// dupe check
+						FOR_EACH_VEC( *m_renderers, i )
+						{
+							uint rendid = (*m_renderers)[i]->m_info.m_rendererID;
+							
+							if ( rendid == fields.m_rendererID )
+							{
+								// don't add to table, it's a dupe
+								selected = false;
+							}
+						}
+					}
+					
+					if (selected)
+					{
+						// criteria check
+						if (fields.m_fullscreen==0)
+							selected = false;
+						if (fields.m_accelerated==0)
+							selected = false;
+						if (fields.m_windowed==0)
+							selected = false;
+					}
+
+					Assert( fields.m_displayMask != 0 );
+					
+					if (selected)
+					{
+						// add to table
+						// note this constructor makes a dummy context just long enough to query remaining fields in the m_info.
+						GLMRendererInfo *newinfo = new GLMRendererInfo( &fields );
+						m_renderers->AddToTail( newinfo );
+					}
+				}
+				if (cgl_rend)
+				{
+					CGLDestroyRendererInfo( cgl_rend );
+				}
+			}
+		}
+	}
+	
+	// now sort the table.
+	m_renderers->Sort( RendererInfoSortFunction );
+
+	// then go back and ask each renderer to populate its display info table.
+	FOR_EACH_VEC( *m_renderers, i )
+	{
+		(*m_renderers)[i]->PopulateDisplays();
+	}
+}
+
+void	GLMDisplayDB::PopulateFakeAdapters( uint realRendererIndex )		// fake adapters = one real adapter times however many displays are on it
+{
+	// presumption is that renderers have been populated.
+	Assert( GetRendererCount() > 0 );
+	Assert( realRendererIndex < GetRendererCount() );
+	
+	m_fakeAdapters.RemoveAll();
+	
+	// for( int r = 0; r < GetRendererCount(); r++ )
+	int r = realRendererIndex;
+	{
+		for( int d = 0; d < GetDisplayCount( r ); d++ )
+		{
+			GLMFakeAdapter temp;
+			
+			temp.m_rendererIndex = r;
+			temp.m_displayIndex = d;
+			
+			m_fakeAdapters.AddToTail( temp );
+		}
+	}
+}
+
+void	GLMDisplayDB::Populate(void)
+{
+	this->PopulateRenderers();
+	
+	// passing in zero here, constrains the set of fake adapters (GL renderer + a display) to the ones using the highest ranked renderer.
+	//FIXME introduce some kind of convar allowing selection of other GPU's in the system.
+	
+	int realRendererIndex = 0;
+
+	if (CommandLine()->FindParm("-glmrenderer0"))
+		realRendererIndex = 0;
+	if (CommandLine()->FindParm("-glmrenderer1"))
+		realRendererIndex = 1;
+	if (CommandLine()->FindParm("-glmrenderer2"))
+		realRendererIndex = 2;
+	if (CommandLine()->FindParm("-glmrenderer3"))
+		realRendererIndex = 3;
+		
+	if (realRendererIndex >= GetRendererCount())
+	{
+		// fall back to 0
+		realRendererIndex = 0;
+	}
+	
+	this->PopulateFakeAdapters( 0 );
+
+	#if GLMDEBUG
+		this->Dump();
+	#endif
+}
+	
+
+
+int		GLMDisplayDB::GetFakeAdapterCount( void )
+{
+	return m_fakeAdapters.Count();
+}
+
+bool	GLMDisplayDB::GetFakeAdapterInfo( int fakeAdapterIndex, int *rendererOut, int *displayOut, GLMRendererInfoFields *rendererInfoOut, GLMDisplayInfoFields *displayInfoOut )
+{
+	if (fakeAdapterIndex >= GetFakeAdapterCount() )
+	{
+		*rendererOut = 0;
+		*displayOut = 0;
+		return true;		// fail
+	}
+
+	*rendererOut = m_fakeAdapters[fakeAdapterIndex].m_rendererIndex;
+	*displayOut = m_fakeAdapters[fakeAdapterIndex].m_displayIndex;
+
+	bool rendResult = GetRendererInfo( *rendererOut, rendererInfoOut );
+	bool dispResult = GetDisplayInfo( *rendererOut, *displayOut, displayInfoOut );
+	
+	return rendResult || dispResult;
+}
+	
+
+int		GLMDisplayDB::GetRendererCount( void )
+{
+	return	m_renderers->Count();
+}
+
+bool	GLMDisplayDB::GetRendererInfo( int rendererIndex, GLMRendererInfoFields *infoOut )
+{
+	memset( infoOut, 0, sizeof( GLMRendererInfoFields ) );
+
+	if (rendererIndex >= GetRendererCount())
+		return true; // fail
+	
+	GLMRendererInfo *rendInfo = (*m_renderers)[rendererIndex];		
+	*infoOut = rendInfo->m_info;
+
+	return false;
+}
+
+int		GLMDisplayDB::GetDisplayCount( int rendererIndex )
+{
+	if (rendererIndex >= GetRendererCount())
+		return 0; // fail
+	
+	GLMRendererInfo *rendInfo = (*m_renderers)[rendererIndex];
+		
+	return	rendInfo->m_displays->Count();
+}
+
+bool	GLMDisplayDB::GetDisplayInfo( int rendererIndex, int displayIndex, GLMDisplayInfoFields *infoOut )
+{
+	memset( infoOut, 0, sizeof( GLMDisplayInfoFields ) );
+	
+	if (rendererIndex >= GetRendererCount())
+		return true; // fail
+	
+	if (displayIndex >= GetDisplayCount(rendererIndex))
+		return true; // fail
+	
+	GLMDisplayInfo *displayInfo = (*(*m_renderers)[rendererIndex]->m_displays)[displayIndex];
+	*infoOut = displayInfo->m_info;
+
+	return false;
+}
+
+int		GLMDisplayDB::GetModeCount( int rendererIndex, int displayIndex )
+{
+	if (rendererIndex >= GetRendererCount())
+		return 0; // fail
+	
+	if (displayIndex >= GetDisplayCount(rendererIndex))
+		return 0; // fail
+		
+	GLMDisplayInfo *displayInfo = (*(*m_renderers)[rendererIndex]->m_displays)[displayIndex];
+
+	return displayInfo->m_modes->Count();
+}
+
+bool	GLMDisplayDB::GetModeInfo( int rendererIndex, int displayIndex, int modeIndex, GLMDisplayModeInfoFields *infoOut )
+{
+	memset( infoOut, 0, sizeof( GLMDisplayModeInfoFields ) );
+	
+	if (rendererIndex >= GetRendererCount())
+		return true; // fail
+	
+	if (displayIndex >= GetDisplayCount(rendererIndex))
+		return true; // fail
+	
+	if (modeIndex >= GetModeCount(rendererIndex,displayIndex))
+		return true; // fail
+	
+	if (modeIndex>=0)
+	{
+		GLMDisplayMode *displayModeInfo = (*(*(*m_renderers)[rendererIndex]->m_displays)[displayIndex]->m_modes)[ modeIndex ];
+		*infoOut = displayModeInfo->m_info;
+	}
+	else
+	{
+		// passing modeIndex = -1 means "tell me about current mode"..
+
+		GLMRendererInfo		*rendInfo = (*m_renderers)[ rendererIndex ];
+		GLMDisplayInfo		*dispinfo = (*rendInfo ->m_displays)[displayIndex];	
+		CGDirectDisplayID	cgid = dispinfo->m_info.m_cgDisplayID;
+		
+		CFDictionaryRef		curModeDict = CGDisplayCurrentMode( cgid );
+		CFNumberRef			number;
+		CFBooleanRef		boolean;
+		CFArrayRef			modeList;
+		CGDisplayErr		cgderr;
+		
+		// get the mode number from the mode dict (using system mode numbering, not our sorted numbering)
+		if (curModeDict)
+		{
+			int modeIndex=0;
+			number = (CFNumberRef)CFDictionaryGetValue(curModeDict, kCGDisplayMode);
+			CFNumberGetValue(number, kCFNumberLongType, &modeIndex);
+
+			// grab the width and height, I am unclear on whether this is the displayed FB width or the display device width.
+			int screenWidth=0;
+			int screenHeight=0;
+			int refreshHz=0;
+			
+			number = (CFNumberRef)CFDictionaryGetValue(curModeDict, kCGDisplayWidth);
+			CFNumberGetValue(number, kCFNumberLongType, &screenWidth);
+			number = (CFNumberRef)CFDictionaryGetValue(curModeDict, kCGDisplayHeight);
+			CFNumberGetValue(number, kCFNumberLongType, &screenHeight);
+			number = (CFNumberRef)CFDictionaryGetValue(curModeDict, kCGDisplayRefreshRate);
+			CFNumberGetValue(number, kCFNumberLongType, &refreshHz);
+			
+			GLMPRINTF(( "-D- GLMDisplayDB::GetModeInfo sees mode-index=%d, width=%d, height=%d on CGID %08x (display index %d on rendererindex %d)", 
+				modeIndex,
+				screenWidth,
+				screenHeight,
+				cgid,
+				displayIndex,
+				rendererIndex ));
+
+			// now match
+			int foundIndex = -1;
+			FOR_EACH_VEC( (*dispinfo->m_modes), i )
+			{
+				GLMDisplayMode *mode = (*dispinfo->m_modes)[i];
+				
+				if (mode->m_info.m_modePixelWidth == screenWidth)
+				{
+					if (mode->m_info.m_modePixelHeight == screenHeight)
+					{
+						if (mode->m_info.m_modeRefreshHz == refreshHz)
+						{
+							foundIndex = i;
+							*infoOut = mode->m_info;
+							return false;
+						}
+					}
+				}
+			}
+		}
+
+		// if we get here, we could not find the mode
+		memset( infoOut, 0, sizeof( *infoOut ) );
+		return true; // fail
+	}
+	return false;
+}
+
+
+void	GLMDisplayDB::Dump( void )
+{
+	GLMPRINTF(("\n GLMDisplayDB @ %08x ",this ));
+
+	FOR_EACH_VEC( *m_renderers, i )
+	{
+		(*m_renderers)[i]->Dump(i);
+	}
+}
+
+//===============================================================================
+
+GLMDisplayInfo::GLMDisplayInfo( CGDirectDisplayID displayID, CGOpenGLDisplayMask displayMask )
+{	
+	m_info.m_cgDisplayID			= displayID;
+	m_info.m_glDisplayMask			= displayMask;
+	
+	// extract info about this display such as pixel width and height
+	m_info.m_displayPixelWidth		= (uint)CGDisplayPixelsWide( m_info.m_cgDisplayID );
+	m_info.m_displayPixelHeight		= (uint)CGDisplayPixelsHigh( m_info.m_cgDisplayID );
+
+	m_modes = NULL;
+}
+
+GLMDisplayInfo::~GLMDisplayInfo( void )
+{
+	if (m_modes)
+	{
+		// delete all the new'd display modes
+		FOR_EACH_VEC( *m_modes, i )
+		{
+			delete (*this->m_modes)[i];
+		}
+		delete m_modes;
+		m_modes = NULL;
+	}
+}
+
+
+extern "C" int DisplayModeSortFunction( GLMDisplayMode * const *A, GLMDisplayMode * const *B )
+{
+	int bigger = -1;
+	int smaller = 1;	// adjust these for desired ordering
+
+	// check refreshrate - higher should win
+	if ( (*A)->m_info.m_modeRefreshHz > (*B)->m_info.m_modeRefreshHz )
+	{	
+		return bigger;
+	}
+	else if ( (*A)->m_info.m_modeRefreshHz < (*B)->m_info.m_modeRefreshHz )
+	{
+		return smaller;
+	}
+
+	// check area - larger mode should win
+	int areaa = (*A)->m_info.m_modePixelWidth * (*A)->m_info.m_modePixelHeight;
+	int areab = (*B)->m_info.m_modePixelWidth * (*B)->m_info.m_modePixelHeight;
+
+	if ( areaa > areab )
+	{	
+		return bigger;
+	}
+	else if ( areaa < areab )
+	{
+		return smaller;
+	}
+	
+	return 0;	// equal rank
+}
+
+
+void	GLMDisplayInfo::PopulateModes( void )
+{
+	Assert( !m_modes );
+	m_modes = new CUtlVector< GLMDisplayMode* >;
+	
+	CFArrayRef		modeList;
+//	CGDisplayErr	cgderr;
+	CFDictionaryRef cgvidmode;
+	CFNumberRef		number;
+	CFBooleanRef	boolean;
+	
+	modeList = CGDisplayAvailableModes( m_info.m_cgDisplayID );
+	if ( modeList != NULL )
+	{
+		//  examine each mode
+		CFIndex count = CFArrayGetCount( modeList );
+		
+		for (CFIndex i = 0; i < count; i++) 
+		{
+			long modeHeight = 0, modeWidth = 0;
+			long depth = 0;
+			long refreshrate = 0;
+			Boolean usable, stretched = false;
+			
+			// grab the mode dictionary
+			cgvidmode = (CFDictionaryRef)CFArrayGetValueAtIndex( modeList, i);
+			
+			// grab mode params we need
+			number = (CFNumberRef)CFDictionaryGetValue(cgvidmode, kCGDisplayBitsPerPixel);
+			CFNumberGetValue(number, kCFNumberLongType, &depth);
+			
+			boolean = (CFBooleanRef)CFDictionaryGetValue(cgvidmode, kCGDisplayModeUsableForDesktopGUI) ;
+			usable = CFBooleanGetValue(boolean);
+			
+			boolean = (CFBooleanRef)CFDictionaryGetValue(cgvidmode, kCGDisplayModeIsStretched);
+			if (NULL != boolean) 
+			{
+				stretched = CFBooleanGetValue(boolean);
+			}
+			
+			if ( usable && (!stretched) && (depth==32) )
+			{
+				// we're going to log this mode to the mode table.
+				
+				// get height of mode
+				number = (CFNumberRef)CFDictionaryGetValue( cgvidmode, kCGDisplayHeight );
+				CFNumberGetValue(number, kCFNumberLongType, &modeHeight);
+				
+				// get width of mode
+				number = (CFNumberRef)CFDictionaryGetValue( cgvidmode, kCGDisplayWidth );
+				CFNumberGetValue(number, kCFNumberLongType, &modeWidth);
+				
+				// get refresh rate of mode
+				number = (CFNumberRef)CFDictionaryGetValue( cgvidmode, kCGDisplayRefreshRate ); 
+				double flrefreshrate = 0.0f;
+				CFNumberGetValue( number, kCFNumberDoubleType, &flrefreshrate );
+				refreshrate = (int)flrefreshrate;
+
+				// exclude silly small modes
+				if ( (modeHeight >= 384) && (modeWidth >= 512) )
+				{
+					GLMDisplayMode *newmode = new GLMDisplayMode( modeWidth, modeHeight, refreshrate );
+					m_modes->AddToTail( newmode );
+				}
+			}
+		}
+	}
+	
+	// now sort the modes
+	// primary key is refresh rate
+	// secondary key is area
+
+	m_modes->Sort( DisplayModeSortFunction );
+}
+
+
+void	GLMDisplayInfo::Dump( int which )
+{
+	GLMPRINTF(("\n         #%d: GLMDisplayInfo @ %08x, cg-id=%08x  display-mask=%08x  pixwidth=%d  pixheight=%d", which, (int)this, m_info.m_cgDisplayID, m_info.m_glDisplayMask, m_info.m_displayPixelWidth,  m_info.m_displayPixelHeight ));
+
+	FOR_EACH_VEC( *m_modes, i )
+	{
+		(*m_modes)[i]->Dump(i);
+	}
+}