1HEADmaster

1 files changed, 6092 insertions, 0 deletions

diff --git a/togl/linuxwin/glmgr.cpp b/togl/linuxwin/glmgr.cpp
new file mode 100644
index 0000000..1c18720
--- /dev/null
+++ b/togl/linuxwin/glmgr.cpp
@@ -0,0 +1,6092 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//                       TOGL CODE LICENSE
+//
+//  Copyright 2011-2014 Valve Corporation
+//  All Rights Reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+// glmgr.cpp
+//
+//===============================================================================
+#include "togl/rendermechanism.h"
+
+#include "tier0/icommandline.h"
+
+#include "tier0/vprof.h"
+#include "glmtexinlines.h"
+
+#include "materialsystem/IShader.h"
+#include "appframework/ilaunchermgr.h"
+
+#include "convar.h"
+
+#include "glmgr_flush.inl"
+
+#ifdef OSX
+#include <OpenGL/OpenGL.h>
+#include "intelglmallocworkaround.h"
+#endif
+
+// memdbgon -must- be the last include file in a .cpp file.
+#include "tier0/memdbgon.h"
+
+
+// Whether the code should use gl_arb_debug_output. This causes error messages to be streamed, via callback, to the application. 
+// It is much friendlier to the MTGL driver. 
+// NOTE: This can be turned off after launch, but it cannot be turned on after launch--it implies a context-creation-time 
+// behavior.
+ConVar gl_debug_output( "gl_debug_output", "1" );
+
+
+// Whether or not we should batch up our creation and deletion behavior. 
+ConVar gl_batch_tex_creates( "gl_batch_tex_creates", "0" );
+ConVar gl_batch_tex_destroys( "gl_batch_tex_destroys", "0" ); 
+
+//===============================================================================
+
+// g_nTotalDrawsOrClears is reset to 0 in Present()
+uint g_nTotalDrawsOrClears, g_nTotalVBLockBytes, g_nTotalIBLockBytes;
+
+#if GL_TELEMETRY_GPU_ZONES
+TelemetryGPUStats_t g_TelemetryGPUStats;
+#endif
+
+const int kGLMInitialTexCount = 4096;
+const int kGLMReUpTexCount = 1024;
+const int kGLMHighWaterUndeleted = 2048;
+const int kDeletedTextureDim = 4;
+const uint32 g_garbageTextureBits[ 4 * kDeletedTextureDim * kDeletedTextureDim ] = { 0 };
+
+char g_nullFragmentProgramText [] =
+{
+	"!!ARBfp1.0  \n"
+	"PARAM black = { 0.0, 0.0, 0.0, 1.0 };  \n"		// opaque black
+	"MOV result.color, black;  \n"
+	"END  \n\n\n"
+	"//GLSLfp\n"
+	"void main()\n"
+	"{\n"
+	"gl_FragColor = vec4( 0.0, 0.0, 0.0, 1.0 );\n"
+	"}\n"
+	
+};
+
+// make dummy programs for doing texture preload via dummy draw
+char g_preloadTexVertexProgramText[] =
+{
+	"//GLSLvp  \n"
+	"#version 120  \n"
+	"varying vec4 otex;  \n"
+	"void main()  \n"
+	"{  \n"
+	"vec4 pos = ftransform(); // vec4( 0.1, 0.1, 0.1, 0.1 );  \n"
+	"vec4 tex = vec4( 0.0, 0.0, 0.0, 0.0 );  \n"
+	"  \n"
+	"gl_Position = pos;  \n"
+	"otex = tex;  \n"
+	"}  \n"
+};
+
+char g_preload2DTexFragmentProgramText[] =
+{
+	"//GLSLfp  \n"
+	"#version 120  \n"
+	"varying vec4 otex;  \n"
+	"//SAMPLERMASK-8000		// may not be needed  \n"
+	"//HIGHWATER-30			// may not be needed  \n"
+	"  \n"
+	"uniform vec4 pc[31];  \n"
+	"uniform sampler2D sampler15;  \n"
+	"  \n"
+	"void main()  \n"
+	"{  \n"
+	"vec4 r0;  \n"
+	"r0 = texture2D( sampler15, otex.xy );  \n"
+	"gl_FragColor = r0;	//discard;  \n"
+	"}  \n"
+};
+
+char g_preload3DTexFragmentProgramText[] =
+{
+	"//GLSLfp  \n"
+	"#version 120  \n"
+	"varying vec4 otex;  \n"
+	"//SAMPLERMASK-8000		// may not be needed  \n"
+	"//HIGHWATER-30			// may not be needed  \n"
+	"  \n"
+	"uniform vec4 pc[31];  \n"
+	"uniform sampler3D sampler15;  \n"
+	"  \n"
+	"void main()  \n"
+	"{  \n"
+	"vec4 r0;  \n"
+	"r0 = texture3D( sampler15, otex.xyz );  \n"
+	"gl_FragColor = r0;	//discard;  \n"
+	"}  \n"
+};
+
+char g_preloadCubeTexFragmentProgramText[] =
+{
+	"//GLSLfp  \n"
+	"#version 120  \n"
+	"varying vec4 otex;  \n"
+	"//SAMPLERMASK-8000		// may not be needed  \n"
+	"//HIGHWATER-30			// may not be needed  \n"
+	"  \n"
+	"uniform vec4 pc[31];  \n"
+	"uniform samplerCube sampler15;  \n"
+	"  \n"
+	"void main()  \n"
+	"{  \n"
+	"vec4 r0;  \n"
+	"r0 = textureCube( sampler15, otex.xyz );  \n"
+	"gl_FragColor = r0;	//discard;  \n"
+	"}  \n"
+};
+
+const char* glSourceToString(GLenum source)
+{
+	switch (source)
+	{
+		case GL_DEBUG_SOURCE_API_ARB:				return "API";
+		case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB:		return "WINDOW_SYSTEM";
+		case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB:	return "SHADER_COMPILER";
+		case GL_DEBUG_SOURCE_THIRD_PARTY_ARB:		return "THIRD_PARTY";
+		case GL_DEBUG_SOURCE_APPLICATION_ARB:		return "APPLICATION";
+		case GL_DEBUG_SOURCE_OTHER_ARB:				return "OTHER";
+		default:									break;
+	}
+	return "UNKNOWN";
+}
+
+const char* glTypeToString(GLenum type)
+{
+	switch (type)
+	{
+		case GL_DEBUG_TYPE_ERROR_ARB:				return "ERROR";
+		case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:	return "DEPRECATION";
+		case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:	return "UNDEFINED_BEHAVIOR";
+		case GL_DEBUG_TYPE_PORTABILITY_ARB:			return "PORTABILITY";
+		case GL_DEBUG_TYPE_PERFORMANCE_ARB:			return "PERFORMANCE";
+		case GL_DEBUG_TYPE_OTHER_ARB:				return "OTHER";
+		default:									break;
+	}
+	return "UNKNOWN";
+}
+
+const char* glSeverityToString(GLenum severity)
+{
+	switch (severity)
+	{
+		case GL_DEBUG_SEVERITY_HIGH_ARB:			return "HIGH";
+		case GL_DEBUG_SEVERITY_MEDIUM_ARB:			return "MEDIUM";
+		case GL_DEBUG_SEVERITY_LOW_ARB:				return "LOW";
+		default:									break;
+	}
+	return "UNKNOWN";
+}
+
+bool g_bDebugOutputBreakpoints = true;
+
+void APIENTRY GL_Debug_Output_Callback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, GLvoid* userParam)
+{
+	const char *sSource = glSourceToString(source),
+		       *sType = glTypeToString(type),
+			   *sSeverity = glSeverityToString(severity);
+	
+	// According to NVidia, this error is a bug in the driver and not really an error (it's a warning in newer drivers): "Texture X is base level inconsistent. Check texture size"
+	if (  ( type == GL_DEBUG_TYPE_ERROR_ARB ) && strstr( message, "base level inconsistent" ) )
+	{
+		return;
+	}
+	
+	if ( gl_debug_output.GetBool() || type == GL_DEBUG_TYPE_ERROR_ARB )
+	{
+		Msg( "GL: [%s][%s][%s][%d]: %s\n", sSource, sType, sSeverity, id, message );
+	}
+
+#ifdef WIN32
+	OutputDebugStringA( message );
+#endif
+			
+	if ( ( type == GL_DEBUG_TYPE_ERROR_ARB ) && ( g_bDebugOutputBreakpoints ) )
+	{
+		DebuggerBreak();
+	}
+}
+
+void GLMDebugPrintf( const char *pMsg, ... )
+{
+	//$ TODO: Should this call Warning()?
+	//$ TODO: Should replace call these calls with Warning() / Msg() / DevMsg()?
+
+	va_list args;
+	va_start( args, pMsg );
+	vprintf( pMsg, args );
+	va_end( args );
+}
+
+//===============================================================================
+// functions that are dependant on g_pLauncherMgr
+
+inline bool MakeContextCurrent( PseudoGLContextPtr hContext ) 
+{
+	return g_pLauncherMgr->MakeContextCurrent( hContext );
+}
+
+inline PseudoGLContextPtr GetMainContext()
+{
+	return g_pLauncherMgr->GetMainContext();
+}
+
+inline PseudoGLContextPtr GetGLContextForWindow( void* windowref )
+{
+	return g_pLauncherMgr->GetGLContextForWindow( windowref );
+}
+
+inline void IncrementWindowRefCount()
+{
+	g_pLauncherMgr->IncWindowRefCount();
+}
+inline void DecrementWindowRefCount()
+{
+	g_pLauncherMgr->DecWindowRefCount();
+}
+inline void ShowPixels( CShowPixelsParams *params )
+{
+	g_pLauncherMgr->ShowPixels(params);
+}
+
+inline void DisplayedSize( uint &width, uint &height ) 
+{
+	g_pLauncherMgr->DisplayedSize( width, height );
+}
+
+inline void GetDesiredPixelFormatAttribsAndRendererInfo( uint **ptrOut, uint *countOut, GLMRendererInfoFields *rendInfoOut )
+{
+	g_pLauncherMgr->GetDesiredPixelFormatAttribsAndRendererInfo( ptrOut, countOut, rendInfoOut );
+}
+
+inline void GetStackCrawl( CStackCrawlParams *params )
+{
+	g_pLauncherMgr->GetStackCrawl(params);
+}
+
+#if GLMDEBUG
+inline void PumpWindowsMessageLoop()
+{
+	g_pLauncherMgr->PumpWindowsMessageLoop();
+}
+inline int GetEvents( CCocoaEvent *pEvents, int nMaxEventsToReturn, bool debugEvents = false ) 
+{
+	return g_pLauncherMgr->GetEvents( pEvents, nMaxEventsToReturn, debugEvents );
+}
+#endif
+
+//===============================================================================
+// helper routines for debug
+
+static bool hasnonzeros( float *values, int count )
+{
+	for( int i=0; i<count; i++)
+	{
+		if (values[i] != 0.0)
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+static void printmat( char *label, int baseSlotNumber, int slots, float *m00 )
+{
+	// print label..
+	// fetch 4 from row, print as a row
+	// fetch 4 from column, print as a row
+	
+	float	row[4];
+	float	col[4];
+	
+	if (hasnonzeros( m00, slots*4) )
+	{
+		GLMPRINTF(("-D-  %s", label ));
+		for( int islot=0; islot<4; islot++ )			// we always run this loop til 4, but we special case the printing if there are only 3 submitted
+		{
+			// extract row and column floats
+			for( int slotcol=0; slotcol<4; slotcol++)
+			{
+				//copy
+				row[slotcol] = m00[(islot*4)+slotcol];
+				
+				// transpose
+				col[slotcol] = m00[(slotcol*4)+islot];
+			}
+			if (slots==4)
+			{
+				GLMPRINTF((		"-D-    %03d: [ %10.5f %10.5f %10.5f %10.5f ] T=> [ %10.5f %10.5f %10.5f %10.5f ]",
+								baseSlotNumber+islot,
+								row[0],row[1],row[2],row[3],
+								col[0],col[1],col[2],col[3]						
+								));
+			}
+			else
+			{
+				if (islot<3)
+				{
+					GLMPRINTF((		"-D-    %03d: [ %10.5f %10.5f %10.5f %10.5f ] T=> [ %10.5f %10.5f %10.5f ]",
+									baseSlotNumber+islot,
+									row[0],row[1],row[2],row[3],
+									col[0],col[1],col[2]
+									));
+				}
+				else
+				{
+					GLMPRINTF((		"-D-    %03d:                                                 T=> [ %10.5f %10.5f %10.5f ]",
+									baseSlotNumber+islot,
+									col[0],col[1],col[2]
+									));
+				}
+			}
+		}
+		GLMPRINTSTR(("-D-"));
+	}
+	else
+	{
+		GLMPRINTF(("-D-  %s - (all 0.0)", label ));
+	}
+
+}
+
+
+static void transform_dp4( float *in4, float *m00, int slots, float *out4 )
+{
+	// m00 points to a column.
+	// each DP is one column of the matrix ( m00[4*n]
+	// if we are passed a three slot matrix, this is three columns, the source W plays into all three columns, but we must set the final output W to 1 ?
+	for( int n=0; n<slots; n++)
+	{
+		float col4[4];
+		
+		col4[0] = m00[(4*n)+0];
+		col4[1] = m00[(4*n)+1];
+		col4[2] = m00[(4*n)+2];
+		col4[3] = m00[(4*n)+3];
+		
+		out4[n] = 0.0;
+		for( int inner = 0; inner < 4; inner++ )
+		{
+			out4[n] += in4[inner] * col4[inner];
+		}
+	}
+	if (slots==3)
+	{
+		out4[3] = 1.0;
+	}
+}
+
+//===============================================================================
+
+
+//===============================================================================
+// GLMgr static methods
+
+GLMgr	*g_glmgr = NULL;
+
+void GLMgr::NewGLMgr( void )
+{
+	if (!g_glmgr)
+	{
+		#if GLMDEBUG
+			// check debug mode early in program lifetime
+			GLMDebugInitialize( true );
+		#endif
+
+		g_glmgr = new GLMgr;
+	}
+}
+
+GLMgr *GLMgr::aGLMgr( void )
+{
+	assert( g_glmgr != NULL);
+	return g_glmgr;
+}
+
+void	GLMgr::DelGLMgr( void )
+{
+	if (g_glmgr)
+	{
+		delete g_glmgr;
+		g_glmgr = NULL;
+	}
+}
+
+// GLMgr class methods
+
+GLMgr::GLMgr()
+{
+}	
+
+
+GLMgr::~GLMgr()
+{
+}
+
+//===============================================================================
+
+GLMContext *GLMgr::NewContext( IDirect3DDevice9 *pDevice, GLMDisplayParams *params )
+{
+	// this now becomes really simple.  We just pass through the params.
+	
+	return new GLMContext( pDevice, params );
+}
+
+void GLMgr::DelContext( GLMContext *context )
+{
+	delete context;
+}
+
+void GLMgr::SetCurrentContext( GLMContext *context )
+{
+#if defined( USE_SDL )
+	context->m_nCurOwnerThreadId = ThreadGetCurrentId();
+	if ( !MakeContextCurrent( context->m_ctx ) )
+	{
+		// give up
+		GLMStop();
+	}
+	Assert( 0 );
+#endif
+}
+
+GLMContext *GLMgr::GetCurrentContext( void )
+{
+#if defined( USE_SDL )
+	PseudoGLContextPtr context = GetMainContext();
+	return (GLMContext*) context;
+#else
+	Assert( 0 );
+	return NULL;
+#endif
+}
+	
+
+// #define CHECK_THREAD_USAGE	1
+
+
+//===============================================================================
+// GLMContext public methods
+void GLMContext::MakeCurrent( bool bRenderThread )
+{
+	tmZone( TELEMETRY_LEVEL0, 0, "GLMContext::MakeCurrent" );
+	Assert( m_nCurOwnerThreadId == 0 || m_nCurOwnerThreadId == ThreadGetCurrentId() );
+		
+#if defined( USE_SDL )
+
+#ifndef CHECK_THREAD_USAGE
+	if ( bRenderThread )
+	{
+//		Msg( "********************************************  %08x Acquiring Context\n", ThreadGetCurrentId() );
+		m_nCurOwnerThreadId = ThreadGetCurrentId();
+		bool bSuccess = MakeContextCurrent( m_ctx );
+		if ( !bSuccess )
+		{
+			Assert( 0 );
+		}
+	}
+#else
+	uint32 dwThreadId = ThreadGetCurrentId();
+
+	if ( bRenderThread || dwThreadId == m_dwRenderThreadId )
+	{
+		m_nCurOwnerThreadId = ThreadGetCurrentId();
+		m_dwRenderThreadId = dwThreadId;
+		MakeContextCurrent( m_ctx );
+		m_bIsThreading = true;
+	}
+	else if ( !m_bIsThreading )
+	{
+		m_nCurOwnerThreadId = ThreadGetCurrentId();
+		MakeContextCurrent( m_ctx );
+	}
+	else
+	{
+		Assert( 0 );
+	}
+#endif
+
+#else
+	Assert( 0 );
+#endif
+}
+
+
+void GLMContext::ReleaseCurrent( bool bRenderThread )
+{
+	tmZone( TELEMETRY_LEVEL0, 0, "GLMContext::ReleaseCurrent" );
+	Assert( m_nCurOwnerThreadId == ThreadGetCurrentId() );
+		
+#if defined( USE_SDL )
+
+#ifndef CHECK_THREAD_USAGE
+	if ( bRenderThread )
+	{
+//		Msg( "********************************************  %08x Releasing Context\n", ThreadGetCurrentId() );
+		m_nCurOwnerThreadId = 0;
+		m_nThreadOwnershipReleaseCounter++;
+		MakeContextCurrent( NULL );
+	}
+#else
+	m_nCurOwnerThreadId = 0;
+	m_nThreadOwnershipReleaseCounter++;
+	MakeContextCurrent( NULL );
+	if ( bRenderThread )
+	{
+		m_bIsThreading = false;
+	}
+#endif
+
+#else
+	Assert( 0 );
+#endif
+}
+
+
+// This function forces all GL state to be re-sent to the context. Some state will only be set on the next batch flush.
+void GLMContext::ForceFlushStates()
+{
+	// Flush various render states
+	m_AlphaTestEnable.Flush();
+	m_AlphaTestFunc.Flush();
+
+	m_DepthBias.Flush();
+
+	m_ScissorEnable.Flush();	
+	m_ScissorBox.Flush();
+
+	m_ViewportBox.Flush();		
+	m_ViewportDepthRange.Flush();
+
+	m_ColorMaskSingle.Flush();	
+
+	m_BlendEnable.Flush();
+	m_BlendFactor.Flush();
+
+	m_BlendEnableSRGB.Flush();
+
+	m_DepthTestEnable.Flush();
+	m_DepthFunc.Flush();
+	m_DepthMask.Flush();
+
+	m_StencilTestEnable.Flush();
+	m_StencilFunc.Flush();
+	m_StencilOp.Flush();
+	m_StencilWriteMask.Flush();
+
+	m_ClearColor.Flush();
+	m_ClearDepth.Flush();
+	m_ClearStencil.Flush();
+
+	m_ClipPlaneEnable.Flush();	// always push clip state
+	m_ClipPlaneEquation.Flush();
+
+	m_CullFaceEnable.Flush();
+
+	m_CullFrontFace.Flush();
+
+	m_PolygonMode.Flush();
+
+	m_AlphaToCoverageEnable.Flush();
+	m_ColorMaskMultiple.Flush();
+	m_BlendEquation.Flush();
+	m_BlendColor.Flush();
+	// Reset various things so they get reset on the next batch flush
+	m_activeTexture = -1;
+
+	for ( int i = 0; i < GLM_SAMPLER_COUNT; i++ )
+	{
+		SetSamplerTex( i, m_samplers[i].m_pBoundTex );
+		SetSamplerDirty( i );
+	}
+
+	// Attributes/vertex attribs
+	ClearCurAttribs();
+
+	m_lastKnownVertexAttribMask = 0;
+	m_nNumSetVertexAttributes = 16;
+	memset( &m_boundVertexAttribs[0], 0xFF, sizeof( m_boundVertexAttribs ) );
+	for( int index=0; index < kGLMVertexAttributeIndexMax; index++ )
+		gGL->glDisableVertexAttribArray( index );
+
+	// Program
+	NullProgram();
+
+	// FBO
+	BindFBOToCtx( m_boundReadFBO, GL_READ_FRAMEBUFFER_EXT );
+	BindFBOToCtx( m_boundDrawFBO, GL_DRAW_FRAMEBUFFER_EXT );
+
+	// Current VB/IB/pinned memory buffers
+	gGL->glBindBufferARB( GL_ELEMENT_ARRAY_BUFFER_ARB, m_nBoundGLBuffer[ kGLMIndexBuffer] );
+	gGL->glBindBufferARB( GL_ARRAY_BUFFER_ARB, m_nBoundGLBuffer[ kGLMVertexBuffer] );
+
+#ifndef OSX
+	if ( gGL->m_bHave_GL_AMD_pinned_memory )
+	{
+		gGL->glBindBufferARB( GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, m_PinnedMemoryBuffers[m_nCurPinnedMemoryBuffer].GetHandle() );
+	}
+#endif
+}
+
+const GLMRendererInfoFields& GLMContext::Caps( void )
+{
+	return m_caps;
+}
+
+void GLMContext::DumpCaps( void )
+{
+	/*
+		#define	dumpfield( fff ) printf( "\n  "#fff" : %d", (int) m_caps.fff )
+		#define	dumpfield_hex( fff ) printf( "\n  "#fff" : 0x%08x", (int) m_caps.fff )
+		#define	dumpfield_str( fff ) printf( "\n  "#fff" : %s", m_caps.fff )
+	*/
+
+	#define	dumpfield( fff )		printf( "\n  %-30s : %d", #fff, (int) m_caps.fff )
+	#define	dumpfield_hex( fff )	printf( "\n  %-30s : 0x%08x", #fff, (int) m_caps.fff )
+	#define	dumpfield_str( fff )	printf( "\n  %-30s : %s", #fff, m_caps.fff )
+
+	printf("\n-------------------------------- context caps for context %08x", (uint)this);
+
+	dumpfield( m_fullscreen );
+	dumpfield( m_accelerated );
+	dumpfield( m_windowed );
+	dumpfield_hex( m_rendererID );
+	dumpfield( m_displayMask );
+	dumpfield( m_bufferModes );
+	dumpfield( m_colorModes );
+	dumpfield( m_accumModes );
+	dumpfield( m_depthModes );
+	dumpfield( m_stencilModes );
+	dumpfield( m_maxAuxBuffers );
+	dumpfield( m_maxSampleBuffers );
+	dumpfield( m_maxSamples );
+	dumpfield( m_sampleModes );
+	dumpfield( m_sampleAlpha );
+	dumpfield_hex( m_vidMemory );
+	dumpfield_hex( m_texMemory );
+
+	dumpfield_hex( m_pciVendorID );
+	dumpfield_hex( m_pciDeviceID );
+	dumpfield_str( m_pciModelString );
+	dumpfield_str( m_driverInfoString );
+
+	printf( "\n  m_osComboVersion: 0x%08x (%d.%d.%d)", m_caps.m_osComboVersion, (m_caps.m_osComboVersion>>16)&0xFF, (m_caps.m_osComboVersion>>8)&0xFF, (m_caps.m_osComboVersion)&0xFF );
+
+	dumpfield( m_ati );
+	if (m_caps.m_ati)
+	{
+		dumpfield( m_atiR5xx );
+		dumpfield( m_atiR6xx );
+		dumpfield( m_atiR7xx );
+		dumpfield( m_atiR8xx );
+		dumpfield( m_atiNewer );
+	}
+
+	dumpfield( m_intel );
+	if (m_caps.m_intel)
+	{
+		dumpfield( m_intel95x );
+		dumpfield( m_intel3100 );
+		dumpfield( m_intelHD4000 );
+	}
+
+	dumpfield( m_nv );
+	if (m_caps.m_nv)
+	{
+		//dumpfield( m_nvG7x );
+		dumpfield( m_nvG8x );
+		dumpfield( m_nvNewer );
+	}
+
+	dumpfield( m_hasGammaWrites );
+	dumpfield( m_hasMixedAttachmentSizes );
+	dumpfield( m_hasBGRA );
+	dumpfield( m_hasNewFullscreenMode );
+	dumpfield( m_hasNativeClipVertexMode );
+	dumpfield( m_maxAniso );
+	
+	dumpfield( m_hasBindableUniforms );
+	dumpfield( m_maxVertexBindableUniforms );
+	dumpfield( m_maxFragmentBindableUniforms );
+	dumpfield( m_maxBindableUniformSize );
+
+	dumpfield( m_hasUniformBuffers );
+	dumpfield( m_hasPerfPackage1 );
+	
+	dumpfield( m_cantBlitReliably );
+	dumpfield( m_cantAttachSRGB );
+	dumpfield( m_cantResolveFlipped );
+	dumpfield( m_cantResolveScaled );
+	dumpfield( m_costlyGammaFlips );
+	dumpfield( m_badDriver1064NV );
+	dumpfield( m_badDriver108Intel );
+
+	printf("\n--------------------------------");
+	
+	#undef dumpfield
+	#undef dumpfield_hex
+	#undef dumpfield_str
+}
+
+CGLMTex	*GLMContext::NewTex( GLMTexLayoutKey *key, uint levels, const char *debugLabel )
+{
+	// get a layout based on the key
+	GLMTexLayout *layout = m_texLayoutTable->NewLayoutRef( key );
+			
+	CGLMTex *tex = new CGLMTex( this, layout, levels, debugLabel );
+	
+	return tex;
+}
+
+void GLMContext::DelTex( CGLMTex * tex )
+{
+	//Queue the texture for deletion in ProcessTextureDeletes
+	//when we are sure we will hold the context.
+	m_DeleteTextureQueue.PushItem(tex);
+}
+
+void GLMContext::ProcessTextureDeletes()
+{
+#if GL_TELEMETRY_GPU_ZONES
+	CScopedGLMPIXEvent glmEvent( "GLMContext::ProcessTextureDeletes" );
+#endif
+
+	CGLMTex* tex = nullptr;
+	while ( m_DeleteTextureQueue.PopItem( &tex ) )
+	{
+		for( int i = 0; i < GLM_SAMPLER_COUNT; i++)
+		{
+			if ( m_samplers[i].m_pBoundTex == tex )
+			{
+				BindTexToTMU( NULL, i );
+			}
+		}
+			
+		if ( tex->m_rtAttachCount != 0 )
+		{
+			// RG - huh? wtf? TODO: fix this code which seems to be purposely leaking
+			// leak it and complain - we may have to implement a deferred-delete system for tex like these
+
+			GLMDebugPrintf("GLMContext::DelTex: Leaking tex %08x [ %s ] - was attached for drawing at time of delete",tex, tex->m_layout->m_layoutSummary );
+
+			#if 0
+				// can't actually do this yet as the draw calls will tank
+				FOR_EACH_VEC( m_fboTable, i )
+				{
+					CGLMFBO *fbo = m_fboTable[i];
+					fbo->TexScrub( tex );
+				}
+				tex->m_rtAttachCount = 0;
+			#endif
+		}
+		else
+		{	
+			delete tex;
+		}
+	}
+}
+
+// push and pop attrib when blit has mixed srgb source and dest?		
+ConVar	gl_radar7954721_workaround_mixed ( "gl_radar7954721_workaround_mixed", "1" );
+
+// push and pop attrib on any blit?
+ConVar	gl_radar7954721_workaround_all ( "gl_radar7954721_workaround_all", "0" );
+
+// what attrib mask to use ?
+ConVar	gl_radar7954721_workaround_maskval ( "gl_radar7954721_workaround_maskval", "0" );
+
+enum eBlitFormatClass
+{
+	eColor,
+	eDepth,				// may not get used.  not sure..
+	eDepthStencil
+};
+
+uint	glAttachFromClass[ 3 ] = 		{ GL_COLOR_ATTACHMENT0_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_DEPTH_STENCIL_ATTACHMENT_EXT };
+
+void glScrubFBO			( GLenum target )
+{
+	gGL->glFramebufferRenderbufferEXT	( target, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, 0);
+	gGL->glFramebufferRenderbufferEXT	( target, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);
+	gGL->glFramebufferRenderbufferEXT	( target, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);
+
+	gGL->glFramebufferTexture2DEXT		( target, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, 0, 0 );
+	gGL->glFramebufferTexture2DEXT		( target, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, 0, 0 );
+	gGL->glFramebufferTexture2DEXT		( target, GL_STENCIL_ATTACHMENT_EXT, GL_TEXTURE_2D, 0, 0 );
+}
+
+void glAttachRBOtoFBO	( GLenum target, eBlitFormatClass formatClass, uint rboName )
+{
+	switch( formatClass )
+	{
+		case eColor:
+			gGL->glFramebufferRenderbufferEXT	( target, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, rboName);
+		break;
+		
+		case eDepth:
+			gGL->glFramebufferRenderbufferEXT	( target, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rboName);
+		break;
+		
+		case eDepthStencil:
+			gGL->glFramebufferRenderbufferEXT	( target, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rboName);
+			gGL->glFramebufferRenderbufferEXT	( target, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rboName);
+		break;
+	}
+}
+
+void glAttachTex2DtoFBO	( GLenum target, eBlitFormatClass formatClass, uint texName, uint texMip )
+{
+	switch( formatClass )
+	{
+		case eColor:
+			gGL->glFramebufferTexture2DEXT		( target, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, texName, texMip );
+		break;
+		
+		case eDepth:
+			gGL->glFramebufferTexture2DEXT		( target, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, texName, texMip );
+		break;
+		
+		case eDepthStencil:
+			gGL->glFramebufferTexture2DEXT		( target, GL_DEPTH_STENCIL_ATTACHMENT_EXT, GL_TEXTURE_2D, texName, texMip );
+		break;
+	}
+}
+
+ConVar gl_can_resolve_flipped("gl_can_resolve_flipped", "0" );
+ConVar gl_cannot_resolve_flipped("gl_cannot_resolve_flipped", "0" );
+
+// these are only consulted if the m_cant_resolve_scaled cap bool is false.
+
+ConVar gl_minify_resolve_mode("gl_minify_resolve_mode", "1" );		// if scaled resolve available, for downscaled resolve blits only (i.e. internal blits)
+ConVar gl_magnify_resolve_mode("gl_magnify_resolve_mode", "2" );	// if scaled resolve available, for upscaled resolve blits only
+
+	// 0 == old style, two steps
+	// 1 == faster, one step blit aka XGL_SCALED_RESOLVE_FASTEST_EXT - if available.
+	// 2 == faster, one step blit aka XGL_SCALED_RESOLVE_NICEST_EXT - if available.
+
+void GLMContext::SaveColorMaskAndSetToDefault()
+{
+	// NVidia's driver doesn't ignore the colormask during blitframebuffer calls, so we need to save/restore it: 
+	// “The bug here is that our driver fails to ignore colormask for BlitFramebuffer calls. This was unclear in the original spec, but we resolved it in Khronos last year (https://cvs.khronos.org/bugzilla/show_bug.cgi?id=7969).”
+	m_ColorMaskSingle.Read( &m_SavedColorMask, 0 );
+
+	GLColorMaskSingle_t newColorMask;
+	newColorMask.r = newColorMask.g = newColorMask.b = newColorMask.a = -1;
+	m_ColorMaskSingle.Write( &newColorMask );
+}
+
+void GLMContext::RestoreSavedColorMask()
+{
+	m_ColorMaskSingle.Write( &m_SavedColorMask );
+}
+
+void GLMContext::Blit2( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, uint filter )
+{
+#if GL_TELEMETRY_GPU_ZONES
+	CScopedGLMPIXEvent glmPIXEvent( "Blit2" );
+	g_TelemetryGPUStats.m_nTotalBlit2++;
+#endif
+	
+	SaveColorMaskAndSetToDefault();
+	
+	Assert( srcFace == 0 );
+	Assert( dstFace == 0 );
+	
+	//----------------------------------------------------------------- format assessment
+
+	eBlitFormatClass	formatClass = eColor;
+	uint				blitMask= 0;
+
+	switch( srcTex->m_layout->m_format->m_glDataFormat )
+	{
+		case GL_RED: case GL_BGRA:	case GL_RGB:	case GL_RGBA:	case GL_ALPHA:	case GL_LUMINANCE:	case GL_LUMINANCE_ALPHA:
+			formatClass = eColor;
+			blitMask = GL_COLOR_BUFFER_BIT;
+		break;
+
+		case GL_DEPTH_COMPONENT:
+			formatClass = eDepth;
+			blitMask = GL_DEPTH_BUFFER_BIT;
+		break;
+		
+		case GL_DEPTH_STENCIL_EXT:
+			formatClass = eDepthStencil;
+			blitMask = GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
+		break;
+
+		default:
+			Assert(!"Unsupported format for blit" );
+			GLMStop();
+		break;
+	}
+
+	//----------------------------------------------------------------- blit assessment
+	
+
+	bool blitResolves	=	srcTex->m_rboName != 0;
+	bool blitScales		=	((srcRect->xmax - srcRect->xmin) != (dstRect->xmax - dstRect->xmin)) || ((srcRect->ymax - srcRect->ymin) != (dstRect->ymax - dstRect->ymin));
+
+	bool blitToBack		=	(dstTex == NULL);
+	bool blitFlips		=	blitToBack;			// implicit y-flip upon blit to GL_BACK supplied
+
+	//should we support blitFromBack ?
+
+	bool srcGamma = srcTex && ((srcTex->m_layout->m_key.m_texFlags & kGLMTexSRGB) != 0);
+	bool dstGamma = dstTex && ((dstTex->m_layout->m_key.m_texFlags & kGLMTexSRGB) != 0);
+
+	bool doPushPop = (srcGamma != dstGamma) && gl_radar7954721_workaround_mixed.GetInt() && m_caps.m_nv;		// workaround for cross gamma blit problems on NV
+		// ^^ need to re-check this on some post-10.6.3 build on NV to see if it was fixed
+
+	if (doPushPop)
+	{
+		gGL->glPushAttrib( 0 );
+	}
+	
+	//----------------------------------------------------------------- figure out the plan
+	
+	bool blitTwoStep = false;		// think positive
+	
+	// each subsequent segment here can only set blitTwoStep, not clear it.
+	// the common case where these get hit is resolve out to presentation
+	// there may be GL extensions or driver revisions which start doing these safely.
+	// ideally many blits internally resolve without scaling and can thus go direct without using the scratch tex.
+	
+	if (blitResolves && (blitFlips||blitToBack))		// flips, blit to back, same thing (for now)
+	{
+		if( gl_cannot_resolve_flipped.GetInt() )
+		{
+			blitTwoStep = true;
+		}
+		else if (!gl_can_resolve_flipped.GetInt())
+		{
+			blitTwoStep = blitTwoStep || m_caps.m_cantResolveFlipped;	// if neither convar renders an opinion, fall back to the caps to decide if we have to two-step.
+		}		
+	}
+
+	// only consider trying to use the scaling resolve filter,
+	// if we are confident we are not headed for two step mode already.
+	if (!blitTwoStep)
+	{
+		if (blitResolves && blitScales)
+		{
+			if (m_caps.m_cantResolveScaled)
+			{
+				// filter is unchanged, two step mode switches on
+				blitTwoStep = true;
+			}
+			else
+			{
+				bool	blitScalesDown	= ((srcRect->xmax - srcRect->xmin) > (dstRect->xmax - dstRect->xmin)) || ((srcRect->ymax - srcRect->ymin) > (dstRect->ymax - dstRect->ymin));
+				int		mode			= (blitScalesDown) ? gl_minify_resolve_mode.GetInt() : gl_magnify_resolve_mode.GetInt();
+				
+				// roughly speaking, resolve blits that minify represent setup for special effects ("copy framebuffer to me")
+				// resolve blits that magnify are almost always on the final present in the case where remder size < display size
+				
+				switch( mode )
+				{
+					case 0:
+					default:
+						// filter is unchanged, two step mode
+						blitTwoStep = true;
+					break;
+						
+					case 1:
+						// filter goes to fastest, one step mode
+						blitTwoStep = false;
+						filter = XGL_SCALED_RESOLVE_FASTEST_EXT;
+					break;
+						
+					case 2:
+						// filter goes to nicest, one step mode
+						blitTwoStep = false;
+						filter = XGL_SCALED_RESOLVE_NICEST_EXT;
+					break;					
+				}
+			}
+		}	
+	}
+
+	//----------------------------------------------------------------- save old scissor state and disable scissor
+	GLScissorEnable_t	oldsciss,newsciss;
+	m_ScissorEnable.Read( &oldsciss, 0 );
+
+	if (oldsciss.enable)
+	{
+		//	turn off scissor
+		newsciss.enable = false;
+		m_ScissorEnable.Write( &newsciss );
+	}
+
+	//----------------------------------------------------------------- fork in the road, depending on two-step or not
+	if (blitTwoStep)
+	{
+		// a resolve that can't be done directly due to constraints on scaling or flipping.
+		
+		// bind scratch FBO0 to read, scrub it, attach RBO
+		BindFBOToCtx		( m_scratchFBO[0], GL_READ_FRAMEBUFFER_EXT );
+		glScrubFBO			( GL_READ_FRAMEBUFFER_EXT );
+		glAttachRBOtoFBO	( GL_READ_FRAMEBUFFER_EXT, formatClass, srcTex->m_rboName );
+		
+		// bind scratch FBO1 to write, scrub it, attach scratch tex
+		BindFBOToCtx		( m_scratchFBO[1], GL_DRAW_FRAMEBUFFER_EXT );
+		glScrubFBO			( GL_DRAW_FRAMEBUFFER_EXT );
+		glAttachTex2DtoFBO	( GL_DRAW_FRAMEBUFFER_EXT, formatClass, srcTex->m_texName, 0 );
+
+		// set read and draw buffers appropriately		
+		gGL->glReadBuffer		( glAttachFromClass[formatClass] );
+		gGL->glDrawBuffer		( glAttachFromClass[formatClass] );
+		
+		// blit#1 - to resolve to scratch
+		// implicitly means no scaling, thus will be done with NEAREST sampling
+
+		GLenum resolveFilter = GL_NEAREST;
+		
+		gGL->glBlitFramebufferEXT(	0, 0,	srcTex->m_layout->m_key.m_xSize, srcTex->m_layout->m_key.m_ySize,
+								0, 0,	srcTex->m_layout->m_key.m_xSize, srcTex->m_layout->m_key.m_ySize,	// same source and dest rect, whole surface
+								blitMask, resolveFilter );
+								
+		// FBO1 now holds the interesting content.
+		// scrub FBO0, bind FBO1 to READ, fall through to next stage of blit where 1 goes onto 0 (or BACK)
+		
+		glScrubFBO			( GL_READ_FRAMEBUFFER_EXT );	// zap FBO0
+		BindFBOToCtx		( m_scratchFBO[1], GL_READ_FRAMEBUFFER_EXT );
+
+		srcTex->ForceRBONonDirty();
+	}
+	else
+	{
+#if 1
+		if (srcTex->m_pBlitSrcFBO == NULL) 
+		{
+			srcTex->m_pBlitSrcFBO = NewFBO();
+			BindFBOToCtx( srcTex->m_pBlitSrcFBO, GL_READ_FRAMEBUFFER_EXT );
+			if (blitResolves)
+			{
+				glAttachRBOtoFBO( GL_READ_FRAMEBUFFER_EXT, formatClass, srcTex->m_rboName );
+			}
+			else
+			{
+				glAttachTex2DtoFBO( GL_READ_FRAMEBUFFER_EXT, formatClass, srcTex->m_texName, srcMip );
+			}
+		} 
+		else 
+		{
+			BindFBOToCtx		( srcTex->m_pBlitSrcFBO, GL_READ_FRAMEBUFFER_EXT );
+			//                     GLMCheckError();
+		}
+#else
+		// arrange source surface on FBO1 for blit directly to dest (which could be FBO0 or BACK)
+		BindFBOToCtx( m_scratchFBO[1], GL_READ_FRAMEBUFFER_EXT );
+		glScrubFBO( GL_READ_FRAMEBUFFER_EXT );
+		GLMCheckError();
+		if (blitResolves)
+		{
+			glAttachRBOtoFBO( GL_READ_FRAMEBUFFER_EXT, formatClass, srcTex->m_rboName );
+		}
+		else
+		{
+			glAttachTex2DtoFBO( GL_READ_FRAMEBUFFER_EXT, formatClass, srcTex->m_texName, srcMip );
+		}
+#endif
+
+		gGL->glReadBuffer( glAttachFromClass[formatClass] );
+	}
+	
+	//----------------------------------------------------------------- zero or one blits may have happened above, whichever took place, FBO1 is now on read
+	
+	bool yflip = false;
+	if (blitToBack)
+	{
+		// backbuffer is special - FBO0 is left out (either scrubbed already, or not used)
+		
+		BindFBOToCtx		( NULL, GL_DRAW_FRAMEBUFFER_EXT );
+		gGL->glDrawBuffer		( GL_BACK );
+		
+		yflip = true;
+	}
+	else
+	{
+		// not going to GL_BACK - use FBO0. set up dest tex or RBO on it.  i.e. it's OK to blit from MSAA to MSAA if needed, though unlikely.
+		Assert( dstTex != NULL );
+#if 1
+		if (dstTex->m_pBlitDstFBO == NULL) 
+		{
+			dstTex->m_pBlitDstFBO = NewFBO();
+			BindFBOToCtx( dstTex->m_pBlitDstFBO, GL_DRAW_FRAMEBUFFER_EXT );
+			if (dstTex->m_rboName)
+			{
+				glAttachRBOtoFBO( GL_DRAW_FRAMEBUFFER_EXT, formatClass, dstTex->m_rboName );		
+			}
+			else
+			{
+				glAttachTex2DtoFBO( GL_DRAW_FRAMEBUFFER_EXT, formatClass, dstTex->m_texName, dstMip );
+			}
+		} 
+		else
+		{
+			BindFBOToCtx( dstTex->m_pBlitDstFBO, GL_DRAW_FRAMEBUFFER_EXT );
+		}
+#else
+		BindFBOToCtx( m_scratchFBO[0], GL_DRAW_FRAMEBUFFER_EXT );							GLMCheckError();								
+		glScrubFBO( GL_DRAW_FRAMEBUFFER_EXT );
+
+		if (dstTex->m_rboName)
+		{
+			glAttachRBOtoFBO( GL_DRAW_FRAMEBUFFER_EXT, formatClass, dstTex->m_rboName );		
+		}
+		else
+		{
+			glAttachTex2DtoFBO( GL_DRAW_FRAMEBUFFER_EXT, formatClass, dstTex->m_texName, dstMip );
+		}	
+
+		gGL->glDrawBuffer		( glAttachFromClass[formatClass] );										GLMCheckError();
+#endif							
+	}
+
+	// final blit
+	
+	// i think in general, if we are blitting same size, gl_nearest is the right filter to pass.
+	// this re-steering won't kick in if there is scaling or a special scaled resolve going on.
+	if (!blitScales)
+	{
+		// steer it
+		filter = GL_NEAREST;
+	}
+	
+	// this is blit #1 or #2 depending on what took place above.
+	if (yflip)
+	{
+		gGL->glBlitFramebufferEXT(	srcRect->xmin, srcRect->ymin, srcRect->xmax, srcRect->ymax,
+								dstRect->xmin, dstRect->ymax, dstRect->xmax, dstRect->ymin,		// note dest Y's are flipped
+								blitMask, filter );
+	}
+	else
+	{
+		gGL->glBlitFramebufferEXT(	srcRect->xmin, srcRect->ymin, srcRect->xmax, srcRect->ymax,
+								dstRect->xmin, dstRect->ymin, dstRect->xmax, dstRect->ymax,
+								blitMask, filter );
+	}
+
+	//----------------------------------------------------------------- scrub READ and maybe DRAW FBO, and unbind
+
+//	glScrubFBO			( GL_READ_FRAMEBUFFER_EXT );
+	BindFBOToCtx		( NULL, GL_READ_FRAMEBUFFER_EXT );
+	if (!blitToBack)
+	{
+//		glScrubFBO			( GL_DRAW_FRAMEBUFFER_EXT );
+		BindFBOToCtx		( NULL, GL_DRAW_FRAMEBUFFER_EXT );
+	}
+		
+	//----------------------------------------------------------------- restore GLM's drawing FBO
+
+	//	restore GLM drawing FBO
+	BindFBOToCtx( m_drawingFBO, GL_FRAMEBUFFER_EXT );
+	
+	if (doPushPop)
+	{
+		gGL->glPopAttrib( );
+	}
+	
+
+	//----------------------------------------------------------------- restore old scissor state
+	if (oldsciss.enable)
+	{
+		m_ScissorEnable.Write( &oldsciss );
+	}
+
+	RestoreSavedColorMask();
+}
+
+
+void GLMContext::BlitTex( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, GLenum filter, bool useBlitFB )
+{
+	// This path doesn't work anymore (or did it ever work in the L4D2 Linux branch?)
+	DXABSTRACT_BREAK_ON_ERROR();
+	return;
+
+	SaveColorMaskAndSetToDefault();
+
+	switch( srcTex->m_layout->m_format->m_glDataFormat )
+	{
+		case GL_BGRA:
+		case GL_RGB:
+		case GL_RGBA:
+		case GL_ALPHA:
+		case GL_LUMINANCE:
+		case GL_LUMINANCE_ALPHA:
+			#if 0
+				if (GLMKnob("caps-key",NULL) > 0.0)
+				{
+					useBlitFB = false;
+				}
+			#endif
+
+			if ( m_caps.m_cantBlitReliably )	// this is referring to a problem with the x3100..
+			{
+				useBlitFB = false;
+			}
+		break;
+	}
+	
+	if (0)
+	{
+		GLMPRINTF(("-D- Blit from %d %d %d %d  to %d %d %d %d",
+			srcRect->xmin, srcRect->ymin, srcRect->xmax, srcRect->ymax,
+			dstRect->xmin, dstRect->ymin, dstRect->xmax, dstRect->ymax
+		));
+		
+		GLMPRINTF(( "-D-       src tex layout is %s", srcTex->m_layout->m_layoutSummary ));
+		GLMPRINTF(( "-D-       dst tex layout is %s", dstTex->m_layout->m_layoutSummary ));
+	}
+
+	int pushed = 0;
+	uint pushmask = gl_radar7954721_workaround_maskval.GetInt();
+		//GL_COLOR_BUFFER_BIT
+		//| GL_CURRENT_BIT
+		//| GL_ENABLE_BIT
+		//| GL_FOG_BIT
+		//| GL_PIXEL_MODE_BIT
+		//| GL_SCISSOR_BIT
+		//| GL_STENCIL_BUFFER_BIT
+		//| GL_TEXTURE_BIT
+		//GL_VIEWPORT_BIT
+		//;
+	
+	if (gl_radar7954721_workaround_all.GetInt()!=0)
+	{
+		gGL->glPushAttrib( pushmask );
+		pushed++;
+	}
+	else
+	{
+		bool srcGamma = (srcTex->m_layout->m_key.m_texFlags & kGLMTexSRGB) != 0;
+		bool dstGamma = (dstTex->m_layout->m_key.m_texFlags & kGLMTexSRGB) != 0;
+
+		if (srcGamma != dstGamma)
+		{
+			if (gl_radar7954721_workaround_mixed.GetInt())
+			{
+				gGL->glPushAttrib( pushmask );
+				pushed++;
+			}
+		}
+	}
+
+	if (useBlitFB)
+	{
+		// state we need to save
+		//	current setting of scissor
+		//	current setting of the drawing fbo (no explicit save, it's in the context)
+		GLScissorEnable_t	oldsciss,newsciss;
+		m_ScissorEnable.Read( &oldsciss, 0 );
+
+		// remember to restore m_drawingFBO at end of effort
+		
+		// setup
+		//	turn off scissor
+		newsciss.enable = false;
+		m_ScissorEnable.Write( &newsciss );
+
+		// select which attachment enum we're going to use for the blit
+		// default to color0, unless it's a depth or stencil flava
+		
+		Assert( srcTex->m_layout->m_format->m_glDataFormat == dstTex->m_layout->m_format->m_glDataFormat );
+		
+		EGLMFBOAttachment	attachIndex = (EGLMFBOAttachment)0;
+		GLenum				attachIndexGL = 0;
+		GLuint				blitMask = 0;
+		switch( srcTex->m_layout->m_format->m_glDataFormat )
+		{
+			case GL_BGRA:
+			case GL_RGB:
+			case GL_RGBA:
+			case GL_ALPHA:
+			case GL_LUMINANCE:
+			case GL_LUMINANCE_ALPHA:
+				attachIndex = kAttColor0;
+				attachIndexGL = GL_COLOR_ATTACHMENT0_EXT;
+				blitMask = GL_COLOR_BUFFER_BIT;
+			break;
+
+			case GL_DEPTH_COMPONENT:
+				attachIndex = kAttDepth;
+				attachIndexGL = GL_DEPTH_ATTACHMENT_EXT;
+				blitMask = GL_DEPTH_BUFFER_BIT;
+			break;
+			
+			case GL_DEPTH_STENCIL_EXT:
+				attachIndex = kAttDepthStencil;
+				attachIndexGL = GL_DEPTH_STENCIL_ATTACHMENT_EXT;
+				blitMask = GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
+			break;
+
+			default:
+				Assert(0);
+			break;
+		}
+
+		//	set the read fb, attach read tex at appropriate attach point, set read buffer
+		BindFBOToCtx( m_blitReadFBO, GL_READ_FRAMEBUFFER_EXT );
+
+		GLMFBOTexAttachParams attparams;
+		attparams.m_tex		=	srcTex;
+		attparams.m_face	=	srcFace;
+		attparams.m_mip		=	srcMip;
+		attparams.m_zslice	=	0;
+		m_blitReadFBO->TexAttach( &attparams, attachIndex, GL_READ_FRAMEBUFFER_EXT );
+
+		gGL->glReadBuffer( attachIndexGL );
+		
+
+		//	set the write fb and buffer, and attach write tex
+		BindFBOToCtx( m_blitDrawFBO, GL_DRAW_FRAMEBUFFER_EXT );
+
+		attparams.m_tex		=	dstTex;
+		attparams.m_face	=	dstFace;
+		attparams.m_mip		=	dstMip;
+		attparams.m_zslice	=	0;
+		m_blitDrawFBO->TexAttach( &attparams, attachIndex, GL_DRAW_FRAMEBUFFER_EXT );
+
+		gGL->glDrawBuffer( attachIndexGL );
+
+		//	do the blit
+		gGL->glBlitFramebufferEXT(	srcRect->xmin, srcRect->ymin, srcRect->xmax, srcRect->ymax,
+								dstRect->xmin, dstRect->ymin, dstRect->xmax, dstRect->ymax,
+								blitMask, filter );
+							
+		// cleanup
+		//	unset the read fb and buffer, detach read tex
+		//	unset the write fb and buffer, detach write tex
+
+		m_blitReadFBO->TexDetach( attachIndex, GL_READ_FRAMEBUFFER_EXT );
+
+		m_blitDrawFBO->TexDetach( attachIndex, GL_DRAW_FRAMEBUFFER_EXT );
+
+		//	put the original FB back in place (both read and draw)
+		// this bind will hit both read and draw bindings
+		BindFBOToCtx( m_drawingFBO, GL_FRAMEBUFFER_EXT );
+		
+			//	set the read and write buffers back to... what ? does it matter for anything but copies ?  don't worry about it
+		
+		// restore the scissor state
+		m_ScissorEnable.Write( &oldsciss );
+	}
+	else
+	{
+		// textured quad style
+
+		// we must attach the dest tex as the color buffer on the blit draw FBO
+		// so that means we need to re-set the drawing FBO on exit
+
+		EGLMFBOAttachment	attachIndex = (EGLMFBOAttachment)0;
+		GLenum				attachIndexGL = 0;
+		switch( srcTex->m_layout->m_format->m_glDataFormat )
+		{
+			case GL_BGRA:
+			case GL_RGB:
+			case GL_RGBA:
+			case GL_ALPHA:
+			case GL_LUMINANCE:
+			case GL_LUMINANCE_ALPHA:
+				attachIndex = kAttColor0;
+				attachIndexGL = GL_COLOR_ATTACHMENT0_EXT;
+			break;
+
+			default:
+				Assert(!"Can't blit that format");
+			break;
+		}
+		
+		BindFBOToCtx( m_blitDrawFBO, GL_DRAW_FRAMEBUFFER_EXT );
+
+		GLMFBOTexAttachParams attparams;
+		attparams.m_tex		=	dstTex;
+		attparams.m_face	=	dstFace;
+		attparams.m_mip		=	dstMip;
+		attparams.m_zslice	=	0;
+		m_blitDrawFBO->TexAttach( &attparams, attachIndex, GL_DRAW_FRAMEBUFFER_EXT );
+
+		gGL->glDrawBuffer( attachIndexGL );
+		
+		// attempt to just set states directly the way we want them, then use the latched states to repair them afterward.
+		NullProgram();	// out of program mode
+		
+		gGL->glDisable ( GL_ALPHA_TEST );
+		gGL->glDisable ( GL_CULL_FACE );
+		gGL->glDisable ( GL_POLYGON_OFFSET_FILL );
+		gGL->glDisable ( GL_SCISSOR_TEST );
+
+		gGL->glDisable ( GL_CLIP_PLANE0 );
+		gGL->glDisable ( GL_CLIP_PLANE1 );
+		
+		gGL->glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
+		gGL->glDisable ( GL_BLEND );
+
+		gGL->glDepthMask ( GL_FALSE );
+		gGL->glDisable ( GL_DEPTH_TEST );
+
+		gGL->glDisable ( GL_STENCIL_TEST );
+		gGL->glStencilMask ( GL_FALSE );
+
+
+		// now do the unlit textured quad...
+		gGL->glActiveTexture( GL_TEXTURE0 );
+		gGL->glBindTexture( GL_TEXTURE_2D, srcTex->m_texName );
+
+		gGL->glEnable(GL_TEXTURE_2D);
+
+		// immediate mode is fine
+
+		float topv = 1.0;
+		float botv = 0.0;
+		
+		gGL->glBegin(GL_QUADS);
+			gGL->glTexCoord2f	( 0.0, botv );
+			gGL->glVertex3f		( -1.0, -1.0, 0.0 );
+			
+			gGL->glTexCoord2f	( 1.0, botv );
+			gGL->glVertex3f		( 1.0, -1.0, 0.0 );
+			
+			gGL->glTexCoord2f	( 1.0, topv );
+			gGL->glVertex3f		( 1.0, 1.0, 0.0 );
+
+			gGL->glTexCoord2f	( 0.0, topv );
+			gGL->glVertex3f		( -1.0, 1.0, 0.0 );
+		gGL->glEnd();
+
+		gGL->glBindTexture( GL_TEXTURE_2D, 0 );
+
+		gGL->glDisable(GL_TEXTURE_2D);
+
+		BindTexToTMU( m_samplers[0].m_pBoundTex, 0 );
+		
+		// leave active program empty - flush draw states will fix
+		
+		// then restore states using the scoreboard
+
+		m_AlphaTestEnable.Flush();
+		m_AlphaToCoverageEnable.Flush();
+		m_CullFaceEnable.Flush();
+		m_DepthBias.Flush();
+		m_ScissorEnable.Flush();
+		
+		m_ClipPlaneEnable.FlushIndex( 0 );
+		m_ClipPlaneEnable.FlushIndex( 1 );
+		
+		m_ColorMaskSingle.Flush();
+		m_BlendEnable.Flush();
+
+		m_DepthMask.Flush();
+		m_DepthTestEnable.Flush();
+		
+		m_StencilWriteMask.Flush();
+		m_StencilTestEnable.Flush();
+
+		//	unset the write fb and buffer, detach write tex
+
+		m_blitDrawFBO->TexDetach( attachIndex, GL_DRAW_FRAMEBUFFER_EXT );
+
+		//	put the original FB back in place (both read and draw)
+		BindFBOToCtx( m_drawingFBO, GL_FRAMEBUFFER_EXT );
+	}
+	
+	while(pushed)
+	{
+		gGL->glPopAttrib();
+		pushed--;
+	}
+
+	RestoreSavedColorMask();
+}
+
+void GLMContext::ResolveTex( CGLMTex *tex, bool forceDirty )
+{
+#if GL_TELEMETRY_GPU_ZONES
+	CScopedGLMPIXEvent glmPIXEvent( "ResolveTex" );
+	g_TelemetryGPUStats.m_nTotalResolveTex++;
+#endif
+
+	// only run resolve if it's (a) possible and (b) dirty or force-dirtied
+	if ( ( tex->m_rboName ) && ( tex->IsRBODirty() || forceDirty ) )
+	{
+		// state we need to save
+		//	current setting of scissor
+		//	current setting of the drawing fbo (no explicit save, it's in the context)
+		GLScissorEnable_t	oldsciss,newsciss;
+		m_ScissorEnable.Read( &oldsciss, 0 );
+
+		// remember to restore m_drawingFBO at end of effort
+		
+		// setup
+		//	turn off scissor
+		newsciss.enable = false;
+		m_ScissorEnable.Write( &newsciss );
+
+		// select which attachment enum we're going to use for the blit
+		// default to color0, unless it's a depth or stencil flava
+		
+		// for resolve, only handle a modest subset of the possible formats
+		EGLMFBOAttachment	attachIndex = (EGLMFBOAttachment)0;
+		GLenum				attachIndexGL = 0;
+		GLuint				blitMask = 0;
+		switch( tex->m_layout->m_format->m_glDataFormat )
+		{
+			case GL_BGRA:
+			case GL_RGB:
+			case GL_RGBA:
+	//		case GL_ALPHA:
+	//		case GL_LUMINANCE:
+	//		case GL_LUMINANCE_ALPHA:
+				attachIndex = kAttColor0;
+				attachIndexGL = GL_COLOR_ATTACHMENT0_EXT;
+				blitMask = GL_COLOR_BUFFER_BIT;
+			break;
+
+	//		case GL_DEPTH_COMPONENT:
+	//			attachIndex = kAttDepth;
+	//			attachIndexGL = GL_DEPTH_ATTACHMENT_EXT;
+	//			blitMask = GL_DEPTH_BUFFER_BIT;
+	//		break;
+			
+			case GL_DEPTH_STENCIL_EXT:
+				attachIndex = kAttDepthStencil;
+				attachIndexGL = GL_DEPTH_STENCIL_ATTACHMENT_EXT;
+				blitMask = GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
+			break;
+
+			default:
+				Assert(!"Unsupported format for MSAA resolve" );
+			break;
+		}
+
+		
+		//	set the read fb, attach read RBO at appropriate attach point, set read buffer
+		BindFBOToCtx( m_blitReadFBO, GL_READ_FRAMEBUFFER_EXT );
+
+		// going to avoid the TexAttach / TexDetach calls due to potential confusion, implement it directly here
+		
+		//-----------------------------------------------------------------------------------
+		// put tex->m_rboName on the read FB's attachment
+		if (attachIndexGL==GL_DEPTH_STENCIL_ATTACHMENT_EXT)
+		{
+			// you have to attach it both places...
+			// http://www.opengl.org/wiki/GL_EXT_framebuffer_object
+
+			// bind the RBO to the GL_RENDERBUFFER_EXT target - is this extraneous ?
+			//glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, tex->m_rboName );
+			
+			// attach the GL_RENDERBUFFER_EXT target to the depth and stencil attach points
+			gGL->glFramebufferRenderbufferEXT( GL_READ_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, tex->m_rboName);						
+				
+			gGL->glFramebufferRenderbufferEXT( GL_READ_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, tex->m_rboName);
+
+			// no need to leave the RBO hanging on
+			//glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, 0 );
+		}
+		else
+		{
+			//glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, tex->m_rboName );
+			
+			gGL->glFramebufferRenderbufferEXT( GL_READ_FRAMEBUFFER_EXT, attachIndexGL, GL_RENDERBUFFER_EXT, tex->m_rboName);
+
+			//glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, 0 );
+		}
+
+		gGL->glReadBuffer( attachIndexGL );
+
+		//-----------------------------------------------------------------------------------
+		// put tex->m_texName on the draw FBO attachment
+
+		//	set the write fb and buffer, and attach write tex
+		BindFBOToCtx( m_blitDrawFBO, GL_DRAW_FRAMEBUFFER_EXT );
+
+		// regular path - attaching a texture2d
+		
+		if (attachIndexGL==GL_DEPTH_STENCIL_ATTACHMENT_EXT)
+		{
+			gGL->glFramebufferTexture2DEXT( GL_DRAW_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, tex->m_texName, 0 );
+
+			gGL->glFramebufferTexture2DEXT( GL_DRAW_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_TEXTURE_2D, tex->m_texName, 0 );
+		}
+		else
+		{
+			gGL->glFramebufferTexture2DEXT( GL_DRAW_FRAMEBUFFER_EXT, attachIndexGL, GL_TEXTURE_2D, tex->m_texName, 0 );
+		}
+
+		gGL->glDrawBuffer( attachIndexGL );
+
+		//-----------------------------------------------------------------------------------
+
+		// blit
+		gGL->glBlitFramebufferEXT(	0, 0,	tex->m_layout->m_key.m_xSize, tex->m_layout->m_key.m_ySize,
+								0, 0,	tex->m_layout->m_key.m_xSize, tex->m_layout->m_key.m_ySize,
+								blitMask, GL_NEAREST );
+			// or should it be GL_LINEAR?  does it matter ?
+			
+		//-----------------------------------------------------------------------------------
+		// cleanup
+		//-----------------------------------------------------------------------------------
+
+
+		//	unset the read fb and buffer, detach read RBO
+		//glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, 0 );
+
+		if (attachIndexGL==GL_DEPTH_STENCIL_ATTACHMENT_EXT)
+		{
+			// detach the GL_RENDERBUFFER_EXT target from the depth and stencil attach points
+			gGL->glFramebufferRenderbufferEXT( GL_READ_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);						
+				
+			gGL->glFramebufferRenderbufferEXT( GL_READ_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, 0);
+		}
+		else
+		{
+			gGL->glFramebufferRenderbufferEXT( GL_READ_FRAMEBUFFER_EXT, attachIndexGL, GL_RENDERBUFFER_EXT, 0);
+		}
+
+		//-----------------------------------------------------------------------------------
+		//	unset the write fb and buffer, detach write tex
+		
+
+		if (attachIndexGL==GL_DEPTH_STENCIL_ATTACHMENT_EXT)
+		{
+			gGL->glFramebufferTexture2DEXT( GL_DRAW_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, 0, 0 );
+
+			gGL->glFramebufferTexture2DEXT( GL_DRAW_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_TEXTURE_2D, 0, 0 );
+		}
+		else
+		{
+			gGL->glFramebufferTexture2DEXT( GL_DRAW_FRAMEBUFFER_EXT, attachIndexGL, GL_TEXTURE_2D, 0, 0 );
+		}
+
+		//	put the original FB back in place (both read and draw)
+		// this bind will hit both read and draw bindings
+		BindFBOToCtx( m_drawingFBO, GL_FRAMEBUFFER_EXT );
+		
+		//	set the read and write buffers back to... what ? does it matter for anything but copies ?  don't worry about it
+		
+		// restore the scissor state
+		m_ScissorEnable.Write( &oldsciss );
+		
+		// mark the RBO clean on the resolved tex
+		tex->ForceRBONonDirty();
+	}
+}
+
+void GLMContext::PreloadTex( CGLMTex *tex, bool force )
+{
+	// if conditions allow (i.e. a drawing surface is active)
+	// bind the texture on TMU 15
+	// set up a dummy program to sample it but not write (use 'discard')
+	// draw a teeny little triangle that won't generate a lot of fragments
+	if (!m_pairCache)
+		return;
+		
+	if (!m_drawingFBO)
+		return;
+			
+	if (tex->m_texPreloaded && !force)	// only do one preload unless forced to re-do
+	{
+		//printf("\nnot-preloading %s", tex->m_debugLabel ? tex->m_debugLabel : "(unknown)");
+		return;
+	}
+
+	//printf("\npreloading     %s", tex->m_debugLabel ? tex->m_debugLabel : "(unknown)");
+
+	CGLMProgram *vp = m_preloadTexVertexProgram;
+	CGLMProgram *fp = NULL;
+	switch(tex->m_layout->m_key.m_texGLTarget)
+	{
+		case GL_TEXTURE_2D:			fp = m_preload2DTexFragmentProgram;
+		break;
+		
+		case GL_TEXTURE_3D:			fp = m_preload3DTexFragmentProgram;
+		break;
+		
+		case GL_TEXTURE_CUBE_MAP:	fp = m_preloadCubeTexFragmentProgram;
+		break;
+	}
+	if (!fp)
+		return;
+	
+	CGLMShaderPair	*preloadPair = m_pairCache->SelectShaderPair( vp, fp, 0 );
+	if (!preloadPair)
+		return;
+
+	if ( !preloadPair->m_valid )
+	{
+		if ( !preloadPair->ValidateProgramPair() )
+		{
+			return;
+		}
+	}
+
+	gGL->glUseProgram( (GLuint)preloadPair->m_program );
+					
+	m_pBoundPair = preloadPair;
+	m_bDirtyPrograms = true;
+			
+	// almost ready to draw...
+
+	//int tmuForPreload = 15;
+	
+	// shut down all the generic attribute arrays on the detention level - next real draw will activate them again
+	m_lastKnownVertexAttribMask = 0;
+	m_nNumSetVertexAttributes = 16;
+	memset( &m_boundVertexAttribs[0], 0xFF, sizeof( m_boundVertexAttribs ) );
+	
+	// Force the next flush to reset the attributes.
+	ClearCurAttribs();
+
+	for( int index=0; index < kGLMVertexAttributeIndexMax; index++ )
+	{
+		gGL->glDisableVertexAttribArray( index );
+	}
+		
+	// bind texture and sampling params
+	CGLMTex *pPrevTex = m_samplers[15].m_pBoundTex;
+
+#ifndef OSX // 10.6
+	if ( m_bUseSamplerObjects )
+	{
+		gGL->glBindSampler( 15, 0 );
+	}
+#endif // !OSX
+
+	BindTexToTMU( tex, 15 );
+	
+	// unbind vertex/index buffers
+	BindBufferToCtx( kGLMVertexBuffer, NULL );
+	BindBufferToCtx( kGLMIndexBuffer, NULL );
+			
+	// draw
+	static float posns[] = {	0.0f, 0.0f, 0.0f,
+								0.0f, 0.0f, 0.0f,
+								0.0f, 0.0f, 0.0f };
+
+	static int indices[] = { 0, 1, 2 };
+	
+
+	gGL->glEnableVertexAttribArray( 0 );
+
+	gGL->glVertexAttribPointer( 0, 3, GL_FLOAT, 0, 0, posns );
+
+	gGL->glDrawRangeElements( GL_TRIANGLES, 0, 3, 3, GL_UNSIGNED_INT, indices);
+
+	gGL->glDisableVertexAttribArray( 0 );
+	
+	SetSamplerDirty( 15 );
+
+	BindTexToTMU( pPrevTex, 15 );
+		
+	tex->m_texPreloaded = true;
+}
+
+
+
+CGLMFBO	*GLMContext::NewFBO( void )
+{
+	GLM_FUNC;
+
+	CGLMFBO *fbo = new CGLMFBO( this );
+
+	m_fboTable.AddToTail( fbo );
+	
+	return fbo;
+}
+
+void GLMContext::DelFBO( CGLMFBO *fbo )
+{
+	GLM_FUNC;
+
+	if (m_drawingFBO == fbo)
+	{
+		m_drawingFBO = NULL;	//poof!
+	}
+	
+	if (m_boundReadFBO == fbo )
+	{
+		BindFBOToCtx( NULL, GL_READ_FRAMEBUFFER_EXT );
+		m_boundReadFBO = NULL;
+	}
+
+	if (m_boundDrawFBO == fbo )
+	{
+		BindFBOToCtx( NULL, GL_DRAW_FRAMEBUFFER_EXT );
+		m_boundDrawFBO = NULL;
+	}
+
+	int idx = m_fboTable.Find( fbo );
+	Assert( idx >= 0 );
+	if ( idx >= 0 )
+	{
+		m_fboTable.FastRemove( idx );
+	}
+	
+	delete fbo;
+}
+
+//===============================================================================
+
+CGLMProgram	*GLMContext::NewProgram( EGLMProgramType type, char *progString, const char *pShaderName )
+{
+	//hushed GLM_FUNC;
+
+	CGLMProgram *prog = new CGLMProgram( this, type );
+	
+	prog->SetProgramText( progString );
+	prog->SetShaderName( pShaderName );
+	prog->CompileActiveSources();
+
+	return prog;
+}
+
+void GLMContext::DelProgram( CGLMProgram *pProg )
+{
+	GLM_FUNC;
+
+	if ( m_drawingProgram[ pProg->m_type ] == pProg )
+	{
+		SetProgram( pProg->m_type, ( pProg->m_type == kGLMFragmentProgram ) ? m_pNullFragmentProgram : NULL );
+	}
+
+	// make sure to eliminate any cached pairs using this shader
+	bool purgeResult = m_pairCache->PurgePairsWithShader( pProg );
+	(void)purgeResult;
+	Assert( !purgeResult );	// very unlikely to trigger
+
+	NullProgram();
+	
+	delete pProg;
+}
+
+void GLMContext::NullProgram( void )
+{
+	gGL->glUseProgram( 0 );
+	m_pBoundPair = NULL;
+	m_bDirtyPrograms = true;
+}
+
+void GLMContext::SetDrawingLang( EGLMProgramLang lang, bool immediate )
+{
+	if ( !m_caps.m_hasDualShaders ) return;		// ignore attempts to change language when -glmdualshaders is not engaged
+	
+	m_drawingLangAtFrameStart = lang;
+	if (immediate)
+	{	
+		NullProgram();
+
+		m_drawingLang = m_drawingLangAtFrameStart;
+	}
+}
+
+void GLMContext::LinkShaderPair( CGLMProgram *vp, CGLMProgram *fp )
+{
+	if ( (m_pairCache) && (m_drawingLang==kGLMGLSL) && (vp) && (fp) )
+	{
+		CGLMShaderPair	*pair = m_pairCache->SelectShaderPair( vp, fp, 0 );
+		(void)pair;
+		
+		Assert( pair != NULL );
+
+		NullProgram();	// clear out any binds that were done - next draw will set it right
+	}
+}
+
+void GLMContext::ValidateShaderPair( CGLMProgram *vp, CGLMProgram *fp )
+{
+	if ((m_pairCache) && (m_drawingLang == kGLMGLSL) && (vp) && (fp))
+	{
+		CGLMShaderPair	*pair = m_pairCache->SelectShaderPair( vp, fp, 0 );
+		Assert( pair != NULL );
+		pair->ValidateProgramPair();
+
+		NullProgram();	// clear out any binds that were done - next draw will set it right
+	}
+}
+
+void GLMContext::ClearShaderPairCache( void )
+{
+	if (m_pairCache)
+	{
+		NullProgram();
+		m_pairCache->Purge();	// bye bye all linked pairs
+		NullProgram();
+	}
+}
+
+void GLMContext::QueryShaderPair( int index, GLMShaderPairInfo *infoOut )
+{
+	if (m_pairCache)
+	{
+		m_pairCache->QueryShaderPair( index, infoOut );		
+	}
+	else
+	{
+		memset( infoOut, 0, sizeof( *infoOut ) );
+		infoOut->m_status = -1;
+	}
+}
+
+CGLMBuffer *GLMContext::NewBuffer( EGLMBufferType type, uint size, uint options )
+{
+	//hushed GLM_FUNC;
+
+	CGLMBuffer *prog = new CGLMBuffer( this, type, size, options );
+
+	return prog;
+}
+
+void GLMContext::DelBuffer( CGLMBuffer *buff )
+{
+	GLM_FUNC;
+
+	for( int index = 0; index < kGLMVertexAttributeIndexMax; index++ )
+	{
+		if ( m_drawVertexSetup.m_attrs[index].m_pBuffer == buff )
+		{
+			// just clear the enable mask - this will force all the attrs to get re-sent on next sync
+			m_drawVertexSetup.m_attrMask = 0;
+		}
+	}
+		
+	BindGLBufferToCtx( buff->m_buffGLTarget, NULL, false );
+			
+	delete buff;
+}
+
+GLMVertexSetup g_blank_setup;
+
+void GLMContext::Clear( bool color, unsigned long colorValue, bool depth, float depthValue, bool stencil, unsigned int stencilValue, GLScissorBox_t *box )
+{
+	GLM_FUNC;
+		
+	++m_nBatchCounter;
+
+#if GLMDEBUG
+	GLMDebugHookInfo info;
+	memset( &info, 0, sizeof(info) );
+	info.m_caller = eClear;
+	
+	do
+	{
+#endif
+		uint mask = 0;
+
+		GLClearColor_t clearcol;
+		GLClearDepth_t cleardep = { depthValue };
+		GLClearStencil_t clearsten = { (GLint)stencilValue };
+
+		// depth write mask must be saved&restored
+		GLDepthMask_t			olddepthmask;
+		GLDepthMask_t			newdepthmask = { true };
+
+		// stencil write mask must be saved and restored
+		GLStencilWriteMask_t			oldstenmask;
+		GLStencilWriteMask_t			newstenmask = { (GLint)0xFFFFFFFF };
+		
+		GLColorMaskSingle_t		oldcolormask;
+		GLColorMaskSingle_t		newcolormask = { -1,-1,-1,-1 };	// D3D clears do not honor color mask, so force it
+		
+		if (color)
+		{
+			// #define D3DCOLOR_ARGB(a,r,g,b) ((D3DCOLOR)((((a)&0xff)<<24)|(((r)&0xff)<<16)|(((g)&0xff)<<8)|((b)&0xff)))
+
+			clearcol.r =	((colorValue >> 16) & 0xFF) / 255.0f;	//R
+			clearcol.g =	((colorValue >>  8) & 0xFF) / 255.0f;	//G
+			clearcol.b =	((colorValue      ) & 0xFF) / 255.0f;	//B
+			clearcol.a =	((colorValue >> 24) & 0xFF) / 255.0f;	//A
+
+			m_ClearColor.Write( &clearcol );	// no check, no wait
+			mask |= GL_COLOR_BUFFER_BIT;
+			
+			// save and set color mask
+			m_ColorMaskSingle.Read( &oldcolormask, 0 );			
+			m_ColorMaskSingle.Write( &newcolormask );			
+		}
+
+		if (depth)
+		{
+			// get old depth write mask
+			m_DepthMask.Read( &olddepthmask, 0 );
+			m_DepthMask.Write( &newdepthmask );
+			m_ClearDepth.Write( &cleardep );	// no check, no wait
+			mask |= GL_DEPTH_BUFFER_BIT;
+		}
+
+		if (stencil)
+		{
+			m_ClearStencil.Write( &clearsten );	// no check, no wait
+			mask |= GL_STENCIL_BUFFER_BIT;
+
+			// save and set sten mask
+			m_StencilWriteMask.Read( &oldstenmask, 0 );			
+			m_StencilWriteMask.Write( &newstenmask );			
+		}
+
+		bool subrect = (box != NULL);
+		GLScissorEnable_t scissorEnableSave;
+		GLScissorEnable_t scissorEnableNew = { true };
+		
+		GLScissorBox_t scissorBoxSave;
+		GLScissorBox_t scissorBoxNew;
+		
+		if (subrect)
+		{
+			// save current scissorbox and enable
+			m_ScissorEnable.Read( &scissorEnableSave, 0 );
+			m_ScissorBox.Read( &scissorBoxSave, 0 );
+			
+			if(0)
+			{
+				// calc new scissorbox as intersection against *box
+
+					// max of the mins
+				scissorBoxNew.x = MAX(scissorBoxSave.x, box->x);
+				scissorBoxNew.y = MAX(scissorBoxSave.y, box->y);
+				
+					// min of the maxes
+				scissorBoxNew.width = ( MIN(scissorBoxSave.x+scissorBoxSave.width, box->x+box->width)) - scissorBoxNew.x;
+				
+					// height is just min of the max y's, minus the new base Y
+				scissorBoxNew.height = ( MIN(scissorBoxSave.y+scissorBoxSave.height, box->y+box->height)) - scissorBoxNew.y;				
+			}
+			else
+			{
+				// ignore old scissor box completely.
+				scissorBoxNew = *box;
+			}
+			// set new box and enable
+			m_ScissorEnable.Write( &scissorEnableNew );
+			m_ScissorBox.Write( &scissorBoxNew );
+		}
+
+		gGL->glClear( mask );
+
+		if (subrect)
+		{
+			// put old scissor box and enable back
+			m_ScissorEnable.Write( &scissorEnableSave );
+			m_ScissorBox.Write( &scissorBoxSave );
+		}
+		
+		if (depth)
+		{
+			// put old depth write mask
+			m_DepthMask.Write( &olddepthmask );
+		}
+		
+		if (color)
+		{
+			// put old color write mask
+			m_ColorMaskSingle.Write( &oldcolormask );			
+		}
+		
+		if (stencil)
+		{
+			// put old sten mask
+			m_StencilWriteMask.Write( &oldstenmask );			
+		}
+
+#if GLMDEBUG
+		DebugHook( &info );
+	} while (info.m_loop);
+#endif
+}
+
+
+// stolen from glmgrbasics.cpp
+extern "C" uint GetCurrentKeyModifiers( void );
+enum ECarbonModKeyIndex
+{
+  EcmdKeyBit                     = 8,    /* command key down?*/
+  EshiftKeyBit                   = 9,    /* shift key down?*/
+  EalphaLockBit                  = 10,   /* alpha lock down?*/
+  EoptionKeyBit                  = 11,   /* option key down?*/
+  EcontrolKeyBit                 = 12    /* control key down?*/
+};
+
+enum ECarbonModKeyMask
+{
+  EcmdKey                        = 1 << EcmdKeyBit,
+  EshiftKey                      = 1 << EshiftKeyBit,
+  EalphaLock                     = 1 << EalphaLockBit,
+  EoptionKey                     = 1 << EoptionKeyBit,
+  EcontrolKey                    = 1 << EcontrolKeyBit
+};
+
+static	ConVar gl_flushpaircache ("gl_flushpaircache", "0");
+static	ConVar gl_paircachestats ("gl_paircachestats", "0");
+static	ConVar gl_mtglflush_at_tof ("gl_mtglflush_at_tof", "0");
+static	ConVar gl_texlayoutstats ("gl_texlayoutstats", "0" );
+
+void GLMContext::BeginFrame( void )
+{
+	GLM_FUNC;
+
+	m_debugFrameIndex++;
+	
+	// check for lang change at TOF
+	if (m_caps.m_hasDualShaders)
+	{
+		if (m_drawingLang != m_drawingLangAtFrameStart)
+		{
+			// language change.  unbind everything..
+			NullProgram();
+
+			m_drawingLang = m_drawingLangAtFrameStart;
+		}
+	}
+
+	// scrub some critical shock absorbers
+	for( int i=0; i< 16; i++)
+	{
+		gGL->glDisableVertexAttribArray( i );						// enable GLSL attribute- this is just client state - will be turned back off
+	}
+	m_lastKnownVertexAttribMask = 0;
+	m_nNumSetVertexAttributes = 0;
+	
+	//FIXME should we also zap the m_lastKnownAttribs array ? (worst case it just sets them all again on first batch)
+
+	BindBufferToCtx( kGLMVertexBuffer, NULL, true );
+	BindBufferToCtx( kGLMIndexBuffer, NULL, true );
+
+	if (gl_flushpaircache.GetInt())
+	{
+		// do the flush and then set back to zero
+		ClearShaderPairCache();
+		
+		printf("\n\n##### shader pair cache cleared\n\n");
+		gl_flushpaircache.SetValue( 0 );
+	}
+	
+	if (gl_paircachestats.GetInt())
+	{
+		// do the flush and then set back to zero
+		m_pairCache->DumpStats();
+		
+		gl_paircachestats.SetValue( 0 );
+	}
+	
+	if (gl_texlayoutstats.GetInt())
+	{
+		m_texLayoutTable->DumpStats();
+		
+		gl_texlayoutstats.SetValue( 0 );
+	}
+	
+	if (gl_mtglflush_at_tof.GetInt())
+	{
+		gGL->glFlush();									// TOF flush - skip this if benchmarking, enable it if human playing (smoothness)
+	}
+	
+#if GLMDEBUG
+	// init debug hook information
+	GLMDebugHookInfo info;
+	memset( &info, 0, sizeof(info) );
+	info.m_caller = eBeginFrame;
+	
+	do
+	{
+		DebugHook( &info );
+	} while (info.m_loop);
+
+#endif
+
+}
+
+void GLMContext::EndFrame( void )
+{
+	GLM_FUNC;
+
+#if GLMDEBUG
+	// init debug hook information
+	GLMDebugHookInfo info;
+	memset( &info, 0, sizeof(info) );
+	info.m_caller = eEndFrame;
+	
+	do
+	{
+		DebugHook( &info );
+	} while (info.m_loop);
+#endif
+}
+
+//===============================================================================
+
+CGLMQuery *GLMContext::NewQuery( GLMQueryParams *params )
+{
+	CGLMQuery *query = new CGLMQuery( this, params );
+	
+	return query;
+}
+
+void GLMContext::DelQuery( CGLMQuery *query )
+{
+	// may want to do some finish/
+	delete query;
+}
+
+static ConVar mat_vsync( "mat_vsync", "0", 0, "Force sync to vertical retrace", true, 0.0, true, 1.0 );
+
+//===============================================================================
+
+ConVar glm_nullrefresh_capslock( "glm_nullrefresh_capslock", "0" );
+ConVar glm_literefresh_capslock( "glm_literefresh_capslock", "0" );
+
+extern ConVar gl_blitmode;
+
+void GLMContext::Present( CGLMTex *tex )
+{
+	GLM_FUNC;
+	
+	{
+#if GL_TELEMETRY_GPU_ZONES
+		CScopedGLMPIXEvent glmPIXEvent( "GLMContext::Present" );
+		g_TelemetryGPUStats.m_nTotalPresent++;
+#endif
+
+		ProcessTextureDeletes();
+
+#ifdef HAVE_GL_ARB_SYNC
+
+		if ( gGL->m_bHave_GL_AMD_pinned_memory )
+		{
+			m_PinnedMemoryBuffers[m_nCurPinnedMemoryBuffer].InsertFence();
+			
+			m_nCurPinnedMemoryBuffer = ( m_nCurPinnedMemoryBuffer + 1 ) % cNumPinnedMemoryBuffers;
+			
+			m_PinnedMemoryBuffers[m_nCurPinnedMemoryBuffer].BlockUntilNotBusy();
+			
+			gGL->glBindBufferARB( GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, m_PinnedMemoryBuffers[m_nCurPinnedMemoryBuffer].GetHandle() );
+		}
+
+		if ( gGL->m_bHave_GL_ARB_buffer_storage )
+		{
+			for (uint lpType = 0; lpType < kGLMNumBufferTypes; ++lpType)
+			{
+				m_persistentBuffer[m_nCurPersistentBuffer][lpType].InsertFence();
+			}
+
+			m_nCurPersistentBuffer = ( m_nCurPersistentBuffer + 1 ) % cNumPersistentBuffers;
+
+			for (uint lpType = 0; lpType < kGLMNumBufferTypes; ++lpType)
+			{
+				m_persistentBuffer[m_nCurPersistentBuffer][lpType].BlockUntilNotBusy();
+			}
+		}
+
+#endif // HAVE_GL_ARB_SYNC
+					
+		bool newRefreshMode = false;
+		// two ways to go:
+	
+		// old school, do the resolve, had the tex down to cocoamgr to actually blit.
+		// that way is required if you are not in one-context mode (10.5.8)
+	
+		if ( (gl_blitmode.GetInt() != 0) )
+		{
+			newRefreshMode = true;
+		}
+	
+		// this is the path whether full screen or windowed... we always blit.
+		CShowPixelsParams showparams;
+		memset( &showparams, 0, sizeof(showparams) );
+
+		showparams.m_srcTexName	= tex->m_texName;
+		showparams.m_width		= tex->m_layout->m_key.m_xSize;
+		showparams.m_height		= tex->m_layout->m_key.m_ySize;
+		showparams.m_vsyncEnable = m_displayParams.m_vsyncEnable = mat_vsync.GetBool();
+		showparams.m_fsEnable	= m_displayParams.m_fsEnable;
+		showparams.m_useBlit	= m_caps.m_hasFramebufferBlit;
+
+		// we call showpixels once with the "only sync view" arg set, so we know what the latest surface size is, before trying to do our own blit !
+		showparams.m_onlySyncView = true;
+		ShowPixels(&showparams);	// doesn't actually show anything, just syncs window/fs state (would make a useful separate call)
+		showparams.m_onlySyncView = false;
+	
+		bool refresh = true;
+	#ifdef OSX
+		if ( (glm_nullrefresh_capslock.GetInt()) && (GetCurrentKeyModifiers() & EalphaLock) )
+		{
+			refresh = false;
+		}
+	#endif	
+		static int counter;
+		counter ++;
+
+	#ifdef OSX
+		if ( (glm_literefresh_capslock.GetInt()) && (GetCurrentKeyModifiers() & EalphaLock) && (counter & 127) )
+		{
+			// just show every 128th frame
+			refresh = false;
+		}
+	#endif
+
+		if (refresh)
+		{
+			if (newRefreshMode)
+			{
+				// blit to GL_BACK done here, not in CocoaMgr, this lets us do resolve directly if conditions are right
+
+				GLMRect	srcRect, dstRect;
+			
+				uint dstWidth,dstHeight;
+				DisplayedSize( dstWidth,dstHeight );
+
+				srcRect.xmin	=	0;
+				srcRect.ymin	=	0;
+				srcRect.xmax	=	showparams.m_width;
+				srcRect.ymax	=	showparams.m_height;
+
+				dstRect.xmin	=	0;
+				dstRect.ymin	=	0;
+				dstRect.xmax	=	dstWidth;
+				dstRect.ymax	=	dstHeight;
+			
+				// do not ask for LINEAR if blit is unscaled
+				// NULL means targeting GL_BACK.  Blit2 will break it down into two steps if needed, and will handle resolve, scale, flip.
+				bool blitScales	=	(showparams.m_width != static_cast<int>(dstWidth)) || (showparams.m_height != static_cast<int>(dstHeight));
+				Blit2(	tex, &srcRect, 0,0,
+								NULL, &dstRect, 0,0,
+								blitScales ? GL_LINEAR : GL_NEAREST );
+
+				// we set showparams.m_noBlit, and just let CocoaMgr handle the swap (flushbuffer / page flip)
+				showparams.m_noBlit = true;
+
+				BindFBOToCtx( NULL, GL_FRAMEBUFFER_EXT );
+			}
+			else
+			{
+				ResolveTex( tex, true );	// dxabstract used to do this unconditionally.we still do if new refresh mode doesn't engage.
+
+				BindFBOToCtx( NULL, GL_FRAMEBUFFER_EXT );
+
+				// showparams.m_noBlit is left set to 0.  CocoaMgr does the blit.
+			}
+
+			ShowPixels(&showparams);
+		}
+
+		//	put the original FB back in place (both read and draw)
+		// this bind will hit both read and draw bindings
+		BindFBOToCtx( m_drawingFBO, GL_FRAMEBUFFER_EXT );
+
+		// put em back !!
+		m_ScissorEnable.Flush();	
+		m_ScissorBox.Flush();
+		m_ViewportBox.Flush();		
+	}
+
+	m_nCurFrame++;
+
+#if GL_BATCH_PERF_ANALYSIS
+	tmMessage( TELEMETRY_LEVEL2, TMMF_ICON_EXCLAMATION, "VS Uniform Calls: %u, VS Uniforms: %u|VS Uniform Bone Calls: %u, VS Bone Uniforms: %u|PS Uniform Calls: %u, PS Uniforms: %u", m_nTotalVSUniformCalls, m_nTotalVSUniformsSet, m_nTotalVSUniformBoneCalls, m_nTotalVSUniformsBoneSet, m_nTotalPSUniformCalls, m_nTotalPSUniformsSet );
+	m_nTotalVSUniformCalls = 0, m_nTotalVSUniformBoneCalls = 0, m_nTotalVSUniformsSet = 0, m_nTotalVSUniformsBoneSet = 0, m_nTotalPSUniformCalls = 0, m_nTotalPSUniformsSet = 0;
+#endif
+
+#ifndef OSX
+	GLMGPUTimestampManagerTick();
+#endif
+}
+
+//===============================================================================
+// GLMContext protected methods
+
+// a naive implementation of this would just clear-drawable on the context at entry,
+// and then capture and set fullscreen if requested.
+// however that would glitch thescreen every time the user changed resolution while staying in full screen.
+// but in windowed mode there's really not much to do in here.  Yeah, this routine centers around obtaining
+// drawables for fullscreen mode, and/or dropping those drawables if we're going back to windowed.
+
+// um, are we expected to re-make the standard surfaces (color, depthstencil) if the res changes?  is that now this routine's job ?
+
+// so, kick it off with an assessment of whather we were FS previously or not.
+// if there was no prior display params latched, then it wasn't.
+
+// changes in here take place immediately.  If you want to defer display changes then that's going to be a different method.
+// common assumption is that there will be two places that call this: context create and the implementation of the DX9 Reset method.
+// in either case the client code is aware of what it signed up for.
+
+bool GLMContext::SetDisplayParams( GLMDisplayParams *params )
+{	
+	m_displayParams = *params;	// latch em
+	m_displayParamsValid = true;
+
+	return true;
+}
+
+
+ConVar gl_can_query_fast("gl_can_query_fast", "0");
+
+static uint gPersistentBufferSize[kGLMNumBufferTypes] = 
+{
+	2 * 1024 * 1024,	// kGLMVertexBuffer
+	1 * 1024 * 1024,	// kGLMIndexBuffer
+	0,					// kGLMUniformBuffer
+	0,					// kGLMPixelBuffer
+};
+
+GLMContext::GLMContext( IDirect3DDevice9 *pDevice, GLMDisplayParams *params )
+{
+// 	m_bUseSamplerObjects = true;
+// 	
+// 	// On most AMD drivers (like the current latest, 12.10 Windows), the PCF depth comparison mode doesn't work on sampler objects, so just punt them.
+// 	if ( gGL->m_nDriverProvider == cGLDriverProviderAMD )
+// 	{
+// 		m_bUseSamplerObjects = false;
+// 	}
+	
+// 	if ( CommandLine()->CheckParm( "-gl_disablesamplerobjects" ) )
+// 	{
+	// Disable sampler object usage for now since ScaleForm isn't aware of them
+	// and doesn't know how to push/pop their binding state. It seems we don't
+	// really use them in this codebase anyhow, except to preload textures.
+	m_bUseSamplerObjects = false;
+	if ( CommandLine()->CheckParm( "-gl_enablesamplerobjects" ) )
+		m_bUseSamplerObjects = true;
+
+	// Try to get some more free memory by relying on driver host copies instead of ours.
+	//  In some cases the driver will be able to discard their own host copy and rely on GPU
+	//  memory, reducing memory usage.
+	// Sadly, we have to enable tex client storage for srgb decoding. This should only happen
+	//  on Macs w/ OSX 10.6.
+	m_bTexClientStorage = !gGL->m_bHave_GL_EXT_texture_sRGB_decode;
+	if ( CommandLine()->CheckParm( "-gl_texclientstorage" ) )
+		m_bTexClientStorage = true;
+
+	GLMDebugPrintf( "GL sampler object usage: %s\n", m_bUseSamplerObjects ? "ENABLED" : "DISABLED" );
+
+	m_nCurOwnerThreadId = ThreadGetCurrentId();
+	m_nThreadOwnershipReleaseCounter = 0;
+
+	m_pDevice = pDevice;
+	m_nCurFrame = 0;
+	m_nBatchCounter = 0;
+
+	ClearCurAttribs();
+
+#ifndef OSX
+	m_nCurPinnedMemoryBuffer = 0;
+	if ( gGL->m_bHave_GL_AMD_pinned_memory )
+	{
+		for ( uint t = 0; t < cNumPinnedMemoryBuffers; t++ )
+		{
+			m_PinnedMemoryBuffers[t].Init( GLMGR_PINNED_MEMORY_BUFFER_SIZE );
+		}
+
+		gGL->glBindBufferARB( GL_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD, m_PinnedMemoryBuffers[m_nCurPinnedMemoryBuffer].GetHandle() );
+	}
+#endif // OSX
+
+	m_nCurPersistentBuffer = 0;
+	if ( gGL->m_bHave_GL_ARB_buffer_storage )
+	{
+		for ( uint lpType = 0; lpType < kGLMNumBufferTypes; ++lpType )
+		{
+			for ( uint lpNum = 0; lpNum < cNumPersistentBuffers; ++lpNum )
+			{
+				m_persistentBuffer[lpNum][lpType].Init( (EGLMBufferType)lpType, gPersistentBufferSize[lpType] );
+			}
+		}
+	}
+
+	m_bUseBoneUniformBuffers = true;
+	if (CommandLine()->CheckParm("-disableboneuniformbuffers"))
+	{
+		m_bUseBoneUniformBuffers = false;
+	}
+
+	m_nMaxUsedVertexProgramConstantsHint = 256;
+
+	// flag our copy of display params as blank
+	m_displayParamsValid = false;
+
+	// peek at any CLI options
+	m_slowAssertEnable = CommandLine()->FindParm("-glmassertslow") != 0;
+	m_slowSpewEnable = CommandLine()->FindParm("-glmspewslow") != 0;
+	m_checkglErrorsAfterEveryBatch = CommandLine()->FindParm("-glcheckerrors") != 0;
+	m_slowCheckEnable = m_slowAssertEnable || m_slowSpewEnable || m_checkglErrorsAfterEveryBatch;
+
+	m_drawingLangAtFrameStart = m_drawingLang = kGLMGLSL;		// default to GLSL
+	
+	// this affects FlushDrawStates which will route program bindings, uniform delivery, sampler setup, and enables accordingly.
+
+	if ( CommandLine()->FindParm("-glslmode") )
+	{
+		m_drawingLangAtFrameStart = m_drawingLang = kGLMGLSL;
+	}
+	if ( CommandLine()->FindParm("-arbmode") && !CommandLine()->FindParm("-glslcontrolflow") )
+	{
+		m_drawingLangAtFrameStart = m_drawingLang = kGLMARB;
+	}
+
+	// proceed with rest of init
+	
+	m_dwRenderThreadId = 0;
+	m_bIsThreading = false;
+	
+	m_nsctx	= NULL;
+	m_ctx	= NULL;
+	
+	int *selAttribs	=	NULL;
+	uint					selWords	=	0;
+
+	memset( &m_caps, 0, sizeof( m_caps ) );
+	GetDesiredPixelFormatAttribsAndRendererInfo( (uint**)&selAttribs, &selWords, &m_caps );
+	uint selBytes = selWords * sizeof( uint ); selBytes;
+
+#if defined( USE_SDL )
+	m_ctx = (SDL_GLContext)GetGLContextForWindow( params ? (void*)params->m_focusWindow : NULL );
+	MakeCurrent( true );
+#else
+#error
+#endif
+	IncrementWindowRefCount();
+
+	// If we're using GL_ARB_debug_output, go ahead and setup the callback here.
+	if ( gGL->m_bHave_GL_ARB_debug_output && CommandLine()->FindParm( "-gl_debug" ) ) 
+	{
+#if GLMDEBUG
+		// Turning this on is a perf loss, but it ensures that you can (at least) swap to the other 
+		// threads to see what call is currently being made.
+		// Note that if the driver is in multithreaded mode, you can put it back into singlethreaded mode
+		// and get a real stack for the offending gl call.
+		gGL->glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
+
+#ifdef WIN32
+		// This happens early enough during init that DevMsg() does nothing.
+		OutputDebugStringA( "GLMContext::GLMContext: GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB enabled!\n" );
+#else
+		printf( "GLMContext::GLMContext: GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB enabled!\n" );
+#endif
+
+#endif
+		// This should be there if we get in here--make sure.
+		Assert(gGL->glDebugMessageControlARB);
+		gGL->glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, (const GLuint *)NULL, GL_TRUE);
+
+		// Gonna filter these out, they're "chatty".
+		gGL->glDebugMessageControlARB(GL_DEBUG_SOURCE_API_ARB, GL_DEBUG_TYPE_OTHER_ARB, GL_DEBUG_SEVERITY_LOW_ARB, 0, (const GLuint *)NULL, GL_FALSE);
+		gGL->glDebugMessageCallbackARB(GL_Debug_Output_Callback, (void*)NULL);
+
+		GLMDebugPrintf( "GLMContext::GLMContext: Debug output (gl_arb_debug_output) enabled!\n" );
+	}
+
+
+	if (CommandLine()->FindParm("-glmspewcaps"))
+	{
+		DumpCaps();
+	}
+	
+	SetDisplayParams( params );
+
+	m_texLayoutTable = new CGLMTexLayoutTable;
+
+#ifndef OSX
+	if ( m_bUseSamplerObjects )
+	{
+		memset( m_samplerObjectHash, 0, sizeof( m_samplerObjectHash ) );
+		m_nSamplerObjectHashNumEntries = 0;
+	
+		for ( uint i = 0; i < cSamplerObjectHashSize; ++i )
+		{
+			gGL->glGenSamplers( 1, &m_samplerObjectHash[i].m_samplerObject );
+		}
+	}
+#endif // !OSX
+
+	memset( m_samplers, 0, sizeof( m_samplers ) );
+	for( int i=0; i< GLM_SAMPLER_COUNT; i++)
+	{
+		GLMTexSamplingParams &params = m_samplers[i].m_samp;
+		params.m_packed.m_addressU = D3DTADDRESS_WRAP;
+		params.m_packed.m_addressV = D3DTADDRESS_WRAP;
+		params.m_packed.m_addressW = D3DTADDRESS_WRAP;
+		params.m_packed.m_minFilter = D3DTEXF_POINT;
+		params.m_packed.m_magFilter = D3DTEXF_POINT;
+		params.m_packed.m_mipFilter = D3DTEXF_NONE;
+		params.m_packed.m_maxAniso = 1;
+		params.m_packed.m_isValid = true;
+		params.m_packed.m_compareMode = 0;
+	}
+	
+	MarkAllSamplersDirty();
+	
+	m_activeTexture = -1;
+					
+	m_texLocks.EnsureCapacity( 16 );	// should be sufficient
+
+	// FIXME need a texture tracking table so we can reliably delete CGLMTex objects at context teardown
+		
+	m_boundReadFBO = NULL;
+	m_boundDrawFBO = NULL;
+	m_drawingFBO = NULL;
+											
+	memset( m_drawingProgram, 0, sizeof( m_drawingProgram ) );
+	m_bDirtyPrograms = true;
+	memset( m_programParamsF , 0, sizeof( m_programParamsF ) );
+	memset( m_programParamsB , 0, sizeof( m_programParamsB ) );
+	memset( m_programParamsI , 0, sizeof( m_programParamsI ) );
+
+	for (uint i = 0; i < ARRAYSIZE(m_programParamsF); i++)
+	{
+		m_programParamsF[i].m_firstDirtySlotNonBone = 256;
+		m_programParamsF[i].m_dirtySlotHighWaterNonBone = 0;
+
+		m_programParamsF[i].m_dirtySlotHighWaterBone = 0;
+	}
+
+	m_paramWriteMode = eParamWriteDirtySlotRange;	// default to fastest mode
+	
+	if (CommandLine()->FindParm("-glmwriteallslots"))				m_paramWriteMode = eParamWriteAllSlots;
+	if (CommandLine()->FindParm("-glmwriteshaderslots"))			m_paramWriteMode = eParamWriteShaderSlots;
+	if (CommandLine()->FindParm("-glmwriteshaderslotsoptional"))	m_paramWriteMode = eParamWriteShaderSlotsOptional;
+	if (CommandLine()->FindParm("-glmwritedirtyslotrange"))			m_paramWriteMode = eParamWriteDirtySlotRange;
+	
+	m_attribWriteMode = eAttribWriteDirty;
+
+	if (CommandLine()->FindParm("-glmwriteallattribs"))				m_attribWriteMode = eAttribWriteAll;
+	if (CommandLine()->FindParm("-glmwritedirtyattribs"))			m_attribWriteMode = eAttribWriteDirty;	
+
+	m_pairCache	= new CGLMShaderPairCache( this );
+	m_pBoundPair = NULL;
+
+	m_fragDataMask = 0;
+			
+	memset( m_nBoundGLBuffer, 0xFF, sizeof( m_nBoundGLBuffer ) );
+
+	memset( m_boundVertexAttribs, 0xFF, sizeof(m_boundVertexAttribs) );
+	m_lastKnownVertexAttribMask = 0;
+	m_nNumSetVertexAttributes = 16;
+
+	// make a null program for use when client asks for NULL FP
+	m_pNullFragmentProgram = NewProgram(kGLMFragmentProgram, g_nullFragmentProgramText, "null" );
+	SetProgram( kGLMFragmentProgram, m_pNullFragmentProgram );
+
+	// make dummy programs for doing texture preload via dummy draw
+	m_preloadTexVertexProgram		=	NewProgram(kGLMVertexProgram, g_preloadTexVertexProgramText, "preloadTex" );
+	m_preload2DTexFragmentProgram	=	NewProgram(kGLMFragmentProgram, g_preload2DTexFragmentProgramText, "preload2DTex" );
+	m_preload3DTexFragmentProgram	=	NewProgram(kGLMFragmentProgram, g_preload3DTexFragmentProgramText, "preload3DTex" );
+	m_preloadCubeTexFragmentProgram	=	NewProgram(kGLMFragmentProgram, g_preloadCubeTexFragmentProgramText, "preloadCube" );
+		
+	//memset( &m_drawVertexSetup, 0, sizeof(m_drawVertexSetup) );
+	SetVertexAttributes( NULL );	// will set up all the entries in m_drawVertexSetup
+	
+	m_debugFontTex = NULL;
+
+	// debug state
+	m_debugFrameIndex = -1;
+	
+#if GLMDEBUG
+	// #######################################################################################
+
+	// DebugHook state - we could set these to more interesting values in response to a CLI arg like "startpaused" or something if desired
+	//m_paused = false;
+	m_holdFrameBegin = -1;
+	m_holdFrameEnd = -1;
+	m_holdBatch = m_holdBatchFrame = -1;
+	
+	m_debugDelayEnable = false;
+	m_debugDelay = 1<<19;	// ~0.5 sec delay
+
+	m_autoClearColor = m_autoClearDepth = m_autoClearStencil = false;
+	m_autoClearColorValues[0] = 0.0;	//red
+	m_autoClearColorValues[1] = 1.0;	//green
+	m_autoClearColorValues[2] = 0.0;	//blue
+	m_autoClearColorValues[3] = 1.0;	//alpha
+	
+	m_selKnobIndex = 0;
+	m_selKnobMinValue = -10.0f;
+
+	m_selKnobMaxValue = 10.0f;
+	m_selKnobIncrement = 1/256.0f;
+
+	// #######################################################################################
+#endif
+
+	// make two scratch FBO's for blit purposes
+	m_blitReadFBO = NewFBO();
+	m_blitDrawFBO = NewFBO();
+
+	for( int i=0; i<kGLMScratchFBOCount; i++)
+	{
+		m_scratchFBO[i] = NewFBO();
+	}
+
+	// Create a PBO that we can use to fill textures with bogus data asyncronously.
+	m_nBoundGLBuffer[ kGLMPixelBuffer ] = 0;
+
+	gGL->glGenBuffersARB( 1, &m_destroyPBO );
+	gGL->glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, m_destroyPBO );
+	gGL->glBufferDataARB( GL_PIXEL_UNPACK_BUFFER_ARB, sizeof( g_garbageTextureBits ), g_garbageTextureBits, GL_STATIC_DRAW );
+	gGL->glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, m_nBoundGLBuffer[ kGLMPixelBuffer ] );
+
+	// Create a bunch of texture names for us to use forever and ever ramen.
+	FillTexCache( false, kGLMInitialTexCount );
+
+#ifdef OSX
+	bool new_mtgl = m_caps.m_hasPerfPackage1;	// i.e. 10.6.4 plus new driver
+	
+	if ( CommandLine()->FindParm("-glmenablemtgl2") )
+	{
+		new_mtgl = true;
+	}
+
+	if ( CommandLine()->FindParm("-glmdisablemtgl2") )
+	{
+		new_mtgl = false;
+	}
+
+	bool mtgl_on = params->m_mtgl;
+	if (CommandLine()->FindParm("-glmenablemtgl"))
+	{
+		mtgl_on = true;
+	}
+	
+	if (CommandLine()->FindParm("-glmdisablemtgl"))
+	{
+		mtgl_on = false;
+	}
+
+	CGLError result = (CGLError)0;
+	if (mtgl_on)
+	{
+		bool ready = false;
+		CGLContextObj context = GetCGLContextFromNSGL(m_ctx);
+		if (new_mtgl)
+		{
+			// afterburner
+			CGLContextEnable kCGLCPGCDMPEngine = ((CGLContextEnable)1314);
+			result = CGLEnable( context, kCGLCPGCDMPEngine );
+			if (!result)
+			{
+				ready = true;	// succeeded - no need to try non-MTGL
+				printf("\nMTGL detected.\n");
+			}
+			else
+			{
+				printf("\nMTGL *not* detected, falling back.\n");
+			}
+		}
+
+		if (!ready)
+		{
+			// try old MTGL
+			result = CGLEnable( context, kCGLCEMPEngine );
+			if (!result)
+			{
+				printf("\nMTGL has been detected.\n");
+				ready = true;	// succeeded - no need to try non-MTGL
+			}
+		}
+	}
+
+	if ( m_caps.m_badDriver108Intel )
+	{
+		// this way we have something to look for in terminal spew if users report issues related to this in the future.
+		printf( "\nEnabling GLSL compiler `malloc' workaround.\n" );
+		if ( !IntelGLMallocWorkaround::Get()->Enable() )
+		{
+			Warning( "Unable to enable OSX 10.8 / Intel HD4000 workaround, there might be crashes.\n" );
+		}
+	}
+
+#endif
+	// also, set the remote convar "gl_can_query_fast" to 1 if perf package present, else 0.
+	gl_can_query_fast.SetValue( m_caps.m_hasPerfPackage1?1:0 );
+
+#if GL_BATCH_PERF_ANALYSIS		
+	m_nTotalVSUniformCalls = 0;
+	m_nTotalVSUniformBoneCalls = 0;
+	m_nTotalVSUniformsSet = 0;
+	m_nTotalVSUniformsBoneSet = 0;
+	m_nTotalPSUniformCalls = 0;
+	m_nTotalPSUniformsSet = 0;
+#endif
+
+	// See g_D3DRS_INFO_packed in dxabstract.cpp; dithering is a non-managed
+	// piece of state that we consider off by default. However it is actually
+	// enabled by default in the GL spec, so account for that here.
+	// See: https://bugs.freedesktop.org/show_bug.cgi?id=74700
+	gGL->glDisable( GL_DITHER );
+}
+
+void GLMContext::Reset()
+{
+}
+
+GLMContext::~GLMContext	()
+{
+#ifndef OSX
+	GLMGPUTimestampManagerDeinit();
+		
+	for ( uint t = 0; t < cNumPinnedMemoryBuffers; t++ )
+	{
+		m_PinnedMemoryBuffers[t].Deinit();
+	}
+
+	if (gGL->m_bHave_GL_ARB_buffer_storage)
+	{
+		for (uint lpType = 0; lpType < kGLMNumBufferTypes; ++lpType)
+		{
+			for (uint lpNum = 0; lpNum < cNumPersistentBuffers; ++lpNum)
+			{
+				m_persistentBuffer[lpNum][lpType].Deinit();
+			}
+		}
+	}
+
+	if ( m_bUseSamplerObjects )
+	{
+		for( int i=0; i< GLM_SAMPLER_COUNT; i++)
+		{
+			gGL->glBindSampler( i, 0 );
+		}
+
+		for( int i=0; i< cSamplerObjectHashSize; i++)
+		{
+			gGL->glDeleteSamplers( 1, &m_samplerObjectHash[i].m_samplerObject );
+			m_samplerObjectHash[i].m_samplerObject = 0;
+		}
+	}
+#endif // !OSX
+
+	if (m_debugFontTex)
+	{
+		DelTex( m_debugFontTex );
+		m_debugFontTex = NULL;
+	}
+
+	ProcessTextureDeletes();
+
+	if ( m_pNullFragmentProgram )
+	{
+		DelProgram( m_pNullFragmentProgram );
+		m_pNullFragmentProgram = NULL;
+	}
+	
+	// walk m_fboTable and free them up..
+	FOR_EACH_VEC( m_fboTable, i )
+	{
+		CGLMFBO *fbo = m_fboTable[i];
+		DelFBO( fbo );
+	}
+	m_fboTable.SetSize( 0 );
+
+	if (m_pairCache)
+	{
+		delete m_pairCache;
+		m_pairCache = NULL;
+	}
+	
+	// we need a m_texTable I think..
+
+	// m_texLayoutTable can be scrubbed once we know that all the tex are freed
+
+	gGL->glDeleteBuffersARB( 1, &m_destroyPBO );
+
+	PurgeTexCache();
+
+	DecrementWindowRefCount();
+}
+
+// This method must call SelectTMU()/glActiveTexture() (it's expected as a side effect).
+// This method is no longer called from any performance sensitive code paths.
+void GLMContext::BindTexToTMU( CGLMTex *pTex, int tmu )
+{
+#if GLMDEBUG
+	GLM_FUNC;
+#endif
+
+	GLMPRINTF(("--- GLMContext::BindTexToTMU tex %p GL name %d -> TMU %d ", pTex, pTex ? pTex->m_texName : -1, tmu ));
+
+	CheckCurrent();
+		
+	SelectTMU( tmu );
+		
+	if ( !pTex )
+	{
+		gGL->glBindTexture( GL_TEXTURE_1D, 0 );
+		gGL->glBindTexture( GL_TEXTURE_2D, 0 );
+		gGL->glBindTexture( GL_TEXTURE_3D, 0 );
+		gGL->glBindTexture( GL_TEXTURE_CUBE_MAP, 0 );
+	}
+	else
+	{
+		const GLenum texGLTarget = pTex->m_texGLTarget;
+		if ( texGLTarget != GL_TEXTURE_1D ) gGL->glBindTexture( GL_TEXTURE_1D, 0 );
+		if ( texGLTarget != GL_TEXTURE_2D ) gGL->glBindTexture( GL_TEXTURE_2D, 0 );
+		if ( texGLTarget != GL_TEXTURE_3D ) gGL->glBindTexture( GL_TEXTURE_3D, 0 );
+		if ( texGLTarget != GL_TEXTURE_CUBE_MAP ) gGL->glBindTexture( GL_TEXTURE_CUBE_MAP, 0 );
+		gGL->glBindTexture( texGLTarget, pTex->m_texName );
+	}
+
+	m_samplers[tmu].m_pBoundTex = pTex;
+}
+
+void GLMContext::BindFBOToCtx( CGLMFBO *fbo, GLenum bindPoint )
+{
+#if GLMDEBUG
+	GLM_FUNC;
+#endif
+	GLMPRINTF(( "--- GLMContext::BindFBOToCtx fbo %p, GL name %d", fbo, (fbo) ? fbo->m_name : -1 ));
+
+	CheckCurrent();
+
+	if ( bindPoint == GL_FRAMEBUFFER_EXT )
+	{
+		gGL->glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, fbo ? fbo->m_name : 0 );
+		m_boundReadFBO = fbo;
+		m_boundDrawFBO = fbo;
+		return;
+	}
+	
+	bool	targetRead = (bindPoint==GL_READ_FRAMEBUFFER_EXT);
+	bool	targetDraw = (bindPoint==GL_DRAW_FRAMEBUFFER_EXT);
+			
+	if (targetRead)
+	{
+		if (fbo)	// you can pass NULL to go back to no-FBO
+		{
+			gGL->glBindFramebufferEXT( GL_READ_FRAMEBUFFER_EXT, fbo->m_name );
+			
+			m_boundReadFBO = fbo;
+			//dontcare fbo->m_bound = true;
+		}
+		else
+		{
+			gGL->glBindFramebufferEXT( GL_READ_FRAMEBUFFER_EXT, 0 );
+			
+			m_boundReadFBO = NULL;
+		}
+	}
+	
+	if (targetDraw)
+	{
+		if (fbo)	// you can pass NULL to go back to no-FBO
+		{
+			gGL->glBindFramebufferEXT( GL_DRAW_FRAMEBUFFER_EXT, fbo->m_name );
+			
+			m_boundDrawFBO = fbo;
+			//dontcare fbo->m_bound = true;
+		}
+		else
+		{
+			gGL->glBindFramebufferEXT( GL_DRAW_FRAMEBUFFER_EXT, 0 );
+			
+			m_boundDrawFBO = NULL;
+		}
+	}
+}
+
+void GLMContext::BindBufferToCtx( EGLMBufferType type, CGLMBuffer *pBuff, bool bForce )
+{
+#if GLMDEBUG
+	GLM_FUNC;
+#endif
+	GLMPRINTF(( "--- GLMContext::BindBufferToCtx buff %p, GL name %d", pBuff, (pBuff) ? pBuff->m_nHandle : -1 ));
+
+	CheckCurrent();
+
+	GLuint nGLName = pBuff ? pBuff->GetHandle() : 0;
+	if ( !bForce ) 
+	{
+		if ( m_nBoundGLBuffer[type] == nGLName )
+			return;
+	}
+	
+	GLenum target = 0;
+	switch( type )
+	{	
+		case kGLMVertexBuffer:		target = GL_ARRAY_BUFFER_ARB;			break;
+		case kGLMIndexBuffer:		target = GL_ELEMENT_ARRAY_BUFFER_ARB;	break;
+		case kGLMUniformBuffer:		target = GL_UNIFORM_BUFFER_EXT;			break;
+		case kGLMPixelBuffer:		target = GL_PIXEL_UNPACK_BUFFER_ARB;	break;
+		default: Assert(!"Unknown buffer type" );
+	}
+			
+	Assert( !pBuff || ( pBuff->m_buffGLTarget == target ) );
+			
+	m_nBoundGLBuffer[type] = nGLName;
+	gGL->glBindBufferARB( target, nGLName );
+}
+
+
+GLuint GLMContext::CreateTex( GLenum texBind, GLenum internalFormat )
+{
+	GLM_FUNC;
+
+	// If we're not doing batch create, just return one here.
+	if ( !gl_batch_tex_creates.GetBool() )
+	{
+		GLuint tex = 0;
+		gGL->glGenTextures( 1, &tex );
+		return tex;
+	}
+
+	FOR_EACH_VEC( m_availableTextures, i )
+	{
+		TextureEntry_t& tex = m_availableTextures[ i ];
+		if (    ( tex.m_nTexBind == GL_NONE || tex.m_nTexBind == texBind  )
+			 && ( tex.m_nInternalFormat == GL_NONE || tex.m_nInternalFormat == internalFormat ) )
+		{
+			// Hit!
+			GLuint retVal = tex.m_nTexName;
+			m_availableTextures.Remove( i );
+			return retVal;
+		}
+	}
+
+	if ( m_availableTextures.Count() >= kGLMHighWaterUndeleted )
+	{
+		PurgeTexCache();
+	}
+
+	return FillTexCache( true, kGLMReUpTexCount );
+}
+
+void GLMContext::CleanupTex( GLenum texBind, GLMTexLayout* pLayout, GLuint tex )
+{
+	// If the total 
+	if ( pLayout->m_storageTotalSize <= ( kDeletedTextureDim * kDeletedTextureDim * sizeof( uint32 ) ) )
+		return;
+
+	const GLuint oldPBO = m_nBoundGLBuffer[ kGLMPixelBuffer ];
+	const GLuint oldTex = ( m_samplers[ m_activeTexture ].m_pBoundTex != NULL ) ? m_samplers[ m_activeTexture ].m_pBoundTex->GetTexName() : 0;
+
+	gGL->glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, m_destroyPBO );
+	gGL->glBindTexture( texBind, tex );
+
+	// Clear out old data.
+	for ( int i = 0; i < pLayout->m_mipCount; ++i )
+	{
+		int mipDim = ( i == 0 ) ? kDeletedTextureDim : 0;
+		if ( pLayout->m_format->m_chunkSize != 1 )
+		{
+			const int chunks = ( mipDim + ( pLayout->m_format->m_chunkSize - 1 ) ) / pLayout->m_format->m_chunkSize;
+			const int dataSize = ( chunks * chunks ) * pLayout->m_format->m_bytesPerSquareChunk;
+			Assert( dataSize <= ( sizeof( uint32) * ARRAYSIZE( g_garbageTextureBits ) ) );
+
+			gGL->glCompressedTexImage2D( texBind, i, pLayout->m_format->m_glIntFormat, mipDim, mipDim, 0, dataSize, 0 );
+		}
+		else
+		{
+			gGL->glTexImage2D( texBind, i, pLayout->m_format->m_glIntFormat, mipDim, mipDim, 0, pLayout->m_format->m_glDataFormat, pLayout->m_format->m_glDataType, 0 );
+		}
+	}
+
+	gGL->glBindTexture( texBind, oldTex );
+	gGL->glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, oldPBO );
+}
+
+void GLMContext::DestroyTex( GLenum texBind, GLMTexLayout* pLayout, GLuint tex )
+{
+	GLM_FUNC;
+
+	// Code only handles 2D for now.
+	if ( texBind != GL_TEXTURE_2D || !gl_batch_tex_destroys.GetBool() )
+	{
+		gGL->glDeleteTextures( 1, &tex );
+		return;
+	}
+	
+	CleanupTex( texBind, pLayout, tex );
+
+	TextureEntry_t entry;
+	entry.m_nTexBind = texBind;
+	entry.m_nInternalFormat = pLayout->m_format->m_glIntFormat;
+	entry.m_nTexName = tex;
+
+	m_availableTextures.AddToTail( entry );
+}
+
+GLuint GLMContext::FillTexCache( bool holdOne, int newTextures )
+{
+	// If we aren't doing batch creates, then don't fill the cache. 
+	if ( !gl_batch_tex_creates.GetBool() )
+		return 0;
+	
+	// If we have to hit the name table, might as well hit it a bunch because this causes 
+	// serialization either way--at least we can do it less often.
+	GLuint* textures = (GLuint*) stackalloc( newTextures * sizeof( GLuint ) );
+	gGL->glGenTextures( newTextures, textures );
+
+	Assert( textures[ 0 ] );
+
+	TextureEntry_t entry;
+	entry.m_nTexBind = GL_NONE;
+	entry.m_nInternalFormat = GL_NONE;
+
+	// We may return 0, so skip adding it here.
+	for ( int i = 1; i < newTextures; ++i )
+	{
+		Assert( textures[ i ] );
+		if ( textures[ i ] )
+		{
+			// We still add these to the tail because we'd prefer to reuse old textures (rather 
+			// than these new ones).
+			entry.m_nTexName = textures[ i ];
+			m_availableTextures.AddToTail( entry );
+		}
+	}
+
+	if ( holdOne )
+		return textures[ 0 ];
+	
+	// If not, stick that last one in the list and return 0.
+	entry.m_nTexName = textures[ 0 ];
+	m_availableTextures.AddToTail( entry );
+
+	return 0;
+}
+
+void GLMContext::PurgeTexCache()
+{
+	GLM_FUNC;
+
+	int textureCount = m_availableTextures.Count();
+
+	if ( textureCount == 0 )
+		return;
+
+	GLuint* textures = (GLuint*) stackalloc( textureCount * sizeof( GLuint ) );
+	
+	FOR_EACH_VEC( m_availableTextures, i )
+	{
+		TextureEntry_t& tex = m_availableTextures[ i ];
+		textures[ i ] = tex.m_nTexName;
+	}
+
+	gGL->glDeleteTextures( textureCount, textures );
+	
+	m_availableTextures.RemoveAll();
+}
+
+#ifdef OSX
+// As far as I can tell this stuff is only useful under OSX.
+ConVar	gl_can_mix_shader_gammas( "gl_can_mix_shader_gammas", 0 );
+ConVar	gl_cannot_mix_shader_gammas( "gl_cannot_mix_shader_gammas", 0 );
+#endif
+
+// ConVar param_write_mode("param_write_mode", "0");
+
+void GLMContext::MarkAllSamplersDirty()
+{
+	m_nNumDirtySamplers = GLM_SAMPLER_COUNT;
+	for (uint i = 0; i < GLM_SAMPLER_COUNT; i++)
+	{
+		m_nDirtySamplerFlags[i] = 0;
+		m_nDirtySamplers[i] = (uint8)i;
+	}
+}
+
+void GLMContext::FlushDrawStatesNoShaders( )
+{
+	Assert( ( m_drawingFBO == m_boundDrawFBO ) && ( m_drawingFBO == m_boundReadFBO ) ); // this check MUST succeed
+
+	GLM_FUNC;
+
+	GL_BATCH_PERF( m_FlushStats.m_nTotalBatchFlushes++; )
+			
+	NullProgram();
+}
+
+#if GLMDEBUG
+
+enum EGLMDebugDumpOptions
+{
+	eDumpBatchInfo,
+	eDumpSurfaceInfo,
+	eDumpStackCrawl,
+	eDumpShaderLinks,
+//	eDumpShaderText,			// we never use this one
+	eDumpShaderParameters,
+	eDumpTextureSetup,
+	eDumpVertexAttribSetup,
+	eDumpVertexData,
+	eOpenShadersForEdit
+};
+
+enum EGLMVertDumpMode
+{
+	// options that affect eDumpVertexData above
+	eDumpVertsNoTransformDump,
+	eDumpVertsTransformedByViewProj,
+	eDumpVertsTransformedByModelViewProj,
+	eDumpVertsTransformedByBoneZeroThenViewProj,
+	eDumpVertsTransformedByBonesThenViewProj,
+	eLastDumpVertsMode
+};
+
+char *g_vertDumpModeNames[] = 
+{
+	"noTransformDump",
+	"transformedByViewProj",
+	"transformedByModelViewProj",
+	"transformedByBoneZeroThenViewProj",
+	"transformedByBonesThenViewProj"
+};
+
+static void CopyTilEOL( char *dst, char *src, int dstSize )
+{
+	dstSize--;
+	
+	int i=0;
+	while ( (i<dstSize) && (src[i] != 0) && (src[i] != '\n') && (src[i] != '\r') )
+	{
+		dst[i] = src[i];
+		i++;
+	}
+	dst[i] = 0;
+}
+
+static uint g_maxVertsToDumpLog2 = 4;
+static uint g_maxFramesToCrawl = 20;			// usually enough.  Not enough? change it..
+
+extern char sg_pPIXName[128];
+
+// min is eDumpVertsNormal, max is the one before eLastDumpVertsMode
+static enum EGLMVertDumpMode g_vertDumpMode = eDumpVertsNoTransformDump;
+
+void GLMContext::DebugDump( GLMDebugHookInfo *info, uint options, uint vertDumpMode )
+{
+	int oldIndent = GLMGetIndent();
+	GLMSetIndent(0);
+	
+	CGLMProgram *vp = m_drawingProgram[kGLMVertexProgram];
+	CGLMProgram *fp = m_drawingProgram[kGLMFragmentProgram];
+
+	bool is_draw = (info->m_caller==eDrawElements);
+	const char *batchtype = is_draw ? "draw" : "clear";
+
+	if (options & (1<<eDumpBatchInfo))
+	{
+		GLMPRINTF(("-D- %s === %s %d ======================================================== %s %d  frame %d", sg_pPIXName, batchtype, m_nBatchCounter, batchtype, m_nBatchCounter, m_debugFrameIndex ));
+	}
+
+	if (options & (1<<eDumpSurfaceInfo))
+	{
+		GLMPRINTF(("-D-" ));
+		GLMPRINTF(("-D- surface info:"));
+		GLMPRINTF(("-D- drawing FBO: %8x   bound draw-FBO: %8x  (%s)", m_drawingFBO, m_boundDrawFBO, (m_drawingFBO==m_boundDrawFBO) ? "in sync" : "desync!" ));
+
+		CGLMFBO	*fbo = m_boundDrawFBO;
+		for( int i=0; i<kAttCount; i++)
+		{
+			CGLMTex *tex = fbo->m_attach[i].m_tex;
+			if (tex)
+			{
+				GLMPRINTF(("-D-    bound FBO (%8x)  attachment %d = tex %8x (GL %d) (%s)", fbo, i, tex, tex->m_texName, tex->m_layout->m_layoutSummary ));
+			}
+			else
+			{
+				// warning if no depthstencil attachment
+				switch(i)
+				{
+					case kAttDepth:
+					case kAttStencil:
+					case kAttDepthStencil:
+						GLMPRINTF(("-D-    bound FBO (%8x)  attachment %d = NULL, warning!", fbo, i ));
+					break;
+				}
+			}
+		}
+	}
+
+	if (options & (1<<eDumpStackCrawl))
+	{
+		CStackCrawlParams	cp;
+		memset( &cp, 0, sizeof(cp) );
+		cp.m_frameLimit = g_maxFramesToCrawl;
+		
+		GetStackCrawl(&cp);
+		
+		GLMPRINTF(("-D-" ));
+		GLMPRINTF(("-D- stack crawl"));
+		for( uint i=0; i< cp.m_frameCount; i++)
+		{
+			GLMPRINTF(("-D-\t%s", cp.m_crawlNames[i] ));
+		}
+	}
+
+	if ( (options & (1<<eDumpShaderLinks)) && is_draw)
+	{
+		// we want to print out - GL name, pathname to disk copy if editable, extra credit would include the summary translation line
+		// so grep for "#// trans#"
+		char	attribtemp[1000];
+		char	transtemp[1000];
+
+		if (vp)
+		{
+			char *attribmap = strstr(vp->m_text, "#//ATTRIBMAP");
+			if (attribmap)
+			{
+				CopyTilEOL( attribtemp, attribmap, sizeof(attribtemp) );
+			}
+			else
+			{
+				strcpy( attribtemp, "no attrib map" );
+			}
+			
+			char *trans = strstr(vp->m_text, "#// trans#");
+			if (trans)
+			{
+				CopyTilEOL( transtemp, trans, sizeof(transtemp) );
+			}
+			else
+			{
+				strcpy( transtemp, "no translation info" );
+			}
+			
+			char *linkpath = "no file link";
+
+			#if GLMDEBUG
+				linkpath = vp->m_editable->m_mirror->m_path;
+			#endif
+			
+			GLMPRINTF(("-D-"));
+			GLMPRINTF(("-D- ARBVP ||  GL %d || Path %s ", vp->m_descs[kGLMARB].m_object.arb, linkpath ));
+			GLMPRINTF(("-D-   Attribs %s", attribtemp ));
+			GLMPRINTF(("-D-   Trans %s", transtemp ));
+
+			/*
+			if ( (options & (1<<eDumpShaderText)) && is_draw )
+			{
+				GLMPRINTF(("-D-"));
+				GLMPRINTF(("-D- VP text " ));
+				GLMPRINTTEXT(vp->m_string, eDebugDump ));
+			}
+			*/
+		}
+		else
+		{
+			GLMPRINTF(("-D- VP (none)" ));
+		}
+
+		if (fp)
+		{
+			char *trans = strstr(fp->m_text, "#// trans#");
+			if (trans)
+			{
+				CopyTilEOL( transtemp, trans, sizeof(transtemp) );
+			}
+			else
+			{
+				strcpy( transtemp, "no translation info" );
+			}
+			
+			char *linkpath = "no file link";
+
+			#if GLMDEBUG
+				linkpath = fp->m_editable->m_mirror->m_path;
+			#endif
+			
+			GLMPRINTF(("-D-"));
+			GLMPRINTF(("-D- FP ||  GL %d || Path %s ", fp->m_descs[kGLMARB].m_object.arb, linkpath ));
+			GLMPRINTF(("-D-   Trans %s", transtemp ));
+
+			/*
+			if ( (options & (1<<eDumpShaderText)) && is_draw )
+			{
+				GLMPRINTF(("-D-"));
+				GLMPRINTF(("-D- FP text " ));
+				GLMPRINTTEXT((fp->m_string, eDebugDump));
+			}
+			*/
+		}
+		else
+		{
+			GLMPRINTF(("-D- FP (none)" ));
+		}
+	}
+
+	if ( (options & (1<<eDumpShaderParameters)) && is_draw )
+	{
+		GLMPRINTF(("-D-"));
+		GLMPRINTF(("-D- VP parameters" ));
+		char *label = "";
+		//int labelcounter = 0;
+		
+		static int vmaskranges[] = { /*18,47,*/ -1,-1 };
+		//float	transposeTemp;				// row, column for printing
+		
+		int slotIndex = 0;
+		int upperSlotLimit = 61;
+			
+			// take a peek at the vertex attrib setup.  If it has an attribute for bone weights, then raise the shader param dump limit to 256.
+		bool usesSkinning = false;
+		GLMVertexSetup *pSetup = &m_drawVertexSetup;			
+		for( int index=0; index < kGLMVertexAttributeIndexMax; index++ )
+		{
+			usesSkinning |= (pSetup->m_attrMask & (1<<index)) && ((pSetup->m_vtxAttribMap[index]>>4)== D3DDECLUSAGE_BLENDWEIGHT);
+		}
+		if (usesSkinning)
+		{
+			upperSlotLimit = 256;
+		}
+
+		while( slotIndex < upperSlotLimit )
+		{
+			// if slot index is in a masked range, skip it
+			// if slot index is the start of a matrix, label it, print it, skip ahead 4 slots
+			for( int maski=0; vmaskranges[maski] >=0; maski+=2)
+			{
+				if ( (slotIndex >= vmaskranges[maski]) && (slotIndex <= vmaskranges[maski+1]) )
+				{
+					// that index is masked. set to one past end of range, print a blank line for clarity
+					slotIndex = vmaskranges[maski+1]+1;
+					GLMPrintStr("-D-     .....");
+				}
+			}
+
+			if (slotIndex < upperSlotLimit)
+			{
+				float *values = &m_programParamsF[ kGLMVertexProgram ].m_values[slotIndex][0];
+				switch( slotIndex )
+				{
+					case	4:
+						printmat( "MODELVIEWPROJ", slotIndex, 4, values );
+						slotIndex += 4;
+					break;
+					
+					case	8:
+						printmat( "VIEWPROJ", slotIndex, 4, values );
+						slotIndex += 4;
+						break;
+						
+					default:
+						if (slotIndex>=58)
+						{
+							// bone
+							char bonelabel[100];
+
+							sprintf(bonelabel, "MODEL_BONE%-2d", (slotIndex-58)/3 );
+							printmat( bonelabel, slotIndex, 3, values );
+
+							slotIndex += 3;
+						}
+						else
+						{
+							// just print the one slot
+							GLMPRINTF(("-D-    %03d: [ %10.5f %10.5f %10.5f %10.5f ]  %s",  slotIndex, values[0], values[1], values[2], values[3], label ));
+							slotIndex++;
+						}
+					break;
+				}
+			}
+		}
+
+		// VP stage still, if in GLSL mode, find the bound pair and see if it has live i0, b0-b3 uniforms
+		if (m_pBoundPair)	// should only be non-NULL in GLSL mode
+		{
+#if 0
+			if (m_pBoundPair->m_locVertexBool0>=0)
+			{
+				GLMPRINTF(("-D- GLSL 'b0': %d",  m_programParamsB[kGLMVertexProgram].m_values[0] ));
+			}
+
+			if (m_pBoundPair->m_locVertexBool1>=0)
+			{
+				GLMPRINTF(("-D- GLSL 'b1': %d",  m_programParamsB[kGLMVertexProgram].m_values[1] ));
+			}
+
+			if (m_pBoundPair->m_locVertexBool2>=0)
+			{
+				GLMPRINTF(("-D- GLSL 'b2': %d",  m_programParamsB[kGLMVertexProgram].m_values[2] ));
+			}
+
+			if (m_pBoundPair->m_locVertexBool3>=0)
+			{
+				GLMPRINTF(("-D- GLSL 'b3': %d",  m_programParamsB[kGLMVertexProgram].m_values[3] ));
+			}
+
+			if (m_pBoundPair->m_locVertexInteger0>=0)
+			{
+				GLMPRINTF(("-D- GLSL 'i0': %d",  m_programParamsI[kGLMVertexProgram].m_values[0][0] ));
+			}
+#endif
+		}
+
+		GLMPRINTF(("-D-"));
+		GLMPRINTF(("-D- FP parameters " ));
+
+		static int fmaskranges[] = { 40,41, -1,-1 };
+		
+		slotIndex = 0;
+		label = "";
+		while(slotIndex < 40)
+		{
+			// if slot index is in a masked range, skip it
+			// if slot index is the start of a matrix, label it, print it, skip ahead 4 slots
+			for( int maski=0; fmaskranges[maski] >=0; maski+=2)
+			{
+				if ( (slotIndex >= fmaskranges[maski]) && (slotIndex <= fmaskranges[maski+1]) )
+				{
+					// that index is masked. set to one past end of range, print a blank line for clarity
+					slotIndex = fmaskranges[maski+1]+1;
+					GLMPrintStr("-D-     .....");
+				}
+			}
+
+			if (slotIndex < 40)
+			{
+				float *values = &m_programParamsF[ kGLMFragmentProgram ].m_values[slotIndex][0];
+				switch( slotIndex )
+				{
+					case 0:	label = "g_EnvmapTint";										break;
+					case 1:	label = "g_DiffuseModulation";								break;
+					case 2:	label = "g_EnvmapContrast_ShadowTweaks";					break;
+					case 3:	label = "g_EnvmapSaturation_SelfIllumMask (xyz, and w)";	break;
+					case 4:	label = "g_SelfIllumTint_and_BlendFactor (xyz, and w)";		break;
+
+					case 12:	label = "g_ShaderControls";				break;
+					case 13:	label = "g_DepthFeatheringConstants";	break;
+
+					case 20:	label = "g_EyePos";						break;
+					case 21:	label = "g_FogParams";					break;
+					case 22:	label = "g_FlashlightAttenuationFactors";	break;
+					case 23:	label = "g_FlashlightPos";				break;
+					case 24:	label = "g_FlashlightWorldToTexture";	break;
+
+					case 28:	label = "cFlashlightColor";				break;
+					case 29:	label = "g_LinearFogColor";				break;
+					case 30:	label = "cLightScale";					break;
+					case 31:	label = "cFlashlightScreenScale";		break;
+
+					default:
+						label = "";
+					break;
+				}
+
+				GLMPRINTF(("-D-    %03d: [ %10.5f %10.5f %10.5f %10.5f ]  %s",  slotIndex, values[0], values[1], values[2], values[3], label ));
+
+				slotIndex ++;
+			}
+		}
+		
+		if (m_pBoundPair->m_locFragmentFakeSRGBEnable)
+		{
+			GLMPRINTF(("-D- GLSL 'flEnableSRGBWrite': %f",  m_pBoundPair->m_fakeSRGBEnableValue ));
+		}
+	}
+
+	if ( (options & (1<<eDumpTextureSetup)) && is_draw )
+	{
+		GLMPRINTF(( "-D-" ));
+		GLMPRINTF(( "-D- Texture / Sampler setup" ));
+		GLMPRINTF(( "-D- TODO" ));
+#if 0
+		for( int i=0; i<GLM_SAMPLER_COUNT; i++ )
+		{
+			if (m_samplers[i].m_pBoundTex)
+			{
+				GLMTexSamplingParams *samp = &m_samplers[i].m_samp;
+				GLMPRINTF(( "-D-" ));
+				GLMPRINTF(("-D- Sampler %-2d tex %08x  layout %s", i, m_samplers[i].m_pBoundTex, m_samplers[i].m_pBoundTex->m_layout->m_layoutSummary ));
+
+				GLMPRINTF(("-D-           addressMode[ %s %s %s ]",
+					GLMDecode( eGL_ENUM, samp->m_addressModes[0] ),
+					GLMDecode( eGL_ENUM, samp->m_addressModes[1] ),
+					GLMDecode( eGL_ENUM, samp->m_addressModes[2] )
+				));
+					
+				GLMPRINTF(("-D-           magFilter    [ %s ]", GLMDecode( eGL_ENUM, samp->m_magFilter ) ));
+				GLMPRINTF(("-D-           minFilter    [ %s ]", GLMDecode( eGL_ENUM, samp->m_minFilter ) ));
+				GLMPRINTF(("-D-           srgb         [ %s ]", samp->m_srgb ? "T" : "F" ));
+				GLMPRINTF(("-D-           shadowFilter [ %s ]", samp->m_compareMode == GL_COMPARE_R_TO_TEXTURE_ARB ? "T" : "F" ));
+				
+				// add more as needed later..
+			}
+		}		
+#endif
+	}
+
+	if ( (options & (1<<eDumpVertexAttribSetup)) && is_draw )
+	{
+		GLMVertexSetup *pSetup = &m_drawVertexSetup;
+		
+		uint	nRelevantMask =	pSetup->m_attrMask;		
+		for( int index=0; index < kGLMVertexAttributeIndexMax; index++ )
+		{
+			uint mask = 1<<index;
+			if (nRelevantMask & mask)
+			{
+				GLMVertexAttributeDesc *setdesc = &pSetup->m_attrs[index];
+
+				char	sizestr[100];
+				if (setdesc->m_nCompCount < 32)
+				{
+					sprintf( sizestr, "%d", setdesc->m_nCompCount);
+				}
+				else
+				{
+					strcpy( sizestr, GLMDecode( eGL_ENUM, setdesc->m_nCompCount ) );
+				}
+				
+				if (pSetup->m_vtxAttribMap[index] != 0xBB)
+				{
+					GLMPRINTF(("-D-   attr=%-2d  decl=$%s%1d  stride=%-2d  offset=%-3d  buf=%08x  size=%s  type=%s  normalized=%s  ",
+									index,
+									GLMDecode(eD3D_VTXDECLUSAGE, pSetup->m_vtxAttribMap[index]>>4 ),
+									pSetup->m_vtxAttribMap[index]&0x0F,
+									setdesc->m_stride,
+									setdesc->m_offset,
+									setdesc->m_pBuffer,
+									sizestr,
+									GLMDecode( eGL_ENUM, setdesc->m_datatype),
+									setdesc->m_normalized?"Y":"N"
+								));
+				}
+				else
+				{
+					// the attrib map is referencing an attribute that is not wired up in the vertex setup...
+					DebuggerBreak();
+				}
+			}
+		}
+	}
+
+	if ( (options & (1<<eDumpVertexData)) && is_draw )
+	{
+		GLMVertexSetup *pSetup = &m_drawVertexSetup;
+		int start = info->m_drawStart;
+		int end = info->m_drawEnd;
+		int endLimit = start + (1<<g_maxVertsToDumpLog2);
+		int realEnd = MIN( end, endLimit );
+
+		// vertex data
+		GLMPRINTF(("-D-"));
+		GLMPRINTF(("-D- Vertex Data : %d of %d verts (index %d through %d)", realEnd-start, end-start, start, realEnd-1));
+	
+		for( int vtxIndex=-1; vtxIndex < realEnd; vtxIndex++ )	// vtxIndex will jump from -1 to start after first spin, not necessarily to 0
+		{
+			char buf[64000];
+			char *mark = buf;
+			
+			// index -1 is the first run through the loop, we just print a header
+			
+			// iterate attrs
+			if (vtxIndex>=0)
+			{
+				mark += sprintf(mark, "-D-  %04d: ", vtxIndex );
+			}
+			
+				// for transform dumping, we latch values as we spot them
+			float	vtxPos[4];
+			int		vtxBoneIndices[4];	// only three get used
+			float	vtxBoneWeights[4];	// only three get used and index 2 is synthesized from 0 and 1
+			
+			vtxPos[0] = vtxPos[1] = vtxPos[2] = 0.0;
+			vtxPos[3] = 1.0;
+			
+			vtxBoneIndices[0] = vtxBoneIndices[1] = vtxBoneIndices[2] = vtxBoneIndices[3] = 0;
+			vtxBoneWeights[0] = vtxBoneWeights[1] = vtxBoneWeights[2] = vtxBoneWeights[3] = 0.0;
+			
+			for( int attr = 0; attr < kGLMVertexAttributeIndexMax; attr++ )
+			{
+				if (pSetup->m_attrMask & (1<<attr) )
+				{
+					GLMVertexAttributeDesc *desc = &pSetup->m_attrs[ attr ];
+					
+					// print that attribute.
+
+					// on OSX, VB's never move unless resized.  You can peek at them when unmapped.  Safe enough for debug..
+					char *bufferBase = (char*)desc->m_pBuffer->m_pLastMappedAddress;
+
+					uint stride = desc->m_stride;
+					uint fieldoffset = desc->m_offset;
+					uint baseoffset = vtxIndex * stride;
+					
+					char *attrBase = bufferBase + baseoffset + fieldoffset;
+
+					uint usage = pSetup->m_vtxAttribMap[attr]>>4;
+					uint usageindex = pSetup->m_vtxAttribMap[attr]&0x0F;
+					
+					if (vtxIndex <0)
+					{
+						mark += sprintf(mark, "[%s%1d @ offs=%04d / strd %03d] ", GLMDecode(eD3D_VTXDECLUSAGE, usage ), usageindex, fieldoffset, stride );
+					}
+					else
+					{
+						mark += sprintf(mark, "[%s%1d ", GLMDecode(eD3D_VTXDECLUSAGE, usage ), usageindex );
+						
+						if (desc->m_nCompCount<32)
+						{
+							for( uint which = 0; which < desc->m_nCompCount; which++ )
+							{
+								static char *fieldname = "xyzw";
+								switch( desc->m_datatype )
+								{
+									case GL_FLOAT:
+									{
+										float	*floatbase = (float*)attrBase;
+										mark += sprintf(mark, (usage != D3DDECLUSAGE_TEXCOORD) ? "%c%7.3f " : "%c%.3f", fieldname[which], floatbase[which] );
+										
+										if (usage==D3DDECLUSAGE_POSITION)
+										{
+											if (which<4)
+											{
+												// latch pos
+												vtxPos[which] = floatbase[which];
+											}
+										}
+
+										if (usage==D3DDECLUSAGE_BLENDWEIGHT)
+										{
+											if (which<4)
+											{
+												// latch weight
+												vtxBoneWeights[which] = floatbase[which];
+											}
+										}
+									}
+									break;
+									
+									case GL_UNSIGNED_BYTE:
+									{
+										unsigned char *unchbase = (unsigned char*)attrBase;
+										mark += sprintf(mark, "%c$%02X ", fieldname[which], unchbase[which] );
+									}
+									break;
+
+									default:
+										// hold off on other formats for now
+										mark += sprintf(mark, "%c????? ", fieldname[which] );
+									break;
+								}
+							}
+						}
+						else	// special path for BGRA bytes which are expressed in GL by setting the *size* to GL_BGRA (gross large enum)
+						{
+							switch(desc->m_nCompCount)
+							{
+								case GL_BGRA:		// byte reversed color
+								{
+									for( int which = 0; which < 4; which++ )
+									{
+										static const char *fieldname = "BGRA";
+										switch( desc->m_datatype )
+										{
+											case GL_UNSIGNED_BYTE:
+											{
+												unsigned char *unchbase = (unsigned char*)attrBase;
+												mark += sprintf(mark, "%c$%02X ", fieldname[which], unchbase[which] );
+												
+												if (usage==D3DDECLUSAGE_BLENDINDICES)
+												{
+													if (which<4)
+													{
+														// latch index
+														vtxBoneIndices[which] = unchbase[which];		// ignoring the component reverse which BGRA would inflict, but we also ignore it below so it matches up.
+													}
+												}
+											}												
+											break;
+
+											default:
+												DebuggerBreak();
+												break;
+										}
+									}
+								}
+								break;
+							}
+						}
+						mark += sprintf(mark, "] " );
+					}
+				}
+			}
+			GLMPrintStr( buf, eDebugDump );
+
+			if (vtxIndex >=0)
+			{
+				// if transform dumping requested, and we've reached the actual vert dump phase, do it
+				float	vtxout[4];
+				char	*translabel = NULL;   // NULL means no print...
+				
+				switch( g_vertDumpMode )
+				{
+					case eDumpVertsNoTransformDump:	break;
+					
+					case eDumpVertsTransformedByViewProj:				// viewproj is slot 8
+					{
+						float *viewproj = &m_programParamsF[ kGLMVertexProgram ].m_values[8][0];
+						transform_dp4( vtxPos, viewproj, 4, vtxout );
+						translabel = "post-viewproj";
+					}
+					break;
+					
+					case eDumpVertsTransformedByModelViewProj:			// modelviewproj is slot 4
+					{
+						float *modelviewproj = &m_programParamsF[ kGLMVertexProgram ].m_values[4][0];
+						transform_dp4( vtxPos, modelviewproj, 4, vtxout );
+						translabel = "post-modelviewproj";
+					}
+					break;
+					
+					case eDumpVertsTransformedByBoneZeroThenViewProj:
+					{
+						float	postbone[4];
+						postbone[3] = 1.0;
+						
+						float *bonemat = &m_programParamsF[ kGLMVertexProgram ].m_values[58][0];
+						transform_dp4( vtxPos, bonemat, 3, postbone );
+						
+						float *viewproj = &m_programParamsF[ kGLMVertexProgram ].m_values[8][0];	// viewproj is slot 8
+						transform_dp4( postbone, viewproj, 4, vtxout );
+
+						translabel = "post-bone0-viewproj";
+					}
+					break;
+					
+					case eDumpVertsTransformedByBonesThenViewProj:
+					{
+						//float	bone[4][4];			// [bone index][bone member]	// members are adjacent
+						
+						vtxout[0] = vtxout[1] = vtxout[2] = vtxout[3] = 0;
+						
+						// unpack the third weight
+						vtxBoneWeights[2] = 1.0 - (vtxBoneWeights[0] + vtxBoneWeights[1]);
+						
+						for( int ibone=0; ibone<3; ibone++ )
+						{
+							int boneindex = vtxBoneIndices[ ibone ];
+							float *bonemat = &m_programParamsF[ kGLMVertexProgram ].m_values[58+(boneindex*3)][0];
+							
+							float boneweight = vtxBoneWeights[ibone];
+							
+							float	postbonevtx[4];
+							
+							transform_dp4( vtxPos, bonemat, 3, postbonevtx );
+							
+							// add weighted sum into output
+							for( int which=0; which<4; which++ )
+							{
+								vtxout[which] += boneweight * postbonevtx[which];
+							}
+						}
+						
+						// fix W ?  do we care ?  check shaders to see what they do...
+						translabel = "post-skin3bone-viewproj";
+					}
+					break;
+				}
+				if(translabel)
+				{
+					// for extra credit, do the perspective divide and viewport
+					
+					GLMPRINTF(("-D-   %-24s: [ %7.4f %7.4f %7.4f %7.4f ]", translabel, vtxout[0],vtxout[1],vtxout[2],vtxout[3] ));
+					GLMPRINTF(("-D-" ));
+				}
+			}
+			
+			if (vtxIndex<0)
+			{
+				vtxIndex = start-1; // for printing of the data (note it will be incremented at bottom of loop, so bias down by 1)
+			}
+			else
+			{	// no more < and > around vert dump lines
+				//mark += sprintf(mark, "" );
+			}
+		}
+	}
+
+	if (options & (1<<eOpenShadersForEdit) )
+	{
+		#if GLMDEBUG
+			if (m_drawingProgram[ kGLMVertexProgram ])
+			{
+				m_drawingProgram[ kGLMVertexProgram ]->m_editable->OpenInEditor();
+			}
+			
+			if (m_drawingProgram[ kGLMFragmentProgram ])
+			{
+				m_drawingProgram[ kGLMFragmentProgram ]->m_editable->OpenInEditor();
+			}
+		#endif
+	}
+/*
+	if (options & (1<<))
+	{
+	}
+*/
+	// trailer line
+	GLMPRINTF(("-D- ===================================================================================== end %s %d  frame %d", batchtype, m_nBatchCounter, m_debugFrameIndex  ));
+
+	GLMSetIndent(oldIndent);
+}
+
+// here is the table that binds knob numbers to names.  change at will.
+char *g_knobnames[] = 
+{
+/*0*/	"dummy",
+
+/*1*/	"FB-SRGB",
+	#if 0
+		/*1*/	"tex-U0-bias",	// src left
+		/*2*/	"tex-V0-bias",	// src upper
+		/*3*/	"tex-U1-bias",	// src right
+		/*4*/	"tex-V1-bias",	// src bottom
+
+		/*5*/	"pos-X0-bias",	// dst left
+		/*6*/	"pos-Y0-bias",	// dst upper
+		/*7*/	"pos-X1-bias",	// dst right
+		/*8*/	"pos-Y1-bias",	// dst bottom
+	#endif
+
+};
+int g_knobcount = sizeof( g_knobnames ) / sizeof( g_knobnames[0] );
+
+void GLMContext::DebugHook( GLMDebugHookInfo *info )
+{
+	// FIXME: This has seriously bitrotted.
+	return;
+
+	bool debughook = false;
+	// debug hook is called after an action has taken place.
+	// that would be the initial action, or a repeat.
+	// if paused, we stay inside this function until return.
+	// when returning, we inform the caller if it should repeat its last action or continue.
+	// there is no global pause state.  The rest of the app runs at the best speed it can.
+
+	// initial stuff we do unconditionally
+	
+	// increment iteration
+	info->m_iteration++;						// can be thought of as "number of times the caller's action has now occurred - starting at 1"
+
+	// now set initial state guess for the info block (outcome may change below)
+	info->m_loop = false;
+
+	// check prior hold-conditions to see if any of them hit.
+	// note we disarm each trigger once the hold has occurred (one-shot style)
+	
+	switch( info->m_caller )
+	{
+		case eBeginFrame:
+			if (debughook) GLMPRINTF(("-D- Caller: BeginFrame" ));
+			if ( (m_holdFrameBegin>=0) && (m_holdFrameBegin==m_debugFrameIndex) )		// did we hit a frame breakpoint?
+			{
+				if (debughook) GLMPRINTF(("-D-         BeginFrame trigger match, clearing m_holdFrameBegin, hold=true" ));
+
+				m_holdFrameBegin = -1;
+
+				info->m_holding = true;
+			}
+		break;
+
+		case eClear:
+			if (debughook) GLMPRINTF(("-D- Caller: Clear" ));
+			if ( (m_holdBatch>=0) && (m_holdBatchFrame>=0) && ((int)m_holdBatch==(int)m_nBatchCounter) && ((int)m_holdBatchFrame==(int)m_debugFrameIndex) )
+			{
+				if (debughook) GLMPRINTF(("-D-         Clear trigger match, clearing m_holdBatch&Frame, hold=true" ));
+
+				m_holdBatch = m_holdBatchFrame = -1;
+
+				info->m_holding = true;
+			}
+			break;
+
+		case eDrawElements:
+			if (debughook) GLMPRINTF(( (info->m_caller==eClear) ? "-D- Caller: Clear" : "-D- Caller: Draw" ));
+			if ( (m_holdBatch>=0) && (m_holdBatchFrame>=0) && ((int)m_holdBatch==(int)m_nBatchCounter) && ((int)m_holdBatchFrame==(int)m_debugFrameIndex) )
+			{
+				if (debughook) GLMPRINTF(("-D-         Draw trigger match, clearing m_holdBatch&Frame, hold=true" ));
+
+				m_holdBatch = m_holdBatchFrame = -1;
+
+				info->m_holding = true;
+			}
+		break;
+
+		case eEndFrame:
+			if (debughook) GLMPRINTF(("-D- Caller: EndFrame" ));
+
+			// check for any expired batch hold req
+			if ( (m_holdBatch>=0) && (m_holdBatchFrame>=0) && (m_holdBatchFrame==m_debugFrameIndex) )
+			{
+				// you tried to say 'next batch', but there wasn't one in this frame.
+				// target first batch of next frame instead
+				if (debughook) GLMPRINTF(("-D-         EndFrame noticed an expired draw hold trigger, rolling to next frame, hold=false"));
+
+				m_holdBatch = 0;
+				m_holdBatchFrame++;
+
+				info->m_holding = false;
+			}
+			
+			// now check for an explicit hold on end of this frame..
+			if ( (m_holdFrameEnd>=0) && (m_holdFrameEnd==m_debugFrameIndex) )
+			{
+				if (debughook) GLMPRINTF(("-D-         EndFrame trigger match, clearing m_holdFrameEnd, hold=true" ));
+
+				m_holdFrameEnd = -1;
+
+				info->m_holding = true;
+			}
+		break;
+	}
+
+	// spin until event queue is empty *and* hold is false
+
+	int evtcount=0;
+
+	bool refresh = info->m_holding || m_debugDelayEnable;  // only refresh once per initial visit (if paused!) or follow up event input	
+	int breakToDebugger = 0;
+		// 1 = break to GDB
+		// 2 = break to OpenGL Profiler if attached
+	
+	do
+	{
+		if (refresh)
+		{
+			if (debughook) GLMPRINTF(("-D- pushing pixels" ));
+			DebugPresent();		// show pixels
+			
+			uint minidumpOptions = (1<<eDumpBatchInfo) /* | (1<<eDumpSurfaceInfo) */;
+			DebugDump( info, minidumpOptions, g_vertDumpMode );
+
+			ThreadSleep( 10000 / 1000 );				// lil sleep
+			
+			refresh = false;
+		}
+
+		bool eventCheck = true;			// event pull will be skipped if we detect a shader edit being done
+		// keep editable shaders in sync
+		#if GLMDEBUG
+		
+			bool redrawBatch = false;
+			if (m_drawingProgram[ kGLMVertexProgram ])
+			{
+				if( m_drawingProgram[ kGLMVertexProgram ]->SyncWithEditable() )
+				{
+					redrawBatch = true;
+				}
+			}
+			
+			if (m_drawingProgram[ kGLMFragmentProgram ])
+			{
+				if( m_drawingProgram[ kGLMFragmentProgram ]->SyncWithEditable() )
+				{
+					redrawBatch = true;
+				}
+			}
+			
+			if (redrawBatch)
+			{
+				// act as if user pressed the option-\ key
+				
+				if (m_drawingLang == kGLMGLSL)
+				{
+					// if GLSL mode, force relink - and refresh the pair cache as needed
+					if (m_pBoundPair)
+					{
+						// fix it in place
+						m_pBoundPair->RefreshProgramPair();
+					}
+				}
+				
+				// TODO - need to retest this whole path
+				FlushDrawStates( 0, 0, 0 );	// this is key, because the linked shader pair may have changed (note call to PurgePairsWithShader in cglmprogram.cpp)
+				
+				GLMPRINTF(("-- Shader changed, re-running batch" ));
+
+				m_holdBatch = m_nBatchCounter;
+				m_holdBatchFrame = m_debugFrameIndex;
+				m_debugDelayEnable = false;
+				
+				info->m_holding = false;
+				info->m_loop = true;
+				
+				eventCheck = false;
+			}
+		#endif
+		
+		if(eventCheck)
+		{
+			PumpWindowsMessageLoop();
+			CCocoaEvent	evt;
+			evtcount = 	GetEvents( &evt, 1, true );	// asking for debug events only.
+			if (evtcount)
+			{
+				// print it
+				if (debughook) GLMPRINTF(("-D- Received debug key '%c' with modifiers %x", evt.m_UnicodeKeyUnmodified, evt.m_ModifierKeyMask ));
+				
+				// flag for refresh if we spin again
+				refresh = 1;
+				
+				switch(evt.m_UnicodeKeyUnmodified)
+				{
+					case ' ':					// toggle pause
+						// clear all the holds to be sure
+						m_holdFrameBegin = m_holdFrameEnd = m_holdBatch = m_holdBatchFrame = -1;
+						info->m_holding = !info->m_holding;
+						
+						if (!info->m_holding)
+						{
+							m_debugDelayEnable = false;	// coming out of pause means no slow mo
+						}
+
+						GLMPRINTF((info->m_holding ? "-D- Paused." :  "-D- Unpaused." ));
+					break;
+					
+					case 'f':					// frame advance
+						GLMPRINTF(("-D- Command: next frame" ));
+						m_holdFrameBegin = m_debugFrameIndex+1;		// stop at top of next numbered frame
+						m_debugDelayEnable = false;					// get there fast
+
+						info->m_holding = false;
+					break;
+
+					case ']':					// ahead 1 batch
+					case '}':					// ahead ten batches
+					{
+						int delta = evt.m_UnicodeKeyUnmodified == ']' ? 1 : 10;
+						m_holdBatch = m_nBatchCounter+delta;
+						m_holdBatchFrame = m_debugFrameIndex;
+						m_debugDelayEnable = false;					// get there fast
+						info->m_holding = false;
+						GLMPRINTF(("-D- Command: advance %d batches to %d", delta, m_holdBatch ));
+					}
+					break;
+
+					case '[':					// back one batch
+					case '{':					// back 10 batches
+					{
+						int delta = evt.m_UnicodeKeyUnmodified == '[' ? -1 : -10;
+						m_holdBatch = m_nBatchCounter + delta;
+						if (m_holdBatch<0)
+						{
+							m_holdBatch = 0;
+						}
+						m_holdBatchFrame = m_debugFrameIndex+1;		// next frame, but prev batch #
+						m_debugDelayEnable = false;					// get there fast
+						info->m_holding = false;
+						GLMPRINTF(("-D- Command: rewind %d batches to %d", delta, m_holdBatch ));
+					}
+					break;
+
+					case '\\':					// batch rerun
+
+						m_holdBatch = m_nBatchCounter;
+						m_holdBatchFrame = m_debugFrameIndex;
+						m_debugDelayEnable = false;						
+						info->m_holding = false;
+						info->m_loop = true;
+						GLMPRINTF(("-D- Command: re-run batch %d", m_holdBatch ));
+					break;
+					
+					case 'c':					// toggle auto color clear
+						m_autoClearColor = !m_autoClearColor;
+						GLMPRINTF((m_autoClearColor ? "-D- Auto color clear ON" :  "-D- Auto color clear OFF" ));
+					break;
+
+					case 's':					// toggle auto stencil clear
+						m_autoClearStencil = !m_autoClearStencil;
+						GLMPRINTF((m_autoClearStencil ? "-D- Auto stencil clear ON" :  "-D- Auto stencil clear OFF" ));
+					break;
+
+					case 'd':					// toggle auto depth clear
+						m_autoClearDepth = !m_autoClearDepth;
+						GLMPRINTF((m_autoClearDepth ? "-D- Auto depth clear ON" :  "-D- Auto depth clear OFF" ));
+					break;
+
+					case '.':					// break to debugger  or insta-quit
+						if (evt.m_ModifierKeyMask & (1<<eControlKey))
+						{
+							GLMPRINTF(( "-D- INSTA QUIT!  (TM) (PAT PEND)" ));
+							abort();
+						}
+						else
+						{
+							GLMPRINTF(( "-D- Breaking to debugger" ));
+							breakToDebugger = 1;
+
+							info->m_holding = true;
+							info->m_loop = true;	// so when you come back from debugger, you get another spin (i.e. you enter paused mode)
+						}						
+					break;
+					
+					case 'g':					// break to OGLP and enable OGLP logging of spew
+						if (GLMDetectOGLP())	// if this comes back true, there will be a breakpoint set on glColor4sv.
+						{
+							uint channelMask = GLMDetectAvailableChannels();	// will re-assert whether spew goes to OGLP log
+							
+							if (channelMask & (1<<eGLProfiler))
+							{
+								GLMDebugChannelMask(&channelMask);
+								breakToDebugger = 2;
+
+								info->m_holding = true;
+								info->m_loop = true;	// so when you come back from debugger, you get another spin (i.e. you enter paused mode)
+							}
+						}
+					break;
+
+					case '_':					// toggle slow mo
+						m_debugDelayEnable = !m_debugDelayEnable;
+					break;
+
+					case '-':					// go slower
+						if (m_debugDelayEnable)
+						{
+							// already in slow mo, so lower speed
+							m_debugDelay <<= 1;	// double delay
+							if (m_debugDelay > (1<<24))
+							{
+								m_debugDelay = (1<<24);
+							}
+						}
+						else
+						{
+							// enter slow mo
+							m_debugDelayEnable = true;
+						}
+					break;
+
+					case '=':					// go faster
+						if (m_debugDelayEnable)
+						{
+							// already in slow mo, so raise speed
+							m_debugDelay >>= 1;	// halve delay
+							if (m_debugDelay < (1<<17))
+							{
+								m_debugDelay = (1<<17);
+							}
+						}
+						else
+						{
+							// enter slow mo
+							m_debugDelayEnable = true;
+						}
+					break;
+					
+					case 'v':
+						// open vs in editor (foreground pop)
+						#if GLMDEBUG
+							if (m_drawingProgram[ kGLMVertexProgram ])
+							{
+								m_drawingProgram[ kGLMVertexProgram ]->m_editable->OpenInEditor( true );
+							}
+						#endif						
+					break;
+
+					case 'p':
+						// open fs/ps in editor (foreground pop)
+						#if GLMDEBUG
+							if (m_drawingProgram[ kGLMFragmentProgram ])
+							{
+								m_drawingProgram[ kGLMFragmentProgram ]->m_editable->OpenInEditor( true );
+							}
+						#endif
+					break;
+					
+					case '<':	// dump fewer verts
+					case '>':	// dump more verts
+					{
+						int delta = (evt.m_UnicodeKeyUnmodified=='>') ? 1 : -1;
+						g_maxVertsToDumpLog2 = MIN( MAX( g_maxVertsToDumpLog2+delta, 0 ), 16 );
+						
+						// just re-dump the verts
+						DebugDump( info, 1<<eDumpVertexData, g_vertDumpMode );
+					}
+					break;
+					
+					case 'x':	// adjust transform dump mode
+					{
+						int newmode = g_vertDumpMode+1;
+						if (newmode >= eLastDumpVertsMode)
+						{
+							// wrap
+							newmode = eDumpVertsNoTransformDump;
+						}
+						g_vertDumpMode = (EGLMVertDumpMode)newmode;
+						
+						GLMPRINTF(("-D- New vert dump mode is %s", g_vertDumpModeNames[g_vertDumpMode] ));
+					}
+					break;
+
+					case	'u':	// more crawl
+					{
+						CStackCrawlParams	cp;
+						memset( &cp, 0, sizeof(cp) );
+						cp.m_frameLimit = kMaxCrawlFrames;
+						
+						GetStackCrawl(&cp);
+						
+						GLMPRINTF(("-D-" ));
+						GLMPRINTF(("-D- extended stack crawl:"));
+						for( uint i=0; i< cp.m_frameCount; i++)
+						{
+							GLMPRINTF(("-D-\t%s", cp.m_crawlNames[i] ));
+						}
+					}
+
+					break;
+						
+					case 'q':
+						DebugDump( info, 0xFFFFFFFF, g_vertDumpMode );
+					break;
+					
+	
+					case 'H':
+					case 'h':
+					{
+						// toggle drawing language.  hold down shift key to do it immediately.
+						
+						if (m_caps.m_hasDualShaders)
+						{
+							bool immediate;
+							
+							immediate = evt.m_UnicodeKeyUnmodified == 'H';	// (evt.m_ModifierKeyMask & (1<<eShiftKey)) != 0;
+							
+							if (m_drawingLang==kGLMARB)
+							{
+								GLMPRINTF(( "-D- Setting GLSL language mode %s.", immediate ? "immediately" : "for next frame start" ));
+								SetDrawingLang( kGLMGLSL, immediate );
+							}
+							else
+							{
+								GLMPRINTF(( "-D- Setting ARB language mode %s.", immediate ? "immediately" : "for next frame start" ));
+								SetDrawingLang( kGLMARB, immediate );
+							}
+							refresh = immediate;
+						}
+						else
+						{
+							GLMPRINTF(("You can't change shader languages unless you launch with -glmdualshaders enabled"));
+						}
+
+					}
+					break;
+					
+
+					// ======================================================== debug knobs.  change these as needed to troubleshoot stuff
+					
+					// keys to select a knob
+					// or, toggle a debug flavor, if control is being held down
+					case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+					{
+						if (evt.m_ModifierKeyMask & (1<<eControlKey))
+						{
+							// '0' toggles the all-channels on or off
+							int flavorSelect = evt.m_UnicodeKeyUnmodified - '0';
+							
+							if ( (flavorSelect >=0) && (flavorSelect<eFlavorCount) )
+							{
+								uint mask = GLMDebugFlavorMask();
+								
+								mask ^= (1<<flavorSelect);
+
+								GLMDebugFlavorMask(&mask);
+							}
+						}
+						else
+						{
+							// knob selection
+							m_selKnobIndex = evt.m_UnicodeKeyUnmodified - '0';
+
+							GLMPRINTF(("-D- Knob # %d (%s) selected.", m_selKnobIndex, g_knobnames[ m_selKnobIndex ] ));
+							
+							m_selKnobIncrement = (m_selKnobIndex<5) ? (1.0f / 2048.0f) : (1.0 / 256.0f);
+							ThreadSleep( 500000 / 1000 );
+						}
+						refresh = false;
+					}
+					break;
+					
+					// keys to adjust or zero a knob
+					case 't':		// toggle
+					{
+						if (m_selKnobIndex < g_knobcount)
+						{
+							GLMKnobToggle( g_knobnames[ m_selKnobIndex ] );
+						}
+					}
+					break;
+					
+					case 'l':		// less
+					case 'm':		// more
+					case 'z':		// zero
+					{						
+						if (m_selKnobIndex < g_knobcount)
+						{
+							float val = GLMKnob( g_knobnames[ m_selKnobIndex ], NULL );
+							
+							if (evt.m_UnicodeKeyUnmodified == 'l')
+							{
+								// minus (less)
+								val -= m_selKnobIncrement;
+								if (val < m_selKnobMinValue)
+								{
+									val = m_selKnobMinValue;
+								}
+								// send new value back to the knob
+								GLMKnob( g_knobnames[ m_selKnobIndex ], &val );
+							}
+
+							if (evt.m_UnicodeKeyUnmodified == 'm')
+							{
+								// plus (more)
+								val += m_selKnobIncrement;
+								if (val > m_selKnobMaxValue)
+								{
+									val = m_selKnobMaxValue;
+								}
+								// send new value back to the knob
+								GLMKnob( g_knobnames[ m_selKnobIndex ], &val );
+							}
+							
+							if (evt.m_UnicodeKeyUnmodified == 'z')
+							{
+								// zero
+								val = 0.0f;
+
+								// send new value back to the knob
+								GLMKnob( g_knobnames[ m_selKnobIndex ], &val );
+							}
+							
+							GLMPRINTF(("-D- Knob # %d (%s) set to %f  (%f/1024.0)", m_selKnobIndex, g_knobnames[ m_selKnobIndex ], val, val * 1024.0 ));
+
+							ThreadSleep( 500000 / 1000 );
+
+							refresh = false;
+						}
+					}
+					break;
+
+				}
+			}
+		}		
+	}	while( ((evtcount>0) || info->m_holding) && (!breakToDebugger) );
+
+	if (m_debugDelayEnable)
+	{
+		ThreadSleep( m_debugDelay / 1000 );
+	}
+
+	if (breakToDebugger)
+	{
+		switch (breakToDebugger)
+		{
+			case 1:
+				DebuggerBreak();
+			break;
+			
+			case 2:
+				short fakecolor[4] = { 0, 0, 0, 0 };
+				gGL->glColor4sv( fakecolor );	// break to OGLP
+			break;
+		}
+		// re-flush all GLM states so you can fiddle with them in the debugger. then run the batch again and spin..
+		ForceFlushStates();
+	}
+}
+
+void GLMContext::DebugPresent( void )
+{
+	CGLMTex *drawBufferTex = m_drawingFBO->m_attach[kAttColor0].m_tex;
+	gGL->glFinish();
+	Present( drawBufferTex );
+}
+
+void GLMContext::DebugClear( void )
+{
+	// get old clear color
+	GLClearColor_t clearcol_orig;
+	m_ClearColor.Read( &clearcol_orig,0 );
+	
+	// new clear color
+	GLClearColor_t clearcol;
+	clearcol.r = m_autoClearColorValues[0];
+	clearcol.g = m_autoClearColorValues[1];
+	clearcol.b = m_autoClearColorValues[2];
+	clearcol.a = m_autoClearColorValues[3];
+	m_ClearColor.Write( &clearcol ); // don't check, don't defer
+	
+	uint mask = 0;
+	
+	if (m_autoClearColor) mask |= GL_COLOR_BUFFER_BIT;
+	if (m_autoClearDepth) mask |= GL_DEPTH_BUFFER_BIT;
+	if (m_autoClearStencil) mask |= GL_STENCIL_BUFFER_BIT;
+	
+	gGL->glClear( mask );
+	gGL->glFinish();
+
+	// put old color back
+	m_ClearColor.Write( &clearcol_orig ); // don't check, don't defer
+}
+
+#endif
+
+void GLMContext::CheckNative( void )
+{
+	// note that this is available in release.  We don't use GLMPRINTF for that reason.
+	// note we do not get called unless either slow-batch asserting or logging is enabled.
+#ifdef OSX	
+	bool gpuProcessing;
+	GLint fragmentGPUProcessing, vertexGPUProcessing;
+	
+	CGLGetParameter (CGLGetCurrentContext(), kCGLCPGPUFragmentProcessing, &fragmentGPUProcessing);
+	CGLGetParameter(CGLGetCurrentContext(), kCGLCPGPUVertexProcessing, &vertexGPUProcessing);
+
+	// spews then asserts.
+	// that way you can enable both, get log output on a pair if it's slow, and then the debugger will pop.
+	if(m_slowSpewEnable)
+	{
+		if ( !vertexGPUProcessing )
+		{
+			m_drawingProgram[ kGLMVertexProgram ]->LogSlow( m_drawingLang );
+		}
+		if ( !fragmentGPUProcessing )
+		{
+			m_drawingProgram[ kGLMFragmentProgram ]->LogSlow( m_drawingLang );
+		}
+	}
+
+	if(m_slowAssertEnable)
+	{
+		if ( !vertexGPUProcessing || !fragmentGPUProcessing)
+		{
+			Assert( !"slow batch" );
+		}
+	}
+#else
+	//Assert( !"impl GLMContext::CheckNative()" );
+
+	if (m_checkglErrorsAfterEveryBatch)
+	{
+		// This is slow, and somewhat redundant (-gldebugoutput uses the GL_ARB_debug_output extension, which can be at least asynchronous), but having a straightforward backup can be useful.
+		// This is useful for callstack purposes - GL_ARB_debug_output may break in a different thread that the thread triggering the GL error.
+		//gGL->glFlush();
+		GLenum errorcode = (GLenum)gGL->glGetError();
+		if ( errorcode != GL_NO_ERROR )
+		{
+			const char	*decodedStr = GLMDecode( eGL_ERROR, errorcode );
+
+			char buf[512];
+			V_snprintf( buf, sizeof( buf), "\nGL ERROR! %08x = '%s'\n", errorcode, decodedStr );
+
+			// Make sure the dev sees something, because these errors can happen early enough that DevMsg() does nothing.
+#ifdef WIN32
+			OutputDebugStringA( buf );
+#else
+			printf( "%s", buf );
+#endif
+		}
+	}
+
+#endif
+
+}
+
+
+
+// debug font
+void GLMContext::GenDebugFontTex( void )
+{
+	if(!m_debugFontTex)
+	{
+		// make a 128x128 RGBA texture
+		GLMTexLayoutKey key;
+		memset( &key, 0, sizeof(key) );
+		
+		key.m_texGLTarget	= GL_TEXTURE_2D;
+		key.m_xSize			= 128;
+		key.m_ySize			= 128;
+		key.m_zSize			= 1;
+		key.m_texFormat		= D3DFMT_A8R8G8B8;
+		key.m_texFlags		= 0;
+
+		m_debugFontTex = NewTex( &key, 1, "GLM debug font" );
+		
+
+		//-----------------------------------------------------
+		GLMTexLockParams lockreq;
+		
+		lockreq.m_tex = m_debugFontTex;
+		lockreq.m_face = 0;
+		lockreq.m_mip = 0;
+
+		GLMTexLayoutSlice *slice = &m_debugFontTex->m_layout->m_slices[ lockreq.m_tex->CalcSliceIndex( lockreq.m_face, lockreq.m_mip ) ];
+		
+		lockreq.m_region.xmin = lockreq.m_region.ymin = lockreq.m_region.zmin = 0;
+		lockreq.m_region.xmax = slice->m_xSize;
+		lockreq.m_region.ymax = slice->m_ySize;
+		lockreq.m_region.zmax = slice->m_zSize;
+
+		lockreq.m_readback = false;
+		
+		char	*lockAddress;
+		int		yStride;
+		int		zStride;
+		
+		m_debugFontTex->Lock( &lockreq, &lockAddress, &yStride, &zStride );
+		
+		//-----------------------------------------------------
+		// fetch elements of font data and make texels... we're doing the whole slab so we don't really need the stride info
+		unsigned long *destTexelPtr = (unsigned long *)lockAddress;
+
+		for( int index = 0; index < 16384; index++ )
+		{
+			if (g_glmDebugFontMap[index] == ' ')
+			{
+				// clear
+				*destTexelPtr = 0x00000000;
+			}
+			else
+			{
+				// opaque white (drawing code can modulate if desired)
+				*destTexelPtr = 0xFFFFFFFF;
+			}
+			destTexelPtr++;
+		}
+		
+		//-----------------------------------------------------
+		GLMTexLockParams unlockreq;
+		
+		unlockreq.m_tex = m_debugFontTex;
+		unlockreq.m_face = 0;
+		unlockreq.m_mip = 0;
+
+		// region need not matter for unlocks
+		unlockreq.m_region.xmin = unlockreq.m_region.ymin = unlockreq.m_region.zmin = 0;
+		unlockreq.m_region.xmax = unlockreq.m_region.ymax = unlockreq.m_region.zmax = 0;
+
+		unlockreq.m_readback = false;
+
+		m_debugFontTex->Unlock( &unlockreq );
+
+		//-----------------------------------------------------
+			// change up the tex sampling on this texture to be "nearest" not linear
+			
+		//-----------------------------------------------------
+
+		// don't leave texture bound on the TMU
+		BindTexToTMU( NULL, 0 );
+		
+		// also make the index and vertex buffers for use - up to 1K indices and 1K verts
+		
+		uint indexBufferSize = 1024*2;
+		
+		m_debugFontIndices = NewBuffer(kGLMIndexBuffer, indexBufferSize, 0);	// two byte indices
+		
+		// we go ahead and lock it now, and fill it with indices 0-1023.
+		char *indices = NULL;
+		GLMBuffLockParams		idxLock;
+		idxLock.m_nOffset		= 0;
+		idxLock.m_nSize			= indexBufferSize;
+		idxLock.m_bNoOverwrite	= false;
+		idxLock.m_bDiscard		= true;
+		m_debugFontIndices->Lock( &idxLock, &indices );
+		for( int i=0; i<1024; i++)
+		{
+			unsigned short *idxPtr = &((unsigned short*)indices)[i];
+			*idxPtr = i;
+		}
+		m_debugFontIndices->Unlock();
+		
+		m_debugFontVertices = NewBuffer(kGLMVertexBuffer, 1024 * 128, 0);	// up to 128 bytes per vert
+	}
+}
+
+#define MAX_DEBUG_CHARS 256
+struct GLMDebugTextVertex
+{
+	float	x,y,z;
+	float	u,v;
+	char	rgba[4];
+};
+
+void GLMContext::DrawDebugText( float x, float y, float z, float drawCharWidth, float drawCharHeight, char *string )
+{
+	if (!m_debugFontTex)
+	{
+		GenDebugFontTex();
+	}
+	
+	// setup needed to draw text
+	
+	// we're assuming that +x goes left to right on screen, no billboarding math in here
+	// and that +y goes bottom up
+	// caller knows projection / rectangle so it gets to decide vertex spacing
+	
+	// debug font must be bound to TMU 0
+	// texturing enabled
+	// alpha blending enabled
+	// generate a quad per character
+	//  characters are 6px wide by 11 px high.
+	//	upper left character in tex is 0x20
+	// y axis will need to be flipped for display
+	
+	// for any character in 0x20 - 0x7F - here are the needed UV's
+	
+	// leftU = ((character % 16) * 6.0f / 128.0f)
+	// rightU = lowU + (6.0 / 128.0);
+	// topV = ((character - 0x20) * 11.0f / 128.0f)
+	// bottomV = lowV + (11.0f / 128.0f)
+	
+	int stringlen = strlen( string );
+	if (stringlen > MAX_DEBUG_CHARS)
+	{
+		stringlen = MAX_DEBUG_CHARS;
+	}
+
+	// lock
+	char					*vertices = NULL;
+	GLMBuffLockParams		vtxLock;
+	vtxLock.m_nOffset		= 0;
+	vtxLock.m_nSize			= 1024 * stringlen;
+	vtxLock.m_bNoOverwrite	= false;
+	vtxLock.m_bDiscard		= false;
+	m_debugFontVertices->Lock( &vtxLock, &vertices );
+			
+	GLMDebugTextVertex	*vtx =  (GLMDebugTextVertex*)vertices;
+	GLMDebugTextVertex *vtxOutPtr = vtx;
+	
+	for( int charindex = 0; charindex < stringlen; charindex++ )
+	{
+		float	leftU,rightU,topV,bottomV;
+		
+		int character = (int)string[charindex];
+		character -= 0x20;
+		if ( (character<0) || (character > 0x7F) )
+		{
+			character = '*' - 0x20;
+		}
+		
+		leftU	= ((character & 0x0F) * 6.0f ) / 128.0f;
+		rightU	= leftU + (6.0f / 128.0f);
+
+		topV	= ((character >> 4) * 11.0f ) / 128.0f;
+		bottomV	= topV + (11.0f / 128.0f);
+		
+		float posx,posy,posz;
+		
+		posx = x + (drawCharWidth * (float)charindex);
+		posy = y;
+		posz = z;
+		
+		// generate four verts
+		// first vert will be upper left of displayed quad (low X, high Y) then we go clockwise
+		for( int quadvert = 0; quadvert < 4; quadvert++ )
+		{
+			bool isTop	= (quadvert <2);						// verts 0 and 1
+			bool isLeft	= (quadvert & 1) == (quadvert >> 1);	// verts 0 and 3
+			
+			vtxOutPtr->x = posx + (isLeft ? 0.0f : drawCharWidth);
+			vtxOutPtr->y = posy + (isTop ? drawCharHeight : 0.0f);
+			vtxOutPtr->z = posz;
+			
+			vtxOutPtr->u = isLeft ? leftU : rightU;
+			vtxOutPtr->v = isTop ? topV : bottomV;
+			
+			vtxOutPtr++;
+		}
+	}
+	
+	// verts are done.
+	// unlock...
+	
+	m_debugFontVertices->Unlock();
+	
+	// make a vertex setup
+	GLMVertexSetup vertSetup;
+	
+		// position, color, tc = 0, 3, 8
+	vertSetup.m_attrMask = (1<<kGLMGenericAttr00) |  (1<<kGLMGenericAttr03) |  (1<<kGLMGenericAttr08);
+	
+	vertSetup.m_attrs[kGLMGenericAttr00].m_pBuffer = m_debugFontVertices;
+	vertSetup.m_attrs[kGLMGenericAttr00].m_nCompCount	= 3;			// 3 floats
+	vertSetup.m_attrs[kGLMGenericAttr00].m_datatype	= GL_FLOAT;
+	vertSetup.m_attrs[kGLMGenericAttr00].m_stride	= sizeof(GLMDebugTextVertex);
+	vertSetup.m_attrs[kGLMGenericAttr00].m_offset	= offsetof(GLMDebugTextVertex, x);
+	vertSetup.m_attrs[kGLMGenericAttr00].m_normalized= false;
+
+	vertSetup.m_attrs[kGLMGenericAttr03].m_pBuffer = m_debugFontVertices;
+	vertSetup.m_attrs[kGLMGenericAttr03].m_nCompCount	= 4;			// four bytes
+	vertSetup.m_attrs[kGLMGenericAttr03].m_datatype	= GL_UNSIGNED_BYTE;
+	vertSetup.m_attrs[kGLMGenericAttr03].m_stride	= sizeof(GLMDebugTextVertex);
+	vertSetup.m_attrs[kGLMGenericAttr03].m_offset	= offsetof(GLMDebugTextVertex, rgba);
+	vertSetup.m_attrs[kGLMGenericAttr03].m_normalized= true;
+
+	vertSetup.m_attrs[kGLMGenericAttr08].m_pBuffer = m_debugFontVertices;
+	vertSetup.m_attrs[kGLMGenericAttr08].m_nCompCount	= 2;			// 2 floats
+	vertSetup.m_attrs[kGLMGenericAttr08].m_datatype	= GL_FLOAT;
+	vertSetup.m_attrs[kGLMGenericAttr08].m_stride	= sizeof(GLMDebugTextVertex);
+	vertSetup.m_attrs[kGLMGenericAttr08].m_offset	= offsetof(GLMDebugTextVertex, u);
+	vertSetup.m_attrs[kGLMGenericAttr03].m_normalized= false;
+
+		
+	// bind texture and draw it..
+	CGLMTex *pPrevTex = m_samplers[0].m_pBoundTex;
+	BindTexToTMU( m_debugFontTex, 0 );
+	
+	SelectTMU(0);	// somewhat redundant
+	
+	gGL->glDisable( GL_DEPTH_TEST );
+	
+	gGL->glEnable(GL_TEXTURE_2D);
+
+	if (0)
+	{
+		gGL->glEnableClientState(GL_VERTEX_ARRAY);
+
+		gGL->glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+		
+		gGL->glVertexPointer( 3, GL_FLOAT, sizeof( vtx[0] ), &vtx[0].x );
+		
+		gGL->glClientActiveTexture(GL_TEXTURE0);
+
+		gGL->glTexCoordPointer( 2, GL_FLOAT, sizeof( vtx[0] ), &vtx[0].u );
+	}
+	else
+	{
+		SetVertexAttributes( &vertSetup );
+	}
+
+	gGL->glDrawArrays( GL_QUADS, 0, stringlen * 4 );
+
+	// disable all the input streams
+	if (0)
+	{
+		gGL->glDisableClientState(GL_VERTEX_ARRAY);
+
+		gGL->glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+	}
+	else
+	{
+		SetVertexAttributes( NULL );
+	}
+
+	gGL->glDisable(GL_TEXTURE_2D);
+
+	BindTexToTMU( pPrevTex, 0 );
+}
+
+//===============================================================================
+
+void GLMgrSelfTests( void )	
+{
+	return;	// until such time as the tests are revised or axed
+	
+	GLMDisplayParams	glmParams;	
+	glmParams.m_fsEnable					=	false;
+
+	glmParams.m_vsyncEnable				=	false;	// "The runtime updates the window client area immediately and might do so more 
+	glmParams.m_backBufferWidth				=	1024;
+	glmParams.m_backBufferHeight			=	768;
+	glmParams.m_backBufferFormat			=	D3DFMT_A8R8G8B8;
+	glmParams.m_multiSampleCount			=	2;
+
+	glmParams.m_enableAutoDepthStencil		=	true;
+	glmParams.m_autoDepthStencilFormat		=	D3DFMT_D24S8;
+
+	glmParams.m_fsRefreshHz					=	60;
+
+	glmParams.m_mtgl						=	true;
+	glmParams.m_focusWindow					=	0;
+
+	// make a new context on renderer 0.
+	GLMContext *ctx = GLMgr::aGLMgr()->NewContext( NULL, &glmParams );	////FIXME you can't make contexts this way any more.
+	if (!ctx)
+	{
+		DebuggerBreak();		// no go
+		return;
+	}
+
+	// make a test object based on that context.
+	//int alltests[] = {0,1,2,3,   -1};
+	//int newtests[] = {3, -1};
+	int twotests[] = {2, -1};
+	//int notests[] = {-1};
+	
+	int *testlist = twotests;
+
+	GLMTestParams	params;
+	memset( &params, 0, sizeof(params) );
+
+	params.m_ctx = ctx;
+	params.m_testList = testlist;
+
+	params.m_glErrToDebugger = true;
+	params.m_glErrToConsole = true;
+	
+	params.m_intlErrToDebugger = true;
+	params.m_intlErrToConsole = true;
+	
+	params.m_frameCount = 1000;
+
+	GLMTester testobj( &params );
+
+	testobj.RunTests( );
+	
+	GLMgr::aGLMgr()->DelContext( ctx );
+}
+
+void GLMContext::SetDefaultStates( void )
+{
+	GLM_FUNC;
+	CheckCurrent();
+
+	m_AlphaTestEnable.Default();
+	m_AlphaTestFunc.Default();
+
+	m_AlphaToCoverageEnable.Default();
+	
+	m_CullFaceEnable.Default();
+	m_CullFrontFace.Default();
+	
+	m_PolygonMode.Default();
+	m_DepthBias.Default();
+
+	m_ClipPlaneEnable.Default();
+	m_ClipPlaneEquation.Default();
+	
+	m_ScissorEnable.Default();	
+	m_ScissorBox.Default();
+	
+	m_ViewportBox.Default();		
+	m_ViewportDepthRange.Default();
+
+	m_ColorMaskSingle.Default();	
+	m_ColorMaskMultiple.Default();
+
+	m_BlendEnable.Default();
+	m_BlendFactor.Default();
+	m_BlendEquation.Default();
+	m_BlendColor.Default();
+	//m_BlendEnableSRGB.Default();	// this isn't useful until there is an FBO bound - in fact it will trip a GL error.
+
+	m_DepthTestEnable.Default();
+	m_DepthFunc.Default();
+	m_DepthMask.Default();
+	
+	m_StencilTestEnable.Default();
+	m_StencilFunc.Default();
+	m_StencilOp.Default();
+	m_StencilWriteMask.Default();
+
+	m_ClearColor.Default();
+	m_ClearDepth.Default();
+	m_ClearStencil.Default();	
+}
+
+void GLMContext::VerifyStates		( void )
+{
+	GLM_FUNC;
+	CheckCurrent();
+
+	// bare bones sanity check, head over to the debugger if our sense of the current context state is not correct
+	// we should only want to call this after a flush or the checks will flunk.
+	
+	if( m_AlphaTestEnable.Check() )			GLMStop();
+	if( m_AlphaTestFunc.Check() )			GLMStop();
+
+	if( m_AlphaToCoverageEnable.Check() )	GLMStop();	
+
+	if( m_CullFaceEnable.Check() )			GLMStop();
+	if( m_CullFrontFace.Check() )			GLMStop();
+	
+	if( m_PolygonMode.Check() )				GLMStop();
+	if( m_DepthBias.Check() )				GLMStop();
+
+	if( m_ClipPlaneEnable.Check() )			GLMStop();
+	//if( m_ClipPlaneEquation.Check() )		GLMStop();
+	
+	if( m_ScissorEnable.Check() )			GLMStop();	
+	if( m_ScissorBox.Check() )				GLMStop();
+	
+
+	if( m_ViewportBox.Check() )				GLMStop();		
+	if( m_ViewportDepthRange.Check() )		GLMStop();
+
+	if( m_ColorMaskSingle.Check() )			GLMStop();	
+	if( m_ColorMaskMultiple.Check() )		GLMStop();
+
+	if( m_BlendEnable.Check() )				GLMStop();
+	if( m_BlendFactor.Check() )				GLMStop();
+	if( m_BlendEquation.Check() )			GLMStop();
+	if( m_BlendColor.Check() )				GLMStop();
+	
+	// only do this as caps permit
+	if (m_caps.m_hasGammaWrites)
+	{
+		if( m_BlendEnableSRGB.Check() )		GLMStop();
+	}
+
+	if( m_DepthTestEnable.Check() )			GLMStop();
+	if( m_DepthFunc.Check() )				GLMStop();
+	if( m_DepthMask.Check() )				GLMStop();
+	
+	if( m_StencilTestEnable.Check() )		GLMStop();
+	if( m_StencilFunc.Check() )				GLMStop();
+	if( m_StencilOp.Check() )				GLMStop();
+	if( m_StencilWriteMask.Check() )		GLMStop();
+
+	if( m_ClearColor.Check() )				GLMStop();
+	if( m_ClearDepth.Check() )				GLMStop();
+	if( m_ClearStencil.Check() )			GLMStop();
+}
+
+static inline uint GetDataTypeSizeInBytes( GLenum dataType ) 
+{
+	switch ( dataType )
+	{
+	case GL_BYTE:
+	case GL_UNSIGNED_BYTE:
+		return 1;
+	case GL_SHORT:
+	case GL_UNSIGNED_SHORT:
+	case GL_HALF_FLOAT:
+		return 2;
+	case GL_INT:
+	case GL_FLOAT:
+		return 4;
+	default:
+		Assert( 0 );
+		break;
+	}
+	return 0;
+}
+
+#ifndef OSX
+
+void GLMContext::DrawRangeElementsNonInline( GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, uint baseVertex, CGLMBuffer *pIndexBuf )
+{
+#if GLMDEBUG
+	GLM_FUNC;
+#else
+	//tmZone( TELEMETRY_LEVEL0, TMZF_NONE, "%s %d-%d count:%d mode:%d type:%d", __FUNCTION__, start, end, count, mode, type );
+#endif
+
+	++m_nBatchCounter;
+
+	SetIndexBuffer( pIndexBuf );
+
+	void *indicesActual = (void*)indices;
+
+	if ( pIndexBuf->m_bPseudo )
+	{
+		// you have to pass actual address, not offset
+		indicesActual = (void*)( (int)indicesActual + (int)pIndexBuf->m_pPseudoBuf );
+	}
+	if (pIndexBuf->m_bUsingPersistentBuffer)
+	{
+		indicesActual = (void*)( (int)indicesActual + (int)pIndexBuf->m_nPersistentBufferStartOffset );
+	}
+
+#if GL_ENABLE_INDEX_VERIFICATION
+	// Obviously only for debugging.
+	if ( !pIndexBuf->IsSpanValid( (uint)indices, count * GetDataTypeSizeInBytes( type ) ) )
+	{
+		// The consumption range crosses more than one lock span, or the lock is trying to consume a bad IB range.
+		DXABSTRACT_BREAK_ON_ERROR();
+	}
+		
+	if ( ( type == GL_UNSIGNED_SHORT ) && ( pIndexBuf->m_bPseudo ) )
+	{
+		Assert( start <= end );
+		for ( int i = 0; i < count; i++)
+		{
+			uint n = ((const uint16*)indicesActual)[i];
+			if ( ( n < start ) || ( n > end ) )
+			{
+				DXABSTRACT_BREAK_ON_ERROR();
+			}
+		}
+
+		unsigned char *pVertexShaderAttribMap = m_pDevice->m_vertexShader->m_vtxAttribMap;
+		const int nMaxVertexAttributesToCheck = m_drawingProgram[ kGLMVertexProgram ]->m_maxVertexAttrs;
+
+		IDirect3DVertexDeclaration9	*pVertDecl = m_pDevice->m_pVertDecl;
+		const uint8	*pVertexAttribDescToStreamIndex = pVertDecl->m_VertexAttribDescToStreamIndex;
+
+		// FIXME: Having to duplicate all this flush logic is terrible here
+		for( int nMask = 1, nIndex = 0; nIndex < nMaxVertexAttributesToCheck; ++nIndex, nMask <<= 1 )
+		{
+			uint8 vertexShaderAttrib = pVertexShaderAttribMap[ nIndex ];
+
+			uint nDeclIndex = pVertexAttribDescToStreamIndex[vertexShaderAttrib];
+			if ( nDeclIndex == 0xFF )
+				continue;
+
+			D3DVERTEXELEMENT9_GL *pDeclElem = &pVertDecl->m_elements[nDeclIndex];
+
+			Assert( ( ( vertexShaderAttrib >> 4 ) == pDeclElem->m_dxdecl.Usage ) && ( ( vertexShaderAttrib & 0x0F ) == pDeclElem->m_dxdecl.UsageIndex) );
+
+			const uint nStreamIndex = pDeclElem->m_dxdecl.Stream;
+			const D3DStreamDesc *pStream = &m_pDevice->m_streams[ nStreamIndex ];
+
+			CGLMBuffer *pBuf = m_pDevice->m_vtx_buffers[ nStreamIndex ];
+			if ( pBuf == m_pDevice->m_pDummy_vtx_buffer )
+				continue;
+
+			Assert( pStream->m_vtxBuffer->m_vtxBuffer == pBuf );
+
+			int nBufOffset = pDeclElem->m_gldecl.m_offset + pStream->m_offset;
+			Assert( nBufOffset >= 0 );
+			Assert( nBufOffset < (int)pBuf->m_nSize );
+
+			uint nBufSize = pStream->m_vtxBuffer->m_vtxBuffer->m_nSize;
+			uint nDataTypeSize = GetDataTypeSizeInBytes( pDeclElem->m_gldecl.m_datatype );
+			uint nActualStride = pStream->m_stride ? pStream->m_stride : nDataTypeSize;
+			uint nStart = nBufOffset + ( start + baseVertex ) * nActualStride;
+			uint nEnd = nBufOffset + ( end + baseVertex ) * nActualStride + nDataTypeSize;
+
+			if ( nEnd > nBufSize )
+			{
+				DXABSTRACT_BREAK_ON_ERROR();
+			}
+
+			if ( !pStream->m_vtxBuffer->m_vtxBuffer->IsSpanValid( nStart, nEnd - nStart ) )
+			{
+				// The draw is trying to consume a range of the bound VB that hasn't been set to valid data!
+				DXABSTRACT_BREAK_ON_ERROR();
+			}
+		}
+	}
+#endif
+
+	Assert( m_drawingLang == kGLMGLSL );
+
+	if ( m_pBoundPair )
+	{
+		gGL->glDrawRangeElementsBaseVertex( mode, start, end, count, type, indicesActual, baseVertex );
+
+#if GLMDEBUG
+		if ( m_slowCheckEnable )
+		{
+			CheckNative();
+		}
+#endif
+	}
+}
+
+#else
+
+// support for OSX 10.6 (no support for glDrawRangeElementsBaseVertex)
+void GLMContext::DrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, CGLMBuffer *pIndexBuf)
+{
+	GLM_FUNC;
+
+	//	CheckCurrent();
+	++m_nBatchCounter;				// batch index increments unconditionally on entry
+
+	SetIndexBuffer( pIndexBuf );
+	void *indicesActual = (void*)indices;    
+	if ( pIndexBuf->m_bPseudo )
+	{
+		// you have to pass actual address, not offset
+		indicesActual = (void*)( (int)indicesActual + (int)pIndexBuf->m_pPseudoBuf );
+	} 
+	if (pIndexBuf->m_bUsingPersistentBuffer)
+	{
+		indicesActual = (void*)( (int)indicesActual + (int)pIndexBuf->m_nPersistentBufferStartOffset );
+	}
+
+#if GLMDEBUG
+	// init debug hook information
+	GLMDebugHookInfo info;
+	memset(&info, 0, sizeof(info));
+	info.m_caller = eDrawElements;
+
+	// relay parameters we're operating under
+	info.m_drawMode = mode;
+	info.m_drawStart = start;
+	info.m_drawEnd = end;
+	info.m_drawCount = count;
+	info.m_drawType = type;
+	info.m_drawIndices = indices;
+
+	do
+	{
+		// obey global options re pre-draw clear
+		if (m_autoClearColor || m_autoClearDepth || m_autoClearStencil)
+		{
+			GLMPRINTF(("-- DrawRangeElements auto clear"));
+			this->DebugClear();
+		}
+
+		// always sync with editable shader text prior to draw
+#if GLMDEBUG
+		// TODO - fixup OSX 10.6 m_boundProg not used in this version togl (m_pBoundPair)
+		//FIXME disengage this path if context is in GLSL mode..
+		// it will need fixes to get the shader pair re-linked etc if edits happen anyway.
+
+		if (m_boundProgram[kGLMVertexProgram])
+		{
+			m_boundProgram[kGLMVertexProgram]->SyncWithEditable();
+		}
+		else
+		{
+			AssertOnce(!"drawing with no vertex program bound");
+		}
+
+		if (m_boundProgram[kGLMFragmentProgram])
+		{
+			m_boundProgram[kGLMFragmentProgram]->SyncWithEditable();
+		}
+		else
+		{
+			AssertOnce(!"drawing with no fragment program bound");
+		}
+#endif
+
+		// do the drawing
+		if ( m_pBoundPair )
+		{
+			gGL->glDrawRangeElements(mode, start, end, count, type, indicesActual);
+			// GLMCheckError();
+
+			if (m_slowCheckEnable)
+			{
+				CheckNative();
+			}
+		}
+		this->DebugHook(&info);
+	} while (info.m_loop);
+#else
+	if ( m_pBoundPair )
+	{
+		gGL->glDrawRangeElements(mode, start, end, count, type, indicesActual);
+
+#if GLMDEBUG
+		if ( m_slowCheckEnable )
+		{
+			CheckNative();
+		}
+#endif
+	}
+#endif
+}
+
+#endif // !OSX
+
+#if 0
+// helper function to do enable or disable in one step
+void glSetEnable( GLenum which, bool enable )
+{
+	if (enable)
+		gGL->glEnable(which);
+	else
+		gGL->glDisable(which);
+}
+
+// helper function for int vs enum clarity
+void glGetEnumv( GLenum which, GLenum *dst )
+{
+	gGL->glGetIntegerv( which, (int*)dst );
+}
+#endif
+
+//===============================================================================
+
+
+GLMTester::GLMTester(GLMTestParams *params)
+{
+	m_params = *params;
+	
+	m_drawFBO = NULL;
+	m_drawColorTex = NULL;
+	m_drawDepthTex = NULL;
+}
+
+GLMTester::~GLMTester()
+{
+}
+
+void GLMTester::StdSetup( void )
+{
+	GLMContext *ctx = m_params.m_ctx;	
+
+	m_drawWidth = 1024;
+	m_drawHeight = 768;
+	
+	// make an FBO to draw into and activate it. no depth buffer yet	
+	m_drawFBO = ctx->NewFBO();					
+
+	// make color buffer texture
+
+	GLMTexLayoutKey colorkey;
+	//CGLMTex			*colortex;
+	memset( &colorkey, 0, sizeof(colorkey) );
+	
+	colorkey.m_texGLTarget = GL_TEXTURE_2D;
+	colorkey.m_xSize =	m_drawWidth;
+	colorkey.m_ySize =	m_drawHeight;
+	colorkey.m_zSize =	1;
+
+	colorkey.m_texFormat	= D3DFMT_A8R8G8B8;
+	colorkey.m_texFlags		= kGLMTexRenderable;
+
+	m_drawColorTex = ctx->NewTex( &colorkey );
+
+	// do not leave that texture bound on the TMU
+	ctx->BindTexToTMU(NULL, 0 );
+	
+	
+	// attach color to FBO
+	GLMFBOTexAttachParams	colorParams;
+	memset( &colorParams, 0, sizeof(colorParams) );
+	
+	colorParams.m_tex	= m_drawColorTex;
+	colorParams.m_face	= 0;
+	colorParams.m_mip	= 0;
+	colorParams.m_zslice= 0;	// for clarity..
+	
+	m_drawFBO->TexAttach( &colorParams, kAttColor0 );
+	
+	// check it.
+	bool ready = m_drawFBO->IsReady();
+	InternalError( !ready, "drawing FBO no go");
+
+	// bind it
+	ctx->BindFBOToCtx( m_drawFBO, GL_FRAMEBUFFER_EXT );
+	
+	gGL->glViewport(0, 0, (GLsizei) m_drawWidth, (GLsizei) m_drawHeight );
+	CheckGLError("stdsetup viewport");
+	
+	gGL->glScissor( 0,0,  (GLsizei) m_drawWidth, (GLsizei) m_drawHeight );
+	CheckGLError("stdsetup scissor");
+
+	gGL->glOrtho( -1,1, -1,1, -1,1 );
+	CheckGLError("stdsetup ortho");
+	
+	// activate debug font
+	ctx->GenDebugFontTex();
+}
+
+void GLMTester::StdCleanup( void )
+{
+	GLMContext *ctx = m_params.m_ctx;	
+
+	// unbind
+	ctx->BindFBOToCtx( NULL, GL_FRAMEBUFFER_EXT );
+	
+	// del FBO
+	if (m_drawFBO)
+	{
+		ctx->DelFBO( m_drawFBO );
+		m_drawFBO = NULL;
+	}
+	
+	// del tex
+	if (m_drawColorTex)
+	{
+		ctx->DelTex( m_drawColorTex );
+		m_drawColorTex = NULL;
+	}
+
+	if (m_drawDepthTex)
+	{
+		ctx->DelTex( m_drawDepthTex );
+		m_drawDepthTex = NULL;
+	}
+}
+
+
+void GLMTester::Clear( void )
+{
+	GLMContext *ctx = m_params.m_ctx;	
+	ctx->MakeCurrent();
+	
+	gGL->glViewport(0, 0, (GLsizei) m_drawWidth, (GLsizei) m_drawHeight );
+	gGL->glScissor( 0,0,  (GLsizei) m_drawWidth, (GLsizei) m_drawHeight );
+	gGL->glOrtho( -1,1, -1,1, -1,1 );
+	CheckGLError("clearing viewport");
+
+	// clear to black
+	gGL->glClearColor(0.0f, 0.0f, 0.0, 1.0f);
+	CheckGLError("clearing color");
+
+	gGL->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+	CheckGLError("clearing");
+
+	//glFinish();
+	//CheckGLError("clear finish");
+}
+
+void GLMTester::Present( int seed )
+{
+	GLMContext *ctx = m_params.m_ctx;	
+	ctx->Present( m_drawColorTex );
+}
+
+void GLMTester::CheckGLError( const char *comment )
+{
+return;
+	char errbuf[1024];
+
+	//borrowed from GLMCheckError.. slightly different
+	
+	if (!comment)
+	{
+		comment = "";
+	}
+	
+	GLenum errorcode = (GLenum)gGL->glGetError();
+	GLenum errorcode2 = 0;
+	if ( errorcode != GL_NO_ERROR )
+	{
+		const char	*decodedStr = GLMDecode( eGL_ERROR, errorcode );
+		const char	*decodedStr2 = "";
+				
+		if ( errorcode == GL_INVALID_FRAMEBUFFER_OPERATION_EXT )
+		{
+			// dig up the more detailed FBO status
+			errorcode2 = gGL->glCheckFramebufferStatusEXT( GL_FRAMEBUFFER_EXT );
+			
+			decodedStr2 = GLMDecode( eGL_ERROR, errorcode2 );
+
+			sprintf( errbuf, "\n%s - GL Error %08x/%08x = '%s / %s'\n", comment, errorcode, errorcode2, decodedStr, decodedStr2 );
+		}
+		else
+		{
+			sprintf( errbuf, "\n%s - GL Error %08x = '%s'\n", comment, errorcode, decodedStr );
+		}
+
+		if ( m_params.m_glErrToConsole )
+		{
+			printf("%s", errbuf );
+		}
+		
+		if ( m_params.m_glErrToDebugger )
+		{
+			DebuggerBreak();
+		}
+	}
+}
+
+void GLMTester::InternalError( int errcode, char *comment )
+{
+	if (errcode)
+	{
+		if (m_params.m_intlErrToConsole)
+		{	
+			printf("%s - error %d\n", comment, errcode );
+		}
+
+		if (m_params.m_intlErrToDebugger)
+		{
+			DebuggerBreak();
+		}
+	}
+}
+
+
+void GLMTester::RunTests( void )
+{
+	int *testList = m_params.m_testList;
+	
+	while( (*testList >=0) && (*testList < 20) )
+	{
+		RunOneTest( *testList++ );
+	}
+}
+
+void GLMTester::RunOneTest( int testindex )
+{
+	// this might be better with 'ptmf' style
+	switch(testindex)
+	{
+		case 0:	Test0();	break;
+		case 1:	Test1();	break;
+		case 2:	Test2();	break;
+		case 3:	Test3();	break;
+
+		default:
+			DebuggerBreak();	// unrecognized
+	}
+}
+
+// #####################################################################################################################
+
+// some fixed lists which may be useful to all tests
+
+D3DFORMAT g_drawTexFormatsGLMT[] =		// -1 terminated
+{
+	D3DFMT_A8R8G8B8,
+	D3DFMT_A4R4G4B4,
+	D3DFMT_X8R8G8B8,
+	D3DFMT_X1R5G5B5,
+	D3DFMT_A1R5G5B5,
+	D3DFMT_L8,
+	D3DFMT_A8L8,	
+	D3DFMT_R8G8B8,	
+	D3DFMT_A8,
+	D3DFMT_R5G6B5,
+	D3DFMT_DXT1,
+	D3DFMT_DXT3,
+	D3DFMT_DXT5,
+	D3DFMT_A32B32G32R32F,
+	D3DFMT_A16B16G16R16,
+
+	(D3DFORMAT)-1
+};
+
+D3DFORMAT g_fboColorTexFormatsGLMT[] =		// -1 terminated
+{
+	D3DFMT_A8R8G8B8,
+	//D3DFMT_A4R4G4B4,			//unsupported
+	D3DFMT_X8R8G8B8,
+	D3DFMT_X1R5G5B5,
+	//D3DFMT_A1R5G5B5,			//unsupported
+	D3DFMT_A16B16G16R16F,
+	D3DFMT_A32B32G32R32F,
+	D3DFMT_R5G6B5,
+
+	(D3DFORMAT)-1			
+};
+
+D3DFORMAT g_fboDepthTexFormatsGLMT[] =		// -1 terminated, but note 0 for "no depth" mode
+{
+	(D3DFORMAT)0,
+	D3DFMT_D16,
+	D3DFMT_D24X8,
+	D3DFMT_D24S8,
+	
+	(D3DFORMAT)-1	
+};
+
+
+// #####################################################################################################################
+
+void GLMTester::Test0( void )
+{
+	// make and delete a bunch of textures.
+	// lock and unlock them.
+	// use various combos of - 
+
+	//	√texel format
+	//	√2D | 3D | cube map
+	//	√mipped / not
+	//	√POT / NPOT
+	//	large / small / square / rect
+	//	square / rect
+	
+	GLMContext *ctx = m_params.m_ctx;	
+	ctx->MakeCurrent();
+	
+	CUtlVector< CGLMTex* >	testTextures;		// will hold all the built textures
+	
+	// test stage loop
+	// 0 is creation
+	// 1 is lock/unlock
+	// 2 is deletion
+	
+	for( int teststage = 0; teststage < 3; teststage++)
+	{
+		int innerindex = 0;	// increment at stage switch
+		// format loop
+		for( D3DFORMAT *fmtPtr = g_drawTexFormatsGLMT; *fmtPtr != ((D3DFORMAT)-1); fmtPtr++ )
+		{
+			// form loop
+			GLenum	forms[] = { GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP, (GLenum)-1 };
+
+			for( GLenum *formPtr = forms; *formPtr != ((GLenum)-1); formPtr++ )
+			{
+				// mip loop
+				for( int mipped = 0; mipped < 2; mipped++ )
+				{
+					// large / square / pot loop
+					// &4 == large		&2 == square		&1 == POT
+					// NOTE you *have to be square* for cube maps.
+					
+					for( int aspect = 0; aspect < 8; aspect++ )
+					{
+						switch( teststage )
+						{
+							case 0:
+							{
+								GLMTexLayoutKey key;
+								memset( &key, 0, sizeof(key) );
+								
+								key.m_texGLTarget	= *formPtr;
+								key.m_texFormat		= *fmtPtr;
+								if (mipped)
+									key.m_texFlags |= kGLMTexMipped;
+								
+								// assume big, square, POT, and 3D, then adjust as needed
+								key.m_xSize = key.m_ySize = key.m_zSize = 256;
+								
+								if ( !(aspect&4) )		// big or little ?
+								{
+									// little
+									key.m_xSize >>= 2;
+									key.m_ySize >>= 2;
+									key.m_zSize >>= 2;
+								}
+								
+								if ( key.m_texGLTarget != GL_TEXTURE_CUBE_MAP )
+								{
+									if ( !(aspect & 2) )	// square or rect?
+									{
+										// rect
+										key.m_ySize >>= 1;
+										key.m_zSize >>= 2;
+									}
+								}
+								
+								if ( !(aspect&1) )		// POT or NPOT?
+								{
+									// NPOT
+									key.m_xSize += 56;
+									key.m_ySize += 56;
+									key.m_zSize += 56;
+								}
+								
+								// 2D, 3D, cube map ?
+								if (key.m_texGLTarget!=GL_TEXTURE_3D)
+								{
+									// 2D or cube map: flatten Z extent to one texel
+									key.m_zSize = 1;
+								}
+								else
+								{
+									// 3D: knock down Z quite a bit so our test case does not run out of RAM
+									key.m_zSize >>= 3;
+									if (!key.m_zSize)
+									{
+										key.m_zSize = 1;
+									}
+								}
+
+								CGLMTex *newtex = ctx->NewTex( &key );
+								CheckGLError( "tex create test");
+								InternalError( newtex==NULL, "tex create test" );
+								
+								testTextures.AddToTail( newtex );
+								printf("\n[%5d] created tex %s",innerindex,newtex->m_layout->m_layoutSummary );
+							}
+							break;
+
+							case 1:
+							{
+								CGLMTex	*ptex = testTextures[innerindex];
+
+								for( int face=0; face <ptex->m_layout->m_faceCount; face++)
+								{
+									for( int mip=0; mip <ptex->m_layout->m_mipCount; mip++)
+									{
+										GLMTexLockParams lockreq;
+										
+										lockreq.m_tex = ptex;
+										lockreq.m_face = face;
+										lockreq.m_mip = mip;
+
+										GLMTexLayoutSlice *slice = &ptex->m_layout->m_slices[ ptex->CalcSliceIndex( face, mip ) ];
+										
+										lockreq.m_region.xmin = lockreq.m_region.ymin = lockreq.m_region.zmin = 0;
+										lockreq.m_region.xmax = slice->m_xSize;
+										lockreq.m_region.ymax = slice->m_ySize;
+										lockreq.m_region.zmax = slice->m_zSize;
+										
+										char	*lockAddress;
+										int		yStride;
+										int		zStride;
+										
+										ptex->Lock( &lockreq, &lockAddress, &yStride, &zStride );
+										CheckGLError( "tex lock test");
+										InternalError( lockAddress==NULL, "null lock address");
+
+										// write some texels of this flavor:
+										//	red 75%  green 40%  blue 15%  alpha 80%
+										
+										GLMGenTexelParams gtp;
+
+										gtp.m_format			=	ptex->m_layout->m_format->m_d3dFormat;
+										gtp.m_dest				=	lockAddress;
+										gtp.m_chunkCount		=	(slice->m_xSize * slice->m_ySize * slice->m_zSize) / (ptex->m_layout->m_format->m_chunkSize * ptex->m_layout->m_format->m_chunkSize);
+										gtp.m_byteCountLimit	=	slice->m_storageSize;
+										gtp.r = 0.75;
+										gtp.g = 0.40;
+										gtp.b = 0.15;
+										gtp.a = 0.80;
+
+										GLMGenTexels( &gtp );
+										
+										InternalError( gtp.m_bytesWritten != gtp.m_byteCountLimit, "byte count mismatch from GLMGenTexels" );
+									}
+								}
+
+								for( int face=0; face <ptex->m_layout->m_faceCount; face++)
+								{
+									for( int mip=0; mip <ptex->m_layout->m_mipCount; mip++)
+									{
+										GLMTexLockParams unlockreq;
+										
+										unlockreq.m_tex = ptex;
+										unlockreq.m_face = face;
+										unlockreq.m_mip = mip;
+
+										// region need not matter for unlocks
+										unlockreq.m_region.xmin = unlockreq.m_region.ymin = unlockreq.m_region.zmin = 0;
+										unlockreq.m_region.xmax = unlockreq.m_region.ymax = unlockreq.m_region.zmax = 0;
+
+										//char	*lockAddress;
+										//int		yStride;
+										//int		zStride;
+										
+										ptex->Unlock( &unlockreq );
+
+										CheckGLError( "tex unlock test");
+									}
+								}
+								printf("\n[%5d] locked/wrote/unlocked tex %s",innerindex, ptex->m_layout->m_layoutSummary );
+							}
+							break;
+
+							case 2:
+							{
+								CGLMTex	*dtex = testTextures[innerindex];
+
+								printf("\n[%5d] deleting tex %s",innerindex, dtex->m_layout->m_layoutSummary );								
+								ctx->DelTex( dtex );
+								CheckGLError( "tex delete test");
+							}
+							break;
+						}	// end stage switch
+						innerindex++;
+					}	// end aspect loop
+				}	// end mip loop
+			}	// end form loop
+		}	// end format loop
+	}	// end stage loop
+}
+
+// #####################################################################################################################
+void GLMTester::Test1( void )
+{
+	// FBO exercises
+	GLMContext *ctx = m_params.m_ctx;	
+	ctx->MakeCurrent();
+
+	// FBO color format loop
+	for( D3DFORMAT *colorFmtPtr = g_fboColorTexFormatsGLMT; *colorFmtPtr != ((D3DFORMAT)-1); colorFmtPtr++ )
+	{
+		// FBO depth format loop
+		for( D3DFORMAT *depthFmtPtr = g_fboDepthTexFormatsGLMT; *depthFmtPtr != ((D3DFORMAT)-1); depthFmtPtr++ )
+		{
+			// mip loop
+			for( int mipped = 0; mipped < 2; mipped++ )
+			{
+				GLenum	forms[] = { GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_CUBE_MAP, (GLenum)-1 };
+
+				// form loop
+				for( GLenum *formPtr = forms; *formPtr != ((GLenum)-1); formPtr++ )
+				{
+					//=============================================== make an FBO
+					CGLMFBO *fbo = ctx->NewFBO();					
+
+					//=============================================== make a color texture
+					GLMTexLayoutKey colorkey;
+					memset( &colorkey, 0, sizeof(colorkey) );
+					
+					switch(*formPtr)
+					{
+						case GL_TEXTURE_2D:
+							colorkey.m_texGLTarget = GL_TEXTURE_2D;
+							colorkey.m_xSize =	800;
+							colorkey.m_ySize =	600;
+							colorkey.m_zSize =	1;
+						break;
+						
+						case GL_TEXTURE_3D:
+							colorkey.m_texGLTarget = GL_TEXTURE_3D;
+							colorkey.m_xSize =	800;
+							colorkey.m_ySize =	600;
+							colorkey.m_zSize =	32;
+						break;
+						
+						case GL_TEXTURE_CUBE_MAP:
+							colorkey.m_texGLTarget = GL_TEXTURE_CUBE_MAP;
+							colorkey.m_xSize =	800;
+							colorkey.m_ySize =	800;	// heh, cube maps have to have square sides...
+							colorkey.m_zSize =	1;
+						break;
+					}
+
+					colorkey.m_texFormat	= *colorFmtPtr;
+					colorkey.m_texFlags		= kGLMTexRenderable;
+					// decide if we want mips
+					if (mipped)
+					{
+						colorkey.m_texFlags		|= kGLMTexMipped;
+					}
+
+					CGLMTex	*colorTex = ctx->NewTex( &colorkey );
+					// Note that GLM will notice the renderable flag, and force texels to be written
+					// so the FBO will be complete
+
+					//=============================================== attach color
+					GLMFBOTexAttachParams	colorParams;
+					memset( &colorParams, 0, sizeof(colorParams) );
+					
+					colorParams.m_tex	= colorTex;
+					colorParams.m_face	= (colorkey.m_texGLTarget == GL_TEXTURE_CUBE_MAP) ? 2 : 0;	// just steer to an alternate face as a test
+
+					colorParams.m_mip	= (colorkey.m_texFlags & kGLMTexMipped) ? 2 : 0;	// pick non-base mip slice
+
+					colorParams.m_zslice= (colorkey.m_texGLTarget == GL_TEXTURE_3D) ? 3 : 0;		// just steer to an alternate slice as a test;
+					
+					fbo->TexAttach( &colorParams, kAttColor0 );
+					
+
+					//=============================================== optional depth tex
+					CGLMTex *depthTex = NULL;
+					
+					if (*depthFmtPtr > 0 )
+					{
+						GLMTexLayoutKey depthkey;
+						memset( &depthkey, 0, sizeof(depthkey) );
+						
+						depthkey.m_texGLTarget		= GL_TEXTURE_2D;
+						depthkey.m_xSize			= colorkey.m_xSize >> colorParams.m_mip;	// scale depth tex to match color tex
+						depthkey.m_ySize			= colorkey.m_ySize >> colorParams.m_mip;
+						depthkey.m_zSize			= 1;
+
+						depthkey.m_texFormat		= *depthFmtPtr;
+						depthkey.m_texFlags			= kGLMTexRenderable | kGLMTexIsDepth;		// no mips.
+						if (depthkey.m_texFormat==D3DFMT_D24S8)
+						{
+							depthkey.m_texFlags |= kGLMTexIsStencil;
+						}
+
+						depthTex = ctx->NewTex( &depthkey );
+
+
+						//=============================================== attach depth
+						GLMFBOTexAttachParams	depthParams;
+						memset( &depthParams, 0, sizeof(depthParams) );
+						
+						depthParams.m_tex	= depthTex;
+						depthParams.m_face	= 0;
+						depthParams.m_mip	= 0;
+						depthParams.m_zslice= 0;
+						
+						EGLMFBOAttachment depthAttachIndex = (depthkey.m_texFlags & kGLMTexIsStencil) ? kAttDepthStencil : kAttDepth;
+						fbo->TexAttach( &depthParams, depthAttachIndex );
+					}
+
+					printf("\n FBO:\n   color tex %s\n   depth tex %s",
+						colorTex->m_layout->m_layoutSummary,
+						depthTex ? depthTex->m_layout->m_layoutSummary : "none"
+						);
+					
+					// see if FBO is happy
+					bool ready = fbo->IsReady();
+
+					printf("\n   -> %s\n", ready ? "pass" : "fail" );
+					
+					// unbind
+					ctx->BindFBOToCtx( NULL, GL_FRAMEBUFFER_EXT );
+					
+					// del FBO
+					ctx->DelFBO(fbo);
+					
+					// del texes
+					ctx->DelTex( colorTex );
+					if (depthTex) ctx->DelTex( depthTex );
+				} // end form loop
+			} // end mip loop
+		} // end depth loop
+	} // end color loop
+}
+
+// #####################################################################################################################
+
+static int selftest2_seed = 0;	// inc this every run to force main thread to teardown/reset display view
+void GLMTester::Test2( void )
+{
+	GLMContext *ctx = m_params.m_ctx;	
+	ctx->MakeCurrent();
+
+	StdSetup();	// default test case drawing setup
+
+	// draw stuff (loop...)
+	for( int i=0; i<m_params.m_frameCount; i++)
+	{
+		// ramping shades of blue...
+		GLfloat clear_color[4] = { 0.50f, 0.05f, ((float)(i%100)) / 100.0f, 1.0f };		
+		gGL->glClearColor(clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
+		CheckGLError("test2 clear color");
+
+		gGL->glClear(GL_COLOR_BUFFER_BIT+GL_DEPTH_BUFFER_BIT+GL_STENCIL_BUFFER_BIT);
+		CheckGLError("test2 clearing");
+
+		// try out debug text
+		for( int j=0; j<16; j++)
+		{
+			char text[256];
+			sprintf(text, "The quick brown fox jumped over the lazy dog %d times", i );
+			
+			float theta = ( (i*0.10f) + (j * 6.28f) ) / 16.0f;
+			
+			float posx = cos(theta) * 0.5;
+			float posy = sin(theta) * 0.5;
+			
+			float charwidth = 6.0 * (2.0 / 1024.0);
+			float charheight = 11.0 * (2.0 / 768.0);
+			
+			ctx->DrawDebugText( posx, posy, 0.0f, charwidth, charheight, text );
+		}
+		gGL->glFinish();
+		CheckGLError("test2 finish");
+
+		Present( selftest2_seed );
+	}
+	
+	StdCleanup();
+	
+	selftest2_seed++;
+}
+
+// #####################################################################################################################
+
+static char g_testVertexProgram01 [] = 
+{
+	"!!ARBvp1.0  \n"
+	"TEMP vertexClip;  \n"
+	"DP4 vertexClip.x, state.matrix.mvp.row[0], vertex.position;  \n"
+	"DP4 vertexClip.y, state.matrix.mvp.row[1], vertex.position;  \n"
+	"DP4 vertexClip.z, state.matrix.mvp.row[2], vertex.position;  \n"
+	"DP4 vertexClip.w, state.matrix.mvp.row[3], vertex.position;  \n"
+	"ADD vertexClip.y, vertexClip.x, vertexClip.y;  \n"
+	"MOV result.position, vertexClip;  \n"
+	"MOV result.color, vertex.color;  \n"
+	"MOV result.texcoord[0], vertex.texcoord;  \n"
+	"END  \n"
+};
+
+static char g_testFragmentProgram01 [] =
+{
+	"!!ARBfp1.0  \n"
+	"TEMP color;  \n"
+	"MUL color, fragment.texcoord[0].y, 2.0;  \n"
+	"ADD color, 1.0, -color;  \n"
+	"ABS color, color;  \n"
+	"ADD result.color, 1.0, -color;  \n"
+	"MOV result.color.a, 1.0;  \n"
+	"END  \n"
+};
+
+
+// generic attrib versions..
+
+static char g_testVertexProgram01_GA [] = 
+{
+	"!!ARBvp1.0  \n"
+	"TEMP vertexClip;  \n"
+	"DP4 vertexClip.x, state.matrix.mvp.row[0], vertex.attrib[0];  \n"
+	"DP4 vertexClip.y, state.matrix.mvp.row[1], vertex.attrib[0];  \n"
+	"DP4 vertexClip.z, state.matrix.mvp.row[2], vertex.attrib[0];  \n"
+	"DP4 vertexClip.w, state.matrix.mvp.row[3], vertex.attrib[0];  \n"
+	"ADD vertexClip.y, vertexClip.x, vertexClip.y;  \n"
+	"MOV result.position, vertexClip;  \n"
+	"MOV result.color, vertex.attrib[3];  \n"
+	"MOV result.texcoord[0], vertex.attrib[8];  \n"
+	"END  \n"
+};
+
+static char g_testFragmentProgram01_GA [] =
+{
+	"!!ARBfp1.0  \n"
+	"TEMP color;  \n"
+	"TEX color, fragment.texcoord[0], texture[0], 2D;"
+	//"MUL color, fragment.texcoord[0].y, 2.0;  \n"
+	//"ADD color, 1.0, -color;  \n"
+	//"ABS color, color;  \n"
+	//"ADD result.color, 1.0, -color;  \n"
+	//"MOV result.color.a, 1.0;  \n"
+	"MOV result.color, color;  \n"
+	"END  \n"
+};
+
+
+void GLMTester::Test3( void )
+{
+	/**************************
+	XXXXXXXXXXXXXXXXXXXXXX	stale test code until we revise the program interface
+		
+	GLMContext *ctx = m_params.m_ctx;	
+	ctx->MakeCurrent();
+
+	StdSetup();	// default test case drawing setup
+
+	// make vertex&pixel shader
+	CGLMProgram *vprog = ctx->NewProgram( kGLMVertexProgram, g_testVertexProgram01_GA );
+	ctx->BindProgramToCtx( kGLMVertexProgram, vprog );
+	
+	CGLMProgram *fprog = ctx->NewProgram( kGLMFragmentProgram, g_testFragmentProgram01_GA );
+	ctx->BindProgramToCtx( kGLMFragmentProgram, fprog );
+	
+	// draw stuff (loop...)
+	for( int i=0; i<m_params.m_frameCount; i++)
+	{
+		// ramping shades of blue...
+		GLfloat clear_color[4] = { 0.50f, 0.05f, ((float)(i%100)) / 100.0, 1.0f };		
+		glClearColor(clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
+		CheckGLError("test3 clear color");
+
+		glClear(GL_COLOR_BUFFER_BIT+GL_DEPTH_BUFFER_BIT+GL_STENCIL_BUFFER_BIT);
+		CheckGLError("test3 clearing");
+
+		// try out debug text
+		for( int j=0; j<16; j++)
+		{
+			char text[256];
+			sprintf(text, "This here is running through a trivial vertex shader");
+			
+			float theta = ( (i*0.10f) + (j * 6.28f) ) / 16.0f;
+			
+			float posx = cos(theta) * 0.5;
+			float posy = sin(theta) * 0.5;
+			
+			float charwidth = 6.0 * (2.0 / 800.0);
+			float charheight = 11.0 * (2.0 / 640.0);
+			
+			ctx->DrawDebugText( posx, posy, 0.0f, charwidth, charheight, text );
+		}
+		glFinish();
+		CheckGLError("test3 finish");
+
+		Present( 3333 );
+	}
+	
+	StdCleanup();
+	*****************************/
+}
+
+#if GLMDEBUG
+void GLMTriggerDebuggerBreak()
+{
+	// we call an obscure GL function which we know has been breakpointed in the OGLP function list
+	static signed short nada[] = { -1,-1,-1,-1 };
+	gGL->glColor4sv( nada );
+}
+#endif