From 0d8dceea4310fde5706b3ce1c70609d72a38efdf Mon Sep 17 00:00:00 2001
From: John Schoenick <johns@valvesoftware.com>
Date: Wed, 9 Sep 2015 18:35:41 -0700
Subject: Updated the SDK with the latest code from the TF and HL2 branches.

---
 mp/src/public/togl/osx/glmgr.h | 1088 ----------------------------------------
 1 file changed, 1088 deletions(-)
 delete mode 100644 mp/src/public/togl/osx/glmgr.h

(limited to 'mp/src/public/togl/osx/glmgr.h')

diff --git a/mp/src/public/togl/osx/glmgr.h b/mp/src/public/togl/osx/glmgr.h
deleted file mode 100644
index cdf64206..00000000
--- a/mp/src/public/togl/osx/glmgr.h
+++ /dev/null
@@ -1,1088 +0,0 @@
-//========= 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
-- 
cgit v1.2.3