Fix some accidental new-line stomping.

12 files changed, 3582 insertions, 3582 deletions

diff --git a/mp/src/public/togl/osx/cglmbuffer.h b/mp/src/public/togl/osx/cglmbuffer.h
index 24a0b0fa..0b161000 100644
--- a/mp/src/public/togl/osx/cglmbuffer.h
+++ b/mp/src/public/togl/osx/cglmbuffer.h
@@ -1,99 +1,99 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-//

-// cglmprogram.h

-//	GLMgr buffers (index / vertex)

-//	... maybe add PBO later as well

-//===============================================================================

-

-#ifndef CGLMBUFFER_H

-#define	CGLMBUFFER_H

-

-#pragma once

-

-// ext links

-

-// http://www.opengl.org/registry/specs/ARB/vertex_buffer_object.txt

-

-//===============================================================================

-

-// tokens not in the SDK headers

-

-//#ifndef	GL_DEPTH_STENCIL_ATTACHMENT_EXT

-//	#define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9

-//#endif

-

-//===============================================================================

-

-// forward declarations

-

-class GLMContext;

-

-enum EGLMBufferType

-{

-	kGLMVertexBuffer,

-	kGLMIndexBuffer,

-	kGLMUniformBuffer,	// for bindable uniform

-	kGLMPixelBuffer,	// for PBO

-	

-	kGLMNumBufferTypes

-};

-

-	// pass this in "options" to constructor to make a dynamic buffer

-#define	GLMBufferOptionDynamic	0x00000001

-

-struct GLMBuffLockParams

-{

-	uint	m_offset;

-	uint	m_size;

-	bool	m_nonblocking;

-	bool	m_discard;

-};

-

-class CGLMBuffer

-{

-

-public:

-	void	Lock( GLMBuffLockParams *params, char **addressOut );

-	void	Unlock( void );

-

-//protected:

-	friend class GLMContext;			// only GLMContext can make CGLMBuffer objects

-	friend class GLMTester;	

-	friend class IDirect3D9;

-	friend class IDirect3DDevice9;

-		

-	CGLMBuffer					( GLMContext *ctx, EGLMBufferType type, uint size, uint options );

-	~CGLMBuffer					( );	

-	

-	void	SetModes			( bool asyncMap, bool explicitFlush, bool force = false );

-	void	FlushRange			( uint offset, uint size );

-	

-	GLMContext				*m_ctx;					// link back to parent context

-	EGLMBufferType			m_type;

-	uint					m_size;

-	GLenum					m_buffGLTarget;			// GL_ARRAY_BUFFER_ARB / GL_ELEMENT_BUFFER_ARB	

-	GLuint					m_name;					// name of this program in the context	

-	uint					m_revision;				// bump anytime the size changes or buffer is orphaned

-	bool					m_enableAsyncMap;		// mirror of the buffer state

-	bool					m_enableExplicitFlush;	// mirror of the buffer state

-

-	bool					m_bound;				// true if bound to context		

-	bool					m_mapped;				// is it currently mapped

-	uint					m_dirtyMinOffset;		// when equal, range is empty

-	uint					m_dirtyMaxOffset;

-	

-	float					*m_lastMappedAddress;

-	

-	// --------------------- pseudo-VBO support below here (explicitly for dynamic index buffers)

-	bool					m_pseudo;				// true if the m_name is 0, and the backing is plain RAM

-	

-	// in pseudo mode, there is just one RAM buffer that acts as the backing.

-	// expectation is that this mode would only be used for dynamic indices.

-	// since indices have to be consumed (copied to command stream) prior to return from a drawing call,

-	// there's no need to do any fencing or multibuffering.  orphaning in particular becomes a no-op.

-	

-	char					*m_pseudoBuf;			// storage for pseudo buffer

-};	

-

-

+//
+// cglmprogram.h
+//	GLMgr buffers (index / vertex)
+//	... maybe add PBO later as well
+//===============================================================================
+
+#ifndef CGLMBUFFER_H
+#define	CGLMBUFFER_H
+
+#pragma once
+
+// ext links
+
+// http://www.opengl.org/registry/specs/ARB/vertex_buffer_object.txt
+
+//===============================================================================
+
+// tokens not in the SDK headers
+
+//#ifndef	GL_DEPTH_STENCIL_ATTACHMENT_EXT
+//	#define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9
+//#endif
+
+//===============================================================================
+
+// forward declarations
+
+class GLMContext;
+
+enum EGLMBufferType
+{
+	kGLMVertexBuffer,
+	kGLMIndexBuffer,
+	kGLMUniformBuffer,	// for bindable uniform
+	kGLMPixelBuffer,	// for PBO
+	
+	kGLMNumBufferTypes
+};
+
+	// pass this in "options" to constructor to make a dynamic buffer
+#define	GLMBufferOptionDynamic	0x00000001
+
+struct GLMBuffLockParams
+{
+	uint	m_offset;
+	uint	m_size;
+	bool	m_nonblocking;
+	bool	m_discard;
+};
+
+class CGLMBuffer
+{
+
+public:
+	void	Lock( GLMBuffLockParams *params, char **addressOut );
+	void	Unlock( void );
+
+//protected:
+	friend class GLMContext;			// only GLMContext can make CGLMBuffer objects
+	friend class GLMTester;	
+	friend class IDirect3D9;
+	friend class IDirect3DDevice9;
+		
+	CGLMBuffer					( GLMContext *ctx, EGLMBufferType type, uint size, uint options );
+	~CGLMBuffer					( );	
+	
+	void	SetModes			( bool asyncMap, bool explicitFlush, bool force = false );
+	void	FlushRange			( uint offset, uint size );
+	
+	GLMContext				*m_ctx;					// link back to parent context
+	EGLMBufferType			m_type;
+	uint					m_size;
+	GLenum					m_buffGLTarget;			// GL_ARRAY_BUFFER_ARB / GL_ELEMENT_BUFFER_ARB	
+	GLuint					m_name;					// name of this program in the context	
+	uint					m_revision;				// bump anytime the size changes or buffer is orphaned
+	bool					m_enableAsyncMap;		// mirror of the buffer state
+	bool					m_enableExplicitFlush;	// mirror of the buffer state
+
+	bool					m_bound;				// true if bound to context		
+	bool					m_mapped;				// is it currently mapped
+	uint					m_dirtyMinOffset;		// when equal, range is empty
+	uint					m_dirtyMaxOffset;
+	
+	float					*m_lastMappedAddress;
+	
+	// --------------------- pseudo-VBO support below here (explicitly for dynamic index buffers)
+	bool					m_pseudo;				// true if the m_name is 0, and the backing is plain RAM
+	
+	// in pseudo mode, there is just one RAM buffer that acts as the backing.
+	// expectation is that this mode would only be used for dynamic indices.
+	// since indices have to be consumed (copied to command stream) prior to return from a drawing call,
+	// there's no need to do any fencing or multibuffering.  orphaning in particular becomes a no-op.
+	
+	char					*m_pseudoBuf;			// storage for pseudo buffer
+};	
+
+
 #endif
\ No newline at end of file
diff --git a/mp/src/public/togl/osx/cglmfbo.h b/mp/src/public/togl/osx/cglmfbo.h
index c94bac70..ccf3e970 100644
--- a/mp/src/public/togl/osx/cglmfbo.h
+++ b/mp/src/public/togl/osx/cglmfbo.h
@@ -1,91 +1,91 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-//

-// cglmfbo.h

-//	GLMgr FBO's (render targets)

-//

-//===============================================================================

-

-#ifndef CGLMFBO_H

-#define	CGLMFBO_H

-

-#pragma once

-

-#include "togl/rendermechanism.h"

-

-// good FBO references / recaps

-// http://www.songho.ca/opengl/gl_fbo.html

-// http://www.gamedev.net/reference/articles/article2331.asp

-

-// ext links

-

-// http://www.opengl.org/registry/specs/EXT/framebuffer_object.txt

-// http://www.opengl.org/registry/specs/EXT/framebuffer_multisample.txt

-

-//===============================================================================

-

-// tokens not in the SDK headers

-

-#ifndef	GL_DEPTH_STENCIL_ATTACHMENT_EXT

-	#define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9

-#endif

-

-//===============================================================================

-

-// forward declarations

-

-class	GLMContext;

-

-// implicitly 16 maximum color attachments possible

-enum EGLMFBOAttachment {

-	kAttColor0,		kAttColor1,		kAttColor2,		kAttColor3,

-	kAttColor4,		kAttColor5,		kAttColor6,		kAttColor7,

-	kAttColor8,		kAttColor9,		kAttColor10,	kAttColor11,

-	kAttColor12,	kAttColor13,	kAttColor14,	kAttColor15,

-	kAttDepth,		kAttStencil,	kAttDepthStencil,

-	kAttCount

-};

-

-struct GLMFBOTexAttachParams

-{	

-	CGLMTex				*m_tex;

-	int					m_face;		// keep zero if not cube map

-	int					m_mip;		// keep zero if notmip mapped

-	int					m_zslice;	// keep zero if not a 3D tex

-};

-

-class CGLMFBO

-{

-

-public:

-

-protected:

-	friend class GLMContext;			// only GLMContext can make CGLMFBO objects

-	friend class GLMTester;

-	friend class CGLMTex;

-	

-	friend class IDirect3D9;

-	friend class IDirect3DDevice9;

-		

-			CGLMFBO( GLMContext *ctx );

-			~CGLMFBO( );	

-

-	void	TexAttach( GLMFBOTexAttachParams *params, EGLMFBOAttachment attachIndex, GLenum fboBindPoint = GL_FRAMEBUFFER_EXT );

-	void	TexDetach( EGLMFBOAttachment attachIndex, GLenum fboBindPoint = GL_FRAMEBUFFER_EXT );

-		// you can also pass GL_READ_FRAMEBUFFER_EXT or GL_DRAW_FRAMEBUFFER_EXT to selectively bind the receiving FBO to one or the other.

-

-	void	TexScrub( CGLMTex *tex );

-		// search and destroy any attachment for the named texture

-	

-	bool	IsReady( void );				// aka FBO completeness check - ready to draw

-	

-	GLMContext				*m_ctx;			// link back to parent context

-

-	GLuint					m_name;			// name of this FBO in the context

-	

-	GLMFBOTexAttachParams	m_attach[ kAttCount ];	// indexed by EGLMFBOAttachment

-	

-	int						m_sizeX,m_sizeY;

-};	

-

-

-#endif

+//
+// cglmfbo.h
+//	GLMgr FBO's (render targets)
+//
+//===============================================================================
+
+#ifndef CGLMFBO_H
+#define	CGLMFBO_H
+
+#pragma once
+
+#include "togl/rendermechanism.h"
+
+// good FBO references / recaps
+// http://www.songho.ca/opengl/gl_fbo.html
+// http://www.gamedev.net/reference/articles/article2331.asp
+
+// ext links
+
+// http://www.opengl.org/registry/specs/EXT/framebuffer_object.txt
+// http://www.opengl.org/registry/specs/EXT/framebuffer_multisample.txt
+
+//===============================================================================
+
+// tokens not in the SDK headers
+
+#ifndef	GL_DEPTH_STENCIL_ATTACHMENT_EXT
+	#define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9
+#endif
+
+//===============================================================================
+
+// forward declarations
+
+class	GLMContext;
+
+// implicitly 16 maximum color attachments possible
+enum EGLMFBOAttachment {
+	kAttColor0,		kAttColor1,		kAttColor2,		kAttColor3,
+	kAttColor4,		kAttColor5,		kAttColor6,		kAttColor7,
+	kAttColor8,		kAttColor9,		kAttColor10,	kAttColor11,
+	kAttColor12,	kAttColor13,	kAttColor14,	kAttColor15,
+	kAttDepth,		kAttStencil,	kAttDepthStencil,
+	kAttCount
+};
+
+struct GLMFBOTexAttachParams
+{	
+	CGLMTex				*m_tex;
+	int					m_face;		// keep zero if not cube map
+	int					m_mip;		// keep zero if notmip mapped
+	int					m_zslice;	// keep zero if not a 3D tex
+};
+
+class CGLMFBO
+{
+
+public:
+
+protected:
+	friend class GLMContext;			// only GLMContext can make CGLMFBO objects
+	friend class GLMTester;
+	friend class CGLMTex;
+	
+	friend class IDirect3D9;
+	friend class IDirect3DDevice9;
+		
+			CGLMFBO( GLMContext *ctx );
+			~CGLMFBO( );	
+
+	void	TexAttach( GLMFBOTexAttachParams *params, EGLMFBOAttachment attachIndex, GLenum fboBindPoint = GL_FRAMEBUFFER_EXT );
+	void	TexDetach( EGLMFBOAttachment attachIndex, GLenum fboBindPoint = GL_FRAMEBUFFER_EXT );
+		// you can also pass GL_READ_FRAMEBUFFER_EXT or GL_DRAW_FRAMEBUFFER_EXT to selectively bind the receiving FBO to one or the other.
+
+	void	TexScrub( CGLMTex *tex );
+		// search and destroy any attachment for the named texture
+	
+	bool	IsReady( void );				// aka FBO completeness check - ready to draw
+	
+	GLMContext				*m_ctx;			// link back to parent context
+
+	GLuint					m_name;			// name of this FBO in the context
+	
+	GLMFBOTexAttachParams	m_attach[ kAttCount ];	// indexed by EGLMFBOAttachment
+	
+	int						m_sizeX,m_sizeY;
+};	
+
+
+#endif
diff --git a/mp/src/public/togl/osx/cglmprogram.h b/mp/src/public/togl/osx/cglmprogram.h
index 3b1b4d86..ee7f4de2 100644
--- a/mp/src/public/togl/osx/cglmprogram.h
+++ b/mp/src/public/togl/osx/cglmprogram.h
@@ -1,291 +1,291 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-//

-// cglmprogram.h

-//	GLMgr programs (ARBVP/ARBfp)

-//

-//===============================================================================

-

-#ifndef CGLMPROGRAM_H

-#define	CGLMPROGRAM_H

-

-#include <sys/stat.h>

-

-#pragma once

-

-// good ARB program references

-// http://petewarden.com/notes/archives/2005/05/fragment_progra_2.html

-// http://petewarden.com/notes/archives/2005/06/fragment_progra_3.html

-

-// ext links

-

-// http://www.opengl.org/registry/specs/ARB/vertex_program.txt

-// http://www.opengl.org/registry/specs/ARB/fragment_program.txt

-// http://www.opengl.org/registry/specs/EXT/gpu_program_parameters.txt

-

-

-//===============================================================================

-

-// tokens not in the SDK headers

-

-//#ifndef	GL_DEPTH_STENCIL_ATTACHMENT_EXT

-//	#define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9

-//#endif

-

-//===============================================================================

-

-// forward declarations

-

-class GLMContext;

-class CGLMShaderPair;

-class CGLMShaderPairCache;

-

-// CGLMProgram can contain two flavors of the same program, one in assembler, one in GLSL.

-// these flavors are pretty different in terms of the API's that are used to activate them - 

-// for example, assembler programs can just get bound to the context, whereas GLSL programs

-// have to be linked.  To some extent we try to hide that detail inside GLM.

-

-// for now, make CGLMProgram a container, it does not set policy or hold a preference as to which

-// flavor you want to use.  GLMContext has to handle that. 

-

-enum EGLMProgramType

-{

-	kGLMVertexProgram,

-	kGLMFragmentProgram,

-	

-	kGLMNumProgramTypes

-};

-

-enum EGLMProgramLang

-{

-	kGLMARB,

-	kGLMGLSL,

-	

-	kGLMNumProgramLangs

-};

-

-struct GLMShaderDesc

-{

-	union

-	{

-		GLuint		arb;		// ARB program object name

-		GLhandleARB	glsl;		// GLSL shader object handle (void*)

-	}	m_object;

-

-	// these can change if shader text is edited

-	bool	m_textPresent;	// is this flavor(lang) of text present in the buffer?

-	int		m_textOffset;	// where is it

-	int		m_textLength;	// how big

-	

-	bool	m_compiled;		// has this text been through a compile attempt

-	bool	m_valid;		// and if so, was the compile successful

-

-	int		m_slowMark;		// has it been flagged during a non native draw batch before. increment every time it's slow.

-	

-	int		m_highWater;	// vount of vec4's in the major uniform array ("vc" on vs, "pc" on ps)

-							// written by dxabstract.... gross!

-};

-

-GLenum	GLMProgTypeToARBEnum( EGLMProgramType type );	// map vert/frag to ARB asm bind target

-GLenum	GLMProgTypeToGLSLEnum( EGLMProgramType type );	// map vert/frag to ARB asm bind target

-

-class CGLMProgram

-{

-public:

-	friend class CGLMShaderPairCache;

-	friend class CGLMShaderPair;

-	friend class GLMContext;			// only GLMContext can make CGLMProgram objects

-	friend class GLMTester;	

-	friend class IDirect3D9;

-	friend class IDirect3DDevice9;

-		

-	//===============================

-	

-	// constructor is very light, it just makes one empty program object per flavor.

-	CGLMProgram( GLMContext *ctx, EGLMProgramType type );

-	~CGLMProgram( );	

-

-	void	SetProgramText			( char *text );				// import text to GLM object - invalidate any prev compiled program

-	

-	bool	CompileActiveSources	( void );					// compile only the flavors that were provided.

-	bool	Compile					( EGLMProgramLang lang );	

-	bool	CheckValidity			( EGLMProgramLang lang );

-

-	void	LogSlow					( EGLMProgramLang lang );	// detailed spew when called for first time; one liner or perhaps silence after that

-	

-	void	GetLabelIndexCombo		( char *labelOut, int labelOutMaxChars, int *indexOut, int *comboOut );	

-	void	GetComboIndexNameString	( char *stringOut, int stringOutMaxChars );		// mmmmmmmm-nnnnnnnn-filename

-	

-#if GLMDEBUG

-	bool	PollForChanges( void );			// check mirror for changes.

-	void	ReloadStringFromEditable( void );	// populate m_string from editable item (react to change)

-	bool	SyncWithEditable( void );

-#endif

-

-	//===============================

-	

-	// common stuff

-

-	GLMContext				*m_ctx;					// link back to parent context

-

-	EGLMProgramType			m_type;					// vertex or pixel

-

-	uint					m_serial;				// serial number for hashing

-	

-	char					*m_text;				// copy of text passed into constructor.  Can change if editable shaders is enabled.

-													// note - it can contain multiple flavors, so use CGLMTextSectioner to scan it and locate them

-#if GLMDEBUG

-	CGLMEditableTextItem	*m_editable;			// editable text item for debugging

-#endif	

-	

-	GLMShaderDesc			m_descs[ kGLMNumProgramLangs ];	

-

-	uint					m_samplerMask;			// (1<<n) mask of sampler active locs, if this is a fragment shader (dxabstract sets this field)

-};	

-

-//===============================================================================

-

-struct GLMShaderPairInfo

-{

-	int		m_status;		// -1 means req'd index was out of bounds (loop stop..)  0 means not present.  1 means present/active.

-	

-	char	m_vsName[ 128 ];

-	int		m_vsStaticIndex;

-	int		m_vsDynamicIndex;

-	

-	char	m_psName[ 128 ];

-	int		m_psStaticIndex;

-	int		m_psDynamicIndex;

-};

-

-

-class CGLMShaderPair					// a container for a linked GLSL shader pair, and metadata obtained post-link

-{

-

-public:

-

-	friend class CGLMProgram;

-	friend class GLMContext;

-	friend class CGLMShaderPairCache;

-		

-	//===============================

-	

-	// constructor just sets up a GLSL program object and leaves it empty.

-	CGLMShaderPair( GLMContext *ctx  );

-	~CGLMShaderPair( );	

-

-	bool	SetProgramPair			( CGLMProgram *vp, CGLMProgram *fp );

-		// true result means successful link and query

-

-	bool	RefreshProgramPair		( void );

-		// re-link and re-query the uniforms

-	

-	//===============================

-	

-	// common stuff

-

-	GLMContext				*m_ctx;					// link back to parent context

-

-	CGLMProgram				*m_vertexProg;	

-	CGLMProgram				*m_fragmentProg;

-

-	GLhandleARB				m_program;				// linked program object

-

-	// need meta data for attribs / samplers / params

-	// actually we only need it for samplers and params.

-	// attributes are hardwired.

-	

-	// vertex stage uniforms

-	GLint					m_locVertexParams;		// "vc" per dx9asmtogl2 convention

-	GLint					m_locVertexInteger0;	// "i0"

-	GLint					m_locVertexBool0;		// "b0"

-	GLint					m_locVertexBool1;		// "b1"

-	GLint					m_locVertexBool2;		// "b2"

-	GLint					m_locVertexBool3;		// "b3"

-	

-	// fragment stage uniforms

-	GLint					m_locFragmentParams;			// "pc" per dx9asmtogl2 convention

-	GLint					m_locFragmentFakeSRGBEnable;	// "flSRGBWrite" - set to 1.0 to effect sRGB encoding on output

-	float					m_fakeSRGBEnableValue;			// shadow to avoid redundant sets of the m_locFragmentFakeSRGBEnable uniform

-		// init it to -1.0 at link or relink, so it will trip on any legit incoming value (0.0 or 1.0)

-

-	GLint					m_locSamplers[ 16 ];			// "sampler0 ... sampler1..."

-

-	// other stuff

-	bool					m_valid;				// true on successful link

-	bool					m_samplersFixed;		// set on first draw (can't write the uniforms until the program is in use, and we don't want to mess with cur program inside cglmprogram)

-	uint					m_revision;				// if this pair is relinked, bump this number.

-};	

-

-//===============================================================================

-

-// N-row, M-way associative cache with LRU per row.

-// still needs some metric dump ability and some parameter tuning.

-// extra credit would be to make an auto-tuner.

-

-struct CGLMPairCacheEntry

-{

-	long long		m_lastMark;				// a mark of zero means an empty entry

-	CGLMProgram		*m_vertexProg;

-	CGLMProgram		*m_fragmentProg;

-	uint			m_extraKeyBits;

-	CGLMShaderPair	*m_pair;

-};

-

-class CGLMShaderPairCache				// cache for linked GLSL shader pairs

-{

-

-public:

-

-protected:

-	friend class CGLMShaderPair;

-	friend class CGLMProgram;

-	friend class GLMContext;

-		

-	//===============================

-	

-	CGLMShaderPairCache( GLMContext *ctx  );

-	~CGLMShaderPairCache( );	

-

-	CGLMShaderPair	*SelectShaderPair	( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits );

-	void			QueryShaderPair		( int index, GLMShaderPairInfo *infoOut );

-	

-	// shoot down linked pairs that use the program in the arg

-	// return true if any had to be skipped due to conflict with currently bound pair

-	bool			PurgePairsWithShader( CGLMProgram *prog );

-	

-	// purge everything (when would GLM know how to do this ?  at context destroy time, but any other times?)

-	// return true if any had to be skipped due to conflict with currently bound pair

-	bool			Purge				( void );

-	

-	// stats

-	void			DumpStats			( void );

-	

-	//===============================

-

-	uint			HashRowIndex		( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits );

-	CGLMPairCacheEntry*	HashRowPtr		( uint hashRowIndex );

-	void			HashRowProbe		( CGLMPairCacheEntry *row, CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits, int *hitwayOut, int *emptywayOut, int *oldestwayOut );

-	//===============================

-

-	// common stuff

-

-	GLMContext				*m_ctx;					// link back to parent context

-

-	long long				m_mark;

-

-	uint					m_rowsLg2;

-	uint					m_rows;

-	

-	uint					m_waysLg2;

-	uint					m_ways;

-	

-	uint					m_entryCount;

-	

-	CGLMPairCacheEntry		*m_entries;				// array[ m_rows ][ m_ways ]

-

-	uint					*m_evictions;			// array[ m_rows ];

-	uint					*m_hits;				// array[ m_rows ];

-};	

-

-

+//
+// cglmprogram.h
+//	GLMgr programs (ARBVP/ARBfp)
+//
+//===============================================================================
+
+#ifndef CGLMPROGRAM_H
+#define	CGLMPROGRAM_H
+
+#include <sys/stat.h>
+
+#pragma once
+
+// good ARB program references
+// http://petewarden.com/notes/archives/2005/05/fragment_progra_2.html
+// http://petewarden.com/notes/archives/2005/06/fragment_progra_3.html
+
+// ext links
+
+// http://www.opengl.org/registry/specs/ARB/vertex_program.txt
+// http://www.opengl.org/registry/specs/ARB/fragment_program.txt
+// http://www.opengl.org/registry/specs/EXT/gpu_program_parameters.txt
+
+
+//===============================================================================
+
+// tokens not in the SDK headers
+
+//#ifndef	GL_DEPTH_STENCIL_ATTACHMENT_EXT
+//	#define GL_DEPTH_STENCIL_ATTACHMENT_EXT 0x84F9
+//#endif
+
+//===============================================================================
+
+// forward declarations
+
+class GLMContext;
+class CGLMShaderPair;
+class CGLMShaderPairCache;
+
+// CGLMProgram can contain two flavors of the same program, one in assembler, one in GLSL.
+// these flavors are pretty different in terms of the API's that are used to activate them - 
+// for example, assembler programs can just get bound to the context, whereas GLSL programs
+// have to be linked.  To some extent we try to hide that detail inside GLM.
+
+// for now, make CGLMProgram a container, it does not set policy or hold a preference as to which
+// flavor you want to use.  GLMContext has to handle that. 
+
+enum EGLMProgramType
+{
+	kGLMVertexProgram,
+	kGLMFragmentProgram,
+	
+	kGLMNumProgramTypes
+};
+
+enum EGLMProgramLang
+{
+	kGLMARB,
+	kGLMGLSL,
+	
+	kGLMNumProgramLangs
+};
+
+struct GLMShaderDesc
+{
+	union
+	{
+		GLuint		arb;		// ARB program object name
+		GLhandleARB	glsl;		// GLSL shader object handle (void*)
+	}	m_object;
+
+	// these can change if shader text is edited
+	bool	m_textPresent;	// is this flavor(lang) of text present in the buffer?
+	int		m_textOffset;	// where is it
+	int		m_textLength;	// how big
+	
+	bool	m_compiled;		// has this text been through a compile attempt
+	bool	m_valid;		// and if so, was the compile successful
+
+	int		m_slowMark;		// has it been flagged during a non native draw batch before. increment every time it's slow.
+	
+	int		m_highWater;	// vount of vec4's in the major uniform array ("vc" on vs, "pc" on ps)
+							// written by dxabstract.... gross!
+};
+
+GLenum	GLMProgTypeToARBEnum( EGLMProgramType type );	// map vert/frag to ARB asm bind target
+GLenum	GLMProgTypeToGLSLEnum( EGLMProgramType type );	// map vert/frag to ARB asm bind target
+
+class CGLMProgram
+{
+public:
+	friend class CGLMShaderPairCache;
+	friend class CGLMShaderPair;
+	friend class GLMContext;			// only GLMContext can make CGLMProgram objects
+	friend class GLMTester;	
+	friend class IDirect3D9;
+	friend class IDirect3DDevice9;
+		
+	//===============================
+	
+	// constructor is very light, it just makes one empty program object per flavor.
+	CGLMProgram( GLMContext *ctx, EGLMProgramType type );
+	~CGLMProgram( );	
+
+	void	SetProgramText			( char *text );				// import text to GLM object - invalidate any prev compiled program
+	
+	bool	CompileActiveSources	( void );					// compile only the flavors that were provided.
+	bool	Compile					( EGLMProgramLang lang );	
+	bool	CheckValidity			( EGLMProgramLang lang );
+
+	void	LogSlow					( EGLMProgramLang lang );	// detailed spew when called for first time; one liner or perhaps silence after that
+	
+	void	GetLabelIndexCombo		( char *labelOut, int labelOutMaxChars, int *indexOut, int *comboOut );	
+	void	GetComboIndexNameString	( char *stringOut, int stringOutMaxChars );		// mmmmmmmm-nnnnnnnn-filename
+	
+#if GLMDEBUG
+	bool	PollForChanges( void );			// check mirror for changes.
+	void	ReloadStringFromEditable( void );	// populate m_string from editable item (react to change)
+	bool	SyncWithEditable( void );
+#endif
+
+	//===============================
+	
+	// common stuff
+
+	GLMContext				*m_ctx;					// link back to parent context
+
+	EGLMProgramType			m_type;					// vertex or pixel
+
+	uint					m_serial;				// serial number for hashing
+	
+	char					*m_text;				// copy of text passed into constructor.  Can change if editable shaders is enabled.
+													// note - it can contain multiple flavors, so use CGLMTextSectioner to scan it and locate them
+#if GLMDEBUG
+	CGLMEditableTextItem	*m_editable;			// editable text item for debugging
+#endif	
+	
+	GLMShaderDesc			m_descs[ kGLMNumProgramLangs ];	
+
+	uint					m_samplerMask;			// (1<<n) mask of sampler active locs, if this is a fragment shader (dxabstract sets this field)
+};	
+
+//===============================================================================
+
+struct GLMShaderPairInfo
+{
+	int		m_status;		// -1 means req'd index was out of bounds (loop stop..)  0 means not present.  1 means present/active.
+	
+	char	m_vsName[ 128 ];
+	int		m_vsStaticIndex;
+	int		m_vsDynamicIndex;
+	
+	char	m_psName[ 128 ];
+	int		m_psStaticIndex;
+	int		m_psDynamicIndex;
+};
+
+
+class CGLMShaderPair					// a container for a linked GLSL shader pair, and metadata obtained post-link
+{
+
+public:
+
+	friend class CGLMProgram;
+	friend class GLMContext;
+	friend class CGLMShaderPairCache;
+		
+	//===============================
+	
+	// constructor just sets up a GLSL program object and leaves it empty.
+	CGLMShaderPair( GLMContext *ctx  );
+	~CGLMShaderPair( );	
+
+	bool	SetProgramPair			( CGLMProgram *vp, CGLMProgram *fp );
+		// true result means successful link and query
+
+	bool	RefreshProgramPair		( void );
+		// re-link and re-query the uniforms
+	
+	//===============================
+	
+	// common stuff
+
+	GLMContext				*m_ctx;					// link back to parent context
+
+	CGLMProgram				*m_vertexProg;	
+	CGLMProgram				*m_fragmentProg;
+
+	GLhandleARB				m_program;				// linked program object
+
+	// need meta data for attribs / samplers / params
+	// actually we only need it for samplers and params.
+	// attributes are hardwired.
+	
+	// vertex stage uniforms
+	GLint					m_locVertexParams;		// "vc" per dx9asmtogl2 convention
+	GLint					m_locVertexInteger0;	// "i0"
+	GLint					m_locVertexBool0;		// "b0"
+	GLint					m_locVertexBool1;		// "b1"
+	GLint					m_locVertexBool2;		// "b2"
+	GLint					m_locVertexBool3;		// "b3"
+	
+	// fragment stage uniforms
+	GLint					m_locFragmentParams;			// "pc" per dx9asmtogl2 convention
+	GLint					m_locFragmentFakeSRGBEnable;	// "flSRGBWrite" - set to 1.0 to effect sRGB encoding on output
+	float					m_fakeSRGBEnableValue;			// shadow to avoid redundant sets of the m_locFragmentFakeSRGBEnable uniform
+		// init it to -1.0 at link or relink, so it will trip on any legit incoming value (0.0 or 1.0)
+
+	GLint					m_locSamplers[ 16 ];			// "sampler0 ... sampler1..."
+
+	// other stuff
+	bool					m_valid;				// true on successful link
+	bool					m_samplersFixed;		// set on first draw (can't write the uniforms until the program is in use, and we don't want to mess with cur program inside cglmprogram)
+	uint					m_revision;				// if this pair is relinked, bump this number.
+};	
+
+//===============================================================================
+
+// N-row, M-way associative cache with LRU per row.
+// still needs some metric dump ability and some parameter tuning.
+// extra credit would be to make an auto-tuner.
+
+struct CGLMPairCacheEntry
+{
+	long long		m_lastMark;				// a mark of zero means an empty entry
+	CGLMProgram		*m_vertexProg;
+	CGLMProgram		*m_fragmentProg;
+	uint			m_extraKeyBits;
+	CGLMShaderPair	*m_pair;
+};
+
+class CGLMShaderPairCache				// cache for linked GLSL shader pairs
+{
+
+public:
+
+protected:
+	friend class CGLMShaderPair;
+	friend class CGLMProgram;
+	friend class GLMContext;
+		
+	//===============================
+	
+	CGLMShaderPairCache( GLMContext *ctx  );
+	~CGLMShaderPairCache( );	
+
+	CGLMShaderPair	*SelectShaderPair	( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits );
+	void			QueryShaderPair		( int index, GLMShaderPairInfo *infoOut );
+	
+	// shoot down linked pairs that use the program in the arg
+	// return true if any had to be skipped due to conflict with currently bound pair
+	bool			PurgePairsWithShader( CGLMProgram *prog );
+	
+	// purge everything (when would GLM know how to do this ?  at context destroy time, but any other times?)
+	// return true if any had to be skipped due to conflict with currently bound pair
+	bool			Purge				( void );
+	
+	// stats
+	void			DumpStats			( void );
+	
+	//===============================
+
+	uint			HashRowIndex		( CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits );
+	CGLMPairCacheEntry*	HashRowPtr		( uint hashRowIndex );
+	void			HashRowProbe		( CGLMPairCacheEntry *row, CGLMProgram *vp, CGLMProgram *fp, uint extraKeyBits, int *hitwayOut, int *emptywayOut, int *oldestwayOut );
+	//===============================
+
+	// common stuff
+
+	GLMContext				*m_ctx;					// link back to parent context
+
+	long long				m_mark;
+
+	uint					m_rowsLg2;
+	uint					m_rows;
+	
+	uint					m_waysLg2;
+	uint					m_ways;
+	
+	uint					m_entryCount;
+	
+	CGLMPairCacheEntry		*m_entries;				// array[ m_rows ][ m_ways ]
+
+	uint					*m_evictions;			// array[ m_rows ];
+	uint					*m_hits;				// array[ m_rows ];
+};	
+
+
 #endif
\ No newline at end of file
diff --git a/mp/src/public/togl/osx/cglmquery.h b/mp/src/public/togl/osx/cglmquery.h
index 21e16893..1f5b1676 100644
--- a/mp/src/public/togl/osx/cglmquery.h
+++ b/mp/src/public/togl/osx/cglmquery.h
@@ -1,85 +1,85 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-//

-// cglmquery.h

-//	GLMgr queries

-//

-//===============================================================================

-

-#ifndef CGLMQUERY_H

-#define	CGLMQUERY_H

-

-#pragma once

-

-//===============================================================================

-

-// forward declarations

-

-class	GLMContext;

-class	CGLMQuery;

-

-//===============================================================================

-

-enum EGLMQueryType

-{

-	EOcclusion,

-	EFence,

-	EGLMQueryCount

-};

-

-struct GLMQueryParams

-{

-	EGLMQueryType	m_type;

-};

-

-class CGLMQuery

-{

-	// leave everything public til it's running

-public:

-	friend class GLMContext;			// only GLMContext can make CGLMTex objects

-	friend class IDirect3DDevice9;

-	friend class IDirect3DQuery9;

-

-	GLMContext		*m_ctx;				// link back to parent context

-	GLMQueryParams	m_params;			// params created with

-	

-	GLuint			m_name;				// name of the query object per se - could be fence, could be query object ... NOT USED WITH GL_ARB_sync!

-#ifdef HAVE_GL_ARB_SYNC

-	GLsync			m_syncobj;			// GL_ARB_sync object. NOT USED WITH GL_NV_fence or GL_APPLE_fence!

-#else

-	GLuint			m_syncobj;

-#endif

-	

-	bool			m_started;

-	bool			m_stopped;

-	bool			m_done;

-	

-	bool			m_nullQuery;		// was gl_nullqueries true at Start time - if so, continue to act like a null query through Stop/IsDone/Complete time

-										// restated - only Start should examine the convar.

-										

-			CGLMQuery( GLMContext *ctx, GLMQueryParams *params );

-			~CGLMQuery( );

-			

-	// for an occlusion query:

-	//	Start = BeginQuery		query-start goes into stream

-	//	Stop = EndQuery			query-end goes into stream - a fence is also set so we can probe for completion

-	//	IsDone = TestFence		use the added fence to ask if query-end has passed (i.e. will Complete block?)

-	//	Complete = GetQueryObjectuivARB(uint id, enum pname, uint *params) - extract the sample count

-

-	// for a fence query:

-	//	Start = SetFence		fence goes into command stream

-	//	Stop = NOP				fences are self finishing - no need to call Stop on a fence

-	//	IsDone = TestFence		ask if fence passed

-	//	Complete = FinishFence

-

-	void	Start		( void );

-	void	Stop		( void );

-	bool	IsDone		( void );

-	void	Complete	( uint *result );

-

-	// accessors for the started/stopped state

-	bool	IsStarted	( void );

-	bool	IsStopped	( void );

-};

-

-

-#endif

+//
+// cglmquery.h
+//	GLMgr queries
+//
+//===============================================================================
+
+#ifndef CGLMQUERY_H
+#define	CGLMQUERY_H
+
+#pragma once
+
+//===============================================================================
+
+// forward declarations
+
+class	GLMContext;
+class	CGLMQuery;
+
+//===============================================================================
+
+enum EGLMQueryType
+{
+	EOcclusion,
+	EFence,
+	EGLMQueryCount
+};
+
+struct GLMQueryParams
+{
+	EGLMQueryType	m_type;
+};
+
+class CGLMQuery
+{
+	// leave everything public til it's running
+public:
+	friend class GLMContext;			// only GLMContext can make CGLMTex objects
+	friend class IDirect3DDevice9;
+	friend class IDirect3DQuery9;
+
+	GLMContext		*m_ctx;				// link back to parent context
+	GLMQueryParams	m_params;			// params created with
+	
+	GLuint			m_name;				// name of the query object per se - could be fence, could be query object ... NOT USED WITH GL_ARB_sync!
+#ifdef HAVE_GL_ARB_SYNC
+	GLsync			m_syncobj;			// GL_ARB_sync object. NOT USED WITH GL_NV_fence or GL_APPLE_fence!
+#else
+	GLuint			m_syncobj;
+#endif
+	
+	bool			m_started;
+	bool			m_stopped;
+	bool			m_done;
+	
+	bool			m_nullQuery;		// was gl_nullqueries true at Start time - if so, continue to act like a null query through Stop/IsDone/Complete time
+										// restated - only Start should examine the convar.
+										
+			CGLMQuery( GLMContext *ctx, GLMQueryParams *params );
+			~CGLMQuery( );
+			
+	// for an occlusion query:
+	//	Start = BeginQuery		query-start goes into stream
+	//	Stop = EndQuery			query-end goes into stream - a fence is also set so we can probe for completion
+	//	IsDone = TestFence		use the added fence to ask if query-end has passed (i.e. will Complete block?)
+	//	Complete = GetQueryObjectuivARB(uint id, enum pname, uint *params) - extract the sample count
+
+	// for a fence query:
+	//	Start = SetFence		fence goes into command stream
+	//	Stop = NOP				fences are self finishing - no need to call Stop on a fence
+	//	IsDone = TestFence		ask if fence passed
+	//	Complete = FinishFence
+
+	void	Start		( void );
+	void	Stop		( void );
+	bool	IsDone		( void );
+	void	Complete	( uint *result );
+
+	// accessors for the started/stopped state
+	bool	IsStarted	( void );
+	bool	IsStopped	( void );
+};
+
+
+#endif
diff --git a/mp/src/public/togl/osx/cglmtex.h b/mp/src/public/togl/osx/cglmtex.h
index ce6b6596..813395c7 100644
--- a/mp/src/public/togl/osx/cglmtex.h
+++ b/mp/src/public/togl/osx/cglmtex.h
@@ -1,273 +1,273 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-//

-// cglmtex.h

-//	GLMgr textures

-//

-//===============================================================================

-

-#ifndef CGLMTEX_H

-#define	CGLMTEX_H

-

-#pragma once

-

-#include "tier1/utlhash.h"

-#include "tier1/utlmap.h"

-

-//===============================================================================

-

-// forward declarations

-

-class	GLMContext;

-class	GLMTester;

-class	CGLMTexLayoutTable;

-class	CGLMTex;

-class	CGLMFBO;

-

-class	IDirect3DSurface9;

-

-//===============================================================================

-

-struct GLMTexFormatDesc

-{

-	char		*m_formatSummary;	// for debug visibility

-	

-	D3DFORMAT	m_d3dFormat;		// what D3D knows it as; see public/bitmap/imageformat.h

-	

-	GLenum		m_glIntFormat;		// GL internal format

-	GLenum		m_glIntFormatSRGB;	// internal format if SRGB flavor

-	GLenum		m_glDataFormat;		// GL data format

-	GLenum		m_glDataType;		// GL data type

-	

-	int			m_chunkSize;		// 1 or 4 - 4 is used for compressed textures

-	int			m_bytesPerSquareChunk;	// how many bytes for the smallest quantum (m_chunkSize x m_chunkSize)

-									// this description lets us calculate size cleanly without conditional logic for compression

-};

-const GLMTexFormatDesc *GetFormatDesc( D3DFORMAT format );

-

-//===============================================================================

-

-// utility function for generating slabs of texels. mostly for test.

-typedef struct

-{

-	// in

-	D3DFORMAT	m_format;

-	void		*m_dest;			// dest address

-	int			m_chunkCount;		// square chunk count (single texels or compressed blocks)

-	int			m_byteCountLimit;	// caller expectation of max number of bytes to write out

-	float		r,g,b,a;			// color desired

-	

-	// out

-	int			m_bytesWritten;

-}	GLMGenTexelParams;

-

-// return true if successful

-bool	GLMGenTexels( GLMGenTexelParams *params );

-

-

-//===============================================================================

-

-struct GLMTexLayoutSlice

-{

-	int	m_xSize,m_ySize,m_zSize;		//texel dimensions of this slice

-	int	m_storageOffset;				//where in the storage slab does this slice live

-	int	m_storageSize;					//how much storage does this slice occupy

-};

-

-enum EGLMTexFlags

-{

-	kGLMTexMipped		=	0x01,

-	kGLMTexMippedAuto	=	0x02,

-	kGLMTexRenderable	=	0x04,

-	kGLMTexIsStencil	=	0x08,

-	kGLMTexIsDepth		=	0x10,

-	kGLMTexSRGB			=	0x20,

-	kGLMTexMultisampled	=	0x40,		// has an RBO backing it.  Cannot combine with Mipped, MippedAuto.  One slice maximum, only targeting GL_TEXTURE_2D.

-										// actually not 100% positive on the mipmapping, the RBO itself can't be mipped, but the resulting texture could

-										// have mipmaps generated.

-};

-

-//===============================================================================

-

-struct GLMTexLayoutKey

-{

-	// input values: held const, these are the hash key for the form map

-	GLenum				m_texGLTarget;				// flavor of texture: GL_TEXTURE_2D, GL_TEXTURE_3D, GLTEXTURE_CUBE_MAP

-	D3DFORMAT			m_texFormat;				// D3D texel format

-	unsigned long		m_texFlags;					// mipped, autogen mips, render target, ... ?

-	unsigned long		m_texSamples;				// zero for a plain tex, 2/4/6/8 for "MSAA tex" (RBO backed)

-	int					m_xSize,m_ySize,m_zSize;	// size of base mip

-};

-

-bool LessFunc_GLMTexLayoutKey( const GLMTexLayoutKey &a, const GLMTexLayoutKey &b );

-

-#define	GLM_TEX_MAX_MIPS	14

-#define	GLM_TEX_MAX_FACES	6

-#define	GLM_TEX_MAX_SLICES	(GLM_TEX_MAX_MIPS * GLM_TEX_MAX_FACES)

-

-struct GLMTexLayout

-{

-	char		*m_layoutSummary;	// for debug visibility

-

-	// const inputs used for hashing

-	GLMTexLayoutKey		m_key;

-	

-	// refcount

-	int					m_refCount;

-

-	// derived values:	

-	GLMTexFormatDesc	*m_format;					// format specific info

-	int					m_mipCount;					// derived by starying at base size and working down towards 1x1

-	int					m_faceCount;				// 1 for 2d/3d, 6 for cubemap

-	int					m_sliceCount;				// product of faces and mips

-	int					m_storageTotalSize;			// size of storage slab required

-	

-	// slice array

-	GLMTexLayoutSlice	m_slices[0];				// dynamically allocated 2-d array [faces][mips]

-};

-

-

-class	CGLMTexLayoutTable

-{

-public:

-					CGLMTexLayoutTable();

-	

-	GLMTexLayout	*NewLayoutRef( GLMTexLayoutKey *key );		// pass in a pointer to layout key - receive ptr to completed layout

-	void			DelLayoutRef( GLMTexLayout *layout );		// pass in pointer to completed layout.  refcount is dropped.

-	

-	void			DumpStats( void );

-protected:

-	CUtlMap< GLMTexLayoutKey, GLMTexLayout* >	m_layoutMap;

-};

-

-//===============================================================================

-

-// a sampler specifies desired state for drawing on a given sampler index

-// this is the combination of a texture choice and a set of sampler parameters

-// see http://msdn.microsoft.com/en-us/library/bb172602(VS.85).aspx

-

-

-struct	GLMTexSamplingParams

-{

-	GLenum	m_addressModes[3];	// S, T, R

-	GLfloat	m_borderColor[4];	// R,G,B,A

-

-	GLenum	m_magFilter;

-	GLenum	m_minFilter;

-	

-	GLfloat	m_mipmapBias;

-	GLint	m_minMipLevel;

-	GLint	m_maxMipLevel;

-	GLint	m_maxAniso;

-	GLenum	m_compareMode;		// only used for depth and stencil type textures

-	bool	m_srgb;				// srgb texture read... 

-};

-

-struct GLMTexLockParams

-{

-	// input params which identify the slice of interest

-	CGLMTex		*m_tex;

-	int			m_face;

-	int			m_mip;

-	

-	// identifies the region of the slice

-	GLMRegion	m_region;

-	

-	// tells GLM to force re-read of the texels back from GL

-	// i.e. "I know I stepped on those texels with a draw or blit - the GLM copy is stale"

-	bool		m_readback;

-};

-

-struct GLMTexLockDesc

-{

-	GLMTexLockParams	m_req;	// form of the lock request

-	

-	bool				m_active;				// set true at lock time. cleared at unlock time.

-

-	int					m_sliceIndex;			// which slice in the layout

-	int					m_sliceBaseOffset;		// where is that in the texture data

-	int					m_sliceRegionOffset;	// offset to the start (lowest address corner) of the region requested

-};

-

-//===============================================================================

-

-#define	GLM_SAMPLER_COUNT	16

-

-typedef CBitVec<GLM_SAMPLER_COUNT> CTexBindMask;

-

-enum EGLMTexSliceFlag

-{

-	kSliceValid			=	0x01,	// slice has been teximage'd in whole at least once - set to 0 initially

-	kSliceStorageValid	=	0x02,	// if backing store is available, this slice's data is a valid copy - set to 0 initially

-	kSliceLocked		=	0x04,	// are one or more locks outstanding on this slice

-	kSliceFullyDirty	=	0x08,	// does the slice need to be fully downloaded at unlock time (disregard dirty rects)

-};

-

-class CGLMTex

-{

-

-public:

-

-	void					Lock( GLMTexLockParams *params, char** addressOut, int* yStrideOut, int *zStrideOut );

-	void					Unlock( GLMTexLockParams *params );

-	

-protected:

-	friend class GLMContext;			// only GLMContext can make CGLMTex objects

-	friend class GLMTester;

-	friend class CGLMFBO;

-

-	friend class IDirect3DDevice9;

-	friend class IDirect3DBaseTexture9;

-	friend class IDirect3DTexture9;

-	friend class IDirect3DSurface9;

-	friend class IDirect3DCubeTexture9;

-	friend class IDirect3DVolumeTexture9;

-	

-			CGLMTex( GLMContext *ctx, GLMTexLayout *layout, GLMTexSamplingParams *sampling, char *debugLabel = NULL );

-			~CGLMTex( );

-	

-	int						CalcSliceIndex( int face, int mip );

-	void					CalcTexelDataOffsetAndStrides( int sliceIndex, int x, int y, int z, int *offsetOut, int *yStrideOut, int *zStrideOut );

-

-	void					ApplySamplingParams( GLMTexSamplingParams *params, bool noCheck=FALSE );

-

-	void					ReadTexels( GLMTexLockDesc *desc, bool readWholeSlice=true );

-	void					WriteTexels( GLMTexLockDesc *desc, bool writeWholeSlice=true, bool noDataWrite=false );

-		// last param lets us send NULL data ptr (only legal with uncompressed formats, beware)

-		// this helps out ResetSRGB.

-	

-	void					ResetSRGB( bool srgb, bool noDataWrite );

-		// re-specify texture format to match desired sRGB form

-		// noWrite means send NULL for texel source addresses instead of actual data - ideal for RT's

-

-	GLMTexLayout			*m_layout;		// layout of texture (shared across all tex with same layout)

-	int						m_minActiveMip;//index of lowest mip that has been written.  used to drive setting of GL_TEXTURE_MAX_LEVEL.

-	int						m_maxActiveMip;//index of highest mip that has been written.  used to drive setting of GL_TEXTURE_MAX_LEVEL.

-				

-	GLMTexSamplingParams	m_sampling;		// mirror of sampling params currently embodied in the texture

-											// (consult this at draw time, in order to know if changes need to be made)

-						

-	GLMContext				*m_ctx;			// link back to parent context

-

-	GLuint					m_texName;			// name of this texture in the context

-	bool					m_texClientStorage;	// was CS selecetd for texture

-	bool					m_texPreloaded;		// has it been kicked into VRAM with GLMContext::PreloadTex yet

-

-	GLuint					m_rboName;		// name of MSAA RBO backing the tex if MSAA enabled (or zero)

-	bool					m_rboDirty;		// has RBO been drawn on - i.e. needs to be blitted back to texture if texture is going to be sampled from

-	

-	CTexBindMask			m_bindPoints;	// true for each place in the parent ctx where currently

-											// bound (indexed via EGLMTexCtxBindingIndex)

-										

-	int						m_rtAttachCount; // how many RT's have this texture attached somewhere

-

-	char					*m_backing;		// backing storage if available

-	

-	int						m_lockCount;	// lock reqs are stored in the GLMContext for tracking

-

-	CUtlVector<unsigned char>	m_sliceFlags;

-	

-	char					*m_debugLabel;	// strdup() of debugLabel passed in, or NULL

-};

-

-

-#endif

+//
+// cglmtex.h
+//	GLMgr textures
+//
+//===============================================================================
+
+#ifndef CGLMTEX_H
+#define	CGLMTEX_H
+
+#pragma once
+
+#include "tier1/utlhash.h"
+#include "tier1/utlmap.h"
+
+//===============================================================================
+
+// forward declarations
+
+class	GLMContext;
+class	GLMTester;
+class	CGLMTexLayoutTable;
+class	CGLMTex;
+class	CGLMFBO;
+
+class	IDirect3DSurface9;
+
+//===============================================================================
+
+struct GLMTexFormatDesc
+{
+	char		*m_formatSummary;	// for debug visibility
+	
+	D3DFORMAT	m_d3dFormat;		// what D3D knows it as; see public/bitmap/imageformat.h
+	
+	GLenum		m_glIntFormat;		// GL internal format
+	GLenum		m_glIntFormatSRGB;	// internal format if SRGB flavor
+	GLenum		m_glDataFormat;		// GL data format
+	GLenum		m_glDataType;		// GL data type
+	
+	int			m_chunkSize;		// 1 or 4 - 4 is used for compressed textures
+	int			m_bytesPerSquareChunk;	// how many bytes for the smallest quantum (m_chunkSize x m_chunkSize)
+									// this description lets us calculate size cleanly without conditional logic for compression
+};
+const GLMTexFormatDesc *GetFormatDesc( D3DFORMAT format );
+
+//===============================================================================
+
+// utility function for generating slabs of texels. mostly for test.
+typedef struct
+{
+	// in
+	D3DFORMAT	m_format;
+	void		*m_dest;			// dest address
+	int			m_chunkCount;		// square chunk count (single texels or compressed blocks)
+	int			m_byteCountLimit;	// caller expectation of max number of bytes to write out
+	float		r,g,b,a;			// color desired
+	
+	// out
+	int			m_bytesWritten;
+}	GLMGenTexelParams;
+
+// return true if successful
+bool	GLMGenTexels( GLMGenTexelParams *params );
+
+
+//===============================================================================
+
+struct GLMTexLayoutSlice
+{
+	int	m_xSize,m_ySize,m_zSize;		//texel dimensions of this slice
+	int	m_storageOffset;				//where in the storage slab does this slice live
+	int	m_storageSize;					//how much storage does this slice occupy
+};
+
+enum EGLMTexFlags
+{
+	kGLMTexMipped		=	0x01,
+	kGLMTexMippedAuto	=	0x02,
+	kGLMTexRenderable	=	0x04,
+	kGLMTexIsStencil	=	0x08,
+	kGLMTexIsDepth		=	0x10,
+	kGLMTexSRGB			=	0x20,
+	kGLMTexMultisampled	=	0x40,		// has an RBO backing it.  Cannot combine with Mipped, MippedAuto.  One slice maximum, only targeting GL_TEXTURE_2D.
+										// actually not 100% positive on the mipmapping, the RBO itself can't be mipped, but the resulting texture could
+										// have mipmaps generated.
+};
+
+//===============================================================================
+
+struct GLMTexLayoutKey
+{
+	// input values: held const, these are the hash key for the form map
+	GLenum				m_texGLTarget;				// flavor of texture: GL_TEXTURE_2D, GL_TEXTURE_3D, GLTEXTURE_CUBE_MAP
+	D3DFORMAT			m_texFormat;				// D3D texel format
+	unsigned long		m_texFlags;					// mipped, autogen mips, render target, ... ?
+	unsigned long		m_texSamples;				// zero for a plain tex, 2/4/6/8 for "MSAA tex" (RBO backed)
+	int					m_xSize,m_ySize,m_zSize;	// size of base mip
+};
+
+bool LessFunc_GLMTexLayoutKey( const GLMTexLayoutKey &a, const GLMTexLayoutKey &b );
+
+#define	GLM_TEX_MAX_MIPS	14
+#define	GLM_TEX_MAX_FACES	6
+#define	GLM_TEX_MAX_SLICES	(GLM_TEX_MAX_MIPS * GLM_TEX_MAX_FACES)
+
+struct GLMTexLayout
+{
+	char		*m_layoutSummary;	// for debug visibility
+
+	// const inputs used for hashing
+	GLMTexLayoutKey		m_key;
+	
+	// refcount
+	int					m_refCount;
+
+	// derived values:	
+	GLMTexFormatDesc	*m_format;					// format specific info
+	int					m_mipCount;					// derived by starying at base size and working down towards 1x1
+	int					m_faceCount;				// 1 for 2d/3d, 6 for cubemap
+	int					m_sliceCount;				// product of faces and mips
+	int					m_storageTotalSize;			// size of storage slab required
+	
+	// slice array
+	GLMTexLayoutSlice	m_slices[0];				// dynamically allocated 2-d array [faces][mips]
+};
+
+
+class	CGLMTexLayoutTable
+{
+public:
+					CGLMTexLayoutTable();
+	
+	GLMTexLayout	*NewLayoutRef( GLMTexLayoutKey *key );		// pass in a pointer to layout key - receive ptr to completed layout
+	void			DelLayoutRef( GLMTexLayout *layout );		// pass in pointer to completed layout.  refcount is dropped.
+	
+	void			DumpStats( void );
+protected:
+	CUtlMap< GLMTexLayoutKey, GLMTexLayout* >	m_layoutMap;
+};
+
+//===============================================================================
+
+// a sampler specifies desired state for drawing on a given sampler index
+// this is the combination of a texture choice and a set of sampler parameters
+// see http://msdn.microsoft.com/en-us/library/bb172602(VS.85).aspx
+
+
+struct	GLMTexSamplingParams
+{
+	GLenum	m_addressModes[3];	// S, T, R
+	GLfloat	m_borderColor[4];	// R,G,B,A
+
+	GLenum	m_magFilter;
+	GLenum	m_minFilter;
+	
+	GLfloat	m_mipmapBias;
+	GLint	m_minMipLevel;
+	GLint	m_maxMipLevel;
+	GLint	m_maxAniso;
+	GLenum	m_compareMode;		// only used for depth and stencil type textures
+	bool	m_srgb;				// srgb texture read... 
+};
+
+struct GLMTexLockParams
+{
+	// input params which identify the slice of interest
+	CGLMTex		*m_tex;
+	int			m_face;
+	int			m_mip;
+	
+	// identifies the region of the slice
+	GLMRegion	m_region;
+	
+	// tells GLM to force re-read of the texels back from GL
+	// i.e. "I know I stepped on those texels with a draw or blit - the GLM copy is stale"
+	bool		m_readback;
+};
+
+struct GLMTexLockDesc
+{
+	GLMTexLockParams	m_req;	// form of the lock request
+	
+	bool				m_active;				// set true at lock time. cleared at unlock time.
+
+	int					m_sliceIndex;			// which slice in the layout
+	int					m_sliceBaseOffset;		// where is that in the texture data
+	int					m_sliceRegionOffset;	// offset to the start (lowest address corner) of the region requested
+};
+
+//===============================================================================
+
+#define	GLM_SAMPLER_COUNT	16
+
+typedef CBitVec<GLM_SAMPLER_COUNT> CTexBindMask;
+
+enum EGLMTexSliceFlag
+{
+	kSliceValid			=	0x01,	// slice has been teximage'd in whole at least once - set to 0 initially
+	kSliceStorageValid	=	0x02,	// if backing store is available, this slice's data is a valid copy - set to 0 initially
+	kSliceLocked		=	0x04,	// are one or more locks outstanding on this slice
+	kSliceFullyDirty	=	0x08,	// does the slice need to be fully downloaded at unlock time (disregard dirty rects)
+};
+
+class CGLMTex
+{
+
+public:
+
+	void					Lock( GLMTexLockParams *params, char** addressOut, int* yStrideOut, int *zStrideOut );
+	void					Unlock( GLMTexLockParams *params );
+	
+protected:
+	friend class GLMContext;			// only GLMContext can make CGLMTex objects
+	friend class GLMTester;
+	friend class CGLMFBO;
+
+	friend class IDirect3DDevice9;
+	friend class IDirect3DBaseTexture9;
+	friend class IDirect3DTexture9;
+	friend class IDirect3DSurface9;
+	friend class IDirect3DCubeTexture9;
+	friend class IDirect3DVolumeTexture9;
+	
+			CGLMTex( GLMContext *ctx, GLMTexLayout *layout, GLMTexSamplingParams *sampling, char *debugLabel = NULL );
+			~CGLMTex( );
+	
+	int						CalcSliceIndex( int face, int mip );
+	void					CalcTexelDataOffsetAndStrides( int sliceIndex, int x, int y, int z, int *offsetOut, int *yStrideOut, int *zStrideOut );
+
+	void					ApplySamplingParams( GLMTexSamplingParams *params, bool noCheck=FALSE );
+
+	void					ReadTexels( GLMTexLockDesc *desc, bool readWholeSlice=true );
+	void					WriteTexels( GLMTexLockDesc *desc, bool writeWholeSlice=true, bool noDataWrite=false );
+		// last param lets us send NULL data ptr (only legal with uncompressed formats, beware)
+		// this helps out ResetSRGB.
+	
+	void					ResetSRGB( bool srgb, bool noDataWrite );
+		// re-specify texture format to match desired sRGB form
+		// noWrite means send NULL for texel source addresses instead of actual data - ideal for RT's
+
+	GLMTexLayout			*m_layout;		// layout of texture (shared across all tex with same layout)
+	int						m_minActiveMip;//index of lowest mip that has been written.  used to drive setting of GL_TEXTURE_MAX_LEVEL.
+	int						m_maxActiveMip;//index of highest mip that has been written.  used to drive setting of GL_TEXTURE_MAX_LEVEL.
+				
+	GLMTexSamplingParams	m_sampling;		// mirror of sampling params currently embodied in the texture
+											// (consult this at draw time, in order to know if changes need to be made)
+						
+	GLMContext				*m_ctx;			// link back to parent context
+
+	GLuint					m_texName;			// name of this texture in the context
+	bool					m_texClientStorage;	// was CS selecetd for texture
+	bool					m_texPreloaded;		// has it been kicked into VRAM with GLMContext::PreloadTex yet
+
+	GLuint					m_rboName;		// name of MSAA RBO backing the tex if MSAA enabled (or zero)
+	bool					m_rboDirty;		// has RBO been drawn on - i.e. needs to be blitted back to texture if texture is going to be sampled from
+	
+	CTexBindMask			m_bindPoints;	// true for each place in the parent ctx where currently
+											// bound (indexed via EGLMTexCtxBindingIndex)
+										
+	int						m_rtAttachCount; // how many RT's have this texture attached somewhere
+
+	char					*m_backing;		// backing storage if available
+	
+	int						m_lockCount;	// lock reqs are stored in the GLMContext for tracking
+
+	CUtlVector<unsigned char>	m_sliceFlags;
+	
+	char					*m_debugLabel;	// strdup() of debugLabel passed in, or NULL
+};
+
+
+#endif
diff --git a/mp/src/public/togl/osx/dxabstract.h b/mp/src/public/togl/osx/dxabstract.h
index 50676e04..92f6bc32 100644
--- a/mp/src/public/togl/osx/dxabstract.h
+++ b/mp/src/public/togl/osx/dxabstract.h
@@ -1,804 +1,804 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-//

-//

-//

-//==================================================================================================

-

-#ifndef DXABSTRACT_H

-#define DXABSTRACT_H

-#ifdef _WIN32

-#pragma once

-#endif

-

-#include "togl/rendermechanism.h"

-

-#include "materialsystem/ishader.h"

-

-// Uncomment this on Windows if you want to compile the Windows GL version.

-// #undef USE_ACTUAL_DX

-

-#ifdef USE_ACTUAL_DX

-

-#ifndef WIN32

-#error sorry man

-#endif

-#ifdef _X360

-#include "d3d9.h"

-#include "d3dx9.h"

-#else

-#include <windows.h>

-#include "../../dx9sdk/include/d3d9.h"

-#include "../../dx9sdk/include/d3dx9.h"

-#endif

-typedef HWND VD3DHWND;

-

-#else

-

-#ifdef WIN32

-#error Gl on win32?

-#endif

-

-#include "tier0/platform.h"

-

-#ifndef DX_TO_GL_ABSTRACTION

-#define DX_TO_GL_ABSTRACTION

-#endif

-

-#include "bitmap/imageformat.h"

-#include "togl/rendermechanism.h"

-

-#ifdef OSX

-extern "C" void Debugger(void);

-#endif

-

-// turn this on to get refcount logging from IUnknown

-#define	IUNKNOWN_ALLOC_SPEW 0

-#define	IUNKNOWN_ALLOC_SPEW_MARK_ALL 0	

-

-

-// ------------------------------------------------------------------------------------------------------------------------------ //

-// DEFINES

-// ------------------------------------------------------------------------------------------------------------------------------ //

-

-typedef void* VD3DHWND;

-typedef void* VD3DHANDLE;

-

-

-TOGL_INTERFACE void toglGetClientRect( VD3DHWND hWnd, RECT *destRect );

-

-struct TOGL_CLASS IUnknown

-{

-	int	m_refcount[2];

-	bool m_mark;

-		

-	IUnknown( void )

-	{

-		m_refcount[0] = 1;

-		m_refcount[1] = 0;

-		m_mark = (IUNKNOWN_ALLOC_SPEW_MARK_ALL != 0);	// either all are marked, or only the ones that have SetMark(true) called on them

-

-		#if IUNKNOWN_ALLOC_SPEW

-			if (m_mark)

-			{

-				GLMPRINTF(("-A- IUnew (%08x) refc -> (%d,%d) ",this,m_refcount[0],m_refcount[1]));

-			}

-		#endif

-	};

-				

-	virtual	~IUnknown( void )

-	{

-		#if IUNKNOWN_ALLOC_SPEW

-			if (m_mark)

-			{

-				GLMPRINTF(("-A- IUdel (%08x) ",this ));

-			}

-		#endif

-	};

-		

-	void	AddRef( int which=0, char *comment = NULL )

-	{

-		Assert( which >= 0 );

-		Assert( which < 2 );

-		m_refcount[which]++;

-			

-		#if IUNKNOWN_ALLOC_SPEW

-			if (m_mark)

-			{

-				GLMPRINTF(("-A- IUAddRef  (%08x,%d) refc -> (%d,%d) [%s]",this,which,m_refcount[0],m_refcount[1],comment?comment:"..."))	;

-				if (!comment)

-				{

-					GLMPRINTF((""))	;	// place to hang a breakpoint

-				}

-			}

-		#endif

-	};

-		

-	ULONG __stdcall	Release( int which=0, char *comment = NULL )

-	{

-		Assert( which >= 0 );

-		Assert( which < 2 );

-			

-		//int oldrefcs[2] = { m_refcount[0], m_refcount[1] };

-		bool deleting = false;

-			

-		m_refcount[which]--;

-		if ( (!m_refcount[0]) && (!m_refcount[1]) )

-		{

-			deleting = true;

-		}

-			

-		#if IUNKNOWN_ALLOC_SPEW

-			if (m_mark)

-			{

-				GLMPRINTF(("-A- IURelease (%08x,%d) refc -> (%d,%d) [%s] %s",this,which,m_refcount[0],m_refcount[1],comment?comment:"...",deleting?"->DELETING":""));

-				if (!comment)

-				{

-					GLMPRINTF((""))	;	// place to hang a breakpoint

-				}

-			}

-		#endif

-

-		if (deleting)

-		{

-			if (m_mark)

-			{

-				GLMPRINTF((""))	;		// place to hang a breakpoint

-			}

-			delete this;

-			return 0;

-		}

-		else

-		{

-			return m_refcount[0];

-		}

-	};

-		

-	void	SetMark( bool markValue, char *comment=NULL )

-	{

-		#if IUNKNOWN_ALLOC_SPEW

-			if (!m_mark && markValue)	// leading edge detect

-			{

-				// print the same thing that the constructor would have printed if it had been marked from the beginning

-				// i.e. it's anticipated that callers asking for marking will do so right at create time

-				GLMPRINTF(("-A- IUSetMark (%08x) refc -> (%d,%d) (%s) ",this,m_refcount[0],m_refcount[1],comment?comment:"..."));

-			}

-		#endif

-

-		m_mark = markValue;

-	}

-};

-

-

-// ------------------------------------------------------------------------------------------------------------------------------ //

-// INTERFACES

-// ------------------------------------------------------------------------------------------------------------------------------ //

-

-struct TOGL_CLASS IDirect3DResource9 : public IUnknown

-{

-	IDirect3DDevice9	*m_device;		// parent device

-	D3DRESOURCETYPE		m_restype;

-	

-	DWORD SetPriority(DWORD PriorityNew);

-};

-

-struct TOGL_CLASS IDirect3DBaseTexture9 : public IDirect3DResource9						// "A Texture.."

-{	

-	D3DSURFACE_DESC			m_descZero;			// desc of top level.

-	CGLMTex					*m_tex;				// a CGLMTex can represent all forms of tex

-	int						m_srgbFlipCount;

-

-	virtual					~IDirect3DBaseTexture9();

-    D3DRESOURCETYPE			GetType();

-    DWORD					GetLevelCount();

-	HRESULT					GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc);

-};

-

-struct TOGL_CLASS IDirect3DTexture9 : public IDirect3DBaseTexture9							// "Texture 2D"

-{	

-	IDirect3DSurface9		*m_surfZero;			// surf of top level.

-

-	virtual					~IDirect3DTexture9();

-

-    HRESULT					LockRect(UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags);

-    HRESULT					UnlockRect(UINT Level);

-    HRESULT					GetSurfaceLevel(UINT Level,IDirect3DSurface9** ppSurfaceLevel);

-};

-

-struct TOGL_CLASS IDirect3DCubeTexture9 : public IDirect3DBaseTexture9						// "Texture Cube Map"

-{

-	IDirect3DSurface9		*m_surfZero[6];			// surfs of top level.

-

-	virtual					~IDirect3DCubeTexture9();

-

-    HRESULT					GetCubeMapSurface(D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface9** ppCubeMapSurface);

-    HRESULT					GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc);

-};

-

-struct TOGL_CLASS IDirect3DVolumeTexture9 : public IDirect3DBaseTexture9					// "Texture 3D"

-{

-	IDirect3DSurface9		*m_surfZero;			// surf of top level.

-	D3DVOLUME_DESC			m_volDescZero;			// volume desc top level

-

-	virtual					~IDirect3DVolumeTexture9();

-

-    HRESULT					LockBox(UINT Level,D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox,DWORD Flags);

-    HRESULT					UnlockBox(UINT Level);

-	HRESULT					GetLevelDesc( UINT level, D3DVOLUME_DESC *pDesc );

-};

-

-

-// for the moment, a "D3D surface" is modeled as a GLM tex, a face, and a mip.

-// no Create method, these are filled in by the various create surface methods.	

-

-struct TOGL_CLASS IDirect3DSurface9 : public IDirect3DResource9

-{

-	virtual					~IDirect3DSurface9();

-

-    HRESULT					LockRect(D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags);

-    HRESULT					UnlockRect();

-	HRESULT					GetDesc(D3DSURFACE_DESC *pDesc);

-

-	D3DSURFACE_DESC			m_desc;

-	CGLMTex					*m_tex;

-	int						m_face;

-	int						m_mip;

-};

-

-

-

-struct TOGL_CLASS IDirect3D9 : public IUnknown

-{

-public:

-	virtual	~IDirect3D9();

-

-	UINT	GetAdapterCount();			//cheese: returns 1

-

-    HRESULT GetDeviceCaps				(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps);

-    HRESULT GetAdapterIdentifier		(UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier);

-    HRESULT CheckDeviceFormat			(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat);

-    UINT	GetAdapterModeCount			(UINT Adapter,D3DFORMAT Format);

-    HRESULT EnumAdapterModes			(UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode);

-    HRESULT CheckDeviceType				(UINT Adapter,D3DDEVTYPE DevType,D3DFORMAT AdapterFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed);

-    HRESULT GetAdapterDisplayMode		(UINT Adapter,D3DDISPLAYMODE* pMode);

-    HRESULT CheckDepthStencilMatch		(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat);

-    HRESULT CheckDeviceMultiSampleType	(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels);

-

-    HRESULT CreateDevice				(UINT Adapter,D3DDEVTYPE DeviceType,VD3DHWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface);

-};

-

-struct TOGL_CLASS IDirect3DSwapChain9 : public IUnknown

-{

-};

-

-

-

-	//	typedef enum D3DDECLUSAGE

-	//	{

-	//		D3DDECLUSAGE_POSITION = 0,

-	//		D3DDECLUSAGE_BLENDWEIGHT = 1,

-	//		D3DDECLUSAGE_BLENDINDICES = 2,

-	//		D3DDECLUSAGE_NORMAL = 3,

-	//		D3DDECLUSAGE_PSIZE = 4,

-	//		D3DDECLUSAGE_TEXCOORD = 5,

-	//		D3DDECLUSAGE_TANGENT = 6,

-	//		D3DDECLUSAGE_BINORMAL = 7,

-	//		D3DDECLUSAGE_TESSFACTOR = 8,

-	//		D3DDECLUSAGE_POSITIONT = 9,

-	//		D3DDECLUSAGE_COLOR = 10,

-	//		D3DDECLUSAGE_FOG = 11,

-	//		D3DDECLUSAGE_DEPTH = 12,

-	//		D3DDECLUSAGE_SAMPLE = 13,

-	//	} D3DDECLUSAGE, *LPD3DDECLUSAGE;

-	//	Constants

-	//	

-	//	D3DDECLUSAGE_POSITION

-	//	Position data ranging from (-1,-1) to (1,1). Use D3DDECLUSAGE_POSITION with

-	//	a usage index of 0 to specify untransformed position for fixed function

-	//	vertex processing and the n-patch tessellator. Use D3DDECLUSAGE_POSITION

-	//	with a usage index of 1 to specify untransformed position in the fixed

-	//	function vertex shader for vertex tweening.

-	//	

-	//	D3DDECLUSAGE_BLENDWEIGHT

-	//	Blending weight data. Use D3DDECLUSAGE_BLENDWEIGHT with a usage index of 0

-	//	to specify the blend weights used in indexed and nonindexed vertex

-	//	blending.

-	//	

-	//	D3DDECLUSAGE_BLENDINDICES

-	//	Blending indices data. Use D3DDECLUSAGE_BLENDINDICES with a usage index of

-	//	0 to specify matrix indices for indexed paletted skinning.

-	//	

-	//	D3DDECLUSAGE_NORMAL

-	//	Vertex normal data. Use D3DDECLUSAGE_NORMAL with a usage index of 0 to

-	//	specify vertex normals for fixed function vertex processing and the n-patch

-	//	tessellator. Use D3DDECLUSAGE_NORMAL with a usage index of 1 to specify

-	//	vertex normals for fixed function vertex processing for vertex tweening.

-	//	

-	//	D3DDECLUSAGE_PSIZE

-	//	Point size data. Use D3DDECLUSAGE_PSIZE with a usage index of 0 to specify

-	//	the point-size attribute used by the setup engine of the rasterizer to

-	//	expand a point into a quad for the point-sprite functionality.

-	//	

-	//	D3DDECLUSAGE_TEXCOORD

-	//	Texture coordinate data. Use D3DDECLUSAGE_TEXCOORD, n to specify texture

-	//	coordinates in fixed function vertex processing and in pixel shaders prior

-	//	to ps_3_0. These can be used to pass user defined data.

-	//	

-	//	D3DDECLUSAGE_TANGENT

-	//	Vertex tangent data.

-	//	

-	//	D3DDECLUSAGE_BINORMAL

-	//	Vertex binormal data.

-	//	

-	//	D3DDECLUSAGE_TESSFACTOR

-	//	Single positive floating point value. Use D3DDECLUSAGE_TESSFACTOR with a

-	//	usage index of 0 to specify a tessellation factor used in the tessellation

-	//	unit to control the rate of tessellation. For more information about the

-	//	data type, see D3DDECLTYPE_FLOAT1.

-	//	

-	//	D3DDECLUSAGE_POSITIONT

-	//	Vertex data contains transformed position data ranging from (0,0) to

-	//	(viewport width, viewport height). Use D3DDECLUSAGE_POSITIONT with a usage

-	//	index of 0 to specify transformed position. When a declaration containing

-	//	this is set, the pipeline does not perform vertex processing.

-	//	

-	//	D3DDECLUSAGE_COLOR

-	//	Vertex data contains diffuse or specular color. Use D3DDECLUSAGE_COLOR with

-	//	a usage index of 0 to specify the diffuse color in the fixed function

-	//	vertex shader and pixel shaders prior to ps_3_0. Use D3DDECLUSAGE_COLOR

-	//	with a usage index of 1 to specify the specular color in the fixed function

-	//	vertex shader and pixel shaders prior to ps_3_0.

-	//	

-	//	D3DDECLUSAGE_FOG

-	//	Vertex data contains fog data. Use D3DDECLUSAGE_FOG with a usage index of 0

-	//	to specify a fog blend value used after pixel shading finishes. This

-	//	applies to pixel shaders prior to version ps_3_0.

-	//	

-	//	D3DDECLUSAGE_DEPTH

-	//	Vertex data contains depth data.

-	//	

-	//	D3DDECLUSAGE_SAMPLE

-	//	Vertex data contains sampler data. Use D3DDECLUSAGE_SAMPLE with a usage

-	//	index of 0 to specify the displacement value to look up. It can be used

-	//	only with D3DDECLUSAGE_LOOKUPPRESAMPLED or D3DDECLUSAGE_LOOKUP.

-

-	//note the form of the list terminator..

-

-	//	#define D3DDECL_END() {0xFF,0,D3DDECLTYPE_UNUSED,0,0,0}

-	//	typedef struct _D3DVERTEXELEMENT9

-	//	{

-	//		WORD    Stream;     // Stream index

-	//		WORD    Offset;     // Offset in the stream in bytes

-	//		BYTE    Type;       // Data type

-	//		BYTE    Method;     // Processing method

-	//		BYTE    Usage;      // Semantics

-	//		BYTE    UsageIndex; // Semantic index

-	//	} D3DVERTEXELEMENT9, *LPD3DVERTEXELEMENT9;

-

-#define MAX_D3DVERTEXELEMENTS	16

-

-struct TOGL_CLASS IDirect3DVertexDeclaration9 : public IUnknown

-{

-//public:

-	uint					m_elemCount;

-	D3DVERTEXELEMENT9_GL	m_elements[ MAX_D3DVERTEXELEMENTS ];

-

-	virtual					~IDirect3DVertexDeclaration9();

-};

-

-struct TOGL_CLASS IDirect3DQuery9 : public IDirect3DResource9	//was IUnknown

-{

-//public:

-	D3DQUERYTYPE			m_type;		// D3DQUERYTYPE_OCCLUSION or D3DQUERYTYPE_EVENT

-	GLMContext				*m_ctx;

-	CGLMQuery				*m_query;

-	

-	virtual					~IDirect3DQuery9();

-

-    HRESULT					Issue(DWORD dwIssueFlags);

-    HRESULT					GetData(void* pData,DWORD dwSize,DWORD dwGetDataFlags);

-};

-

-struct TOGL_CLASS IDirect3DVertexBuffer9 : public IDirect3DResource9	//was IUnknown

-{

-//public:

-	GLMContext				*m_ctx;

-	CGLMBuffer				*m_vtxBuffer;

-	D3DVERTEXBUFFER_DESC	m_vtxDesc;		// to satisfy GetDesc

-

-	virtual					~IDirect3DVertexBuffer9();

-    HRESULT					Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags);

-    HRESULT					Unlock();

-	HRESULT					UnlockActualSize( uint nActualSize, const void *pActualData = NULL );

-

-};

-

-struct TOGL_CLASS IDirect3DIndexBuffer9 : public IDirect3DResource9	//was IUnknown

-{

-//public:

-	GLMContext				*m_ctx;

-	CGLMBuffer				*m_idxBuffer;

-	D3DINDEXBUFFER_DESC		m_idxDesc;		// to satisfy GetDesc

-	

-	virtual					~IDirect3DIndexBuffer9();

-

-    HRESULT					Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags);

-    HRESULT					Unlock();

-	HRESULT					UnlockActualSize( uint nActualSize, const void *pActualData = NULL );

-    HRESULT					GetDesc(D3DINDEXBUFFER_DESC *pDesc);

-};

-

-struct TOGL_CLASS IDirect3DPixelShader9 : public IDirect3DResource9	//was IUnknown

-{

-//public:

-	CGLMProgram				*m_pixProgram;

-	uint					m_pixHighWater;		// count of active constant slots referenced by shader.

-	uint					m_pixSamplerMask;	// (1<<n) mask of samplers referemnced by this pixel shader

-												// this can help FlushSamplers avoid SRGB flipping on textures not being referenced...

-

-	virtual					~IDirect3DPixelShader9();

-};

-

-struct TOGL_CLASS IDirect3DVertexShader9 : public IDirect3DResource9	//was IUnknown

-{

-//public:

-	CGLMProgram				*m_vtxProgram;

-	uint					m_vtxHighWater;		// count of active constant slots referenced by shader.

-	unsigned char			m_vtxAttribMap[16];	// high nibble is usage, low nibble is usageindex, array position is attrib number

-

-	virtual					~IDirect3DVertexShader9();

-

-};

-

-struct TOGL_CLASS ID3DXMatrixStack : public IUnknown

-{

-//public:

-	CUtlVector<D3DMATRIX>	m_stack;

-	int						m_stackTop;	// top of stack is at the highest index, this is that index.  push increases, pop decreases.

-	

-	HRESULT	Create( void );

-	

-    D3DXMATRIX* GetTop();

-	void Push();

-	void Pop();

-	void LoadIdentity();

-	void LoadMatrix( const D3DXMATRIX *pMat );

-	void MultMatrix( const D3DXMATRIX *pMat );

-	void MultMatrixLocal( const D3DXMATRIX *pMat );

-    HRESULT ScaleLocal(FLOAT x, FLOAT y, FLOAT z);

-

-	// Left multiply the current matrix with the computed rotation

-    // matrix, counterclockwise about the given axis with the given angle.

-    // (rotation is about the local origin of the object)

-    HRESULT RotateAxisLocal(CONST D3DXVECTOR3* pV, FLOAT Angle);

-

-	// Left multiply the current matrix with the computed translation

-    // matrix. (transformation is about the local origin of the object)

-    HRESULT TranslateLocal(FLOAT x, FLOAT y, FLOAT z);

-};

-typedef ID3DXMatrixStack* LPD3DXMATRIXSTACK;

-

-struct TOGL_CLASS IDirect3DDevice9 : public IUnknown

-{

-public:

-	// members

-	

-	IDirect3DDevice9Params	m_params;						// mirror of the creation inputs

-

-	// D3D flavor stuff

-	IDirect3DSurface9			*m_rtSurfaces[16];				// current color RT surfaces. [0] is initially == m_defaultColorSurface

-	IDirect3DSurface9			*m_dsSurface;					// current DS RT surface. can be changed!

-	

-	IDirect3DSurface9			*m_defaultColorSurface;			// default color surface.

-	IDirect3DSurface9			*m_defaultDepthStencilSurface;	// queried by GetDepthStencilSurface.

-	

-	IDirect3DVertexDeclaration9	*m_vertDecl;					// Set by SetVertexDeclaration...

-	D3DStreamDesc				m_streams[ D3D_MAX_STREAMS ];	// Set by SetStreamSource..

-	D3DIndexDesc				m_indices;						// Set by SetIndices..

-	

-	IDirect3DVertexShader9		*m_vertexShader;				// Set by SetVertexShader...

-	IDirect3DPixelShader9		*m_pixelShader;					// Set by SetPixelShader...

-

-	IDirect3DBaseTexture9		*m_textures[16];				// set by SetTexture... NULL if stage inactive

-	D3DSamplerDesc				m_samplers[16];					// set by SetSamplerState..

-	// GLM flavor stuff

-	GLMContext					*m_ctx;

-	CGLMFBO						*m_drawableFBO;					// this FBO should have all the attachments set to match m_rtSurfaces and m_dsSurface.

-	

-	// GL state 

-	struct 

-	{

-		// render state buckets

-		GLAlphaTestEnable_t			m_AlphaTestEnable;

-		GLAlphaTestFunc_t			m_AlphaTestFunc;

-

-		GLAlphaToCoverageEnable_t	m_AlphaToCoverageEnable;

-		

-		GLDepthTestEnable_t			m_DepthTestEnable;

-		GLDepthMask_t				m_DepthMask;

-		GLDepthFunc_t				m_DepthFunc;

-

-		GLClipPlaneEnable_t			m_ClipPlaneEnable[kGLMUserClipPlanes];

-		GLClipPlaneEquation_t		m_ClipPlaneEquation[kGLMUserClipPlanes];

-		

-		GLColorMaskSingle_t			m_ColorMaskSingle;

-		GLColorMaskMultiple_t		m_ColorMaskMultiple;

-		

-		GLCullFaceEnable_t			m_CullFaceEnable;

-		GLCullFrontFace_t			m_CullFrontFace;

-		GLPolygonMode_t				m_PolygonMode;

-		GLDepthBias_t				m_DepthBias;

-		GLScissorEnable_t			m_ScissorEnable;

-		GLScissorBox_t				m_ScissorBox;

-		GLViewportBox_t				m_ViewportBox;

-		GLViewportDepthRange_t		m_ViewportDepthRange;

-

-		GLBlendEnable_t				m_BlendEnable;

-		GLBlendFactor_t				m_BlendFactor;

-		GLBlendEquation_t			m_BlendEquation;

-		GLBlendColor_t				m_BlendColor;

-		GLBlendEnableSRGB_t			m_BlendEnableSRGB;

-

-		GLStencilTestEnable_t		m_StencilTestEnable;

-		GLStencilFunc_t				m_StencilFunc;

-		GLStencilOp_t				m_StencilOp;

-		GLStencilWriteMask_t		m_StencilWriteMask;

-

-		GLClearColor_t				m_ClearColor;

-		GLClearDepth_t				m_ClearDepth;

-		GLClearStencil_t			m_ClearStencil;

-		

-		bool						m_FogEnable;			// not really pushed to GL, just latched here

-		

-		// samplers

-		GLMTexSamplingParams		m_samplers[ 16 ];

-		

-		// bindings...hmmm...		

-

-		// dirty-bits

-		uint						m_stateDirtyMask;		// covers the state blocks, indexed by 1<<n, n = EGLMStateBlockType

-		uint						m_samplerDirtyMask;		// covers the samplers, indexed 1<<n, n = sampler index

-	}	gl;

-	

-	// methods

-

-public:

-	virtual					~IDirect3DDevice9();

-	

-	// Create call invoked from IDirect3D9

-	HRESULT	Create( IDirect3DDevice9Params *params );

-	

-	//

-	// Basics

-	//

-	HRESULT Reset(D3DPRESENT_PARAMETERS* pPresentationParameters);

-	HRESULT SetViewport(CONST D3DVIEWPORT9* pViewport);

-	HRESULT GetViewport(D3DVIEWPORT9* pViewport);

-    HRESULT BeginScene();

-	HRESULT Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil);

-    HRESULT EndScene();

-    HRESULT Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,VD3DHWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion);

-

-	// textures

-	HRESULT CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);

-    HRESULT CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);

-    HRESULT CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);

-	

-	HRESULT SetTexture(DWORD Stage,IDirect3DBaseTexture9* pTexture);

-    HRESULT GetTexture(DWORD Stage,IDirect3DBaseTexture9** ppTexture);

-

-	// render targets, color and depthstencil, surfaces, blit

-    HRESULT CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);

-    HRESULT SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget);

-    HRESULT GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget);

-

-    HRESULT CreateOffscreenPlainSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle);

-

-    HRESULT CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle);

-    HRESULT SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil);

-    HRESULT GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface);

-

-	HRESULT GetRenderTargetData(IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface);	// ? is anyone using this ?

-    HRESULT GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface);

-    HRESULT StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter);

-

-	// pixel shaders

-    HRESULT CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader, const char *pShaderName, char *debugLabel = NULL);

-	HRESULT SetPixelShader(IDirect3DPixelShader9* pShader);

-    HRESULT SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);

-    HRESULT SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount);

-    HRESULT SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);

-

-	// vertex shaders

-    HRESULT CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader, const char *pShaderName, char *debugLabel = NULL);

-    HRESULT SetVertexShader(IDirect3DVertexShader9* pShader);

-    HRESULT SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);

-    HRESULT SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount);

-    HRESULT SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);

-

-	// POSIX only - preheating for a specific vertex/pixel shader pair - trigger GLSL link inside GLM

-	HRESULT LinkShaderPair( IDirect3DVertexShader9* vs, IDirect3DPixelShader9* ps );

-	HRESULT QueryShaderPair( int index, GLMShaderPairInfo *infoOut );

-	

-	// vertex buffers

-    HRESULT CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl);

-	HRESULT SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl);

-

-    HRESULT SetFVF(DWORD FVF);		// we might not be using these ?

-	HRESULT GetFVF(DWORD* pFVF);

-

-    HRESULT CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,VD3DHANDLE* pSharedHandle);

-    HRESULT SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride);

-

-	// index buffers

-    HRESULT CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,VD3DHANDLE* pSharedHandle);

-    HRESULT SetIndices(IDirect3DIndexBuffer9* pIndexData);

-

-	// response to retired objects (when refcount goes to zero and they self-delete..)

-	void	ReleasedTexture			( IDirect3DBaseTexture9 *baseTex );			// called from texture destructor - need to scrub samplers	

-	void	ReleasedSurface			( IDirect3DSurface9 *surface );				// called from any surface destructor - need to scrub RT table if an RT

-	void	ReleasedPixelShader		( IDirect3DPixelShader9 *pixelShader );		// called from IDirect3DPixelShader9 destructor

-	void	ReleasedVertexShader	( IDirect3DVertexShader9 *vertexShader );	// called from IDirect3DVertexShader9 destructor

-	void	ReleasedVertexBuffer	( IDirect3DVertexBuffer9 *vertexBuffer );	// called from IDirect3DVertexBuffer9 destructor

-	void	ReleasedIndexBuffer		( IDirect3DIndexBuffer9 *indexBuffer );		// called from IDirect3DIndexBuffer9 destructor

-	void	ReleasedQuery			( IDirect3DQuery9 *query );					// called from IDirect3DQuery9 destructor

-

-	// State management.

-	HRESULT SetRenderStateInline(D3DRENDERSTATETYPE State,DWORD Value);

-	HRESULT SetRenderStateConstInline(D3DRENDERSTATETYPE State,DWORD Value);

-	HRESULT SetRenderState(D3DRENDERSTATETYPE State,DWORD Value);

-	HRESULT SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value);

-

-

-	// Flushing changes to GL

-	HRESULT FlushStates( uint mask );

-	HRESULT FlushSamplers( uint mask );		// push SetRenderState and SetSamplerState changes

-	HRESULT FlushIndexBindings( void );		// push index buffer (set index ptr)

-	HRESULT	FlushVertexBindings( uint baseVertexIndex );	// push vertex streams (set attrib ptrs)

-	HRESULT FlushGLM( void );

-	

-	// Draw.

-    HRESULT DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount);

-    HRESULT DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount);

-	HRESULT DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride);

-

-	// misc

-    BOOL ShowCursor(BOOL bShow);

-    HRESULT ValidateDevice(DWORD* pNumPasses);

-    HRESULT SetMaterial(CONST D3DMATERIAL9* pMaterial);

-    HRESULT LightEnable(DWORD Index,BOOL Enable);

-    HRESULT SetScissorRect(CONST RECT* pRect);

-	HRESULT CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery);

-    HRESULT GetDeviceCaps(D3DCAPS9* pCaps);

-    HRESULT TestCooperativeLevel();

-    HRESULT EvictManagedResources();

-    HRESULT SetLight(DWORD Index,CONST D3DLIGHT9*);

-    void SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp);

-

-	void SaveGLState();

-	void RestoreGLState();

-

-	// Talk to JasonM about this one. It's tricky in GL.

-    HRESULT SetClipPlane(DWORD Index,CONST float* pPlane);

-

-	//

-	//

-	// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.

-	//

-	//

-    HRESULT SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix);

-    HRESULT SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value);	

-

-	void AcquireThreadOwnership( );

-	void ReleaseThreadOwnership( );

-	inline DWORD GetCurrentOwnerThreadId() const { return m_ctx->m_nCurOwnerThreadId; }

-

-};

-

-struct ID3DXInclude

-{

-    virtual HRESULT Open(D3DXINCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) = 0;

-    virtual HRESULT Close(LPCVOID pData) = 0;

-};

-typedef ID3DXInclude* LPD3DXINCLUDE;

-

-

-struct TOGL_CLASS ID3DXBuffer : public IUnknown

-{

-    void* GetBufferPointer();

-    DWORD GetBufferSize();

-};

-

-typedef ID3DXBuffer* LPD3DXBUFFER;

-

-class TOGL_CLASS ID3DXConstantTable : public IUnknown

-{

-};

-typedef ID3DXConstantTable* LPD3DXCONSTANTTABLE;

-

-

-

-// ------------------------------------------------------------------------------------------------------------------------------ //

-// D3DX stuff.

-// ------------------------------------------------------------------------------------------------------------------------------ //

-

-TOGL_INTERFACE const char* D3DXGetPixelShaderProfile( IDirect3DDevice9 *pDevice );

-

-

-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixMultiply( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 );

-TOGL_INTERFACE D3DXVECTOR3* D3DXVec3TransformCoord( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM );

-

-TOGL_INTERFACE  HRESULT D3DXCreateMatrixStack( DWORD Flags, LPD3DXMATRIXSTACK* ppStack);

-TOGL_INTERFACE void D3DXMatrixIdentity( D3DXMATRIX * );

-

-TOGL_INTERFACE D3DXINLINE D3DXVECTOR3* D3DXVec3Subtract( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )

-{

-    pOut->x = pV1->x - pV2->x;

-    pOut->y = pV1->y - pV2->y;

-    pOut->z = pV1->z - pV2->z;

-    return pOut;

-}

-

-TOGL_INTERFACE D3DXINLINE D3DXVECTOR3* D3DXVec3Cross( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )

-{

-    D3DXVECTOR3 v;

-

-    v.x = pV1->y * pV2->z - pV1->z * pV2->y;

-    v.y = pV1->z * pV2->x - pV1->x * pV2->z;

-    v.z = pV1->x * pV2->y - pV1->y * pV2->x;

-

-    *pOut = v;

-    return pOut;

-}

-

-TOGL_INTERFACE D3DXINLINE FLOAT D3DXVec3Dot( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )

-{

-    return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z;

-}

-

-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixInverse( D3DXMATRIX *pOut, FLOAT *pDeterminant, CONST D3DXMATRIX *pM );

-

-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixTranspose( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM );

-

-TOGL_INTERFACE D3DXPLANE* D3DXPlaneNormalize( D3DXPLANE *pOut, CONST D3DXPLANE *pP);

-

-TOGL_INTERFACE D3DXVECTOR4* D3DXVec4Transform( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, CONST D3DXMATRIX *pM );

-

-

-TOGL_INTERFACE D3DXVECTOR4* D3DXVec4Normalize( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV );

-

-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixTranslation( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z );

-

-// Build an ortho projection matrix. (right-handed)

-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixOrthoOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,FLOAT zf );

-

-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixPerspectiveRH( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf );

-

-TOGL_INTERFACE D3DXMATRIX* D3DXMatrixPerspectiveOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf );

-

-// Transform a plane by a matrix.  The vector (a,b,c) must be normal.

-// M should be the inverse transpose of the transformation desired.

-TOGL_INTERFACE D3DXPLANE* D3DXPlaneTransform( D3DXPLANE *pOut, CONST D3DXPLANE *pP, CONST D3DXMATRIX *pM );

-

-TOGL_INTERFACE IDirect3D9 *Direct3DCreate9(UINT SDKVersion);

-

-TOGL_INTERFACE void D3DPERF_SetOptions( DWORD dwOptions );

-

-TOGL_INTERFACE HRESULT D3DXCompileShader(

-        LPCSTR                          pSrcData,

-        UINT                            SrcDataLen,

-        CONST D3DXMACRO*                pDefines,

-        LPD3DXINCLUDE                   pInclude,

-        LPCSTR                          pFunctionName,

-        LPCSTR                          pProfile,

-        DWORD                           Flags,

-        LPD3DXBUFFER*                   ppShader,

-        LPD3DXBUFFER*                   ppErrorMsgs,

-        LPD3DXCONSTANTTABLE*            ppConstantTable);

-

-

-#endif // USE_ACTUAL_DX

-

-// fake D3D usage constant for SRGB tex creation

-#define D3DUSAGE_TEXTURE_SRGB (0x80000000L)

-

-#endif // DXABSTRACT_H

+//
+//
+//
+//==================================================================================================
+
+#ifndef DXABSTRACT_H
+#define DXABSTRACT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "togl/rendermechanism.h"
+
+#include "materialsystem/ishader.h"
+
+// Uncomment this on Windows if you want to compile the Windows GL version.
+// #undef USE_ACTUAL_DX
+
+#ifdef USE_ACTUAL_DX
+
+#ifndef WIN32
+#error sorry man
+#endif
+#ifdef _X360
+#include "d3d9.h"
+#include "d3dx9.h"
+#else
+#include <windows.h>
+#include "../../dx9sdk/include/d3d9.h"
+#include "../../dx9sdk/include/d3dx9.h"
+#endif
+typedef HWND VD3DHWND;
+
+#else
+
+#ifdef WIN32
+#error Gl on win32?
+#endif
+
+#include "tier0/platform.h"
+
+#ifndef DX_TO_GL_ABSTRACTION
+#define DX_TO_GL_ABSTRACTION
+#endif
+
+#include "bitmap/imageformat.h"
+#include "togl/rendermechanism.h"
+
+#ifdef OSX
+extern "C" void Debugger(void);
+#endif
+
+// turn this on to get refcount logging from IUnknown
+#define	IUNKNOWN_ALLOC_SPEW 0
+#define	IUNKNOWN_ALLOC_SPEW_MARK_ALL 0	
+
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// DEFINES
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+typedef void* VD3DHWND;
+typedef void* VD3DHANDLE;
+
+
+TOGL_INTERFACE void toglGetClientRect( VD3DHWND hWnd, RECT *destRect );
+
+struct TOGL_CLASS IUnknown
+{
+	int	m_refcount[2];
+	bool m_mark;
+		
+	IUnknown( void )
+	{
+		m_refcount[0] = 1;
+		m_refcount[1] = 0;
+		m_mark = (IUNKNOWN_ALLOC_SPEW_MARK_ALL != 0);	// either all are marked, or only the ones that have SetMark(true) called on them
+
+		#if IUNKNOWN_ALLOC_SPEW
+			if (m_mark)
+			{
+				GLMPRINTF(("-A- IUnew (%08x) refc -> (%d,%d) ",this,m_refcount[0],m_refcount[1]));
+			}
+		#endif
+	};
+				
+	virtual	~IUnknown( void )
+	{
+		#if IUNKNOWN_ALLOC_SPEW
+			if (m_mark)
+			{
+				GLMPRINTF(("-A- IUdel (%08x) ",this ));
+			}
+		#endif
+	};
+		
+	void	AddRef( int which=0, char *comment = NULL )
+	{
+		Assert( which >= 0 );
+		Assert( which < 2 );
+		m_refcount[which]++;
+			
+		#if IUNKNOWN_ALLOC_SPEW
+			if (m_mark)
+			{
+				GLMPRINTF(("-A- IUAddRef  (%08x,%d) refc -> (%d,%d) [%s]",this,which,m_refcount[0],m_refcount[1],comment?comment:"..."))	;
+				if (!comment)
+				{
+					GLMPRINTF((""))	;	// place to hang a breakpoint
+				}
+			}
+		#endif
+	};
+		
+	ULONG __stdcall	Release( int which=0, char *comment = NULL )
+	{
+		Assert( which >= 0 );
+		Assert( which < 2 );
+			
+		//int oldrefcs[2] = { m_refcount[0], m_refcount[1] };
+		bool deleting = false;
+			
+		m_refcount[which]--;
+		if ( (!m_refcount[0]) && (!m_refcount[1]) )
+		{
+			deleting = true;
+		}
+			
+		#if IUNKNOWN_ALLOC_SPEW
+			if (m_mark)
+			{
+				GLMPRINTF(("-A- IURelease (%08x,%d) refc -> (%d,%d) [%s] %s",this,which,m_refcount[0],m_refcount[1],comment?comment:"...",deleting?"->DELETING":""));
+				if (!comment)
+				{
+					GLMPRINTF((""))	;	// place to hang a breakpoint
+				}
+			}
+		#endif
+
+		if (deleting)
+		{
+			if (m_mark)
+			{
+				GLMPRINTF((""))	;		// place to hang a breakpoint
+			}
+			delete this;
+			return 0;
+		}
+		else
+		{
+			return m_refcount[0];
+		}
+	};
+		
+	void	SetMark( bool markValue, char *comment=NULL )
+	{
+		#if IUNKNOWN_ALLOC_SPEW
+			if (!m_mark && markValue)	// leading edge detect
+			{
+				// print the same thing that the constructor would have printed if it had been marked from the beginning
+				// i.e. it's anticipated that callers asking for marking will do so right at create time
+				GLMPRINTF(("-A- IUSetMark (%08x) refc -> (%d,%d) (%s) ",this,m_refcount[0],m_refcount[1],comment?comment:"..."));
+			}
+		#endif
+
+		m_mark = markValue;
+	}
+};
+
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// INTERFACES
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+struct TOGL_CLASS IDirect3DResource9 : public IUnknown
+{
+	IDirect3DDevice9	*m_device;		// parent device
+	D3DRESOURCETYPE		m_restype;
+	
+	DWORD SetPriority(DWORD PriorityNew);
+};
+
+struct TOGL_CLASS IDirect3DBaseTexture9 : public IDirect3DResource9						// "A Texture.."
+{	
+	D3DSURFACE_DESC			m_descZero;			// desc of top level.
+	CGLMTex					*m_tex;				// a CGLMTex can represent all forms of tex
+	int						m_srgbFlipCount;
+
+	virtual					~IDirect3DBaseTexture9();
+    D3DRESOURCETYPE			GetType();
+    DWORD					GetLevelCount();
+	HRESULT					GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc);
+};
+
+struct TOGL_CLASS IDirect3DTexture9 : public IDirect3DBaseTexture9							// "Texture 2D"
+{	
+	IDirect3DSurface9		*m_surfZero;			// surf of top level.
+
+	virtual					~IDirect3DTexture9();
+
+    HRESULT					LockRect(UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags);
+    HRESULT					UnlockRect(UINT Level);
+    HRESULT					GetSurfaceLevel(UINT Level,IDirect3DSurface9** ppSurfaceLevel);
+};
+
+struct TOGL_CLASS IDirect3DCubeTexture9 : public IDirect3DBaseTexture9						// "Texture Cube Map"
+{
+	IDirect3DSurface9		*m_surfZero[6];			// surfs of top level.
+
+	virtual					~IDirect3DCubeTexture9();
+
+    HRESULT					GetCubeMapSurface(D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface9** ppCubeMapSurface);
+    HRESULT					GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc);
+};
+
+struct TOGL_CLASS IDirect3DVolumeTexture9 : public IDirect3DBaseTexture9					// "Texture 3D"
+{
+	IDirect3DSurface9		*m_surfZero;			// surf of top level.
+	D3DVOLUME_DESC			m_volDescZero;			// volume desc top level
+
+	virtual					~IDirect3DVolumeTexture9();
+
+    HRESULT					LockBox(UINT Level,D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox,DWORD Flags);
+    HRESULT					UnlockBox(UINT Level);
+	HRESULT					GetLevelDesc( UINT level, D3DVOLUME_DESC *pDesc );
+};
+
+
+// for the moment, a "D3D surface" is modeled as a GLM tex, a face, and a mip.
+// no Create method, these are filled in by the various create surface methods.	
+
+struct TOGL_CLASS IDirect3DSurface9 : public IDirect3DResource9
+{
+	virtual					~IDirect3DSurface9();
+
+    HRESULT					LockRect(D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags);
+    HRESULT					UnlockRect();
+	HRESULT					GetDesc(D3DSURFACE_DESC *pDesc);
+
+	D3DSURFACE_DESC			m_desc;
+	CGLMTex					*m_tex;
+	int						m_face;
+	int						m_mip;
+};
+
+
+
+struct TOGL_CLASS IDirect3D9 : public IUnknown
+{
+public:
+	virtual	~IDirect3D9();
+
+	UINT	GetAdapterCount();			//cheese: returns 1
+
+    HRESULT GetDeviceCaps				(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps);
+    HRESULT GetAdapterIdentifier		(UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier);
+    HRESULT CheckDeviceFormat			(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat);
+    UINT	GetAdapterModeCount			(UINT Adapter,D3DFORMAT Format);
+    HRESULT EnumAdapterModes			(UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode);
+    HRESULT CheckDeviceType				(UINT Adapter,D3DDEVTYPE DevType,D3DFORMAT AdapterFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed);
+    HRESULT GetAdapterDisplayMode		(UINT Adapter,D3DDISPLAYMODE* pMode);
+    HRESULT CheckDepthStencilMatch		(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat);
+    HRESULT CheckDeviceMultiSampleType	(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels);
+
+    HRESULT CreateDevice				(UINT Adapter,D3DDEVTYPE DeviceType,VD3DHWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface);
+};
+
+struct TOGL_CLASS IDirect3DSwapChain9 : public IUnknown
+{
+};
+
+
+
+	//	typedef enum D3DDECLUSAGE
+	//	{
+	//		D3DDECLUSAGE_POSITION = 0,
+	//		D3DDECLUSAGE_BLENDWEIGHT = 1,
+	//		D3DDECLUSAGE_BLENDINDICES = 2,
+	//		D3DDECLUSAGE_NORMAL = 3,
+	//		D3DDECLUSAGE_PSIZE = 4,
+	//		D3DDECLUSAGE_TEXCOORD = 5,
+	//		D3DDECLUSAGE_TANGENT = 6,
+	//		D3DDECLUSAGE_BINORMAL = 7,
+	//		D3DDECLUSAGE_TESSFACTOR = 8,
+	//		D3DDECLUSAGE_POSITIONT = 9,
+	//		D3DDECLUSAGE_COLOR = 10,
+	//		D3DDECLUSAGE_FOG = 11,
+	//		D3DDECLUSAGE_DEPTH = 12,
+	//		D3DDECLUSAGE_SAMPLE = 13,
+	//	} D3DDECLUSAGE, *LPD3DDECLUSAGE;
+	//	Constants
+	//	
+	//	D3DDECLUSAGE_POSITION
+	//	Position data ranging from (-1,-1) to (1,1). Use D3DDECLUSAGE_POSITION with
+	//	a usage index of 0 to specify untransformed position for fixed function
+	//	vertex processing and the n-patch tessellator. Use D3DDECLUSAGE_POSITION
+	//	with a usage index of 1 to specify untransformed position in the fixed
+	//	function vertex shader for vertex tweening.
+	//	
+	//	D3DDECLUSAGE_BLENDWEIGHT
+	//	Blending weight data. Use D3DDECLUSAGE_BLENDWEIGHT with a usage index of 0
+	//	to specify the blend weights used in indexed and nonindexed vertex
+	//	blending.
+	//	
+	//	D3DDECLUSAGE_BLENDINDICES
+	//	Blending indices data. Use D3DDECLUSAGE_BLENDINDICES with a usage index of
+	//	0 to specify matrix indices for indexed paletted skinning.
+	//	
+	//	D3DDECLUSAGE_NORMAL
+	//	Vertex normal data. Use D3DDECLUSAGE_NORMAL with a usage index of 0 to
+	//	specify vertex normals for fixed function vertex processing and the n-patch
+	//	tessellator. Use D3DDECLUSAGE_NORMAL with a usage index of 1 to specify
+	//	vertex normals for fixed function vertex processing for vertex tweening.
+	//	
+	//	D3DDECLUSAGE_PSIZE
+	//	Point size data. Use D3DDECLUSAGE_PSIZE with a usage index of 0 to specify
+	//	the point-size attribute used by the setup engine of the rasterizer to
+	//	expand a point into a quad for the point-sprite functionality.
+	//	
+	//	D3DDECLUSAGE_TEXCOORD
+	//	Texture coordinate data. Use D3DDECLUSAGE_TEXCOORD, n to specify texture
+	//	coordinates in fixed function vertex processing and in pixel shaders prior
+	//	to ps_3_0. These can be used to pass user defined data.
+	//	
+	//	D3DDECLUSAGE_TANGENT
+	//	Vertex tangent data.
+	//	
+	//	D3DDECLUSAGE_BINORMAL
+	//	Vertex binormal data.
+	//	
+	//	D3DDECLUSAGE_TESSFACTOR
+	//	Single positive floating point value. Use D3DDECLUSAGE_TESSFACTOR with a
+	//	usage index of 0 to specify a tessellation factor used in the tessellation
+	//	unit to control the rate of tessellation. For more information about the
+	//	data type, see D3DDECLTYPE_FLOAT1.
+	//	
+	//	D3DDECLUSAGE_POSITIONT
+	//	Vertex data contains transformed position data ranging from (0,0) to
+	//	(viewport width, viewport height). Use D3DDECLUSAGE_POSITIONT with a usage
+	//	index of 0 to specify transformed position. When a declaration containing
+	//	this is set, the pipeline does not perform vertex processing.
+	//	
+	//	D3DDECLUSAGE_COLOR
+	//	Vertex data contains diffuse or specular color. Use D3DDECLUSAGE_COLOR with
+	//	a usage index of 0 to specify the diffuse color in the fixed function
+	//	vertex shader and pixel shaders prior to ps_3_0. Use D3DDECLUSAGE_COLOR
+	//	with a usage index of 1 to specify the specular color in the fixed function
+	//	vertex shader and pixel shaders prior to ps_3_0.
+	//	
+	//	D3DDECLUSAGE_FOG
+	//	Vertex data contains fog data. Use D3DDECLUSAGE_FOG with a usage index of 0
+	//	to specify a fog blend value used after pixel shading finishes. This
+	//	applies to pixel shaders prior to version ps_3_0.
+	//	
+	//	D3DDECLUSAGE_DEPTH
+	//	Vertex data contains depth data.
+	//	
+	//	D3DDECLUSAGE_SAMPLE
+	//	Vertex data contains sampler data. Use D3DDECLUSAGE_SAMPLE with a usage
+	//	index of 0 to specify the displacement value to look up. It can be used
+	//	only with D3DDECLUSAGE_LOOKUPPRESAMPLED or D3DDECLUSAGE_LOOKUP.
+
+	//note the form of the list terminator..
+
+	//	#define D3DDECL_END() {0xFF,0,D3DDECLTYPE_UNUSED,0,0,0}
+	//	typedef struct _D3DVERTEXELEMENT9
+	//	{
+	//		WORD    Stream;     // Stream index
+	//		WORD    Offset;     // Offset in the stream in bytes
+	//		BYTE    Type;       // Data type
+	//		BYTE    Method;     // Processing method
+	//		BYTE    Usage;      // Semantics
+	//		BYTE    UsageIndex; // Semantic index
+	//	} D3DVERTEXELEMENT9, *LPD3DVERTEXELEMENT9;
+
+#define MAX_D3DVERTEXELEMENTS	16
+
+struct TOGL_CLASS IDirect3DVertexDeclaration9 : public IUnknown
+{
+//public:
+	uint					m_elemCount;
+	D3DVERTEXELEMENT9_GL	m_elements[ MAX_D3DVERTEXELEMENTS ];
+
+	virtual					~IDirect3DVertexDeclaration9();
+};
+
+struct TOGL_CLASS IDirect3DQuery9 : public IDirect3DResource9	//was IUnknown
+{
+//public:
+	D3DQUERYTYPE			m_type;		// D3DQUERYTYPE_OCCLUSION or D3DQUERYTYPE_EVENT
+	GLMContext				*m_ctx;
+	CGLMQuery				*m_query;
+	
+	virtual					~IDirect3DQuery9();
+
+    HRESULT					Issue(DWORD dwIssueFlags);
+    HRESULT					GetData(void* pData,DWORD dwSize,DWORD dwGetDataFlags);
+};
+
+struct TOGL_CLASS IDirect3DVertexBuffer9 : public IDirect3DResource9	//was IUnknown
+{
+//public:
+	GLMContext				*m_ctx;
+	CGLMBuffer				*m_vtxBuffer;
+	D3DVERTEXBUFFER_DESC	m_vtxDesc;		// to satisfy GetDesc
+
+	virtual					~IDirect3DVertexBuffer9();
+    HRESULT					Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags);
+    HRESULT					Unlock();
+	HRESULT					UnlockActualSize( uint nActualSize, const void *pActualData = NULL );
+
+};
+
+struct TOGL_CLASS IDirect3DIndexBuffer9 : public IDirect3DResource9	//was IUnknown
+{
+//public:
+	GLMContext				*m_ctx;
+	CGLMBuffer				*m_idxBuffer;
+	D3DINDEXBUFFER_DESC		m_idxDesc;		// to satisfy GetDesc
+	
+	virtual					~IDirect3DIndexBuffer9();
+
+    HRESULT					Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags);
+    HRESULT					Unlock();
+	HRESULT					UnlockActualSize( uint nActualSize, const void *pActualData = NULL );
+    HRESULT					GetDesc(D3DINDEXBUFFER_DESC *pDesc);
+};
+
+struct TOGL_CLASS IDirect3DPixelShader9 : public IDirect3DResource9	//was IUnknown
+{
+//public:
+	CGLMProgram				*m_pixProgram;
+	uint					m_pixHighWater;		// count of active constant slots referenced by shader.
+	uint					m_pixSamplerMask;	// (1<<n) mask of samplers referemnced by this pixel shader
+												// this can help FlushSamplers avoid SRGB flipping on textures not being referenced...
+
+	virtual					~IDirect3DPixelShader9();
+};
+
+struct TOGL_CLASS IDirect3DVertexShader9 : public IDirect3DResource9	//was IUnknown
+{
+//public:
+	CGLMProgram				*m_vtxProgram;
+	uint					m_vtxHighWater;		// count of active constant slots referenced by shader.
+	unsigned char			m_vtxAttribMap[16];	// high nibble is usage, low nibble is usageindex, array position is attrib number
+
+	virtual					~IDirect3DVertexShader9();
+
+};
+
+struct TOGL_CLASS ID3DXMatrixStack : public IUnknown
+{
+//public:
+	CUtlVector<D3DMATRIX>	m_stack;
+	int						m_stackTop;	// top of stack is at the highest index, this is that index.  push increases, pop decreases.
+	
+	HRESULT	Create( void );
+	
+    D3DXMATRIX* GetTop();
+	void Push();
+	void Pop();
+	void LoadIdentity();
+	void LoadMatrix( const D3DXMATRIX *pMat );
+	void MultMatrix( const D3DXMATRIX *pMat );
+	void MultMatrixLocal( const D3DXMATRIX *pMat );
+    HRESULT ScaleLocal(FLOAT x, FLOAT y, FLOAT z);
+
+	// Left multiply the current matrix with the computed rotation
+    // matrix, counterclockwise about the given axis with the given angle.
+    // (rotation is about the local origin of the object)
+    HRESULT RotateAxisLocal(CONST D3DXVECTOR3* pV, FLOAT Angle);
+
+	// Left multiply the current matrix with the computed translation
+    // matrix. (transformation is about the local origin of the object)
+    HRESULT TranslateLocal(FLOAT x, FLOAT y, FLOAT z);
+};
+typedef ID3DXMatrixStack* LPD3DXMATRIXSTACK;
+
+struct TOGL_CLASS IDirect3DDevice9 : public IUnknown
+{
+public:
+	// members
+	
+	IDirect3DDevice9Params	m_params;						// mirror of the creation inputs
+
+	// D3D flavor stuff
+	IDirect3DSurface9			*m_rtSurfaces[16];				// current color RT surfaces. [0] is initially == m_defaultColorSurface
+	IDirect3DSurface9			*m_dsSurface;					// current DS RT surface. can be changed!
+	
+	IDirect3DSurface9			*m_defaultColorSurface;			// default color surface.
+	IDirect3DSurface9			*m_defaultDepthStencilSurface;	// queried by GetDepthStencilSurface.
+	
+	IDirect3DVertexDeclaration9	*m_vertDecl;					// Set by SetVertexDeclaration...
+	D3DStreamDesc				m_streams[ D3D_MAX_STREAMS ];	// Set by SetStreamSource..
+	D3DIndexDesc				m_indices;						// Set by SetIndices..
+	
+	IDirect3DVertexShader9		*m_vertexShader;				// Set by SetVertexShader...
+	IDirect3DPixelShader9		*m_pixelShader;					// Set by SetPixelShader...
+
+	IDirect3DBaseTexture9		*m_textures[16];				// set by SetTexture... NULL if stage inactive
+	D3DSamplerDesc				m_samplers[16];					// set by SetSamplerState..
+	// GLM flavor stuff
+	GLMContext					*m_ctx;
+	CGLMFBO						*m_drawableFBO;					// this FBO should have all the attachments set to match m_rtSurfaces and m_dsSurface.
+	
+	// GL state 
+	struct 
+	{
+		// render state buckets
+		GLAlphaTestEnable_t			m_AlphaTestEnable;
+		GLAlphaTestFunc_t			m_AlphaTestFunc;
+
+		GLAlphaToCoverageEnable_t	m_AlphaToCoverageEnable;
+		
+		GLDepthTestEnable_t			m_DepthTestEnable;
+		GLDepthMask_t				m_DepthMask;
+		GLDepthFunc_t				m_DepthFunc;
+
+		GLClipPlaneEnable_t			m_ClipPlaneEnable[kGLMUserClipPlanes];
+		GLClipPlaneEquation_t		m_ClipPlaneEquation[kGLMUserClipPlanes];
+		
+		GLColorMaskSingle_t			m_ColorMaskSingle;
+		GLColorMaskMultiple_t		m_ColorMaskMultiple;
+		
+		GLCullFaceEnable_t			m_CullFaceEnable;
+		GLCullFrontFace_t			m_CullFrontFace;
+		GLPolygonMode_t				m_PolygonMode;
+		GLDepthBias_t				m_DepthBias;
+		GLScissorEnable_t			m_ScissorEnable;
+		GLScissorBox_t				m_ScissorBox;
+		GLViewportBox_t				m_ViewportBox;
+		GLViewportDepthRange_t		m_ViewportDepthRange;
+
+		GLBlendEnable_t				m_BlendEnable;
+		GLBlendFactor_t				m_BlendFactor;
+		GLBlendEquation_t			m_BlendEquation;
+		GLBlendColor_t				m_BlendColor;
+		GLBlendEnableSRGB_t			m_BlendEnableSRGB;
+
+		GLStencilTestEnable_t		m_StencilTestEnable;
+		GLStencilFunc_t				m_StencilFunc;
+		GLStencilOp_t				m_StencilOp;
+		GLStencilWriteMask_t		m_StencilWriteMask;
+
+		GLClearColor_t				m_ClearColor;
+		GLClearDepth_t				m_ClearDepth;
+		GLClearStencil_t			m_ClearStencil;
+		
+		bool						m_FogEnable;			// not really pushed to GL, just latched here
+		
+		// samplers
+		GLMTexSamplingParams		m_samplers[ 16 ];
+		
+		// bindings...hmmm...		
+
+		// dirty-bits
+		uint						m_stateDirtyMask;		// covers the state blocks, indexed by 1<<n, n = EGLMStateBlockType
+		uint						m_samplerDirtyMask;		// covers the samplers, indexed 1<<n, n = sampler index
+	}	gl;
+	
+	// methods
+
+public:
+	virtual					~IDirect3DDevice9();
+	
+	// Create call invoked from IDirect3D9
+	HRESULT	Create( IDirect3DDevice9Params *params );
+	
+	//
+	// Basics
+	//
+	HRESULT Reset(D3DPRESENT_PARAMETERS* pPresentationParameters);
+	HRESULT SetViewport(CONST D3DVIEWPORT9* pViewport);
+	HRESULT GetViewport(D3DVIEWPORT9* pViewport);
+    HRESULT BeginScene();
+	HRESULT Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil);
+    HRESULT EndScene();
+    HRESULT Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,VD3DHWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion);
+
+	// textures
+	HRESULT CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+    HRESULT CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+    HRESULT CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+	
+	HRESULT SetTexture(DWORD Stage,IDirect3DBaseTexture9* pTexture);
+    HRESULT GetTexture(DWORD Stage,IDirect3DBaseTexture9** ppTexture);
+
+	// render targets, color and depthstencil, surfaces, blit
+    HRESULT CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
+    HRESULT SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget);
+    HRESULT GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget);
+
+    HRESULT CreateOffscreenPlainSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle);
+
+    HRESULT CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle);
+    HRESULT SetDepthStencilSurface(IDirect3DSurface9* pNewZStencil);
+    HRESULT GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface);
+
+	HRESULT GetRenderTargetData(IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface);	// ? is anyone using this ?
+    HRESULT GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface);
+    HRESULT StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter);
+
+	// pixel shaders
+    HRESULT CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader, const char *pShaderName, char *debugLabel = NULL);
+	HRESULT SetPixelShader(IDirect3DPixelShader9* pShader);
+    HRESULT SetPixelShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
+    HRESULT SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount);
+    HRESULT SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);
+
+	// vertex shaders
+    HRESULT CreateVertexShader(CONST DWORD* pFunction,IDirect3DVertexShader9** ppShader, const char *pShaderName, char *debugLabel = NULL);
+    HRESULT SetVertexShader(IDirect3DVertexShader9* pShader);
+    HRESULT SetVertexShaderConstantF(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount);
+    HRESULT SetVertexShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT  BoolCount);
+    HRESULT SetVertexShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount);
+
+	// POSIX only - preheating for a specific vertex/pixel shader pair - trigger GLSL link inside GLM
+	HRESULT LinkShaderPair( IDirect3DVertexShader9* vs, IDirect3DPixelShader9* ps );
+	HRESULT QueryShaderPair( int index, GLMShaderPairInfo *infoOut );
+	
+	// vertex buffers
+    HRESULT CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl);
+	HRESULT SetVertexDeclaration(IDirect3DVertexDeclaration9* pDecl);
+
+    HRESULT SetFVF(DWORD FVF);		// we might not be using these ?
+	HRESULT GetFVF(DWORD* pFVF);
+
+    HRESULT CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,VD3DHANDLE* pSharedHandle);
+    HRESULT SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride);
+
+	// index buffers
+    HRESULT CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,VD3DHANDLE* pSharedHandle);
+    HRESULT SetIndices(IDirect3DIndexBuffer9* pIndexData);
+
+	// response to retired objects (when refcount goes to zero and they self-delete..)
+	void	ReleasedTexture			( IDirect3DBaseTexture9 *baseTex );			// called from texture destructor - need to scrub samplers	
+	void	ReleasedSurface			( IDirect3DSurface9 *surface );				// called from any surface destructor - need to scrub RT table if an RT
+	void	ReleasedPixelShader		( IDirect3DPixelShader9 *pixelShader );		// called from IDirect3DPixelShader9 destructor
+	void	ReleasedVertexShader	( IDirect3DVertexShader9 *vertexShader );	// called from IDirect3DVertexShader9 destructor
+	void	ReleasedVertexBuffer	( IDirect3DVertexBuffer9 *vertexBuffer );	// called from IDirect3DVertexBuffer9 destructor
+	void	ReleasedIndexBuffer		( IDirect3DIndexBuffer9 *indexBuffer );		// called from IDirect3DIndexBuffer9 destructor
+	void	ReleasedQuery			( IDirect3DQuery9 *query );					// called from IDirect3DQuery9 destructor
+
+	// State management.
+	HRESULT SetRenderStateInline(D3DRENDERSTATETYPE State,DWORD Value);
+	HRESULT SetRenderStateConstInline(D3DRENDERSTATETYPE State,DWORD Value);
+	HRESULT SetRenderState(D3DRENDERSTATETYPE State,DWORD Value);
+	HRESULT SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value);
+
+
+	// Flushing changes to GL
+	HRESULT FlushStates( uint mask );
+	HRESULT FlushSamplers( uint mask );		// push SetRenderState and SetSamplerState changes
+	HRESULT FlushIndexBindings( void );		// push index buffer (set index ptr)
+	HRESULT	FlushVertexBindings( uint baseVertexIndex );	// push vertex streams (set attrib ptrs)
+	HRESULT FlushGLM( void );
+	
+	// Draw.
+    HRESULT DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount);
+    HRESULT DrawIndexedPrimitive(D3DPRIMITIVETYPE PrimitiveType,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount);
+	HRESULT DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride);
+
+	// misc
+    BOOL ShowCursor(BOOL bShow);
+    HRESULT ValidateDevice(DWORD* pNumPasses);
+    HRESULT SetMaterial(CONST D3DMATERIAL9* pMaterial);
+    HRESULT LightEnable(DWORD Index,BOOL Enable);
+    HRESULT SetScissorRect(CONST RECT* pRect);
+	HRESULT CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery);
+    HRESULT GetDeviceCaps(D3DCAPS9* pCaps);
+    HRESULT TestCooperativeLevel();
+    HRESULT EvictManagedResources();
+    HRESULT SetLight(DWORD Index,CONST D3DLIGHT9*);
+    void SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp);
+
+	void SaveGLState();
+	void RestoreGLState();
+
+	// Talk to JasonM about this one. It's tricky in GL.
+    HRESULT SetClipPlane(DWORD Index,CONST float* pPlane);
+
+	//
+	//
+	// **** FIXED FUNCTION STUFF - None of this stuff needs support in GL.
+	//
+	//
+    HRESULT SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix);
+    HRESULT SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value);	
+
+	void AcquireThreadOwnership( );
+	void ReleaseThreadOwnership( );
+	inline DWORD GetCurrentOwnerThreadId() const { return m_ctx->m_nCurOwnerThreadId; }
+
+};
+
+struct ID3DXInclude
+{
+    virtual HRESULT Open(D3DXINCLUDE_TYPE IncludeType, LPCSTR pFileName, LPCVOID pParentData, LPCVOID *ppData, UINT *pBytes) = 0;
+    virtual HRESULT Close(LPCVOID pData) = 0;
+};
+typedef ID3DXInclude* LPD3DXINCLUDE;
+
+
+struct TOGL_CLASS ID3DXBuffer : public IUnknown
+{
+    void* GetBufferPointer();
+    DWORD GetBufferSize();
+};
+
+typedef ID3DXBuffer* LPD3DXBUFFER;
+
+class TOGL_CLASS ID3DXConstantTable : public IUnknown
+{
+};
+typedef ID3DXConstantTable* LPD3DXCONSTANTTABLE;
+
+
+
+// ------------------------------------------------------------------------------------------------------------------------------ //
+// D3DX stuff.
+// ------------------------------------------------------------------------------------------------------------------------------ //
+
+TOGL_INTERFACE const char* D3DXGetPixelShaderProfile( IDirect3DDevice9 *pDevice );
+
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixMultiply( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 );
+TOGL_INTERFACE D3DXVECTOR3* D3DXVec3TransformCoord( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE  HRESULT D3DXCreateMatrixStack( DWORD Flags, LPD3DXMATRIXSTACK* ppStack);
+TOGL_INTERFACE void D3DXMatrixIdentity( D3DXMATRIX * );
+
+TOGL_INTERFACE D3DXINLINE D3DXVECTOR3* D3DXVec3Subtract( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+    pOut->x = pV1->x - pV2->x;
+    pOut->y = pV1->y - pV2->y;
+    pOut->z = pV1->z - pV2->z;
+    return pOut;
+}
+
+TOGL_INTERFACE D3DXINLINE D3DXVECTOR3* D3DXVec3Cross( D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+    D3DXVECTOR3 v;
+
+    v.x = pV1->y * pV2->z - pV1->z * pV2->y;
+    v.y = pV1->z * pV2->x - pV1->x * pV2->z;
+    v.z = pV1->x * pV2->y - pV1->y * pV2->x;
+
+    *pOut = v;
+    return pOut;
+}
+
+TOGL_INTERFACE D3DXINLINE FLOAT D3DXVec3Dot( CONST D3DXVECTOR3 *pV1, CONST D3DXVECTOR3 *pV2 )
+{
+    return pV1->x * pV2->x + pV1->y * pV2->y + pV1->z * pV2->z;
+}
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixInverse( D3DXMATRIX *pOut, FLOAT *pDeterminant, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixTranspose( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE D3DXPLANE* D3DXPlaneNormalize( D3DXPLANE *pOut, CONST D3DXPLANE *pP);
+
+TOGL_INTERFACE D3DXVECTOR4* D3DXVec4Transform( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, CONST D3DXMATRIX *pM );
+
+
+TOGL_INTERFACE D3DXVECTOR4* D3DXVec4Normalize( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixTranslation( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z );
+
+// Build an ortho projection matrix. (right-handed)
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixOrthoOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,FLOAT zf );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixPerspectiveRH( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf );
+
+TOGL_INTERFACE D3DXMATRIX* D3DXMatrixPerspectiveOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf );
+
+// Transform a plane by a matrix.  The vector (a,b,c) must be normal.
+// M should be the inverse transpose of the transformation desired.
+TOGL_INTERFACE D3DXPLANE* D3DXPlaneTransform( D3DXPLANE *pOut, CONST D3DXPLANE *pP, CONST D3DXMATRIX *pM );
+
+TOGL_INTERFACE IDirect3D9 *Direct3DCreate9(UINT SDKVersion);
+
+TOGL_INTERFACE void D3DPERF_SetOptions( DWORD dwOptions );
+
+TOGL_INTERFACE HRESULT D3DXCompileShader(
+        LPCSTR                          pSrcData,
+        UINT                            SrcDataLen,
+        CONST D3DXMACRO*                pDefines,
+        LPD3DXINCLUDE                   pInclude,
+        LPCSTR                          pFunctionName,
+        LPCSTR                          pProfile,
+        DWORD                           Flags,
+        LPD3DXBUFFER*                   ppShader,
+        LPD3DXBUFFER*                   ppErrorMsgs,
+        LPD3DXCONSTANTTABLE*            ppConstantTable);
+
+
+#endif // USE_ACTUAL_DX
+
+// fake D3D usage constant for SRGB tex creation
+#define D3DUSAGE_TEXTURE_SRGB (0x80000000L)
+
+#endif // DXABSTRACT_H
diff --git a/mp/src/public/togl/osx/glfuncs.h b/mp/src/public/togl/osx/glfuncs.h
index b0be737c..78184bef 100644
--- a/mp/src/public/togl/osx/glfuncs.h
+++ b/mp/src/public/togl/osx/glfuncs.h
@@ -1,184 +1,184 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-// !!! FIXME: Some of these aren't base OpenGL...pick out the extensions.

-// !!! FIXME: Also, look up these -1, -1 versions numbers.

-GL_FUNC(OpenGL,true,GLenum,glGetError,(void),())

-GL_FUNC_VOID(OpenGL,true,glActiveTexture,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glAlphaFunc,(GLenum a,GLclampf b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glAttachObjectARB,(GLhandleARB a,GLhandleARB b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glBegin,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glBindAttribLocationARB,(GLhandleARB a,GLuint b,const GLcharARB *c),(a,b,c))

-GL_FUNC_VOID(OpenGL,true,glBindBufferARB,(GLenum a,GLuint b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glBindProgramARB,(GLenum a,GLuint b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glBindTexture,(GLenum a,GLuint b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glBlendColor,(GLclampf a,GLclampf b,GLclampf c,GLclampf d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glBlendEquation,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glBlendFunc,(GLenum a,GLenum b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glBufferDataARB,(GLenum a,GLsizeiptrARB b,const GLvoid *c,GLenum d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glClear,(GLbitfield a),(a))

-GL_FUNC_VOID(OpenGL,true,glClearColor,(GLclampf a,GLclampf b,GLclampf c,GLclampf d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glClearDepth,(GLclampd a),(a))

-GL_FUNC_VOID(OpenGL,true,glClearStencil,(GLint a),(a))

-GL_FUNC_VOID(OpenGL,true,glClipPlane,(GLenum a,const GLdouble *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glColorMask,(GLboolean a,GLboolean b,GLboolean c,GLboolean d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glCompileShaderARB,(GLhandleARB a),(a))

-GL_FUNC_VOID(OpenGL,true,glCompressedTexImage2D,(GLenum a,GLint b,GLenum c,GLsizei d,GLsizei e,GLint f,GLsizei g,const GLvoid *h),(a,b,c,d,e,f,g,h))

-GL_FUNC_VOID(OpenGL,true,glCompressedTexImage3D,(GLenum a,GLint b,GLenum c,GLsizei d,GLsizei e,GLsizei f,GLint g,GLsizei h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))

-GL_FUNC(OpenGL,true,GLhandleARB,glCreateProgramObjectARB,(void),())

-GL_FUNC(OpenGL,true,GLhandleARB,glCreateShaderObjectARB,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glDeleteBuffersARB,(GLsizei a,const GLuint *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glDeleteObjectARB,(GLhandleARB a),(a))

-GL_FUNC_VOID(OpenGL,true,glDeleteProgramsARB,(GLsizei a,const GLuint *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glDeleteQueriesARB,(GLsizei a,const GLuint *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glDeleteShader,(GLuint a),(a))

-GL_FUNC_VOID(OpenGL,true,glDeleteTextures,(GLsizei a,const GLuint *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glDepthFunc,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glDepthMask,(GLboolean a),(a))

-GL_FUNC_VOID(OpenGL,true,glDepthRange,(GLclampd a,GLclampd b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glDetachObjectARB,(GLhandleARB a,GLhandleARB b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glDisable,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glDisableVertexAttribArray,(GLuint a),(a))

-GL_FUNC_VOID(OpenGL,true,glDrawArrays,(GLenum a,GLint b,GLsizei c),(a,b,c))

-GL_FUNC_VOID(OpenGL,true,glDrawBuffer,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glDrawRangeElements,(GLenum a,GLuint b,GLuint c,GLsizei d,GLenum e,const GLvoid *f),(a,b,c,d,e,f))

-GL_FUNC_VOID(OpenGL,true,glEnable,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glEnableVertexAttribArray,(GLuint a),(a))

-GL_FUNC_VOID(OpenGL,true,glEnd,(void),())

-GL_FUNC_VOID(OpenGL,true,glFinish,(void),())

-GL_FUNC_VOID(OpenGL,true,glFlush,(void),())

-GL_FUNC_VOID(OpenGL,true,glFrontFace,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glGenBuffersARB,(GLsizei a,GLuint *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glGenProgramsARB,(GLsizei a,GLuint *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glGenQueriesARB,(GLsizei a,GLuint *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glGenTextures,(GLsizei a,GLuint *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glGetBooleanv,(GLenum a,GLboolean *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glGetCompressedTexImage,(GLenum a,GLint b,GLvoid *c),(a,b,c))

-GL_FUNC_VOID(OpenGL,true,glGetDoublev,(GLenum a,GLdouble *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glGetFloatv,(GLenum a,GLfloat *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glGetInfoLogARB,(GLhandleARB a,GLsizei b,GLsizei *c,GLcharARB *d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glGetIntegerv,(GLenum a,GLint *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glGetObjectParameterivARB,(GLhandleARB a,GLenum b,GLint *c),(a,b,c))

-GL_FUNC_VOID(OpenGL,true,glGetProgramivARB,(GLenum a,GLenum b,GLint *c),(a,b,c))

-GL_FUNC(OpenGL,true,const GLubyte *,glGetString,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glGetTexImage,(GLenum a,GLint b,GLenum c,GLenum d,GLvoid *e),(a,b,c,d,e))

-GL_FUNC(OpenGL,true,GLint,glGetUniformLocationARB,(GLhandleARB a,const GLcharARB *b),(a,b))

-GL_FUNC(OpenGL,true,GLboolean,glIsEnabled,(GLenum a),(a))

-GL_FUNC(OpenGL,true,GLboolean,glIsTexture,(GLuint a),(a))

-GL_FUNC_VOID(OpenGL,true,glLinkProgramARB,(GLhandleARB a),(a))

-GL_FUNC(OpenGL,true,GLvoid*,glMapBufferARB,(GLenum a,GLenum b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glOrtho,(GLdouble a,GLdouble b,GLdouble c,GLdouble d,GLdouble e,GLdouble f),(a,b,c,d,e,f))

-GL_FUNC_VOID(OpenGL,true,glPixelStorei,(GLenum a,GLint b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glPolygonMode,(GLenum a,GLenum b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glPolygonOffset,(GLfloat a,GLfloat b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glPopAttrib,(void),())

-GL_FUNC_VOID(OpenGL,true,glProgramStringARB,(GLenum a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glPushAttrib,(GLbitfield a),(a))

-GL_FUNC_VOID(OpenGL,true,glReadBuffer,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glScissor,(GLint a,GLint b,GLsizei c,GLsizei d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glShaderSourceARB,(GLhandleARB a,GLsizei b,const GLcharARB **c,const GLint *d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glStencilFunc,(GLenum a,GLint b,GLuint c),(a,b,c))

-GL_FUNC_VOID(OpenGL,true,glStencilMask,(GLuint a),(a))

-GL_FUNC_VOID(OpenGL,true,glStencilOp,(GLenum a,GLenum b,GLenum c),(a,b,c))

-GL_FUNC_VOID(OpenGL,true,glTexCoord2f,(GLfloat a,GLfloat b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glTexImage2D,(GLenum a,GLint b,GLint c,GLsizei d,GLsizei e,GLint f,GLenum g,GLenum h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))

-GL_FUNC_VOID(OpenGL,true,glTexImage3D,(GLenum a,GLint b,GLint c,GLsizei d,GLsizei e,GLsizei f,GLint g,GLenum h,GLenum i,const GLvoid *j),(a,b,c,d,e,f,g,h,i,j))

-GL_FUNC_VOID(OpenGL,true,glTexParameterfv,(GLenum a,GLenum b,const GLfloat *c),(a,b,c))

-GL_FUNC_VOID(OpenGL,true,glTexParameteri,(GLenum a,GLenum b,GLint c),(a,b,c))

-GL_FUNC_VOID(OpenGL,true,glTexSubImage2D,(GLenum a,GLint b,GLint c,GLint d,GLsizei e,GLsizei f,GLenum g,GLenum h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))

-GL_FUNC_VOID(OpenGL,true,glUniform1f,(GLint a,GLfloat b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glUniform1i,(GLint a,GLint b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glUniform1iARB,(GLint a,GLint b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glUniform4fv,(GLint a,GLsizei b,const GLfloat *c),(a,b,c))

-GL_FUNC(OpenGL,true,GLboolean,glUnmapBuffer,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glUseProgram,(GLuint a),(a))

-GL_FUNC_VOID(OpenGL,true,glVertex3f,(GLfloat a,GLfloat b,GLfloat c),(a,b,c))

-GL_FUNC_VOID(OpenGL,true,glVertexAttribPointer,(GLuint a,GLint b,GLenum c,GLboolean d,GLsizei e,const GLvoid *f),(a,b,c,d,e,f))

-GL_FUNC_VOID(OpenGL,true,glViewport,(GLint a,GLint b,GLsizei c,GLsizei d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glEnableClientState,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glDisableClientState,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glClientActiveTexture,(GLenum a),(a))

-GL_FUNC_VOID(OpenGL,true,glVertexPointer,(GLint a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glTexCoordPointer,(GLint a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glProgramEnvParameters4fvEXT,(GLenum a,GLuint b,GLsizei c,const GLfloat *d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glColor4sv,(const GLshort  *a),(a))

-GL_FUNC_VOID(OpenGL,true,glStencilOpSeparate,(GLenum a,GLenum b,GLenum c,GLenum d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glStencilFuncSeparate,(GLenum a,GLenum b,GLint c,GLuint d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glGetTexLevelParameteriv,(GLenum a,GLint b,GLenum c,GLint *d),(a,b,c,d))

-GL_FUNC_VOID(OpenGL,true,glColor4f,(GLfloat a,GLfloat b,GLfloat c,GLfloat d),(a,b,c,d))

-GL_EXT(GL_EXT_framebuffer_object,-1,-1)

-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glBindFramebufferEXT,(GLenum a,GLuint b),(a,b))

-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glBindRenderbufferEXT,(GLenum a,GLuint b),(a,b))

-GL_FUNC(GL_EXT_framebuffer_object,false,GLenum,glCheckFramebufferStatusEXT,(GLenum a),(a))

-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glDeleteRenderbuffersEXT,(GLsizei a,const GLuint *b),(a,b))

-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferRenderbufferEXT,(GLenum a,GLenum b,GLenum c,GLuint d),(a,b,c,d))

-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferTexture2DEXT,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e),(a,b,c,d,e))

-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferTexture3DEXT,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e,GLint f),(a,b,c,d,e,f))

-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glGenFramebuffersEXT,(GLsizei a,GLuint *b),(a,b))

-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glGenRenderbuffersEXT,(GLsizei a,GLuint *b),(a,b))

-GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glDeleteFramebuffersEXT,(GLsizei a,const GLuint *b),(a,b))

-GL_EXT(GL_EXT_framebuffer_blit,-1,-1)

-GL_FUNC_VOID(GL_EXT_framebuffer_blit,false,glBlitFramebufferEXT,(GLint a,GLint b,GLint c,GLint d,GLint e,GLint f,GLint g,GLint h,GLbitfield i,GLenum j),(a,b,c,d,e,f,g,h,i,j))

-GL_EXT(GL_EXT_framebuffer_multisample,-1,-1)

-GL_FUNC_VOID(GL_EXT_framebuffer_multisample,false,glRenderbufferStorageMultisampleEXT,(GLenum a,GLsizei b,GLenum c,GLsizei d,GLsizei e),(a,b,c,d,e))

-GL_EXT(GL_APPLE_fence,-1,-1)

-GL_FUNC(GL_APPLE_fence,false,GLboolean,glTestFenceAPPLE,(GLuint a),(a))

-GL_FUNC_VOID(GL_APPLE_fence,false,glSetFenceAPPLE,(GLuint a),(a))

-GL_FUNC_VOID(GL_APPLE_fence,false,glFinishFenceAPPLE,(GLuint a),(a))

-GL_FUNC_VOID(GL_APPLE_fence,false,glDeleteFencesAPPLE,(GLsizei a,const GLuint *b),(a,b))

-GL_FUNC_VOID(GL_APPLE_fence,false,glGenFencesAPPLE,(GLsizei a,GLuint *b),(a,b))

-GL_EXT(GL_NV_fence,-1,-1)

-GL_FUNC(GL_NV_fence,false,GLboolean,glTestFenceNV,(GLuint a),(a))

-GL_FUNC_VOID(GL_NV_fence,false,glSetFenceNV,(GLuint a,GLenum b),(a,b))

-GL_FUNC_VOID(GL_NV_fence,false,glFinishFenceNV,(GLuint a),(a))

-GL_FUNC_VOID(GL_NV_fence,false,glDeleteFencesNV,(GLsizei a,const GLuint *b),(a,b))

-GL_FUNC_VOID(GL_NV_fence,false,glGenFencesNV,(GLsizei a,GLuint *b),(a,b))

-GL_EXT(GL_ARB_sync,3,2)

-#ifdef HAVE_GL_ARB_SYNC

-GL_FUNC_VOID(GL_ARB_sync,false,glGetSynciv,(GLsync a, GLenum b, GLsizei c, GLsizei *d, GLint *e),(a,b,c,d,e))

-GL_FUNC(GL_ARB_sync,false,GLenum,glClientWaitSync,(GLsync a, GLbitfield b, GLuint64 c),(a,b,c))

-GL_FUNC_VOID(GL_ARB_sync,false,glWaitSync,(GLsync a, GLbitfield b, GLuint64 c),(a,b,c))

-GL_FUNC_VOID(GL_ARB_sync,false,glDeleteSync,(GLsync a),(a))

-GL_FUNC(GL_ARB_sync,false,GLsync,glFenceSync,(GLenum a, GLbitfield b),(a,b))

-#endif

-GL_EXT(GL_EXT_draw_buffers2,-1,-1)

-GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glColorMaskIndexedEXT,(GLuint a,GLboolean b,GLboolean c,GLboolean d,GLboolean e),(a,b,c,d,e))

-GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glEnableIndexedEXT,(GLenum a,GLuint b),(a,b))

-GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glDisableIndexedEXT,(GLenum a,GLuint b),(a,b))

-GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glGetBooleanIndexedvEXT,(GLenum a,GLuint b,GLboolean  *c),(a,b,c))

-GL_EXT(GL_EXT_bindable_uniform,-1,-1)

-GL_FUNC_VOID(GL_EXT_bindable_uniform,false,glUniformBufferEXT,(GLuint a,GLint b,GLuint c),(a,b,c))

-GL_EXT(GL_APPLE_flush_buffer_range,-1,-1)

-GL_FUNC_VOID(GL_APPLE_flush_buffer_range,false,glBufferParameteriAPPLE,(GLenum a,GLenum b,GLint c),(a,b,c))

-GL_FUNC_VOID(GL_APPLE_flush_buffer_range,false,glFlushMappedBufferRangeAPPLE,(GLenum a,GLintptr b,GLsizeiptr c),(a,b,c))

-GL_EXT(GL_ARB_map_buffer_range,-1,-1)

-GL_FUNC(GL_ARB_map_buffer_range,false,void*,glMapBufferRange,(GLenum a,GLintptr b,GLsizeiptr c,GLbitfield d),(a,b,c,d))

-GL_FUNC_VOID(GL_ARB_map_buffer_range,false,glFlushMappedBufferRange,(GLenum a,GLintptr b,GLsizeiptr c),(a,b,c))

-GL_EXT(GL_ARB_occlusion_query,-1,-1)

-GL_FUNC_VOID(GL_ARB_occlusion_query,false,glBeginQueryARB,(GLenum a,GLuint b),(a,b))

-GL_FUNC_VOID(GL_ARB_occlusion_query,false,glEndQueryARB,(GLenum a),(a))

-GL_FUNC_VOID(GL_ARB_occlusion_query,false,glGetQueryObjectivARB,(GLuint a,GLenum b,GLint *c),(a,b,c))

-GL_FUNC_VOID(GL_ARB_occlusion_query,false,glGetQueryObjectuivARB,(GLuint a,GLenum b,GLuint *c),(a,b,c))

-GL_EXT(GL_APPLE_texture_range,-1,-1)

-GL_FUNC_VOID(GL_APPLE_texture_range,false,glTextureRangeAPPLE,(GLenum a,GLsizei b,void *c),(a,b,c))

-GL_FUNC_VOID(GL_APPLE_texture_range,false,glGetTexParameterPointervAPPLE,(GLenum a,GLenum b,void* *c),(a,b,c))

-GL_EXT(GL_APPLE_client_storage,-1,-1)

-GL_EXT(GL_ARB_uniform_buffer,-1,-1)

-GL_EXT(GL_ARB_vertex_array_bgra,-1,-1)

-GL_EXT(GL_EXT_vertex_array_bgra,-1,-1)

-GL_EXT(GL_ARB_framebuffer_object,3,0)

-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBindFramebuffer,(GLenum a,GLuint b),(a,b))

-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBindRenderbuffer,(GLenum a,GLuint b),(a,b))

-GL_FUNC(GL_ARB_framebuffer_object,false,GLenum,glCheckFramebufferStatus,(GLenum a),(a))

-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glDeleteRenderbuffers,(GLsizei a,const GLuint *b),(a,b))

-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferRenderbuffer,(GLenum a,GLenum b,GLenum c,GLuint d),(a,b,c,d))

-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferTexture2D,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e),(a,b,c,d,e))

-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferTexture3D,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e,GLint f),(a,b,c,d,e,f))

-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glGenFramebuffers,(GLsizei a,GLuint *b),(a,b))

-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glGenRenderbuffers,(GLsizei a,GLuint *b),(a,b))

-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glDeleteFramebuffers,(GLsizei a,const GLuint *b),(a,b))

-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBlitFramebuffer,(GLint a,GLint b,GLint c,GLint d,GLint e,GLint f,GLint g,GLint h,GLbitfield i,GLenum j),(a,b,c,d,e,f,g,h,i,j))

-GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glRenderbufferStorageMultisample,(GLenum a,GLsizei b,GLenum c,GLsizei d,GLsizei e),(a,b,c,d,e))

-GL_EXT(GL_GREMEDY_string_marker,-1,-1)

-GL_FUNC_VOID(GL_GREMEDY_string_marker,false,glStringMarkerGREMEDY,(GLsizei a,const void *b),(a,b))

-GL_FUNC_VOID(OpenGL,true,glPushClientAttrib,(GLbitfield a),(a))

-GL_FUNC_VOID(OpenGL,true,glPopClientAttrib,(void),())

-

+// !!! FIXME: Some of these aren't base OpenGL...pick out the extensions.
+// !!! FIXME: Also, look up these -1, -1 versions numbers.
+GL_FUNC(OpenGL,true,GLenum,glGetError,(void),())
+GL_FUNC_VOID(OpenGL,true,glActiveTexture,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glAlphaFunc,(GLenum a,GLclampf b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glAttachObjectARB,(GLhandleARB a,GLhandleARB b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBegin,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glBindAttribLocationARB,(GLhandleARB a,GLuint b,const GLcharARB *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glBindBufferARB,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBindProgramARB,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBindTexture,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBlendColor,(GLclampf a,GLclampf b,GLclampf c,GLclampf d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glBlendEquation,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glBlendFunc,(GLenum a,GLenum b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glBufferDataARB,(GLenum a,GLsizeiptrARB b,const GLvoid *c,GLenum d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glClear,(GLbitfield a),(a))
+GL_FUNC_VOID(OpenGL,true,glClearColor,(GLclampf a,GLclampf b,GLclampf c,GLclampf d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glClearDepth,(GLclampd a),(a))
+GL_FUNC_VOID(OpenGL,true,glClearStencil,(GLint a),(a))
+GL_FUNC_VOID(OpenGL,true,glClipPlane,(GLenum a,const GLdouble *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glColorMask,(GLboolean a,GLboolean b,GLboolean c,GLboolean d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glCompileShaderARB,(GLhandleARB a),(a))
+GL_FUNC_VOID(OpenGL,true,glCompressedTexImage2D,(GLenum a,GLint b,GLenum c,GLsizei d,GLsizei e,GLint f,GLsizei g,const GLvoid *h),(a,b,c,d,e,f,g,h))
+GL_FUNC_VOID(OpenGL,true,glCompressedTexImage3D,(GLenum a,GLint b,GLenum c,GLsizei d,GLsizei e,GLsizei f,GLint g,GLsizei h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
+GL_FUNC(OpenGL,true,GLhandleARB,glCreateProgramObjectARB,(void),())
+GL_FUNC(OpenGL,true,GLhandleARB,glCreateShaderObjectARB,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDeleteBuffersARB,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDeleteObjectARB,(GLhandleARB a),(a))
+GL_FUNC_VOID(OpenGL,true,glDeleteProgramsARB,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDeleteQueriesARB,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDeleteShader,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glDeleteTextures,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDepthFunc,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDepthMask,(GLboolean a),(a))
+GL_FUNC_VOID(OpenGL,true,glDepthRange,(GLclampd a,GLclampd b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDetachObjectARB,(GLhandleARB a,GLhandleARB b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glDisable,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDisableVertexAttribArray,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glDrawArrays,(GLenum a,GLint b,GLsizei c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glDrawBuffer,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDrawRangeElements,(GLenum a,GLuint b,GLuint c,GLsizei d,GLenum e,const GLvoid *f),(a,b,c,d,e,f))
+GL_FUNC_VOID(OpenGL,true,glEnable,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glEnableVertexAttribArray,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glEnd,(void),())
+GL_FUNC_VOID(OpenGL,true,glFinish,(void),())
+GL_FUNC_VOID(OpenGL,true,glFlush,(void),())
+GL_FUNC_VOID(OpenGL,true,glFrontFace,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glGenBuffersARB,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGenProgramsARB,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGenQueriesARB,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGenTextures,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetBooleanv,(GLenum a,GLboolean *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetCompressedTexImage,(GLenum a,GLint b,GLvoid *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glGetDoublev,(GLenum a,GLdouble *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetFloatv,(GLenum a,GLfloat *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetInfoLogARB,(GLhandleARB a,GLsizei b,GLsizei *c,GLcharARB *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glGetIntegerv,(GLenum a,GLint *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glGetObjectParameterivARB,(GLhandleARB a,GLenum b,GLint *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glGetProgramivARB,(GLenum a,GLenum b,GLint *c),(a,b,c))
+GL_FUNC(OpenGL,true,const GLubyte *,glGetString,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glGetTexImage,(GLenum a,GLint b,GLenum c,GLenum d,GLvoid *e),(a,b,c,d,e))
+GL_FUNC(OpenGL,true,GLint,glGetUniformLocationARB,(GLhandleARB a,const GLcharARB *b),(a,b))
+GL_FUNC(OpenGL,true,GLboolean,glIsEnabled,(GLenum a),(a))
+GL_FUNC(OpenGL,true,GLboolean,glIsTexture,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glLinkProgramARB,(GLhandleARB a),(a))
+GL_FUNC(OpenGL,true,GLvoid*,glMapBufferARB,(GLenum a,GLenum b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glOrtho,(GLdouble a,GLdouble b,GLdouble c,GLdouble d,GLdouble e,GLdouble f),(a,b,c,d,e,f))
+GL_FUNC_VOID(OpenGL,true,glPixelStorei,(GLenum a,GLint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glPolygonMode,(GLenum a,GLenum b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glPolygonOffset,(GLfloat a,GLfloat b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glPopAttrib,(void),())
+GL_FUNC_VOID(OpenGL,true,glProgramStringARB,(GLenum a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glPushAttrib,(GLbitfield a),(a))
+GL_FUNC_VOID(OpenGL,true,glReadBuffer,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glScissor,(GLint a,GLint b,GLsizei c,GLsizei d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glShaderSourceARB,(GLhandleARB a,GLsizei b,const GLcharARB **c,const GLint *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glStencilFunc,(GLenum a,GLint b,GLuint c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glStencilMask,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glStencilOp,(GLenum a,GLenum b,GLenum c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glTexCoord2f,(GLfloat a,GLfloat b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glTexImage2D,(GLenum a,GLint b,GLint c,GLsizei d,GLsizei e,GLint f,GLenum g,GLenum h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
+GL_FUNC_VOID(OpenGL,true,glTexImage3D,(GLenum a,GLint b,GLint c,GLsizei d,GLsizei e,GLsizei f,GLint g,GLenum h,GLenum i,const GLvoid *j),(a,b,c,d,e,f,g,h,i,j))
+GL_FUNC_VOID(OpenGL,true,glTexParameterfv,(GLenum a,GLenum b,const GLfloat *c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glTexParameteri,(GLenum a,GLenum b,GLint c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glTexSubImage2D,(GLenum a,GLint b,GLint c,GLint d,GLsizei e,GLsizei f,GLenum g,GLenum h,const GLvoid *i),(a,b,c,d,e,f,g,h,i))
+GL_FUNC_VOID(OpenGL,true,glUniform1f,(GLint a,GLfloat b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glUniform1i,(GLint a,GLint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glUniform1iARB,(GLint a,GLint b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glUniform4fv,(GLint a,GLsizei b,const GLfloat *c),(a,b,c))
+GL_FUNC(OpenGL,true,GLboolean,glUnmapBuffer,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glUseProgram,(GLuint a),(a))
+GL_FUNC_VOID(OpenGL,true,glVertex3f,(GLfloat a,GLfloat b,GLfloat c),(a,b,c))
+GL_FUNC_VOID(OpenGL,true,glVertexAttribPointer,(GLuint a,GLint b,GLenum c,GLboolean d,GLsizei e,const GLvoid *f),(a,b,c,d,e,f))
+GL_FUNC_VOID(OpenGL,true,glViewport,(GLint a,GLint b,GLsizei c,GLsizei d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glEnableClientState,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glDisableClientState,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glClientActiveTexture,(GLenum a),(a))
+GL_FUNC_VOID(OpenGL,true,glVertexPointer,(GLint a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glTexCoordPointer,(GLint a,GLenum b,GLsizei c,const GLvoid *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glProgramEnvParameters4fvEXT,(GLenum a,GLuint b,GLsizei c,const GLfloat *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glColor4sv,(const GLshort  *a),(a))
+GL_FUNC_VOID(OpenGL,true,glStencilOpSeparate,(GLenum a,GLenum b,GLenum c,GLenum d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glStencilFuncSeparate,(GLenum a,GLenum b,GLint c,GLuint d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glGetTexLevelParameteriv,(GLenum a,GLint b,GLenum c,GLint *d),(a,b,c,d))
+GL_FUNC_VOID(OpenGL,true,glColor4f,(GLfloat a,GLfloat b,GLfloat c,GLfloat d),(a,b,c,d))
+GL_EXT(GL_EXT_framebuffer_object,-1,-1)
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glBindFramebufferEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glBindRenderbufferEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC(GL_EXT_framebuffer_object,false,GLenum,glCheckFramebufferStatusEXT,(GLenum a),(a))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glDeleteRenderbuffersEXT,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferRenderbufferEXT,(GLenum a,GLenum b,GLenum c,GLuint d),(a,b,c,d))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferTexture2DEXT,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e),(a,b,c,d,e))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glFramebufferTexture3DEXT,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e,GLint f),(a,b,c,d,e,f))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glGenFramebuffersEXT,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glGenRenderbuffersEXT,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_EXT_framebuffer_object,false,glDeleteFramebuffersEXT,(GLsizei a,const GLuint *b),(a,b))
+GL_EXT(GL_EXT_framebuffer_blit,-1,-1)
+GL_FUNC_VOID(GL_EXT_framebuffer_blit,false,glBlitFramebufferEXT,(GLint a,GLint b,GLint c,GLint d,GLint e,GLint f,GLint g,GLint h,GLbitfield i,GLenum j),(a,b,c,d,e,f,g,h,i,j))
+GL_EXT(GL_EXT_framebuffer_multisample,-1,-1)
+GL_FUNC_VOID(GL_EXT_framebuffer_multisample,false,glRenderbufferStorageMultisampleEXT,(GLenum a,GLsizei b,GLenum c,GLsizei d,GLsizei e),(a,b,c,d,e))
+GL_EXT(GL_APPLE_fence,-1,-1)
+GL_FUNC(GL_APPLE_fence,false,GLboolean,glTestFenceAPPLE,(GLuint a),(a))
+GL_FUNC_VOID(GL_APPLE_fence,false,glSetFenceAPPLE,(GLuint a),(a))
+GL_FUNC_VOID(GL_APPLE_fence,false,glFinishFenceAPPLE,(GLuint a),(a))
+GL_FUNC_VOID(GL_APPLE_fence,false,glDeleteFencesAPPLE,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_APPLE_fence,false,glGenFencesAPPLE,(GLsizei a,GLuint *b),(a,b))
+GL_EXT(GL_NV_fence,-1,-1)
+GL_FUNC(GL_NV_fence,false,GLboolean,glTestFenceNV,(GLuint a),(a))
+GL_FUNC_VOID(GL_NV_fence,false,glSetFenceNV,(GLuint a,GLenum b),(a,b))
+GL_FUNC_VOID(GL_NV_fence,false,glFinishFenceNV,(GLuint a),(a))
+GL_FUNC_VOID(GL_NV_fence,false,glDeleteFencesNV,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_NV_fence,false,glGenFencesNV,(GLsizei a,GLuint *b),(a,b))
+GL_EXT(GL_ARB_sync,3,2)
+#ifdef HAVE_GL_ARB_SYNC
+GL_FUNC_VOID(GL_ARB_sync,false,glGetSynciv,(GLsync a, GLenum b, GLsizei c, GLsizei *d, GLint *e),(a,b,c,d,e))
+GL_FUNC(GL_ARB_sync,false,GLenum,glClientWaitSync,(GLsync a, GLbitfield b, GLuint64 c),(a,b,c))
+GL_FUNC_VOID(GL_ARB_sync,false,glWaitSync,(GLsync a, GLbitfield b, GLuint64 c),(a,b,c))
+GL_FUNC_VOID(GL_ARB_sync,false,glDeleteSync,(GLsync a),(a))
+GL_FUNC(GL_ARB_sync,false,GLsync,glFenceSync,(GLenum a, GLbitfield b),(a,b))
+#endif
+GL_EXT(GL_EXT_draw_buffers2,-1,-1)
+GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glColorMaskIndexedEXT,(GLuint a,GLboolean b,GLboolean c,GLboolean d,GLboolean e),(a,b,c,d,e))
+GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glEnableIndexedEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glDisableIndexedEXT,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_EXT_draw_buffers2,false,glGetBooleanIndexedvEXT,(GLenum a,GLuint b,GLboolean  *c),(a,b,c))
+GL_EXT(GL_EXT_bindable_uniform,-1,-1)
+GL_FUNC_VOID(GL_EXT_bindable_uniform,false,glUniformBufferEXT,(GLuint a,GLint b,GLuint c),(a,b,c))
+GL_EXT(GL_APPLE_flush_buffer_range,-1,-1)
+GL_FUNC_VOID(GL_APPLE_flush_buffer_range,false,glBufferParameteriAPPLE,(GLenum a,GLenum b,GLint c),(a,b,c))
+GL_FUNC_VOID(GL_APPLE_flush_buffer_range,false,glFlushMappedBufferRangeAPPLE,(GLenum a,GLintptr b,GLsizeiptr c),(a,b,c))
+GL_EXT(GL_ARB_map_buffer_range,-1,-1)
+GL_FUNC(GL_ARB_map_buffer_range,false,void*,glMapBufferRange,(GLenum a,GLintptr b,GLsizeiptr c,GLbitfield d),(a,b,c,d))
+GL_FUNC_VOID(GL_ARB_map_buffer_range,false,glFlushMappedBufferRange,(GLenum a,GLintptr b,GLsizeiptr c),(a,b,c))
+GL_EXT(GL_ARB_occlusion_query,-1,-1)
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glBeginQueryARB,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glEndQueryARB,(GLenum a),(a))
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glGetQueryObjectivARB,(GLuint a,GLenum b,GLint *c),(a,b,c))
+GL_FUNC_VOID(GL_ARB_occlusion_query,false,glGetQueryObjectuivARB,(GLuint a,GLenum b,GLuint *c),(a,b,c))
+GL_EXT(GL_APPLE_texture_range,-1,-1)
+GL_FUNC_VOID(GL_APPLE_texture_range,false,glTextureRangeAPPLE,(GLenum a,GLsizei b,void *c),(a,b,c))
+GL_FUNC_VOID(GL_APPLE_texture_range,false,glGetTexParameterPointervAPPLE,(GLenum a,GLenum b,void* *c),(a,b,c))
+GL_EXT(GL_APPLE_client_storage,-1,-1)
+GL_EXT(GL_ARB_uniform_buffer,-1,-1)
+GL_EXT(GL_ARB_vertex_array_bgra,-1,-1)
+GL_EXT(GL_EXT_vertex_array_bgra,-1,-1)
+GL_EXT(GL_ARB_framebuffer_object,3,0)
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBindFramebuffer,(GLenum a,GLuint b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBindRenderbuffer,(GLenum a,GLuint b),(a,b))
+GL_FUNC(GL_ARB_framebuffer_object,false,GLenum,glCheckFramebufferStatus,(GLenum a),(a))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glDeleteRenderbuffers,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferRenderbuffer,(GLenum a,GLenum b,GLenum c,GLuint d),(a,b,c,d))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferTexture2D,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e),(a,b,c,d,e))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glFramebufferTexture3D,(GLenum a,GLenum b,GLenum c,GLuint d,GLint e,GLint f),(a,b,c,d,e,f))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glGenFramebuffers,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glGenRenderbuffers,(GLsizei a,GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glDeleteFramebuffers,(GLsizei a,const GLuint *b),(a,b))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glBlitFramebuffer,(GLint a,GLint b,GLint c,GLint d,GLint e,GLint f,GLint g,GLint h,GLbitfield i,GLenum j),(a,b,c,d,e,f,g,h,i,j))
+GL_FUNC_VOID(GL_ARB_framebuffer_object,false,glRenderbufferStorageMultisample,(GLenum a,GLsizei b,GLenum c,GLsizei d,GLsizei e),(a,b,c,d,e))
+GL_EXT(GL_GREMEDY_string_marker,-1,-1)
+GL_FUNC_VOID(GL_GREMEDY_string_marker,false,glStringMarkerGREMEDY,(GLsizei a,const void *b),(a,b))
+GL_FUNC_VOID(OpenGL,true,glPushClientAttrib,(GLbitfield a),(a))
+GL_FUNC_VOID(OpenGL,true,glPopClientAttrib,(void),())
+
diff --git a/mp/src/public/togl/osx/glmdisplay.h b/mp/src/public/togl/osx/glmdisplay.h
index c0d9e10b..cf3a3b90 100644
--- a/mp/src/public/togl/osx/glmdisplay.h
+++ b/mp/src/public/togl/osx/glmdisplay.h
@@ -1,177 +1,177 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-//

-// glmdisplay.h

-// display related stuff - used by both GLMgr and the CocoaMgr

-//

-//===============================================================================

-

-#ifndef GLMDISPLAY_H

-#define	GLMDISPLAY_H

-

-#pragma once

-

-#ifdef OSX

-#include <OpenGL/OpenGL.h>

-#include <OpenGL/gl.h>

-#include <OpenGL/glext.h>

-#include <OpenGL/CGLTypes.h>

-#include <OpenGL/CGLRenderers.h>

-#include <OpenGL/CGLCurrent.h>

-

-typedef uint32_t CGDirectDisplayID; 

-typedef uint32_t CGOpenGLDisplayMask; 

-typedef double CGRefreshRate; 

-

-//#include <ApplicationServices/ApplicationServices.h>

-#elif defined(LINUX)

-#include "tier0/platform.h"

-#include <GL/gl.h>

-#include <GL/glext.h>

-#else

-#error

-#endif

-

-typedef void _PseudoNSGLContext;					// aka NSOpenGLContext

-typedef _PseudoNSGLContext	*PseudoNSGLContextPtr;

-

-struct GLMDisplayModeInfoFields

-{

-	uint	m_modePixelWidth;

-	uint	m_modePixelHeight;

-	uint	m_modeRefreshHz;

-	// are we even going to talk about bit depth... not yet

-};

-

-struct GLMDisplayInfoFields

-{

-#ifdef OSX

-	CGDirectDisplayID				m_cgDisplayID;

-	CGOpenGLDisplayMask				m_glDisplayMask;		// result of CGDisplayIDToOpenGLDisplayMask on the cg_displayID.

-#endif

-	uint							m_displayPixelWidth;

-	uint							m_displayPixelHeight;	

-};

-

-struct GLMRendererInfoFields

-{

-	/*properties of interest and their desired values.

-	

-	   kCGLRPFullScreen          =  54,		true

-	   kCGLRPAccelerated         =  73,		true

-	   kCGLRPWindow              =  80,		true

-

-	   kCGLRPRendererID          =  70,		informational

-	   kCGLRPDisplayMask         =  84,		informational

-	   kCGLRPBufferModes         = 100,		informational

-	   kCGLRPColorModes          = 103,		informational

-	   kCGLRPAccumModes          = 104,		informational

-	   kCGLRPDepthModes          = 105,		informational

-	   kCGLRPStencilModes        = 106,		informational

-	   kCGLRPMaxAuxBuffers       = 107,		informational

-	   kCGLRPMaxSampleBuffers    = 108,		informational

-	   kCGLRPMaxSamples          = 109,		informational

-	   kCGLRPSampleModes         = 110,		informational

-	   kCGLRPSampleAlpha         = 111,		informational

-	   kCGLRPVideoMemory         = 120,		informational

-	   kCGLRPTextureMemory       = 121,		informational

-	   kCGLRPRendererCount       = 128		number of renderers in the CGLRendererInfoObj under examination

-

-	   kCGLRPOffScreen           =  53,		D/C

-	   kCGLRPRobust              =  75,		FALSE or D/C - aka we're asking for no-fallback

-	   kCGLRPBackingStore        =  76,		D/C

-	   kCGLRPMPSafe              =  78,		D/C

-	   kCGLRPMultiScreen         =  81,		D/C

-	   kCGLRPCompliant           =  83,		D/C

-	*/

-

-

-	//--------------------------- info we have from CGL renderer queries, IOKit, Gestalt

-	//--------------------------- these are set up in the displayDB by CocoaMgr

-	GLint	m_fullscreen;

-	GLint	m_accelerated;

-	GLint	m_windowed;

-	

-	GLint	m_rendererID;

-	GLint	m_displayMask;

-	GLint	m_bufferModes;

-	GLint	m_colorModes;

-	GLint	m_accumModes;

-	GLint	m_depthModes;

-	GLint	m_stencilModes;

-

-	GLint	m_maxAuxBuffers;

-	GLint	m_maxSampleBuffers;

-	GLint	m_maxSamples;

-	GLint	m_sampleModes;

-	GLint	m_sampleAlpha;

-

-	GLint	m_vidMemory;

-	GLint	m_texMemory;

-	

-	uint	m_pciVendorID;

-	uint	m_pciDeviceID;

-	char	m_pciModelString[64];

-	char	m_driverInfoString[64];

-

-	//--------------------------- OS version related - set up by CocoaMgr

-

-	// OS version found

-	uint	m_osComboVersion;			// 0x00XXYYZZ : XX major, YY minor, ZZ minor minor : 10.6.3 --> 0x000A0603.  10.5.8 --> 0x000A0508.

-		

-	//--------------------------- shorthands - also set up by CocoaMgr - driven by vendorid / deviceid

-

-	bool	m_ati;

-	bool	m_atiR5xx;

-	bool	m_atiR6xx;

-	bool	m_atiR7xx;

-	bool	m_atiR8xx;

-	bool	m_atiNewer;

-	

-	bool	m_intel;

-	bool	m_intel95x;

-	bool	m_intel3100;

-	bool	m_intelNewer;

-

-	bool	m_nv;

-	bool	m_nvG7x;

-	bool	m_nvG8x;

-	bool	m_nvNewer;

-	

-	//--------------------------- context query results - left blank in the display DB - but valid in a GLMContext (call ctx->Caps() to get a const ref)

-	

-	// booleans	

-	bool	m_hasGammaWrites;			// aka glGetBooleanv(GL_FRAMEBUFFER_SRGB_CAPABLE_EXT) / glEnable(GL_FRAMEBUFFER_SRGB_EXT)

-	bool	m_hasMixedAttachmentSizes;	// aka ARB_fbo in 10.6.3 - test for min OS vers, then exported ext string

-	bool	m_hasBGRA;					// aka GL_BGRA vertex attribs in 10.6.3 -  - test for min OS vers, then exported ext string

-	bool	m_hasNewFullscreenMode;		// aka 10.6.x "big window" fullscreen mode

-	bool	m_hasNativeClipVertexMode;	// aka GLSL gl_ClipVertex does not fall back to SW- OS version and folklore-based

-	bool	m_hasOcclusionQuery;		// occlusion query: do you speak it ?!

-	bool	m_hasFramebufferBlit;		// framebuffer blit: know what I'm sayin?!

-	bool	m_hasPerfPackage1;			// means new MTGL, fast OQ, fast uniform upload, NV can resolve flipped (late summer 2010 post 10.6.4 update)

-	

-	// counts

-	int		m_maxAniso;					// aniso limit - context query

-	

-	// other exts

-	bool	m_hasBindableUniforms;

-	bool	m_hasUniformBuffers;

-	

-	// runtime options that aren't negotiable once set

-	bool	m_hasDualShaders;			// must supply CLI arg "-glmdualshaders" or we go GLSL only

-

-	//--------------------------- " can'ts " - specific problems that need to be worked around

-

-	bool	m_cantBlitReliably;		// Intel chipsets have problems blitting sRGB sometimes

-	bool	m_cantAttachSRGB;		// NV G8x on 10.5.8 can't have srgb tex on FBO color - separate issue from hasGammaWrites

-	bool	m_cantResolveFlipped;	// happens on NV in 10.6.4 and prior - console variable "gl_can_resolve_flipped" can overrule

-	bool	m_cantResolveScaled;	// happens everywhere per GL spec but may be relaxed some day - console variable "gl_can_resolve_scaled" can overrule

-	bool	m_costlyGammaFlips;		// this means that sRGB sampling state affects shader code gen, resulting in state-dependent code regen

-

-

-	//--------------------------- " bads " - known bad drivers

-	bool	m_badDriver1064NV;		// this is the bad NVIDIA driver on 10.6.4 - stutter, tex corruption, black screen issues

-};

-

-

-

-#endif

+//
+// glmdisplay.h
+// display related stuff - used by both GLMgr and the CocoaMgr
+//
+//===============================================================================
+
+#ifndef GLMDISPLAY_H
+#define	GLMDISPLAY_H
+
+#pragma once
+
+#ifdef OSX
+#include <OpenGL/OpenGL.h>
+#include <OpenGL/gl.h>
+#include <OpenGL/glext.h>
+#include <OpenGL/CGLTypes.h>
+#include <OpenGL/CGLRenderers.h>
+#include <OpenGL/CGLCurrent.h>
+
+typedef uint32_t CGDirectDisplayID; 
+typedef uint32_t CGOpenGLDisplayMask; 
+typedef double CGRefreshRate; 
+
+//#include <ApplicationServices/ApplicationServices.h>
+#elif defined(LINUX)
+#include "tier0/platform.h"
+#include <GL/gl.h>
+#include <GL/glext.h>
+#else
+#error
+#endif
+
+typedef void _PseudoNSGLContext;					// aka NSOpenGLContext
+typedef _PseudoNSGLContext	*PseudoNSGLContextPtr;
+
+struct GLMDisplayModeInfoFields
+{
+	uint	m_modePixelWidth;
+	uint	m_modePixelHeight;
+	uint	m_modeRefreshHz;
+	// are we even going to talk about bit depth... not yet
+};
+
+struct GLMDisplayInfoFields
+{
+#ifdef OSX
+	CGDirectDisplayID				m_cgDisplayID;
+	CGOpenGLDisplayMask				m_glDisplayMask;		// result of CGDisplayIDToOpenGLDisplayMask on the cg_displayID.
+#endif
+	uint							m_displayPixelWidth;
+	uint							m_displayPixelHeight;	
+};
+
+struct GLMRendererInfoFields
+{
+	/*properties of interest and their desired values.
+	
+	   kCGLRPFullScreen          =  54,		true
+	   kCGLRPAccelerated         =  73,		true
+	   kCGLRPWindow              =  80,		true
+
+	   kCGLRPRendererID          =  70,		informational
+	   kCGLRPDisplayMask         =  84,		informational
+	   kCGLRPBufferModes         = 100,		informational
+	   kCGLRPColorModes          = 103,		informational
+	   kCGLRPAccumModes          = 104,		informational
+	   kCGLRPDepthModes          = 105,		informational
+	   kCGLRPStencilModes        = 106,		informational
+	   kCGLRPMaxAuxBuffers       = 107,		informational
+	   kCGLRPMaxSampleBuffers    = 108,		informational
+	   kCGLRPMaxSamples          = 109,		informational
+	   kCGLRPSampleModes         = 110,		informational
+	   kCGLRPSampleAlpha         = 111,		informational
+	   kCGLRPVideoMemory         = 120,		informational
+	   kCGLRPTextureMemory       = 121,		informational
+	   kCGLRPRendererCount       = 128		number of renderers in the CGLRendererInfoObj under examination
+
+	   kCGLRPOffScreen           =  53,		D/C
+	   kCGLRPRobust              =  75,		FALSE or D/C - aka we're asking for no-fallback
+	   kCGLRPBackingStore        =  76,		D/C
+	   kCGLRPMPSafe              =  78,		D/C
+	   kCGLRPMultiScreen         =  81,		D/C
+	   kCGLRPCompliant           =  83,		D/C
+	*/
+
+
+	//--------------------------- info we have from CGL renderer queries, IOKit, Gestalt
+	//--------------------------- these are set up in the displayDB by CocoaMgr
+	GLint	m_fullscreen;
+	GLint	m_accelerated;
+	GLint	m_windowed;
+	
+	GLint	m_rendererID;
+	GLint	m_displayMask;
+	GLint	m_bufferModes;
+	GLint	m_colorModes;
+	GLint	m_accumModes;
+	GLint	m_depthModes;
+	GLint	m_stencilModes;
+
+	GLint	m_maxAuxBuffers;
+	GLint	m_maxSampleBuffers;
+	GLint	m_maxSamples;
+	GLint	m_sampleModes;
+	GLint	m_sampleAlpha;
+
+	GLint	m_vidMemory;
+	GLint	m_texMemory;
+	
+	uint	m_pciVendorID;
+	uint	m_pciDeviceID;
+	char	m_pciModelString[64];
+	char	m_driverInfoString[64];
+
+	//--------------------------- OS version related - set up by CocoaMgr
+
+	// OS version found
+	uint	m_osComboVersion;			// 0x00XXYYZZ : XX major, YY minor, ZZ minor minor : 10.6.3 --> 0x000A0603.  10.5.8 --> 0x000A0508.
+		
+	//--------------------------- shorthands - also set up by CocoaMgr - driven by vendorid / deviceid
+
+	bool	m_ati;
+	bool	m_atiR5xx;
+	bool	m_atiR6xx;
+	bool	m_atiR7xx;
+	bool	m_atiR8xx;
+	bool	m_atiNewer;
+	
+	bool	m_intel;
+	bool	m_intel95x;
+	bool	m_intel3100;
+	bool	m_intelNewer;
+
+	bool	m_nv;
+	bool	m_nvG7x;
+	bool	m_nvG8x;
+	bool	m_nvNewer;
+	
+	//--------------------------- context query results - left blank in the display DB - but valid in a GLMContext (call ctx->Caps() to get a const ref)
+	
+	// booleans	
+	bool	m_hasGammaWrites;			// aka glGetBooleanv(GL_FRAMEBUFFER_SRGB_CAPABLE_EXT) / glEnable(GL_FRAMEBUFFER_SRGB_EXT)
+	bool	m_hasMixedAttachmentSizes;	// aka ARB_fbo in 10.6.3 - test for min OS vers, then exported ext string
+	bool	m_hasBGRA;					// aka GL_BGRA vertex attribs in 10.6.3 -  - test for min OS vers, then exported ext string
+	bool	m_hasNewFullscreenMode;		// aka 10.6.x "big window" fullscreen mode
+	bool	m_hasNativeClipVertexMode;	// aka GLSL gl_ClipVertex does not fall back to SW- OS version and folklore-based
+	bool	m_hasOcclusionQuery;		// occlusion query: do you speak it ?!
+	bool	m_hasFramebufferBlit;		// framebuffer blit: know what I'm sayin?!
+	bool	m_hasPerfPackage1;			// means new MTGL, fast OQ, fast uniform upload, NV can resolve flipped (late summer 2010 post 10.6.4 update)
+	
+	// counts
+	int		m_maxAniso;					// aniso limit - context query
+	
+	// other exts
+	bool	m_hasBindableUniforms;
+	bool	m_hasUniformBuffers;
+	
+	// runtime options that aren't negotiable once set
+	bool	m_hasDualShaders;			// must supply CLI arg "-glmdualshaders" or we go GLSL only
+
+	//--------------------------- " can'ts " - specific problems that need to be worked around
+
+	bool	m_cantBlitReliably;		// Intel chipsets have problems blitting sRGB sometimes
+	bool	m_cantAttachSRGB;		// NV G8x on 10.5.8 can't have srgb tex on FBO color - separate issue from hasGammaWrites
+	bool	m_cantResolveFlipped;	// happens on NV in 10.6.4 and prior - console variable "gl_can_resolve_flipped" can overrule
+	bool	m_cantResolveScaled;	// happens everywhere per GL spec but may be relaxed some day - console variable "gl_can_resolve_scaled" can overrule
+	bool	m_costlyGammaFlips;		// this means that sRGB sampling state affects shader code gen, resulting in state-dependent code regen
+
+
+	//--------------------------- " bads " - known bad drivers
+	bool	m_badDriver1064NV;		// this is the bad NVIDIA driver on 10.6.4 - stutter, tex corruption, black screen issues
+};
+
+
+
+#endif
diff --git a/mp/src/public/togl/osx/glmgr.h b/mp/src/public/togl/osx/glmgr.h
index 24f9a00d..cdf64206 100644
--- a/mp/src/public/togl/osx/glmgr.h
+++ b/mp/src/public/togl/osx/glmgr.h
@@ -1,1088 +1,1088 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-//

-// glmgr.h

-//	singleton class, common basis for managing GL contexts

-//	responsible for tracking adapters and contexts

-//

-//===============================================================================

-

-#ifndef GLMGR_H

-#define	GLMGR_H

-

-#pragma once

-

-#undef HAVE_GL_ARB_SYNC

-#ifdef LINUX

-#define HAVE_GL_ARB_SYNC 1

-#endif

-

-#include "glentrypoints.h"

-#include "glmdebug.h"

-#include "glmdisplay.h"

-#include "glmgrext.h"

-#include "glmgrbasics.h"

-#include "cglmtex.h"

-#include "cglmfbo.h"

-#include "cglmprogram.h"

-#include "cglmbuffer.h"

-#include "cglmquery.h"

-

-#include "tier0/vprof_telemetry.h"

-#include "materialsystem/ishader.h"

-#include "dxabstract_types.h"

-

-

-#ifdef LINUX

-#define Debugger DebuggerBreak

-#undef CurrentTime

-

-// prevent some conflicts in SDL headers...

-#undef M_PI

-#include <stdint.h>

-#ifndef _STDINT_H_

-#define _STDINT_H_ 1

-#endif

-

-#include "SDL/SDL.h"

-#endif

-

-//===============================================================================

-// glue to call out to Obj-C land (these are in glmgrcocoa.mm)

-#ifdef OSX

-PseudoNSGLContextPtr  GetCurrentNSGLContext( );

-CGLContextObj         GetCGLContextFromNSGL( PseudoNSGLContextPtr nsglCtx );

-#endif

-

-#include "tier0/dynfunction.h"

-

-//===============================================================================

-

-// parrot the D3D present parameters, more or less... "adapter" translates into "active display index" per the m_activeDisplayCount below.

-class GLMDisplayParams

-{

-	public:

-

-		// presumption, these indices are in sync with the current display DB that GLMgr has handy

-	//int					m_rendererIndex;		// index of renderer (-1 if root context)

-	//int					m_displayIndex;			// index of display in renderer - for FS

-	//int					m_modeIndex;			// index of mode in display - for FS

-

-	void				*m_focusWindow;			// (VD3DHWND aka WindowRef) - what window does this context display into

-	

-	bool				m_fsEnable;				// fullscreen on or not

-	bool				m_vsyncEnable;			// vsync on or not

-

-	// height and width have to match the display mode info if full screen.

-	

-	uint				m_backBufferWidth;		// pixel width (aka screen h-resolution if full screen)

-	uint				m_backBufferHeight;		// pixel height (aka screen v-resolution if full screen)

-	D3DFORMAT           m_backBufferFormat;		// pixel format

-	uint				m_multiSampleCount;		// 0 means no MSAA, 2 means 2x MSAA, etc

-		// uint				m_multiSampleQuality;	// no MSAA quality control yet

-		

-	bool				m_enableAutoDepthStencil;	// generally set to 'TRUE' per CShaderDeviceDx8::SetPresentParameters

-	D3DFORMAT			m_autoDepthStencilFormat;

-	

-	uint				m_fsRefreshHz;			// if full screen, this refresh rate (likely 0 for LCD's)

-	

-	//uint				m_rootRendererID;		// only used if m_rendererIndex is -1.

-	//uint				m_rootDisplayMask;		// only used if m_rendererIndex is -1.

-

-	bool				m_mtgl;					// enable multi threaded GL driver

-};

-

-//===============================================================================

-

-class GLMgr

-{

-public:

-	

-	//===========================================================================

-	// class methods - singleton

-	static void		NewGLMgr( void );			// instantiate singleton..

-	static GLMgr	*aGLMgr( void );			// return singleton..

-	static void		DelGLMgr( void );			// tear down singleton..

-

-	//===========================================================================

-	// plain methods

-

-					#if 0				// turned all these off while new approach is coded

-						void			RefreshDisplayDB( void );	// blow away old display DB, make a new one

-						GLMDisplayDB	*GetDisplayDB( void );		// get a ptr to the one GLMgr keeps.  only valid til next refresh.

-

-							// eligible renderers will be ranked by desirability starting at index 0 within the db

-							// within each renderer, eligible displays will be ranked some kind of desirability (area? dist from menu bar?) 

-							// within each display, eligible modes will be ranked by descending areas

-						

-							// calls supplying indices are implicitly making reference to the current DB

-						bool			CaptureDisplay( int rendIndex, int displayIndex, bool captureAll );		// capture one display or all displays

-						void			ReleaseDisplays( void );												// release all captures

-						

-						int				GetDisplayMode( int rendIndex, int displayIndex );						// retrieve current display res (returns modeIndex)

-						void			SetDisplayMode( GLMDisplayParams *params );								// set the display res (only useful for FS)

-					#endif

-	

-	GLMContext		*NewContext( GLMDisplayParams *params );		// this will have to change

-	void			DelContext( GLMContext *context );

-

-		// with usage of CGLMacro.h we could dispense with the "current context" thing

-		// and just declare a member variable of GLMContext, allowing each glXXX call to be routed directly

-		// to the correct context

-	void		SetCurrentContext( GLMContext *context );	// make current in calling thread only

-	GLMContext	*GetCurrentContext( void );

-		

-protected:

-	friend class GLMContext;

-

-	GLMgr();

-	~GLMgr();

-};

-

-

-//===========================================================================//

-

-// helper function to do enable or disable in one step

-inline void glSetEnable( GLenum which, bool enable )

-{

-	if (enable)

-		gGL->glEnable(which);

-	else

-		gGL->glDisable(which);

-}

-

-// helper function for int vs enum clarity

-inline void glGetEnumv( GLenum which, GLenum *dst )

-{

-	gGL->glGetIntegerv( which, (int*)dst );

-}

-

-//===========================================================================//

-//

-// types to support the GLMContext

-//

-//===========================================================================//

-

-// Each state set/get path we are providing caching for, needs its own struct and a comparison operator.

-// we also provide an enum of how many such types there are, handy for building dirty masks etc.

-

-// shorthand macros

-#define	EQ(fff) ( (src.fff) == (fff) )

-

-//rasterizer

-struct GLAlphaTestEnable_t		{ GLint		enable;													bool operator==(const GLAlphaTestEnable_t& src)		const { return EQ(enable);									} };

-struct GLAlphaTestFunc_t		{ GLenum	func; GLclampf ref;										bool operator==(const GLAlphaTestFunc_t& src)		const { return EQ(func) && EQ(ref);							} };

-struct GLCullFaceEnable_t		{ GLint		enable;													bool operator==(const GLCullFaceEnable_t& src)		const { return EQ(enable);									} };

-struct GLCullFrontFace_t		{ GLenum	value;													bool operator==(const GLCullFrontFace_t& src)		const { return EQ(value);									} };

-struct GLPolygonMode_t			{ GLenum	values[2];												bool operator==(const GLPolygonMode_t& src)			const { return EQ(values[0]) && EQ(values[1]);				} };

-struct GLDepthBias_t			{ GLfloat	factor;		GLfloat units;								bool operator==(const GLDepthBias_t& src)			const { return EQ(factor) && EQ(units);						} };

-struct GLScissorEnable_t		{ GLint		enable;													bool operator==(const GLScissorEnable_t& src)		const { return EQ(enable);									} };

-struct GLScissorBox_t			{ GLint		x,y;		GLsizei width, height;						bool operator==(const GLScissorBox_t& src)			const { return EQ(x) && EQ(y) && EQ(width) && EQ(height);	} };

-struct GLAlphaToCoverageEnable_t{ GLint		enable;													bool operator==(const GLAlphaToCoverageEnable_t& src) const { return EQ(enable);								} };

-struct GLViewportBox_t			{ GLint		x,y;		GLsizei width, height;						bool operator==(const GLViewportBox_t& src)			const { return EQ(x) && EQ(y) && EQ(width) && EQ(height);	} };

-struct GLViewportDepthRange_t	{ GLdouble	near,far;												bool operator==(const GLViewportDepthRange_t& src)	const { return EQ(near) && EQ(far);							} };

-struct GLClipPlaneEnable_t		{ GLint		enable;													bool operator==(const GLClipPlaneEnable_t& src)		const { return EQ(enable);									} };

-struct GLClipPlaneEquation_t	{ GLfloat	x,y,z,w;												bool operator==(const GLClipPlaneEquation_t& src)	const { return EQ(x) && EQ(y) && EQ(z) && EQ(w);			} };

-

-//blend

-struct GLColorMaskSingle_t		{ char		r,g,b,a;												bool operator==(const GLColorMaskSingle_t& src)		const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };

-struct GLColorMaskMultiple_t	{ char		r,g,b,a;												bool operator==(const GLColorMaskMultiple_t& src)	const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };

-struct GLBlendEnable_t			{ GLint		enable;													bool operator==(const GLBlendEnable_t& src)			const { return EQ(enable);									} };

-struct GLBlendFactor_t			{ GLenum	srcfactor,dstfactor;									bool operator==(const GLBlendFactor_t& src)			const { return EQ(srcfactor) && EQ(dstfactor);				} };

-struct GLBlendEquation_t		{ GLenum	equation;												bool operator==(const GLBlendEquation_t& src)		const { return EQ(equation);								} };

-struct GLBlendColor_t			{ GLfloat	r,g,b,a;												bool operator==(const GLBlendColor_t& src)			const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };

-struct GLBlendEnableSRGB_t		{ GLint		enable;													bool operator==(const GLBlendEnableSRGB_t& src)		const { return EQ(enable);									} };

-

-//depth

-struct GLDepthTestEnable_t		{ GLint		enable;													bool operator==(const GLDepthTestEnable_t& src)		const { return EQ(enable);									} };

-struct GLDepthFunc_t			{ GLenum	func;													bool operator==(const GLDepthFunc_t& src)			const { return EQ(func);									} };

-struct GLDepthMask_t			{ char		mask;													bool operator==(const GLDepthMask_t& src)			const { return EQ(mask);									} };

-

-//stencil

-struct GLStencilTestEnable_t	{ GLint		enable;													bool operator==(const GLStencilTestEnable_t& src)	const { return EQ(enable);									} };

-struct GLStencilFunc_t			{ GLenum	frontfunc, backfunc;	GLint ref;  GLuint mask;		bool operator==(const GLStencilFunc_t& src)			const { return EQ(frontfunc) && EQ(backfunc) && EQ(ref) && EQ(mask); } };

-struct GLStencilOp_t			{ GLenum	sfail;	GLenum dpfail; GLenum dppass;					bool operator==(const GLStencilOp_t& src)			const { return EQ(sfail) && EQ(dpfail) && EQ(dppass);		} };

-struct GLStencilWriteMask_t		{ GLint		mask;													bool operator==(const GLStencilWriteMask_t& src)	const { return EQ(mask);									} };

-

-//clearing

-struct GLClearColor_t			{  GLfloat	r,g,b,a;												bool operator==(const GLClearColor_t& src)			const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };

-struct GLClearDepth_t			{  GLdouble	d;														bool operator==(const GLClearDepth_t& src)			const { return EQ(d);										} };

-struct GLClearStencil_t			{  GLint	s;														bool operator==(const GLClearStencil_t& src)		const { return EQ(s);										} };

-

-#undef EQ

-

-enum EGLMStateBlockType

-{

-	kGLAlphaTestEnable,

-	kGLAlphaTestFunc,

-	

-	kGLCullFaceEnable,

-	kGLCullFrontFace,

-

-	kGLPolygonMode,

-

-	kGLDepthBias,

-	

-	kGLScissorEnable,

-	kGLScissorBox,

-

-	kGLViewportBox,

-	kGLViewportDepthRange,

-	

-	kGLClipPlaneEnable,

-	kGLClipPlaneEquation,

-	

-	kGLColorMaskSingle,

-	kGLColorMaskMultiple,

-

-	kGLBlendEnable,

-	kGLBlendFactor,	

-	kGLBlendEquation,

-	kGLBlendColor,

-	kGLBlendEnableSRGB,

-

-	kGLDepthTestEnable,

-	kGLDepthFunc,

-	kGLDepthMask,

-

-	kGLStencilTestEnable,

-	kGLStencilFunc,

-	kGLStencilOp,	

-	kGLStencilWriteMask,

-

-	kGLClearColor,

-	kGLClearDepth,

-	kGLClearStencil,

-

-	kGLAlphaToCoverageEnable,

-	

-	kGLMStateBlockLimit

-};

-

-//===========================================================================//

-

-// templated functions representing GL R/W bottlenecks

-// one set of set/get/getdefault is instantiated for each of the GL*** types above.

-

-// use these from the non array state objects

-template<typename T>	void GLContextSet( T *src );

-template<typename T>	void GLContextGet( T *dst );

-template<typename T>	void GLContextGetDefault( T *dst );

-

-// use these from the array state objects

-template<typename T>	void GLContextSetIndexed( T *src, int index );

-template<typename T>	void GLContextGetIndexed( T *dst, int index );

-template<typename T>	void GLContextGetDefaultIndexed( T *dst, int index );

-

-//===========================================================================//

-

-// caching state object template.  One of these is instantiated in the context per unique struct type above

-template<typename T> class GLState

-{

-	public:

-	

-		GLState<T>()

-		{

-			dirty = false;

-			memset( &data, 0, sizeof(data) );

-		};

-

-		// write: client src into cache

-		// common case is both false.  dirty is calculated, context write is deferred.

-		void	Write( T *src, bool noCompare=false, bool noDefer=false )

-		{

-			if (noCompare)

-			{

-				dirty = true;

-			}

-			else

-			{

-				// only == is implemented, so test for equal and negate

-				// note, you only set dirty if mismatch, you never clear it until flush

-				if ( !(data == *src) )

-				{

-					dirty = true;

-				}

-			}

-			

-			data = *src;

-			

-			if (noDefer)

-			{

-				Flush( true );	// dirty becomes false

-			}

-		};

-		

-		// write cache->context if dirty or forced.

-		void Flush( bool noDefer=false )

-		{

-			if (dirty || noDefer)

-			{

-				GLContextSet( &data );

-				GLMCheckError();

-					// good place for some error checking here

-				dirty = false;

-			}

-		};

-		

-		// default: write default value to cache, optionally write through

-		void Default( bool noDefer=false )

-		{

-			GLContextGetDefault( &data );	// read default values directly to our cache copy

-			dirty = true;

-			Flush(noDefer);

-		};

-

-		// read: sel = 0 for cache, 1 for context

-		void Read( T *dst, int sel )

-		{

-			if (sel==0)

-			{

-				*dst = data;

-			}

-			else

-			{

-				GLContextGet( dst );

-				GLMCheckError();

-			}

-		};

-		

-		// check: verify that context equals cache, return true if mismatched or if illegal values seen

-		bool Check ( void )

-		{

-			T		temp;

-			bool	result;

-

-			GLContextGet( &temp );

-			GLMCheckError();

-			result = !(temp == data);

-			return result;

-		};

-		

-	protected:

-		T		data;

-		bool	dirty;

-};

-

-// caching state object template - with multiple values behind it that are indexed

-template<typename T, int COUNT> class GLStateArray

-{

-	public:

-	

-		GLStateArray<T,COUNT>()

-		{

-			memset( &dirty, 0, sizeof(dirty) );

-			memset( &data, 0, sizeof(data) );

-		};

-

-		// write: client src into cache

-		// common case is both false.  dirty is calculated, context write is deferred.

-		void WriteIndex( T *src, int index, bool noCompare=false, bool noDefer=false )

-		{

-			if (noCompare)

-			{

-				dirty[index] = true;

-			}

-			else

-			{

-				// only == is implemented, so test for equal and negate

-				// note, you only set dirty if mismatch, you never clear it until flush

-				if (! (data[index] == *src) )

-				{

-					dirty[index] = true;

-				}

-			}

-			

-			data[index] = *src;

-			

-			if (noDefer)

-			{

-				FlushIndex( index, true );	// dirty becomes false

-			}

-		};

-		

-		// write cache->context if dirty or forced.

-		void FlushIndex( int index, bool noDefer=false )

-		{

-			if (dirty[index] || noDefer)

-			{

-				GLContextSetIndexed( &data[index], index );

-				GLMCheckError();

-				dirty[index] = false;

-			}

-		};

-		

-		// write all slots in the array

-		void Flush( bool noDefer=false )

-		{

-			for( int i=0; i<COUNT; i++)

-			{

-				FlushIndex( i, noDefer );

-			}

-		}

-		

-		// default: write default value to cache, optionally write through

-		void DefaultIndex( int index, bool noDefer=false )

-		{

-			GLContextGetDefaultIndexed( &data[index], index );	// read default values directly to our cache copy

-			dirty[index] = true;

-			Flush(noDefer);

-		};

-		

-		void Default( void )

-		{

-			for( int i=0; i<COUNT; i++)

-			{

-				DefaultIndex( i );

-			}			

-		}

-

-		// read: sel = 0 for cache, 1 for context

-		void ReadIndex( T *dst, int index, int sel )

-		{

-			if (sel==0)

-			{

-				*dst = data[index];

-			}

-			else

-			{

-				GLContextGetIndexed( dst, index );

-				GLMCheckError();

-			}

-		};

-		

-		// check: verify that context equals cache, return true if mismatched or if illegal values seen

-		bool CheckIndex( int index )

-		{

-			T		temp;

-			bool	result;

-

-			GLContextGetIndexed( &temp, index );

-			GLMCheckError();

-			result = !(temp == data[index]);

-			

-			return result;

-		};

-

-		bool Check( void )

-		{

-			T		temp;

-			bool	result = false;

-

-			for( int i=0; i<COUNT; i++)

-			{

-				result |= CheckIndex( i );

-			}

-			

-			return result;

-		};

-		

-	protected:

-		T		data	[COUNT];

-		bool	dirty	[COUNT];

-};

-

-

-//===========================================================================//

-

-struct	GLMTexSampler

-{

-	GLMTexSamplingParams	m_samp;

-	CGLMTex					*m_drawTex;		// tex which must be bound at time of draw

-	CGLMTex					*m_boundTex;	// tex which is actually bound now (if does not match, a rebind is needed to draw)

-};

-

-#ifdef NEVER

-//===========================================================================//

-

-enum	GLMVertexAttributeIndex

-{

-	kGLMGenericAttr00 = 0,

-	kGLMGenericAttr01,

-	kGLMGenericAttr02,

-	kGLMGenericAttr03,

-	kGLMGenericAttr04,

-	kGLMGenericAttr05,

-	kGLMGenericAttr06,

-	kGLMGenericAttr07,

-	kGLMGenericAttr08,

-	kGLMGenericAttr09,

-	kGLMGenericAttr10,

-	kGLMGenericAttr11,

-	kGLMGenericAttr12,

-	kGLMGenericAttr13,

-	kGLMGenericAttr14,

-	kGLMGenericAttr15,

-

-	kGLMVertexAttributeIndexMax			// ideally < 32

-};

-

-struct GLMVertexAttributeDesc			// all the info you need to do vertex setup for one attribute

-{

-	CGLMBuffer				*m_buffer;	// NULL allowed in which case m_offset is the full 32-bit pointer.. so you can draw from plain RAM if desired

-	GLuint					m_datasize;	// comp count of the attribute (1-4)

-	GLenum					m_datatype;	// data type of the attribute (GL_FLOAT, GL_UNSIGNED_BYTE, etc)

-	GLuint					m_stride;

-	GLuint					m_offset;	// net offset to attribute 'zero' within the buffer.

-	GLboolean				m_normalized;	// apply to any fixed point data that needs normalizing, esp color bytes

-	

-		// may need a seed value at some point to be able to disambiguate re-lifed buffers holding same pointer

-		// simpler alternative is to do shoot-down inside the vertex/index buffer free calls.

-		// I'd rather not have to have each attribute fiddling a ref count on the buffer to which it refers..

-

-#define	EQ(fff) ( (src.fff) == (fff) )

-	// test in decreasing order of likelihood of difference, but do not include the buffer revision as caller is not supplying it..

-	bool operator==(const GLMVertexAttributeDesc& src)		const { return EQ(m_buffer) && EQ(m_offset) && EQ(m_stride) && EQ(m_datatype) && EQ(m_normalized) && EQ(m_datasize);	}

-#undef EQ

-

-	uint					m_bufferRevision;	// only set in GLM context's copy, to disambiguate references that are same offset / same buffer but cross an orphan event

-};

-

-// GLMContext will maintain one of these structures inside the context to represent the current state.

-// Client can supply a new one when it wants to change the setup.

-//FIXME GLMContext can do the work to migrate from old setup to new setup as efficiently as possible (but it doesn't yet)

-#endif

-

-struct GLMVertexSetup

-{

-	uint	m_attrMask;					// which attrs are enabled (1<<n) mask where n is a GLMVertexAttributeIndex.

-	

-	GLMVertexAttributeDesc	m_attrs[ kGLMVertexAttributeIndexMax ];

-

-	// copied in from dxabstract, not strictly needed for operation, helps debugging

-	unsigned char	m_vtxAttribMap[16];

-

-		/* high nibble is usage per _D3DDECLUSAGE

-			typedef enum _D3DDECLUSAGE

-			{

-				D3DDECLUSAGE_POSITION		= 0,

-				D3DDECLUSAGE_BLENDWEIGHT	= 1,

-				D3DDECLUSAGE_BLENDINDICES	= 2,

-				D3DDECLUSAGE_NORMAL			= 3,

-				D3DDECLUSAGE_PSIZE			= 4,

-				D3DDECLUSAGE_TEXCOORD		= 5,

-				D3DDECLUSAGE_TANGENT		= 6,

-				D3DDECLUSAGE_BINORMAL		= 7,

-				D3DDECLUSAGE_TESSFACTOR		= 8,

-				D3DDECLUSAGE_PLUGH			= 9,	// mystery value

-				D3DDECLUSAGE_COLOR			= 10,

-				D3DDECLUSAGE_FOG			= 11,

-				D3DDECLUSAGE_DEPTH			= 12,

-				D3DDECLUSAGE_SAMPLE			= 13,

-			} D3DDECLUSAGE;

-		

-			low nibble is usageindex (i.e. POSITION0, POSITION1, etc)

-			array position is attrib number.

-		*/

-};

-

-//===========================================================================//

-

-//FIXME magic numbers here

-

-#define	kGLMProgramParamFloat4Limit	256

-#define	kGLMProgramParamBoolLimit	16

-#define	kGLMProgramParamInt4Limit	16

-

-#define	kGLMVertexProgramParamFloat4Limit	256

-#define	kGLMFragmentProgramParamFloat4Limit	32

-

-struct GLMProgramParamsF

-{

-	float	m_values[kGLMProgramParamFloat4Limit][4];		// float4's 256 of them

-	uint	m_dirtySlotCount;								// index of slot past highest dirty (assume 0 for base of range)

-};

-

-struct GLMProgramParamsB

-{

-	int		m_values[kGLMProgramParamBoolLimit];			// bools, 4 of them

-	uint	m_dirtySlotCount;

-};

-

-struct GLMProgramParamsI

-{

-	int		m_values[kGLMProgramParamInt4Limit][4];			// int4s, 16 of them

-	uint	m_dirtySlotCount;

-};

-

-enum EGLMParamWriteMode

-{

-	eParamWriteAllSlots,			// glUniform4fv of the maximum size	(not recommended if shader is down-sizing the decl)

-	eParamWriteShaderSlots,			// glUniform4fv of the active slot count ("highwater")

-	eParamWriteShaderSlotsOptional,	// glUniform4fv of the active slot count ("highwater") - but only if at least one has been written - it's optional

-	eParamWriteDirtySlotRange		// glUniform4fv of the 0-N range where N is highest dirty slot

-};

-

-enum EGLMAttribWriteMode

-{

-	eAttribWriteAll,

-	eAttribWriteDirty

-};

-

-//===========================================================================//

-

-#if GLMDEBUG

-enum EGLMDebugCallSite

-{

-	eBeginFrame,		// inside begin frame func - frame number has been inc'd, batch number should be -1

-	eClear,				// inside clear func

-	eDrawElements,		// inside repeat loop, prior to draw call - batch numberhas been inc'd

-	eEndFrame,			// end frame

-	ePresent			// before showing pixels

-};

-

-// caller should zero one of these out and fill in the m_caller before invoking the hook

-struct GLMDebugHookInfo

-{

-		// info from the caller to the debug hook

-	EGLMDebugCallSite	m_caller;

-

-	

-		// state the hook uses to keep track of progress within a single run of the caller		

-	int					m_iteration;	// which call to the hook is this.  if it's zero, it precedes any action in the caller.

-

-	

-		// bools used to communicate between caller and hook

-	bool				m_loop;			// hook tells caller to loop around again (don't exit)

-	bool				m_holding;		// current mood of hook, are we holding on this batch (i.e. rerun)

-	

-		// specific info for a draw call

-	GLenum				m_drawMode;

-	GLuint				m_drawStart;

-	GLuint				m_drawEnd;

-	GLsizei				m_drawCount;

-	GLenum				m_drawType;

-	const GLvoid		*m_drawIndices;

-};

-#endif

-

-//===========================================================================//

-

-#define	kGLMUserClipPlanes			2

-#define kGLMScratchFBOCount			4

-

-class	GLMContext

-{

-	public:

-		// set/check current context (perq for many other calls)

-		void	MakeCurrent( bool bRenderThread = false );

-		void	ReleaseCurrent( bool bRenderThread = false );

-

-		// CheckCurrent has been removed (it no longer compiled). To minimize churn I'm leaving

-		// the inline NOP version.

-		// DO NOT change this to non-inlined. It's called all over the place from very hot codepaths.

-		FORCEINLINE void CheckCurrent( void ) { }

-		

-		void							PopulateCaps( void );	// fill out later portions of renderer info record which need context queries

-		void							DumpCaps( void );		// printf all the caps info (you can call this in release too)

-		const GLMRendererInfoFields&	Caps( void );			// peek at the caps record

-	

-		// state cache/mirror

-		void	SetDefaultStates( void );

-		void	FlushStates( bool noDefer = false );

-		void	VerifyStates( void );

-

-		// textures

-		// Lock and Unlock reqs go directly to the tex object

-		CGLMTex	*NewTex( GLMTexLayoutKey *key, char *debugLabel=NULL );

-		void	DelTex( CGLMTex	*tex );	

-

-			// options for Blit (replacement for ResolveTex and BlitTex)

-			// pass NULL for dstTex if you want to target GL_BACK with the blit.  You get y-flip with that, don't change the dstrect yourself.		

-		void	Blit2( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, uint filter );

-

-			// tex blit (via FBO blit)

-		void	BlitTex( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, uint filter, bool useBlitFB = true );

-

-			//	MSAA resolve - we do this in GLMContext because it has to do a bunch of FBO/blit gymnastics

-		void	ResolveTex( CGLMTex *tex, bool forceDirty=false );	

-		

-			// texture pre-load (residency forcing) - normally done one-time but you can force it

-		void	PreloadTex( CGLMTex *tex, bool force=false );

-

-		// samplers

-		void	SetSamplerTex( int sampler, CGLMTex *tex );

-		void	SetSamplerParams( int sampler, GLMTexSamplingParams *params );

-

-		// render targets (FBO's)

-		CGLMFBO	*NewFBO( void );

-		void	DelFBO( CGLMFBO *fbo );		

-		void	SetDrawingFBO( CGLMFBO *fbo );	// as with samplers, the notion of the target FBO is latched til draw time and then checked

-

-		// programs

-		CGLMProgram	*NewProgram( EGLMProgramType type, char *progString );

-		void	DelProgram( CGLMProgram *prog );

-		void	NullProgram( void );											// de-ac all shader state

-		

-		void	SetDrawingProgram( EGLMProgramType type, CGLMProgram *prog );	// set NULL for no program

-		void	SetDrawingLang( EGLMProgramLang lang, bool immediate=false );	// choose ARB or GLSL.  immediate=false defers lang change to top of frame

-		

-		void	LinkShaderPair( CGLMProgram *vp, CGLMProgram *fp );			// ensure this combo has been linked and is in the GLSL pair cache

-		void	ClearShaderPairCache( void );								// call this to shoot down all the linked pairs

-		void	QueryShaderPair( int index, GLMShaderPairInfo *infoOut );	// this lets you query the shader pair cache for saving its state

-		

-		// buffers

-		// Lock and Unlock reqs go directly to the buffer object

-		CGLMBuffer	*NewBuffer( EGLMBufferType type, uint size, uint options );

-		void	DelBuffer( CGLMBuffer *buff );

-

-		void	SetIndexBuffer( CGLMBuffer *buff );		

-		void	SetVertexAttributes( GLMVertexSetup *setup );

-			// note, no API is exposed for setting a single attribute source.

-			// come prepared with a complete block of attributes to use.

-			

-		// Queries

-		CGLMQuery	*NewQuery( GLMQueryParams *params );

-		void		DelQuery( CGLMQuery *query );

-			

-		// "slot" means a vec4-sized thing

-		// these write into .env parameter space

-		void	SetProgramParametersF( EGLMProgramType type, uint baseSlot, float *slotData, uint slotCount );	// take vec4f's

-		void	SetProgramParametersB( EGLMProgramType type, uint baseSlot, int  *slotData, uint boolCount );	// take "BOOL" aka int

-		void	SetProgramParametersI( EGLMProgramType type, uint baseSlot, int  *slotData, uint slotCount );	// take int4s

-

-		// state sync

-		void	FlushDrawStates( bool shadersOn=true );				// pushes all drawing state - samplers, tex, programs, etc.

-		

-		// drawing

-		void	DrawRangeElements(	GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices );

-		void	CheckNative( void );

-		

-		// clearing

-		void	Clear( bool color, unsigned long colorValue, bool depth, float depthValue, bool stencil, unsigned int stencilValue, GLScissorBox_t *rect = NULL );

-		

-		// display

-		//void	SetVSyncEnable( bool vsyncOn );

-		//void	SetFullScreen( bool fsOn, int screenIndex );		// will be latched for next BeginFrame

-		//void	ActivateFullScreen( bool fsOn, int screenIndex );	// will be called by BeginFrame

-		bool	SetDisplayParams( GLMDisplayParams *params );		// either the first time setup, or a change to new setup

-		

-		void	Present( CGLMTex *tex );		// somewhat hardwired for the time being

-

-		// mode switch / reset

-		void	Reset( void );							// not a lot of args for now..

-		

-		// writers for the state block inputs

-		

-		void	WriteAlphaTestEnable		( GLAlphaTestEnable_t *src );

-		void	WriteAlphaTestFunc			( GLAlphaTestFunc_t *src );

-		void	WriteCullFaceEnable			( GLCullFaceEnable_t *src );

-		void	WriteCullFrontFace			( GLCullFrontFace_t *src );

-		void	WritePolygonMode			( GLPolygonMode_t *src );

-		void	WriteDepthBias				( GLDepthBias_t *src );

-		void	WriteClipPlaneEnable		( GLClipPlaneEnable_t *src, int which );

-		void	WriteClipPlaneEquation		( GLClipPlaneEquation_t *src, int which );

-		void	WriteScissorEnable			( GLScissorEnable_t *src );

-		void	WriteScissorBox				( GLScissorBox_t *src );

-		void	WriteAlphaToCoverageEnable	( GLAlphaToCoverageEnable_t *src );

-		void	WriteViewportBox			( GLViewportBox_t *src );

-		void	WriteViewportDepthRange		( GLViewportDepthRange_t *src );

-		void	WriteColorMaskSingle		( GLColorMaskSingle_t *src );

-		void	WriteColorMaskMultiple		( GLColorMaskMultiple_t *src, int which );

-		void	WriteBlendEnable			( GLBlendEnable_t *src );

-		void	WriteBlendFactor			( GLBlendFactor_t *src );

-		void	WriteBlendEquation			( GLBlendEquation_t *src );

-		void	WriteBlendColor				( GLBlendColor_t *src );

-		void	WriteBlendEnableSRGB		( GLBlendEnableSRGB_t *src );

-		void	WriteDepthTestEnable		( GLDepthTestEnable_t *src );

-		void	WriteDepthFunc				( GLDepthFunc_t *src );

-		void	WriteDepthMask				( GLDepthMask_t *src );

-		void	WriteStencilTestEnable		( GLStencilTestEnable_t *src );

-		void	WriteStencilFunc			( GLStencilFunc_t *src );

-		void	WriteStencilOp				( GLStencilOp_t *src, int which );

-		void	WriteStencilWriteMask		( GLStencilWriteMask_t *src );

-		void	WriteClearColor				( GLClearColor_t *src );

-		void	WriteClearDepth				( GLClearDepth_t *src );

-		void	WriteClearStencil			( GLClearStencil_t *src );

-

-

-		// debug stuff

-		void	BeginFrame( void );

-		void	EndFrame( void );

-		

-		// new interactive debug stuff

-#if GLMDEBUG

-		void	DebugDump( GLMDebugHookInfo *info, uint options, uint vertDumpMode );

-		void	DebugHook( GLMDebugHookInfo *info );

-		void	DebugPresent( void );

-		void	DebugClear( void );

-#endif

-

-		FORCEINLINE DWORD GetCurrentOwnerThreadId() const { return m_nCurOwnerThreadId; }

-		

-	protected:

-		friend class GLMgr;				// only GLMgr can make GLMContext objects

-		friend class GLMRendererInfo;	// only GLMgr can make GLMContext objects

-		friend class CGLMTex;			// tex needs to be able to do binds

-		friend class CGLMFBO;			// fbo needs to be able to do binds

-		friend class CGLMProgram;

-		friend class CGLMShaderPair;

-		friend class CGLMShaderPairCache;

-		friend class CGLMBuffer;

-		friend class GLMTester;			// tester class needs access back into GLMContext

-		

-		friend class IDirect3D9;

-		friend class IDirect3DDevice9;

-		

-		// methods------------------------------------------

-		

-				// old GLMContext( GLint displayMask, GLint rendererID, PseudoNSGLContextPtr nsglShareCtx );

-				GLMContext( GLMDisplayParams *params );

-				~GLMContext();

-		

-		// textures

-		void	SelectTMU( int tmu );																// wrapper for glActiveTexture()

-		int		BindTexToTMU( CGLMTex *tex, int tmu, bool noCheck=false );

-		

-		// render targets / FBO's

-		void	BindFBOToCtx( CGLMFBO *fbo, GLenum bindPoint = GL_FRAMEBUFFER_EXT );				// you can also choose GL_READ_FRAMEBUFFER_EXT / GL_DRAW_FRAMEBUFFER_EXT

-		

-		// programs

-		//void	BindProgramToCtx( EGLMProgramType type, CGLMProgram *prog );						// will set program mode enable appropriately

-

-		// buffers

-		void	BindBufferToCtx( EGLMBufferType type, CGLMBuffer *buff, bool force = false );		// does not twiddle any enables.

-

-		// debug font

-		void	GenDebugFontTex( void );

-		void	DrawDebugText( float x, float y, float z, float drawCharWidth, float drawCharHeight, char *string );

-		

-		// members------------------------------------------

-		

-		// context

-		DWORD							m_nCurOwnerThreadId;

-

-		GLMRendererInfoFields			m_caps;

-	

-		bool							m_displayParamsValid;		// is there a param block copied in yet

-		GLMDisplayParams				m_displayParams;			// last known display config, either via constructor, or by SetDisplayParams...

-		

-#if defined(USE_SDL)

-		int								m_pixelFormatAttribs[100];	// more than enough

-		void *							m_ctx;

-#endif

-

-		// texture form table

-		CGLMTexLayoutTable				*m_texLayoutTable;

-

-		// context state mirrors

-

-		GLState<GLAlphaTestEnable_t>	m_AlphaTestEnable;

-		

-		GLState<GLAlphaTestFunc_t>		m_AlphaTestFunc;

-		

-		GLState<GLCullFaceEnable_t>		m_CullFaceEnable;			

-		GLState<GLCullFrontFace_t>		m_CullFrontFace;	

-		GLState<GLPolygonMode_t>		m_PolygonMode;

-		

-		GLState<GLDepthBias_t>			m_DepthBias;		

-

-		GLStateArray<GLClipPlaneEnable_t,kGLMUserClipPlanes>	m_ClipPlaneEnable;

-		GLStateArray<GLClipPlaneEquation_t,kGLMUserClipPlanes>	m_ClipPlaneEquation;	// dxabstract puts them directly into param slot 253(0) and 254(1)

-		

-		GLState<GLScissorEnable_t>		m_ScissorEnable;	

-		GLState<GLScissorBox_t>			m_ScissorBox;

-

-		GLState<GLAlphaToCoverageEnable_t> m_AlphaToCoverageEnable;	

-		

-		GLState<GLViewportBox_t>		m_ViewportBox;		

-		GLState<GLViewportDepthRange_t>	m_ViewportDepthRange;

-		

-		GLState<GLColorMaskSingle_t>	m_ColorMaskSingle;	

-		GLStateArray<GLColorMaskMultiple_t,8>	m_ColorMaskMultiple;	// need an official constant for the color buffers limit

-		

-		GLState<GLBlendEnable_t>		m_BlendEnable;		

-		GLState<GLBlendFactor_t>		m_BlendFactor;		

-		GLState<GLBlendEquation_t>		m_BlendEquation;	

-		GLState<GLBlendColor_t>			m_BlendColor;		

-		GLState<GLBlendEnableSRGB_t>	m_BlendEnableSRGB;		// write to this one to transmit intent to write SRGB encoded pixels to drawing FB

-		bool							m_FakeBlendEnableSRGB;	// writes to above will be shunted here if fake SRGB is in effect.

-		

-		GLState<GLDepthTestEnable_t>	m_DepthTestEnable;	

-		GLState<GLDepthFunc_t>			m_DepthFunc;		

-		GLState<GLDepthMask_t>			m_DepthMask;		

-		

-		GLState<GLStencilTestEnable_t>	m_StencilTestEnable;	// global stencil test enable

-		GLState<GLStencilFunc_t>		m_StencilFunc;			// holds front and back stencil funcs

-		GLStateArray<GLStencilOp_t,2>	m_StencilOp;			// indexed: 0=front 1=back

-		GLState<GLStencilWriteMask_t>	m_StencilWriteMask;		

-		

-		GLState<GLClearColor_t>			m_ClearColor;		

-		GLState<GLClearDepth_t>			m_ClearDepth;		

-		GLState<GLClearStencil_t>		m_ClearStencil;		

-		

-		// texture bindings and sampler setup

-		int								m_activeTexture;		// mirror for glActiveTexture

-		GLMTexSampler					m_samplers[GLM_SAMPLER_COUNT];

-	

-		// texture lock tracking - CGLMTex objects share usage of this

-		CUtlVector< GLMTexLockDesc >	m_texLocks;

-		

-		// render target binding - check before draw

-		// similar to tex sampler mechanism, we track "bound" from "chosen for drawing" separately,

-		// so binding for creation/setup need not disrupt any notion of what will be used at draw time

-		

-		CGLMFBO							*m_boundDrawFBO;		// FBO on GL_DRAW_FRAMEBUFFER bind point

-		CGLMFBO							*m_boundReadFBO;		// FBO on GL_READ_FRAMEBUFFER bind point

-																// ^ both are set if you bind to GL_FRAMEBUFFER_EXT

-		

-		CGLMFBO							*m_drawingFBO;			// what FBO should be bound at draw time (to both read/draw bp's).

-

-		CGLMFBO							*m_blitReadFBO;

-		CGLMFBO							*m_blitDrawFBO;			// scratch FBO's for framebuffer blit

-		

-		CGLMFBO							*m_scratchFBO[ kGLMScratchFBOCount ];	// general purpose FBO's for internal use

-		

-		CUtlVector< CGLMFBO* >			m_fboTable;				// each live FBO goes in the table

-		

-		// program bindings

-		EGLMProgramLang					m_drawingLangAtFrameStart;	// selector for start of frame (spills into m_drawingLang)

-		EGLMProgramLang					m_drawingLang;				// selector for which language we desire to draw with on the next batch

-		CGLMProgram						*m_drawingProgram[ kGLMNumProgramTypes ];

-		

-		GLMProgramParamsF				m_programParamsF[ kGLMNumProgramTypes ];

-		GLMProgramParamsB				m_programParamsB[ kGLMNumProgramTypes ];	// two banks, but only the vertex one is used

-		GLMProgramParamsI				m_programParamsI[ kGLMNumProgramTypes ];	// two banks, but only the vertex one is used

-		EGLMParamWriteMode				m_paramWriteMode;

-		

-		CGLMProgram						*m_nullFragmentProgram;		// write opaque black.  Activate when caller asks for null FP

-

-		CGLMProgram						*m_preloadTexVertexProgram;			// programs to help preload textures (dummies)

-		CGLMProgram						*m_preload2DTexFragmentProgram;

-		CGLMProgram						*m_preload3DTexFragmentProgram;

-		CGLMProgram						*m_preloadCubeTexFragmentProgram;

-

-		CGLMProgram						*m_boundProgram[ kGLMNumProgramTypes ];

-

-		CGLMShaderPairCache				*m_pairCache;				// GLSL only

-		CGLMShaderPair					*m_boundPair;				// GLSL only

-		uint							m_boundPairRevision;		// GLSL only

-		GLhandleARB						m_boundPairProgram;			// GLSL only

-

-		// buffer bindings

-		CGLMBuffer						*m_lastKnownBufferBinds[ kGLMNumBufferTypes ];				// tracked per bind point for dupe-bind-absorb

-		GLMVertexAttributeDesc			m_lastKnownVertexAttribs[ kGLMVertexAttributeIndexMax ];	// tracked per attrib for dupe-set-absorb

-		uint							m_lastKnownVertexAttribMask;								// tracked for dupe-enable-absorb

-		

-		CGLMBuffer						*m_drawIndexBuffer;	// ... ? do we need dupe tracking for index buffer setup? ?

-		

-		GLMVertexSetup					m_drawVertexSetup;

-

-		EGLMAttribWriteMode				m_attribWriteMode;

-		

-		bool							m_slowCheckEnable;		// turn this on or no native checking is done ("-glmassertslow" or "-glmsspewslow")

-		bool							m_slowAssertEnable;		// turn this on to assert on a non-native batch	"-glmassertslow"

-		bool							m_slowSpewEnable;	// turn this on to log non-native batches to stdout "-glmspewslow"

-		

-		// debug font texture

-		CGLMTex							*m_debugFontTex;		// might be NULL unless you call GenDebugFontTex

-		CGLMBuffer						*m_debugFontIndices;	// up to 1024 indices (256 chars times 4)

-		CGLMBuffer						*m_debugFontVertices;	// up to 1024 verts

-

-		// batch/frame debugging support

-		int								m_debugFrameIndex;			// init to -1. Increment at BeginFrame

-		int								m_debugBatchIndex;			// init to -1. Increment at any draw call

-

-#if GLMDEBUG

-		// interactive (DebugHook) debug support

-

-			// using these you can implement frame advance, batch single step, and batch rewind (let it run til next frame and hold on prev batch #)

-		int								m_holdFrameBegin;		// -1 if no hold req'd, otherwise # of frame to hold at (at beginframe time)

-		int								m_holdFrameEnd;			// -1 if no hold req'd, otherwise # of frame to hold at (at endframe time)

-

-		int								m_holdBatch,m_holdBatchFrame;	// -1 if no hold, else # of batch&frame to hold at (both must be set)

-																// these can be expired/cleared to -1 if the frame passes without a hit

-																// may be desirable to re-pause in that event, as user was expecting a hold to occur

-

-		bool							m_debugDelayEnable;		// allow sleep delay

-		uint							m_debugDelay;			// sleep time per hook call in microseconds (for usleep())

-		

-			// pre-draw global toggles / options

-		bool							m_autoClearColor,m_autoClearDepth,m_autoClearStencil;

-		float							m_autoClearColorValues[4];

-		

-			// debug knobs

-		int								m_selKnobIndex;

-		float							m_selKnobMinValue,m_selKnobMaxValue,m_selKnobIncrement;

-#endif

-

-};

-

-struct GLMTestParams

-{

-	GLMContext	*m_ctx;

-	int			*m_testList;			// -1 termed

-	

-	bool		m_glErrToDebugger;

-	bool		m_glErrToConsole;

-	

-	bool		m_intlErrToDebugger;

-	bool		m_intlErrToConsole;

-	

-	int			m_frameCount;			// how many frames to test.

-};

-

-class GLMTester

-{

-	public:

-	

-	GLMTester(GLMTestParams *params);

-	~GLMTester();

-	

-

-	// optionally callable by test routines to get basic drawables wired up

-	void	StdSetup( void );

-	void	StdCleanup( void );

-	

-	// callable by test routines to clear the frame or present it

-	void	Clear( void );

-	void	Present( int seed );

-

-	// error reporting

-	void	CheckGLError( char *comment );					// obey m_params setting for console / debugger response

-	void	InternalError( int errcode, char *comment );	// if errcode!=0, obey m_params setting for console / debugger response

-	

-	void	RunTests();

-

-	void	RunOneTest( int testindex );

-

-	// test routines themselves

-	void	Test0();

-	void	Test1();

-	void	Test2();

-	void	Test3();

-

-	GLMTestParams	m_params;		// copy of caller's params, do not mutate...

-	

-	// std-setup stuff

-	int				m_drawWidth, m_drawHeight;

-	CGLMFBO			*m_drawFBO;

-	CGLMTex			*m_drawColorTex;

-	CGLMTex			*m_drawDepthTex;

-};

-

-class CShowPixelsParams

-{

-public:

-	GLuint					m_srcTexName;

-	int						m_width,m_height;

-	bool					m_vsyncEnable;

-	bool					m_fsEnable;		// want receiving view to be full screen.  for now, just target the main screen.  extend later.

-	bool					m_useBlit;		// use FBO blit - sending context says it is available.

-	bool					m_noBlit;		// the back buffer has already been populated by the caller (perhaps via direct MSAA resolve from multisampled RT tex)

-	bool					m_onlySyncView;	// react to full/windowed state change only, do not present bits

-};

-

-

-#define	kMaxCrawlFrames	100

-#define	kMaxCrawlText		(kMaxCrawlFrames * 256)

-class CStackCrawlParams

-{

-	public:

-	uint					m_frameLimit;							// input: max frames to retrieve

-	uint					m_frameCount;							// output: frames found

-	void					*m_crawl[kMaxCrawlFrames];				// call site addresses

-	char					*m_crawlNames[kMaxCrawlFrames];			// pointers into text following, one per decoded name

-	char					m_crawlText[kMaxCrawlText];

-};

-

-#endif

+//
+// glmgr.h
+//	singleton class, common basis for managing GL contexts
+//	responsible for tracking adapters and contexts
+//
+//===============================================================================
+
+#ifndef GLMGR_H
+#define	GLMGR_H
+
+#pragma once
+
+#undef HAVE_GL_ARB_SYNC
+#ifdef LINUX
+#define HAVE_GL_ARB_SYNC 1
+#endif
+
+#include "glentrypoints.h"
+#include "glmdebug.h"
+#include "glmdisplay.h"
+#include "glmgrext.h"
+#include "glmgrbasics.h"
+#include "cglmtex.h"
+#include "cglmfbo.h"
+#include "cglmprogram.h"
+#include "cglmbuffer.h"
+#include "cglmquery.h"
+
+#include "tier0/vprof_telemetry.h"
+#include "materialsystem/ishader.h"
+#include "dxabstract_types.h"
+
+
+#ifdef LINUX
+#define Debugger DebuggerBreak
+#undef CurrentTime
+
+// prevent some conflicts in SDL headers...
+#undef M_PI
+#include <stdint.h>
+#ifndef _STDINT_H_
+#define _STDINT_H_ 1
+#endif
+
+#include "SDL/SDL.h"
+#endif
+
+//===============================================================================
+// glue to call out to Obj-C land (these are in glmgrcocoa.mm)
+#ifdef OSX
+PseudoNSGLContextPtr  GetCurrentNSGLContext( );
+CGLContextObj         GetCGLContextFromNSGL( PseudoNSGLContextPtr nsglCtx );
+#endif
+
+#include "tier0/dynfunction.h"
+
+//===============================================================================
+
+// parrot the D3D present parameters, more or less... "adapter" translates into "active display index" per the m_activeDisplayCount below.
+class GLMDisplayParams
+{
+	public:
+
+		// presumption, these indices are in sync with the current display DB that GLMgr has handy
+	//int					m_rendererIndex;		// index of renderer (-1 if root context)
+	//int					m_displayIndex;			// index of display in renderer - for FS
+	//int					m_modeIndex;			// index of mode in display - for FS
+
+	void				*m_focusWindow;			// (VD3DHWND aka WindowRef) - what window does this context display into
+	
+	bool				m_fsEnable;				// fullscreen on or not
+	bool				m_vsyncEnable;			// vsync on or not
+
+	// height and width have to match the display mode info if full screen.
+	
+	uint				m_backBufferWidth;		// pixel width (aka screen h-resolution if full screen)
+	uint				m_backBufferHeight;		// pixel height (aka screen v-resolution if full screen)
+	D3DFORMAT           m_backBufferFormat;		// pixel format
+	uint				m_multiSampleCount;		// 0 means no MSAA, 2 means 2x MSAA, etc
+		// uint				m_multiSampleQuality;	// no MSAA quality control yet
+		
+	bool				m_enableAutoDepthStencil;	// generally set to 'TRUE' per CShaderDeviceDx8::SetPresentParameters
+	D3DFORMAT			m_autoDepthStencilFormat;
+	
+	uint				m_fsRefreshHz;			// if full screen, this refresh rate (likely 0 for LCD's)
+	
+	//uint				m_rootRendererID;		// only used if m_rendererIndex is -1.
+	//uint				m_rootDisplayMask;		// only used if m_rendererIndex is -1.
+
+	bool				m_mtgl;					// enable multi threaded GL driver
+};
+
+//===============================================================================
+
+class GLMgr
+{
+public:
+	
+	//===========================================================================
+	// class methods - singleton
+	static void		NewGLMgr( void );			// instantiate singleton..
+	static GLMgr	*aGLMgr( void );			// return singleton..
+	static void		DelGLMgr( void );			// tear down singleton..
+
+	//===========================================================================
+	// plain methods
+
+					#if 0				// turned all these off while new approach is coded
+						void			RefreshDisplayDB( void );	// blow away old display DB, make a new one
+						GLMDisplayDB	*GetDisplayDB( void );		// get a ptr to the one GLMgr keeps.  only valid til next refresh.
+
+							// eligible renderers will be ranked by desirability starting at index 0 within the db
+							// within each renderer, eligible displays will be ranked some kind of desirability (area? dist from menu bar?) 
+							// within each display, eligible modes will be ranked by descending areas
+						
+							// calls supplying indices are implicitly making reference to the current DB
+						bool			CaptureDisplay( int rendIndex, int displayIndex, bool captureAll );		// capture one display or all displays
+						void			ReleaseDisplays( void );												// release all captures
+						
+						int				GetDisplayMode( int rendIndex, int displayIndex );						// retrieve current display res (returns modeIndex)
+						void			SetDisplayMode( GLMDisplayParams *params );								// set the display res (only useful for FS)
+					#endif
+	
+	GLMContext		*NewContext( GLMDisplayParams *params );		// this will have to change
+	void			DelContext( GLMContext *context );
+
+		// with usage of CGLMacro.h we could dispense with the "current context" thing
+		// and just declare a member variable of GLMContext, allowing each glXXX call to be routed directly
+		// to the correct context
+	void		SetCurrentContext( GLMContext *context );	// make current in calling thread only
+	GLMContext	*GetCurrentContext( void );
+		
+protected:
+	friend class GLMContext;
+
+	GLMgr();
+	~GLMgr();
+};
+
+
+//===========================================================================//
+
+// helper function to do enable or disable in one step
+inline void glSetEnable( GLenum which, bool enable )
+{
+	if (enable)
+		gGL->glEnable(which);
+	else
+		gGL->glDisable(which);
+}
+
+// helper function for int vs enum clarity
+inline void glGetEnumv( GLenum which, GLenum *dst )
+{
+	gGL->glGetIntegerv( which, (int*)dst );
+}
+
+//===========================================================================//
+//
+// types to support the GLMContext
+//
+//===========================================================================//
+
+// Each state set/get path we are providing caching for, needs its own struct and a comparison operator.
+// we also provide an enum of how many such types there are, handy for building dirty masks etc.
+
+// shorthand macros
+#define	EQ(fff) ( (src.fff) == (fff) )
+
+//rasterizer
+struct GLAlphaTestEnable_t		{ GLint		enable;													bool operator==(const GLAlphaTestEnable_t& src)		const { return EQ(enable);									} };
+struct GLAlphaTestFunc_t		{ GLenum	func; GLclampf ref;										bool operator==(const GLAlphaTestFunc_t& src)		const { return EQ(func) && EQ(ref);							} };
+struct GLCullFaceEnable_t		{ GLint		enable;													bool operator==(const GLCullFaceEnable_t& src)		const { return EQ(enable);									} };
+struct GLCullFrontFace_t		{ GLenum	value;													bool operator==(const GLCullFrontFace_t& src)		const { return EQ(value);									} };
+struct GLPolygonMode_t			{ GLenum	values[2];												bool operator==(const GLPolygonMode_t& src)			const { return EQ(values[0]) && EQ(values[1]);				} };
+struct GLDepthBias_t			{ GLfloat	factor;		GLfloat units;								bool operator==(const GLDepthBias_t& src)			const { return EQ(factor) && EQ(units);						} };
+struct GLScissorEnable_t		{ GLint		enable;													bool operator==(const GLScissorEnable_t& src)		const { return EQ(enable);									} };
+struct GLScissorBox_t			{ GLint		x,y;		GLsizei width, height;						bool operator==(const GLScissorBox_t& src)			const { return EQ(x) && EQ(y) && EQ(width) && EQ(height);	} };
+struct GLAlphaToCoverageEnable_t{ GLint		enable;													bool operator==(const GLAlphaToCoverageEnable_t& src) const { return EQ(enable);								} };
+struct GLViewportBox_t			{ GLint		x,y;		GLsizei width, height;						bool operator==(const GLViewportBox_t& src)			const { return EQ(x) && EQ(y) && EQ(width) && EQ(height);	} };
+struct GLViewportDepthRange_t	{ GLdouble	near,far;												bool operator==(const GLViewportDepthRange_t& src)	const { return EQ(near) && EQ(far);							} };
+struct GLClipPlaneEnable_t		{ GLint		enable;													bool operator==(const GLClipPlaneEnable_t& src)		const { return EQ(enable);									} };
+struct GLClipPlaneEquation_t	{ GLfloat	x,y,z,w;												bool operator==(const GLClipPlaneEquation_t& src)	const { return EQ(x) && EQ(y) && EQ(z) && EQ(w);			} };
+
+//blend
+struct GLColorMaskSingle_t		{ char		r,g,b,a;												bool operator==(const GLColorMaskSingle_t& src)		const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };
+struct GLColorMaskMultiple_t	{ char		r,g,b,a;												bool operator==(const GLColorMaskMultiple_t& src)	const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };
+struct GLBlendEnable_t			{ GLint		enable;													bool operator==(const GLBlendEnable_t& src)			const { return EQ(enable);									} };
+struct GLBlendFactor_t			{ GLenum	srcfactor,dstfactor;									bool operator==(const GLBlendFactor_t& src)			const { return EQ(srcfactor) && EQ(dstfactor);				} };
+struct GLBlendEquation_t		{ GLenum	equation;												bool operator==(const GLBlendEquation_t& src)		const { return EQ(equation);								} };
+struct GLBlendColor_t			{ GLfloat	r,g,b,a;												bool operator==(const GLBlendColor_t& src)			const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };
+struct GLBlendEnableSRGB_t		{ GLint		enable;													bool operator==(const GLBlendEnableSRGB_t& src)		const { return EQ(enable);									} };
+
+//depth
+struct GLDepthTestEnable_t		{ GLint		enable;													bool operator==(const GLDepthTestEnable_t& src)		const { return EQ(enable);									} };
+struct GLDepthFunc_t			{ GLenum	func;													bool operator==(const GLDepthFunc_t& src)			const { return EQ(func);									} };
+struct GLDepthMask_t			{ char		mask;													bool operator==(const GLDepthMask_t& src)			const { return EQ(mask);									} };
+
+//stencil
+struct GLStencilTestEnable_t	{ GLint		enable;													bool operator==(const GLStencilTestEnable_t& src)	const { return EQ(enable);									} };
+struct GLStencilFunc_t			{ GLenum	frontfunc, backfunc;	GLint ref;  GLuint mask;		bool operator==(const GLStencilFunc_t& src)			const { return EQ(frontfunc) && EQ(backfunc) && EQ(ref) && EQ(mask); } };
+struct GLStencilOp_t			{ GLenum	sfail;	GLenum dpfail; GLenum dppass;					bool operator==(const GLStencilOp_t& src)			const { return EQ(sfail) && EQ(dpfail) && EQ(dppass);		} };
+struct GLStencilWriteMask_t		{ GLint		mask;													bool operator==(const GLStencilWriteMask_t& src)	const { return EQ(mask);									} };
+
+//clearing
+struct GLClearColor_t			{  GLfloat	r,g,b,a;												bool operator==(const GLClearColor_t& src)			const { return EQ(r) && EQ(g) && EQ(b) && EQ(a);			} };
+struct GLClearDepth_t			{  GLdouble	d;														bool operator==(const GLClearDepth_t& src)			const { return EQ(d);										} };
+struct GLClearStencil_t			{  GLint	s;														bool operator==(const GLClearStencil_t& src)		const { return EQ(s);										} };
+
+#undef EQ
+
+enum EGLMStateBlockType
+{
+	kGLAlphaTestEnable,
+	kGLAlphaTestFunc,
+	
+	kGLCullFaceEnable,
+	kGLCullFrontFace,
+
+	kGLPolygonMode,
+
+	kGLDepthBias,
+	
+	kGLScissorEnable,
+	kGLScissorBox,
+
+	kGLViewportBox,
+	kGLViewportDepthRange,
+	
+	kGLClipPlaneEnable,
+	kGLClipPlaneEquation,
+	
+	kGLColorMaskSingle,
+	kGLColorMaskMultiple,
+
+	kGLBlendEnable,
+	kGLBlendFactor,	
+	kGLBlendEquation,
+	kGLBlendColor,
+	kGLBlendEnableSRGB,
+
+	kGLDepthTestEnable,
+	kGLDepthFunc,
+	kGLDepthMask,
+
+	kGLStencilTestEnable,
+	kGLStencilFunc,
+	kGLStencilOp,	
+	kGLStencilWriteMask,
+
+	kGLClearColor,
+	kGLClearDepth,
+	kGLClearStencil,
+
+	kGLAlphaToCoverageEnable,
+	
+	kGLMStateBlockLimit
+};
+
+//===========================================================================//
+
+// templated functions representing GL R/W bottlenecks
+// one set of set/get/getdefault is instantiated for each of the GL*** types above.
+
+// use these from the non array state objects
+template<typename T>	void GLContextSet( T *src );
+template<typename T>	void GLContextGet( T *dst );
+template<typename T>	void GLContextGetDefault( T *dst );
+
+// use these from the array state objects
+template<typename T>	void GLContextSetIndexed( T *src, int index );
+template<typename T>	void GLContextGetIndexed( T *dst, int index );
+template<typename T>	void GLContextGetDefaultIndexed( T *dst, int index );
+
+//===========================================================================//
+
+// caching state object template.  One of these is instantiated in the context per unique struct type above
+template<typename T> class GLState
+{
+	public:
+	
+		GLState<T>()
+		{
+			dirty = false;
+			memset( &data, 0, sizeof(data) );
+		};
+
+		// write: client src into cache
+		// common case is both false.  dirty is calculated, context write is deferred.
+		void	Write( T *src, bool noCompare=false, bool noDefer=false )
+		{
+			if (noCompare)
+			{
+				dirty = true;
+			}
+			else
+			{
+				// only == is implemented, so test for equal and negate
+				// note, you only set dirty if mismatch, you never clear it until flush
+				if ( !(data == *src) )
+				{
+					dirty = true;
+				}
+			}
+			
+			data = *src;
+			
+			if (noDefer)
+			{
+				Flush( true );	// dirty becomes false
+			}
+		};
+		
+		// write cache->context if dirty or forced.
+		void Flush( bool noDefer=false )
+		{
+			if (dirty || noDefer)
+			{
+				GLContextSet( &data );
+				GLMCheckError();
+					// good place for some error checking here
+				dirty = false;
+			}
+		};
+		
+		// default: write default value to cache, optionally write through
+		void Default( bool noDefer=false )
+		{
+			GLContextGetDefault( &data );	// read default values directly to our cache copy
+			dirty = true;
+			Flush(noDefer);
+		};
+
+		// read: sel = 0 for cache, 1 for context
+		void Read( T *dst, int sel )
+		{
+			if (sel==0)
+			{
+				*dst = data;
+			}
+			else
+			{
+				GLContextGet( dst );
+				GLMCheckError();
+			}
+		};
+		
+		// check: verify that context equals cache, return true if mismatched or if illegal values seen
+		bool Check ( void )
+		{
+			T		temp;
+			bool	result;
+
+			GLContextGet( &temp );
+			GLMCheckError();
+			result = !(temp == data);
+			return result;
+		};
+		
+	protected:
+		T		data;
+		bool	dirty;
+};
+
+// caching state object template - with multiple values behind it that are indexed
+template<typename T, int COUNT> class GLStateArray
+{
+	public:
+	
+		GLStateArray<T,COUNT>()
+		{
+			memset( &dirty, 0, sizeof(dirty) );
+			memset( &data, 0, sizeof(data) );
+		};
+
+		// write: client src into cache
+		// common case is both false.  dirty is calculated, context write is deferred.
+		void WriteIndex( T *src, int index, bool noCompare=false, bool noDefer=false )
+		{
+			if (noCompare)
+			{
+				dirty[index] = true;
+			}
+			else
+			{
+				// only == is implemented, so test for equal and negate
+				// note, you only set dirty if mismatch, you never clear it until flush
+				if (! (data[index] == *src) )
+				{
+					dirty[index] = true;
+				}
+			}
+			
+			data[index] = *src;
+			
+			if (noDefer)
+			{
+				FlushIndex( index, true );	// dirty becomes false
+			}
+		};
+		
+		// write cache->context if dirty or forced.
+		void FlushIndex( int index, bool noDefer=false )
+		{
+			if (dirty[index] || noDefer)
+			{
+				GLContextSetIndexed( &data[index], index );
+				GLMCheckError();
+				dirty[index] = false;
+			}
+		};
+		
+		// write all slots in the array
+		void Flush( bool noDefer=false )
+		{
+			for( int i=0; i<COUNT; i++)
+			{
+				FlushIndex( i, noDefer );
+			}
+		}
+		
+		// default: write default value to cache, optionally write through
+		void DefaultIndex( int index, bool noDefer=false )
+		{
+			GLContextGetDefaultIndexed( &data[index], index );	// read default values directly to our cache copy
+			dirty[index] = true;
+			Flush(noDefer);
+		};
+		
+		void Default( void )
+		{
+			for( int i=0; i<COUNT; i++)
+			{
+				DefaultIndex( i );
+			}			
+		}
+
+		// read: sel = 0 for cache, 1 for context
+		void ReadIndex( T *dst, int index, int sel )
+		{
+			if (sel==0)
+			{
+				*dst = data[index];
+			}
+			else
+			{
+				GLContextGetIndexed( dst, index );
+				GLMCheckError();
+			}
+		};
+		
+		// check: verify that context equals cache, return true if mismatched or if illegal values seen
+		bool CheckIndex( int index )
+		{
+			T		temp;
+			bool	result;
+
+			GLContextGetIndexed( &temp, index );
+			GLMCheckError();
+			result = !(temp == data[index]);
+			
+			return result;
+		};
+
+		bool Check( void )
+		{
+			T		temp;
+			bool	result = false;
+
+			for( int i=0; i<COUNT; i++)
+			{
+				result |= CheckIndex( i );
+			}
+			
+			return result;
+		};
+		
+	protected:
+		T		data	[COUNT];
+		bool	dirty	[COUNT];
+};
+
+
+//===========================================================================//
+
+struct	GLMTexSampler
+{
+	GLMTexSamplingParams	m_samp;
+	CGLMTex					*m_drawTex;		// tex which must be bound at time of draw
+	CGLMTex					*m_boundTex;	// tex which is actually bound now (if does not match, a rebind is needed to draw)
+};
+
+#ifdef NEVER
+//===========================================================================//
+
+enum	GLMVertexAttributeIndex
+{
+	kGLMGenericAttr00 = 0,
+	kGLMGenericAttr01,
+	kGLMGenericAttr02,
+	kGLMGenericAttr03,
+	kGLMGenericAttr04,
+	kGLMGenericAttr05,
+	kGLMGenericAttr06,
+	kGLMGenericAttr07,
+	kGLMGenericAttr08,
+	kGLMGenericAttr09,
+	kGLMGenericAttr10,
+	kGLMGenericAttr11,
+	kGLMGenericAttr12,
+	kGLMGenericAttr13,
+	kGLMGenericAttr14,
+	kGLMGenericAttr15,
+
+	kGLMVertexAttributeIndexMax			// ideally < 32
+};
+
+struct GLMVertexAttributeDesc			// all the info you need to do vertex setup for one attribute
+{
+	CGLMBuffer				*m_buffer;	// NULL allowed in which case m_offset is the full 32-bit pointer.. so you can draw from plain RAM if desired
+	GLuint					m_datasize;	// comp count of the attribute (1-4)
+	GLenum					m_datatype;	// data type of the attribute (GL_FLOAT, GL_UNSIGNED_BYTE, etc)
+	GLuint					m_stride;
+	GLuint					m_offset;	// net offset to attribute 'zero' within the buffer.
+	GLboolean				m_normalized;	// apply to any fixed point data that needs normalizing, esp color bytes
+	
+		// may need a seed value at some point to be able to disambiguate re-lifed buffers holding same pointer
+		// simpler alternative is to do shoot-down inside the vertex/index buffer free calls.
+		// I'd rather not have to have each attribute fiddling a ref count on the buffer to which it refers..
+
+#define	EQ(fff) ( (src.fff) == (fff) )
+	// test in decreasing order of likelihood of difference, but do not include the buffer revision as caller is not supplying it..
+	bool operator==(const GLMVertexAttributeDesc& src)		const { return EQ(m_buffer) && EQ(m_offset) && EQ(m_stride) && EQ(m_datatype) && EQ(m_normalized) && EQ(m_datasize);	}
+#undef EQ
+
+	uint					m_bufferRevision;	// only set in GLM context's copy, to disambiguate references that are same offset / same buffer but cross an orphan event
+};
+
+// GLMContext will maintain one of these structures inside the context to represent the current state.
+// Client can supply a new one when it wants to change the setup.
+//FIXME GLMContext can do the work to migrate from old setup to new setup as efficiently as possible (but it doesn't yet)
+#endif
+
+struct GLMVertexSetup
+{
+	uint	m_attrMask;					// which attrs are enabled (1<<n) mask where n is a GLMVertexAttributeIndex.
+	
+	GLMVertexAttributeDesc	m_attrs[ kGLMVertexAttributeIndexMax ];
+
+	// copied in from dxabstract, not strictly needed for operation, helps debugging
+	unsigned char	m_vtxAttribMap[16];
+
+		/* high nibble is usage per _D3DDECLUSAGE
+			typedef enum _D3DDECLUSAGE
+			{
+				D3DDECLUSAGE_POSITION		= 0,
+				D3DDECLUSAGE_BLENDWEIGHT	= 1,
+				D3DDECLUSAGE_BLENDINDICES	= 2,
+				D3DDECLUSAGE_NORMAL			= 3,
+				D3DDECLUSAGE_PSIZE			= 4,
+				D3DDECLUSAGE_TEXCOORD		= 5,
+				D3DDECLUSAGE_TANGENT		= 6,
+				D3DDECLUSAGE_BINORMAL		= 7,
+				D3DDECLUSAGE_TESSFACTOR		= 8,
+				D3DDECLUSAGE_PLUGH			= 9,	// mystery value
+				D3DDECLUSAGE_COLOR			= 10,
+				D3DDECLUSAGE_FOG			= 11,
+				D3DDECLUSAGE_DEPTH			= 12,
+				D3DDECLUSAGE_SAMPLE			= 13,
+			} D3DDECLUSAGE;
+		
+			low nibble is usageindex (i.e. POSITION0, POSITION1, etc)
+			array position is attrib number.
+		*/
+};
+
+//===========================================================================//
+
+//FIXME magic numbers here
+
+#define	kGLMProgramParamFloat4Limit	256
+#define	kGLMProgramParamBoolLimit	16
+#define	kGLMProgramParamInt4Limit	16
+
+#define	kGLMVertexProgramParamFloat4Limit	256
+#define	kGLMFragmentProgramParamFloat4Limit	32
+
+struct GLMProgramParamsF
+{
+	float	m_values[kGLMProgramParamFloat4Limit][4];		// float4's 256 of them
+	uint	m_dirtySlotCount;								// index of slot past highest dirty (assume 0 for base of range)
+};
+
+struct GLMProgramParamsB
+{
+	int		m_values[kGLMProgramParamBoolLimit];			// bools, 4 of them
+	uint	m_dirtySlotCount;
+};
+
+struct GLMProgramParamsI
+{
+	int		m_values[kGLMProgramParamInt4Limit][4];			// int4s, 16 of them
+	uint	m_dirtySlotCount;
+};
+
+enum EGLMParamWriteMode
+{
+	eParamWriteAllSlots,			// glUniform4fv of the maximum size	(not recommended if shader is down-sizing the decl)
+	eParamWriteShaderSlots,			// glUniform4fv of the active slot count ("highwater")
+	eParamWriteShaderSlotsOptional,	// glUniform4fv of the active slot count ("highwater") - but only if at least one has been written - it's optional
+	eParamWriteDirtySlotRange		// glUniform4fv of the 0-N range where N is highest dirty slot
+};
+
+enum EGLMAttribWriteMode
+{
+	eAttribWriteAll,
+	eAttribWriteDirty
+};
+
+//===========================================================================//
+
+#if GLMDEBUG
+enum EGLMDebugCallSite
+{
+	eBeginFrame,		// inside begin frame func - frame number has been inc'd, batch number should be -1
+	eClear,				// inside clear func
+	eDrawElements,		// inside repeat loop, prior to draw call - batch numberhas been inc'd
+	eEndFrame,			// end frame
+	ePresent			// before showing pixels
+};
+
+// caller should zero one of these out and fill in the m_caller before invoking the hook
+struct GLMDebugHookInfo
+{
+		// info from the caller to the debug hook
+	EGLMDebugCallSite	m_caller;
+
+	
+		// state the hook uses to keep track of progress within a single run of the caller		
+	int					m_iteration;	// which call to the hook is this.  if it's zero, it precedes any action in the caller.
+
+	
+		// bools used to communicate between caller and hook
+	bool				m_loop;			// hook tells caller to loop around again (don't exit)
+	bool				m_holding;		// current mood of hook, are we holding on this batch (i.e. rerun)
+	
+		// specific info for a draw call
+	GLenum				m_drawMode;
+	GLuint				m_drawStart;
+	GLuint				m_drawEnd;
+	GLsizei				m_drawCount;
+	GLenum				m_drawType;
+	const GLvoid		*m_drawIndices;
+};
+#endif
+
+//===========================================================================//
+
+#define	kGLMUserClipPlanes			2
+#define kGLMScratchFBOCount			4
+
+class	GLMContext
+{
+	public:
+		// set/check current context (perq for many other calls)
+		void	MakeCurrent( bool bRenderThread = false );
+		void	ReleaseCurrent( bool bRenderThread = false );
+
+		// CheckCurrent has been removed (it no longer compiled). To minimize churn I'm leaving
+		// the inline NOP version.
+		// DO NOT change this to non-inlined. It's called all over the place from very hot codepaths.
+		FORCEINLINE void CheckCurrent( void ) { }
+		
+		void							PopulateCaps( void );	// fill out later portions of renderer info record which need context queries
+		void							DumpCaps( void );		// printf all the caps info (you can call this in release too)
+		const GLMRendererInfoFields&	Caps( void );			// peek at the caps record
+	
+		// state cache/mirror
+		void	SetDefaultStates( void );
+		void	FlushStates( bool noDefer = false );
+		void	VerifyStates( void );
+
+		// textures
+		// Lock and Unlock reqs go directly to the tex object
+		CGLMTex	*NewTex( GLMTexLayoutKey *key, char *debugLabel=NULL );
+		void	DelTex( CGLMTex	*tex );	
+
+			// options for Blit (replacement for ResolveTex and BlitTex)
+			// pass NULL for dstTex if you want to target GL_BACK with the blit.  You get y-flip with that, don't change the dstrect yourself.		
+		void	Blit2( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, uint filter );
+
+			// tex blit (via FBO blit)
+		void	BlitTex( CGLMTex *srcTex, GLMRect *srcRect, int srcFace, int srcMip, CGLMTex *dstTex, GLMRect *dstRect, int dstFace, int dstMip, uint filter, bool useBlitFB = true );
+
+			//	MSAA resolve - we do this in GLMContext because it has to do a bunch of FBO/blit gymnastics
+		void	ResolveTex( CGLMTex *tex, bool forceDirty=false );	
+		
+			// texture pre-load (residency forcing) - normally done one-time but you can force it
+		void	PreloadTex( CGLMTex *tex, bool force=false );
+
+		// samplers
+		void	SetSamplerTex( int sampler, CGLMTex *tex );
+		void	SetSamplerParams( int sampler, GLMTexSamplingParams *params );
+
+		// render targets (FBO's)
+		CGLMFBO	*NewFBO( void );
+		void	DelFBO( CGLMFBO *fbo );		
+		void	SetDrawingFBO( CGLMFBO *fbo );	// as with samplers, the notion of the target FBO is latched til draw time and then checked
+
+		// programs
+		CGLMProgram	*NewProgram( EGLMProgramType type, char *progString );
+		void	DelProgram( CGLMProgram *prog );
+		void	NullProgram( void );											// de-ac all shader state
+		
+		void	SetDrawingProgram( EGLMProgramType type, CGLMProgram *prog );	// set NULL for no program
+		void	SetDrawingLang( EGLMProgramLang lang, bool immediate=false );	// choose ARB or GLSL.  immediate=false defers lang change to top of frame
+		
+		void	LinkShaderPair( CGLMProgram *vp, CGLMProgram *fp );			// ensure this combo has been linked and is in the GLSL pair cache
+		void	ClearShaderPairCache( void );								// call this to shoot down all the linked pairs
+		void	QueryShaderPair( int index, GLMShaderPairInfo *infoOut );	// this lets you query the shader pair cache for saving its state
+		
+		// buffers
+		// Lock and Unlock reqs go directly to the buffer object
+		CGLMBuffer	*NewBuffer( EGLMBufferType type, uint size, uint options );
+		void	DelBuffer( CGLMBuffer *buff );
+
+		void	SetIndexBuffer( CGLMBuffer *buff );		
+		void	SetVertexAttributes( GLMVertexSetup *setup );
+			// note, no API is exposed for setting a single attribute source.
+			// come prepared with a complete block of attributes to use.
+			
+		// Queries
+		CGLMQuery	*NewQuery( GLMQueryParams *params );
+		void		DelQuery( CGLMQuery *query );
+			
+		// "slot" means a vec4-sized thing
+		// these write into .env parameter space
+		void	SetProgramParametersF( EGLMProgramType type, uint baseSlot, float *slotData, uint slotCount );	// take vec4f's
+		void	SetProgramParametersB( EGLMProgramType type, uint baseSlot, int  *slotData, uint boolCount );	// take "BOOL" aka int
+		void	SetProgramParametersI( EGLMProgramType type, uint baseSlot, int  *slotData, uint slotCount );	// take int4s
+
+		// state sync
+		void	FlushDrawStates( bool shadersOn=true );				// pushes all drawing state - samplers, tex, programs, etc.
+		
+		// drawing
+		void	DrawRangeElements(	GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices );
+		void	CheckNative( void );
+		
+		// clearing
+		void	Clear( bool color, unsigned long colorValue, bool depth, float depthValue, bool stencil, unsigned int stencilValue, GLScissorBox_t *rect = NULL );
+		
+		// display
+		//void	SetVSyncEnable( bool vsyncOn );
+		//void	SetFullScreen( bool fsOn, int screenIndex );		// will be latched for next BeginFrame
+		//void	ActivateFullScreen( bool fsOn, int screenIndex );	// will be called by BeginFrame
+		bool	SetDisplayParams( GLMDisplayParams *params );		// either the first time setup, or a change to new setup
+		
+		void	Present( CGLMTex *tex );		// somewhat hardwired for the time being
+
+		// mode switch / reset
+		void	Reset( void );							// not a lot of args for now..
+		
+		// writers for the state block inputs
+		
+		void	WriteAlphaTestEnable		( GLAlphaTestEnable_t *src );
+		void	WriteAlphaTestFunc			( GLAlphaTestFunc_t *src );
+		void	WriteCullFaceEnable			( GLCullFaceEnable_t *src );
+		void	WriteCullFrontFace			( GLCullFrontFace_t *src );
+		void	WritePolygonMode			( GLPolygonMode_t *src );
+		void	WriteDepthBias				( GLDepthBias_t *src );
+		void	WriteClipPlaneEnable		( GLClipPlaneEnable_t *src, int which );
+		void	WriteClipPlaneEquation		( GLClipPlaneEquation_t *src, int which );
+		void	WriteScissorEnable			( GLScissorEnable_t *src );
+		void	WriteScissorBox				( GLScissorBox_t *src );
+		void	WriteAlphaToCoverageEnable	( GLAlphaToCoverageEnable_t *src );
+		void	WriteViewportBox			( GLViewportBox_t *src );
+		void	WriteViewportDepthRange		( GLViewportDepthRange_t *src );
+		void	WriteColorMaskSingle		( GLColorMaskSingle_t *src );
+		void	WriteColorMaskMultiple		( GLColorMaskMultiple_t *src, int which );
+		void	WriteBlendEnable			( GLBlendEnable_t *src );
+		void	WriteBlendFactor			( GLBlendFactor_t *src );
+		void	WriteBlendEquation			( GLBlendEquation_t *src );
+		void	WriteBlendColor				( GLBlendColor_t *src );
+		void	WriteBlendEnableSRGB		( GLBlendEnableSRGB_t *src );
+		void	WriteDepthTestEnable		( GLDepthTestEnable_t *src );
+		void	WriteDepthFunc				( GLDepthFunc_t *src );
+		void	WriteDepthMask				( GLDepthMask_t *src );
+		void	WriteStencilTestEnable		( GLStencilTestEnable_t *src );
+		void	WriteStencilFunc			( GLStencilFunc_t *src );
+		void	WriteStencilOp				( GLStencilOp_t *src, int which );
+		void	WriteStencilWriteMask		( GLStencilWriteMask_t *src );
+		void	WriteClearColor				( GLClearColor_t *src );
+		void	WriteClearDepth				( GLClearDepth_t *src );
+		void	WriteClearStencil			( GLClearStencil_t *src );
+
+
+		// debug stuff
+		void	BeginFrame( void );
+		void	EndFrame( void );
+		
+		// new interactive debug stuff
+#if GLMDEBUG
+		void	DebugDump( GLMDebugHookInfo *info, uint options, uint vertDumpMode );
+		void	DebugHook( GLMDebugHookInfo *info );
+		void	DebugPresent( void );
+		void	DebugClear( void );
+#endif
+
+		FORCEINLINE DWORD GetCurrentOwnerThreadId() const { return m_nCurOwnerThreadId; }
+		
+	protected:
+		friend class GLMgr;				// only GLMgr can make GLMContext objects
+		friend class GLMRendererInfo;	// only GLMgr can make GLMContext objects
+		friend class CGLMTex;			// tex needs to be able to do binds
+		friend class CGLMFBO;			// fbo needs to be able to do binds
+		friend class CGLMProgram;
+		friend class CGLMShaderPair;
+		friend class CGLMShaderPairCache;
+		friend class CGLMBuffer;
+		friend class GLMTester;			// tester class needs access back into GLMContext
+		
+		friend class IDirect3D9;
+		friend class IDirect3DDevice9;
+		
+		// methods------------------------------------------
+		
+				// old GLMContext( GLint displayMask, GLint rendererID, PseudoNSGLContextPtr nsglShareCtx );
+				GLMContext( GLMDisplayParams *params );
+				~GLMContext();
+		
+		// textures
+		void	SelectTMU( int tmu );																// wrapper for glActiveTexture()
+		int		BindTexToTMU( CGLMTex *tex, int tmu, bool noCheck=false );
+		
+		// render targets / FBO's
+		void	BindFBOToCtx( CGLMFBO *fbo, GLenum bindPoint = GL_FRAMEBUFFER_EXT );				// you can also choose GL_READ_FRAMEBUFFER_EXT / GL_DRAW_FRAMEBUFFER_EXT
+		
+		// programs
+		//void	BindProgramToCtx( EGLMProgramType type, CGLMProgram *prog );						// will set program mode enable appropriately
+
+		// buffers
+		void	BindBufferToCtx( EGLMBufferType type, CGLMBuffer *buff, bool force = false );		// does not twiddle any enables.
+
+		// debug font
+		void	GenDebugFontTex( void );
+		void	DrawDebugText( float x, float y, float z, float drawCharWidth, float drawCharHeight, char *string );
+		
+		// members------------------------------------------
+		
+		// context
+		DWORD							m_nCurOwnerThreadId;
+
+		GLMRendererInfoFields			m_caps;
+	
+		bool							m_displayParamsValid;		// is there a param block copied in yet
+		GLMDisplayParams				m_displayParams;			// last known display config, either via constructor, or by SetDisplayParams...
+		
+#if defined(USE_SDL)
+		int								m_pixelFormatAttribs[100];	// more than enough
+		void *							m_ctx;
+#endif
+
+		// texture form table
+		CGLMTexLayoutTable				*m_texLayoutTable;
+
+		// context state mirrors
+
+		GLState<GLAlphaTestEnable_t>	m_AlphaTestEnable;
+		
+		GLState<GLAlphaTestFunc_t>		m_AlphaTestFunc;
+		
+		GLState<GLCullFaceEnable_t>		m_CullFaceEnable;			
+		GLState<GLCullFrontFace_t>		m_CullFrontFace;	
+		GLState<GLPolygonMode_t>		m_PolygonMode;
+		
+		GLState<GLDepthBias_t>			m_DepthBias;		
+
+		GLStateArray<GLClipPlaneEnable_t,kGLMUserClipPlanes>	m_ClipPlaneEnable;
+		GLStateArray<GLClipPlaneEquation_t,kGLMUserClipPlanes>	m_ClipPlaneEquation;	// dxabstract puts them directly into param slot 253(0) and 254(1)
+		
+		GLState<GLScissorEnable_t>		m_ScissorEnable;	
+		GLState<GLScissorBox_t>			m_ScissorBox;
+
+		GLState<GLAlphaToCoverageEnable_t> m_AlphaToCoverageEnable;	
+		
+		GLState<GLViewportBox_t>		m_ViewportBox;		
+		GLState<GLViewportDepthRange_t>	m_ViewportDepthRange;
+		
+		GLState<GLColorMaskSingle_t>	m_ColorMaskSingle;	
+		GLStateArray<GLColorMaskMultiple_t,8>	m_ColorMaskMultiple;	// need an official constant for the color buffers limit
+		
+		GLState<GLBlendEnable_t>		m_BlendEnable;		
+		GLState<GLBlendFactor_t>		m_BlendFactor;		
+		GLState<GLBlendEquation_t>		m_BlendEquation;	
+		GLState<GLBlendColor_t>			m_BlendColor;		
+		GLState<GLBlendEnableSRGB_t>	m_BlendEnableSRGB;		// write to this one to transmit intent to write SRGB encoded pixels to drawing FB
+		bool							m_FakeBlendEnableSRGB;	// writes to above will be shunted here if fake SRGB is in effect.
+		
+		GLState<GLDepthTestEnable_t>	m_DepthTestEnable;	
+		GLState<GLDepthFunc_t>			m_DepthFunc;		
+		GLState<GLDepthMask_t>			m_DepthMask;		
+		
+		GLState<GLStencilTestEnable_t>	m_StencilTestEnable;	// global stencil test enable
+		GLState<GLStencilFunc_t>		m_StencilFunc;			// holds front and back stencil funcs
+		GLStateArray<GLStencilOp_t,2>	m_StencilOp;			// indexed: 0=front 1=back
+		GLState<GLStencilWriteMask_t>	m_StencilWriteMask;		
+		
+		GLState<GLClearColor_t>			m_ClearColor;		
+		GLState<GLClearDepth_t>			m_ClearDepth;		
+		GLState<GLClearStencil_t>		m_ClearStencil;		
+		
+		// texture bindings and sampler setup
+		int								m_activeTexture;		// mirror for glActiveTexture
+		GLMTexSampler					m_samplers[GLM_SAMPLER_COUNT];
+	
+		// texture lock tracking - CGLMTex objects share usage of this
+		CUtlVector< GLMTexLockDesc >	m_texLocks;
+		
+		// render target binding - check before draw
+		// similar to tex sampler mechanism, we track "bound" from "chosen for drawing" separately,
+		// so binding for creation/setup need not disrupt any notion of what will be used at draw time
+		
+		CGLMFBO							*m_boundDrawFBO;		// FBO on GL_DRAW_FRAMEBUFFER bind point
+		CGLMFBO							*m_boundReadFBO;		// FBO on GL_READ_FRAMEBUFFER bind point
+																// ^ both are set if you bind to GL_FRAMEBUFFER_EXT
+		
+		CGLMFBO							*m_drawingFBO;			// what FBO should be bound at draw time (to both read/draw bp's).
+
+		CGLMFBO							*m_blitReadFBO;
+		CGLMFBO							*m_blitDrawFBO;			// scratch FBO's for framebuffer blit
+		
+		CGLMFBO							*m_scratchFBO[ kGLMScratchFBOCount ];	// general purpose FBO's for internal use
+		
+		CUtlVector< CGLMFBO* >			m_fboTable;				// each live FBO goes in the table
+		
+		// program bindings
+		EGLMProgramLang					m_drawingLangAtFrameStart;	// selector for start of frame (spills into m_drawingLang)
+		EGLMProgramLang					m_drawingLang;				// selector for which language we desire to draw with on the next batch
+		CGLMProgram						*m_drawingProgram[ kGLMNumProgramTypes ];
+		
+		GLMProgramParamsF				m_programParamsF[ kGLMNumProgramTypes ];
+		GLMProgramParamsB				m_programParamsB[ kGLMNumProgramTypes ];	// two banks, but only the vertex one is used
+		GLMProgramParamsI				m_programParamsI[ kGLMNumProgramTypes ];	// two banks, but only the vertex one is used
+		EGLMParamWriteMode				m_paramWriteMode;
+		
+		CGLMProgram						*m_nullFragmentProgram;		// write opaque black.  Activate when caller asks for null FP
+
+		CGLMProgram						*m_preloadTexVertexProgram;			// programs to help preload textures (dummies)
+		CGLMProgram						*m_preload2DTexFragmentProgram;
+		CGLMProgram						*m_preload3DTexFragmentProgram;
+		CGLMProgram						*m_preloadCubeTexFragmentProgram;
+
+		CGLMProgram						*m_boundProgram[ kGLMNumProgramTypes ];
+
+		CGLMShaderPairCache				*m_pairCache;				// GLSL only
+		CGLMShaderPair					*m_boundPair;				// GLSL only
+		uint							m_boundPairRevision;		// GLSL only
+		GLhandleARB						m_boundPairProgram;			// GLSL only
+
+		// buffer bindings
+		CGLMBuffer						*m_lastKnownBufferBinds[ kGLMNumBufferTypes ];				// tracked per bind point for dupe-bind-absorb
+		GLMVertexAttributeDesc			m_lastKnownVertexAttribs[ kGLMVertexAttributeIndexMax ];	// tracked per attrib for dupe-set-absorb
+		uint							m_lastKnownVertexAttribMask;								// tracked for dupe-enable-absorb
+		
+		CGLMBuffer						*m_drawIndexBuffer;	// ... ? do we need dupe tracking for index buffer setup? ?
+		
+		GLMVertexSetup					m_drawVertexSetup;
+
+		EGLMAttribWriteMode				m_attribWriteMode;
+		
+		bool							m_slowCheckEnable;		// turn this on or no native checking is done ("-glmassertslow" or "-glmsspewslow")
+		bool							m_slowAssertEnable;		// turn this on to assert on a non-native batch	"-glmassertslow"
+		bool							m_slowSpewEnable;	// turn this on to log non-native batches to stdout "-glmspewslow"
+		
+		// debug font texture
+		CGLMTex							*m_debugFontTex;		// might be NULL unless you call GenDebugFontTex
+		CGLMBuffer						*m_debugFontIndices;	// up to 1024 indices (256 chars times 4)
+		CGLMBuffer						*m_debugFontVertices;	// up to 1024 verts
+
+		// batch/frame debugging support
+		int								m_debugFrameIndex;			// init to -1. Increment at BeginFrame
+		int								m_debugBatchIndex;			// init to -1. Increment at any draw call
+
+#if GLMDEBUG
+		// interactive (DebugHook) debug support
+
+			// using these you can implement frame advance, batch single step, and batch rewind (let it run til next frame and hold on prev batch #)
+		int								m_holdFrameBegin;		// -1 if no hold req'd, otherwise # of frame to hold at (at beginframe time)
+		int								m_holdFrameEnd;			// -1 if no hold req'd, otherwise # of frame to hold at (at endframe time)
+
+		int								m_holdBatch,m_holdBatchFrame;	// -1 if no hold, else # of batch&frame to hold at (both must be set)
+																// these can be expired/cleared to -1 if the frame passes without a hit
+																// may be desirable to re-pause in that event, as user was expecting a hold to occur
+
+		bool							m_debugDelayEnable;		// allow sleep delay
+		uint							m_debugDelay;			// sleep time per hook call in microseconds (for usleep())
+		
+			// pre-draw global toggles / options
+		bool							m_autoClearColor,m_autoClearDepth,m_autoClearStencil;
+		float							m_autoClearColorValues[4];
+		
+			// debug knobs
+		int								m_selKnobIndex;
+		float							m_selKnobMinValue,m_selKnobMaxValue,m_selKnobIncrement;
+#endif
+
+};
+
+struct GLMTestParams
+{
+	GLMContext	*m_ctx;
+	int			*m_testList;			// -1 termed
+	
+	bool		m_glErrToDebugger;
+	bool		m_glErrToConsole;
+	
+	bool		m_intlErrToDebugger;
+	bool		m_intlErrToConsole;
+	
+	int			m_frameCount;			// how many frames to test.
+};
+
+class GLMTester
+{
+	public:
+	
+	GLMTester(GLMTestParams *params);
+	~GLMTester();
+	
+
+	// optionally callable by test routines to get basic drawables wired up
+	void	StdSetup( void );
+	void	StdCleanup( void );
+	
+	// callable by test routines to clear the frame or present it
+	void	Clear( void );
+	void	Present( int seed );
+
+	// error reporting
+	void	CheckGLError( char *comment );					// obey m_params setting for console / debugger response
+	void	InternalError( int errcode, char *comment );	// if errcode!=0, obey m_params setting for console / debugger response
+	
+	void	RunTests();
+
+	void	RunOneTest( int testindex );
+
+	// test routines themselves
+	void	Test0();
+	void	Test1();
+	void	Test2();
+	void	Test3();
+
+	GLMTestParams	m_params;		// copy of caller's params, do not mutate...
+	
+	// std-setup stuff
+	int				m_drawWidth, m_drawHeight;
+	CGLMFBO			*m_drawFBO;
+	CGLMTex			*m_drawColorTex;
+	CGLMTex			*m_drawDepthTex;
+};
+
+class CShowPixelsParams
+{
+public:
+	GLuint					m_srcTexName;
+	int						m_width,m_height;
+	bool					m_vsyncEnable;
+	bool					m_fsEnable;		// want receiving view to be full screen.  for now, just target the main screen.  extend later.
+	bool					m_useBlit;		// use FBO blit - sending context says it is available.
+	bool					m_noBlit;		// the back buffer has already been populated by the caller (perhaps via direct MSAA resolve from multisampled RT tex)
+	bool					m_onlySyncView;	// react to full/windowed state change only, do not present bits
+};
+
+
+#define	kMaxCrawlFrames	100
+#define	kMaxCrawlText		(kMaxCrawlFrames * 256)
+class CStackCrawlParams
+{
+	public:
+	uint					m_frameLimit;							// input: max frames to retrieve
+	uint					m_frameCount;							// output: frames found
+	void					*m_crawl[kMaxCrawlFrames];				// call site addresses
+	char					*m_crawlNames[kMaxCrawlFrames];			// pointers into text following, one per decoded name
+	char					m_crawlText[kMaxCrawlText];
+};
+
+#endif
diff --git a/mp/src/public/togl/osx/glmgrbasics.h b/mp/src/public/togl/osx/glmgrbasics.h
index d446b512..78e41464 100644
--- a/mp/src/public/togl/osx/glmgrbasics.h
+++ b/mp/src/public/togl/osx/glmgrbasics.h
@@ -1,299 +1,299 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-//

-// glmgrbasics.h

-//	types, common headers, forward declarations, utilities

-//

-//===============================================================================

-

-#ifndef GLMBASICS_H

-#define	GLMBASICS_H

-

-#pragma once

-

-#ifdef OSX

-#include <OpenGL/OpenGL.h>

-#include <OpenGL/gl.h>

-#include <OpenGL/glext.h>

-#include <OpenGL/CGLTypes.h>

-#include <OpenGL/CGLRenderers.h>

-#include <OpenGL/CGLCurrent.h>

-#include <OpenGL/CGLProfiler.h>

-//#include <ApplicationServices/ApplicationServices.h>

-#elif defined(LINUX)

-#include <GL/gl.h>

-#include <GL/glext.h>

-#else

-#error

-#endif

-

-#include "tier0/platform.h"

-

-#include "bitmap/imageformat.h"

-#include "bitvec.h"

-#include "tier1/checksum_md5.h"

-#include "tier1/utlvector.h"

-#include "tier1/convar.h"

-

-#include <sys/stat.h>

-

-#include "dxabstract_types.h"

-

-// types

-struct GLMRect;

-typedef void *PseudoGLContextPtr;

-

-

-	// 3-d integer box (used for texture lock/unlock etc)

-struct	GLMRegion

-{

-	int	xmin,xmax;

-	int	ymin,ymax;

-	int zmin,zmax;

-};

-

-struct GLMRect	// follows GL convention - if coming from the D3D rect you will need to fiddle the Y's

-{

-    int xmin;	// left

-    int ymin;	// bottom

-    int xmax;	// right

-    int ymax;	// top

-};

-

-// macros

-

-//#define	GLMassert(x)	assert(x)

-

-// forward decls

-class	GLMgr;				// singleton

-class	GLMContext;			// GL context

-class	CGLMContextTester;	// testing class

-class	CGLMTex;

-class	CGLMFBO;

-class	CGLMProgram;

-class	CGLMBuffer;

-

-

-// utilities

-

-typedef enum

-{

-	// D3D codes

-	eD3D_DEVTYPE,

-	eD3D_FORMAT,

-	eD3D_RTYPE,

-	eD3D_USAGE,

-	eD3D_RSTATE,	// render state

-	eD3D_SIO,		// D3D shader bytecode

-	eD3D_VTXDECLUSAGE,

-	

-	// CGL codes

-	eCGL_RENDID,

-	

-	// OpenGL error codes

-	eGL_ERROR,

-	

-	// OpenGL enums

-	eGL_ENUM,

-	eGL_RENDERER

-

-}	GLMThing_t;

-

-const char* GLMDecode( GLMThing_t type, unsigned long value );		// decode a numeric const

-const char* GLMDecodeMask( GLMThing_t type, unsigned long value );	// decode a bitmask

-

-void GLMStop( void );	// aka Debugger()

-void GLMCheckError( bool noStop = false, bool noLog= false );

-void GLMEnableTrace( bool on );

-

-// expose these in release now

-// Mimic PIX events so we can decorate debug spew

-void	GLMBeginPIXEvent( const char *str );

-void	GLMEndPIXEvent( void );

-

-//===============================================================================

-// knob twiddling

-float	GLMKnob( char *knobname, float *setvalue );	// Pass NULL to not-set the knob value

-float	GLMKnobToggle( char *knobname );

-

-//===============================================================================

-// other stuff

-

-// helpers for CGLSetOption - no op if no profiler

-void	GLMProfilerClearTrace( void );

-void	GLMProfilerEnableTrace( bool enable );

-

-// helpers for CGLSetParameter - no op if no profiler

-void	GLMProfilerDumpState( void );

-

-

-//===============================================================================

-// classes

-

-// helper class making function tracking easier to wire up

-#if GLMDEBUG

-class GLMFuncLogger

-{

-	public:

-	

-		// simple function log

-		GLMFuncLogger( const char *funcName )

-		{

-			m_funcName = funcName;

-			m_earlyOut = false;

-			

-			GLMPrintf( ">%s", m_funcName );

-		};

-		

-		// more advanced version lets you pass args (i.e. called parameters or anything else of interest)

-		// no macro for this one, since no easy way to pass through the args as well as the funcname

-		GLMFuncLogger( const char *funcName, char *fmt, ... )

-		{

-			m_funcName = funcName;

-			m_earlyOut = false;

-

-			// this acts like GLMPrintf here

-			// all the indent policy is down in GLMPrintfVA

-			// which means we need to inject a ">" at the front of the format string to make this work... sigh.

-			

-			char modifiedFmt[2000];

-			modifiedFmt[0] = '>';

-			strcpy( modifiedFmt+1, fmt );

-			

-			va_list	vargs;

-			va_start(vargs, fmt);

-			GLMPrintfVA( modifiedFmt, vargs );

-			va_end( vargs );

-		}

-		

-		~GLMFuncLogger( )

-		{

-			if (m_earlyOut)

-			{

-				GLMPrintf( "<%s (early out)", m_funcName );

-			}

-			else

-			{

-				GLMPrintf( "<%s", m_funcName );

-			}

-		};

-	

-		void EarlyOut( void )

-		{

-			m_earlyOut = true;

-		};

-		

-		const char *m_funcName;				// set at construction time

-		bool m_earlyOut;

-};

-

-// handy macro to go with the function tracking class

-#define	GLM_FUNC			GLMFuncLogger _logger_ ( __FUNCTION__ )

-#else

-#define	GLM_FUNC

-#endif

-

-

-// class to keep an in-memory mirror of a file which may be getting edited during run

-class CGLMFileMirror

-{

-public:

-	CGLMFileMirror( char *fullpath );		// just associates mirror with file. if file exists it will be read.

-											//if non existent it will be created with size zero

-	~CGLMFileMirror( );

-	

-	bool		HasData( void );								// see if data avail

-	void		GetData( char **dataPtr, uint *dataSizePtr );	// read it out

-	void		SetData( char *data, uint dataSize );			// put data in (and write it to disk)

-	bool		PollForChanges( void );							// check disk copy.  If different, read it back in and return true.

-	

-	void		UpdateStatInfo( void );		// make sure stat info is current for our file

-	void		ReadFile( void );

-	void		WriteFile( void );

-

-	void		OpenInEditor( bool foreground=false );			// pass TRUE if you would like the editor to pop to foreground

-	

-	/// how about a "wait for change" method..

-

-	char		*m_path;	// fullpath to file

-	bool		m_exists;

-	struct stat	m_stat;		// stat results for the file (last time checked)

-	

-	char		*m_data;	// content of file

-	uint		m_size;		// length of content

-

-};

-

-// class based on the file mirror, that makes it easy to edit them outside the app.

-

-// it receives an initial block of text from the engine, and hashes it. ("orig")

-// it munges it by duplicating all the text after the "!!" line, and appending it in commented form. ("munged")

-// a mirror file is activated, using a filename based on the hash from the orig text.

-// if there is already content on disk matching that filename, use that content *unless* the 'blitz' parameter is set.

-//		(i.e. engine is instructing this subsystem to wipe out any old/modified variants of the text)

-

-

-class CGLMEditableTextItem

-{

-public:

-					CGLMEditableTextItem( char *text, uint size, bool forceOverwrite, char *prefix, char *suffix = NULL );		// create a text blob from text source, optional filename suffix

-					~CGLMEditableTextItem( );

-

-	bool			HasData( void );

-	bool			PollForChanges( void );									// return true if stale i.e. you need to get a new edition

-	void			GetCurrentText( char **textOut, uint *sizeOut );		// query for read access to the active blob (could be the original, could be external edited copy)

-	void			OpenInEditor( bool foreground=false );									// call user attention to this text

-

-	// internal methods

-	void			GenHashOfOrigText( void );

-	void			GenBaseNameAndFullPath( char *prefix, char *suffix );

-	void			GenMungedText( bool fromMirror );

-

-	// members

-	// orig

-	uint			m_origSize;

-	char			*m_origText;						// what was submitted

-	unsigned char	m_origDigest[MD5_DIGEST_LENGTH];	// digest of what was submitted

-	

-	// munged

-	uint			m_mungedSize;

-	char			*m_mungedText;						// re-processed edition, initial content submission to the file mirror

-

-	// mirror

-	char			*m_mirrorBaseName;					// generated from the hash of the orig text, plus the label / prefix

-	char			*m_mirrorFullPath;					// base name 

-	CGLMFileMirror	*m_mirror;							// file mirror itself.  holds "official" copy for GetCurrentText to return.

-};

-

-

-// debug font

-extern unsigned char g_glmDebugFontMap[16384];

-

-// class for cracking multi-part text blobs

-// sections are demarcated by beginning-of-line markers submitted in a table by the caller

-

-struct GLMTextSection

-{

-	int		m_markerIndex;		// based on table of markers passed in to constructor

-	uint	m_textOffset;		// where is the text - offset

-	int		m_textLength;		// how big is the section

-};

-

-class CGLMTextSectioner

-{

-public:

-					CGLMTextSectioner( char *text, int textSize, char **markers );		// constructor finds all the sections

-					~CGLMTextSectioner( );

-					

-	int				Count( void );			// how many sections found

-	void			GetSection( int index, uint *offsetOut, uint *lengthOut, int *markerIndexOut );

-		// find section, size, what marker

-		// note that more than one section can be marked similarly.

-		// so policy isn't made here, you walk the sections and decide what to do if there are dupes.

-	

-	//members

-	

-	//section table

-	CUtlVector< GLMTextSection >	m_sectionTable;

-};

-

-#endif

+//
+// glmgrbasics.h
+//	types, common headers, forward declarations, utilities
+//
+//===============================================================================
+
+#ifndef GLMBASICS_H
+#define	GLMBASICS_H
+
+#pragma once
+
+#ifdef OSX
+#include <OpenGL/OpenGL.h>
+#include <OpenGL/gl.h>
+#include <OpenGL/glext.h>
+#include <OpenGL/CGLTypes.h>
+#include <OpenGL/CGLRenderers.h>
+#include <OpenGL/CGLCurrent.h>
+#include <OpenGL/CGLProfiler.h>
+//#include <ApplicationServices/ApplicationServices.h>
+#elif defined(LINUX)
+#include <GL/gl.h>
+#include <GL/glext.h>
+#else
+#error
+#endif
+
+#include "tier0/platform.h"
+
+#include "bitmap/imageformat.h"
+#include "bitvec.h"
+#include "tier1/checksum_md5.h"
+#include "tier1/utlvector.h"
+#include "tier1/convar.h"
+
+#include <sys/stat.h>
+
+#include "dxabstract_types.h"
+
+// types
+struct GLMRect;
+typedef void *PseudoGLContextPtr;
+
+
+	// 3-d integer box (used for texture lock/unlock etc)
+struct	GLMRegion
+{
+	int	xmin,xmax;
+	int	ymin,ymax;
+	int zmin,zmax;
+};
+
+struct GLMRect	// follows GL convention - if coming from the D3D rect you will need to fiddle the Y's
+{
+    int xmin;	// left
+    int ymin;	// bottom
+    int xmax;	// right
+    int ymax;	// top
+};
+
+// macros
+
+//#define	GLMassert(x)	assert(x)
+
+// forward decls
+class	GLMgr;				// singleton
+class	GLMContext;			// GL context
+class	CGLMContextTester;	// testing class
+class	CGLMTex;
+class	CGLMFBO;
+class	CGLMProgram;
+class	CGLMBuffer;
+
+
+// utilities
+
+typedef enum
+{
+	// D3D codes
+	eD3D_DEVTYPE,
+	eD3D_FORMAT,
+	eD3D_RTYPE,
+	eD3D_USAGE,
+	eD3D_RSTATE,	// render state
+	eD3D_SIO,		// D3D shader bytecode
+	eD3D_VTXDECLUSAGE,
+	
+	// CGL codes
+	eCGL_RENDID,
+	
+	// OpenGL error codes
+	eGL_ERROR,
+	
+	// OpenGL enums
+	eGL_ENUM,
+	eGL_RENDERER
+
+}	GLMThing_t;
+
+const char* GLMDecode( GLMThing_t type, unsigned long value );		// decode a numeric const
+const char* GLMDecodeMask( GLMThing_t type, unsigned long value );	// decode a bitmask
+
+void GLMStop( void );	// aka Debugger()
+void GLMCheckError( bool noStop = false, bool noLog= false );
+void GLMEnableTrace( bool on );
+
+// expose these in release now
+// Mimic PIX events so we can decorate debug spew
+void	GLMBeginPIXEvent( const char *str );
+void	GLMEndPIXEvent( void );
+
+//===============================================================================
+// knob twiddling
+float	GLMKnob( char *knobname, float *setvalue );	// Pass NULL to not-set the knob value
+float	GLMKnobToggle( char *knobname );
+
+//===============================================================================
+// other stuff
+
+// helpers for CGLSetOption - no op if no profiler
+void	GLMProfilerClearTrace( void );
+void	GLMProfilerEnableTrace( bool enable );
+
+// helpers for CGLSetParameter - no op if no profiler
+void	GLMProfilerDumpState( void );
+
+
+//===============================================================================
+// classes
+
+// helper class making function tracking easier to wire up
+#if GLMDEBUG
+class GLMFuncLogger
+{
+	public:
+	
+		// simple function log
+		GLMFuncLogger( const char *funcName )
+		{
+			m_funcName = funcName;
+			m_earlyOut = false;
+			
+			GLMPrintf( ">%s", m_funcName );
+		};
+		
+		// more advanced version lets you pass args (i.e. called parameters or anything else of interest)
+		// no macro for this one, since no easy way to pass through the args as well as the funcname
+		GLMFuncLogger( const char *funcName, char *fmt, ... )
+		{
+			m_funcName = funcName;
+			m_earlyOut = false;
+
+			// this acts like GLMPrintf here
+			// all the indent policy is down in GLMPrintfVA
+			// which means we need to inject a ">" at the front of the format string to make this work... sigh.
+			
+			char modifiedFmt[2000];
+			modifiedFmt[0] = '>';
+			strcpy( modifiedFmt+1, fmt );
+			
+			va_list	vargs;
+			va_start(vargs, fmt);
+			GLMPrintfVA( modifiedFmt, vargs );
+			va_end( vargs );
+		}
+		
+		~GLMFuncLogger( )
+		{
+			if (m_earlyOut)
+			{
+				GLMPrintf( "<%s (early out)", m_funcName );
+			}
+			else
+			{
+				GLMPrintf( "<%s", m_funcName );
+			}
+		};
+	
+		void EarlyOut( void )
+		{
+			m_earlyOut = true;
+		};
+		
+		const char *m_funcName;				// set at construction time
+		bool m_earlyOut;
+};
+
+// handy macro to go with the function tracking class
+#define	GLM_FUNC			GLMFuncLogger _logger_ ( __FUNCTION__ )
+#else
+#define	GLM_FUNC
+#endif
+
+
+// class to keep an in-memory mirror of a file which may be getting edited during run
+class CGLMFileMirror
+{
+public:
+	CGLMFileMirror( char *fullpath );		// just associates mirror with file. if file exists it will be read.
+											//if non existent it will be created with size zero
+	~CGLMFileMirror( );
+	
+	bool		HasData( void );								// see if data avail
+	void		GetData( char **dataPtr, uint *dataSizePtr );	// read it out
+	void		SetData( char *data, uint dataSize );			// put data in (and write it to disk)
+	bool		PollForChanges( void );							// check disk copy.  If different, read it back in and return true.
+	
+	void		UpdateStatInfo( void );		// make sure stat info is current for our file
+	void		ReadFile( void );
+	void		WriteFile( void );
+
+	void		OpenInEditor( bool foreground=false );			// pass TRUE if you would like the editor to pop to foreground
+	
+	/// how about a "wait for change" method..
+
+	char		*m_path;	// fullpath to file
+	bool		m_exists;
+	struct stat	m_stat;		// stat results for the file (last time checked)
+	
+	char		*m_data;	// content of file
+	uint		m_size;		// length of content
+
+};
+
+// class based on the file mirror, that makes it easy to edit them outside the app.
+
+// it receives an initial block of text from the engine, and hashes it. ("orig")
+// it munges it by duplicating all the text after the "!!" line, and appending it in commented form. ("munged")
+// a mirror file is activated, using a filename based on the hash from the orig text.
+// if there is already content on disk matching that filename, use that content *unless* the 'blitz' parameter is set.
+//		(i.e. engine is instructing this subsystem to wipe out any old/modified variants of the text)
+
+
+class CGLMEditableTextItem
+{
+public:
+					CGLMEditableTextItem( char *text, uint size, bool forceOverwrite, char *prefix, char *suffix = NULL );		// create a text blob from text source, optional filename suffix
+					~CGLMEditableTextItem( );
+
+	bool			HasData( void );
+	bool			PollForChanges( void );									// return true if stale i.e. you need to get a new edition
+	void			GetCurrentText( char **textOut, uint *sizeOut );		// query for read access to the active blob (could be the original, could be external edited copy)
+	void			OpenInEditor( bool foreground=false );									// call user attention to this text
+
+	// internal methods
+	void			GenHashOfOrigText( void );
+	void			GenBaseNameAndFullPath( char *prefix, char *suffix );
+	void			GenMungedText( bool fromMirror );
+
+	// members
+	// orig
+	uint			m_origSize;
+	char			*m_origText;						// what was submitted
+	unsigned char	m_origDigest[MD5_DIGEST_LENGTH];	// digest of what was submitted
+	
+	// munged
+	uint			m_mungedSize;
+	char			*m_mungedText;						// re-processed edition, initial content submission to the file mirror
+
+	// mirror
+	char			*m_mirrorBaseName;					// generated from the hash of the orig text, plus the label / prefix
+	char			*m_mirrorFullPath;					// base name 
+	CGLMFileMirror	*m_mirror;							// file mirror itself.  holds "official" copy for GetCurrentText to return.
+};
+
+
+// debug font
+extern unsigned char g_glmDebugFontMap[16384];
+
+// class for cracking multi-part text blobs
+// sections are demarcated by beginning-of-line markers submitted in a table by the caller
+
+struct GLMTextSection
+{
+	int		m_markerIndex;		// based on table of markers passed in to constructor
+	uint	m_textOffset;		// where is the text - offset
+	int		m_textLength;		// how big is the section
+};
+
+class CGLMTextSectioner
+{
+public:
+					CGLMTextSectioner( char *text, int textSize, char **markers );		// constructor finds all the sections
+					~CGLMTextSectioner( );
+					
+	int				Count( void );			// how many sections found
+	void			GetSection( int index, uint *offsetOut, uint *lengthOut, int *markerIndexOut );
+		// find section, size, what marker
+		// note that more than one section can be marked similarly.
+		// so policy isn't made here, you walk the sections and decide what to do if there are dupes.
+	
+	//members
+	
+	//section table
+	CUtlVector< GLMTextSection >	m_sectionTable;
+};
+
+#endif
diff --git a/mp/src/public/togl/osx/glmgrext.h b/mp/src/public/togl/osx/glmgrext.h
index ace2c666..02939bb6 100644
--- a/mp/src/public/togl/osx/glmgrext.h
+++ b/mp/src/public/togl/osx/glmgrext.h
@@ -1,93 +1,93 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-//

-// glmgrext.h

-// helper file for extension testing and runtime importing of entry points

-//

-//===============================================================================

-

-#pragma once

-

-#ifdef OSX

-#include <OpenGL/gl.h>

-#include <OpenGL/glext.h>

-#elif defined(LINUX)

-#include <GL/gl.h>

-#include <GL/glext.h>

-#else

-#error

-#endif

-

-#ifndef GL_EXT_framebuffer_sRGB

-	#define GL_FRAMEBUFFER_SRGB_EXT                 0x8DB9

-	#define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT         0x8DBA

-#endif

-

-#ifndef ARB_texture_rg

-	#define GL_COMPRESSED_RED                 0x8225

-	#define GL_COMPRESSED_RG                  0x8226

-	#define GL_RG                             0x8227

-	#define GL_RG_INTEGER                     0x8228

-	#define GL_R8                             0x8229

-	#define GL_R16                            0x822A

-	#define GL_RG8                            0x822B

-	#define GL_RG16                           0x822C

-	#define GL_R16F                           0x822D

-	#define GL_R32F                           0x822E

-	#define GL_RG16F                          0x822F

-	#define GL_RG32F                          0x8230

-	#define GL_R8I                            0x8231

-	#define GL_R8UI                           0x8232

-	#define GL_R16I                           0x8233

-	#define GL_R16UI                          0x8234

-	#define GL_R32I                           0x8235

-	#define GL_R32UI                          0x8236

-	#define GL_RG8I                           0x8237

-	#define GL_RG8UI                          0x8238

-	#define GL_RG16I                          0x8239

-	#define GL_RG16UI                         0x823A

-	#define GL_RG32I                          0x823B

-	#define GL_RG32UI                         0x823C

-#endif

-

-#ifndef GL_EXT_bindable_uniform

-	#define GL_UNIFORM_BUFFER_EXT             0x8DEE

-#endif

-

-// unpublished extension enums (thus the "X")

-

-// from EXT_framebuffer_multisample_blit_scaled..

-#define XGL_SCALED_RESOLVE_FASTEST_EXT 0x90BA

-#define XGL_SCALED_RESOLVE_NICEST_EXT 0x90BB

-

-#ifndef GL_TEXTURE_MINIMIZE_STORAGE_APPLE

-#define GL_TEXTURE_MINIMIZE_STORAGE_APPLE  0x85B6

-#endif

-

-#ifndef GL_ALL_COMPLETED_NV

-#define GL_ALL_COMPLETED_NV               0x84F2

-#endif

-

-#ifndef GL_MAP_READ_BIT

-#define GL_MAP_READ_BIT                   0x0001

-#endif

-

-#ifndef GL_MAP_WRITE_BIT

-#define GL_MAP_WRITE_BIT                  0x0002

-#endif

-

-#ifndef GL_MAP_INVALIDATE_RANGE_BIT

-#define GL_MAP_INVALIDATE_RANGE_BIT       0x0004

-#endif

-

-#ifndef GL_MAP_INVALIDATE_BUFFER_BIT

-#define GL_MAP_INVALIDATE_BUFFER_BIT      0x0008

-#endif

-

-#ifndef GL_MAP_FLUSH_EXPLICIT_BIT

-#define GL_MAP_FLUSH_EXPLICIT_BIT         0x0010

-#endif

-

-#ifndef GL_MAP_UNSYNCHRONIZED_BIT

-#define GL_MAP_UNSYNCHRONIZED_BIT         0x0020

-#endif

-

+//
+// glmgrext.h
+// helper file for extension testing and runtime importing of entry points
+//
+//===============================================================================
+
+#pragma once
+
+#ifdef OSX
+#include <OpenGL/gl.h>
+#include <OpenGL/glext.h>
+#elif defined(LINUX)
+#include <GL/gl.h>
+#include <GL/glext.h>
+#else
+#error
+#endif
+
+#ifndef GL_EXT_framebuffer_sRGB
+	#define GL_FRAMEBUFFER_SRGB_EXT                 0x8DB9
+	#define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT         0x8DBA
+#endif
+
+#ifndef ARB_texture_rg
+	#define GL_COMPRESSED_RED                 0x8225
+	#define GL_COMPRESSED_RG                  0x8226
+	#define GL_RG                             0x8227
+	#define GL_RG_INTEGER                     0x8228
+	#define GL_R8                             0x8229
+	#define GL_R16                            0x822A
+	#define GL_RG8                            0x822B
+	#define GL_RG16                           0x822C
+	#define GL_R16F                           0x822D
+	#define GL_R32F                           0x822E
+	#define GL_RG16F                          0x822F
+	#define GL_RG32F                          0x8230
+	#define GL_R8I                            0x8231
+	#define GL_R8UI                           0x8232
+	#define GL_R16I                           0x8233
+	#define GL_R16UI                          0x8234
+	#define GL_R32I                           0x8235
+	#define GL_R32UI                          0x8236
+	#define GL_RG8I                           0x8237
+	#define GL_RG8UI                          0x8238
+	#define GL_RG16I                          0x8239
+	#define GL_RG16UI                         0x823A
+	#define GL_RG32I                          0x823B
+	#define GL_RG32UI                         0x823C
+#endif
+
+#ifndef GL_EXT_bindable_uniform
+	#define GL_UNIFORM_BUFFER_EXT             0x8DEE
+#endif
+
+// unpublished extension enums (thus the "X")
+
+// from EXT_framebuffer_multisample_blit_scaled..
+#define XGL_SCALED_RESOLVE_FASTEST_EXT 0x90BA
+#define XGL_SCALED_RESOLVE_NICEST_EXT 0x90BB
+
+#ifndef GL_TEXTURE_MINIMIZE_STORAGE_APPLE
+#define GL_TEXTURE_MINIMIZE_STORAGE_APPLE  0x85B6
+#endif
+
+#ifndef GL_ALL_COMPLETED_NV
+#define GL_ALL_COMPLETED_NV               0x84F2
+#endif
+
+#ifndef GL_MAP_READ_BIT
+#define GL_MAP_READ_BIT                   0x0001
+#endif
+
+#ifndef GL_MAP_WRITE_BIT
+#define GL_MAP_WRITE_BIT                  0x0002
+#endif
+
+#ifndef GL_MAP_INVALIDATE_RANGE_BIT
+#define GL_MAP_INVALIDATE_RANGE_BIT       0x0004
+#endif
+
+#ifndef GL_MAP_INVALIDATE_BUFFER_BIT
+#define GL_MAP_INVALIDATE_BUFFER_BIT      0x0008
+#endif
+
+#ifndef GL_MAP_FLUSH_EXPLICIT_BIT
+#define GL_MAP_FLUSH_EXPLICIT_BIT         0x0010
+#endif
+
+#ifndef GL_MAP_UNSYNCHRONIZED_BIT
+#define GL_MAP_UNSYNCHRONIZED_BIT         0x0020
+#endif
+
diff --git a/mp/src/tier1/qsort_s.cpp b/mp/src/tier1/qsort_s.cpp
index 820d151d..8222b32b 100644
--- a/mp/src/tier1/qsort_s.cpp
+++ b/mp/src/tier1/qsort_s.cpp
@@ -1,112 +1,112 @@
 //========= Copyright Valve Corporation, All rights reserved. ============//
-/******************************************************************/

-/* qsort.c  --  Non-Recursive ANSI Quicksort function             */

-/*                                                                */

-/* Public domain by Raymond Gardner, Englewood CO  February 1991  */

-/*                                                                */

-/* Usage:                                                         */

-/*     qsort(base, nbr_elements, width_bytes, compare_function);  */

-/*        void *base;                                             */

-/*        size_t nbr_elements, width_bytes;                       */

-/*        int (*compare_function)(const void *, const void *);    */

-/*                                                                */

-/* Sorts an array starting at base, of length nbr_elements, each  */

-/* element of size width_bytes, ordered via compare_function,     */

-/* which is called as  (*compare_function)(ptr_to_element1,       */

-/* ptr_to_element2) and returns < 0 if element1 < element2,       */

-/* 0 if element1 = element2, > 0 if element1 > element2.          */

-/* Most refinements are due to R. Sedgewick. See "Implementing    */

-/* Quicksort Programs", Comm. ACM, Oct. 1978, and Corrigendum,    */

-/* Comm. ACM, June 1979.                                          */

-/******************************************************************/

-

-// modified to take (and use) a context object, ala Microsoft's qsort_s

-// "extension" to the stdlib

-

-#include <stddef.h>                     /* for size_t definition  */

-

-/*

-**  swap nbytes between a and b

-*/

-

-static void swap_bytes(char *a, char *b, size_t nbytes)

-{

-   char tmp;

-   do {

-      tmp = *a; *a++ = *b; *b++ = tmp;

-   } while ( --nbytes );

-}

-

-#define  SWAP(a, b)  (swap_bytes((char *)(a), (char *)(b), size))

-

-#define  COMP(ctx, a, b)  ((*comp)((void *)ctx, (void *)(a), (void *)(b)))

-

-#define  T           7    /* subfiles of T or fewer elements will */

-                          /* be sorted by a simple insertion sort */

-                          /* Note!  T must be at least 3          */

-

-extern "C" void qsort_s(void *basep, size_t nelems, size_t size,

-           int (*comp)(void *, const void *, const void *),

-	   void *ctx)

-{

-   char *stack[40], **sp;       /* stack and stack pointer        */

-   char *i, *j, *limit;         /* scan and limit pointers        */

-   size_t thresh;               /* size of T elements in bytes    */

-   char *base;                  /* base pointer as char *         */

-

-   base = (char *)basep;        /* set up char * base pointer     */

-   thresh = T * size;           /* init threshold                 */

-   sp = stack;                  /* init stack pointer             */

-   limit = base + nelems * size;/* pointer past end of array      */

-   for ( ;; ) {                 /* repeat until break...          */

-      if ( limit - base > thresh ) {  /* if more than T elements  */

-                                      /*   swap base with middle  */

-         SWAP((((limit-base)/size)/2)*size+base, base);

-         i = base + size;             /* i scans left to right    */

-         j = limit - size;            /* j scans right to left    */

-         if ( COMP(ctx, i, j) > 0 )   /* Sedgewick's              */

-            SWAP(i, j);               /*    three-element sort    */

-         if ( COMP(ctx, base, j) > 0 )/*        sets things up    */

-            SWAP(base, j);            /*            so that       */

-         if ( COMP(ctx, i, base) > 0 )/*      *i <= *base <= *j   */

-            SWAP(i, base);            /* *base is pivot element   */

-         for ( ;; ) {                 /* loop until break         */

-            do                        /* move i right             */

-               i += size;             /*        until *i >= pivot */

-            while ( COMP(ctx, i, base) < 0 );

-            do                        /* move j left              */

-               j -= size;             /*        until *j <= pivot */

-            while ( COMP(ctx, j, base) > 0 );

-            if ( i > j )              /* if pointers crossed      */

-               break;                 /*     break loop           */

-            SWAP(i, j);       /* else swap elements, keep scanning*/

-         }

-         SWAP(base, j);         /* move pivot into correct place  */

-         if ( j - base > limit - i ) {  /* if left subfile larger */

-            sp[0] = base;             /* stack left subfile base  */

-            sp[1] = j;                /*    and limit             */

-            base = i;                 /* sort the right subfile   */

-         } else {                     /* else right subfile larger*/

-            sp[0] = i;                /* stack right subfile base */

-            sp[1] = limit;            /*    and limit             */

-            limit = j;                /* sort the left subfile    */

-         }

-         sp += 2;                     /* increment stack pointer  */

-      } else {      /* else subfile is small, use insertion sort  */

-         for ( j = base, i = j+size; i < limit; j = i, i += size )

-            for ( ; COMP(ctx, j, j+size) > 0; j -= size ) {

-               SWAP(j, j+size);

-               if ( j == base )

-                  break;

-            }

-         if ( sp != stack ) {         /* if any entries on stack  */

-            sp -= 2;                  /* pop the base and limit   */

-            base = sp[0];

-            limit = sp[1];

-         } else                       /* else stack empty, done   */

-            break;

-      }

-   }

-}

-

-

+/******************************************************************/
+/* qsort.c  --  Non-Recursive ANSI Quicksort function             */
+/*                                                                */
+/* Public domain by Raymond Gardner, Englewood CO  February 1991  */
+/*                                                                */
+/* Usage:                                                         */
+/*     qsort(base, nbr_elements, width_bytes, compare_function);  */
+/*        void *base;                                             */
+/*        size_t nbr_elements, width_bytes;                       */
+/*        int (*compare_function)(const void *, const void *);    */
+/*                                                                */
+/* Sorts an array starting at base, of length nbr_elements, each  */
+/* element of size width_bytes, ordered via compare_function,     */
+/* which is called as  (*compare_function)(ptr_to_element1,       */
+/* ptr_to_element2) and returns < 0 if element1 < element2,       */
+/* 0 if element1 = element2, > 0 if element1 > element2.          */
+/* Most refinements are due to R. Sedgewick. See "Implementing    */
+/* Quicksort Programs", Comm. ACM, Oct. 1978, and Corrigendum,    */
+/* Comm. ACM, June 1979.                                          */
+/******************************************************************/
+
+// modified to take (and use) a context object, ala Microsoft's qsort_s
+// "extension" to the stdlib
+
+#include <stddef.h>                     /* for size_t definition  */
+
+/*
+**  swap nbytes between a and b
+*/
+
+static void swap_bytes(char *a, char *b, size_t nbytes)
+{
+   char tmp;
+   do {
+      tmp = *a; *a++ = *b; *b++ = tmp;
+   } while ( --nbytes );
+}
+
+#define  SWAP(a, b)  (swap_bytes((char *)(a), (char *)(b), size))
+
+#define  COMP(ctx, a, b)  ((*comp)((void *)ctx, (void *)(a), (void *)(b)))
+
+#define  T           7    /* subfiles of T or fewer elements will */
+                          /* be sorted by a simple insertion sort */
+                          /* Note!  T must be at least 3          */
+
+extern "C" void qsort_s(void *basep, size_t nelems, size_t size,
+           int (*comp)(void *, const void *, const void *),
+	   void *ctx)
+{
+   char *stack[40], **sp;       /* stack and stack pointer        */
+   char *i, *j, *limit;         /* scan and limit pointers        */
+   size_t thresh;               /* size of T elements in bytes    */
+   char *base;                  /* base pointer as char *         */
+
+   base = (char *)basep;        /* set up char * base pointer     */
+   thresh = T * size;           /* init threshold                 */
+   sp = stack;                  /* init stack pointer             */
+   limit = base + nelems * size;/* pointer past end of array      */
+   for ( ;; ) {                 /* repeat until break...          */
+      if ( limit - base > thresh ) {  /* if more than T elements  */
+                                      /*   swap base with middle  */
+         SWAP((((limit-base)/size)/2)*size+base, base);
+         i = base + size;             /* i scans left to right    */
+         j = limit - size;            /* j scans right to left    */
+         if ( COMP(ctx, i, j) > 0 )   /* Sedgewick's              */
+            SWAP(i, j);               /*    three-element sort    */
+         if ( COMP(ctx, base, j) > 0 )/*        sets things up    */
+            SWAP(base, j);            /*            so that       */
+         if ( COMP(ctx, i, base) > 0 )/*      *i <= *base <= *j   */
+            SWAP(i, base);            /* *base is pivot element   */
+         for ( ;; ) {                 /* loop until break         */
+            do                        /* move i right             */
+               i += size;             /*        until *i >= pivot */
+            while ( COMP(ctx, i, base) < 0 );
+            do                        /* move j left              */
+               j -= size;             /*        until *j <= pivot */
+            while ( COMP(ctx, j, base) > 0 );
+            if ( i > j )              /* if pointers crossed      */
+               break;                 /*     break loop           */
+            SWAP(i, j);       /* else swap elements, keep scanning*/
+         }
+         SWAP(base, j);         /* move pivot into correct place  */
+         if ( j - base > limit - i ) {  /* if left subfile larger */
+            sp[0] = base;             /* stack left subfile base  */
+            sp[1] = j;                /*    and limit             */
+            base = i;                 /* sort the right subfile   */
+         } else {                     /* else right subfile larger*/
+            sp[0] = i;                /* stack right subfile base */
+            sp[1] = limit;            /*    and limit             */
+            limit = j;                /* sort the left subfile    */
+         }
+         sp += 2;                     /* increment stack pointer  */
+      } else {      /* else subfile is small, use insertion sort  */
+         for ( j = base, i = j+size; i < limit; j = i, i += size )
+            for ( ; COMP(ctx, j, j+size) > 0; j -= size ) {
+               SWAP(j, j+size);
+               if ( j == base )
+                  break;
+            }
+         if ( sp != stack ) {         /* if any entries on stack  */
+            sp -= 2;                  /* pop the base and limit   */
+            base = sp[0];
+            limit = sp[1];
+         } else                       /* else stack empty, done   */
+            break;
+      }
+   }
+}
+
+