1HEADmaster

1 files changed, 1567 insertions, 0 deletions

diff --git a/materialsystem/shaderapidx9/d3d_async.h b/materialsystem/shaderapidx9/d3d_async.h
new file mode 100644
index 0000000..7deb2f3
--- /dev/null
+++ b/materialsystem/shaderapidx9/d3d_async.h
@@ -0,0 +1,1567 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//
+//===========================================================================//
+
+#ifdef D3D_ASYNC_SUPPORTED
+
+#ifndef D3DASYNC_H
+#define D3DASYNC_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+// Set this to 1 to allow d3d calls to be buffered and played back on another thread
+// Slamming this off - it's causing very hot D3D9 function calls to not be inlined and contain a bunch of unused code. (Does this code even work/add real value any more?)
+#define SHADERAPI_USE_SMP 0
+
+// Set this to 1 to allow buffering of the whole frame to memory and then playback (singlethreaded).  
+// This is for debugging only and is used to test the performance of just calling D3D and rendering without other CPU overhead.
+#define SHADERAPI_BUFFER_D3DCALLS 0
+
+#if SHADERAPI_BUFFER_D3DCALLS && !SHADERAPI_USE_SMP
+#	error "SHADERAPI_USE_SMP must be 1 for SHADERAPI_BUFFER_D3DCALLS to work!"
+#endif
+
+#include "recording.h"
+#include "strtools.h"
+#include "glmgr/dxabstract.h"
+
+#ifdef NDEBUG
+#define DO_D3D(x) Dx9Device()->x
+#else
+#define DO_D3D(x) Dx9Device()->x
+//#define DO_D3D(x) { HRESULT	hr=Dx9Device()->x; Assert( !FAILED(hr) ); }
+#endif
+
+#define PUSHBUFFER_NELEMS 4096
+
+enum PushBufferState 
+{
+	PUSHBUFFER_AVAILABLE,
+	PUSHBUFFER_BEING_FILLED,
+	PUSHBUFFER_SUBMITTED,
+	PUSHBUFFER_BEING_USED_FOR_LOCKEDDATA,
+};
+
+class PushBuffer
+{
+	friend class D3DDeviceWrapper;
+
+	volatile PushBufferState m_State;
+	uint32 m_BufferData[PUSHBUFFER_NELEMS];
+public:
+	PushBuffer(void)
+	{
+		m_State = PUSHBUFFER_AVAILABLE;
+	}
+};
+
+// When running multithreaded, lock for write calls actually return a pointer to temporary memory
+// buffer. When the buffer is later unlocked by the caller, data must be queued with the Unlock()
+// that lets the d3d thread know how much data to copy from where.  One possible optimization for
+// things which write a lot of data into lock buffers woudl be to proviude a way for the caller to
+// occasionally check if the Lock() has been dequeued. If so, the the data pushed so far could be
+// copied asynchronously into the buffer, while the caller would be told to switch to writing
+// directly to the vertex buffer.
+//
+// another possibility would be lock()ing in advance for large ones, such as the world renderer,
+// or keeping multiple locked vb's open for meshbuilder.
+
+struct LockedBufferContext
+{
+	PushBuffer *m_pPushBuffer;								// if a push buffer was used to hold
+															// the temporary data, this will be non-null
+	void *m_pMallocedMemory;								// if memory had to be malloc'd, this will be set.
+
+	size_t m_MallocSize;									// # of bytes malloced if mallocedmem ptr non-null
+
+	LockedBufferContext( void )
+	{
+		m_pPushBuffer = NULL;
+		m_pMallocedMemory = NULL;
+	}
+
+};
+
+
+
+// push buffer commands follow
+enum PushBufferCommand
+{
+	PBCMD_END,												// at end of push buffer
+	PBCMD_SET_RENDERSTATE,									// state, val
+	PBCMD_SET_TEXTURE,										// stage, txtr
+	PBCMD_DRAWPRIM,											// prim type, start v, nprims
+	PBCMD_DRAWINDEXEDPRIM,									// prim type, baseidx, minidx, numv, starti, pcount
+	PBCMD_SET_PIXEL_SHADER,									// shaderptr
+	PBCMD_SET_VERTEX_SHADER,								// shaderptr
+	PBCMD_SET_PIXEL_SHADER_CONSTANT,						// startreg, nregs, data...
+	PBCMD_SET_BOOLEAN_PIXEL_SHADER_CONSTANT,				// startreg, nregs, data...
+	PBCMD_SET_INTEGER_PIXEL_SHADER_CONSTANT,				// startreg, nregs, data...
+	PBCMD_SET_VERTEX_SHADER_CONSTANT,						// startreg, nregs, data...
+	PBCMD_SET_BOOLEAN_VERTEX_SHADER_CONSTANT,				// startreg, nregs, data...
+	PBCMD_SET_INTEGER_VERTEX_SHADER_CONSTANT,				// startreg, nregs, data...
+	PBCMD_SET_RENDER_TARGET,								// idx, targetptr
+	PBCMD_SET_DEPTH_STENCIL_SURFACE,						// surfptr
+	PBCMD_SET_STREAM_SOURCE,								// idx, sptr, ofs, stride
+	PBCMD_SET_INDICES,										// idxbuffer
+	PBCMD_SET_SAMPLER_STATE,								// stage, state, val
+	PBCMD_UNLOCK_VB,										// vptr
+	PBCMD_UNLOCK_IB,										// idxbufptr
+	PBCMD_SETVIEWPORT,										// vp_struct
+	PBCMD_CLEAR,											// count, n rect structs, flags, color, z, stencil
+	PBCMD_SET_VERTEXDECLARATION,							// vdeclptr
+	PBCMD_BEGIN_SCENE,										// 
+	PBCMD_END_SCENE,										// 
+	PBCMD_PRESENT,											// complicated..see code
+	PBCMD_SETCLIPPLANE,										// idx, 4 floats
+	PBCMD_STRETCHRECT,										// see code
+	PBCMD_ASYNC_LOCK_VB,									// see code
+	PBCMD_ASYNC_UNLOCK_VB,
+	PBCMD_ASYNC_LOCK_IB,									// see code
+	PBCMD_ASYNC_UNLOCK_IB,
+	PBCMD_SET_SCISSOR_RECT,									// RECT
+};
+
+
+
+#define N_DWORDS( x ) (( sizeof(x)+3)/sizeof( DWORD ))
+#define N_DWORDS_IN_PTR (N_DWORDS( void * ))
+
+class D3DDeviceWrapper
+{
+private:
+	IDirect3DDevice9 *m_pD3DDevice;
+	bool m_bSupportsTessellation;
+	int m_nCurrentTessLevel;
+	TessellationMode_t m_nTessellationMode;
+
+#if SHADERAPI_USE_SMP
+	uintptr_t m_pASyncThreadHandle;
+	PushBuffer *m_pCurPushBuffer;
+	uint32 *m_pOutputPtr;
+	size_t m_PushBufferFreeSlots;
+#endif
+
+#if SHADERAPI_BUFFER_D3DCALLS
+	bool m_bBufferingD3DCalls;
+#	define SHADERAPI_BUFFER_MAXRENDERTARGETS 4
+	IDirect3DSurface9 *m_StoredRenderTargets[SHADERAPI_BUFFER_MAXRENDERTARGETS];
+#endif
+
+	PushBuffer *FindFreePushBuffer( PushBufferState newstate );	// find a free push buffer and change its state
+
+	void GetPushBuffer(void);								// set us up to point at a new push buffer
+	void SubmitPushBufferAndGetANewOne(void);				// submit the current push buffer
+	void ExecutePushBuffer( PushBuffer const *pb);
+
+#if	SHADERAPI_USE_SMP
+	void Synchronize(void);									// wait for all commands to be done
+#else
+	FORCEINLINE void Synchronize(void)
+	{
+	}
+#endif
+
+
+	void SubmitIfNotBusy(void);
+
+#if	SHADERAPI_USE_SMP	
+	template<class T> FORCEINLINE void PushStruct( PushBufferCommand cmd, T const *str )
+	{
+		int nwords=N_DWORDS( T );
+		AllocatePushBufferSpace( 1+ nwords );
+		m_pOutputPtr[0]=cmd;
+		memcpy( m_pOutputPtr+1, str, sizeof( T ) );
+		m_pOutputPtr += 1+nwords;
+	}
+	
+	FORCEINLINE void AllocatePushBufferSpace(size_t nSlots)
+	{
+		// check for N slots of space, and decrement amount of space left
+		if ( nSlots>m_PushBufferFreeSlots )					// out of room?
+		{
+			SubmitPushBufferAndGetANewOne();
+		}
+		m_PushBufferFreeSlots -= nSlots;
+	}
+
+	// simple methods for pushing a few words into output buffer
+	FORCEINLINE void Push( PushBufferCommand cmd )
+	{
+		AllocatePushBufferSpace(1);
+		m_pOutputPtr[0]=cmd;
+		m_pOutputPtr++;
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, int arg1)
+	{
+		AllocatePushBufferSpace(2);
+		m_pOutputPtr[0]=cmd;
+		m_pOutputPtr[1]=arg1;
+		m_pOutputPtr += 2;
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, void *ptr )
+	{
+		AllocatePushBufferSpace(1+N_DWORDS_IN_PTR);
+		*(m_pOutputPtr++)=cmd;
+		*((void **) m_pOutputPtr)=ptr;
+		m_pOutputPtr+=N_DWORDS_IN_PTR;
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, void *ptr, void *ptr1 )
+	{
+		AllocatePushBufferSpace(1+2*N_DWORDS_IN_PTR);
+		*(m_pOutputPtr++)=cmd;
+		*((void **) m_pOutputPtr)=ptr;
+		m_pOutputPtr+=N_DWORDS_IN_PTR;
+		*((void **) m_pOutputPtr)=ptr1;
+		m_pOutputPtr+=N_DWORDS_IN_PTR;
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, void *arg1, uint32 arg2, uint32 arg3, uint32 arg4,
+					  void *arg5)
+	{
+		AllocatePushBufferSpace(1+N_DWORDS_IN_PTR+1+1+1+N_DWORDS_IN_PTR);
+		*(m_pOutputPtr++)=cmd;
+		*((void **) m_pOutputPtr)=arg1;
+		m_pOutputPtr+=N_DWORDS_IN_PTR;
+		*(m_pOutputPtr++)=arg2;
+		*(m_pOutputPtr++)=arg3;
+		*(m_pOutputPtr++)=arg4;
+		*((void **) m_pOutputPtr)=arg5;
+		m_pOutputPtr+=N_DWORDS_IN_PTR;
+
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, uint32 arg1, void *ptr )
+	{
+		AllocatePushBufferSpace(2+N_DWORDS_IN_PTR);
+		*(m_pOutputPtr++)=cmd;
+		*(m_pOutputPtr++)=arg1;
+		*((void **) m_pOutputPtr)=ptr;
+		m_pOutputPtr+=N_DWORDS_IN_PTR;
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, uint32 arg1, void *ptr, int arg2, int arg3 )
+	{
+		AllocatePushBufferSpace( 4+N_DWORDS_IN_PTR );
+		*(m_pOutputPtr++)=cmd;
+		*(m_pOutputPtr++)=arg1;
+		*((void **) m_pOutputPtr)=ptr;
+		m_pOutputPtr+=N_DWORDS_IN_PTR;
+		m_pOutputPtr[0]=arg2;
+		m_pOutputPtr[1]=arg3;
+		m_pOutputPtr += 2;
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, int arg1, int arg2)
+	{
+		AllocatePushBufferSpace(3);
+		m_pOutputPtr[0]=cmd;
+		m_pOutputPtr[1]=arg1;
+		m_pOutputPtr[2]=arg2;
+		m_pOutputPtr += 3;
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, int arg1, int arg2, int arg3)
+	{
+		AllocatePushBufferSpace(4);
+		m_pOutputPtr[0]=cmd;
+		m_pOutputPtr[1]=arg1;
+		m_pOutputPtr[2]=arg2;
+		m_pOutputPtr[3]=arg3;
+		m_pOutputPtr += 4;
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6 )
+	{
+		AllocatePushBufferSpace(7);
+		m_pOutputPtr[0]=cmd;
+		m_pOutputPtr[1]=arg1;
+		m_pOutputPtr[2]=arg2;
+		m_pOutputPtr[3]=arg3;
+		m_pOutputPtr[4]=arg4;
+		m_pOutputPtr[5]=arg5;
+		m_pOutputPtr[6]=arg6;
+		m_pOutputPtr += 7;
+	}
+
+#else
+	template<class T> FORCEINLINE void PushStruct( PushBufferCommand cmd, T const *str )
+	{
+	}
+	
+	FORCEINLINE void AllocatePushBufferSpace(size_t nSlots)
+	{
+	}
+
+	// simple methods for pushing a few words into output buffer
+	FORCEINLINE void Push( PushBufferCommand cmd )
+	{
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, int arg1)
+	{
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, void *ptr )
+	{
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, void *ptr, void *ptr1 )
+	{
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, void *arg1, uint32 arg2, uint32 arg3, uint32 arg4,
+					  void *arg5)
+	{
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, uint32 arg1, void *ptr )
+	{
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, uint32 arg1, void *ptr, int arg2, int arg3 )
+	{
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, int arg1, int arg2)
+	{
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, int arg1, int arg2, int arg3)
+	{
+	}
+
+	FORCEINLINE void Push( PushBufferCommand cmd, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6 )
+	{
+	}
+
+#endif
+
+	FORCEINLINE bool ASyncMode(void) const
+	{
+#if SHADERAPI_USE_SMP
+#	if SHADERAPI_BUFFER_D3DCALLS
+		return m_bBufferingD3DCalls;
+#	else
+		return (m_pASyncThreadHandle != 0 );
+#	endif
+#else
+		return false;
+#endif
+	}
+
+	FORCEINLINE IDirect3DDevice9* Dx9Device(void) const
+	{
+		return m_pD3DDevice;
+	}
+
+	void  AsynchronousLock( IDirect3DVertexBuffer9* vb, size_t offset, size_t size, void **ptr,
+							DWORD flags,
+							LockedBufferContext *lb);
+
+	void  AsynchronousLock( IDirect3DIndexBuffer9* ib, size_t offset, size_t size, void **ptr,
+							DWORD flags,
+							LockedBufferContext *lb);
+
+	// handlers for push buffer contexts
+	void HandleAsynchronousLockVBCommand( uint32 const *dptr );
+	void HandleAsynchronousUnLockVBCommand( uint32 const *dptr );
+	void HandleAsynchronousLockIBCommand( uint32 const *dptr );
+	void HandleAsynchronousUnLockIBCommand( uint32 const *dptr );
+
+public:
+
+#if SHADERAPI_BUFFER_D3DCALLS
+	void ExecuteAllWork( void );
+#endif
+	void RunThread( void );									// this is what the worker thread runs
+
+	void SetASyncMode( bool onoff );
+
+
+	bool IsActive( void )const
+	{
+		return m_pD3DDevice != NULL;
+	}
+
+	void D3DeviceWrapper(void)
+	{
+		m_pD3DDevice = 0;
+#if SHADERAPI_USE_SMP
+		m_pASyncThreadHandle = 0;
+#endif
+#if SHADERAPI_BUFFER_D3DCALLS
+		m_bBufferingD3DCalls = false;
+#endif
+	}
+	
+	void SetDevicePtr(IDirect3DDevice9 *pD3DDev )
+	{
+		m_pD3DDevice = pD3DDev;
+	}
+
+	void SetSupportsTessellation( bool bSupportsTessellation )
+	{
+		m_bSupportsTessellation = bSupportsTessellation;
+	}
+
+	void ShutDownDevice(void)
+	{
+		if ( ASyncMode() )
+		{
+			// sync w/ thread
+		}
+		m_pD3DDevice = 0;
+	}
+
+	void FORCEINLINE SetDepthStencilSurface( IDirect3DSurface9 *new_stencil )
+	{
+		if ( ASyncMode() )
+			Push( PBCMD_SET_DEPTH_STENCIL_SURFACE, new_stencil );
+		else
+			DO_D3D( SetDepthStencilSurface( new_stencil ) );
+	}
+	
+	HRESULT CreateCubeTexture(
+		UINT EdgeLength,
+		UINT Levels,
+		DWORD Usage,
+		D3DFORMAT Format,
+		D3DPOOL Pool,
+		IDirect3DCubeTexture9 ** ppCubeTexture,
+		HANDLE* pSharedHandle,
+		char *debugLabel = NULL				// <-- OK to not pass this arg, only passed through on DX_TO_GL_ABSTRACTION
+		)
+	{
+		Synchronize();
+		return m_pD3DDevice->CreateCubeTexture( EdgeLength, Levels, Usage, Format, Pool,
+												ppCubeTexture, pSharedHandle
+											#if defined( DX_TO_GL_ABSTRACTION )
+												,debugLabel
+											#endif
+											  );
+	}
+
+	HRESULT CreateVolumeTexture(
+		UINT Width,
+		UINT Height,
+		UINT Depth,
+		UINT Levels,
+		DWORD Usage,
+		D3DFORMAT Format,
+		D3DPOOL Pool,
+		IDirect3DVolumeTexture9** ppVolumeTexture,
+		HANDLE* pSharedHandle,
+		char *debugLabel = NULL				// <-- OK to not pass this arg, only passed through on DX_TO_GL_ABSTRACTION
+		)
+	{
+		Synchronize();
+		return m_pD3DDevice->CreateVolumeTexture( Width, Height, Depth, Levels,
+												  Usage, Format, Pool, ppVolumeTexture,
+												  pSharedHandle
+											#if defined( DX_TO_GL_ABSTRACTION )
+												,debugLabel
+											#endif
+												  );
+	}
+
+	HRESULT CreateOffscreenPlainSurface( UINT Width,
+										 UINT Height,
+										 D3DFORMAT Format,
+										 D3DPOOL Pool,
+										 IDirect3DSurface9** ppSurface,
+										 HANDLE* pSharedHandle)
+	{
+		Synchronize();
+		return m_pD3DDevice->CreateOffscreenPlainSurface( Width, Height, Format, Pool,
+														  ppSurface, pSharedHandle);
+	}
+	
+	HRESULT CreateTexture(
+		UINT Width,
+		UINT Height,
+		UINT Levels,
+		DWORD Usage,
+		D3DFORMAT Format,
+		D3DPOOL Pool,
+		IDirect3DTexture9** ppTexture,
+		HANDLE* pSharedHandle,
+		char *debugLabel = NULL				// <-- OK to not pass this arg, only passed through on DX_TO_GL_ABSTRACTION
+		)
+	{
+		Synchronize();
+		return m_pD3DDevice->CreateTexture( Width, Height, Levels, Usage, 
+											Format, Pool, ppTexture, pSharedHandle
+											#if defined( DX_TO_GL_ABSTRACTION )
+												,debugLabel
+											#endif
+											);
+	}
+
+	HRESULT GetRenderTargetData(
+		IDirect3DSurface9* pRenderTarget,
+		IDirect3DSurface9* pDestSurface
+		)
+	{
+		Synchronize();
+		return m_pD3DDevice->GetRenderTargetData( pRenderTarget, pDestSurface );
+	}
+
+
+	void GetDeviceCaps( D3DCAPS9 * pCaps )
+	{
+		Synchronize();
+		m_pD3DDevice->GetDeviceCaps( pCaps );
+	}
+
+	LPCSTR GetPixelShaderProfile( void )
+	{
+		Synchronize();
+		return D3DXGetPixelShaderProfile( m_pD3DDevice );
+	}
+
+	HRESULT TestCooperativeLevel( void )
+	{
+	// hack!  We are going to assume that calling this immediately when in buffered mode isn't going to cause problems.
+#if !SHADERAPI_BUFFER_D3DCALLS
+		Synchronize();
+#endif
+		return m_pD3DDevice->TestCooperativeLevel();
+	}
+
+	HRESULT GetFrontBufferData( UINT  iSwapChain, IDirect3DSurface9 * pDestSurface )
+	{
+		Synchronize();
+		return m_pD3DDevice->GetFrontBufferData( iSwapChain, pDestSurface );
+	}
+
+	void SetGammaRamp( int swapchain, int flags, D3DGAMMARAMP const *pRamp)
+	{
+		Synchronize();
+		m_pD3DDevice->SetGammaRamp( swapchain, flags, pRamp);
+	}
+
+	HRESULT GetTexture(  DWORD Stage,  IDirect3DBaseTexture9 ** ppTexture )
+	{
+		Synchronize();
+		return m_pD3DDevice->GetTexture( Stage, ppTexture );
+	}
+
+	HRESULT GetFVF( DWORD * pFVF )
+	{
+		Synchronize();
+		return m_pD3DDevice->GetFVF( pFVF );
+	}
+
+	HRESULT GetDepthStencilSurface(
+		IDirect3DSurface9 ** ppZStencilSurface
+		)
+	{
+		Synchronize();
+		return m_pD3DDevice->GetDepthStencilSurface( ppZStencilSurface );
+	}
+
+	FORCEINLINE void SetClipPlane( int idx, float const * pplane)
+	{
+		RECORD_COMMAND( DX8_SET_CLIP_PLANE, 5 );
+		RECORD_INT( idx );
+		RECORD_FLOAT( pplane[0] );
+		RECORD_FLOAT( pplane[1] );
+		RECORD_FLOAT( pplane[2] );
+		RECORD_FLOAT( pplane[3] );
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			AllocatePushBufferSpace( 6 );
+			m_pOutputPtr[0]=PBCMD_SETCLIPPLANE;
+			m_pOutputPtr[1]=idx;
+			memcpy(m_pOutputPtr+2,pplane, 4*sizeof(float) );
+			m_pOutputPtr += 6;
+		}
+		else
+#endif
+			DO_D3D( SetClipPlane( idx, pplane ) );
+	}
+
+	FORCEINLINE void SetVertexDeclaration( IDirect3DVertexDeclaration9 *decl )
+	{
+		RECORD_COMMAND( DX8_SET_VERTEX_DECLARATION, 1 );
+		RECORD_INT( ( int ) decl );
+
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			Push( PBCMD_SET_VERTEXDECLARATION, decl );
+		}
+		else
+#endif
+			DO_D3D( SetVertexDeclaration( decl ) );
+	}
+
+	FORCEINLINE void SetViewport( D3DVIEWPORT9 const *vp )
+	{
+		RECORD_COMMAND( DX8_SET_VIEWPORT, 1 );
+		RECORD_STRUCT( vp, sizeof( *vp ));
+
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+			PushStruct( PBCMD_SETVIEWPORT, vp );
+		else
+#endif
+			DO_D3D( SetViewport( vp ) );
+	}
+
+	HRESULT GetRenderTarget(
+		DWORD RenderTargetIndex,
+		IDirect3DSurface9 ** ppRenderTarget)
+	{
+#if SHADERAPI_BUFFER_D3DCALLS
+		if ( ASyncMode() )
+		{
+			Assert( RenderTargetIndex >= 0 && RenderTargetIndex < SHADERAPI_BUFFER_MAXRENDERTARGETS );
+			*ppRenderTarget = m_StoredRenderTargets[RenderTargetIndex];
+			return D3D_OK;
+		}
+#endif
+		Synchronize();
+		return m_pD3DDevice->GetRenderTarget( RenderTargetIndex, ppRenderTarget );
+	}
+
+	HRESULT CreateQuery( D3DQUERYTYPE Type, IDirect3DQuery9** ppQuery )
+	{
+		Synchronize();
+		return m_pD3DDevice->CreateQuery( Type, ppQuery );
+	}
+
+	HRESULT CreateRenderTarget(
+		UINT Width,
+		UINT Height,
+		D3DFORMAT Format,
+		D3DMULTISAMPLE_TYPE MultiSample,
+		DWORD MultisampleQuality,
+		BOOL Lockable,
+		IDirect3DSurface9** ppSurface,
+		HANDLE* pSharedHandle
+		)
+	{
+		Synchronize();
+		return m_pD3DDevice->CreateRenderTarget( Width, Height, Format, MultiSample,
+												 MultisampleQuality, Lockable, ppSurface,
+												 pSharedHandle);
+	}
+
+	HRESULT CreateDepthStencilSurface(
+		UINT Width,
+		UINT Height,
+		D3DFORMAT Format,
+		D3DMULTISAMPLE_TYPE MultiSample,
+		DWORD MultisampleQuality,
+		BOOL Discard,
+		IDirect3DSurface9** ppSurface,
+		HANDLE* pSharedHandle
+		)
+	{
+		Synchronize();
+		return m_pD3DDevice->CreateDepthStencilSurface( Width, Height, Format, MultiSample,
+														MultisampleQuality, Discard, ppSurface,
+														pSharedHandle );
+	}
+
+
+	FORCEINLINE void SetRenderTarget( int idx, IDirect3DSurface9 *new_rt )
+	{
+		if (ASyncMode())
+		{
+			Push( PBCMD_SET_RENDER_TARGET, idx, new_rt );
+#if SHADERAPI_BUFFER_D3DCALLS
+			m_StoredRenderTargets[idx] = new_rt;
+#endif
+		}
+		else
+		{
+			// NOTE: If the debug runtime breaks here on the shadow depth render target that is normal.  dx9 doesn't directly support shadow
+			// depth texturing so we are forced to initialize this texture without the render target flagr
+			DO_D3D( SetRenderTarget( idx, new_rt) );
+		}
+	}
+
+	FORCEINLINE void LightEnable( int lidx, bool onoff )
+	{
+		RECORD_COMMAND( DX8_LIGHT_ENABLE, 2 );
+		RECORD_INT( lidx );
+		RECORD_INT( onoff );
+
+		Synchronize();
+		DO_D3D( LightEnable( lidx, onoff ) );
+	}
+
+	FORCEINLINE void SetRenderState( D3DRENDERSTATETYPE state, DWORD val )
+	{
+//		Assert( state >= 0 && state < MAX_NUM_RENDERSTATES );
+		RECORD_RENDER_STATE( state, val ); 
+		if (ASyncMode())
+		{
+			Push( PBCMD_SET_RENDERSTATE, state, val );
+		}
+		else
+			DO_D3D( SetRenderState( state, val ) );
+	}
+
+	FORCEINLINE void SetRenderStateInline( D3DRENDERSTATETYPE state, DWORD val )
+	{
+		//		Assert( state >= 0 && state < MAX_NUM_RENDERSTATES );
+		RECORD_RENDER_STATE( state, val ); 
+		if (ASyncMode())
+		{
+			SetRenderState( state, val );
+		}
+		else
+		{
+#ifdef DX_TO_GL_ABSTRACTION
+			DO_D3D( SetRenderStateInline( state, val ) );
+#else
+			DO_D3D( SetRenderState( state, val ) );
+#endif
+		}
+	}
+
+	FORCEINLINE void SetScissorRect( const RECT *pScissorRect )
+	{
+		RECORD_COMMAND( DX8_SET_SCISSOR_RECT, 1 );
+		RECORD_STRUCT( pScissorRect, 4 * sizeof(LONG) );
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			AllocatePushBufferSpace( 5 );
+			m_pOutputPtr[0] = PBCMD_SET_SCISSOR_RECT;
+			memcpy( m_pOutputPtr + 1, pScissorRect, sizeof( *pScissorRect ) );
+		}
+		else
+#endif
+			DO_D3D( SetScissorRect( pScissorRect ) );
+	}
+
+	FORCEINLINE void SetVertexShaderConstantF( UINT StartRegister, CONST float * pConstantData,
+								   UINT Vector4fCount)
+	{
+		RECORD_COMMAND( DX8_SET_VERTEX_SHADER_CONSTANT, 3 );
+		RECORD_INT( StartRegister );
+		RECORD_INT( Vector4fCount );
+		RECORD_STRUCT( pConstantData, Vector4fCount * 4 * sizeof(float) );
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			AllocatePushBufferSpace(3+4*Vector4fCount);
+			m_pOutputPtr[0]=PBCMD_SET_VERTEX_SHADER_CONSTANT;
+			m_pOutputPtr[1]=StartRegister;
+			m_pOutputPtr[2]=Vector4fCount;
+			memcpy(m_pOutputPtr+3,pConstantData,sizeof(float)*4*Vector4fCount);
+			m_pOutputPtr+=3+4*Vector4fCount;
+		}
+		else
+#endif
+			DO_D3D( SetVertexShaderConstantF( StartRegister, pConstantData, Vector4fCount ) );
+	}
+
+	FORCEINLINE void SetVertexShaderConstantB( UINT StartRegister, CONST int * pConstantData,
+		UINT BoolCount)
+	{
+		RECORD_COMMAND( DX8_SET_VERTEX_SHADER_CONSTANT, 3 );
+		RECORD_INT( StartRegister );
+		RECORD_INT( BoolCount );
+		RECORD_STRUCT( pConstantData, BoolCount * sizeof(int) );
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			AllocatePushBufferSpace(3+BoolCount);
+			m_pOutputPtr[0]=PBCMD_SET_BOOLEAN_VERTEX_SHADER_CONSTANT;
+			m_pOutputPtr[1]=StartRegister;
+			m_pOutputPtr[2]=BoolCount;
+			memcpy(m_pOutputPtr+3,pConstantData,sizeof(int)*BoolCount);
+			m_pOutputPtr+=3+BoolCount;
+		}
+		else
+#endif
+			DO_D3D( SetVertexShaderConstantB( StartRegister, pConstantData, BoolCount ) );
+	}
+
+	FORCEINLINE void SetVertexShaderConstantI( UINT StartRegister, CONST int * pConstantData,
+		UINT Vector4IntCount)
+	{
+		RECORD_COMMAND( DX8_SET_VERTEX_SHADER_CONSTANT, 3 );
+		RECORD_INT( StartRegister );
+		RECORD_INT( Vector4IntCount );
+		RECORD_STRUCT( pConstantData, Vector4IntCount * 4 * sizeof(int) );
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			AllocatePushBufferSpace(3+4*Vector4IntCount);
+			m_pOutputPtr[0]=PBCMD_SET_INTEGER_VERTEX_SHADER_CONSTANT;
+			m_pOutputPtr[1]=StartRegister;
+			m_pOutputPtr[2]=Vector4IntCount;
+			memcpy(m_pOutputPtr+3,pConstantData,sizeof(int)*4*Vector4IntCount);
+			m_pOutputPtr+=3+4*Vector4IntCount;
+		}
+		else
+#endif
+			DO_D3D( SetVertexShaderConstantI( StartRegister, pConstantData, Vector4IntCount ) );
+	}
+
+	FORCEINLINE void SetPixelShaderConstantF( UINT StartRegister, CONST float * pConstantData,
+								   UINT Vector4fCount)
+	{
+		RECORD_COMMAND( DX8_SET_PIXEL_SHADER_CONSTANT, 3 );
+		RECORD_INT( StartRegister );
+		RECORD_INT( Vector4fCount );
+		RECORD_STRUCT( pConstantData, Vector4fCount * 4 * sizeof(float) );
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			AllocatePushBufferSpace(3+4*Vector4fCount);
+			m_pOutputPtr[0]=PBCMD_SET_PIXEL_SHADER_CONSTANT;
+			m_pOutputPtr[1]=StartRegister;
+			m_pOutputPtr[2]=Vector4fCount;
+			memcpy(m_pOutputPtr+3,pConstantData,sizeof(float)*4*Vector4fCount);
+			m_pOutputPtr+=3+4*Vector4fCount;
+		}
+		else
+#endif
+			DO_D3D( SetPixelShaderConstantF( StartRegister, pConstantData, Vector4fCount ) );
+	}
+
+	FORCEINLINE void SetPixelShaderConstantB( UINT StartRegister, CONST int * pConstantData,
+		UINT BoolCount)
+	{
+		RECORD_COMMAND( DX8_SET_PIXEL_SHADER_CONSTANT, 3 );
+		RECORD_INT( StartRegister );
+		RECORD_INT( BoolCount );
+		RECORD_STRUCT( pConstantData, BoolCount * sizeof(int) );
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			AllocatePushBufferSpace(3+BoolCount);
+			m_pOutputPtr[0]=PBCMD_SET_BOOLEAN_PIXEL_SHADER_CONSTANT;
+			m_pOutputPtr[1]=StartRegister;
+			m_pOutputPtr[2]=BoolCount;
+			memcpy(m_pOutputPtr+3,pConstantData,sizeof(int)*BoolCount);
+			m_pOutputPtr+=3+BoolCount;
+		}
+		else
+#endif
+			DO_D3D( SetPixelShaderConstantB( StartRegister, pConstantData, BoolCount ) );
+	}
+
+	FORCEINLINE void SetPixelShaderConstantI( UINT StartRegister, CONST int * pConstantData,
+		UINT Vector4IntCount)
+	{
+		RECORD_COMMAND( DX8_SET_PIXEL_SHADER_CONSTANT, 3 );
+		RECORD_INT( StartRegister );
+		RECORD_INT( Vector4IntCount );
+		RECORD_STRUCT( pConstantData, Vector4IntCount * 4 * sizeof(int) );
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			AllocatePushBufferSpace(3+4*Vector4IntCount);
+			m_pOutputPtr[0]=PBCMD_SET_INTEGER_PIXEL_SHADER_CONSTANT;
+			m_pOutputPtr[1]=StartRegister;
+			m_pOutputPtr[2]=Vector4IntCount;
+			memcpy(m_pOutputPtr+3,pConstantData,sizeof(int)*4*Vector4IntCount);
+			m_pOutputPtr+=3+4*Vector4IntCount;
+		}
+		else
+#endif
+			DO_D3D( SetPixelShaderConstantI( StartRegister, pConstantData, Vector4IntCount ) );
+	}
+
+	HRESULT StretchRect( IDirect3DSurface9 * pSourceSurface,
+					  CONST RECT * pSourceRect,
+					  IDirect3DSurface9 * pDestSurface,
+					  CONST RECT * pDestRect,
+					  D3DTEXTUREFILTERTYPE Filter )
+	{
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			AllocatePushBufferSpace(1+1+1+N_DWORDS( RECT )+1+1+N_DWORDS( RECT ) + 1);
+			*(m_pOutputPtr++)=PBCMD_STRETCHRECT;
+			*(m_pOutputPtr++)=(int) pSourceSurface;
+			*(m_pOutputPtr++)=(pSourceRect != NULL);
+			if (pSourceRect)
+			{
+				memcpy(m_pOutputPtr,pSourceRect,sizeof(RECT));
+			}
+			m_pOutputPtr+=N_DWORDS(RECT);
+			*(m_pOutputPtr++)=(int) pDestSurface;
+			*(m_pOutputPtr++)=(pDestRect != NULL);
+			if (pDestRect)
+				memcpy(m_pOutputPtr,pDestRect,sizeof(RECT));
+			m_pOutputPtr+=N_DWORDS(RECT);
+			*(m_pOutputPtr++)=Filter;
+			return S_OK;									// !bug!
+		}
+		else
+#endif
+			return m_pD3DDevice->
+				StretchRect( pSourceSurface, pSourceRect, pDestSurface, pDestRect, Filter );
+	}
+
+
+	FORCEINLINE void BeginScene(void)
+	{
+		RECORD_COMMAND( DX8_BEGIN_SCENE, 0 );
+		if ( ASyncMode() )
+			Push( PBCMD_BEGIN_SCENE );
+		else
+			DO_D3D( BeginScene() );
+	}
+
+	FORCEINLINE void EndScene(void)
+	{
+		RECORD_COMMAND( DX8_END_SCENE, 0 );
+		if ( ASyncMode() )
+			Push( PBCMD_END_SCENE );
+		else
+			DO_D3D( EndScene() );
+	}
+
+	FORCEINLINE HRESULT Lock( IDirect3DVertexBuffer9* vb, size_t offset, size_t size, void **ptr, DWORD flags )
+	{
+		Assert( size );						 // lock size of 0 = unknown entire size of buffer = bad
+		Synchronize();
+
+		HRESULT hr = vb->Lock(offset, size, ptr, flags);
+		switch (hr)
+		{
+			case D3DERR_INVALIDCALL:
+				Warning( "D3DERR_INVALIDCALL - Vertex Buffer Lock Failed in %s on line %d(offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+				break;
+			case D3DERR_DRIVERINTERNALERROR:
+				Warning( "D3DERR_DRIVERINTERNALERROR - Vertex Buffer Lock Failed in %s on line %d (offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+				break;
+			case D3DERR_OUTOFVIDEOMEMORY:
+				Warning( "D3DERR_OUTOFVIDEOMEMORY - Vertex Buffer Lock Failed in %s on line %d (offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+				break;
+		}
+
+		return hr;
+	}
+
+		
+	FORCEINLINE HRESULT  Lock( IDirect3DVertexBuffer9* vb, size_t offset, size_t size, void **ptr,
+							DWORD flags,
+							LockedBufferContext *lb)
+	{
+
+		HRESULT hr = D3D_OK;
+
+		// asynchronous write-only dynamic vb lock
+		if ( ASyncMode() )
+		{
+			AsynchronousLock( vb, offset, size, ptr, flags, lb );
+		}
+		else
+		{
+			hr = vb->Lock(offset, size, ptr, flags);
+			switch (hr)
+			{
+				case D3DERR_INVALIDCALL:
+					Warning( "D3DERR_INVALIDCALL - Vertex Buffer Lock Failed in %s on line %d(offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+					break;
+				case D3DERR_DRIVERINTERNALERROR:
+					Warning( "D3DERR_DRIVERINTERNALERROR - Vertex Buffer Lock Failed in %s on line %d (offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+					break;
+				case D3DERR_OUTOFVIDEOMEMORY:
+					Warning( "D3DERR_OUTOFVIDEOMEMORY - Vertex Buffer Lock Failed in %s on line %d (offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+					break;
+			}
+		}
+
+		return hr;
+	}
+
+	FORCEINLINE HRESULT Lock( IDirect3DIndexBuffer9* ib, size_t offset, size_t size, void **ptr, DWORD flags)
+	{
+		HRESULT hr = D3D_OK;
+
+		Synchronize();
+
+		hr = ib->Lock(offset, size, ptr, flags);
+		switch (hr)
+		{
+			case D3DERR_INVALIDCALL:
+				Warning( "D3DERR_INVALIDCALL - Index Buffer Lock Failed in %s on line %d(offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+				break;
+			case D3DERR_DRIVERINTERNALERROR:
+				Warning( "D3DERR_DRIVERINTERNALERROR - Index Buffer Lock Failed in %s on line %d (offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+				break;
+			case D3DERR_OUTOFVIDEOMEMORY:
+				Warning( "D3DERR_OUTOFVIDEOMEMORY - Index Buffer Lock Failed in %s on line %d (offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+				break;
+		}
+
+		return hr;
+	}
+	
+	// asycnhronous lock of index buffer
+	FORCEINLINE HRESULT Lock( IDirect3DIndexBuffer9* ib, size_t offset, size_t size, void **ptr, DWORD flags,
+						   LockedBufferContext * lb)
+	{
+		HRESULT hr = D3D_OK;
+
+		if ( ASyncMode() )
+			AsynchronousLock( ib, offset, size, ptr, flags, lb );
+		else
+		{
+			hr = ib->Lock(offset, size, ptr, flags);
+			switch (hr)
+			{
+				case D3DERR_INVALIDCALL:
+					Warning( "D3DERR_INVALIDCALL - Index Buffer Lock Failed in %s on line %d(offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+					break;
+				case D3DERR_DRIVERINTERNALERROR:
+					Warning( "D3DERR_DRIVERINTERNALERROR - Index Buffer Lock Failed in %s on line %d (offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+					break;
+				case D3DERR_OUTOFVIDEOMEMORY:
+					Warning( "D3DERR_OUTOFVIDEOMEMORY - Index Buffer Lock Failed in %s on line %d (offset %d, size %d, flags 0x%x)\n", V_UnqualifiedFileName(__FILE__), __LINE__, offset, size, flags );
+					break;
+			}
+		}
+
+		return hr;
+	}
+
+#ifndef DX_TO_GL_ABSTRACTION
+	FORCEINLINE HRESULT  UpdateSurface(	IDirect3DSurface9* pSourceSurface, CONST RECT* pSourceRect, IDirect3DSurface9* pDestSurface, CONST POINT* pDestPoint )
+	{
+		return m_pD3DDevice->UpdateSurface( pSourceSurface, pSourceRect, pDestSurface, pDestPoint );
+	}
+#endif
+
+	void Release( IDirect3DIndexBuffer9* ib )
+	{
+		Synchronize();
+		ib->Release();
+	}
+
+	void Release( IDirect3DVertexBuffer9* vb )
+	{
+		Synchronize();
+		vb->Release();
+	}
+
+	FORCEINLINE void Unlock( IDirect3DVertexBuffer9* vb )
+	{
+		// needed for d3d on pc only
+		if ( ASyncMode() )
+			Push(PBCMD_UNLOCK_VB, vb);
+		else
+		{
+			HRESULT hr = vb->Unlock( );
+
+			if ( FAILED(hr) )
+			{
+				Warning( "Vertex Buffer Unlock Failed in %s on line %d\n", V_UnqualifiedFileName(__FILE__), __LINE__ );
+			}
+		}
+	}
+
+	FORCEINLINE void Unlock( IDirect3DVertexBuffer9* vb, LockedBufferContext *lb, size_t unlock_size)
+	{
+		// needed for d3d on pc only
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			AllocatePushBufferSpace( 1+N_DWORDS_IN_PTR+N_DWORDS( LockedBufferContext )+1 );
+			*(m_pOutputPtr++)=PBCMD_ASYNC_UNLOCK_VB;
+			*((IDirect3DVertexBuffer9* *) m_pOutputPtr)=vb;
+			m_pOutputPtr+=N_DWORDS_IN_PTR;
+			*((LockedBufferContext *) m_pOutputPtr)=*lb;
+			m_pOutputPtr+=N_DWORDS( LockedBufferContext );
+			*(m_pOutputPtr++)=unlock_size;
+		}
+		else
+#endif
+		{
+			HRESULT hr = vb->Unlock();
+
+			if ( FAILED(hr) )
+			{
+				Warning( "Vertex Buffer Unlock Failed in %s on line %d\n", V_UnqualifiedFileName(__FILE__), __LINE__ );
+			}
+		}
+	}
+
+	FORCEINLINE void Unlock( IDirect3DIndexBuffer9* ib )
+	{
+		// needed for d3d on pc only
+		if ( ASyncMode() )
+			Push(PBCMD_UNLOCK_IB, ib);
+		else
+		{
+			HRESULT hr = ib->Unlock();
+
+			if ( FAILED(hr) )
+			{
+				Warning( "Index Buffer Unlock Failed in %s on line %d\n", V_UnqualifiedFileName(__FILE__), __LINE__ );
+			}
+		}
+	}
+
+	FORCEINLINE void Unlock( IDirect3DIndexBuffer9* ib, LockedBufferContext *lb, size_t unlock_size)
+	{
+		// needed for d3d on pc only
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			AllocatePushBufferSpace( 1+N_DWORDS_IN_PTR+N_DWORDS( LockedBufferContext )+1 );
+			*(m_pOutputPtr++)=PBCMD_ASYNC_UNLOCK_IB;
+			*((IDirect3DIndexBuffer9* *) m_pOutputPtr)=ib;
+			m_pOutputPtr+=N_DWORDS_IN_PTR;
+			*((LockedBufferContext *) m_pOutputPtr)=*lb;
+			m_pOutputPtr+=N_DWORDS( LockedBufferContext );
+			*(m_pOutputPtr++)=unlock_size;
+		}
+		else
+#endif
+		{
+			HRESULT hr = ib->Unlock( );
+
+			if ( FAILED(hr) )
+			{
+				Warning( "Index Buffer Unlock Failed in %s on line %d\n", V_UnqualifiedFileName(__FILE__), __LINE__ );
+			}
+		}
+	}
+
+	void ShowCursor( bool onoff)
+	{
+		Synchronize();
+		DO_D3D( ShowCursor(onoff) );
+	}
+
+	FORCEINLINE void Clear( int count, D3DRECT const *pRects, int Flags, D3DCOLOR color, float Z, int stencil)
+	{
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			int n_rects_words = count * N_DWORDS( D3DRECT );
+			AllocatePushBufferSpace( 2 + n_rects_words + 4 );
+			*(m_pOutputPtr++) = PBCMD_CLEAR;
+			*(m_pOutputPtr++) = count;
+			if ( count )
+			{
+				memcpy( m_pOutputPtr, pRects, count * sizeof( D3DRECT ) );
+				m_pOutputPtr += n_rects_words;
+			}
+			*(m_pOutputPtr++) = Flags;
+			*( (D3DCOLOR *) m_pOutputPtr ) = color;
+			m_pOutputPtr++;
+			*( (float *) m_pOutputPtr ) = Z;
+			m_pOutputPtr++;
+			*(m_pOutputPtr++) = stencil;
+		}
+		else
+#endif
+			DO_D3D( Clear(count, pRects, Flags, color, Z, stencil) );
+	}
+	
+	HRESULT Reset( D3DPRESENT_PARAMETERS *parms)
+	{
+		RECORD_COMMAND( DX8_RESET, 1 );
+		RECORD_STRUCT( parms, sizeof(*parms) );
+		Synchronize();
+		return m_pD3DDevice->Reset( parms );
+	}
+
+	void Release( void )
+	{
+		Synchronize();
+		DO_D3D( Release() );
+	}
+
+	FORCEINLINE void SetTexture(int stage, IDirect3DBaseTexture9 *txtr)
+	{
+		RECORD_COMMAND( DX8_SET_TEXTURE, 3 );
+		RECORD_INT( stage );
+		RECORD_INT( -1 );
+		RECORD_INT( -1 );
+		if (ASyncMode())
+		{
+			Push( PBCMD_SET_TEXTURE, stage, txtr );
+		}
+		else
+			DO_D3D( SetTexture( stage, txtr) );
+	}
+	void SetTransform( D3DTRANSFORMSTATETYPE mtrx_id, D3DXMATRIX const *mt)
+	{
+		RECORD_COMMAND( DX8_SET_TRANSFORM, 2 );
+		RECORD_INT( mtrx_id );
+		RECORD_STRUCT( mt, sizeof(D3DXMATRIX) );
+		Synchronize();
+		DO_D3D( SetTransform( mtrx_id, mt) );
+	}
+	
+	FORCEINLINE void SetSamplerState( int stage, D3DSAMPLERSTATETYPE state, DWORD val)
+	{
+		RECORD_SAMPLER_STATE( stage, state, val ); 
+		if ( ASyncMode() )
+			Push( PBCMD_SET_SAMPLER_STATE, stage, state, val );
+		else
+			DO_D3D( SetSamplerState( stage, state, val) );
+	}
+	
+	void SetFVF( int fvf)
+	{
+		Synchronize();
+		DO_D3D( SetFVF( fvf) );
+	}
+
+	FORCEINLINE void SetTextureStageState( int stage, D3DTEXTURESTAGESTATETYPE state, DWORD val )
+	{
+		RECORD_TEXTURE_STAGE_STATE( stage, state, val ); 
+		Synchronize();
+		DO_D3D( SetTextureStageState( stage, state, val) );
+	}
+
+	FORCEINLINE void DrawPrimitive(
+		D3DPRIMITIVETYPE PrimitiveType,
+		UINT StartVertex,
+		UINT PrimitiveCount
+		)
+	{
+		RECORD_COMMAND( DX8_DRAW_PRIMITIVE, 3 );
+		RECORD_INT( PrimitiveType );
+		RECORD_INT(	StartVertex );
+		RECORD_INT( PrimitiveCount );
+		if ( ASyncMode() )
+		{
+			Push( PBCMD_DRAWPRIM, PrimitiveType, StartVertex, PrimitiveCount );
+			SubmitIfNotBusy();
+		}
+		else
+			DO_D3D( DrawPrimitive( PrimitiveType, StartVertex, PrimitiveCount ) );
+
+	}
+
+	HRESULT CreateVertexDeclaration(
+		CONST D3DVERTEXELEMENT9* pVertexElements,
+		IDirect3DVertexDeclaration9** ppDecl
+		)
+	{
+		Synchronize();
+		return m_pD3DDevice->CreateVertexDeclaration( pVertexElements, ppDecl );
+	}
+
+
+	HRESULT ValidateDevice( DWORD * pNumPasses )
+	{
+		Synchronize();
+		return m_pD3DDevice->ValidateDevice( pNumPasses );
+	}
+
+
+
+	HRESULT CreateVertexShader(
+		CONST DWORD * pFunction,
+		IDirect3DVertexShader9** ppShader,
+		const char *pShaderName,
+		char *debugLabel = NULL
+		)
+	{
+		Synchronize();
+		#ifdef DX_TO_GL_ABSTRACTION
+			return m_pD3DDevice->CreateVertexShader( pFunction, ppShader, pShaderName, debugLabel );
+		#else
+			return m_pD3DDevice->CreateVertexShader( pFunction, ppShader );
+		#endif
+	}
+
+	HRESULT CreatePixelShader(
+		CONST DWORD * pFunction,
+		IDirect3DPixelShader9** ppShader,
+	    const char *pShaderName,
+		char *debugLabel = NULL
+		)
+	{
+		Synchronize();
+		#ifdef DX_TO_GL_ABSTRACTION
+			return m_pD3DDevice->CreatePixelShader( pFunction, ppShader, pShaderName, debugLabel );
+		#else
+			return m_pD3DDevice->CreatePixelShader( pFunction, ppShader );
+		#endif
+	}
+
+
+	FORCEINLINE void SetIndices(
+		IDirect3DIndexBuffer9 * pIndexData
+		)
+	{
+		if ( ASyncMode() )
+			Push( PBCMD_SET_INDICES, pIndexData );
+		else
+			DO_D3D( SetIndices( pIndexData ) );
+	}
+
+	FORCEINLINE void SetStreamSource(
+		UINT StreamNumber,
+		IDirect3DVertexBuffer9 * pStreamData,
+		UINT OffsetInBytes,
+		UINT Stride
+		)
+	{
+		if ( ASyncMode() )
+			Push( PBCMD_SET_STREAM_SOURCE, StreamNumber, pStreamData, OffsetInBytes, Stride );
+		else
+			DO_D3D( SetStreamSource( StreamNumber, pStreamData, OffsetInBytes, Stride ) );
+	}
+
+
+	HRESULT CreateVertexBuffer(
+		UINT Length,
+		DWORD Usage,
+		DWORD FVF,
+		D3DPOOL Pool,
+		IDirect3DVertexBuffer9** ppVertexBuffer,
+		HANDLE* pSharedHandle
+		)
+	{
+		Synchronize();
+		return m_pD3DDevice->CreateVertexBuffer( Length, Usage, FVF,
+												 Pool, ppVertexBuffer, pSharedHandle );
+	}
+
+	HRESULT CreateIndexBuffer(
+		UINT Length,
+		DWORD Usage,
+		D3DFORMAT Format,
+		D3DPOOL Pool,
+		IDirect3DIndexBuffer9** ppIndexBuffer,
+		HANDLE* pSharedHandle
+		)
+	{
+		Synchronize();
+		return m_pD3DDevice->CreateIndexBuffer( Length, Usage, Format, Pool, ppIndexBuffer,
+												pSharedHandle );
+	}
+
+
+	FORCEINLINE void DrawIndexedPrimitive(
+		D3DPRIMITIVETYPE Type,
+		INT BaseVertexIndex,
+		UINT MinIndex,
+		UINT NumVertices,
+		UINT StartIndex,
+		UINT PrimitiveCount	)
+	{
+		RECORD_COMMAND( DX8_DRAW_INDEXED_PRIMITIVE, 6 );
+		RECORD_INT( Type );
+		RECORD_INT( BaseVertexIndex );
+		RECORD_INT( MinIndex );
+		RECORD_INT( NumVertices );
+		RECORD_INT(	StartIndex );
+		RECORD_INT( PrimitiveCount );
+		if ( ASyncMode() )
+		{
+			Push(PBCMD_DRAWINDEXEDPRIM, 
+				 Type, BaseVertexIndex, MinIndex, NumVertices, StartIndex, PrimitiveCount );
+//			SubmitIfNotBusy();
+		}
+		else
+		{
+			DO_D3D( DrawIndexedPrimitive( Type, BaseVertexIndex, MinIndex, NumVertices, StartIndex, PrimitiveCount ) );
+		}
+	}
+
+#ifndef DX_TO_GL_ABSTRACTION
+	FORCEINLINE void DrawTessellatedIndexedPrimitive( INT BaseVertexIndex, UINT MinIndex, UINT NumVertices,
+													  UINT StartIndex, UINT PrimitiveCount )
+	{
+		// Setup our stream-source frequencies
+		DO_D3D( SetStreamSourceFreq( 0, D3DSTREAMSOURCE_INDEXEDDATA | PrimitiveCount  ) );
+		DO_D3D( SetStreamSourceFreq( VertexStreamSpec_t::STREAM_MORPH, D3DSTREAMSOURCE_INSTANCEDATA | 1ul  ) );
+		DO_D3D( SetStreamSourceFreq( VertexStreamSpec_t::STREAM_SUBDQUADS, D3DSTREAMSOURCE_INSTANCEDATA | 1ul ) );
+
+		int nIndicesPerPatch = ( ( ( m_nCurrentTessLevel + 1 ) * 2 + 2 ) * m_nCurrentTessLevel ) - 2;
+		int nVerticesPerPatch = m_nCurrentTessLevel + 1;
+		nVerticesPerPatch *= nVerticesPerPatch;
+		int nPrimitiveCount = nIndicesPerPatch - 2;
+		DO_D3D( DrawIndexedPrimitive( D3DPT_TRIANGLESTRIP, 0, 0, nVerticesPerPatch, 0, nPrimitiveCount ) );
+
+		// Disable instancing
+		DO_D3D( SetStreamSourceFreq( 0, 1ul ) );
+		DO_D3D( SetStreamSourceFreq( VertexStreamSpec_t::STREAM_MORPH, 1ul ) );
+		DO_D3D( SetStreamSourceFreq( VertexStreamSpec_t::STREAM_SUBDQUADS, 1ul ) );
+	}
+
+	FORCEINLINE void DrawTessellatedPrimitive( UINT StartVertex, UINT PrimitiveCount )
+	{
+
+		// Setup our stream-source frequencies
+		DO_D3D( SetStreamSourceFreq( 0, D3DSTREAMSOURCE_INDEXEDDATA | PrimitiveCount  ) );
+		DO_D3D( SetStreamSourceFreq( VertexStreamSpec_t::STREAM_MORPH, D3DSTREAMSOURCE_INSTANCEDATA | 1ul  ) );
+		DO_D3D( SetStreamSourceFreq( VertexStreamSpec_t::STREAM_SUBDQUADS, D3DSTREAMSOURCE_INSTANCEDATA | 1ul ) );
+
+		int nIndicesPerPatch = ( ( ( m_nCurrentTessLevel + 1 ) * 2 + 2 ) * m_nCurrentTessLevel ) - 2;
+		int nVerticesPerPatch = m_nCurrentTessLevel + 1;
+		nVerticesPerPatch *= nVerticesPerPatch;
+		int nPrimitiveCount = nIndicesPerPatch - 2;
+		DO_D3D( DrawIndexedPrimitive( D3DPT_TRIANGLESTRIP, 0, 0, nVerticesPerPatch, 0, nPrimitiveCount ) );
+
+		// Disable instancing
+		DO_D3D( SetStreamSourceFreq( 0, 1ul ) );
+		DO_D3D( SetStreamSourceFreq( VertexStreamSpec_t::STREAM_MORPH, 1ul ) );
+		DO_D3D( SetStreamSourceFreq( VertexStreamSpec_t::STREAM_SUBDQUADS, 1ul ) );
+	}
+
+	FORCEINLINE void SetTessellationLevel( float level )
+	{
+		// Track our current tessellation level
+		m_nCurrentTessLevel = (int)ceil( level );
+	}
+#endif
+	
+	void SetMaterial( D3DMATERIAL9 const *mat)
+	{
+		RECORD_COMMAND( DX8_SET_MATERIAL, 1 );
+		RECORD_STRUCT( &mat, sizeof(mat) );
+		Synchronize();
+		DO_D3D( SetMaterial( mat ) );
+	}
+
+	FORCEINLINE void SetPixelShader( IDirect3DPixelShader9 *pShader )
+	{
+		RECORD_COMMAND( DX8_SET_PIXEL_SHADER, 1 );
+		RECORD_INT( ( int ) pShader );
+		if ( ASyncMode() )
+			Push( PBCMD_SET_PIXEL_SHADER, pShader );
+		else
+			DO_D3D( SetPixelShader( pShader ) );
+	}
+
+	FORCEINLINE void SetVertexShader( IDirect3DVertexShader9 *pShader )
+	{
+		if ( ASyncMode() )
+			Push( PBCMD_SET_VERTEX_SHADER, pShader );
+		else
+			DO_D3D( SetVertexShader( pShader ) );
+	}
+
+#ifdef DX_TO_GL_ABSTRACTION
+	FORCEINLINE HRESULT LinkShaderPair( IDirect3DVertexShader9* vs, IDirect3DPixelShader9* ps )
+	{
+		Assert ( !ASyncMode() );
+		return DO_D3D( LinkShaderPair( vs, ps ) );
+	}
+
+	HRESULT QueryShaderPair( int index, GLMShaderPairInfo *infoOut )
+	{
+		Assert ( !ASyncMode() );
+		return DO_D3D( QueryShaderPair( index, infoOut ) );
+	}
+
+	void SetMaxUsedVertexShaderConstantsHint( uint nMaxReg )
+	{
+		Assert( !ASyncMode() );
+		DO_D3D( SetMaxUsedVertexShaderConstantsHint( nMaxReg ) );
+	}
+
+#endif
+
+	void EvictManagedResources( void )
+	{
+		if (m_pD3DDevice)									// people call this before creating the device
+		{
+			Synchronize();
+			DO_D3D( EvictManagedResources() );
+		}
+	}
+
+	void SetLight( int i, D3DLIGHT9 const *l)
+	{
+		RECORD_COMMAND( DX8_SET_LIGHT, 2 );
+		RECORD_INT( i );
+		RECORD_STRUCT( l, sizeof(*l) );
+
+		Synchronize();
+		DO_D3D( SetLight(i, l) );
+	}
+
+	void DrawIndexedPrimitiveUP( D3DPRIMITIVETYPE PrimitiveType,
+								 UINT MinVertexIndex,
+								 UINT NumVertices,
+								 UINT PrimitiveCount,
+								 CONST void * pIndexData,
+								 D3DFORMAT IndexDataFormat,
+								 CONST void* pVertexStreamZeroData,
+								 UINT VertexStreamZeroStride )
+	{
+		Synchronize();
+		DO_D3D( DrawIndexedPrimitiveUP( PrimitiveType, MinVertexIndex, NumVertices, PrimitiveCount,
+										pIndexData, IndexDataFormat, pVertexStreamZeroData,
+										VertexStreamZeroStride ) );
+	}
+
+	HRESULT Present(
+		CONST RECT * pSourceRect,
+		CONST RECT * pDestRect,
+		VD3DHWND hDestWindowOverride,
+		CONST RGNDATA * pDirtyRegion)
+	{
+		RECORD_COMMAND( DX8_PRESENT, 0 );
+#if SHADERAPI_USE_SMP
+		if ( ASyncMode() )
+		{
+			// need to deal with ret code here
+			AllocatePushBufferSpace(1+1+
+									N_DWORDS( RECT )+1+N_DWORDS( RECT )+1+1+N_DWORDS( RGNDATA ));
+			*(m_pOutputPtr++)=PBCMD_PRESENT;
+			*(m_pOutputPtr++)=( pSourceRect != NULL );
+			if (pSourceRect)
+				memcpy(m_pOutputPtr, pSourceRect, sizeof( RECT ) );
+			m_pOutputPtr+=N_DWORDS( RECT );
+			*(m_pOutputPtr++)=( pDestRect != NULL );
+			if (pDestRect)
+				memcpy(m_pOutputPtr, pDestRect, sizeof( RECT ) );
+			m_pOutputPtr+=N_DWORDS( RECT );
+			*(m_pOutputPtr++)=(uint32) hDestWindowOverride;
+			*(m_pOutputPtr++)=( pDirtyRegion != NULL );
+			if (pDirtyRegion)
+				memcpy(m_pOutputPtr, pDirtyRegion, sizeof( RGNDATA ));
+			m_pOutputPtr+=N_DWORDS( RGNDATA );
+			return S_OK;									// not good - caller wants to here about lost devices
+		}
+		else
+#endif
+			return m_pD3DDevice->Present( pSourceRect, pDestRect, 
+									  hDestWindowOverride, pDirtyRegion );
+	}
+	
+
+#if defined( DX_TO_GL_ABSTRACTION )
+
+	void AcquireThreadOwnership( )
+	{
+		m_pD3DDevice->AcquireThreadOwnership();
+	}
+
+	void ReleaseThreadOwnership( )
+	{
+		m_pD3DDevice->ReleaseThreadOwnership();
+	}
+
+#endif
+
+};
+
+#endif // D3DASYNC_H
+
+#endif // #if D3D_ASYNC_SUPPORTED