//========= Copyright 1996-2008, Valve LLC, All rights reserved. ============
//
// Purpose: Main class for the game engine -- osx implementation
//
// $NoKeywords: $
//=============================================================================

#include "stdafx.h"

#include <Cocoa/Cocoa.h>
#include <map>
#include <queue>
#include <sys/time.h>

#include "glstringosx.h"
#include "gameengineosx.h"


CGameEngineGL *g_engine;		// dxabstract will use this.. it is set by the engine constructor

IGameEngine *CreateGameEngineOSX()
{
	static CGameEngineGL* s_pGameEngine = NULL;
	
	if (!s_pGameEngine)
	{
		s_pGameEngine = new CGameEngineGL();
	}
	
	return s_pGameEngine;
}

inline uint64_t GetTickCount()
{
    timeval time;
    gettimeofday(&time, NULL);
    return (time.tv_sec * 1000ULL) + (time.tv_usec / 1000ULL);
}

void OutputDebugString( const char *pchMsg )
{
	fprintf( stderr, "%s", pchMsg );
}

struct Packet_t
{
	uint32 unSize;
	void *pData;
};

class CVoiceContext 
{
public:
	CVoiceContext() 
	{
		alGenBuffers( ARRAYSIZE(m_buffers), m_buffers );
		alGenSources( 1, &m_nSource );
		
		alSourcei( m_nSource, AL_LOOPING, AL_FALSE );
		
		for (int i = 0; i < ARRAYSIZE(m_buffers); i++ )
			alSourcei( m_nSource, AL_BUFFER, m_buffers[i] ); 
		
		m_nNextFreeBuffer = 0;
	}
	virtual ~CVoiceContext()
	{
		// 
	}

	ALuint m_buffers[4];
	ALuint m_nSource;
	size_t m_nNextFreeBuffer;
	std::queue<Packet_t> m_pending;
};

class AutoReleasePool
{
public:
	AutoReleasePool()
	{
		pool = [[NSAutoreleasePool alloc] init];
	}
	~AutoReleasePool()
	{
		[pool release];
	}
	
	NSAutoreleasePool *pool;
};


@interface GLApplication : NSApplication
{
	
}
- (void)sendEvent:(NSEvent *)anEvent;
- (void)windowWillClose:(NSNotification *)notification;
@end

@implementation GLApplication
- (void)sendEvent:(NSEvent *)anEvent
{
	//fprintf( stderr, "sendEvent: %s\n", [[anEvent description] UTF8String] );
	
	[super sendEvent:anEvent];
}

- (void)windowWillClose:(NSNotification *)notification
{
	CreateGameEngineOSX()->Shutdown();
}

@end


//-----------------------------------------------------------------------------
// Purpose: Constructor for game engine instance
//-----------------------------------------------------------------------------
CGameEngineGL::CGameEngineGL()
{
	g_engine = this;
	
	m_bEngineReadyForUse = false;
	m_bShuttingDown = false;
	m_nWindowWidth = 0;
	m_nWindowHeight = 0;
	m_ulPreviousGameTickCount = 0;
	m_ulGameTickCount = 0;
	m_unVoiceChannelCount = 0;

	
	#if DX9MODE

		m_hwnd				= NULL;
		m_pD3D9Interface	= NULL;
		m_pD3D9Device		= NULL;

		m_displayDB			= NULL;

		m_dwBackgroundColor = D3DCOLOR_ARGB(0, 255, 255, 255 );

		m_nNextVertBufferHandle = 1;
		m_nNextTextureHandle = 1;

		m_hLineBuffer = 0;
		m_pLineVertexes = NULL;
		m_dwLinesToFlush = 0;
		m_dwLineBufferBatchPos = 0;

		m_hPointBuffer = NULL;
		m_pPointVertexes = NULL;
		m_dwPointsToFlush = 0;
		m_dwPointBufferBatchPos = 0;
		
		m_hQuadBuffer = NULL;
		m_pQuadVertexes = NULL;
		m_dwQuadsToFlush = 0;
		m_dwQuadBufferBatchPos = 0;

		m_hTextureWhite = NULL;

		m_nNextFontHandle = 1;
	#else

		m_hTextureWhite = 0;
		m_nNextFontHandle = 1;
		m_nNextTextureHandle = 1;
		m_hLastTexture = 0;
	
		m_rgflPointsData = new GLfloat[ 3*POINT_BUFFER_TOTAL_SIZE ];
		m_rgflPointsColorData = new GLubyte[ 4*POINT_BUFFER_TOTAL_SIZE ];
		m_dwPointsToFlush = 0;
	
		m_rgflLinesData = new GLfloat[ 6*LINE_BUFFER_TOTAL_SIZE ];
		m_rgflLinesColorData = new GLubyte[ 8*LINE_BUFFER_TOTAL_SIZE ];
		m_dwLinesToFlush = 0;
	
		m_rgflQuadsData = new GLfloat [ 12*QUAD_BUFFER_TOTAL_SIZE ];
		m_rgflQuadsColorData = new GLubyte[ 16*QUAD_BUFFER_TOTAL_SIZE ];
		m_rgflQuadsTextureData = new GLfloat[ 8*QUAD_BUFFER_TOTAL_SIZE ];
		m_dwQuadsToFlush = 0;

	#endif
	
	if( !BInitializeGraphics() )
	{
		OutputDebugString( "!! Initializing graphics failed\n" );
		return;
	}

	if ( !BInitializeAudio() )
	{
		OutputDebugString( "!! Initializing audio failed\n" );
		return;
	}

	m_bEngineReadyForUse = true;
}


//-----------------------------------------------------------------------------
// Purpose: Shutdown the game engine
//-----------------------------------------------------------------------------
void CGameEngineGL::Shutdown()
{
	// Flag that we are shutting down so the frame loop will stop running
	m_bShuttingDown = true;

	#if DX9MODE
	#else
		if ( m_rgflPointsData )
		{
			delete[] m_rgflPointsData;
			m_rgflPointsData = NULL;
		}
	
		if ( m_rgflPointsColorData )
		{
			delete[] m_rgflPointsColorData;
			m_rgflPointsColorData = NULL;
		}
	
		if ( m_rgflLinesData )
		{
			delete[] m_rgflLinesData;
			m_rgflLinesData = NULL;
		}
	
		if ( m_rgflLinesColorData )
		{
			delete[] m_rgflLinesColorData;
			m_rgflLinesColorData = NULL;
		}
	
		if ( m_rgflQuadsData )
		{
			delete[] m_rgflQuadsData;
			m_rgflQuadsData = NULL;
		}
	
		if ( m_rgflQuadsColorData )
		{
			delete[] m_rgflQuadsColorData;
			m_rgflQuadsColorData = NULL;
		}
	
		if ( m_rgflQuadsTextureData )
		{
			delete[] m_rgflQuadsTextureData;
			m_rgflQuadsTextureData = NULL;
		}
	
		std::map<std::string, GLString *>::const_iterator i;
		for (i = m_MapStrings.begin(); i != m_MapStrings.end(); ++i)
		{
			[i->second release];
		}
		
		m_MapStrings.clear();
		
		m_dwLinesToFlush = 0;
		m_dwPointsToFlush = 0;
		m_dwQuadsToFlush = 0;
	#endif
}


//-----------------------------------------------------------------------------
// Purpose: Initialize voice/audio interfaces
//-----------------------------------------------------------------------------
bool CGameEngineGL::BInitializeAudio()
{
	m_palDevice = alcOpenDevice(NULL);
	if ( m_palDevice ) 
	{
		m_palContext = alcCreateContext( m_palDevice, NULL );
		alcMakeContextCurrent( m_palContext );
		return true;
	}
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Initialize the GL rendering interfaces and default state
//-----------------------------------------------------------------------------
#define D3DADAPTER_DEFAULT 0

bool CGameEngineGL::BInitializeGraphics()
{
	m_nWindowWidth = 1024;
	m_nWindowHeight = 768;

	AutoReleasePool pool;

	ProcessSerialNumber psn = { 0, kCurrentProcess };
	TransformProcessType( &psn, kProcessTransformToForegroundApplication );
	SetFrontProcess( &psn );
	
	uint32_t mask = NSTitledWindowMask | NSClosableWindowMask| NSResizableWindowMask;

	GLuint attribs[] = 
	{
		NSOpenGLPFAAccelerated,
		NSOpenGLPFADoubleBuffer,
		NSOpenGLPFANoRecovery,
		NSOpenGLPFABackingStore,
		NSOpenGLPFAColorSize, 32,
		NSOpenGLPFADepthSize, 16,
		0
	};
	
	NSOpenGLPixelFormat* pixelFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes: (NSOpenGLPixelFormatAttribute*) attribs];

	NSApplication *app = [GLApplication sharedApplication];
	
	NSApplicationLoad();

	m_view = [[NSOpenGLView alloc] initWithFrame:NSMakeRect( 0, 0, m_nWindowWidth, m_nWindowHeight )
									 pixelFormat:pixelFormat];
	
	
	int wherex = 50;
	int wherey = 50;
	m_window = [[NSWindow alloc] initWithContentRect:NSMakeRect( wherex, wherey, m_nWindowWidth, m_nWindowHeight )
										   styleMask:mask
											 backing:NSBackingStoreBuffered
											   defer:NO];

	[m_window setAcceptsMouseMovedEvents:YES];
	
	GLint swapInt = 1;
	[[m_view openGLContext] setValues:&swapInt forParameter:NSOpenGLCPSwapInterval];

	[m_window setContentView:m_view];
	
	[m_window makeKeyAndOrderFront:nil];
	// [m_view setPostsFrameChangedNotifications:YES];

#if DX9MODE
	GLMgr::NewGLMgr();				// init GL manager

	m_hwnd = (void*) [m_window windowRef];

	// code transplanted from Windows sample.
	if ( !m_pD3D9Interface )
	{
		// Initialize the d3d interface
		m_pD3D9Interface = Direct3DCreate9( D3D_SDK_VERSION );
		if ( m_pD3D9Interface == NULL )
		{
			OutputDebugString( "Direct3DCreate9 failed\n" );
			return false;
		}
	}

	if ( !m_pD3D9Device )
	{
		D3DDISPLAYMODE d3ddisplaymode;

		// Get the current desktop display mode, only needed if running in a window.
		HRESULT hRes = m_pD3D9Interface->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddisplaymode );
		if (FAILED(hRes))
		{
			OutputDebugString( "GetAdapterDisplayMode failed\n");
			return false;
		}

		// Setup presentation parameters
		ZeroMemory( &m_d3dpp, sizeof( m_d3dpp ) );
		m_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; 
		m_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE; // no v-sync
		m_d3dpp.hDeviceWindow = m_hwnd;
		m_d3dpp.BackBufferCount = 1; 
		m_d3dpp.EnableAutoDepthStencil = TRUE;
		m_d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
		m_d3dpp.Windowed = TRUE; // bugbug jmccaskey - make a parameter?

		m_d3dpp.BackBufferWidth = m_nWindowWidth;
		m_d3dpp.BackBufferHeight = m_nWindowHeight;	// get it officially later on
		m_d3dpp.BackBufferFormat  = d3ddisplaymode.Format; 
		m_d3dpp.BackBufferCount = 1;

		m_d3dpp.MultiSampleType = (D3DMULTISAMPLE_TYPE)0;
		m_d3dpp.MultiSampleQuality = 0;

		// Create Direct3D9 device 
		// (if it fails to create hardware vertex processing, then go with the software alternative).
		hRes = m_pD3D9Interface->CreateDevice(	
			D3DADAPTER_DEFAULT, 
			D3DDEVTYPE_HAL,	
			m_hwnd, 
			D3DCREATE_HARDWARE_VERTEXPROCESSING, 
			&m_d3dpp, 
			&m_pD3D9Device );

		// Could not create a hardware device, create a software one instead (slow....)
		if ( FAILED( hRes ) )
		{
			hRes = m_pD3D9Interface->CreateDevice(
				D3DADAPTER_DEFAULT, 
				D3DDEVTYPE_HAL, 
				m_hwnd, 
				D3DCREATE_SOFTWARE_VERTEXPROCESSING, 
				&m_d3dpp, 
				&m_pD3D9Device );
		}

		// If we couldn't create a device even with software vertex processing then 
		// it's a fatal error
		if ( FAILED( hRes ) )
		{
			// Make sure the pointer is NULL after failures (seems it sometimes gets modified even when failing)
			m_pD3D9Device = NULL;

			OutputDebugString( "Failed to create D3D9 device\n" );
			return false;
		}

		//Initialize our render, texture, and sampler stage states
		ResetRenderStates();
	}

	[[m_view openGLContext] update];

#else
	// Clear any errors
	glGetError();

	glClearDepth( 1.0f );
	glClearColor( 0.0f, 0.0f, 0.0f, 1.0f );

	glEnable( GL_BLEND );
	glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );

	glDisable( GL_CULL_FACE );
	glDisable( GL_ALPHA_TEST );
	glDisable( GL_STENCIL_TEST );
	glDisable( GL_SCISSOR_TEST );
	glDisable( GL_LIGHTING );
	glDisable( GL_DEPTH_TEST );
	glDisable( GL_FOG );

	glDepthMask( GL_FALSE );

	// We always need these two
	glEnableClientState( GL_COLOR_ARRAY );
	glEnableClientState( GL_VERTEX_ARRAY );

	// This we'll enable as needed
	glDisableClientState( GL_TEXTURE_COORD_ARRAY );

	glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
	glTranslatef( 0, 0, 0 );
	
	glMatrixMode( GL_TEXTURE );
	glLoadIdentity();
	glTranslatef( 0, 0, 0 );

	glDepthRange( 0.0f, 1.0f );
	
	AdjustViewport();
#endif

	return true;
}

#if DX9MODE

	void CGameEngineGL::ResetRenderStates()
	{
		// Since we are just a really basic rendering engine we'll setup our initial 
		// render states here and we can just assume that they don't change later
		m_pD3D9Device->SetRenderState( D3DRS_LIGHTING, FALSE );
		m_pD3D9Device->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
		m_pD3D9Device->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
		m_pD3D9Device->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );

		m_pD3D9Device->SetRenderState( D3DRS_ZENABLE, FALSE );
		m_pD3D9Device->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );
		m_pD3D9Device->SetRenderState( D3DRS_COLORWRITEENABLE, (D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE | D3DCOLORWRITEENABLE_ALPHA ) );
		m_pD3D9Device->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
		
		m_pD3D9Device->SetRenderState( D3DRS_ALPHATESTENABLE, FALSE );
		m_pD3D9Device->SetRenderState( D3DRS_STENCILENABLE, FALSE );
		m_pD3D9Device->SetRenderState( D3DRS_FOGENABLE, FALSE );
		m_pD3D9Device->SetRenderState( D3DRS_SCISSORTESTENABLE, FALSE );
		m_pD3D9Device->SetRenderState( D3DRS_CLIPPING, FALSE );


		m_pD3D9Device->SetRenderState( D3DRS_LIGHTING, 0 );

		// texture stage state - not meaningful on all-shader impl
		#if 0
			m_pD3D9Device->SetTextureStageState( 0, D3DTSS_COLOROP, D3DTOP_MODULATE );
			m_pD3D9Device->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
			m_pD3D9Device->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_CURRENT );
			m_pD3D9Device->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
			m_pD3D9Device->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
			m_pD3D9Device->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_CURRENT );
		#endif
		
		// sampler state
		m_pD3D9Device->SetSamplerState(	0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
		m_pD3D9Device->SetSamplerState(	0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
		m_pD3D9Device->SetSamplerState(	0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
		
		// vertex decls
		static D3DVERTEXELEMENT9 s_elems_P4C1[] = 
		{
			//	stream		offset		type					method		usage					usageindex
			{	0,			0,			D3DDECLTYPE_FLOAT4,		0,			D3DDECLUSAGE_POSITION,	0			},
			{	0,			16,			D3DDECLTYPE_D3DCOLOR,	0,			D3DDECLUSAGE_COLOR,		0			},
			{	0xFF,		0,			0,						0,			0,						0			}	// end marker
		};

		static D3DVERTEXELEMENT9 s_elems_P4C1T2[] = 
		{
			//	stream		offset		type					method		usage					usageindex
			{	0,			0,			D3DDECLTYPE_FLOAT4,		0,			D3DDECLUSAGE_POSITION,	0			},
			{	0,			16,			D3DDECLTYPE_D3DCOLOR,	0,			D3DDECLUSAGE_COLOR,		0			},
			{	0,			20,			D3DDECLTYPE_FLOAT2,		0,			D3DDECLUSAGE_TEXCOORD,	0			},
			{	0xFF,		0,			0,						0,			0,						0			}	// end marker
		};
		
		m_pD3D9Device->CreateVertexDeclaration( s_elems_P4C1,	&m_decl_P4C1 );
		m_pD3D9Device->CreateVertexDeclaration( s_elems_P4C1T2,	&m_decl_P4C1T2 );
		
		// vertex shaders
		
		static char s_vsh_P4C1[] =
			"//GLSLvp\n"
			"#version 120  \n"
			"//ATTRIBMAP-00-A0-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx  \n"
			"attribute vec4 v0;  \n"
			"attribute vec4 v1;  \n"
			"//SAMPLERMASK-0  \n"
			"//HIGHWATER-1  \n"
			"uniform vec4 vc[1];  \n"
			"varying vec4 oColor;  \n"
			"void main()  \n"
			"{  \n"
			"vec4 consts = vec4( 0.0, 0.5, 1.0, 2.0 );  \n"
			"vec4 bias = vec4( -1.0, -1.0, 0.0, 0.0 );  \n"
			"vec4 scaling = vec4( 2.0/800.0, 2.0/600.0, 1.0, 1.0 );  \n"
			"vec4 r0;  \n"
			"vec4 r1;  \n"
			"vec4 vTempPos;  \n"
			"oColor = v1; //.wzyx;  \n"	// flip the channels
			"vTempPos = (v0 * scaling) + bias;  \n"
			"vTempPos.z = vTempPos.z * consts.w - vTempPos.w; // z' = (2*z)-w  \n"
			"//vTempPos.y = -vTempPos.y; // y' = -y   \n"
			"gl_Position = vTempPos;  \n"
			"}  \n";
			
		static char s_vsh_P4C1T2[] =
			"//GLSLvp\n"
			"#version 120  \n"
			"//ATTRIBMAP-00-A0-50-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx-xx  \n"
			"attribute vec4 v0;  \n"
			"attribute vec4 v1;  \n"
			"attribute vec2 v2;  \n"
			"//SAMPLERMASK-1  \n"
			"//HIGHWATER-1  \n"
			"uniform vec4 vc[1];  \n"
			"varying vec4 oColor;  \n"
			"varying vec2 oTexC0;  \n"
			"void main()  \n"
			"{  \n"
			"vec4 consts = vec4( 0.0, 0.5, 1.0, 2.0 );  \n"
			"vec4 bias = vec4( -1.0, -1.0, 0.0, 0.0 );  \n"
			"vec4 scaling = vec4( 2.0/800.0, 2.0/600.0, 1.0, 1.0 );  \n"
			"vec4 r0;  \n"
			"vec4 r1;  \n"
			"vec4 vTempPos;  \n"
			"oColor = v1; //.wzyx;  \n"	// flip the channels
			"oTexC0 = v2;  \n"
			"vTempPos = (v0 * scaling)+bias;  \n"
			"vTempPos.z = vTempPos.z * consts.w - vTempPos.w; // z' = (2*z)-w  \n"
			"//vTempPos.y = -vTempPos.y; // y' = -y   \n"
			"gl_Position = vTempPos;  \n"
			"}  \n";
			
		
		m_pD3D9Device->CreateVertexShader( (const DWORD*) s_vsh_P4C1,	&m_vsh_P4C1, "vsh-P4C1", NULL);
		m_pD3D9Device->CreateVertexShader( (const DWORD*) s_vsh_P4C1T2,	&m_vsh_P4C1T2, "vsh-P4C1T2", NULL);

		static char s_psh_P4C1[] = 
			"//GLSLfp\n"
			"#version 120  \n"
			"//SAMPLERMASK-0  \n"
			"//HIGHWATER-1  \n"
			"varying vec4 oColor;  \n"
			"uniform vec4 pc[1];  \n"
			"void main()  \n"
			"{  \n"
			"gl_FragColor = oColor;\n"
			"}  \n";
			
		static char s_psh_P4C1T2[] =
			"//GLSLfp\n"
			"#version 120  \n"
			"//SAMPLERMASK-1  \n"
			"//HIGHWATER-1  \n"
			"varying vec4 oColor;  \n"
			"varying vec2 oTexC0;  \n"
			"uniform vec4 pc[1];  \n"
			"uniform sampler2D sampler0;  \n"
			"void main()  \n"
			"{  \n"
			"vec4 r0;  \n"
			"r0 = texture2D( sampler0, oTexC0.xy );  \n"
			"r0 = r0 * oColor;  \n"
			"gl_FragColor = r0;  \n"
			"}  \n";

		m_pD3D9Device->CreatePixelShader( (const DWORD*) s_psh_P4C1,	&m_psh_P4C1, "psh-P4C1", NULL);
		m_pD3D9Device->CreatePixelShader( (const DWORD*) s_psh_P4C1T2,	&m_psh_P4C1T2, "psh-P4C1T2", NULL);
	}

#else	
	void CGameEngineGL::AdjustViewport()
	{
		NSRect viewBounds = { { 0, 0 }, { static_cast<CGFloat>(m_nWindowWidth), static_cast<CGFloat>(m_nWindowHeight) } };
		
		if( !NSEqualRects( [m_view bounds], viewBounds ) )
		{
			m_nWindowWidth = [m_view bounds].size.width;
			m_nWindowHeight = [m_view bounds].size.height;			
		}

		// Perspective
		glMatrixMode(GL_PROJECTION);
		glLoadIdentity();
		glOrtho( 0, m_nWindowWidth, m_nWindowHeight, 0, -1.0f, 1.0f );
		glTranslatef( 0, 0, 0 );
		
		// View port has changed as well
		glMatrixMode(GL_MODELVIEW);

		glViewport( 0, 0, m_nWindowWidth, m_nWindowHeight );
		glScissor( 0, 0, m_nWindowWidth, m_nWindowHeight );

		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
		glFlush();
	}
#endif

//-----------------------------------------------------------------------------
// Purpose: Updates current tick count for the game engine
//-----------------------------------------------------------------------------
void CGameEngineGL::UpdateGameTickCount()
{
	m_ulPreviousGameTickCount = m_ulGameTickCount;
	m_ulGameTickCount = GetTickCount();
}


//-----------------------------------------------------------------------------
// Purpose: Tell the game engine to sleep for a bit if needed to limit frame rate.  You must keep
// calling this repeatedly until it returns false.  If it returns true it's slept a little, but more
// time may be needed.
//-----------------------------------------------------------------------------
bool CGameEngineGL::BSleepForFrameRateLimit( uint32 ulMaxFrameRate )
{
	// Frame rate limiting
	float flDesiredFrameMilliseconds = 1000.0f/ulMaxFrameRate;

	uint64 ulGameTickCount = GetTickCount();

	float flMillisecondsElapsed = (float)(ulGameTickCount - m_ulGameTickCount);
	if ( flMillisecondsElapsed < flDesiredFrameMilliseconds )
	{
		// If enough time is left sleep, otherwise just keep spinning so we don't go over the limit...
		if ( flDesiredFrameMilliseconds - flMillisecondsElapsed > 3.0f )
		{
			usleep( 5000 );
		}
		else
		{
			// Just return right away so we busy loop, don't want to sleep too long and go over
		}

		return true;
	}
	else
	{
		return false;
	}
}


//-----------------------------------------------------------------------------
// Purpose: Set the background color to clear to
//-----------------------------------------------------------------------------
void CGameEngineGL::SetBackgroundColor( short a, short r, short g, short b )
{
	#if DX9MODE
		m_dwBackgroundColor = D3DCOLOR_ARGB( a, r, g, b );
	#else
		glClearColor( (float)r/255.0f, (float)g/255.0f, (float)b/255.0f, (float)a/255.0f );
	#endif
}

//-----------------------------------------------------------------------------
// Purpose: Start a new frame
//-----------------------------------------------------------------------------
bool CGameEngineGL::StartFrame()
{
	#if DX9MODE
		m_pD3D9Device->BeginScene();
	#else
	    AdjustViewport();
	#endif
    
	// Pump system callbacks
	MessagePump();

	// We may now be shutting down, check and don't start a frame then
	if ( BShuttingDown() )
		return false;

	#if DX9MODE
		uint bkcolor = m_dwBackgroundColor;

		#if 0 // for debug
			static unsigned char counter;
			counter++;
			bkcolor = ((uint)counter * 0x01010101) | 0xFF000000;

			bkcolor = 0x20202020;
		#endif
		
		m_pD3D9Device->Clear( 0, NULL, D3DCLEAR_TARGET, bkcolor, 0, 0 );		
	#else
		#if 0 // for debug
			static unsigned char counter;
			counter++;
			glClearColor( (float)counter/255.0f, (float)counter/255.0f, (float)counter/255.0f, (float)1.0f );
		#endif

		// Clear the screen for the new frame
		glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
	#endif

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: End the current frame
//-----------------------------------------------------------------------------
void CGameEngineGL::EndFrame()
{
	if ( BShuttingDown() )
		return;

	// Flush point buffer
	BFlushPointBuffer();

	// Flush line buffer
	BFlushLineBuffer();

	// Flush quad buffer
	BFlushQuadBuffer();

	#if DX9MODE
		m_pD3D9Device->EndScene();
		m_pD3D9Device->Present( NULL, NULL, NULL, NULL );
	#else
		// Swap buffers now that everything is flushed
	    [[m_view openGLContext] flushBuffer];
	#endif
    
	RunAudio();
}

#if DX9MODE

//-----------------------------------------------------------------------------
// Purpose: Creates a new vertex buffer
//-----------------------------------------------------------------------------
HGAMEVERTBUF CGameEngineGL::HCreateVertexBuffer( uint32 nSizeInBytes, DWORD dwUsage, DWORD dwFVF )
{
	if ( !m_pD3D9Device )
		return false;

	// Create a vertex buffer object
	IDirect3DVertexBuffer9 *pVertBuffer;
	HRESULT hRes = m_pD3D9Device->CreateVertexBuffer( nSizeInBytes, dwUsage,
		dwFVF, D3DPOOL_DEFAULT, &pVertBuffer, NULL );
	if ( FAILED( hRes ) )
	{
		OutputDebugString( "Failed creating vertex buffer\n" );
		return 0;
	}

	HGAMEVERTBUF hVertBuf = m_nNextVertBufferHandle;
	++m_nNextVertBufferHandle;

	VertBufData_t data;
	data.m_bIsLocked = false;
	data.m_pBuffer = pVertBuffer;

	m_MapVertexBuffers[ hVertBuf ] = data;
	return hVertBuf;
}


//-----------------------------------------------------------------------------
// Purpose: Locks an entire vertex buffer with the specified flags into memory
//-----------------------------------------------------------------------------
bool CGameEngineGL::BLockEntireVertexBuffer( HGAMEVERTBUF hVertBuf, void **ppVoid, DWORD dwFlags )
{
	if ( !m_pD3D9Device )
		return false;

	if ( !hVertBuf )
	{
		OutputDebugString( "Someone is calling BLockEntireVertexBuffer() with a null handle\n" );
		return false;
	}

	// Find the vertex buffer object for the passed handle
	std::map<HGAMEVERTBUF, VertBufData_t>::iterator iter;
	iter = m_MapVertexBuffers.find( hVertBuf );
	if ( iter == m_MapVertexBuffers.end() )
	{
		OutputDebugString( "Invalid vertex buffer handle passed to BLockEntireVertexBuffer()\n" );
		return false;
	}

	// Make sure the pointer is valid
	if ( !iter->second.m_pBuffer )
	{
		OutputDebugString( "Pointer to vertex buffer is invalid (lost device and not recreated?)!\n" );
		return false;
	}


	// Make sure its not already locked
	if ( iter->second.m_bIsLocked )
	{
		OutputDebugString( "Trying to lock an already locked vertex buffer!\n" );
		return false;
	}

	// we have the buffer, try to lock it
	if( FAILED( iter->second.m_pBuffer->Lock( 0, 0, ppVoid, dwFlags ) ) )
	{
		OutputDebugString( "BLockEntireVertexBuffer call failed\n" );
		return false;
	}

	// Track that we are now locked
	iter->second.m_bIsLocked = true;

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Unlocks a vertex buffer
//-----------------------------------------------------------------------------
bool CGameEngineGL::BUnlockVertexBuffer( HGAMEVERTBUF hVertBuf )
{
	if ( !m_pD3D9Device )
		return false;

	if ( !hVertBuf )
	{
		OutputDebugString( "Someone is calling BUnlockVertexBuffer() with a null handle\n" );
		return false;
	}

	// Find the vertex buffer for the passed handle
	std::map<HGAMEVERTBUF, VertBufData_t>::iterator iter;
	iter = m_MapVertexBuffers.find( hVertBuf );
	if ( iter == m_MapVertexBuffers.end() )
	{
		OutputDebugString( "Invalid vertex buffer handle passed to BUnlockVertexBuffer()\n" );
		return false;
	}

	// Make sure the pointer is valid
	if ( !iter->second.m_pBuffer )
	{
		OutputDebugString( "Pointer to vertex buffer is invalid (lost device and not recreated?)!\n" );
		return false;
	}

	// Make sure we are locked if someone is trying to unlock
	if ( !iter->second.m_bIsLocked )
	{
		OutputDebugString( "Trying to unlock a vertex buffer that is not locked!\n" );
		return false;
	}

	// we have the buffer, try to lock it
	if( FAILED( iter->second.m_pBuffer->Unlock() ) )
	{
		OutputDebugString( "BUnlockVertexBuffer call failed\n" );
		return false;
	}

	// Track that we are now unlocked
	iter->second.m_bIsLocked = false;

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Release a vertex buffer and free its resources
//-----------------------------------------------------------------------------
bool CGameEngineGL::BReleaseVertexBuffer( HGAMEVERTBUF hVertBuf )
{
	if ( !m_pD3D9Device )
		return false;

	if ( !hVertBuf )
	{
		OutputDebugString( "Someone is calling BReleaseVertexBuffer() with a null handle\n" );
		return false;
	}

	// Find the vertex buffer object for the passed handle
	std::map<HGAMEVERTBUF, VertBufData_t>::iterator iter;
	iter = m_MapVertexBuffers.find( hVertBuf );
	if ( iter == m_MapVertexBuffers.end() )
	{
		OutputDebugString( "Invalid vertex buffer handle passed to BReleaseVertexBuffer()\n" );
		return false;
	}

	// Make sure the pointer is valid
	if ( !iter->second.m_pBuffer )
	{
		OutputDebugString( "Pointer to vertex buffer is invalid (lost device and not recreated?)!\n" );
		return false;
	}

	// Make sure its unlocked, if it isn't locked this will just fail quietly
	if ( iter->second.m_bIsLocked )
		iter->second.m_pBuffer->Unlock();

	// Release the resources
	iter->second.m_pBuffer->Release();

	// Remove from the map
	m_MapVertexBuffers.erase( iter );

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: set vertex decl
//-----------------------------------------------------------------------------
bool CGameEngineGL::BSetVertexDeclaration( IDirect3DVertexDeclaration9 *decl )
{
	if ( !m_pD3D9Device )
		return false;
		
	m_pD3D9Device->SetVertexDeclaration( decl );
	
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: set stream source
//-----------------------------------------------------------------------------
bool CGameEngineGL::BSetStreamSource( uint streamNumber, HGAMEVERTBUF hVertBuf, uint32 uOffset, uint32 uStride )
{
	if ( !m_pD3D9Device )
		return false;

	std::map<HGAMEVERTBUF, VertBufData_t>::iterator iter;
	iter = m_MapVertexBuffers.find( hVertBuf );
	if ( iter == m_MapVertexBuffers.end() )
	{
		OutputDebugString( "Invalid vertex buffer handle passed to BSetStreamSource()\n" );
		return false;
	}

	// Make sure the pointer is valid
	if ( !iter->second.m_pBuffer )
	{
		OutputDebugString( "Pointer to vertex buffer is invalid (lost device and not recreated?)!\n" );
		return false;
	}

	// buffer located, pass it to set stream source call
	m_pD3D9Device->SetStreamSource( streamNumber, iter->second.m_pBuffer, uOffset, uStride );
		
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Set shader pair for rendering
//-----------------------------------------------------------------------------
bool CGameEngineGL::BSetShaders( IDirect3DVertexShader9 *vsh, IDirect3DPixelShader9 *psh )
{
	if ( !m_pD3D9Device )
		return false;

	m_pD3D9Device->SetVertexShader( vsh );
	m_pD3D9Device->SetPixelShader( psh );
	
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Render primitives out of the current stream source
//-----------------------------------------------------------------------------
bool CGameEngineGL::BRenderPrimitive( D3DPRIMITIVETYPE primType, uint32 uStartVertex, uint32 uCount )
{
	if ( !m_pD3D9Device )
		return false;

	if ( FAILED( m_pD3D9Device->DrawPrimitive( primType, uStartVertex, uCount ) ) )
	{
		OutputDebugString( "BRenderPrimitive() call failed\n" );
		return false;
	}
		
	return true;
}

bool CGameEngineGL::BUberRenderPrimitive(	IDirect3DVertexShader9 *vsh,
									IDirect3DPixelShader9 *psh,
									IDirect3DVertexDeclaration9 *decl,
									uint streamNumber,
									HGAMEVERTBUF hVertBuf,
									uint32 uOffset,
									uint32 uStride,
									D3DPRIMITIVETYPE primType,
									uint32 uStartVertex,
									uint32 uCount )
{
	if ( !m_pD3D9Device )
		return false;
	
	bool bRes = false;
	bRes |= BSetShaders				( vsh, psh );
	bRes |= BSetVertexDeclaration	( decl );
	bRes |= BSetStreamSource		( streamNumber, hVertBuf, 0 /*uOffset*/, uStride );		// streams are based at start of buffer
	bRes |= BRenderPrimitive		( primType, uStartVertex, uCount );						// uStartVertex advances the fetch offset from the base

	return bRes;
}



#endif

//-----------------------------------------------------------------------------
// Purpose: Draw a line, the engine internally manages a vertex buffer for batching these
//-----------------------------------------------------------------------------
bool CGameEngineGL::BDrawLine( float xPos0, float yPos0, DWORD dwColor0, float xPos1, float yPos1, DWORD dwColor1 )
{
	if ( m_bShuttingDown )
		return false;

	#if DX9MODE
		if ( !m_pD3D9Device )
			return false;

		if ( !m_hLineBuffer )
		{
			// Create the line buffer
			m_hLineBuffer = HCreateVertexBuffer( sizeof( LineVertex_t ) * LINE_BUFFER_TOTAL_SIZE * 2, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_XYZRHW | D3DFVF_DIFFUSE );

			if ( !m_hLineBuffer )
			{
				OutputDebugString( "Can't BDrawLine() because vertex buffer creation failed\n" );
				return false;
			}
		}

		// Check if we are out of room and need to flush the buffer
		if ( m_dwLinesToFlush == LINE_BUFFER_BATCH_SIZE )
		{
			BFlushLineBuffer();
		}

		// Lock the vertex buffer into memory
		if ( !m_pLineVertexes )
		{
			if ( !BLockEntireVertexBuffer( m_hLineBuffer, (void**)&m_pLineVertexes, m_dwLineBufferBatchPos ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) )
			{
				m_pLineVertexes = NULL;
				OutputDebugString( "BDrawLine failed because locking vertex buffer failed\n" );
				return false;
			}
		}

		LineVertex_t *pVertData = &m_pLineVertexes[ m_dwLineBufferBatchPos*2+m_dwLinesToFlush*2 ];
		pVertData[0].rhw = 1.0;
		pVertData[0].z = 1.0;
		pVertData[0].x = xPos0;
		pVertData[0].y = yPos0;
		pVertData[0].color = dwColor0;

		pVertData[1].rhw = 1.0;
		pVertData[1].z = 1.0;
		pVertData[1].x = xPos1;
		pVertData[1].y = yPos1;
		pVertData[1].color = dwColor1;

		++m_dwLinesToFlush;
	#else
		// Check if we are out of room and need to flush the buffer
		if ( m_dwLinesToFlush == LINE_BUFFER_TOTAL_SIZE )	
		{
			BFlushLineBuffer();
		}
	
		DWORD dwOffset = m_dwLinesToFlush*6;
		m_rgflLinesData[dwOffset] = xPos0;
		m_rgflLinesData[dwOffset+1] = yPos0;
		m_rgflLinesData[dwOffset+2] = 1.0;
		m_rgflLinesData[dwOffset+3] = xPos1;
		m_rgflLinesData[dwOffset+4] = yPos1;
		m_rgflLinesData[dwOffset+5] = 1.0;
	
		dwOffset = m_dwLinesToFlush*8;
		m_rgflLinesColorData[dwOffset] = COLOR_RED( dwColor0 );
		m_rgflLinesColorData[dwOffset+1] = COLOR_GREEN( dwColor0 );
		m_rgflLinesColorData[dwOffset+2] = COLOR_BLUE( dwColor0 );
		m_rgflLinesColorData[dwOffset+3] = COLOR_ALPHA( dwColor0 );
		m_rgflLinesColorData[dwOffset+4] = COLOR_RED( dwColor1 );
		m_rgflLinesColorData[dwOffset+5] = COLOR_GREEN( dwColor1 );
		m_rgflLinesColorData[dwOffset+6] = COLOR_BLUE( dwColor1 );
		m_rgflLinesColorData[dwOffset+7] = COLOR_ALPHA( dwColor1 );
	
		++m_dwLinesToFlush;
	#endif
	
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Flush batched lines to the screen
//-----------------------------------------------------------------------------
bool CGameEngineGL::BFlushLineBuffer()
{
	#if DX9MODE
		// If the vert buffer isn't already locked into memory, then there is nothing to flush
		if ( m_pLineVertexes == NULL )
			return true; // consider this successful since there was no error

		// OK, it is locked, so unlock now
		if ( !BUnlockVertexBuffer( m_hLineBuffer ) )
		{
			OutputDebugString( "Failed flushing line buffer because BUnlockVertexBuffer failed\n" );
			return false;
		}

		// Clear the memory pointer as its invalid now that we unlocked
		m_pLineVertexes = NULL;

		// If there is nothing to actual flush, we are done
		if ( m_dwLinesToFlush == 0 )
			return true;

		BUberRenderPrimitive( m_vsh_P4C1, m_psh_P4C1, m_decl_P4C1, 0, m_hLineBuffer, 0, sizeof( LineVertex_t ), D3DPT_LINELIST, m_dwLineBufferBatchPos*2, m_dwLinesToFlush );

		m_dwLinesToFlush = 0;
		m_dwLineBufferBatchPos += LINE_BUFFER_BATCH_SIZE;
		if ( m_dwLineBufferBatchPos >= LINE_BUFFER_TOTAL_SIZE )
		{
			m_dwLineBufferBatchPos = 0;
		}

		return true;
	#else
		if ( !m_rgflLinesColorData || !m_rgflLinesData || m_bShuttingDown )
			return false;
	
		if ( m_dwLinesToFlush )
		{
			glColorPointer( 4, GL_UNSIGNED_BYTE, 0, m_rgflLinesColorData );
			glVertexPointer( 3, GL_FLOAT, 0, m_rgflLinesData );
			glDrawArrays( GL_LINES, 0, m_dwLinesToFlush*2 );
	
			m_dwLinesToFlush = 0;
		}
	#endif

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Draw a point, the engine internally manages a vertex buffer for batching these
//-----------------------------------------------------------------------------
bool CGameEngineGL::BDrawPoint( float xPos, float yPos, DWORD dwColor )
{
	if ( m_bShuttingDown )
		return false;


	#if DX9MODE
		if ( !m_pD3D9Device )
			return false;

		if ( !m_hPointBuffer )
		{
			// Create the point buffer
			m_hPointBuffer = HCreateVertexBuffer( sizeof( PointVertex_t ) * POINT_BUFFER_TOTAL_SIZE * 2, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_XYZRHW | D3DFVF_DIFFUSE );

			if ( !m_hPointBuffer )
			{
				OutputDebugString( "Can't BDrawPoint() because vertex buffer creation failed\n" );
				return false;
			}
		}

		// Check if we are out of room and need to flush the buffer
		if ( m_dwPointsToFlush == POINT_BUFFER_BATCH_SIZE )	
		{
			BFlushPointBuffer();
		}

		// Set FVF
		//if ( !BSetFVF( D3DFVF_XYZRHW | D3DFVF_DIFFUSE ) )
		//	return false;

		// Lock the vertex buffer into memory
		if ( !m_pPointVertexes )
		{
			if ( !BLockEntireVertexBuffer( m_hPointBuffer, (void**)&m_pPointVertexes, m_dwPointBufferBatchPos+m_dwPointsToFlush ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) )
			{
				m_pPointVertexes = NULL;
				OutputDebugString( "BDrawPoint failed because locking vertex buffer failed\n" );
				return false;
			}
		}

		PointVertex_t *pVertData = &m_pPointVertexes[ m_dwPointBufferBatchPos+m_dwPointsToFlush ];
		pVertData[0].rhw = 1.0;
		pVertData[0].z = 1.0;
		pVertData[0].x = xPos;
		pVertData[0].y = yPos;
		pVertData[0].color = dwColor;

		++m_dwPointsToFlush;

	#else
		// Check if we are out of room and need to flush the buffer
		if ( m_dwPointsToFlush == POINT_BUFFER_TOTAL_SIZE )	
		{
			BFlushPointBuffer();
		}
	
		DWORD dwOffset = m_dwPointsToFlush*3;
		m_rgflPointsData[dwOffset] = xPos;
		m_rgflPointsData[dwOffset+1] = yPos;
		m_rgflPointsData[dwOffset+2] = 1.0;
	
		dwOffset = m_dwPointsToFlush*4;
		m_rgflPointsColorData[dwOffset] = COLOR_RED( dwColor );
		m_rgflPointsColorData[dwOffset+1] = COLOR_GREEN( dwColor );
		m_rgflPointsColorData[dwOffset+2] = COLOR_BLUE( dwColor );
		m_rgflPointsColorData[dwOffset+3] = COLOR_ALPHA( dwColor );
		
		++m_dwPointsToFlush;
	#endif
	
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Flush batched points to the screen
//-----------------------------------------------------------------------------
bool CGameEngineGL::BFlushPointBuffer()
{
	#if DX9MODE
		#if 1
			// If the vert buffer isn't already locked into memory, then there is nothing to flush
			if ( m_pPointVertexes == NULL )
				return true; // consider this successful since there was no error

			// OK, it is locked, so unlock now
			if ( !BUnlockVertexBuffer( m_hPointBuffer ) )
			{
				OutputDebugString( "Failed flushing point buffer because BUnlockVertexBuffer failed\n" );
				return false;
			}

			// Clear the memory pointer as its invalid now that we unlocked
			m_pPointVertexes = NULL;

			// If there is nothing to actual flush, we are done
			if ( m_dwPointsToFlush == 0 )
				return true;

			BUberRenderPrimitive( m_vsh_P4C1, m_psh_P4C1, m_decl_P4C1, 0, m_hPointBuffer, 0, sizeof( PointVertex_t ), D3DPT_POINTLIST, m_dwPointBufferBatchPos, m_dwPointsToFlush );

			m_dwPointsToFlush = 0;
			m_dwPointBufferBatchPos += POINT_BUFFER_BATCH_SIZE;
			if ( m_dwPointBufferBatchPos >= POINT_BUFFER_TOTAL_SIZE )
			{
				m_dwPointBufferBatchPos = 0;
			}
		#endif
		m_dwPointsToFlush = 0;
	#else
		if ( !m_rgflPointsColorData || !m_rgflPointsData || m_bShuttingDown )
			return false;
	
		if ( m_dwPointsToFlush )
		{
			glColorPointer( 4, GL_UNSIGNED_BYTE, 0, m_rgflPointsColorData );
			glVertexPointer( 3, GL_FLOAT, 0, m_rgflPointsData );
			glDrawArrays( GL_POINTS, 0, m_dwPointsToFlush );
	
			m_dwPointsToFlush = 0;
		}
    #endif
    
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Draw a filled quad
//-----------------------------------------------------------------------------
bool CGameEngineGL::BDrawFilledRect( float xPos0, float yPos0, float xPos1, float yPos1, DWORD dwColor )
{
	#if DX9MODE
		if ( !m_hTextureWhite )
		{
			#if 0	// debug gradient
				byte *pRGBAData = new byte[ 16 * 16 * 4 ];
				for( uint y = 0; y< 16; y++)
				{
					for( uint x = 0; x< 16; x++)
					{
						byte *dest = pRGBAData + (y*64) + (x*4);
						dest[0] = 0xFF;
						dest[1] = y * 0x11;
						dest[2] = x * 0x11;
						dest[3] = 0xFF;
					}
				}
				m_hTextureWhite = HCreateTexture( pRGBAData, 16, 16 );
			#else
				byte *pRGBAData = new byte[ 1 * 1 * 4 ];
				memset( pRGBAData, 255, 1*1*4 );
				m_hTextureWhite = HCreateTexture( pRGBAData, 1, 1 );
			#endif
			
			delete[] pRGBAData;
		}

		return BDrawTexturedRect( xPos0, yPos0, xPos1, yPos1, 0.0f, 0.0f, 1.0f, 1.0f, dwColor, m_hTextureWhite );
	#else
		if ( !m_hTextureWhite )
		{
			byte *pRGBAData = new byte[ 1 * 1 * 4 ];
			memset( pRGBAData, 255, 1*1*4 );
			m_hTextureWhite = HCreateTexture( pRGBAData, 1, 1 );
			delete[] pRGBAData;
		}
	
		return BDrawTexturedRect( xPos0, yPos0, xPos1, yPos1, 0.0f, 0.0f, 1.0f, 1.0f, dwColor, m_hTextureWhite );
	#endif
}


//-----------------------------------------------------------------------------
// Purpose: Draw a textured rect
//-----------------------------------------------------------------------------
bool CGameEngineGL::BDrawTexturedRect( float xPos0, float yPos0, float xPos1, float yPos1, float u0, float v0, float u1, float v1, DWORD dwColor, HGAMETEXTURE hTexture )
{
	if ( m_bShuttingDown )
		return false;

	#if DX9MODE
		if ( !m_pD3D9Device )
			return false;

		// Find the texture
		std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
		iter = m_MapTextures.find( hTexture );
		if ( iter == m_MapTextures.end() )
		{
			OutputDebugString( "BDrawTexturedRect called with invalid hTexture value\n" );
			return false;
		}

		if ( !m_hQuadBuffer )
		{
			// Create the line buffer
			m_hQuadBuffer = HCreateVertexBuffer( sizeof( TexturedQuadVertex_t ) * QUAD_BUFFER_TOTAL_SIZE * 4, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1 );

			if ( !m_hQuadBuffer )
			{
				OutputDebugString( "Can't BDrawTexturedRect() because vertex buffer creation failed\n" );
				return false;
			}
		}

		// Check if we are out of room and need to flush the buffer
		if ( m_dwQuadsToFlush == QUAD_BUFFER_BATCH_SIZE )
		{
			BFlushQuadBuffer();
		}

		// Check if the texture changed so we need to flush the buffer
		if ( m_hLastTexture != hTexture )
		{
			BFlushQuadBuffer();
		}	

		// Save the texture to use for next flush
		m_hLastTexture = hTexture;

		// Lock the vertex buffer into memory
		if ( !m_pQuadVertexes )
		{
			if ( !BLockEntireVertexBuffer( m_hQuadBuffer, (void**)&m_pQuadVertexes, m_dwQuadBufferBatchPos ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) )
			{
				m_pQuadVertexes = NULL;
				OutputDebugString( "BDrawTexturedRect failed because locking vertex buffer failed\n" );
				return false;
			}
		}

		TexturedQuadVertex_t *pVertData = &m_pQuadVertexes[ m_dwQuadBufferBatchPos*4+m_dwQuadsToFlush*4 ];

		#if GLMDEBUG && 0
			GLMPRINTF(("-D- m_dwQuadBufferBatchPos = %d, m_dwQuadsToFlush = %d, net vertex index = %d(offset $%08x), m_pQuadVertexes is %08x, pVertData is %08x " ,
				m_dwQuadBufferBatchPos,
				m_dwQuadsToFlush,
				m_dwQuadBufferBatchPos*4+m_dwQuadsToFlush*4,
				(m_dwQuadBufferBatchPos*4+m_dwQuadsToFlush*4) * sizeof( m_pQuadVertexes[0] ),
				m_pQuadVertexes,
				pVertData
				));
		#endif
		pVertData[0].color = dwColor;
		pVertData[0].rhw = 1.0f;
		pVertData[0].z = 1.0f;
		pVertData[0].x = xPos0;
		pVertData[0].y = yPos0;
		pVertData[0].u = u0;
		pVertData[0].v = v0;

		pVertData[1].color = dwColor;
		pVertData[1].rhw = 1.0f;
		pVertData[1].z = 1.0f;
		pVertData[1].x = xPos1;
		pVertData[1].y = yPos0;
		pVertData[1].u = u1;
		pVertData[1].v = v0;

		pVertData[2].color = dwColor;
		pVertData[2].rhw = 1.0f;
		pVertData[2].z = 1.0f;
		pVertData[2].x = xPos0;
		pVertData[2].y = yPos1;
		pVertData[2].u = u0;
		pVertData[2].v = v1;

		pVertData[3].color = dwColor;
		pVertData[3].rhw = 1.0f;
		pVertData[3].z = 1.0f;
		pVertData[3].x = xPos1;
		pVertData[3].y = yPos1;
		pVertData[3].u = u1;
		pVertData[3].v = v1;

		++m_dwQuadsToFlush;
	#else
		// Find the texture
		std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
		iter = m_MapTextures.find( hTexture );
		if ( iter == m_MapTextures.end() )
		{
			OutputDebugString( "BDrawTexturedQuad called with invalid hTexture value\n" );
			return false;
		}
	
		// Check if we are out of room and need to flush the buffer, or if our texture is changing
		// then we also need to flush the buffer.
		if ( m_dwQuadsToFlush == QUAD_BUFFER_TOTAL_SIZE || m_hLastTexture != hTexture )	
		{
			BFlushQuadBuffer();
		}
	
		// Bind the new texture
		glBindTexture( GL_TEXTURE_2D, iter->second.m_uTextureID );
	
		DWORD dwOffset = m_dwQuadsToFlush*12;
		m_rgflQuadsData[dwOffset] = xPos0;
		m_rgflQuadsData[dwOffset+1] = yPos0;
		m_rgflQuadsData[dwOffset+2] = 1.0;
		m_rgflQuadsData[dwOffset+3] = xPos1;
		m_rgflQuadsData[dwOffset+4] = yPos0;
		m_rgflQuadsData[dwOffset+5] = 1.0;
		m_rgflQuadsData[dwOffset+6] = xPos1;
		m_rgflQuadsData[dwOffset+7] = yPos1;
		m_rgflQuadsData[dwOffset+8] = 1.0;
		m_rgflQuadsData[dwOffset+9] = xPos0;
		m_rgflQuadsData[dwOffset+10] = yPos1;
		m_rgflQuadsData[dwOffset+11] = 1.0;
	
		dwOffset = m_dwQuadsToFlush*16;
		m_rgflQuadsColorData[dwOffset] = COLOR_RED( dwColor );
		m_rgflQuadsColorData[dwOffset+1] = COLOR_GREEN( dwColor );
		m_rgflQuadsColorData[dwOffset+2] = COLOR_BLUE( dwColor );
		m_rgflQuadsColorData[dwOffset+3] = COLOR_ALPHA( dwColor );
		m_rgflQuadsColorData[dwOffset+4] = COLOR_RED( dwColor );
		m_rgflQuadsColorData[dwOffset+5] = COLOR_GREEN( dwColor );
		m_rgflQuadsColorData[dwOffset+6] = COLOR_BLUE( dwColor );
		m_rgflQuadsColorData[dwOffset+7] = COLOR_ALPHA( dwColor );
		m_rgflQuadsColorData[dwOffset+8] = COLOR_RED( dwColor );
		m_rgflQuadsColorData[dwOffset+9] = COLOR_GREEN( dwColor );
		m_rgflQuadsColorData[dwOffset+10] = COLOR_BLUE( dwColor );
		m_rgflQuadsColorData[dwOffset+11] = COLOR_ALPHA( dwColor );
		m_rgflQuadsColorData[dwOffset+12] = COLOR_RED( dwColor );
		m_rgflQuadsColorData[dwOffset+13] = COLOR_GREEN( dwColor );
		m_rgflQuadsColorData[dwOffset+14] = COLOR_BLUE( dwColor );
		m_rgflQuadsColorData[dwOffset+15] = COLOR_ALPHA( dwColor );
	
		dwOffset = m_dwQuadsToFlush*8;
		m_rgflQuadsTextureData[dwOffset] = u0;
		m_rgflQuadsTextureData[dwOffset+1] = v0;
		m_rgflQuadsTextureData[dwOffset+2] = u1;
		m_rgflQuadsTextureData[dwOffset+3] = v0;
		m_rgflQuadsTextureData[dwOffset+4] = u1;
		m_rgflQuadsTextureData[dwOffset+5] = v1;
		m_rgflQuadsTextureData[dwOffset+6] = u0;
		m_rgflQuadsTextureData[dwOffset+7] = v1;
	
	
		++m_dwQuadsToFlush;
	#endif
	
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Draw a textured rect
//-----------------------------------------------------------------------------
bool CGameEngineGL::BDrawTexturedQuad( float xPos0, float yPos0, float xPos1, float yPos1, float xPos2, float yPos2, float xPos3, float yPos3,
	float u0, float v0, float u1, float v1, DWORD dwColor, HGAMETEXTURE hTexture )
{
	if ( m_bShuttingDown )
		return false;

	#if DX9MODE
		if ( !m_pD3D9Device )
			return false;

		// Find the texture
		std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
		iter = m_MapTextures.find( hTexture );
		if ( iter == m_MapTextures.end() )
		{
			OutputDebugString( "BDrawTexturedRect called with invalid hTexture value\n" );
			return false;
		}

		if ( !m_hQuadBuffer )
		{
			// Create the line buffer
			m_hQuadBuffer = HCreateVertexBuffer( sizeof( TexturedQuadVertex_t ) * QUAD_BUFFER_TOTAL_SIZE * 4, D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_TEX1 );

			if ( !m_hQuadBuffer )
			{
				OutputDebugString( "Can't BDrawTexturedRect() because vertex buffer creation failed\n" );
				return false;
			}
		}

		// Check if we are out of room and need to flush the buffer
		if ( m_dwQuadsToFlush == QUAD_BUFFER_BATCH_SIZE )
		{
			BFlushQuadBuffer();
		}

		// Check if the texture changed so we need to flush the buffer
		if ( m_hLastTexture != hTexture )
		{
			BFlushQuadBuffer();
		}	

		// Save the texture to use for next flush
		m_hLastTexture = hTexture;

		// Lock the vertex buffer into memory
		if ( !m_pQuadVertexes )
		{
			if ( !BLockEntireVertexBuffer( m_hQuadBuffer, (void**)&m_pQuadVertexes, m_dwQuadBufferBatchPos ? D3DLOCK_NOOVERWRITE : D3DLOCK_DISCARD ) )
			{
				m_pQuadVertexes = NULL;
				OutputDebugString( "BDrawTexturedRect failed because locking vertex buffer failed\n" );
				return false;
			}
		}

		TexturedQuadVertex_t *pVertData = &m_pQuadVertexes[ m_dwQuadBufferBatchPos*4+m_dwQuadsToFlush*4 ];

		#if GLMDEBUG && 0
			GLMPRINTF(("-D- m_dwQuadBufferBatchPos = %d, m_dwQuadsToFlush = %d, net vertex index = %d(offset $%08x), m_pQuadVertexes is %08x, pVertData is %08x " ,
				m_dwQuadBufferBatchPos,
				m_dwQuadsToFlush,
				m_dwQuadBufferBatchPos*4+m_dwQuadsToFlush*4,
				(m_dwQuadBufferBatchPos*4+m_dwQuadsToFlush*4) * sizeof( m_pQuadVertexes[0] ),
				m_pQuadVertexes,
				pVertData
				));
		#endif
		pVertData[0].color = dwColor;
		pVertData[0].rhw = 1.0f;
		pVertData[0].z = 1.0f;
		pVertData[0].x = xPos0;
		pVertData[0].y = yPos0;
		pVertData[0].u = u0;
		pVertData[0].v = v0;

		pVertData[1].color = dwColor;
		pVertData[1].rhw = 1.0f;
		pVertData[1].z = 1.0f;
		pVertData[1].x = xPos1;
		pVertData[1].y = yPos1;
		pVertData[1].u = u1;
		pVertData[1].v = v0;

		pVertData[2].color = dwColor;
		pVertData[2].rhw = 1.0f;
		pVertData[2].z = 1.0f;
		pVertData[2].x = xPos2;
		pVertData[2].y = yPos2;
		pVertData[2].u = u0;
		pVertData[2].v = v1;

		pVertData[3].color = dwColor;
		pVertData[3].rhw = 1.0f;
		pVertData[3].z = 1.0f;
		pVertData[3].x = xPos3;
		pVertData[3].y = yPos3;
		pVertData[3].u = u1;
		pVertData[3].v = v1;

		++m_dwQuadsToFlush;
	#else
		// Find the texture
		std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
		iter = m_MapTextures.find( hTexture );
		if ( iter == m_MapTextures.end() )
		{
			OutputDebugString( "BDrawTexturedQuad called with invalid hTexture value\n" );
			return false;
		}
	
		// Check if we are out of room and need to flush the buffer, or if our texture is changing
		// then we also need to flush the buffer.
		if ( m_dwQuadsToFlush == QUAD_BUFFER_TOTAL_SIZE || m_hLastTexture != hTexture )	
		{
			BFlushQuadBuffer();
		}
	
		// Bind the new texture
		glBindTexture( GL_TEXTURE_2D, iter->second.m_uTextureID );
	
		DWORD dwOffset = m_dwQuadsToFlush*12;
		m_rgflQuadsData[dwOffset] = xPos0;
		m_rgflQuadsData[dwOffset+1] = yPos0;
		m_rgflQuadsData[dwOffset+2] = 1.0;
		m_rgflQuadsData[dwOffset+3] = xPos1;
		m_rgflQuadsData[dwOffset+4] = yPos1;
		m_rgflQuadsData[dwOffset+5] = 1.0;
		m_rgflQuadsData[dwOffset+6] = xPos2;
		m_rgflQuadsData[dwOffset+7] = yPos2;
		m_rgflQuadsData[dwOffset+8] = 1.0;
		m_rgflQuadsData[dwOffset+9] = xPos3;
		m_rgflQuadsData[dwOffset+10] = yPos3;
		m_rgflQuadsData[dwOffset+11] = 1.0;
	
		dwOffset = m_dwQuadsToFlush*16;
		m_rgflQuadsColorData[dwOffset] = COLOR_RED( dwColor );
		m_rgflQuadsColorData[dwOffset+1] = COLOR_GREEN( dwColor );
		m_rgflQuadsColorData[dwOffset+2] = COLOR_BLUE( dwColor );
		m_rgflQuadsColorData[dwOffset+3] = COLOR_ALPHA( dwColor );
		m_rgflQuadsColorData[dwOffset+4] = COLOR_RED( dwColor );
		m_rgflQuadsColorData[dwOffset+5] = COLOR_GREEN( dwColor );
		m_rgflQuadsColorData[dwOffset+6] = COLOR_BLUE( dwColor );
		m_rgflQuadsColorData[dwOffset+7] = COLOR_ALPHA( dwColor );
		m_rgflQuadsColorData[dwOffset+8] = COLOR_RED( dwColor );
		m_rgflQuadsColorData[dwOffset+9] = COLOR_GREEN( dwColor );
		m_rgflQuadsColorData[dwOffset+10] = COLOR_BLUE( dwColor );
		m_rgflQuadsColorData[dwOffset+11] = COLOR_ALPHA( dwColor );
		m_rgflQuadsColorData[dwOffset+12] = COLOR_RED( dwColor );
		m_rgflQuadsColorData[dwOffset+13] = COLOR_GREEN( dwColor );
		m_rgflQuadsColorData[dwOffset+14] = COLOR_BLUE( dwColor );
		m_rgflQuadsColorData[dwOffset+15] = COLOR_ALPHA( dwColor );
	
		dwOffset = m_dwQuadsToFlush*8;
		m_rgflQuadsTextureData[dwOffset] = u0;
		m_rgflQuadsTextureData[dwOffset+1] = v0;
		m_rgflQuadsTextureData[dwOffset+2] = u1;
		m_rgflQuadsTextureData[dwOffset+3] = v0;
		m_rgflQuadsTextureData[dwOffset+4] = u1;
		m_rgflQuadsTextureData[dwOffset+5] = v1;
		m_rgflQuadsTextureData[dwOffset+6] = u0;
		m_rgflQuadsTextureData[dwOffset+7] = v1;
	
	
		++m_dwQuadsToFlush;
	#endif
	
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Flush buffered quads
//-----------------------------------------------------------------------------
bool CGameEngineGL::BFlushQuadBuffer()
{
	#if DX9MODE
		// If the vert buffer isn't already locked into memory, then there is nothing to flush
		if ( m_pQuadVertexes == NULL )
			return true; // consider this successful since there was no error

		// OK, it is locked, so unlock now
		if ( !BUnlockVertexBuffer( m_hQuadBuffer ) )
		{
			OutputDebugString( "Failed flushing quad buffer because BUnlockVertexBuffer failed\n" );
			return false;
		}

		// Clear the memory pointer as its invalid now that we unlocked
		m_pQuadVertexes = NULL;

		// If there is nothing to actual flush, we are done
		if ( m_dwQuadsToFlush == 0 )
			return true;

		// Find the texture
		std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
		iter = m_MapTextures.find( m_hLastTexture );
		if ( iter == m_MapTextures.end() )
		{
			OutputDebugString( "BFlushQuadBuffer failed with invalid m_hLastTexture value\n" );
			return false;
		}

		// See if we need to actually create the d3d texture
		if ( !iter->second.m_pTexture )
		{
			//HRESULT CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,VD3DHANDLE* pSharedHandle, char *debugLabel=NULL);
			HRESULT hRes = m_pD3D9Device->CreateTexture( 
				(UINT)iter->second.m_uWidth, 
				(UINT)iter->second.m_uHeight, 
				(UINT)1, // mip map levels (0 = generate all levels down to 1x1 if supported)
				(DWORD)0, // have to set the right flag here if you want to autogen mipmaps... we don't
				(D3DFORMAT)D3DFMT_A8R8G8B8,
				(D3DPOOL)D3DPOOL_MANAGED,
				(IDirect3DTexture9** )&iter->second.m_pTexture,
				(VD3DHANDLE*)NULL,
				"debuglabel" );
				
			if( FAILED( hRes ) )
			{
				OutputDebugString( "BFlushQuadBuffer failed because CreateTexture() call failed\n" );
				iter->second.m_pTexture = NULL;
				return false;
			}

			// Put the data into the texture
			D3DLOCKED_RECT rect;
			hRes = iter->second.m_pTexture->LockRect( 0, &rect, NULL, 0 );
			if( FAILED( hRes ) )
			{
				OutputDebugString( "LockRect call failed\n" );
				iter->second.m_pTexture->Release();
				iter->second.m_pTexture = NULL;
				return false;
			}

			DWORD *pARGB = (DWORD *) rect.pBits;
			byte *pRGBA = (byte *) iter->second.m_pRGBAData;

			byte r,g,b,a;
			for( uint32 y = 0; y < iter->second.m_uHeight; ++y )
			{
				for( uint32 x = 0; x < iter->second.m_uWidth; ++x )
				{
					// swap position of alpha value from back to front to be in correct format for d3d...
					r = *pRGBA++;
					g = *pRGBA++;
					b = *pRGBA++;
					a = *pRGBA++;

					*pARGB++ =  D3DCOLOR_ARGB( a, r, g, b );
				}
			}

			hRes = iter->second.m_pTexture->UnlockRect( 0 );
			if( FAILED( hRes ) )
			{
				OutputDebugString( "UnlockRect call failed\n" );
				iter->second.m_pTexture->Release();
				iter->second.m_pTexture = NULL;
				return false;
			}
		}

		// Ok, texture should be created ok, do the drawing work
		if ( FAILED( m_pD3D9Device->SetTexture( 0, iter->second.m_pTexture ) ) )
		{
			OutputDebugString( "BFlushQuadBuffer failed setting texture\n" );
			return false;
		}

		for ( DWORD i=0; i < m_dwQuadsToFlush*4; i += 4 )
		{
			BUberRenderPrimitive( m_vsh_P4C1T2, m_psh_P4C1T2, m_decl_P4C1T2, 0, m_hQuadBuffer, 0, sizeof( TexturedQuadVertex_t ), D3DPT_TRIANGLESTRIP, (m_dwQuadBufferBatchPos*4)+i, 2 );
		}

		m_pD3D9Device->SetTexture( 0, NULL ); // need to clear the texture before other drawing ops


		m_dwQuadsToFlush = 0;
		m_dwQuadBufferBatchPos += QUAD_BUFFER_BATCH_SIZE;
		if ( m_dwQuadBufferBatchPos >= QUAD_BUFFER_TOTAL_SIZE )
		{
			m_dwQuadBufferBatchPos = 0;
		}
	#else
		if ( !m_rgflPointsColorData || !m_rgflPointsData || m_bShuttingDown )
			return false;
	
		if ( m_dwQuadsToFlush )
		{
			glEnable( GL_TEXTURE_2D );
			glEnableClientState( GL_TEXTURE_COORD_ARRAY );
	
			glColorPointer( 4, GL_UNSIGNED_BYTE, 0, m_rgflQuadsColorData );
			glVertexPointer( 3, GL_FLOAT, 0, m_rgflQuadsData );
			glTexCoordPointer( 2, GL_FLOAT, 0, m_rgflQuadsTextureData );
			glDrawArrays( GL_QUADS, 0, m_dwQuadsToFlush*4 );
	
			glDisable( GL_TEXTURE_2D );
			glDisableClientState( GL_TEXTURE_COORD_ARRAY );
	
			m_dwQuadsToFlush = 0;
		}
	#endif
	
	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Creates a new texture 
//-----------------------------------------------------------------------------
HGAMETEXTURE CGameEngineGL::HCreateTexture( byte *pRGBAData, uint32 uWidth, uint32 uHeight, ETEXTUREFORMAT eTextureFormat )
{
	#if DX9MODE
		if ( !m_pD3D9Device )
			return 0;

		TextureData_t TexData;
		TexData.m_uWidth = uWidth;
		TexData.m_uHeight = uHeight;
		TexData.m_pRGBAData = new byte[uWidth*uHeight*4];
		memcpy( TexData.m_pRGBAData, pRGBAData, uWidth*uHeight*4 );
		TexData.m_pTexture = NULL;

		int nHandle = m_nNextTextureHandle;
		++m_nNextTextureHandle;
		m_MapTextures[nHandle] = TexData;

		return nHandle;
	#else
		if ( m_bShuttingDown )
			return 0;
	
		TextureData_t TexData;
		TexData.m_uWidth = uWidth;
		TexData.m_uHeight = uHeight;
		TexData.m_uTextureID = 0;
	
		glEnable( GL_TEXTURE_2D );
		glGenTextures( 1, &TexData.m_uTextureID );
		glBindTexture( GL_TEXTURE_2D, TexData.m_uTextureID );
	
		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0 );
		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0 );
		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
		glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
	
		// build our texture mipmaps
		glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, uWidth, uHeight, 0, eTextureFormat == eTextureFormat_RGBA ? GL_RGBA : GL_BGRA, GL_UNSIGNED_BYTE, (void *)pRGBAData );
		glDisable( GL_TEXTURE_2D );
	
		int nHandle = m_nNextTextureHandle;
		++m_nNextTextureHandle;
		m_MapTextures[nHandle] = TexData;
	
		return nHandle;
	#endif
}


//-----------------------------------------------------------------------------
// Purpose: update an exiting textue
//-----------------------------------------------------------------------------
bool CGameEngineGL::UpdateTexture( HGAMETEXTURE texture, byte *pRGBAData, uint32 uWidth, uint32 uHeight, ETEXTUREFORMAT eTextureFormat )
{
#if DX9MODE
		
	return false;
#else
	if ( m_bShuttingDown )
		return false;
	
	std::map<HGAMETEXTURE, TextureData_t>::iterator iter;
	iter = m_MapTextures.find( texture );
	if ( iter == m_MapTextures.end() )
	{
		OutputDebugString( "BDrawTexturedQuad called with invalid hTexture value\n" );
		return false;
	}

	glEnable( GL_TEXTURE_2D );
	glBindTexture( GL_TEXTURE_2D, iter->second.m_uTextureID );
	
	// build our texture mipmaps
	glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, uWidth, uHeight, 0, eTextureFormat == eTextureFormat_RGBA ? GL_RGBA : GL_BGRA, GL_UNSIGNED_BYTE, (void *)pRGBAData );
	glDisable( GL_TEXTURE_2D );
	
	return true;
#endif
	
}


//-----------------------------------------------------------------------------
// Purpose: Creates a new font
//-----------------------------------------------------------------------------
HGAMEFONT CGameEngineGL::HCreateFont( int nHeight, int nFontWeight, bool bItalic, const char * pchFont )
{
	#if DX9MODE
		extern unsigned char g_glmDebugFontMap[ 128 * 128 ];		// raster order
		
		#if GLMDEBUG
			GLMPRINTF(("-D- CGameEngineGL::HCreateFont nHeight=%d, nFontWeight=%d, bItalic=%s, fontname=%s", nHeight, nFontWeight, bItalic?"T":"F", pchFont ));
		#endif
		
		byte *pRGBAData = new byte[ 128 * 128 * 4];

		byte *src = (byte*)g_glmDebugFontMap;
		byte *dst = pRGBAData;
		
		for( uint y = 0; y< 128; y++)
		{
			for( uint x = 0; x< 128; x++)
			{
				if (*src == ' ')
				{
					dst[0] = 0;
					dst[1] = 0;
					dst[2] = 0;
					dst[3] = 0;
				}
				else
				{
					dst[0] = 0xFF;
					dst[1] = 0xFF;
					dst[2] = 0xFF;
					dst[3] = 0xFF;
				}
				src++;
				dst += 4;
			}
		}
		HGAMETEXTURE font = HCreateTexture( pRGBAData, 128, 128 );
		
		delete[] pRGBAData;

		HGAMEFONT hFont = m_nNextFontHandle;
		++m_nNextFontHandle;
		
		m_MapGameFonts[ hFont ] = font;
	
		return hFont;		
	#else
		AutoReleasePool pool;
		
		HGAMEFONT hFont = m_nNextFontHandle;
		++m_nNextFontHandle;
		
		NSString *fontName = [NSString stringWithUTF8String:pchFont];
	
		NSFont *font = [NSFont fontWithName: fontName size: nHeight];
		[font retain];
		
		m_MapGameFonts[ hFont ] = font;
	
		return hFont;
	#endif
}


//-----------------------------------------------------------------------------
// Purpose: Draws text to the screen inside the given rectangular region, using the given font
//-----------------------------------------------------------------------------
bool CGameEngineGL::BDrawString( HGAMEFONT hFont, RECT rect, DWORD dwColor, DWORD dwFormat, const char *pchText )
{
	#if DX9MODE
		HGAMETEXTURE font = (HGAMETEXTURE)m_MapGameFonts[ hFont ];

		int stringlen = strlen( pchText );

		float stringwidth = stringlen * 7.0f;
		float stringheight = 11.0f;
		
		float stringleft = rect.left + floor( ((rect.right - rect.left) - stringwidth) / 2.0f );
		float stringtop = rect.top + floor( ((rect.bottom - rect.top) - stringheight) / 2.0f );

		for( int charindex = 0; charindex < stringlen; charindex++ )
		{
			float	leftU,rightU,topV,bottomV;
			
			int character = (int)pchText[charindex];
			character -= 0x20;
			if ( (character<0) || (character > 0x7F) )
			{
				character = '*' - 0x20;
			}
			
			leftU	= ((character & 0x0F) * 6.0f ) / 128.0f;
			rightU	= leftU + (6.0f / 128.0f);

			topV	= ((character >> 4) * 11.0f ) / 128.0f;
			bottomV	= topV + (11.0f / 128.0f);
			
			float posx,posy;
			
			posx = stringleft + (7.0f * (float)charindex);
			posy = stringtop;
			
			BDrawTexturedRect( posx, posy, posx + 6.0f, posy + 11.0f, leftU, topV, rightU, bottomV, dwColor, font );		
		}
	
	#else
		if ( !hFont )
		{
			OutputDebugString( "Someone is calling BDrawString with a null font handle\n" );
			return false;
		}

		AutoReleasePool pool;
		
		NSFont *pFont = (NSFont*) m_MapGameFonts[ hFont ];
		NSRect box = { { static_cast<CGFloat>(rect.left), static_cast<CGFloat>(rect.top) }, { static_cast<CGFloat>(rect.right-rect.left), static_cast<CGFloat>(rect.bottom-rect.top) } };
		NSColor *pColor = [NSColor colorWithCalibratedRed:COLOR_RED(dwColor)/255.0
													green:COLOR_GREEN(dwColor)/255.0
													 blue:COLOR_BLUE(dwColor)/255.0
													alpha:COLOR_ALPHA(dwColor)/255.0 ];
		
		GLString *&string = m_MapStrings[ std::string(pchText) ];
		
		NSString *nsString = [NSString stringWithUTF8String:pchText];
		
		if ( string == NULL)
		{
			string = [[GLString alloc] initWithString:nsString
											 withFont:pFont
										withTextColor:pColor
												inBox:&box
											withFlags:dwFormat];
		}
		else
		{
			[string setFont: pFont];
			[string setColor: pColor];
			[string setBox: &box];
		}
		
		[string drawWithBounds: box];	
	
	#endif
	return true;
}

void CGameEngineGL::UpdateKey( uint32_t vkKey, int nDown )
{
    if ( nDown )
        m_SetKeysDown.insert( vkKey );
    else
        m_SetKeysDown.erase( vkKey );
}

//-----------------------------------------------------------------------------
// Purpose: Message pump for OS messages
//-----------------------------------------------------------------------------
void CGameEngineGL::MessagePump()
{
    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
	NSApplication *pApp = [NSApplication sharedApplication];
    do
    {
        NSEvent *event = [pApp nextEventMatchingMask:NSAnyEventMask untilDate:nil inMode:NSDefaultRunLoopMode dequeue:YES];
		if ( event == nil )
			break;
		
		// fprintf( stderr, ": %s\n", [[event description] UTF8String] );
		
        uint32_t c = 0;
		switch ( [event type] )
		{
			case NSKeyDown:
			case NSKeyUp:
                c = [[event charactersIgnoringModifiers] characterAtIndex:0];
            
                switch ( c )
                {
                    case NSUpArrowFunctionKey:
                        c = VK_UP;
                        break;
                    case NSDownArrowFunctionKey:
                        c = VK_DOWN;
                        break;
                    case NSLeftArrowFunctionKey:
                        c = VK_LEFT;
                        break;
                    case NSRightArrowFunctionKey:
                        c = VK_RIGHT;
                        break;
                    case 127: // on mac 'del' is backspace
                        c = VK_BACK;
                        break;
                }
                
                c = toupper(c);
                
                if ( [event type] == NSKeyDown )
                    m_SetKeysDown.insert( c );
                else
                    m_SetKeysDown.erase( c );
				continue;
            
            case NSFlagsChanged:
                c = [event modifierFlags];
                UpdateKey( VK_SHIFT, c & NSShiftKeyMask );
                UpdateKey( VK_CONTROL, c & NSControlKeyMask );
                UpdateKey( VK_SELECT, c & NSAlternateKeyMask );
                continue;
            
		}

        [pApp sendEvent:event];
        [pApp updateWindows];
    } while ( !BShuttingDown() );

    [pool release];
}

//-----------------------------------------------------------------------------
// Purpose: Find out if a key is currently down
//-----------------------------------------------------------------------------
bool CGameEngineGL::BIsKeyDown( DWORD dwVK )
{
	std::set<DWORD>::iterator iter;
	iter = m_SetKeysDown.find( dwVK );
	if ( iter != m_SetKeysDown.end() )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Get a down key value
//-----------------------------------------------------------------------------
bool CGameEngineGL::BGetFirstKeyDown( DWORD *pdwVK )
{
	std::set<DWORD>::iterator iter;
	iter = m_SetKeysDown.begin();
	if ( iter != m_SetKeysDown.end() )
	{
		*pdwVK = *iter;
		m_SetKeysDown.erase( iter );
		return true;
	}
	else
	{
		return false;
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
HGAMEVOICECHANNEL CGameEngineGL::HCreateVoiceChannel()
{
	m_unVoiceChannelCount++;
	CVoiceContext* pVoiceContext = new CVoiceContext;
    
	m_MapVoiceChannel[m_unVoiceChannelCount] = pVoiceContext;
	
	return m_unVoiceChannelCount;
}

void CGameEngineGL::RunAudio()
{
	std::map<HGAMEVOICECHANNEL, CVoiceContext* >::iterator iter;

	for( iter = m_MapVoiceChannel.begin(); iter!=m_MapVoiceChannel.end(); ++iter)
	{
		CVoiceContext* pVoice = iter->second;

		const int nBufferCount =  ARRAYSIZE( pVoice->m_buffers );
		ALint nQueued, nProcessed;
		alGetSourcei( pVoice->m_nSource, AL_BUFFERS_QUEUED, &nQueued );
		alGetSourcei( pVoice->m_nSource, AL_BUFFERS_PROCESSED, &nProcessed );
		
		if ( ( nQueued == nBufferCount ) && ( nProcessed == 0 ) )
		{	// No room at the inn
			continue;
		}
		
		ALuint nBufferID;
		for ( int i = 0; i < nProcessed; i++ )
			alSourceUnqueueBuffers( pVoice->m_nSource, 1, &nBufferID );
		
		int nMaxToQueue = nBufferCount - nQueued + nProcessed;
		bool bQueued = false;
		
		while ( nMaxToQueue && !pVoice->m_pending.empty() )
		{
			Packet_t &packet = pVoice->m_pending.front();
			
			nBufferID = pVoice->m_buffers[ pVoice->m_nNextFreeBuffer ];
			alBufferData( nBufferID, AL_FORMAT_MONO16, packet.pData, packet.unSize, VOICE_OUTPUT_SAMPLE_RATE_IDEAL );
			pVoice->m_nNextFreeBuffer = (pVoice->m_nNextFreeBuffer + 1 ) % nBufferCount;
			
            alSourceQueueBuffers( pVoice->m_nSource, 1, &nBufferID);

			nMaxToQueue--;
			free( packet.pData );
			pVoice->m_pending.pop();
			bQueued = true;
        }
	
		if ( bQueued && ( (nQueued-nProcessed) == 0 ) )
		{
			alSourcePlay( pVoice->m_nSource );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CGameEngineGL::DestroyVoiceChannel( HGAMEVOICECHANNEL hChannel )
{
	std::map<HGAMEVOICECHANNEL, CVoiceContext* >::iterator iter;
	iter = m_MapVoiceChannel.find( hChannel );
	if ( iter != m_MapVoiceChannel.end() )
	{
		CVoiceContext* pVoiceContext = iter->second;
		
		// free outstanding voice packets

		while( !pVoiceContext->m_pending.empty() )
		{
			free( pVoiceContext->m_pending.front().pData );
			pVoiceContext->m_pending.pop();
		}

		delete pVoiceContext;
		m_MapVoiceChannel.erase( iter );
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CGameEngineGL::AddVoiceData( HGAMEVOICECHANNEL hChannel, const uint8 *pVoiceData, uint32 uLength )
{
	std::map<HGAMEVOICECHANNEL, CVoiceContext* >::iterator iter;
	iter = m_MapVoiceChannel.find( hChannel );
	if ( iter == m_MapVoiceChannel.end() )
		return false; // channel not found

	CVoiceContext* pVoiceContext = iter->second;

	Packet_t packet;

	packet.pData = malloc ( uLength );
	memcpy( packet.pData, pVoiceData, uLength );
	packet.unSize = uLength;

	pVoiceContext->m_pending.push( packet );

	return true;
}


#if DX9MODE

//-----------------------------------------------------------------------------
// Purpose: return a pointer to a display db object, created on demand
//-----------------------------------------------------------------------------

GLMDisplayDB	*CGameEngineGL::GetDisplayDB( void )
{
	if (!m_displayDB)
	{
		m_displayDB = new GLMDisplayDB;		
		m_displayDB->Populate();
	}
	
	return m_displayDB;
}

//-----------------------------------------------------------------------------
// Purpose: allow dxabstract to read back the capabilities of the selected renderer
//-----------------------------------------------------------------------------

void	CGameEngineGL::GetRendererInfo( GLMRendererInfoFields *rendInfoOut )
{
	// hardwired to renderer 0 which is fine on any single monitor system
	if (rendInfoOut)
	{
		GLMDisplayDB *db = GetDisplayDB();
		*rendInfoOut = ((*db->m_renderers)[ 0 ])->m_info;
	}
}

PseudoNSGLContextPtr CGameEngineGL::GetNSGLContextForWindow ( void* windowref )
{
	WindowRef win = (WindowRef)windowref;
	
	if (win==[m_window windowRef])
	{
		PseudoNSGLContextPtr nsctx = [ m_view openGLContext ];
		
		Assert( nsctx != NULL );
		
		return nsctx;
	}
	else
	{
		return NULL;	// sorry, no idea
	}
}


//-----------------------------------------------------------------------------
// Purpose: either set or get the rendered size 
//-----------------------------------------------------------------------------

void	CGameEngineGL::RenderedSize( uint &width, uint &height, bool set )
{
	if (set)
	{
		Assert( 0 );	// not impl'd yet
	}
	else
	{
		width = m_nWindowWidth;
		height = m_nWindowHeight;
	}
}


//-----------------------------------------------------------------------------
// Purpose: get the displayed size which need not match the rendered size
//-----------------------------------------------------------------------------

void	CGameEngineGL::DisplayedSize( uint &width, uint &height )
{
	width = m_nWindowWidth;
	height = m_nWindowHeight;
}

//-----------------------------------------------------------------------------
// Purpose: display completed frame - assumes GLM/DXA already blitted final bits into back buffer of m_view's context
//-----------------------------------------------------------------------------

void	CGameEngineGL::ShowPixels		( CShowPixelsParams *params )
{
	Assert( m_window != NULL );
	Assert( m_view != NULL );

	[ [ m_view openGLContext ] makeCurrentContext ];

	//if (!params->m_onlySyncView)
	{
		// save old context
		NSOpenGLContext *oldctx = [ NSOpenGLContext currentContext ];
		
		// get target context
		NSOpenGLContext *newctx = [ m_view openGLContext ];
		
		// make it current
		[newctx makeCurrentContext];

		[newctx flushBuffer];	

		[oldctx makeCurrentContext];
	}
}
	
#endif

//-----------------------------------------------------------------------------
// Purpose: Return true if there is an active Steam Controller
//-----------------------------------------------------------------------------
bool CGameEngineGL::BIsSteamControllerActive( )
{
	if ( m_ActiveControllerHandle )
	{
		return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Initialize the steam controller actions
//-----------------------------------------------------------------------------
void CGameEngineGL::InitSteamController( )
{
	// Digital game actions
	m_ControllerDigitalActionHandles[eControllerDigitalAction_TurnLeft] = SteamController( )->GetDigitalActionHandle( "turn_left" );
	m_ControllerDigitalActionHandles[eControllerDigitalAction_TurnRight] = SteamController( )->GetDigitalActionHandle( "turn_right" );
	m_ControllerDigitalActionHandles[eControllerDigitalAction_ForwardThrust] = SteamController( )->GetDigitalActionHandle( "forward_thrust" );
	m_ControllerDigitalActionHandles[eControllerDigitalAction_ReverseThrust] = SteamController( )->GetDigitalActionHandle( "backward_thrust" );
	m_ControllerDigitalActionHandles[eControllerDigitalAction_FireLasers] = SteamController( )->GetDigitalActionHandle( "fire_lasers" );
	m_ControllerDigitalActionHandles[eControllerDigitalAction_PauseMenu] = SteamController( )->GetDigitalActionHandle( "pause_menu" );

	m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuUp] = SteamController( )->GetDigitalActionHandle( "menu_up" );
	m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuDown] = SteamController( )->GetDigitalActionHandle( "menu_down" );
	m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuLeft] = SteamController( )->GetDigitalActionHandle( "menu_left" );
	m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuRight] = SteamController( )->GetDigitalActionHandle( "menu_right" );
	m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuSelect] = SteamController( )->GetDigitalActionHandle( "menu_select" );
	m_ControllerDigitalActionHandles[eControllerDigitalAction_MenuCancel] = SteamController( )->GetDigitalActionHandle( "menu_cancel" );

	// Analog game actions
	m_ControllerAnalogActionHandles[eControllerAnalogAction_AnalogControls] = SteamController( )->GetAnalogActionHandle( "analog_controls" );

	// Action set handles
	m_ControllerActionSetHandles[eControllerActionSet_ShipControls] = SteamController( )->GetActionSetHandle( "ship_controls" );
	m_ControllerActionSetHandles[eControllerActionSet_MenuControls] = SteamController( )->GetActionSetHandle( "menu_controls" );

}

//-----------------------------------------------------------------------------
// Purpose: Find an active Steam controller
//-----------------------------------------------------------------------------
void CGameEngineGL::FindActiveSteamController( )
{
	// Use the first available steam controller for all interaction. We can call this each frame to handle
	// a controller disconnecting and a different one reconnecting. Handles are guaranteed to be unique for
	// a given controller, even across power cycles.

	// See how many Steam Controllers are active. 
	ControllerHandle_t pHandles[STEAM_CONTROLLER_MAX_COUNT];
	int nNumActive = SteamController( )->GetConnectedControllers( pHandles );

	// If there's an active controller, and if we're not already using it, select the first one.
	if ( nNumActive && (m_ActiveControllerHandle != pHandles[0]) )
	{
		m_ActiveControllerHandle = pHandles[0];
	}
}


//--------------------------------------------------------------------------------------------------------------
// Purpose: For a given in-game action in a given action set, return a human-reaadable string to use as a prompt.
//--------------------------------------------------------------------------------------------------------------
const char *CGameEngineGL::GetTextStringForControllerOriginDigital( ECONTROLLERACTIONSET dwActionSet, ECONTROLLERDIGITALACTION dwDigitalAction )
{
	EControllerActionOrigin origins[STEAM_CONTROLLER_MAX_ORIGINS];
	int nNumOrigins = SteamController( )->GetDigitalActionOrigins( m_ActiveControllerHandle, m_ControllerActionSetHandles[dwActionSet], m_ControllerDigitalActionHandles[dwDigitalAction], origins );

	if ( nNumOrigins )
	{
		// We should handle the case where this action is bound to multiple buttons, but
		// here we just grab the first.
		return SteamController()->GetStringForActionOrigin( origins[0] );
	}

	return SteamController()->GetStringForActionOrigin( k_EControllerActionOrigin_None ); // Return "None"
}

//--------------------------------------------------------------------------------------------------------------
// Purpose: For a given in-game action in a given action set, return a human-reaadable string to use as a prompt.
//--------------------------------------------------------------------------------------------------------------
const char *CGameEngineGL::GetTextStringForControllerOriginAnalog( ECONTROLLERACTIONSET dwActionSet, ECONTROLLERANALOGACTION dwDigitalAction )
{
	EControllerActionOrigin origins[STEAM_CONTROLLER_MAX_ORIGINS];
	int nNumOrigins = SteamController( )->GetAnalogActionOrigins( m_ActiveControllerHandle, m_ControllerActionSetHandles[dwActionSet], m_ControllerDigitalActionHandles[dwDigitalAction], origins );

	if ( nNumOrigins )
	{
		// We should handle the case where this action is bound to multiple buttons, but
		// here we just grab the first.
		return SteamController()->GetStringForActionOrigin( origins[0] );
	}

	return SteamController()->GetStringForActionOrigin( k_EControllerActionOrigin_None ); // Return "None"
}

//-----------------------------------------------------------------------------
// Purpose: Called each frame
//-----------------------------------------------------------------------------
void CGameEngineGL::PollSteamController( )
{
	// There's a bug where the action handles aren't non-zero until a config is done loading. Soon config
	// information will be available immediately. Until then try to init as long as the handles are invalid.
	if ( m_ControllerDigitalActionHandles[eControllerDigitalAction_TurnLeft] == 0 )
	{
		InitSteamController( );
		return;
	}

	// Each frame check our active controller handle
	FindActiveSteamController( );

}

//-----------------------------------------------------------------------------
// Purpose: Set the LED color on the controller, if supported by controller
//-----------------------------------------------------------------------------
void CGameEngineGL::SetControllerColor( uint8 nColorR, uint8 nColorG, uint8 nColorB, unsigned int nFlags )
{
	SteamController()->SetLEDColor( m_ActiveControllerHandle, nColorR, nColorG, nColorB, nFlags );
}

//-----------------------------------------------------------------------------
// Purpose: Trigger vibration on the controller, if supported by controller
//-----------------------------------------------------------------------------
void CGameEngineGL::TriggerControllerVibration( unsigned short nLeftSpeed, unsigned short nRightSpeed )
{
	SteamController()->TriggerVibration( m_ActiveControllerHandle, nLeftSpeed, nRightSpeed );
}

//-----------------------------------------------------------------------------
// Purpose: Trigger haptics on the controller, if supported by controller
//-----------------------------------------------------------------------------
void CGameEngineGL::TriggerControllerHaptics( ESteamControllerPad ePad, unsigned short usOnMicroSec, unsigned short usOffMicroSec, unsigned short usRepeat )
{
	SteamController()->TriggerRepeatedHapticPulse( m_ActiveControllerHandle, ePad, usOnMicroSec, usOffMicroSec, usRepeat, 0 );
}

//-----------------------------------------------------------------------------
// Purpose: Find out if a controller event is currently active
//-----------------------------------------------------------------------------
bool CGameEngineGL::BIsControllerActionActive( ECONTROLLERDIGITALACTION dwAction )
{
	ControllerDigitalActionData_t digitalData = SteamController( )->GetDigitalActionData( m_ActiveControllerHandle, m_ControllerDigitalActionHandles[dwAction] );

	// Actions are only 'active' when they're assigned to a control in an action set, and that action set is active.
	if ( digitalData.bActive )
		return digitalData.bState;
	
	return false;
}

//---------------------------------------------------------------------------------------------------------------------------------------------------
// Purpose: Get the current x,y state of the analog action. Examples of an analog action are a virtual joystick on the trackpad or the real joystick.
//---------------------------------------------------------------------------------------------------------------------------------------------------
void CGameEngineGL::GetControllerAnalogAction( ECONTROLLERANALOGACTION dwAction, float *x, float *y )
{
	ControllerAnalogActionData_t analogData = SteamController( )->GetAnalogActionData( m_ActiveControllerHandle, m_ControllerAnalogActionHandles[dwAction] );

	// Actions are only 'active' when they're assigned to a control in an action set, and that action set is active.
	if ( analogData.bActive )
	{
		*x = analogData.x;
		*y = analogData.y;
	}
	else
	{
		*x = 0.0f;
		*y = 0.0f;
	}
}

//-----------------------------------------------------------------------------------------------------------------------------------------------------
// Purpose: Put the controller into a specific action set. Action sets are collections of game-context actions ie "walking", "flying" or "menu"
//-----------------------------------------------------------------------------------------------------------------------------------------------------
void CGameEngineGL::SetSteamControllerActionSet( ECONTROLLERACTIONSET dwActionSet )
{
	if ( m_ActiveControllerHandle == 0 )
		return;

	// This call is low-overhead and can be called repeatedly from game code that is active in a specific mode.
	SteamController( )->ActivateActionSet( m_ActiveControllerHandle, m_ControllerActionSetHandles[dwActionSet] );
}

