//========= 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 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 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