You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6846 lines
204 KiB
6846 lines
204 KiB
![]()
4 years ago
|
//========= Copyright Valve Corporation, All rights reserved. ============//
|
||
|
// TOGL CODE LICENSE
|
||
|
//
|
||
|
// Copyright 2011-2014 Valve Corporation
|
||
|
// All Rights Reserved.
|
||
|
//
|
||
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
|
// of this software and associated documentation files (the "Software"), to deal
|
||
|
// in the Software without restriction, including without limitation the rights
|
||
|
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
|
// copies of the Software, and to permit persons to whom the Software is
|
||
|
// furnished to do so, subject to the following conditions:
|
||
|
//
|
||
|
// The above copyright notice and this permission notice shall be included in
|
||
|
// all copies or substantial portions of the Software.
|
||
|
//
|
||
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
|
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||
|
// THE SOFTWARE.
|
||
|
//
|
||
|
// dxabstract.cpp
|
||
|
//
|
||
|
//==================================================================================================
|
||
|
#include "togl/rendermechanism.h"
|
||
|
#include "tier0/vprof_telemetry.h"
|
||
|
#include "tier0/dbg.h"
|
||
|
#include "tier0/threadtools.h"
|
||
|
#include "tier0/vprof.h"
|
||
|
#include "tier1/strtools.h"
|
||
|
#include "tier1/utlbuffer.h"
|
||
|
#include "dx9asmtogl2.h"
|
||
|
#include "mathlib/vmatrix.h"
|
||
|
#include "materialsystem/IShader.h"
|
||
|
|
||
|
#include "glmgr_flush.inl"
|
||
|
|
||
|
#if defined(OSX) || defined(LINUX) || (defined (WIN32) && defined( DX_TO_GL_ABSTRACTION ))
|
||
|
#include "appframework/ilaunchermgr.h"
|
||
|
extern ILauncherMgr *g_pLauncherMgr;
|
||
|
#endif
|
||
|
|
||
|
#include "tier0/icommandline.h"
|
||
|
#include "tier0/memdbgon.h"
|
||
|
|
||
|
#ifdef USE_ACTUAL_DX
|
||
|
|
||
|
#pragma comment( lib, "../../dx9sdk/lib/d3d9.lib" )
|
||
|
#pragma comment( lib, "../../dx9sdk/lib/d3dx9.lib" )
|
||
|
|
||
|
#else
|
||
|
|
||
|
#ifdef POSIX
|
||
|
#define strcat_s( a, b, c) V_strcat( a, c, b )
|
||
|
#endif
|
||
|
|
||
|
#define D3D_DEVICE_VALID_MARKER 0x12EBC845
|
||
|
#define GL_PUBLIC_ENTRYPOINT_CHECKS( dev ) Assert( dev->GetCurrentOwnerThreadId() == ThreadGetCurrentId() ); Assert( dev->m_nValidMarker == D3D_DEVICE_VALID_MARKER );
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
bool g_bNullD3DDevice;
|
||
|
|
||
|
static D3DToGL g_D3DToOpenGLTranslatorGLSL;
|
||
|
static IDirect3DDevice9 *g_pD3D_Device;
|
||
|
|
||
|
#if GL_BATCH_PERF_ANALYSIS
|
||
|
#include "../../thirdparty/miniz/simple_bitmap.h"
|
||
|
#include "../../thirdparty/miniz/miniz.c"
|
||
|
|
||
|
ConVar gl_batch_vis_abs_scale( "gl_batch_vis_abs_scale", ".050" );
|
||
|
ConVar gl_present_vis_abs_scale( "gl_present_vis_abs_scale", ".050" );
|
||
|
//ConVar gl_batch_vis_y_scale( "gl_batch_vis_y_scale", "0.007" );
|
||
|
ConVar gl_batch_vis_y_scale( "gl_batch_vis_y_scale", "0.0" );
|
||
|
static double s_rdtsc_to_ms;
|
||
|
|
||
|
uint64 g_nTotalD3DCycles;
|
||
|
uint g_nTotalD3DCalls;
|
||
|
|
||
|
class CGLBatchPerfCallTimer
|
||
|
{
|
||
|
public:
|
||
|
inline CGLBatchPerfCallTimer() { g_nTotalD3DCalls++; g_nTotalD3DCycles -= TM_FAST_TIME(); }
|
||
|
inline ~CGLBatchPerfCallTimer() { g_nTotalD3DCycles += TM_FAST_TIME(); }
|
||
|
};
|
||
|
|
||
|
#define GL_BATCH_PERF_CALL_TIMER CGLBatchPerfCallTimer scopedCallTimer;
|
||
|
#else
|
||
|
#define GL_BATCH_PERF_CALL_TIMER
|
||
|
#endif // GL_BATCH_PERF_ANALYSIS
|
||
|
|
||
|
ConVar gl_batch_vis( "gl_batch_vis", "0" );
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
// functions that are dependant on g_pLauncherMgr
|
||
|
|
||
|
inline GLMDisplayDB *GetDisplayDB( void )
|
||
|
{
|
||
|
return g_pLauncherMgr->GetDisplayDB();
|
||
|
}
|
||
|
|
||
|
inline void RenderedSize( uint &width, uint &height, bool set )
|
||
|
{
|
||
|
g_pLauncherMgr->RenderedSize( width, height, set );
|
||
|
}
|
||
|
|
||
|
inline void GetStackCrawl( CStackCrawlParams *params )
|
||
|
{
|
||
|
g_pLauncherMgr->GetStackCrawl(params);
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#if defined( WIN32 )
|
||
|
|
||
|
bool D3DMATRIX::operator == ( CONST D3DMATRIX& src) const
|
||
|
{
|
||
|
return V_memcmp( (void*)this, (void*)&src, sizeof(this) ) == 0;
|
||
|
}
|
||
|
|
||
|
D3DMATRIX::operator void* ()
|
||
|
{
|
||
|
return (void*)this;
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- D3DXMATRIX operators
|
||
|
|
||
|
#endif
|
||
|
|
||
|
D3DXMATRIX D3DXMATRIX::operator*( const D3DXMATRIX &o ) const
|
||
|
{
|
||
|
D3DXMATRIX result;
|
||
|
|
||
|
D3DXMatrixMultiply( &result, this, &o ); // this = lhs o = rhs result = this * o
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
D3DXMATRIX::operator FLOAT* ()
|
||
|
{
|
||
|
return (float*)this;
|
||
|
}
|
||
|
|
||
|
float& D3DXMATRIX::operator()( int row, int column )
|
||
|
{
|
||
|
return m[row][column];
|
||
|
}
|
||
|
|
||
|
const float& D3DXMATRIX::operator()( int row, int column ) const
|
||
|
{
|
||
|
return m[row][column];
|
||
|
}
|
||
|
|
||
|
bool D3DXMATRIX::operator != ( CONST D3DXMATRIX& src ) const
|
||
|
{
|
||
|
return V_memcmp( (void*)this, (void*)&src, sizeof(this) ) != 0;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- D3DXPLANE operators
|
||
|
|
||
|
#endif
|
||
|
|
||
|
float& D3DXPLANE::operator[]( int i )
|
||
|
{
|
||
|
return ((float*)this)[i];
|
||
|
}
|
||
|
|
||
|
bool D3DXPLANE::operator==( const D3DXPLANE &o )
|
||
|
{
|
||
|
return a == o.a && b == o.b && c == o.c && d == o.d;
|
||
|
}
|
||
|
|
||
|
bool D3DXPLANE::operator!=( const D3DXPLANE &o )
|
||
|
{
|
||
|
return !( *this == o );
|
||
|
}
|
||
|
|
||
|
D3DXPLANE::operator float*()
|
||
|
{
|
||
|
return (float*)this;
|
||
|
}
|
||
|
|
||
|
D3DXPLANE::operator const float*() const
|
||
|
{
|
||
|
return (const float*)this;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- D3DXVECTOR2 operators
|
||
|
|
||
|
#endif
|
||
|
|
||
|
D3DXVECTOR2::operator FLOAT* ()
|
||
|
{
|
||
|
return (float*)this;
|
||
|
}
|
||
|
|
||
|
D3DXVECTOR2::operator CONST FLOAT* () const
|
||
|
{
|
||
|
return (const float*)this;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- D3DXVECTOR3 operators
|
||
|
|
||
|
#endif
|
||
|
|
||
|
D3DXVECTOR3::D3DXVECTOR3( float a, float b, float c )
|
||
|
{
|
||
|
x = a;
|
||
|
y = b;
|
||
|
z = c;
|
||
|
}
|
||
|
|
||
|
D3DXVECTOR3::operator FLOAT* ()
|
||
|
{
|
||
|
return (float*)this;
|
||
|
}
|
||
|
|
||
|
D3DXVECTOR3::operator CONST FLOAT* () const
|
||
|
{
|
||
|
return (const float*)this;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- D3DXVECTOR4 operators
|
||
|
|
||
|
#endif
|
||
|
|
||
|
D3DXVECTOR4::D3DXVECTOR4( float a, float b, float c, float d )
|
||
|
{
|
||
|
x = a;
|
||
|
y = b;
|
||
|
z = c;
|
||
|
w = d;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
DWORD IDirect3DResource9::SetPriority(DWORD PriorityNew)
|
||
|
{
|
||
|
// DXABSTRACT_BREAK_ON_ERROR();
|
||
|
// GLMPRINTF(( "-X- SetPriority" ));
|
||
|
// no-op city
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- IDirect3DBaseTexture9
|
||
|
|
||
|
#endif
|
||
|
|
||
|
IDirect3DBaseTexture9::~IDirect3DBaseTexture9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
GLMPRINTF(( ">-A- ~IDirect3DBaseTexture9" ));
|
||
|
|
||
|
if (m_device)
|
||
|
{
|
||
|
Assert( m_device->m_ObjectStats.m_nTotalTextures >= 1 );
|
||
|
m_device->m_ObjectStats.m_nTotalTextures--;
|
||
|
|
||
|
GLMPRINTF(( "-A- ~IDirect3DBaseTexture9 taking normal delete path on %08x, device is %08x ", this, m_device ));
|
||
|
m_device->ReleasedTexture( this );
|
||
|
|
||
|
if (m_tex)
|
||
|
{
|
||
|
GLMPRINTF(("-A- ~IDirect3DBaseTexture9 deleted '%s' @ %08x (GLM %08x) %s",m_tex->m_layout->m_layoutSummary, this, m_tex, m_tex->m_debugLabel ? m_tex->m_debugLabel : "" ));
|
||
|
|
||
|
m_device->ReleasedCGLMTex( m_tex );
|
||
|
|
||
|
m_tex->m_ctx->DelTex( m_tex );
|
||
|
m_tex = NULL;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
GLMPRINTF(( "-A- ~IDirect3DBaseTexture9 : whoops, no tex to delete here ?" ));
|
||
|
}
|
||
|
m_device = NULL; // ** THIS ** is the only place to scrub this. Don't do it in the subclass destructors.
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
GLMPRINTF(( "-A- ~IDirect3DBaseTexture9 taking strange delete path on %08x, device is %08x ", this, m_device ));
|
||
|
}
|
||
|
|
||
|
GLMPRINTF(( "<-A- ~IDirect3DBaseTexture9" ));
|
||
|
}
|
||
|
|
||
|
D3DRESOURCETYPE IDirect3DBaseTexture9::GetType()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
|
||
|
return m_restype; //D3DRTYPE_TEXTURE;
|
||
|
}
|
||
|
|
||
|
DWORD IDirect3DBaseTexture9::GetLevelCount()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
|
||
|
return m_tex->m_layout->m_mipCount;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DBaseTexture9::GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
|
||
|
Assert (Level < static_cast<uint>(m_tex->m_layout->m_mipCount));
|
||
|
|
||
|
D3DSURFACE_DESC result = m_descZero;
|
||
|
// then mutate it for the level of interest
|
||
|
|
||
|
GLMTexLayoutSlice *slice = &m_tex->m_layout->m_slices[ m_tex->CalcSliceIndex( 0, Level ) ];
|
||
|
|
||
|
result.Width = slice->m_xSize;
|
||
|
result.Height = slice->m_ySize;
|
||
|
|
||
|
*pDesc = result;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- IDirect3DTexture9
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9** ppTexture,VD3DHANDLE* pSharedHandle, char *pDebugLabel )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
|
||
|
m_ObjectStats.m_nTotalTextures++;
|
||
|
|
||
|
GLMPRINTF((">-A-IDirect3DDevice9::CreateTexture"));
|
||
|
IDirect3DTexture9 *dxtex = new IDirect3DTexture9;
|
||
|
dxtex->m_restype = D3DRTYPE_TEXTURE;
|
||
|
|
||
|
dxtex->m_device = this;
|
||
|
|
||
|
dxtex->m_descZero.Format = Format;
|
||
|
dxtex->m_descZero.Type = D3DRTYPE_TEXTURE;
|
||
|
dxtex->m_descZero.Usage = Usage;
|
||
|
dxtex->m_descZero.Pool = Pool;
|
||
|
|
||
|
dxtex->m_descZero.MultiSampleType = D3DMULTISAMPLE_NONE;
|
||
|
dxtex->m_descZero.MultiSampleQuality = 0;
|
||
|
dxtex->m_descZero.Width = Width;
|
||
|
dxtex->m_descZero.Height = Height;
|
||
|
|
||
|
GLMTexLayoutKey key;
|
||
|
memset( &key, 0, sizeof(key) );
|
||
|
|
||
|
key.m_texGLTarget = GL_TEXTURE_2D;
|
||
|
key.m_texFormat = Format;
|
||
|
|
||
|
if (Levels>1)
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexMipped;
|
||
|
}
|
||
|
|
||
|
// http://msdn.microsoft.com/en-us/library/bb172625(VS.85).aspx
|
||
|
|
||
|
// complain if any usage bits come down that I don't know.
|
||
|
uint knownUsageBits = (D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_RENDERTARGET | D3DUSAGE_DYNAMIC | D3DUSAGE_TEXTURE_SRGB | D3DUSAGE_DEPTHSTENCIL);
|
||
|
if ( (Usage & knownUsageBits) != Usage )
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_AUTOGENMIPMAP)
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexMipped | kGLMTexMippedAuto;
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_DYNAMIC)
|
||
|
{
|
||
|
// GLMPRINTF(("-X- DYNAMIC tex usage ignored..")); //FIXME
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_TEXTURE_SRGB)
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexSRGB;
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_RENDERTARGET)
|
||
|
{
|
||
|
Assert( !(Usage & D3DUSAGE_DEPTHSTENCIL) );
|
||
|
|
||
|
m_ObjectStats.m_nTotalRenderTargets++;
|
||
|
|
||
|
key.m_texFlags |= kGLMTexRenderable;
|
||
|
|
||
|
const GLMTexFormatDesc *pFmtDesc = GetFormatDesc( key.m_texFormat );
|
||
|
if ( pFmtDesc->m_glIntFormatSRGB != 0 )
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexSRGB; // this catches callers of CreateTexture who set the "renderable" option - they get an SRGB tex
|
||
|
}
|
||
|
|
||
|
if (m_ctx->Caps().m_cantAttachSRGB)
|
||
|
{
|
||
|
// this config can't support SRGB render targets. quietly turn off the sRGB bit.
|
||
|
key.m_texFlags &= ~kGLMTexSRGB;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( ( Format == D3DFMT_D16 ) || ( Format == D3DFMT_D24X8 ) || ( Format == D3DFMT_D24S8 ) )
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexIsDepth;
|
||
|
}
|
||
|
if ( Format == D3DFMT_D24S8 )
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexIsStencil;
|
||
|
}
|
||
|
|
||
|
key.m_xSize = Width;
|
||
|
key.m_ySize = Height;
|
||
|
key.m_zSize = 1;
|
||
|
|
||
|
CGLMTex *tex = m_ctx->NewTex( &key, Levels, pDebugLabel );
|
||
|
if (!tex)
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
dxtex->m_tex = tex;
|
||
|
|
||
|
dxtex->m_tex->m_srgbFlipCount = 0;
|
||
|
|
||
|
m_ObjectStats.m_nTotalSurfaces++;
|
||
|
|
||
|
dxtex->m_surfZero = new IDirect3DSurface9;
|
||
|
dxtex->m_surfZero->m_restype = (D3DRESOURCETYPE)0; // this is a ref to a tex, not the owner...
|
||
|
|
||
|
// do not do an AddRef here.
|
||
|
|
||
|
dxtex->m_surfZero->m_device = this;
|
||
|
|
||
|
dxtex->m_surfZero->m_desc = dxtex->m_descZero;
|
||
|
dxtex->m_surfZero->m_tex = tex;
|
||
|
dxtex->m_surfZero->m_face = 0;
|
||
|
dxtex->m_surfZero->m_mip = 0;
|
||
|
|
||
|
GLMPRINTF(("-A- IDirect3DDevice9::CreateTexture created '%s' @ %08x (GLM %08x) %s",tex->m_layout->m_layoutSummary, dxtex, tex, pDebugLabel ? pDebugLabel : "" ));
|
||
|
|
||
|
*ppTexture = dxtex;
|
||
|
|
||
|
GLMPRINTF(("<-A-IDirect3DDevice9::CreateTexture"));
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
IDirect3DTexture9::~IDirect3DTexture9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
|
||
|
GLMPRINTF(( ">-A- IDirect3DTexture9" ));
|
||
|
|
||
|
// IDirect3DBaseTexture9::~IDirect3DBaseTexture9 frees up m_tex
|
||
|
// we take care of surfZero
|
||
|
|
||
|
if (m_device)
|
||
|
{
|
||
|
m_device->ReleasedTexture( this );
|
||
|
|
||
|
if (m_surfZero)
|
||
|
{
|
||
|
ULONG refc = m_surfZero->Release( 0, "~IDirect3DTexture9 public release (surfZero)" ); (void)refc;
|
||
|
Assert( !refc );
|
||
|
m_surfZero = NULL;
|
||
|
}
|
||
|
// leave m_device alone!
|
||
|
}
|
||
|
|
||
|
GLMPRINTF(( "<-A- IDirect3DTexture9" ));
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DTexture9::LockRect(UINT Level,D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DTexture9::UnlockRect(UINT Level)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DTexture9::GetSurfaceLevel(UINT Level,IDirect3DSurface9** ppSurfaceLevel)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
// we create and pass back a surface, and the client is on the hook to release it. tidy.
|
||
|
|
||
|
m_device->m_ObjectStats.m_nTotalSurfaces++;
|
||
|
|
||
|
IDirect3DSurface9 *surf = new IDirect3DSurface9;
|
||
|
surf->m_restype = (D3DRESOURCETYPE)0; // 0 is special and means this 'surface' does not own its m_tex
|
||
|
|
||
|
// Dicey...higher level code seems to want this and not want this. Are we missing some AddRef/Release behavior elsewhere?
|
||
|
// trying to turn this off - experimental - 26Oct2010 surf->AddRef();
|
||
|
|
||
|
surf->m_device = this->m_device;
|
||
|
|
||
|
GLMTexLayoutSlice *slice = &m_tex->m_layout->m_slices[ m_tex->CalcSliceIndex( 0, Level ) ];
|
||
|
|
||
|
surf->m_desc = m_descZero;
|
||
|
surf->m_desc.Width = slice->m_xSize;
|
||
|
surf->m_desc.Height = slice->m_ySize;
|
||
|
|
||
|
surf->m_tex = m_tex;
|
||
|
surf->m_face = 0;
|
||
|
surf->m_mip = Level;
|
||
|
|
||
|
*ppSurfaceLevel = surf;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- IDirect3DCubeTexture9
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9** ppCubeTexture,VD3DHANDLE* pSharedHandle, char *pDebugLabel)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
Assert( m_ctx->m_nCurOwnerThreadId == ThreadGetCurrentId() );
|
||
|
GLMPRINTF((">-A- IDirect3DDevice9::CreateCubeTexture"));
|
||
|
|
||
|
Assert( m_ctx->m_nCurOwnerThreadId == ThreadGetCurrentId() );
|
||
|
|
||
|
m_ObjectStats.m_nTotalTextures++;
|
||
|
|
||
|
IDirect3DCubeTexture9 *dxtex = new IDirect3DCubeTexture9;
|
||
|
dxtex->m_restype = D3DRTYPE_CUBETEXTURE;
|
||
|
|
||
|
dxtex->m_device = this;
|
||
|
|
||
|
dxtex->m_descZero.Format = Format;
|
||
|
dxtex->m_descZero.Type = D3DRTYPE_CUBETEXTURE;
|
||
|
dxtex->m_descZero.Usage = Usage;
|
||
|
dxtex->m_descZero.Pool = Pool;
|
||
|
|
||
|
dxtex->m_descZero.MultiSampleType = D3DMULTISAMPLE_NONE;
|
||
|
dxtex->m_descZero.MultiSampleQuality = 0;
|
||
|
dxtex->m_descZero.Width = EdgeLength;
|
||
|
dxtex->m_descZero.Height = EdgeLength;
|
||
|
|
||
|
GLMTexLayoutKey key;
|
||
|
memset( &key, 0, sizeof(key) );
|
||
|
|
||
|
key.m_texGLTarget = GL_TEXTURE_CUBE_MAP;
|
||
|
key.m_texFormat = Format;
|
||
|
|
||
|
if (Levels>1)
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexMipped;
|
||
|
}
|
||
|
|
||
|
// http://msdn.microsoft.com/en-us/library/bb172625(VS.85).aspx
|
||
|
// complain if any usage bits come down that I don't know.
|
||
|
uint knownUsageBits = (D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_RENDERTARGET | D3DUSAGE_DYNAMIC | D3DUSAGE_TEXTURE_SRGB);
|
||
|
if ( (Usage & knownUsageBits) != Usage )
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_AUTOGENMIPMAP)
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexMipped | kGLMTexMippedAuto;
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_RENDERTARGET)
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexRenderable;
|
||
|
|
||
|
m_ObjectStats.m_nTotalRenderTargets++;
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_DYNAMIC)
|
||
|
{
|
||
|
//GLMPRINTF(("-X- DYNAMIC tex usage ignored..")); //FIXME
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_TEXTURE_SRGB)
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexSRGB;
|
||
|
}
|
||
|
|
||
|
key.m_xSize = EdgeLength;
|
||
|
key.m_ySize = EdgeLength;
|
||
|
key.m_zSize = 1;
|
||
|
|
||
|
CGLMTex *tex = m_ctx->NewTex( &key, Levels, pDebugLabel );
|
||
|
if (!tex)
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
dxtex->m_tex = tex;
|
||
|
|
||
|
dxtex->m_tex->m_srgbFlipCount = 0;
|
||
|
|
||
|
for( int face = 0; face < 6; face ++)
|
||
|
{
|
||
|
m_ObjectStats.m_nTotalSurfaces++;
|
||
|
|
||
|
dxtex->m_surfZero[face] = new IDirect3DSurface9;
|
||
|
dxtex->m_surfZero[face]->m_restype = (D3DRESOURCETYPE)0; // 0 is special and means this 'surface' does not own its m_tex
|
||
|
// do not do an AddRef here.
|
||
|
|
||
|
dxtex->m_surfZero[face]->m_device = this;
|
||
|
|
||
|
dxtex->m_surfZero[face]->m_desc = dxtex->m_descZero;
|
||
|
dxtex->m_surfZero[face]->m_tex = tex;
|
||
|
dxtex->m_surfZero[face]->m_face = face;
|
||
|
dxtex->m_surfZero[face]->m_mip = 0;
|
||
|
}
|
||
|
|
||
|
GLMPRINTF(("-A- IDirect3DDevice9::CreateCubeTexture created '%s' @ %08x (GLM %08x)",tex->m_layout->m_layoutSummary, dxtex, tex ));
|
||
|
|
||
|
*ppCubeTexture = dxtex;
|
||
|
|
||
|
GLMPRINTF(("<-A- IDirect3DDevice9::CreateCubeTexture"));
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
IDirect3DCubeTexture9::~IDirect3DCubeTexture9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
GLMPRINTF(( ">-A- ~IDirect3DCubeTexture9" ));
|
||
|
|
||
|
if (m_device)
|
||
|
{
|
||
|
GLMPRINTF(( "-A- ~IDirect3DCubeTexture9 taking normal delete path on %08x, device is %08x, surfzero[0] is %08x ", this, m_device, m_surfZero[0] ));
|
||
|
m_device->ReleasedTexture( this );
|
||
|
|
||
|
// let IDirect3DBaseTexture9::~IDirect3DBaseTexture9 free up m_tex
|
||
|
// we handle the surfZero array for the faces
|
||
|
|
||
|
for( int face = 0; face < 6; face ++)
|
||
|
{
|
||
|
if (m_surfZero[face])
|
||
|
{
|
||
|
Assert( m_surfZero[face]->m_device == m_device );
|
||
|
ULONG refc = m_surfZero[face]->Release( 0, "~IDirect3DCubeTexture9 public release (surfZero)");
|
||
|
if ( refc!=0 )
|
||
|
{
|
||
|
GLMPRINTF(( "-A- ~IDirect3DCubeTexture9 seeing non zero refcount on surfzero[%d] => %d ", face, refc ));
|
||
|
}
|
||
|
m_surfZero[face] = NULL;
|
||
|
}
|
||
|
}
|
||
|
// leave m_device alone!
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
GLMPRINTF(( "-A- ~IDirect3DCubeTexture9 taking strange delete path on %08x, device is %08x, surfzero[0] is %08x ", this, m_device, m_surfZero[0] ));
|
||
|
}
|
||
|
|
||
|
GLMPRINTF(( "<-A- ~IDirect3DCubeTexture9" ));
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DCubeTexture9::GetCubeMapSurface(D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface9** ppCubeMapSurface)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
// we create and pass back a surface, and the client is on the hook to release it...
|
||
|
|
||
|
m_device->m_ObjectStats.m_nTotalSurfaces++;
|
||
|
|
||
|
IDirect3DSurface9 *surf = new IDirect3DSurface9;
|
||
|
surf->m_restype = (D3DRESOURCETYPE)0; // 0 is special and means this 'surface' does not own its m_tex
|
||
|
|
||
|
GLMTexLayoutSlice *slice = &m_tex->m_layout->m_slices[ m_tex->CalcSliceIndex( FaceType, Level ) ];
|
||
|
|
||
|
surf->m_device = this->m_device;
|
||
|
|
||
|
surf->m_desc = m_descZero;
|
||
|
surf->m_desc.Width = slice->m_xSize;
|
||
|
surf->m_desc.Height = slice->m_ySize;
|
||
|
|
||
|
surf->m_tex = m_tex;
|
||
|
surf->m_face = FaceType;
|
||
|
surf->m_mip = Level;
|
||
|
|
||
|
*ppCubeMapSurface = surf;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DCubeTexture9::GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
Assert (Level < static_cast<uint>(m_tex->m_layout->m_mipCount));
|
||
|
|
||
|
D3DSURFACE_DESC result = m_descZero;
|
||
|
// then mutate it for the level of interest
|
||
|
|
||
|
GLMTexLayoutSlice *slice = &m_tex->m_layout->m_slices[ m_tex->CalcSliceIndex( 0, Level ) ];
|
||
|
|
||
|
result.Width = slice->m_xSize;
|
||
|
result.Height = slice->m_ySize;
|
||
|
|
||
|
*pDesc = result;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- IDirect3DVolumeTexture9
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9** ppVolumeTexture,VD3DHANDLE* pSharedHandle, char *pDebugLabel)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GLMPRINTF((">-A- IDirect3DDevice9::CreateVolumeTexture"));
|
||
|
// set dxtex->m_restype to D3DRTYPE_VOLUMETEXTURE...
|
||
|
|
||
|
Assert( m_ctx->m_nCurOwnerThreadId == ThreadGetCurrentId() );
|
||
|
|
||
|
m_ObjectStats.m_nTotalTextures++;
|
||
|
|
||
|
IDirect3DVolumeTexture9 *dxtex = new IDirect3DVolumeTexture9;
|
||
|
dxtex->m_restype = D3DRTYPE_VOLUMETEXTURE;
|
||
|
|
||
|
dxtex->m_device = this;
|
||
|
|
||
|
dxtex->m_descZero.Format = Format;
|
||
|
dxtex->m_descZero.Type = D3DRTYPE_VOLUMETEXTURE;
|
||
|
dxtex->m_descZero.Usage = Usage;
|
||
|
dxtex->m_descZero.Pool = Pool;
|
||
|
|
||
|
dxtex->m_descZero.MultiSampleType = D3DMULTISAMPLE_NONE;
|
||
|
dxtex->m_descZero.MultiSampleQuality = 0;
|
||
|
dxtex->m_descZero.Width = Width;
|
||
|
dxtex->m_descZero.Height = Height;
|
||
|
|
||
|
// also a volume specific desc
|
||
|
dxtex->m_volDescZero.Format = Format;
|
||
|
dxtex->m_volDescZero.Type = D3DRTYPE_VOLUMETEXTURE;
|
||
|
dxtex->m_volDescZero.Usage = Usage;
|
||
|
dxtex->m_volDescZero.Pool = Pool;
|
||
|
|
||
|
dxtex->m_volDescZero.Width = Width;
|
||
|
dxtex->m_volDescZero.Height = Height;
|
||
|
dxtex->m_volDescZero.Depth = Depth;
|
||
|
|
||
|
GLMTexLayoutKey key;
|
||
|
memset( &key, 0, sizeof(key) );
|
||
|
|
||
|
key.m_texGLTarget = GL_TEXTURE_3D;
|
||
|
key.m_texFormat = Format;
|
||
|
|
||
|
if (Levels>1)
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexMipped;
|
||
|
}
|
||
|
|
||
|
// http://msdn.microsoft.com/en-us/library/bb172625(VS.85).aspx
|
||
|
// complain if any usage bits come down that I don't know.
|
||
|
uint knownUsageBits = (D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_RENDERTARGET | D3DUSAGE_DYNAMIC | D3DUSAGE_TEXTURE_SRGB);
|
||
|
if ( (Usage & knownUsageBits) != Usage )
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_AUTOGENMIPMAP)
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexMipped | kGLMTexMippedAuto;
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_RENDERTARGET)
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexRenderable;
|
||
|
|
||
|
m_ObjectStats.m_nTotalRenderTargets++;
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_DYNAMIC)
|
||
|
{
|
||
|
GLMPRINTF(("-X- DYNAMIC tex usage ignored..")); //FIXME
|
||
|
}
|
||
|
|
||
|
if (Usage & D3DUSAGE_TEXTURE_SRGB)
|
||
|
{
|
||
|
key.m_texFlags |= kGLMTexSRGB;
|
||
|
}
|
||
|
|
||
|
key.m_xSize = Width;
|
||
|
key.m_ySize = Height;
|
||
|
key.m_zSize = Depth;
|
||
|
|
||
|
CGLMTex *tex = m_ctx->NewTex( &key, Levels, pDebugLabel );
|
||
|
if (!tex)
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
dxtex->m_tex = tex;
|
||
|
|
||
|
dxtex->m_tex->m_srgbFlipCount = 0;
|
||
|
|
||
|
m_ObjectStats.m_nTotalSurfaces++;
|
||
|
|
||
|
dxtex->m_surfZero = new IDirect3DSurface9;
|
||
|
dxtex->m_surfZero->m_restype = (D3DRESOURCETYPE)0; // this is a ref to a tex, not the owner...
|
||
|
// do not do an AddRef here.
|
||
|
|
||
|
dxtex->m_surfZero->m_device = this;
|
||
|
|
||
|
dxtex->m_surfZero->m_desc = dxtex->m_descZero;
|
||
|
dxtex->m_surfZero->m_tex = tex;
|
||
|
dxtex->m_surfZero->m_face = 0;
|
||
|
dxtex->m_surfZero->m_mip = 0;
|
||
|
|
||
|
GLMPRINTF(("-A- IDirect3DDevice9::CreateVolumeTexture created '%s' @ %08x (GLM %08x)",tex->m_layout->m_layoutSummary, dxtex, tex ));
|
||
|
|
||
|
*ppVolumeTexture = dxtex;
|
||
|
|
||
|
GLMPRINTF(("<-A- IDirect3DDevice9::CreateVolumeTexture"));
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
IDirect3DVolumeTexture9::~IDirect3DVolumeTexture9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GLMPRINTF((">-A- ~IDirect3DVolumeTexture9"));
|
||
|
|
||
|
if (m_device)
|
||
|
{
|
||
|
m_device->ReleasedTexture( this );
|
||
|
|
||
|
// let IDirect3DBaseTexture9::~IDirect3DBaseTexture9 free up m_tex
|
||
|
// we handle m_surfZero
|
||
|
|
||
|
if (m_surfZero)
|
||
|
{
|
||
|
ULONG refc = m_surfZero->Release( 0, "~IDirect3DVolumeTexture9 public release (surfZero)" ); (void)refc;
|
||
|
Assert( !refc );
|
||
|
m_surfZero = NULL;
|
||
|
}
|
||
|
// leave m_device alone!
|
||
|
}
|
||
|
|
||
|
GLMPRINTF(("<-A- ~IDirect3DVolumeTexture9"));
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DVolumeTexture9::LockBox(UINT Level,D3DLOCKED_BOX* pLockedVolume,CONST D3DBOX* pBox,DWORD Flags)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
|
||
|
GLMTexLockParams lockreq;
|
||
|
memset( &lockreq, 0, sizeof(lockreq) );
|
||
|
|
||
|
lockreq.m_tex = this->m_tex;
|
||
|
lockreq.m_face = 0;
|
||
|
lockreq.m_mip = Level;
|
||
|
|
||
|
lockreq.m_region.xmin = pBox->Left;
|
||
|
lockreq.m_region.ymin = pBox->Top;
|
||
|
lockreq.m_region.zmin = pBox->Front;
|
||
|
lockreq.m_region.xmax = pBox->Right;
|
||
|
lockreq.m_region.ymax = pBox->Bottom;
|
||
|
lockreq.m_region.zmax = pBox->Back;
|
||
|
|
||
|
char *lockAddress;
|
||
|
int yStride;
|
||
|
int zStride;
|
||
|
|
||
|
lockreq.m_tex->Lock( &lockreq, &lockAddress, &yStride, &zStride );
|
||
|
|
||
|
pLockedVolume->RowPitch = yStride;
|
||
|
pLockedVolume->SlicePitch = yStride;
|
||
|
pLockedVolume->pBits = lockAddress;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DVolumeTexture9::UnlockBox(UINT Level)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
|
||
|
GLMTexLockParams lockreq;
|
||
|
memset( &lockreq, 0, sizeof(lockreq) );
|
||
|
|
||
|
lockreq.m_tex = this->m_tex;
|
||
|
lockreq.m_face = 0;
|
||
|
lockreq.m_mip = Level;
|
||
|
|
||
|
this->m_tex->Unlock( &lockreq );
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DVolumeTexture9::GetLevelDesc( UINT Level, D3DVOLUME_DESC *pDesc )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
|
||
|
if (Level > static_cast<uint>(m_tex->m_layout->m_mipCount))
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
|
||
|
D3DVOLUME_DESC result = m_volDescZero;
|
||
|
// then mutate it for the level of interest
|
||
|
|
||
|
GLMTexLayoutSlice *slice = &m_tex->m_layout->m_slices[ m_tex->CalcSliceIndex( 0, Level ) ];
|
||
|
|
||
|
result.Width = slice->m_xSize;
|
||
|
result.Height = slice->m_ySize;
|
||
|
result.Depth = slice->m_zSize;
|
||
|
|
||
|
*pDesc = result;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- IDirect3DSurface9
|
||
|
|
||
|
#endif
|
||
|
|
||
|
IDirect3DSurface9::~IDirect3DSurface9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
|
||
|
// not much to do here, but good to verify that these things are being freed (and they are)
|
||
|
//GLMPRINTF(("-A- ~IDirect3DSurface9 - signpost"));
|
||
|
|
||
|
if (m_device)
|
||
|
{
|
||
|
GLMPRINTF(("-A- ~IDirect3DSurface9 - taking real delete path on %08x device %08x", this, m_device));
|
||
|
m_device->ReleasedSurface( this );
|
||
|
|
||
|
memset( &m_desc, 0, sizeof(m_desc) );
|
||
|
|
||
|
if (m_restype != 0) // signal that we are a surface that owns this tex (render target)
|
||
|
{
|
||
|
if (m_tex)
|
||
|
{
|
||
|
GLMPRINTF(("-A- ~IDirect3DSurface9 deleted '%s' @ %08x (GLM %08x) %s",m_tex->m_layout->m_layoutSummary, this, m_tex, m_tex->m_debugLabel ? m_tex->m_debugLabel : "" ));
|
||
|
|
||
|
m_device->ReleasedCGLMTex( m_tex );
|
||
|
|
||
|
m_tex->m_ctx->DelTex( m_tex );
|
||
|
m_tex = NULL;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
GLMPRINTF(( "-A- ~IDirect3DSurface9 : whoops, no tex to delete here ?" ));
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_tex = NULL; // we are just a view on the tex, we don't own the tex, do not delete it
|
||
|
}
|
||
|
|
||
|
m_face = m_mip = 0;
|
||
|
|
||
|
m_device = NULL;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
GLMPRINTF(("-A- ~IDirect3DSurface9 - taking strange delete path on %08x device %08x", this, m_device));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DSurface9::LockRect(D3DLOCKED_RECT* pLockedRect,CONST RECT* pRect,DWORD Flags)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
GLMTexLockParams lockreq;
|
||
|
memset( &lockreq, 0, sizeof(lockreq) );
|
||
|
|
||
|
lockreq.m_tex = this->m_tex;
|
||
|
lockreq.m_face = this->m_face;
|
||
|
lockreq.m_mip = this->m_mip;
|
||
|
|
||
|
lockreq.m_region.xmin = pRect->left;
|
||
|
lockreq.m_region.ymin = pRect->top;
|
||
|
lockreq.m_region.zmin = 0;
|
||
|
lockreq.m_region.xmax = pRect->right;
|
||
|
lockreq.m_region.ymax = pRect->bottom;
|
||
|
lockreq.m_region.zmax = 1;
|
||
|
|
||
|
if ((Flags & (D3DLOCK_READONLY | D3DLOCK_NOSYSLOCK)) == (D3DLOCK_READONLY | D3DLOCK_NOSYSLOCK) )
|
||
|
{
|
||
|
// smells like readback, force texel readout
|
||
|
lockreq.m_readback = true;
|
||
|
}
|
||
|
|
||
|
char *lockAddress;
|
||
|
int yStride;
|
||
|
int zStride;
|
||
|
|
||
|
lockreq.m_tex->Lock( &lockreq, &lockAddress, &yStride, &zStride );
|
||
|
|
||
|
pLockedRect->Pitch = yStride;
|
||
|
pLockedRect->pBits = lockAddress;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DSurface9::UnlockRect()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
GLMTexLockParams lockreq;
|
||
|
memset( &lockreq, 0, sizeof(lockreq) );
|
||
|
|
||
|
lockreq.m_tex = this->m_tex;
|
||
|
lockreq.m_face = this->m_face;
|
||
|
lockreq.m_mip = this->m_mip;
|
||
|
|
||
|
lockreq.m_tex->Unlock( &lockreq );
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DSurface9::GetDesc(D3DSURFACE_DESC *pDesc)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
*pDesc = m_desc;
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- IDirect3D9 -------------------------------------------------------
|
||
|
|
||
|
#endif
|
||
|
|
||
|
IDirect3D9::~IDirect3D9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GLMPRINTF(("-A- ~IDirect3D9 - signpost"));
|
||
|
}
|
||
|
|
||
|
UINT IDirect3D9::GetAdapterCount()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GLMgr::NewGLMgr(); // init GL manager
|
||
|
|
||
|
GLMDisplayDB *db = GetDisplayDB();
|
||
|
int dxAdapterCount = db->GetFakeAdapterCount();
|
||
|
|
||
|
return dxAdapterCount;
|
||
|
}
|
||
|
|
||
|
static void FillD3DCaps9( const GLMRendererInfoFields &glmRendererInfo, D3DCAPS9* pCaps )
|
||
|
{
|
||
|
// fill in the pCaps record for adapter... we zero most of it and just fill in the fields that we think the caller wants.
|
||
|
Q_memset( pCaps, 0, sizeof(*pCaps) );
|
||
|
|
||
|
|
||
|
/* Device Info */
|
||
|
pCaps->DeviceType = D3DDEVTYPE_HAL;
|
||
|
|
||
|
/* Caps from DX7 Draw */
|
||
|
pCaps->Caps = 0; // does anyone look at this ?
|
||
|
|
||
|
pCaps->Caps2 = D3DCAPS2_DYNAMICTEXTURES;
|
||
|
/* Cursor Caps */
|
||
|
pCaps->CursorCaps = 0; // nobody looks at this
|
||
|
|
||
|
/* 3D Device Caps */
|
||
|
pCaps->DevCaps = D3DDEVCAPS_HWTRANSFORMANDLIGHT;
|
||
|
|
||
|
pCaps->TextureCaps = D3DPTEXTURECAPS_CUBEMAP | D3DPTEXTURECAPS_MIPCUBEMAP | D3DPTEXTURECAPS_NONPOW2CONDITIONAL | D3DPTEXTURECAPS_PROJECTED;
|
||
|
// D3DPTEXTURECAPS_NOPROJECTEDBUMPENV ?
|
||
|
// D3DPTEXTURECAPS_POW2 ?
|
||
|
// caller looks at POT support like this:
|
||
|
// pCaps->m_SupportsNonPow2Textures =
|
||
|
// ( !( caps.TextureCaps & D3DPTEXTURECAPS_POW2 ) ||
|
||
|
// ( caps.TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL ) );
|
||
|
// so we should set D3DPTEXTURECAPS_NONPOW2CONDITIONAL bit ?
|
||
|
|
||
|
|
||
|
pCaps->PrimitiveMiscCaps = 0; //only the HDR setup looks at this for D3DPMISCCAPS_SEPARATEALPHABLEND.
|
||
|
// ? D3DPMISCCAPS_SEPARATEALPHABLEND
|
||
|
// ? D3DPMISCCAPS_BLENDOP
|
||
|
// ? D3DPMISCCAPS_CLIPPLANESCALEDPOINTS
|
||
|
// ? D3DPMISCCAPS_CLIPTLVERTS D3DPMISCCAPS_COLORWRITEENABLE D3DPMISCCAPS_MASKZ D3DPMISCCAPS_TSSARGTEMP
|
||
|
|
||
|
|
||
|
pCaps->RasterCaps = D3DPRASTERCAPS_SCISSORTEST
|
||
|
| D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS // ref'd in CShaderDeviceMgrDx8::ComputeCapsFromD3D
|
||
|
| D3DPRASTERCAPS_DEPTHBIAS // ref'd in CShaderDeviceMgrDx8::ComputeCapsFromD3D
|
||
|
;
|
||
|
|
||
|
pCaps->TextureFilterCaps = D3DPTFILTERCAPS_MINFANISOTROPIC | D3DPTFILTERCAPS_MAGFANISOTROPIC;
|
||
|
|
||
|
pCaps->MaxTextureWidth = 4096;
|
||
|
pCaps->MaxTextureHeight = 4096;
|
||
|
pCaps->MaxVolumeExtent = 1024; //guesses
|
||
|
|
||
|
pCaps->MaxTextureAspectRatio = 0; // imply no limit on AR
|
||
|
|
||
|
pCaps->MaxAnisotropy = glmRendererInfo.m_maxAniso;
|
||
|
|
||
|
pCaps->TextureOpCaps = D3DTEXOPCAPS_ADD | D3DTEXOPCAPS_MODULATE2X; //guess
|
||
|
//DWORD MaxTextureBlendStages;
|
||
|
//DWORD MaxSimultaneousTextures;
|
||
|
|
||
|
pCaps->VertexProcessingCaps = D3DVTXPCAPS_TEXGEN_SPHEREMAP;
|
||
|
|
||
|
pCaps->MaxActiveLights = 8; // guess
|
||
|
|
||
|
|
||
|
// MaxUserClipPlanes. A bit complicated..
|
||
|
// it's difficult to make this fluid without teaching the engine about a cap that could change during run.
|
||
|
|
||
|
// start it out set to '2'.
|
||
|
// turn it off, if we're in GLSL mode but do not have native clip plane capability.
|
||
|
pCaps->MaxUserClipPlanes = 2; // assume good news
|
||
|
|
||
|
// is user asking for it to be off ?
|
||
|
if ( CommandLine()->CheckParm( "-nouserclip" ) )
|
||
|
{
|
||
|
pCaps->MaxUserClipPlanes = 0;
|
||
|
}
|
||
|
|
||
|
pCaps->MaxVertexBlendMatrices = 0; // see if anyone cares
|
||
|
pCaps->MaxVertexBlendMatrixIndex = 0; // see if anyone cares
|
||
|
|
||
|
pCaps->MaxPrimitiveCount = 32768; // guess
|
||
|
pCaps->MaxStreams = D3D_MAX_STREAMS; // guess
|
||
|
|
||
|
pCaps->VertexShaderVersion = 0x300; // model 3.0
|
||
|
pCaps->MaxVertexShaderConst = DXABSTRACT_VS_PARAM_SLOTS; // number of vertex shader constant registers
|
||
|
|
||
|
pCaps->PixelShaderVersion = 0x300; // model 3.0
|
||
|
|
||
|
// Here are the DX9 specific ones
|
||
|
pCaps->DevCaps2 = D3DDEVCAPS2_STREAMOFFSET;
|
||
|
|
||
|
pCaps->PS20Caps.NumInstructionSlots = 512; // guess
|
||
|
// only examined once:
|
||
|
// pCaps->m_SupportsPixelShaders_2_b = ( ( caps.PixelShaderVersion & 0xffff ) >= 0x0200) && (caps.PS20Caps.NumInstructionSlots >= 512);
|
||
|
//pCaps->m_SupportsPixelShaders_2_b = 1;
|
||
|
|
||
|
pCaps->NumSimultaneousRTs = 1; // Will be at least 1
|
||
|
pCaps->MaxVertexShader30InstructionSlots = 0;
|
||
|
pCaps->MaxPixelShader30InstructionSlots = 0;
|
||
|
|
||
|
#if DX_TO_GL_ABSTRACTION
|
||
|
pCaps->FakeSRGBWrite = !glmRendererInfo.m_hasGammaWrites;
|
||
|
pCaps->CanDoSRGBReadFromRTs = !glmRendererInfo.m_cantAttachSRGB;
|
||
|
pCaps->MixedSizeTargets = glmRendererInfo.m_hasMixedAttachmentSizes;
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3D9::GetDeviceCaps(UINT Adapter, D3DDEVTYPE DeviceType, D3DCAPS9* pCaps)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
// Generally called from "CShaderDeviceMgrDx8::ComputeCapsFromD3D" in ShaderDeviceDX8.cpp
|
||
|
|
||
|
// "Adapter" is used to index amongst the set of fake-adapters maintained in the display DB
|
||
|
GLMDisplayDB *db = GetDisplayDB();
|
||
|
int glmRendererIndex = -1;
|
||
|
int glmDisplayIndex = -1;
|
||
|
|
||
|
GLMRendererInfoFields glmRendererInfo;
|
||
|
GLMDisplayInfoFields glmDisplayInfo;
|
||
|
|
||
|
bool result = db->GetFakeAdapterInfo( Adapter, &glmRendererIndex, &glmDisplayIndex, &glmRendererInfo, &glmDisplayInfo ); (void)result;
|
||
|
Assert (!result);
|
||
|
// just leave glmRendererInfo filled out for subsequent code to look at as needed.
|
||
|
|
||
|
FillD3DCaps9( glmRendererInfo, pCaps );
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3D9::GetAdapterIdentifier( UINT Adapter, DWORD Flags, D3DADAPTER_IDENTIFIER9* pIdentifier )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
// Generally called from "CShaderDeviceMgrDx8::ComputeCapsFromD3D" in ShaderDeviceDX8.cpp
|
||
|
|
||
|
Assert( Flags == D3DENUM_WHQL_LEVEL ); // we're not handling any other queries than this yet
|
||
|
|
||
|
Q_memset( pIdentifier, 0, sizeof(*pIdentifier) );
|
||
|
|
||
|
GLMDisplayDB *db = GetDisplayDB();
|
||
|
int glmRendererIndex = -1;
|
||
|
int glmDisplayIndex = -1;
|
||
|
|
||
|
GLMRendererInfoFields glmRendererInfo;
|
||
|
GLMDisplayInfoFields glmDisplayInfo;
|
||
|
|
||
|
// the D3D "Adapter" number feeds the fake adapter index
|
||
|
bool result = db->GetFakeAdapterInfo( Adapter, &glmRendererIndex, &glmDisplayIndex, &glmRendererInfo, &glmDisplayInfo ); (void)result;
|
||
|
Assert (!result);
|
||
|
|
||
|
#ifndef OSX
|
||
|
if( glmRendererInfo.m_rendererID )
|
||
|
#endif
|
||
|
{
|
||
|
const char *pRenderer = GLMDecode( eGL_RENDERER, glmRendererInfo.m_rendererID & 0x00FFFF00 );
|
||
|
|
||
|
Q_snprintf( pIdentifier->Driver, sizeof(pIdentifier->Driver), "OpenGL %s (%08x)",
|
||
|
pRenderer, glmRendererInfo.m_rendererID );
|
||
|
|
||
|
Q_snprintf( pIdentifier->Description, sizeof(pIdentifier->Description), "%s - %dx%d - %dMB VRAM",
|
||
|
pRenderer,
|
||
|
glmDisplayInfo.m_displayPixelWidth, glmDisplayInfo.m_displayPixelHeight,
|
||
|
glmRendererInfo.m_vidMemory >> 20 );
|
||
|
}
|
||
|
#ifndef OSX
|
||
|
else
|
||
|
{
|
||
|
static CDynamicFunctionOpenGL< true, const GLubyte *( APIENTRY *)(GLenum name), const GLubyte * > glGetString("glGetString");
|
||
|
|
||
|
const char *pszStringVendor = ( const char * )glGetString( GL_VENDOR ); // NVIDIA Corporation
|
||
|
const char *pszStringRenderer = ( const char * )glGetString( GL_RENDERER ); // GeForce GTX 680/PCIe/SSE2
|
||
|
const char *pszStringVersion = ( const char * )glGetString( GL_VERSION ); // 4.2.0 NVIDIA 304.22
|
||
|
|
||
|
Q_snprintf( pIdentifier->Driver, sizeof( pIdentifier->Driver ), "OpenGL %s (%s)",
|
||
|
pszStringVendor, pszStringRenderer );
|
||
|
Q_snprintf( pIdentifier->Description, sizeof( pIdentifier->Description ), "%s (%s) %s - %dx%d",
|
||
|
pszStringVendor, pszStringRenderer, pszStringVersion,
|
||
|
glmDisplayInfo.m_displayPixelWidth, glmDisplayInfo.m_displayPixelHeight );
|
||
|
}
|
||
|
#endif // !OSX
|
||
|
|
||
|
pIdentifier->VendorId = glmRendererInfo.m_pciVendorID; // 4318;
|
||
|
pIdentifier->DeviceId = glmRendererInfo.m_pciDeviceID; // 401;
|
||
|
pIdentifier->SubSysId = 0; // 3358668866;
|
||
|
pIdentifier->Revision = 0; // 162;
|
||
|
pIdentifier->VideoMemory = glmRendererInfo.m_vidMemory; // amount of video memory in bytes
|
||
|
|
||
|
#if 0
|
||
|
// this came from the shaderapigl effort
|
||
|
Q_strncpy( pIdentifier->Driver, "Fake-Video-Card", MAX_DEVICE_IDENTIFIER_STRING );
|
||
|
Q_strncpy( pIdentifier->Description, "Fake-Video-Card", MAX_DEVICE_IDENTIFIER_STRING );
|
||
|
pIdentifier->VendorId = 4318;
|
||
|
pIdentifier->DeviceId = 401;
|
||
|
pIdentifier->SubSysId = 3358668866;
|
||
|
pIdentifier->Revision = 162;
|
||
|
#endif
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3D9::CheckDeviceFormat(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
if (0) // hush for now, less spew
|
||
|
{
|
||
|
GLMPRINTF(("-X- ** IDirect3D9::CheckDeviceFormat: \n -- Adapter=%d || DeviceType=%4x:%s || AdapterFormat=%8x:%s\n -- RType %8x: %s\n -- CheckFormat %8x: %s\n -- Usage %8x: %s",
|
||
|
Adapter,
|
||
|
DeviceType, GLMDecode(eD3D_DEVTYPE, DeviceType),
|
||
|
AdapterFormat, GLMDecode(eD3D_FORMAT, AdapterFormat),
|
||
|
RType, GLMDecode(eD3D_RTYPE, RType),
|
||
|
CheckFormat, GLMDecode(eD3D_FORMAT, CheckFormat),
|
||
|
Usage, GLMDecodeMask( eD3D_USAGE, Usage ) ));
|
||
|
}
|
||
|
|
||
|
HRESULT result = D3DERR_NOTAVAILABLE; // failure
|
||
|
|
||
|
DWORD knownUsageMask = D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL | D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP
|
||
|
| D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_FILTER | D3DUSAGE_QUERY_SRGBWRITE | D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
|
||
|
| D3DUSAGE_QUERY_VERTEXTEXTURE;
|
||
|
(void)knownUsageMask;
|
||
|
|
||
|
// FramebufferSRGB stuff.
|
||
|
// basically a format is only allowed to have SRGB usage for writing, if you have the framebuffer SRGB extension.
|
||
|
// so, check for that capability with GLM adapter db, and if it's not there, don't mark that bit as usable in any of our formats.
|
||
|
GLMDisplayDB *db = GetDisplayDB();
|
||
|
int glmRendererIndex = -1;
|
||
|
int glmDisplayIndex = -1;
|
||
|
|
||
|
GLMRendererInfoFields glmRendererInfo;
|
||
|
GLMDisplayInfoFields glmDisplayInfo;
|
||
|
|
||
|
bool dbresult = db->GetFakeAdapterInfo( Adapter, &glmRendererIndex, &glmDisplayIndex, &glmRendererInfo, &glmDisplayInfo ); (void)dbresult;
|
||
|
Assert (!dbresult);
|
||
|
|
||
|
Assert ((Usage & knownUsageMask) == Usage);
|
||
|
|
||
|
DWORD legalUsage = 0;
|
||
|
switch( AdapterFormat )
|
||
|
{
|
||
|
case D3DFMT_X8R8G8B8:
|
||
|
switch( RType )
|
||
|
{
|
||
|
case D3DRTYPE_TEXTURE:
|
||
|
switch( CheckFormat )
|
||
|
{
|
||
|
case D3DFMT_DXT1:
|
||
|
case D3DFMT_DXT3:
|
||
|
case D3DFMT_DXT5:
|
||
|
legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
legalUsage |= D3DUSAGE_QUERY_SRGBREAD;
|
||
|
|
||
|
//open question: is auto gen of mipmaps is allowed or attempted on any DXT textures.
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_A8R8G8B8: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
legalUsage |= D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE | D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
|
||
|
break;
|
||
|
|
||
|
//$ TODO: Need to merge bitmap changes over from Dota to get these formats.
|
||
|
#if 0
|
||
|
case D3DFMT_A2R10G10B10: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
legalUsage |= D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE | D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_A2B10G10R10: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
legalUsage |= D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE | D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
|
||
|
break;
|
||
|
#endif
|
||
|
|
||
|
case D3DFMT_R32F: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
legalUsage |= D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE | D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_A16B16G16R16:
|
||
|
legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
legalUsage |= D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE | D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_A16B16G16R16F: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE;
|
||
|
|
||
|
if ( !glmRendererInfo.m_atiR5xx )
|
||
|
{
|
||
|
legalUsage |= D3DUSAGE_QUERY_FILTER | D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_A32B32G32R32F: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_RENDERTARGET | D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE;
|
||
|
|
||
|
if ( !glmRendererInfo.m_atiR5xx && !glmRendererInfo.m_nvG7x )
|
||
|
{
|
||
|
legalUsage |= D3DUSAGE_QUERY_FILTER | D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_R5G6B5: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
break;
|
||
|
|
||
|
//-----------------------------------------------------------
|
||
|
// these come in from TestTextureFormat in ColorFormatDX8.cpp which is being driven by InitializeColorInformation...
|
||
|
// which is going to try all 8 combinations of (vertex texturable / render targetable / filterable ) on every image format it knows.
|
||
|
|
||
|
case D3DFMT_R8G8B8: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
legalUsage |= D3DUSAGE_QUERY_SRGBREAD;
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_X8R8G8B8: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
legalUsage |= D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE;
|
||
|
break;
|
||
|
|
||
|
// one and two channel textures... we'll have to fake these as four channel tex if we want to support them
|
||
|
case D3DFMT_L8: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_A8L8: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_A8: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
break;
|
||
|
|
||
|
// going to need to go back and double check all of these..
|
||
|
case D3DFMT_X1R5G5B5: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_A4R4G4B4: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_A1R5G5B5: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_V8U8: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_Q8W8V8U8: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
// what the heck is QWVU8 ... ?
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_X8L8V8U8: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_AUTOGENMIPMAP | D3DUSAGE_QUERY_FILTER;
|
||
|
// what the heck is XLVU8 ... ?
|
||
|
break;
|
||
|
|
||
|
// formats with depth...
|
||
|
|
||
|
case D3DFMT_D16: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL;
|
||
|
// just a guess on the legal usages
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_D24S8: legalUsage = D3DUSAGE_DYNAMIC | D3DUSAGE_RENDERTARGET | D3DUSAGE_DEPTHSTENCIL;
|
||
|
// just a guess on the legal usages
|
||
|
break;
|
||
|
|
||
|
// vendor formats... try marking these all invalid for now
|
||
|
case D3DFMT_NV_INTZ:
|
||
|
case D3DFMT_NV_RAWZ:
|
||
|
case D3DFMT_NV_NULL:
|
||
|
case D3DFMT_ATI_D16:
|
||
|
case D3DFMT_ATI_D24S8:
|
||
|
case D3DFMT_ATI_2N:
|
||
|
case D3DFMT_ATI_1N:
|
||
|
legalUsage = 0;
|
||
|
break;
|
||
|
|
||
|
//-----------------------------------------------------------
|
||
|
|
||
|
default:
|
||
|
Assert(!"Unknown check format");
|
||
|
result = D3DERR_NOTAVAILABLE;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if ((Usage & legalUsage) == Usage)
|
||
|
{
|
||
|
result = S_OK;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
DWORD unsatBits = Usage & (~legalUsage); // clear the bits of the req that were legal, leaving the illegal ones
|
||
|
unsatBits;
|
||
|
GLMPRINTF(( "-X- --> NOT OK: flags %8x:%s", unsatBits,GLMDecodeMask( eD3D_USAGE, unsatBits ) ));
|
||
|
result = D3DERR_NOTAVAILABLE;
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case D3DRTYPE_SURFACE:
|
||
|
switch( static_cast<uint>(CheckFormat) )
|
||
|
{
|
||
|
case 0x434f5441:
|
||
|
case 0x41415353:
|
||
|
result = D3DERR_NOTAVAILABLE;
|
||
|
break;
|
||
|
|
||
|
case D3DFMT_D24S8:
|
||
|
result = S_OK;
|
||
|
break;
|
||
|
//** IDirect3D9::CheckDeviceFormat adapter=0, DeviceType= 1:D3DDEVTYPE_HAL, AdapterFormat= 5:D3DFMT_X8R8G8B8, RType= 1:D3DRTYPE_SURFACE, CheckFormat=434f5441:UNKNOWN
|
||
|
//** IDirect3D9::CheckDeviceFormat adapter=0, DeviceType= 1:D3DDEVTYPE_HAL, AdapterFormat= 5:D3DFMT_X8R8G8B8, RType= 1:D3DRTYPE_SURFACE, CheckFormat=41415353:UNKNOWN
|
||
|
//** IDirect3D9::CheckDeviceFormat adapter=0, DeviceType= 1:D3DDEVTYPE_HAL, AdapterFormat= 5:D3DFMT_X8R8G8B8, RType= 1:D3DRTYPE_SURFACE, CheckFormat=434f5441:UNKNOWN
|
||
|
//** IDirect3D9::CheckDeviceFormat adapter=0, DeviceType= 1:D3DDEVTYPE_HAL, AdapterFormat= 5:D3DFMT_X8R8G8B8, RType= 1:D3DRTYPE_SURFACE, CheckFormat=41415353:UNKNOWN
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
Assert(!"Unknown resource type");
|
||
|
result = D3DERR_NOTAVAILABLE;
|
||
|
break;
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
Assert(!"Unknown adapter format");
|
||
|
result = D3DERR_NOTAVAILABLE;
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
UINT IDirect3D9::GetAdapterModeCount(UINT Adapter,D3DFORMAT Format)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GLMPRINTF(( "-X- IDirect3D9::GetAdapterModeCount: Adapter=%d || Format=%8x:%s", Adapter, Format, GLMDecode(eD3D_FORMAT, Format) ));
|
||
|
|
||
|
uint modeCount=0;
|
||
|
|
||
|
GLMDisplayDB *db = GetDisplayDB();
|
||
|
int glmRendererIndex = -1;
|
||
|
int glmDisplayIndex = -1;
|
||
|
|
||
|
GLMRendererInfoFields glmRendererInfo;
|
||
|
GLMDisplayInfoFields glmDisplayInfo;
|
||
|
|
||
|
// the D3D "Adapter" number feeds the fake adapter index
|
||
|
bool result = db->GetFakeAdapterInfo( Adapter, &glmRendererIndex, &glmDisplayIndex, &glmRendererInfo, &glmDisplayInfo ); (void)result;
|
||
|
Assert (!result);
|
||
|
|
||
|
modeCount = db->GetModeCount( glmRendererIndex, glmDisplayIndex );
|
||
|
GLMPRINTF(( "-X- --> result is %d", modeCount ));
|
||
|
|
||
|
return modeCount;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3D9::EnumAdapterModes(UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GLMPRINTF(( "-X- IDirect3D9::EnumAdapterModes: Adapter=%d || Format=%8x:%s || Mode=%d", Adapter, Format, GLMDecode(eD3D_FORMAT, Format), Mode ));
|
||
|
|
||
|
Assert(Format==D3DFMT_X8R8G8B8);
|
||
|
|
||
|
GLMDisplayDB *db = GetDisplayDB();
|
||
|
|
||
|
int glmRendererIndex = -1;
|
||
|
int glmDisplayIndex = -1;
|
||
|
|
||
|
GLMRendererInfoFields glmRendererInfo;
|
||
|
GLMDisplayInfoFields glmDisplayInfo;
|
||
|
GLMDisplayModeInfoFields glmModeInfo;
|
||
|
|
||
|
// the D3D "Adapter" number feeds the fake adapter index
|
||
|
bool result = db->GetFakeAdapterInfo( Adapter, &glmRendererIndex, &glmDisplayIndex, &glmRendererInfo, &glmDisplayInfo );
|
||
|
Assert (!result);
|
||
|
if (result) return D3DERR_NOTAVAILABLE;
|
||
|
|
||
|
bool result2 = db->GetModeInfo( glmRendererIndex, glmDisplayIndex, Mode, &glmModeInfo );
|
||
|
Assert( !result2 );
|
||
|
if (result2) return D3DERR_NOTAVAILABLE;
|
||
|
|
||
|
pMode->Width = glmModeInfo.m_modePixelWidth;
|
||
|
pMode->Height = glmModeInfo.m_modePixelHeight;
|
||
|
pMode->RefreshRate = glmModeInfo.m_modeRefreshHz; // "adapter default"
|
||
|
pMode->Format = Format; // whatever you asked for ?
|
||
|
|
||
|
GLMPRINTF(( "-X- IDirect3D9::EnumAdapterModes returning mode size (%d,%d) and D3DFMT_X8R8G8B8",pMode->Width,pMode->Height ));
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3D9::CheckDeviceType(UINT Adapter,D3DDEVTYPE DevType,D3DFORMAT AdapterFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
//FIXME: we just say "OK" on any query
|
||
|
|
||
|
GLMPRINTF(( "-X- IDirect3D9::CheckDeviceType: Adapter=%d || DevType=%d:%s || AdapterFormat=%d:%s || BackBufferFormat=%d:%s || bWindowed=%d",
|
||
|
Adapter,
|
||
|
DevType, GLMDecode(eD3D_DEVTYPE,DevType),
|
||
|
AdapterFormat, GLMDecode(eD3D_FORMAT, AdapterFormat),
|
||
|
BackBufferFormat, GLMDecode(eD3D_FORMAT, BackBufferFormat),
|
||
|
(int) bWindowed ));
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3D9::GetAdapterDisplayMode(UINT Adapter,D3DDISPLAYMODE* pMode)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
// asking what the current mode is
|
||
|
GLMPRINTF(("-X- IDirect3D9::GetAdapterDisplayMode: Adapter=%d", Adapter ));
|
||
|
|
||
|
GLMDisplayDB *db = GetDisplayDB();
|
||
|
|
||
|
int glmRendererIndex = -1;
|
||
|
int glmDisplayIndex = -1;
|
||
|
|
||
|
GLMRendererInfoFields glmRendererInfo;
|
||
|
GLMDisplayInfoFields glmDisplayInfo;
|
||
|
GLMDisplayModeInfoFields glmModeInfo;
|
||
|
|
||
|
// the D3D "Adapter" number feeds the fake adapter index
|
||
|
bool result = db->GetFakeAdapterInfo( Adapter, &glmRendererIndex, &glmDisplayIndex, &glmRendererInfo, &glmDisplayInfo );
|
||
|
Assert(!result);
|
||
|
if (result) return D3DERR_INVALIDCALL;
|
||
|
|
||
|
int modeIndex = -1; // pass -1 as a mode index to find out about whatever the current mode is on the selected display
|
||
|
|
||
|
bool modeResult = db->GetModeInfo( glmRendererIndex, glmDisplayIndex, modeIndex, &glmModeInfo );
|
||
|
Assert (!modeResult);
|
||
|
if (modeResult) return D3DERR_INVALIDCALL;
|
||
|
|
||
|
pMode->Width = glmModeInfo.m_modePixelWidth;
|
||
|
pMode->Height = glmModeInfo.m_modePixelHeight;
|
||
|
pMode->RefreshRate = glmModeInfo.m_modeRefreshHz; // "adapter default"
|
||
|
pMode->Format = D3DFMT_X8R8G8B8; //FIXME, this is a SWAG
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3D9::CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GLMPRINTF(("-X- IDirect3D9::CheckDepthStencilMatch: Adapter=%d || DevType=%d:%s || AdapterFormat=%d:%s || RenderTargetFormat=%d:%s || DepthStencilFormat=%d:%s",
|
||
|
Adapter,
|
||
|
DeviceType, GLMDecode(eD3D_DEVTYPE,DeviceType),
|
||
|
AdapterFormat, GLMDecode(eD3D_FORMAT, AdapterFormat),
|
||
|
RenderTargetFormat, GLMDecode(eD3D_FORMAT, RenderTargetFormat),
|
||
|
DepthStencilFormat, GLMDecode(eD3D_FORMAT, DepthStencilFormat) ));
|
||
|
|
||
|
// one known request looks like this:
|
||
|
// AdapterFormat=5:D3DFMT_X8R8G8B8 || RenderTargetFormat=3:D3DFMT_A8R8G8B8 || DepthStencilFormat=2:D3DFMT_D24S8
|
||
|
|
||
|
// return S_OK for that one combo, DXABSTRACT_BREAK_ON_ERROR() on anything else
|
||
|
HRESULT result = D3DERR_NOTAVAILABLE; // failure
|
||
|
|
||
|
switch( AdapterFormat )
|
||
|
{
|
||
|
case D3DFMT_X8R8G8B8:
|
||
|
{
|
||
|
if ( (RenderTargetFormat == D3DFMT_A8R8G8B8) && (DepthStencilFormat == D3DFMT_D24S8) )
|
||
|
{
|
||
|
result = S_OK;
|
||
|
}
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
Assert( result == S_OK );
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3D9::CheckDeviceMultiSampleType( UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GLMDisplayDB *db = GetDisplayDB();
|
||
|
|
||
|
int glmRendererIndex = -1;
|
||
|
int glmDisplayIndex = -1;
|
||
|
|
||
|
GLMRendererInfoFields glmRendererInfo;
|
||
|
GLMDisplayInfoFields glmDisplayInfo;
|
||
|
//GLMDisplayModeInfoFields glmModeInfo;
|
||
|
|
||
|
// the D3D "Adapter" number feeds the fake adapter index
|
||
|
bool result = db->GetFakeAdapterInfo( Adapter, &glmRendererIndex, &glmDisplayIndex, &glmRendererInfo, &glmDisplayInfo );
|
||
|
Assert( !result );
|
||
|
if ( result )
|
||
|
return D3DERR_INVALIDCALL;
|
||
|
|
||
|
|
||
|
if ( !CommandLine()->FindParm("-glmenabletrustmsaa") )
|
||
|
{
|
||
|
// These ghetto drivers don't get MSAA
|
||
|
if ( ( glmRendererInfo.m_nvG7x || glmRendererInfo.m_atiR5xx ) && ( MultiSampleType > D3DMULTISAMPLE_NONE ) )
|
||
|
{
|
||
|
if ( pQualityLevels )
|
||
|
{
|
||
|
*pQualityLevels = 0;
|
||
|
}
|
||
|
return D3DERR_NOTAVAILABLE;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
switch ( MultiSampleType )
|
||
|
{
|
||
|
case D3DMULTISAMPLE_NONE: // always return true
|
||
|
if ( pQualityLevels )
|
||
|
{
|
||
|
*pQualityLevels = 1;
|
||
|
}
|
||
|
return S_OK;
|
||
|
break;
|
||
|
|
||
|
case D3DMULTISAMPLE_2_SAMPLES:
|
||
|
case D3DMULTISAMPLE_4_SAMPLES:
|
||
|
case D3DMULTISAMPLE_6_SAMPLES:
|
||
|
case D3DMULTISAMPLE_8_SAMPLES:
|
||
|
// note the fact that the d3d enums for 2, 4, 6, 8 samples are equal to 2,4,6,8...
|
||
|
if (glmRendererInfo.m_maxSamples >= (int)MultiSampleType )
|
||
|
{
|
||
|
if ( pQualityLevels )
|
||
|
{
|
||
|
*pQualityLevels = 1;
|
||
|
}
|
||
|
return S_OK;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return D3DERR_NOTAVAILABLE;
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
if ( pQualityLevels )
|
||
|
{
|
||
|
*pQualityLevels = 0;
|
||
|
}
|
||
|
return D3DERR_NOTAVAILABLE;
|
||
|
break;
|
||
|
}
|
||
|
return D3DERR_NOTAVAILABLE;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3D9::CreateDevice(UINT Adapter,D3DDEVTYPE DeviceType,VD3DHWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9** ppReturnedDeviceInterface)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
|
||
|
#if GLMDEBUG
|
||
|
GLMDebugPrintf( "WARNING: GLMEBUG is 1, perf. is going to be low!" );
|
||
|
Warning( "WARNING: GLMEBUG is 1, perf. is going to be low!" );
|
||
|
#endif
|
||
|
#if !TOGL_SUPPORT_NULL_DEVICE
|
||
|
if (DeviceType == D3DDEVTYPE_NULLREF)
|
||
|
{
|
||
|
Error( "Must define TOGL_SUPPORT_NULL_DEVICE to use the NULL device" );
|
||
|
DebuggerBreak();
|
||
|
return E_FAIL;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
// constrain these inputs for the time being
|
||
|
// BackBufferFormat -> A8R8G8B8
|
||
|
// BackBufferCount -> 1;
|
||
|
// MultiSampleType -> D3DMULTISAMPLE_NONE
|
||
|
// AutoDepthStencilFormat -> D3DFMT_D24S8
|
||
|
|
||
|
// NULL out the return pointer so if we exit early it is not set
|
||
|
*ppReturnedDeviceInterface = NULL;
|
||
|
|
||
|
// assume success unless something is sour
|
||
|
HRESULT result = S_OK;
|
||
|
|
||
|
// relax this check for now
|
||
|
//if (pPresentationParameters->BackBufferFormat != D3DFMT_A8R8G8B8)
|
||
|
//{
|
||
|
// DXABSTRACT_BREAK_ON_ERROR();
|
||
|
// result = -1;
|
||
|
//}
|
||
|
|
||
|
//rbarris 24Aug10 - relaxing this check - we don't care if the game asks for two backbuffers, it's moot
|
||
|
//if ( pPresentationParameters->BackBufferCount != 1 )
|
||
|
//{
|
||
|
// DXABSTRACT_BREAK_ON_ERROR();
|
||
|
// result = D3DERR_NOTAVAILABLE;
|
||
|
//}
|
||
|
|
||
|
if ( pPresentationParameters->AutoDepthStencilFormat != D3DFMT_D24S8 )
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
result = D3DERR_NOTAVAILABLE;
|
||
|
}
|
||
|
|
||
|
if ( result == S_OK )
|
||
|
{
|
||
|
// create an IDirect3DDevice9
|
||
|
// it will make a GLMContext and set up some drawables
|
||
|
|
||
|
IDirect3DDevice9Params devparams;
|
||
|
memset( &devparams, 0, sizeof(devparams) );
|
||
|
|
||
|
devparams.m_adapter = Adapter;
|
||
|
devparams.m_deviceType = DeviceType;
|
||
|
devparams.m_focusWindow = hFocusWindow; // is this meaningful? is this a WindowRef ? follow it up the chain..
|
||
|
devparams.m_behaviorFlags = BehaviorFlags;
|
||
|
devparams.m_presentationParameters = *pPresentationParameters;
|
||
|
|
||
|
IDirect3DDevice9 *dev = new IDirect3DDevice9;
|
||
|
|
||
|
result = dev->Create( &devparams );
|
||
|
|
||
|
if ( result == S_OK )
|
||
|
{
|
||
|
*ppReturnedDeviceInterface = dev;
|
||
|
}
|
||
|
|
||
|
g_bNullD3DDevice = ( DeviceType == D3DDEVTYPE_NULLREF );
|
||
|
}
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- IDirect3DQuery9
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DQuery9::Issue(DWORD dwIssueFlags)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
Assert( m_device->m_nValidMarker == D3D_DEVICE_VALID_MARKER );
|
||
|
// Flags field for Issue
|
||
|
// #define D3DISSUE_END (1 << 0) // Tells the runtime to issue the end of a query, changing it's state to "non-signaled".
|
||
|
// #define D3DISSUE_BEGIN (1 << 1) // Tells the runtime to issue the beginng of a query.
|
||
|
|
||
|
// Make sure calling thread owns the GL context.
|
||
|
Assert( m_ctx->m_nCurOwnerThreadId == ThreadGetCurrentId() );
|
||
|
|
||
|
if (dwIssueFlags & D3DISSUE_BEGIN)
|
||
|
{
|
||
|
m_nIssueStartThreadID = ThreadGetCurrentId();
|
||
|
m_nIssueStartDrawCallIndex = g_nTotalDrawsOrClears;
|
||
|
m_nIssueStartFrameIndex = m_ctx->m_nCurFrame;
|
||
|
m_nIssueStartQueryCreationCounter = CGLMQuery::s_nTotalOcclusionQueryCreatesOrDeletes;
|
||
|
|
||
|
switch( m_type )
|
||
|
{
|
||
|
case D3DQUERYTYPE_OCCLUSION:
|
||
|
m_query->Start(); // drop "start counter" call into stream
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
Assert(!"Can't use D3DISSUE_BEGIN on this query");
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (dwIssueFlags & D3DISSUE_END)
|
||
|
{
|
||
|
m_nIssueEndThreadID = ThreadGetCurrentId();
|
||
|
m_nIssueEndDrawCallIndex = g_nTotalDrawsOrClears;
|
||
|
m_nIssueEndFrameIndex = m_ctx->m_nCurFrame;
|
||
|
m_nIssueEndQueryCreationCounter = CGLMQuery::s_nTotalOcclusionQueryCreatesOrDeletes;
|
||
|
|
||
|
switch( m_type )
|
||
|
{
|
||
|
case D3DQUERYTYPE_OCCLUSION:
|
||
|
m_query->Stop(); // drop "end counter" call into stream
|
||
|
break;
|
||
|
|
||
|
case D3DQUERYTYPE_EVENT:
|
||
|
m_nIssueStartThreadID = m_nIssueEndThreadID;
|
||
|
m_nIssueStartDrawCallIndex = m_nIssueEndDrawCallIndex;
|
||
|
m_nIssueStartFrameIndex = m_nIssueEndFrameIndex;
|
||
|
m_nIssueStartQueryCreationCounter = m_nIssueEndQueryCreationCounter;
|
||
|
|
||
|
// End is very weird with respect to Events (fences).
|
||
|
// DX9 docs say to use End to put the fence in the stream. So we map End to GLM's Start.
|
||
|
// http://msdn.microsoft.com/en-us/library/ee422167(VS.85).aspx
|
||
|
m_query->Start(); // drop "set fence" into stream
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DQuery9::GetData(void* pData,DWORD dwSize,DWORD dwGetDataFlags)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
Assert( m_device->m_nValidMarker == D3D_DEVICE_VALID_MARKER );
|
||
|
HRESULT result = S_FALSE ;
|
||
|
DWORD nCurThreadId = ThreadGetCurrentId();
|
||
|
|
||
|
// Make sure calling thread owns the GL context.
|
||
|
Assert( m_ctx->m_nCurOwnerThreadId == nCurThreadId );
|
||
|
if ( pData )
|
||
|
{
|
||
|
*(uint*)pData = 0;
|
||
|
}
|
||
|
|
||
|
if ( !m_query->IsStarted() || !m_query->IsStopped() )
|
||
|
{
|
||
|
Assert(!"Can't GetData before issue/start/stop");
|
||
|
printf("\n** IDirect3DQuery9::GetData: can't GetData before issue/start/stop");
|
||
|
return S_FALSE;
|
||
|
}
|
||
|
|
||
|
// GetData is not always called with the flush bit.
|
||
|
|
||
|
// if an answer is not yet available - return S_FALSE.
|
||
|
// if an answer is available - return S_OK and write the answer into *pData.
|
||
|
bool done = false;
|
||
|
bool flush = (dwGetDataFlags & D3DGETDATA_FLUSH) != 0; // aka spin until done
|
||
|
|
||
|
// hmmm both of these paths are the same, maybe we could fold them up
|
||
|
if ( m_type == D3DQUERYTYPE_OCCLUSION )
|
||
|
{
|
||
|
// Detect cases that are actually just not supported with the way we're using GL queries. (For example, beginning a query, then creating/deleting any query, the ending the same query is not supported.)
|
||
|
// Also extra paranoid to detect/work around various NV/AMD driver issues.
|
||
|
if ( ( ( m_nIssueStartThreadID != nCurThreadId ) || ( m_nIssueEndThreadID != nCurThreadId ) ) ||
|
||
|
( m_nIssueStartDrawCallIndex == m_nIssueEndDrawCallIndex ) || ( m_nIssueStartFrameIndex != m_nIssueEndFrameIndex ) ||
|
||
|
( m_nIssueStartQueryCreationCounter != m_nIssueEndQueryCreationCounter ) )
|
||
|
{
|
||
|
// The thread Issue() was called on differs from GetData() - NV's driver doesn't like this, not sure about AMD. Just fake the results if a flush is requested.
|
||
|
// There are various ways to properly handle this scenario, but in practice it only seems to occur in non-critical times (during shutdown or when mat_queue_mode is changed in L4D2).
|
||
|
if ( flush )
|
||
|
{
|
||
|
gGL->glFlush();
|
||
|
}
|
||
|
|
||
|
#if 0
|
||
|
if ( ( m_nIssueStartThreadID != nCurThreadId ) || ( m_nIssueEndThreadID != nCurThreadId ) )
|
||
|
{
|
||
|
GLMDebugPrintf( "IDirect3DQuery9::GetData: GetData() called from different thread verses the issueing thread()!\n" );
|
||
|
}
|
||
|
#endif
|
||
|
if ( m_nIssueStartQueryCreationCounter != m_nIssueEndQueryCreationCounter )
|
||
|
{
|
||
|
GLMDebugPrintf( "IDirect3DQuery9::GetData: One or more queries have been created or released while this query was still issued! This scenario is not supported in GL.\n");
|
||
|
}
|
||
|
|
||
|
// Return with a non-standard error code, so the caller has a chance to do something halfway intelligent.
|
||
|
return D3DERR_NOTAVAILABLE;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
switch( m_type )
|
||
|
{
|
||
|
case D3DQUERYTYPE_OCCLUSION:
|
||
|
{
|
||
|
|
||
|
if ( flush )
|
||
|
{
|
||
|
uint oqValue = 0;
|
||
|
CFastTimer tm;
|
||
|
tm.Start();
|
||
|
|
||
|
|
||
|
// Is this flush actually necessary? According to the extension it's not.
|
||
|
// It doesn't seem to matter if this is a glFlush() or glFinish() with NVidia's driver (tested in MT mode - not sure if it matters), it still can take several calls to IsDone() before we can stop waiting for the query results.
|
||
|
// On AMD, this flush logic fails during shutdown (the query results never become available) - tried a bunch of experiments and checks with no luck.
|
||
|
|
||
|
m_query->Complete(&oqValue);
|
||
|
|
||
|
|
||
|
double flTotalTime = tm.GetDurationInProgress().GetSeconds() * 1000.0f;
|
||
|
if ( flTotalTime > .5f )
|
||
|
{
|
||
|
// Give up - something silly has obviously gone wrong in the driver, lying is better than stalling potentially forever.
|
||
|
// This occurs on AMD (single threaded driver) during shutdown, not sure why yet. It has nothing to do with threading. It may have to do with releasing queries or other objects.
|
||
|
// We must return a result otherwise the app itself could hang, waiting infinitely.
|
||
|
//Assert( 0 );
|
||
|
Warning( "IDirect3DQuery9::GetData(): Occlusion query flush took %3.3fms!\n", flTotalTime );
|
||
|
}
|
||
|
if (pData)
|
||
|
{
|
||
|
*(uint*)pData = oqValue;
|
||
|
}
|
||
|
result = S_OK;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
done = m_query->IsDone();
|
||
|
if (done)
|
||
|
{
|
||
|
uint oqValue = 0; // or we could just pass pData directly to Complete...
|
||
|
m_query->Complete(&oqValue);
|
||
|
if (pData)
|
||
|
{
|
||
|
*(uint*)pData = oqValue;
|
||
|
}
|
||
|
result = S_OK;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
result = S_FALSE;
|
||
|
Assert( !flush );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
break;
|
||
|
|
||
|
case D3DQUERYTYPE_EVENT:
|
||
|
{
|
||
|
done = m_query->IsDone();
|
||
|
if ( ( done ) || ( flush ) )
|
||
|
{
|
||
|
m_query->Complete(NULL); // this will block on pre-SLGU
|
||
|
|
||
|
result = S_OK;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
result = S_FALSE;
|
||
|
Assert( !flush );
|
||
|
}
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- IDirect3DVertexBuffer9
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9** ppVertexBuffer,VD3DHANDLE* pSharedHandle)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GLMPRINTF(( ">-A- IDirect3DDevice9::CreateVertexBuffer" ));
|
||
|
Assert( m_ctx->m_nCurOwnerThreadId == ThreadGetCurrentId() );
|
||
|
|
||
|
m_ObjectStats.m_nTotalVertexBuffers++;
|
||
|
|
||
|
IDirect3DVertexBuffer9 *newbuff = new IDirect3DVertexBuffer9;
|
||
|
|
||
|
newbuff->m_device = this;
|
||
|
|
||
|
newbuff->m_ctx = m_ctx;
|
||
|
|
||
|
// FIXME need to find home or use for the Usage, FVF, Pool values passed in
|
||
|
uint options = 0;
|
||
|
|
||
|
if (Usage&D3DUSAGE_DYNAMIC)
|
||
|
{
|
||
|
options |= GLMBufferOptionDynamic;
|
||
|
}
|
||
|
|
||
|
newbuff->m_vtxBuffer = m_ctx->NewBuffer( kGLMVertexBuffer, Length, options ) ;
|
||
|
|
||
|
newbuff->m_vtxDesc.Type = D3DRTYPE_VERTEXBUFFER;
|
||
|
newbuff->m_vtxDesc.Usage = Usage;
|
||
|
newbuff->m_vtxDesc.Pool = Pool;
|
||
|
newbuff->m_vtxDesc.Size = Length;
|
||
|
|
||
|
*ppVertexBuffer = newbuff;
|
||
|
|
||
|
GLMPRINTF(( "<-A- IDirect3DDevice9::CreateVertexBuffer" ));
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
IDirect3DVertexBuffer9::~IDirect3DVertexBuffer9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
GLMPRINTF(( ">-A- ~IDirect3DVertexBuffer9" ));
|
||
|
|
||
|
if (m_device)
|
||
|
{
|
||
|
m_device->ReleasedVertexBuffer( this );
|
||
|
|
||
|
if (m_ctx && m_vtxBuffer)
|
||
|
{
|
||
|
GLMPRINTF(( ">-A- ~IDirect3DVertexBuffer9 deleting m_vtxBuffer" ));
|
||
|
m_ctx->DelBuffer( m_vtxBuffer );
|
||
|
m_vtxBuffer = NULL;
|
||
|
GLMPRINTF(( "<-A- ~IDirect3DVertexBuffer9 deleting m_vtxBuffer - done" ));
|
||
|
}
|
||
|
m_device = NULL;
|
||
|
}
|
||
|
|
||
|
GLMPRINTF(( "<-A- ~IDirect3DVertexBuffer9" ));
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DVertexBuffer9::Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
tmZoneFiltered( TELEMETRY_LEVEL2, 25, TMZF_NONE, "VB Lock" );
|
||
|
|
||
|
// FIXME would be good to have "can't lock twice" logic
|
||
|
|
||
|
Assert( !(Flags & D3DLOCK_READONLY) ); // not impl'd
|
||
|
// Assert( !(Flags & D3DLOCK_NOSYSLOCK) ); // not impl'd - it triggers though
|
||
|
|
||
|
GLMBuffLockParams lockreq;
|
||
|
lockreq.m_nOffset = OffsetToLock;
|
||
|
lockreq.m_nSize = SizeToLock;
|
||
|
lockreq.m_bNoOverwrite = (Flags & D3DLOCK_NOOVERWRITE) != 0;
|
||
|
lockreq.m_bDiscard = (Flags & D3DLOCK_DISCARD) != 0;
|
||
|
|
||
|
m_vtxBuffer->Lock( &lockreq, (char**)ppbData );
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Lock on D3D buf %p (GL name %d) offset %d, size %d => address %p", this, this->m_vtxBuffer->m_nHandle, OffsetToLock, SizeToLock, *ppbData));
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DVertexBuffer9::Unlock()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
|
||
|
tmZoneFiltered( TELEMETRY_LEVEL2, 25, TMZF_NONE, "VB Unlock" );
|
||
|
|
||
|
m_vtxBuffer->Unlock();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
void IDirect3DVertexBuffer9::UnlockActualSize( uint nActualSize, const void *pActualData )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
tmZoneFiltered( TELEMETRY_LEVEL2, 25, TMZF_NONE, "VB UnlockActualSize" );
|
||
|
|
||
|
m_vtxBuffer->Unlock( nActualSize, pActualData );
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- IDirect3DIndexBuffer9
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9** ppIndexBuffer,VD3DHANDLE* pSharedHandle)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
GLMPRINTF(( ">-A- IDirect3DDevice9::CreateIndexBuffer" ));
|
||
|
|
||
|
// it is important to save all the create info, since GetDesc could get called later to query it
|
||
|
|
||
|
m_ObjectStats.m_nTotalIndexBuffers++;
|
||
|
|
||
|
IDirect3DIndexBuffer9 *newbuff = new IDirect3DIndexBuffer9;
|
||
|
|
||
|
newbuff->m_device = this;
|
||
|
|
||
|
newbuff->m_restype = D3DRTYPE_INDEXBUFFER; // hmmmmmmm why are we not derived from d3dresource..
|
||
|
|
||
|
newbuff->m_ctx = m_ctx;
|
||
|
|
||
|
// FIXME need to find home or use for the Usage, Format, Pool values passed in
|
||
|
uint options = 0;
|
||
|
|
||
|
if (Usage&D3DUSAGE_DYNAMIC)
|
||
|
{
|
||
|
options |= GLMBufferOptionDynamic;
|
||
|
}
|
||
|
|
||
|
newbuff->m_idxBuffer = m_ctx->NewBuffer( kGLMIndexBuffer, Length, options ) ;
|
||
|
|
||
|
newbuff->m_idxDesc.Format = Format;
|
||
|
newbuff->m_idxDesc.Type = D3DRTYPE_INDEXBUFFER;
|
||
|
newbuff->m_idxDesc.Usage = Usage;
|
||
|
newbuff->m_idxDesc.Pool = Pool;
|
||
|
newbuff->m_idxDesc.Size = Length;
|
||
|
|
||
|
*ppIndexBuffer = newbuff;
|
||
|
|
||
|
GLMPRINTF(( "<-A- IDirect3DDevice9::CreateIndexBuffer" ));
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
IDirect3DIndexBuffer9::~IDirect3DIndexBuffer9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
GLMPRINTF(( ">-A- ~IDirect3DIndexBuffer9" ));
|
||
|
|
||
|
if (m_device)
|
||
|
{
|
||
|
m_device->ReleasedIndexBuffer( this );
|
||
|
|
||
|
if (m_ctx && m_idxBuffer)
|
||
|
{
|
||
|
GLMPRINTF(( ">-A- ~IDirect3DIndexBuffer9 deleting m_idxBuffer" ));
|
||
|
m_ctx->DelBuffer( m_idxBuffer );
|
||
|
GLMPRINTF(( "<-A- ~IDirect3DIndexBuffer9 deleting m_idxBuffer - done" ));
|
||
|
}
|
||
|
m_device = NULL;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
}
|
||
|
|
||
|
GLMPRINTF(( "<-A- ~IDirect3DIndexBuffer9" ));
|
||
|
}
|
||
|
|
||
|
|
||
|
HRESULT IDirect3DIndexBuffer9::Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
// FIXME would be good to have "can't lock twice" logic
|
||
|
|
||
|
tmZoneFiltered( TELEMETRY_LEVEL2, 25, TMZF_NONE, "IB Lock" );
|
||
|
|
||
|
GLMBuffLockParams lockreq;
|
||
|
lockreq.m_nOffset = OffsetToLock;
|
||
|
lockreq.m_nSize = SizeToLock;
|
||
|
lockreq.m_bNoOverwrite = ( Flags & D3DLOCK_NOOVERWRITE ) != 0;
|
||
|
lockreq.m_bDiscard = ( Flags & D3DLOCK_DISCARD ) != 0;
|
||
|
|
||
|
m_idxBuffer->Lock( &lockreq, (char**)ppbData );
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DIndexBuffer9::Unlock()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
|
||
|
tmZoneFiltered( TELEMETRY_LEVEL2, 25, TMZF_NONE, "IB Unlock" );
|
||
|
|
||
|
m_idxBuffer->Unlock();
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
void IDirect3DIndexBuffer9::UnlockActualSize( uint nActualSize, const void *pActualData )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
tmZoneFiltered( TELEMETRY_LEVEL2, 25, TMZF_NONE, "IB UnlockActualSize" );
|
||
|
|
||
|
m_idxBuffer->Unlock( nActualSize, pActualData );
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DIndexBuffer9::GetDesc(D3DINDEXBUFFER_DESC *pDesc)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
*pDesc = m_idxDesc;
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- IDirect3DDevice9 -------------------------------------------------
|
||
|
|
||
|
#endif
|
||
|
|
||
|
void ConvertPresentationParamsToGLMDisplayParams( D3DPRESENT_PARAMETERS *d3dp, GLMDisplayParams *gldp )
|
||
|
{
|
||
|
memset( gldp, 0, sizeof(*gldp) );
|
||
|
|
||
|
gldp->m_fsEnable = !d3dp->Windowed;
|
||
|
|
||
|
// see http://msdn.microsoft.com/en-us/library/ee416515(VS.85).aspx
|
||
|
// note that the values below are the only ones mentioned by Source engine; there are many others
|
||
|
switch(d3dp->PresentationInterval)
|
||
|
{
|
||
|
case D3DPRESENT_INTERVAL_ONE:
|
||
|
gldp->m_vsyncEnable = true; // "The driver will wait for the vertical retrace period (the runtime will beam-follow to prevent tearing)."
|
||
|
break;
|
||
|
|
||
|
case D3DPRESENT_INTERVAL_IMMEDIATE:
|
||
|
gldp->m_vsyncEnable = false; // "The runtime updates the window client area immediately and might do so more than once during the adapter refresh period."
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
gldp->m_vsyncEnable = true; // if I don't know it, you're getting vsync enabled.
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
gldp->m_backBufferWidth = d3dp->BackBufferWidth;
|
||
|
gldp->m_backBufferHeight = d3dp->BackBufferHeight;
|
||
|
gldp->m_backBufferFormat = d3dp->BackBufferFormat;
|
||
|
gldp->m_multiSampleCount = d3dp->MultiSampleType; // it's a count really
|
||
|
|
||
|
gldp->m_enableAutoDepthStencil = d3dp->EnableAutoDepthStencil != 0;
|
||
|
gldp->m_autoDepthStencilFormat = d3dp->AutoDepthStencilFormat;
|
||
|
|
||
|
gldp->m_fsRefreshHz = d3dp->FullScreen_RefreshRateInHz;
|
||
|
|
||
|
// some fields in d3d PB we're not acting on yet...
|
||
|
// UINT BackBufferCount;
|
||
|
// DWORD MultiSampleQuality;
|
||
|
// D3DSWAPEFFECT SwapEffect;
|
||
|
// VD3DHWND hDeviceWindow;
|
||
|
// DWORD Flags;
|
||
|
}
|
||
|
|
||
|
void UnpackD3DRSITable( void );
|
||
|
|
||
|
HRESULT IDirect3DDevice9::Create( IDirect3DDevice9Params *params )
|
||
|
{
|
||
|
g_pD3D_Device = this;
|
||
|
|
||
|
GLMDebugPrintf( "IDirect3DDevice9::Create: BackBufWidth: %u, BackBufHeight: %u, D3DFMT: %u, BackBufCount: %u, MultisampleType: %u, MultisampleQuality: %u\n",
|
||
|
params->m_presentationParameters.BackBufferWidth,
|
||
|
params->m_presentationParameters.BackBufferHeight,
|
||
|
params->m_presentationParameters.BackBufferFormat,
|
||
|
params->m_presentationParameters.BackBufferCount,
|
||
|
params->m_presentationParameters.MultiSampleType,
|
||
|
params->m_presentationParameters.MultiSampleQuality );
|
||
|
|
||
|
UnpackD3DRSITable();
|
||
|
|
||
|
m_ObjectStats.clear();
|
||
|
m_PrevObjectStats.clear();
|
||
|
|
||
|
#if GL_BATCH_PERF_ANALYSIS && GL_BATCH_PERF_ANALYSIS_WRITE_PNGS
|
||
|
m_pBatch_vis_bitmap = NULL;
|
||
|
#endif
|
||
|
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GLMPRINTF((">-X-IDirect3DDevice9::Create"));
|
||
|
HRESULT result = S_OK;
|
||
|
|
||
|
// create an IDirect3DDevice9
|
||
|
// make a GLMContext and set up some drawables
|
||
|
m_params = *params;
|
||
|
|
||
|
m_ctx = NULL;
|
||
|
|
||
|
V_memset( m_pRenderTargets, 0, sizeof( m_pRenderTargets ) );
|
||
|
m_pDepthStencil = NULL;
|
||
|
|
||
|
m_pDefaultColorSurface = NULL;
|
||
|
m_pDefaultDepthStencilSurface = NULL;
|
||
|
|
||
|
memset( m_streams, 0, sizeof(m_streams) );
|
||
|
memset( m_vtx_buffers, 0, sizeof( m_vtx_buffers ) );
|
||
|
memset( m_textures, 0, sizeof(m_textures) );
|
||
|
//memset( m_samplers, 0, sizeof(m_samplers) );
|
||
|
|
||
|
m_indices.m_idxBuffer = NULL;
|
||
|
|
||
|
m_vertexShader = NULL;
|
||
|
m_pixelShader = NULL;
|
||
|
|
||
|
m_pVertDecl = NULL;
|
||
|
|
||
|
//============================================================================
|
||
|
// param block for GLM context create
|
||
|
GLMDisplayParams glmParams;
|
||
|
ConvertPresentationParamsToGLMDisplayParams( ¶ms->m_presentationParameters, &glmParams );
|
||
|
|
||
|
glmParams.m_mtgl = true; // forget this idea -> (params->m_behaviorFlags & D3DCREATE_MULTITHREADED) != 0;
|
||
|
// the call above fills in a bunch of things, but doesn't know about anything outside of the presentation params.
|
||
|
// those tend to be the things that do not change after create, so we do those here in Create.
|
||
|
|
||
|
glmParams.m_focusWindow = params->m_focusWindow;
|
||
|
|
||
|
#if 0 //FIXME-HACK
|
||
|
// map the D3D "adapter" to a renderer/display pair
|
||
|
// (that GPU will have to stay set as-is for any subsequent mode changes)
|
||
|
|
||
|
int glmRendererIndex = -1;
|
||
|
int glmDisplayIndex = -1;
|
||
|
|
||
|
GLMRendererInfoFields glmRendererInfo;
|
||
|
GLMDisplayInfoFields glmDisplayInfo;
|
||
|
|
||
|
// the D3D "Adapter" number feeds the fake adapter index
|
||
|
bool adaptResult = GLMgr::aGLMgr()->GetDisplayDB()->GetFakeAdapterInfo( params->m_adapter, &glmRendererIndex, &glmDisplayIndex, &glmRendererInfo, &glmDisplayInfo );
|
||
|
Assert(!adaptResult);
|
||
|
|
||
|
glmParams.m_rendererIndex = glmRendererIndex;
|
||
|
glmParams.m_displayIndex = glmDisplayIndex;
|
||
|
// glmParams.m_modeIndex hmmmmm, client doesn't give us a mode number, just a resolution..
|
||
|
#endif
|
||
|
|
||
|
m_ctx = GLMgr::aGLMgr()->NewContext( this, &glmParams );
|
||
|
if (!m_ctx)
|
||
|
{
|
||
|
GLMPRINTF(("<-X- IDirect3DDevice9::Create (error out)"));
|
||
|
return (HRESULT) -1;
|
||
|
}
|
||
|
|
||
|
// make an FBO to draw into and activate it.
|
||
|
m_ctx->m_drawingFBO = m_ctx->NewFBO();
|
||
|
|
||
|
// bind it to context. will receive attachments shortly.
|
||
|
m_ctx->BindFBOToCtx( m_ctx->m_drawingFBO, GL_FRAMEBUFFER_EXT );
|
||
|
|
||
|
m_bFBODirty = false;
|
||
|
|
||
|
m_pFBOs = new CGLMFBOMap();
|
||
|
m_pFBOs->SetLessFunc( RenderTargetState_t::LessFunc );
|
||
|
|
||
|
// we create two IDirect3DSurface9's. These will be known as the internal render target 0 and the depthstencil.
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Create making color render target..."));
|
||
|
// color surface
|
||
|
result = this->CreateRenderTarget(
|
||
|
m_params.m_presentationParameters.BackBufferWidth, // width
|
||
|
m_params.m_presentationParameters.BackBufferHeight, // height
|
||
|
m_params.m_presentationParameters.BackBufferFormat, // format
|
||
|
m_params.m_presentationParameters.MultiSampleType, // MSAA depth
|
||
|
m_params.m_presentationParameters.MultiSampleQuality, // MSAA quality
|
||
|
true, // lockable
|
||
|
&m_pDefaultColorSurface, // ppSurface
|
||
|
NULL, // shared handle
|
||
|
"InternalRT0"
|
||
|
);
|
||
|
|
||
|
if (result != S_OK)
|
||
|
{
|
||
|
GLMPRINTF(("<-X- IDirect3DDevice9::Create (error out)"));
|
||
|
return result;
|
||
|
}
|
||
|
// do not do an AddRef..
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Create making color render target complete -> %08x", m_pDefaultColorSurface ));
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Create setting color render target..."));
|
||
|
result = this->SetRenderTarget(0, m_pDefaultColorSurface);
|
||
|
if (result != S_OK)
|
||
|
{
|
||
|
GLMPRINTF(("< IDirect3DDevice9::Create (error out)"));
|
||
|
return result;
|
||
|
}
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Create setting color render target complete."));
|
||
|
|
||
|
Assert (m_params.m_presentationParameters.EnableAutoDepthStencil);
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Create making depth-stencil..."));
|
||
|
result = CreateDepthStencilSurface(
|
||
|
m_params.m_presentationParameters.BackBufferWidth, // width
|
||
|
m_params.m_presentationParameters.BackBufferHeight, // height
|
||
|
m_params.m_presentationParameters.AutoDepthStencilFormat, // format
|
||
|
m_params.m_presentationParameters.MultiSampleType, // MSAA depth
|
||
|
m_params.m_presentationParameters.MultiSampleQuality, // MSAA quality
|
||
|
TRUE, // enable z-buffer discard ????
|
||
|
&m_pDefaultDepthStencilSurface, // ppSurface
|
||
|
NULL // shared handle
|
||
|
);
|
||
|
if (result != S_OK)
|
||
|
{
|
||
|
GLMPRINTF(("<-X- IDirect3DDevice9::Create (error out)"));
|
||
|
return result;
|
||
|
}
|
||
|
// do not do an AddRef here..
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Create making depth-stencil complete -> %08x", m_pDefaultDepthStencilSurface));
|
||
|
GLMPRINTF(("-X- Direct3DDevice9::Create setting depth-stencil render target..."));
|
||
|
result = this->SetDepthStencilSurface(m_pDefaultDepthStencilSurface);
|
||
|
if (result != S_OK)
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
GLMPRINTF(("<-X- IDirect3DDevice9::Create (error out)"));
|
||
|
return result;
|
||
|
}
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Create setting depth-stencil render target complete."));
|
||
|
|
||
|
UpdateBoundFBO();
|
||
|
|
||
|
bool ready = m_ctx->m_drawingFBO->IsReady();
|
||
|
if (!ready)
|
||
|
{
|
||
|
GLMPRINTF(("<-X- IDirect3DDevice9::Create (error out)"));
|
||
|
return (HRESULT)-1;
|
||
|
}
|
||
|
|
||
|
// this next part really needs to be inside GLMContext.. or replaced with D3D style viewport setup calls.
|
||
|
m_ctx->GenDebugFontTex();
|
||
|
|
||
|
// blast the gl state mirror...
|
||
|
memset( &this->gl, 0, sizeof( this->gl ) );
|
||
|
|
||
|
InitStates();
|
||
|
|
||
|
GLScissorEnable_t defScissorEnable = { true };
|
||
|
GLScissorBox_t defScissorBox = { 0,0, (GLsizei)m_params.m_presentationParameters.BackBufferWidth, (GLsizei)m_params.m_presentationParameters.BackBufferHeight };
|
||
|
GLViewportBox_t defViewportBox = { 0,0, (GLsizei)m_params.m_presentationParameters.BackBufferWidth, (GLsizei)m_params.m_presentationParameters.BackBufferHeight, m_params.m_presentationParameters.BackBufferWidth | ( m_params.m_presentationParameters.BackBufferHeight << 16 ) };
|
||
|
GLViewportDepthRange_t defViewportDepthRange = { 0.1, 1000.0 };
|
||
|
GLCullFaceEnable_t defCullFaceEnable = { true };
|
||
|
GLCullFrontFace_t defCullFrontFace = { GL_CCW };
|
||
|
|
||
|
gl.m_ScissorEnable = defScissorEnable;
|
||
|
gl.m_ScissorBox = defScissorBox;
|
||
|
gl.m_ViewportBox = defViewportBox;
|
||
|
gl.m_ViewportDepthRange = defViewportDepthRange;
|
||
|
gl.m_CullFaceEnable = defCullFaceEnable;
|
||
|
gl.m_CullFrontFace = defCullFrontFace;
|
||
|
|
||
|
FullFlushStates();
|
||
|
|
||
|
GLMPRINTF(("<-X- IDirect3DDevice9::Create complete"));
|
||
|
|
||
|
// so GetClientRect can return sane answers
|
||
|
//uint width, height;
|
||
|
RenderedSize( m_params.m_presentationParameters.BackBufferWidth, m_params.m_presentationParameters.BackBufferHeight, true ); // true = set
|
||
|
|
||
|
#if GL_TELEMETRY_GPU_ZONES
|
||
|
g_TelemetryGPUStats.Clear();
|
||
|
#endif
|
||
|
|
||
|
GL_BATCH_PERF(
|
||
|
g_nTotalD3DCalls = 0, g_nTotalD3DCycles = 0, m_nBatchVisY = 0, m_nBatchVisFrameIndex = 0, m_nBatchVisFileIdx = 0, m_nNumProgramChanges = 0, m_flTotalD3DTime = 0, m_nTotalD3DCalls = 0,
|
||
|
m_flTotalD3DTime = 0, m_nTotalGLCalls = 0, m_flTotalGLTime = 0, m_nOverallDraws = 0, m_nOverallPrims = 0, m_nOverallD3DCalls = 0, m_flOverallD3DTime = 0, m_nOverallGLCalls = 0, m_flOverallGLTime = 0, m_nOverallProgramChanges = 0,
|
||
|
m_flOverallPresentTime = 0, m_flOverallPresentTimeSquared = 0, m_nOverallPresents = 0, m_flOverallSwapWindowTime = 0, m_flOverallSwapWindowTimeSquared = 0, m_nTotalPrims = 0; );
|
||
|
|
||
|
g_nTotalDrawsOrClears = 0;
|
||
|
|
||
|
gGL->m_nTotalGLCycles = 0;
|
||
|
gGL->m_nTotalGLCalls = 0;
|
||
|
|
||
|
m_pDummy_vtx_buffer = new CGLMBuffer( m_ctx, kGLMVertexBuffer, 4096, 0 );
|
||
|
m_vtx_buffers[0] = m_pDummy_vtx_buffer;
|
||
|
m_vtx_buffers[1] = m_pDummy_vtx_buffer;
|
||
|
m_vtx_buffers[2] = m_pDummy_vtx_buffer;
|
||
|
m_vtx_buffers[3] = m_pDummy_vtx_buffer;
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
IDirect3DDevice9::IDirect3DDevice9() :
|
||
|
m_nValidMarker( D3D_DEVICE_VALID_MARKER )
|
||
|
{
|
||
|
}
|
||
|
IDirect3DDevice9::~IDirect3DDevice9()
|
||
|
{
|
||
|
Assert( m_nValidMarker == D3D_DEVICE_VALID_MARKER );
|
||
|
#if GL_BATCH_PERF_ANALYSIS && GL_BATCH_PERF_ANALYSIS_WRITE_PNGS
|
||
|
delete m_pBatch_vis_bitmap;
|
||
|
#endif
|
||
|
|
||
|
delete m_pDummy_vtx_buffer;
|
||
|
for ( int i = 0; i < 4; i++ )
|
||
|
SetRenderTarget( i, NULL );
|
||
|
SetDepthStencilSurface( NULL );
|
||
|
if ( m_pDefaultColorSurface )
|
||
|
{
|
||
|
m_pDefaultColorSurface->Release( 0, "IDirect3DDevice9::~IDirect3DDevice9 release color surface" );
|
||
|
m_pDefaultColorSurface = NULL;
|
||
|
}
|
||
|
if ( m_pDefaultDepthStencilSurface )
|
||
|
{
|
||
|
m_pDefaultDepthStencilSurface->Release( 0, "IDirect3DDevice9::~IDirect3DDevice9 release depth surface" );
|
||
|
m_pDefaultDepthStencilSurface = NULL;
|
||
|
}
|
||
|
|
||
|
if ( m_pFBOs )
|
||
|
{
|
||
|
ResetFBOMap();
|
||
|
}
|
||
|
|
||
|
GLMPRINTF(( "-D- IDirect3DDevice9::~IDirect3DDevice9 signpost" )); // want to know when this is called, if ever
|
||
|
|
||
|
g_pD3D_Device = NULL;
|
||
|
if ( m_ObjectStats.m_nTotalFBOs ) GLMDebugPrintf( "Leaking %i FBOs\n", m_ObjectStats.m_nTotalFBOs );
|
||
|
if ( m_ObjectStats.m_nTotalVertexShaders ) ConMsg( "Leaking %i vertex shaders\n", m_ObjectStats.m_nTotalVertexShaders );
|
||
|
if ( m_ObjectStats.m_nTotalPixelShaders ) ConMsg( "Leaking %i pixel shaders\n", m_ObjectStats.m_nTotalPixelShaders );
|
||
|
if ( m_ObjectStats.m_nTotalVertexDecls ) ConMsg( "Leaking %i vertex decls\n", m_ObjectStats.m_nTotalVertexDecls );
|
||
|
if ( m_ObjectStats.m_nTotalIndexBuffers ) ConMsg( "Leaking %i index buffers\n", m_ObjectStats.m_nTotalIndexBuffers );
|
||
|
if ( m_ObjectStats.m_nTotalVertexBuffers ) ConMsg( "Leaking %i vertex buffers\n", m_ObjectStats.m_nTotalVertexBuffers );
|
||
|
if ( m_ObjectStats.m_nTotalTextures ) ConMsg( "Leaking %i textures\n", m_ObjectStats.m_nTotalTextures );
|
||
|
if ( m_ObjectStats.m_nTotalSurfaces ) ConMsg( "Leaking %i surfaces\n", m_ObjectStats.m_nTotalSurfaces );
|
||
|
if ( m_ObjectStats.m_nTotalQueries ) ConMsg( "Leaking %i queries\n", m_ObjectStats.m_nTotalQueries );
|
||
|
if ( m_ObjectStats.m_nTotalRenderTargets ) ConMsg( "Leaking %i render targets\n", m_ObjectStats.m_nTotalRenderTargets );
|
||
|
GLMgr::aGLMgr()->DelContext( m_ctx );
|
||
|
m_ctx = NULL;
|
||
|
m_nValidMarker = 0xDEADBEEF;
|
||
|
}
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Basics - (IDirect3DDevice9)
|
||
|
|
||
|
#endif
|
||
|
|
||
|
|
||
|
HRESULT IDirect3DDevice9::Reset(D3DPRESENT_PARAMETERS* pPresentationParameters)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
Assert( m_nValidMarker == D3D_DEVICE_VALID_MARKER );
|
||
|
HRESULT result = S_OK;
|
||
|
|
||
|
// define the task of reset as:
|
||
|
// provide new drawable RT's for the backbuffer (color and depthstencil).
|
||
|
// fix up viewport / scissor..
|
||
|
// then pass the new presentation parameters through to GLM.
|
||
|
// (it will in turn notify appframework on the next present... which may be very soon, as mode changes are usually spotted inside Present() ).
|
||
|
|
||
|
// so some of this looks a lot like Create - we're just a subset of what it does.
|
||
|
// with a little work you could refactor this to be common code.
|
||
|
|
||
|
GLMDebugPrintf( "IDirect3DDevice9::Reset: BackBufWidth: %u, BackBufHeight: %u, D3DFMT: %u, BackBufCount: %u, MultisampleType: %u, MultisampleQuality: %u\n",
|
||
|
pPresentationParameters->BackBufferWidth,
|
||
|
pPresentationParameters->BackBufferHeight,
|
||
|
pPresentationParameters->BackBufferFormat,
|
||
|
pPresentationParameters->BackBufferCount,
|
||
|
pPresentationParameters->MultiSampleType,
|
||
|
pPresentationParameters->MultiSampleQuality );
|
||
|
|
||
|
//------------------------------------------------------------------------------- absorb new presentation params..
|
||
|
|
||
|
m_params.m_presentationParameters = *pPresentationParameters;
|
||
|
|
||
|
//------------------------------------------------------------------------------- color buffer..
|
||
|
// release old color surface if it's there..
|
||
|
if ( m_pDefaultColorSurface )
|
||
|
{
|
||
|
ULONG refc = m_pDefaultColorSurface->Release( 0, "IDirect3DDevice9::Reset public release color surface" ); (void)refc;
|
||
|
Assert( !refc );
|
||
|
m_pDefaultColorSurface = NULL;
|
||
|
}
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Reset making new color render target..."));
|
||
|
|
||
|
// color surface
|
||
|
result = this->CreateRenderTarget(
|
||
|
m_params.m_presentationParameters.BackBufferWidth, // width
|
||
|
m_params.m_presentationParameters.BackBufferHeight, // height
|
||
|
m_params.m_presentationParameters.BackBufferFormat, // format
|
||
|
m_params.m_presentationParameters.MultiSampleType, // MSAA depth
|
||
|
m_params.m_presentationParameters.MultiSampleQuality, // MSAA quality
|
||
|
true, // lockable
|
||
|
&m_pDefaultColorSurface, // ppSurface
|
||
|
NULL // shared handle
|
||
|
);
|
||
|
|
||
|
if ( result != S_OK )
|
||
|
{
|
||
|
GLMPRINTF(("<-X- IDirect3DDevice9::Reset (error out)"));
|
||
|
return result;
|
||
|
}
|
||
|
// do not do an AddRef here..
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Reset making color render target complete -> %08x", m_pDefaultColorSurface ));
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Reset setting color render target..."));
|
||
|
|
||
|
result = this->SetDepthStencilSurface( NULL );
|
||
|
|
||
|
result = this->SetRenderTarget( 0, m_pDefaultColorSurface );
|
||
|
if (result != S_OK)
|
||
|
{
|
||
|
GLMPRINTF(("< IDirect3DDevice9::Reset (error out)"));
|
||
|
return result;
|
||
|
}
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Reset setting color render target complete."));
|
||
|
|
||
|
|
||
|
//-------------------------------------------------------------------------------depth stencil buffer
|
||
|
// release old depthstencil surface if it's there..
|
||
|
if ( m_pDefaultDepthStencilSurface )
|
||
|
{
|
||
|
ULONG refc = m_pDefaultDepthStencilSurface->Release( 0, "IDirect3DDevice9::Reset public release depthstencil surface" ); (void)refc;
|
||
|
Assert(!refc);
|
||
|
m_pDefaultDepthStencilSurface = NULL;
|
||
|
}
|
||
|
|
||
|
Assert (m_params.m_presentationParameters.EnableAutoDepthStencil);
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Reset making depth-stencil..."));
|
||
|
result = CreateDepthStencilSurface(
|
||
|
m_params.m_presentationParameters.BackBufferWidth, // width
|
||
|
m_params.m_presentationParameters.BackBufferHeight, // height
|
||
|
m_params.m_presentationParameters.AutoDepthStencilFormat, // format
|
||
|
m_params.m_presentationParameters.MultiSampleType, // MSAA depth
|
||
|
m_params.m_presentationParameters.MultiSampleQuality, // MSAA quality
|
||
|
TRUE, // enable z-buffer discard ????
|
||
|
&m_pDefaultDepthStencilSurface, // ppSurface
|
||
|
NULL // shared handle
|
||
|
);
|
||
|
if (result != S_OK)
|
||
|
{
|
||
|
GLMPRINTF(("<-X- IDirect3DDevice9::Reset (error out)"));
|
||
|
return result;
|
||
|
}
|
||
|
// do not do an AddRef here..
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Reset making depth-stencil complete -> %08x", m_pDefaultDepthStencilSurface));
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Reset setting depth-stencil render target..."));
|
||
|
result = this->SetDepthStencilSurface(m_pDefaultDepthStencilSurface);
|
||
|
if (result != S_OK)
|
||
|
{
|
||
|
GLMPRINTF(("<-X- IDirect3DDevice9::Reset (error out)"));
|
||
|
return result;
|
||
|
}
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::Reset setting depth-stencil render target complete."));
|
||
|
|
||
|
UpdateBoundFBO();
|
||
|
|
||
|
bool ready = m_ctx->m_drawingFBO->IsReady();
|
||
|
if (!ready)
|
||
|
{
|
||
|
GLMPRINTF(("<-X- IDirect3DDevice9::Reset (error out)"));
|
||
|
return D3DERR_DEVICELOST;
|
||
|
}
|
||
|
|
||
|
//-------------------------------------------------------------------------------zap viewport and scissor to new backbuffer size
|
||
|
|
||
|
InitStates();
|
||
|
|
||
|
GLScissorEnable_t defScissorEnable = { true };
|
||
|
GLScissorBox_t defScissorBox = { 0,0, (GLsizei)m_params.m_presentationParameters.BackBufferWidth, (GLsizei)m_params.m_presentationParameters.BackBufferHeight };
|
||
|
GLViewportBox_t defViewportBox = { 0,0, (GLsizei)m_params.m_presentationParameters.BackBufferWidth, (GLsizei)m_params.m_presentationParameters.BackBufferHeight, m_params.m_presentationParameters.BackBufferWidth | ( m_params.m_presentationParameters.BackBufferHeight << 16 ) };
|
||
|
GLViewportDepthRange_t defViewportDepthRange = { 0.1, 1000.0 };
|
||
|
GLCullFaceEnable_t defCullFaceEnable = { true };
|
||
|
GLCullFrontFace_t defCullFrontFace = { GL_CCW };
|
||
|
|
||
|
gl.m_ScissorEnable = defScissorEnable;
|
||
|
gl.m_ScissorBox = defScissorBox;
|
||
|
gl.m_ViewportBox = defViewportBox;
|
||
|
gl.m_ViewportDepthRange = defViewportDepthRange;
|
||
|
gl.m_CullFaceEnable = defCullFaceEnable;
|
||
|
gl.m_CullFrontFace = defCullFrontFace;
|
||
|
|
||
|
FullFlushStates();
|
||
|
|
||
|
//-------------------------------------------------------------------------------finally, propagate new display params to GLM context
|
||
|
GLMDisplayParams glmParams;
|
||
|
ConvertPresentationParamsToGLMDisplayParams( pPresentationParameters, &glmParams );
|
||
|
|
||
|
// steal back previously sent focus window...
|
||
|
glmParams.m_focusWindow = m_ctx->m_displayParams.m_focusWindow;
|
||
|
Assert( glmParams.m_focusWindow != NULL );
|
||
|
|
||
|
// so GetClientRect can return sane answers
|
||
|
//uint width, height;
|
||
|
RenderedSize( pPresentationParameters->BackBufferWidth, pPresentationParameters->BackBufferHeight, true ); // true = set
|
||
|
|
||
|
m_ctx->Reset();
|
||
|
|
||
|
m_ctx->SetDisplayParams( &glmParams );
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetViewport(CONST D3DVIEWPORT9* pViewport)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::SetViewport : minZ %f, maxZ %f",pViewport->MinZ, pViewport->MaxZ ));
|
||
|
|
||
|
gl.m_ViewportBox.x = pViewport->X;
|
||
|
gl.m_ViewportBox.width = pViewport->Width;
|
||
|
|
||
|
gl.m_ViewportBox.y = pViewport->Y;
|
||
|
gl.m_ViewportBox.height = pViewport->Height;
|
||
|
|
||
|
gl.m_ViewportBox.widthheight = pViewport->Width | ( pViewport->Height << 16 );
|
||
|
|
||
|
m_ctx->WriteViewportBox( &gl.m_ViewportBox );
|
||
|
|
||
|
gl.m_ViewportDepthRange.flNear = pViewport->MinZ;
|
||
|
gl.m_ViewportDepthRange.flFar = pViewport->MaxZ;
|
||
|
m_ctx->WriteViewportDepthRange( &gl.m_ViewportDepthRange );
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::GetViewport( D3DVIEWPORT9* pViewport )
|
||
|
{
|
||
|
// 7LS - unfinished, used in scaleformuirenderimpl.cpp (only width and height required)
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::GetViewport " ));
|
||
|
|
||
|
pViewport->X = gl.m_ViewportBox.x;
|
||
|
pViewport->Width = gl.m_ViewportBox.width;
|
||
|
|
||
|
pViewport->Y = gl.m_ViewportBox.y;
|
||
|
pViewport->Height = gl.m_ViewportBox.height;
|
||
|
|
||
|
pViewport->MinZ = gl.m_ViewportDepthRange.flNear;
|
||
|
pViewport->MaxZ = gl.m_ViewportDepthRange.flFar;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::BeginScene()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
m_ctx->BeginFrame();
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::EndScene()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
m_ctx->EndFrame();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
// stolen from glmgrbasics.cpp
|
||
|
|
||
|
enum ECarbonModKeyIndex
|
||
|
{
|
||
|
EcmdKeyBit = 8, /* command key down?*/
|
||
|
EshiftKeyBit = 9, /* shift key down?*/
|
||
|
EalphaLockBit = 10, /* alpha lock down?*/
|
||
|
EoptionKeyBit = 11, /* option key down?*/
|
||
|
EcontrolKeyBit = 12 /* control key down?*/
|
||
|
};
|
||
|
|
||
|
enum ECarbonModKeyMask
|
||
|
{
|
||
|
EcmdKey = 1 << EcmdKeyBit,
|
||
|
EshiftKey = 1 << EshiftKeyBit,
|
||
|
EalphaLock = 1 << EalphaLockBit,
|
||
|
EoptionKey = 1 << EoptionKeyBit,
|
||
|
EcontrolKey = 1 << EcontrolKeyBit
|
||
|
};
|
||
|
|
||
|
void IDirect3DDevice9::PrintObjectStats( const ObjectStats_t &stats )
|
||
|
{
|
||
|
ConMsg( "Total FBOs: %i\n", stats.m_nTotalFBOs );
|
||
|
ConMsg( "Total vertex shaders: %i\n", stats.m_nTotalVertexShaders );
|
||
|
ConMsg( "Total pixel shaders: %i\n", stats.m_nTotalPixelShaders );
|
||
|
ConMsg( "Total vertex decls: %i\n", stats.m_nTotalVertexDecls );
|
||
|
ConMsg( "Total index buffers: %i\n", stats.m_nTotalIndexBuffers );
|
||
|
ConMsg( "Total vertex buffers: %i\n", stats.m_nTotalVertexBuffers );
|
||
|
ConMsg( "Total textures: %i\n", stats.m_nTotalTextures );
|
||
|
ConMsg( "Total surfaces: %i\n", stats.m_nTotalSurfaces );
|
||
|
ConMsg( "Total queries: %i\n", stats.m_nTotalQueries );
|
||
|
ConMsg( "Total render targets: %i\n", stats.m_nTotalRenderTargets );
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::DumpStatsToConsole( const CCommand *pArgs )
|
||
|
{
|
||
|
#if GL_BATCH_PERF_ANALYSIS
|
||
|
ConMsg( "Overall: Batches: %u, Prims: %u, Program Changes: %u\n", m_nOverallDraws, m_nOverallPrims, m_nOverallProgramChanges );
|
||
|
ConMsg( "Overall: D3D Calls: %u D3D Time: %4.3fms, Avg D3D Time Per Call: %4.9fms\n", m_nOverallD3DCalls, m_flOverallD3DTime, m_nOverallD3DCalls ? ( m_flOverallD3DTime / m_nOverallD3DCalls ) : 0.0f );
|
||
|
ConMsg( "Overall: GL Calls: %u GL Time: %4.3fms, Avg GL Time Per Call: %4.9fms\n", m_nOverallGLCalls, m_flOverallGLTime, m_nOverallGLCalls ? ( m_flOverallGLTime / m_nOverallGLCalls ) : 0.0f );
|
||
|
|
||
|
ConMsg( "D3DPresent: %u, Overall Time: %4.3fms, Avg: %4.6fms, Std Dev: %4.6fms\n",
|
||
|
m_nOverallPresents,
|
||
|
m_flOverallPresentTime, m_nOverallPresents ? ( m_flOverallPresentTime / m_nOverallPresents ) : 0.0f,
|
||
|
m_nOverallPresents ? ( sqrt( ( m_flOverallPresentTimeSquared / m_nOverallPresents ) - ( m_flOverallPresentTime / m_nOverallPresents ) * ( m_flOverallPresentTime / m_nOverallPresents ) ) ) : 0.0f );
|
||
|
|
||
|
ConMsg( "GL SwapWindow(): Overall Time: %4.3fms, Avg: %4.6fms, Std Dev: %4.6fms\n",
|
||
|
m_flOverallSwapWindowTime, m_nOverallPresents ? ( m_flOverallSwapWindowTime / m_nOverallPresents ) : 0.0f,
|
||
|
m_nOverallPresents ? ( sqrt( ( m_flOverallSwapWindowTimeSquared / m_nOverallPresents ) - ( m_flOverallSwapWindowTime / m_nOverallPresents ) * ( m_flOverallSwapWindowTime / m_nOverallPresents ) ) ) : 0.0f );
|
||
|
|
||
|
if ( ( pArgs ) && ( pArgs->ArgC() == 2 ) && (pArgs->Arg(1)[0] != '0') )
|
||
|
{
|
||
|
m_nOverallDraws = 0;
|
||
|
m_nOverallPrims = 0;
|
||
|
m_nOverallProgramChanges = 0;
|
||
|
m_nOverallD3DCalls = 0;
|
||
|
m_flOverallD3DTime = 0;
|
||
|
m_nOverallGLCalls = 0;
|
||
|
m_flOverallGLTime = 0;
|
||
|
m_flOverallPresentTime = 0;
|
||
|
m_flOverallPresentTimeSquared = 0;
|
||
|
m_flOverallSwapWindowTime = 0;
|
||
|
m_flOverallSwapWindowTimeSquared = 0;
|
||
|
m_nOverallPresents = 0;
|
||
|
}
|
||
|
#endif
|
||
|
ConMsg( "Totals:\n" );
|
||
|
m_ObjectStats.m_nTotalFBOs = m_pFBOs->Count();
|
||
|
PrintObjectStats( m_ObjectStats );
|
||
|
ObjectStats_t delta( m_ObjectStats );
|
||
|
delta -= m_PrevObjectStats;
|
||
|
ConMsg( "Delta:\n" );
|
||
|
PrintObjectStats( delta );
|
||
|
m_PrevObjectStats = m_ObjectStats;
|
||
|
}
|
||
|
|
||
|
static void gl_dump_stats_func( const CCommand &args )
|
||
|
{
|
||
|
if ( g_pD3D_Device )
|
||
|
{
|
||
|
g_pD3D_Device->DumpStatsToConsole( &args );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static ConCommand gl_dump_stats( "gl_dump_stats", gl_dump_stats_func );
|
||
|
#if GLMDEBUG
|
||
|
void IDirect3DDevice9::DumpTextures( const CCommand *pArgs )
|
||
|
{
|
||
|
Assert( m_nValidMarker == D3D_DEVICE_VALID_MARKER );
|
||
|
(void)pArgs;
|
||
|
CGLMTex *pCurTex = g_pFirstCGMLTex;
|
||
|
if ( pCurTex )
|
||
|
{
|
||
|
Assert( pCurTex->m_pPrevTex == NULL );
|
||
|
}
|
||
|
ConMsg( "--- Internal CGLMTex's:\n" );
|
||
|
uint nNumFound = 0;
|
||
|
while ( pCurTex )
|
||
|
{
|
||
|
nNumFound++;
|
||
|
ConMsg( "Tex \"%s\", Layout: \"%s\", Size: %u, RT: %u, Depth: %u, Stencil: %u, MSAA: %u\n",
|
||
|
pCurTex->m_debugLabel ? pCurTex->m_debugLabel : "?",
|
||
|
pCurTex->m_layout->m_layoutSummary,
|
||
|
pCurTex->m_layout->m_storageTotalSize,
|
||
|
( pCurTex->m_layout->m_key.m_texFlags & kGLMTexRenderable ) ? 1 : 0,
|
||
|
( pCurTex->m_layout->m_key.m_texFlags & kGLMTexIsDepth ) ? 1 : 0,
|
||
|
( pCurTex->m_layout->m_key.m_texFlags & kGLMTexIsStencil ) ? 1 : 0,
|
||
|
( pCurTex->m_layout->m_key.m_texFlags & kGLMTexMultisampled ) ? 1 : 0 );
|
||
|
CGLMTex *pNextTex = pCurTex->m_pNextTex;
|
||
|
if ( pNextTex )
|
||
|
{
|
||
|
Assert( pNextTex->m_pPrevTex == pCurTex );
|
||
|
}
|
||
|
pCurTex = pNextTex;
|
||
|
}
|
||
|
ConMsg( "--- Found %u total CGLMTex's\n", nNumFound );
|
||
|
}
|
||
|
static void gl_dump_textures_func( const CCommand &args )
|
||
|
{
|
||
|
if ( g_pD3D_Device )
|
||
|
{
|
||
|
g_pD3D_Device->DumpTextures( &args );
|
||
|
}
|
||
|
}
|
||
|
static ConCommand gl_dump_textures( "gl_dump_textures", gl_dump_textures_func );
|
||
|
|
||
|
#endif
|
||
|
|
||
|
ConVar gl_blitmode( "gl_blitmode", "1" );
|
||
|
ConVar dxa_nullrefresh_capslock( "dxa_nullrefresh_capslock", "0" );
|
||
|
|
||
|
HRESULT IDirect3DDevice9::Present(CONST RECT* pSourceRect,CONST RECT* pDestRect,VD3DHWND hDestWindowOverride,CONST RGNDATA* pDirtyRegion)
|
||
|
{
|
||
|
GL_BATCH_PERF( g_nTotalD3DCalls++; )
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
|
||
|
TOGL_NULL_DEVICE_CHECK;
|
||
|
|
||
|
if ( m_bFBODirty )
|
||
|
{
|
||
|
UpdateBoundFBO();
|
||
|
}
|
||
|
|
||
|
// before attempting to present a tex, make sure it's been resolved if it was MSAA.
|
||
|
// if we push that responsibility down to m_ctx->Present, it could probably do it without an extra copy.
|
||
|
// i.e. anticipate the blit from the resolvedtex to GL_BACK, and just do that instead.
|
||
|
|
||
|
// no explicit ResolveTex call first - that got pushed down into GLMContext::Present
|
||
|
|
||
|
#if GL_BATCH_PERF_ANALYSIS
|
||
|
uint64 nStartGLCycles = gGL->m_nTotalGLCycles;
|
||
|
nStartGLCycles;
|
||
|
|
||
|
CFastTimer tm;
|
||
|
tm.Start();
|
||
|
#endif
|
||
|
|
||
|
m_ctx->Present( m_pDefaultColorSurface->m_tex );
|
||
|
|
||
|
#if GL_BATCH_PERF_ANALYSIS
|
||
|
double flPresentTime = tm.GetDurationInProgress().GetMillisecondsF();
|
||
|
double flGLSwapWindowTime = g_pLauncherMgr->GetPrevGLSwapWindowTime();
|
||
|
|
||
|
m_flOverallPresentTime += flPresentTime;
|
||
|
m_flOverallPresentTimeSquared += flPresentTime * flPresentTime;
|
||
|
m_flOverallSwapWindowTime += flGLSwapWindowTime;
|
||
|
m_flOverallSwapWindowTimeSquared += flGLSwapWindowTime * flGLSwapWindowTime;
|
||
|
m_nOverallPresents++;
|
||
|
|
||
|
uint64 nEndGLCycles = gGL->m_nTotalGLCycles;
|
||
|
nEndGLCycles;
|
||
|
|
||
|
m_flTotalD3DTime += flPresentTime + g_nTotalD3DCycles * s_rdtsc_to_ms;
|
||
|
m_nTotalD3DCalls += g_nTotalD3DCalls;
|
||
|
|
||
|
m_flTotalGLTime += gGL->m_nTotalGLCycles * s_rdtsc_to_ms;
|
||
|
m_nTotalGLCalls += gGL->m_nTotalGLCalls;
|
||
|
|
||
|
m_nOverallProgramChanges += m_nNumProgramChanges;
|
||
|
m_nOverallDraws += g_nTotalDrawsOrClears;
|
||
|
m_nOverallPrims += m_nTotalPrims;
|
||
|
m_nOverallD3DCalls += m_nTotalD3DCalls;
|
||
|
m_flOverallD3DTime += m_flTotalD3DTime;
|
||
|
m_nOverallGLCalls += m_nTotalGLCalls;
|
||
|
m_flOverallGLTime += m_flTotalGLTime;
|
||
|
|
||
|
static int nPrevBatchVis = -1;
|
||
|
|
||
|
#if GL_BATCH_PERF_ANALYSIS_WRITE_PNGS
|
||
|
if ((nPrevBatchVis == 1) && m_pBatch_vis_bitmap && m_pBatch_vis_bitmap->is_valid())
|
||
|
{
|
||
|
double flTotalGLPresentTime = ( nEndGLCycles - nStartGLCycles ) * s_rdtsc_to_ms;
|
||
|
|
||
|
m_pBatch_vis_bitmap->fill_box(0, m_nBatchVisY, (uint)(.5f + flPresentTime / gl_present_vis_abs_scale.GetFloat() * m_pBatch_vis_bitmap->width()), 10, 255, 16, 128);
|
||
|
m_pBatch_vis_bitmap->additive_fill_box(0, m_nBatchVisY, (uint)(.5f + flTotalGLPresentTime / gl_present_vis_abs_scale.GetFloat() * m_pBatch_vis_bitmap->width()), 10, 0, 255, 128);
|
||
|
m_nBatchVisY += 10;
|
||
|
|
||
|
uint y = MAX(m_nBatchVisY + 20, 600), l = 0;
|
||
|
m_pBatch_vis_bitmap->draw_formatted_text(0, y+8*(l++), 1, 255, 255, 255, "OpenGL Frame: %u, Batches+Clears: %u, Prims: %u, Program Changes: %u", m_nOverallPresents, g_nTotalDrawsOrClears, m_nTotalPrims, m_nNumProgramChanges );
|
||
|
m_pBatch_vis_bitmap->draw_formatted_text(0, y+8*(l++), 1, 255, 255, 255, "Frame: D3D Calls: %u, D3D Time: %3.3fms", m_nTotalD3DCalls, m_flTotalD3DTime);
|
||
|
m_pBatch_vis_bitmap->draw_formatted_text(0, y+8*(l++), 1, 255, 255, 255, "Frame: GL Calls: %u, GL Time: %3.3fms", m_nTotalGLCalls, m_flTotalGLTime);
|
||
|
l++;
|
||
|
m_pBatch_vis_bitmap->draw_formatted_text(0, y+8*(l++), 1, 255, 255, 255, "Overall: Batches: %u, Prims: %u, Program Changes: %u", m_nOverallDraws, m_nOverallPrims, m_nOverallProgramChanges );
|
||
|
m_pBatch_vis_bitmap->draw_formatted_text(0, y+8*(l++), 1, 255, 255, 255, "Overall: D3D Calls: %u D3D Time: %4.3fms", m_nOverallD3DCalls, m_flOverallD3DTime );
|
||
|
m_pBatch_vis_bitmap->draw_formatted_text(0, y+8*(l++), 1, 255, 255, 255, "Overall: GL Calls: %u GL Time: %4.3fms", m_nOverallGLCalls, m_flOverallGLTime );
|
||
|
|
||
|
size_t png_size = 0;
|
||
|
void *pPNG_data = tdefl_write_image_to_png_file_in_memory(m_pBatch_vis_bitmap->get_ptr(), m_pBatch_vis_bitmap->width(), m_pBatch_vis_bitmap->height(), 3, &png_size, true);
|
||
|
if (pPNG_data)
|
||
|
{
|
||
|
char filename[256];
|
||
|
V_snprintf(filename, sizeof(filename), "left4dead2/batchvis_%u_%u.png", m_nBatchVisFileIdx, m_nBatchVisFrameIndex);
|
||
|
FILE* pFile = fopen(filename, "wb");
|
||
|
if (pFile)
|
||
|
{
|
||
|
fwrite(pPNG_data, png_size, 1, pFile);
|
||
|
fclose(pFile);
|
||
|
}
|
||
|
free(pPNG_data);
|
||
|
}
|
||
|
m_nBatchVisFrameIndex++;
|
||
|
m_nBatchVisY = 0;
|
||
|
m_pBatch_vis_bitmap->cls();
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
if (nPrevBatchVis != (int)gl_batch_vis.GetBool())
|
||
|
{
|
||
|
if ( !m_pBatch_vis_bitmap )
|
||
|
m_pBatch_vis_bitmap = new simple_bitmap;
|
||
|
|
||
|
nPrevBatchVis = gl_batch_vis.GetBool();
|
||
|
if (!nPrevBatchVis)
|
||
|
{
|
||
|
DumpStatsToConsole( NULL );
|
||
|
m_pBatch_vis_bitmap->clear();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_pBatch_vis_bitmap->init(768, 1024);
|
||
|
}
|
||
|
m_nBatchVisY = 0;
|
||
|
m_nBatchVisFrameIndex = 0;
|
||
|
m_nBatchVisFileIdx = (uint)time(NULL); //rand();
|
||
|
|
||
|
m_nOverallProgramChanges = 0;
|
||
|
m_nOverallDraws = 0;
|
||
|
m_nOverallD3DCalls = 0;
|
||
|
m_flOverallD3DTime = 0;
|
||
|
m_nOverallGLCalls = 0;
|
||
|
m_flOverallGLTime = 0;
|
||
|
m_flOverallPresentTime = 0;
|
||
|
m_flOverallPresentTimeSquared = 0;
|
||
|
m_flOverallSwapWindowTime = 0;
|
||
|
m_flOverallSwapWindowTimeSquared = 0;
|
||
|
m_nOverallPresents = 0;
|
||
|
}
|
||
|
|
||
|
g_nTotalD3DCycles = 0;
|
||
|
g_nTotalD3DCalls = 0;
|
||
|
gGL->m_nTotalGLCycles = 0;
|
||
|
gGL->m_nTotalGLCalls = 0;
|
||
|
|
||
|
m_nNumProgramChanges = 0;
|
||
|
m_flTotalD3DTime = 0;
|
||
|
m_nTotalD3DCalls = 0;
|
||
|
m_flTotalGLTime = 0;
|
||
|
m_nTotalGLCalls = 0;
|
||
|
m_nTotalPrims = 0;
|
||
|
#else
|
||
|
if ( gl_batch_vis.GetBool() )
|
||
|
{
|
||
|
gl_batch_vis.SetValue( false );
|
||
|
|
||
|
ConMsg( "Must define GL_BATCH_PERF_ANALYSIS to use this feature" );
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
g_nTotalDrawsOrClears = 0;
|
||
|
|
||
|
#if GL_TELEMETRY_GPU_ZONES
|
||
|
g_TelemetryGPUStats.Clear();
|
||
|
#endif
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Textures - (IDirect3DDevice9)
|
||
|
#pragma mark ( create functions for each texture are now adjacent to the rest of the methods for each texture class)
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::GetTexture(DWORD Stage,IDirect3DBaseTexture9** ppTexture)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
// if implemented, should it increase the ref count ??
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- RTs and Surfaces - (IDirect3DDevice9)
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle, char *pDebugLabel)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
HRESULT result = S_OK;
|
||
|
|
||
|
m_ObjectStats.m_nTotalSurfaces++;
|
||
|
m_ObjectStats.m_nTotalRenderTargets++;
|
||
|
|
||
|
IDirect3DSurface9 *surf = new IDirect3DSurface9;
|
||
|
surf->m_restype = D3DRTYPE_SURFACE;
|
||
|
|
||
|
surf->m_device = this; // always set device on creations!
|
||
|
|
||
|
GLMTexLayoutKey rtkey;
|
||
|
memset( &rtkey, 0, sizeof(rtkey) );
|
||
|
|
||
|
rtkey.m_texGLTarget = GL_TEXTURE_2D;
|
||
|
rtkey.m_xSize = Width;
|
||
|
rtkey.m_ySize = Height;
|
||
|
rtkey.m_zSize = 1;
|
||
|
|
||
|
rtkey.m_texFormat = Format;
|
||
|
rtkey.m_texFlags = kGLMTexRenderable;
|
||
|
|
||
|
rtkey.m_texFlags |= kGLMTexSRGB; // all render target tex are SRGB mode
|
||
|
if (m_ctx->Caps().m_cantAttachSRGB)
|
||
|
{
|
||
|
// this config can't support SRGB render targets. quietly turn off the sRGB bit.
|
||
|
rtkey.m_texFlags &= ~kGLMTexSRGB;
|
||
|
}
|
||
|
|
||
|
if ( (MultiSample !=0) && (!m_ctx->Caps().m_nvG7x) )
|
||
|
{
|
||
|
rtkey.m_texFlags |= kGLMTexMultisampled;
|
||
|
rtkey.m_texSamples = MultiSample;
|
||
|
// FIXME no support for "MS quality" yet
|
||
|
}
|
||
|
|
||
|
surf->m_tex = m_ctx->NewTex( &rtkey, 1, pDebugLabel );
|
||
|
surf->m_face = 0;
|
||
|
surf->m_mip = 0;
|
||
|
|
||
|
//desc
|
||
|
surf->m_desc.Format = Format;
|
||
|
surf->m_desc.Type = D3DRTYPE_SURFACE;
|
||
|
surf->m_desc.Usage = 0; //FIXME ???????????
|
||
|
surf->m_desc.Pool = D3DPOOL_DEFAULT; //FIXME ???????????
|
||
|
surf->m_desc.MultiSampleType = MultiSample;
|
||
|
surf->m_desc.MultiSampleQuality = MultisampleQuality;
|
||
|
surf->m_desc.Width = Width;
|
||
|
surf->m_desc.Height = Height;
|
||
|
|
||
|
*ppSurface = (result==S_OK) ? surf : NULL;
|
||
|
|
||
|
#if IUNKNOWN_ALLOC_SPEW
|
||
|
char scratch[1024];
|
||
|
sprintf(scratch,"RT %s", surf->m_tex->m_layout->m_layoutSummary );
|
||
|
surf->SetMark( true, scratch );
|
||
|
#endif
|
||
|
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::UpdateBoundFBO()
|
||
|
{
|
||
|
RenderTargetState_t renderTargetState;
|
||
|
for ( uint i = 0; i < 4; i++ )
|
||
|
{
|
||
|
renderTargetState.m_pRenderTargets[i] = m_pRenderTargets[i] ? m_pRenderTargets[i]->m_tex : NULL;
|
||
|
}
|
||
|
renderTargetState.m_pDepthStencil = m_pDepthStencil ? m_pDepthStencil->m_tex : NULL;
|
||
|
CUtlMap < RenderTargetState_t, CGLMFBO * >::IndexType_t index = m_pFBOs->Find( renderTargetState );
|
||
|
|
||
|
if ( m_pFBOs->IsValidIndex( index ) )
|
||
|
{
|
||
|
Assert( (*m_pFBOs)[index] );
|
||
|
|
||
|
m_ctx->m_drawingFBO = (*m_pFBOs)[index];
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
CGLMFBO *newFBO = m_ctx->NewFBO();
|
||
|
|
||
|
m_pFBOs->Insert( renderTargetState, newFBO );
|
||
|
|
||
|
uint nNumBound = 0;
|
||
|
|
||
|
for ( uint i = 0; i < 4; i++ )
|
||
|
{
|
||
|
if ( !m_pRenderTargets[i] )
|
||
|
continue;
|
||
|
|
||
|
GLMFBOTexAttachParams rtParams;
|
||
|
memset( &rtParams, 0, sizeof(rtParams) );
|
||
|
|
||
|
rtParams.m_tex = m_pRenderTargets[i]->m_tex;
|
||
|
rtParams.m_face = m_pRenderTargets[i]->m_face;
|
||
|
rtParams.m_mip = m_pRenderTargets[i]->m_mip;
|
||
|
rtParams.m_zslice = 0;
|
||
|
|
||
|
newFBO->TexAttach( &rtParams, (EGLMFBOAttachment)(kAttColor0 + i) );
|
||
|
nNumBound++;
|
||
|
}
|
||
|
|
||
|
if ( m_pDepthStencil )
|
||
|
{
|
||
|
GLMFBOTexAttachParams depthParams;
|
||
|
memset( &depthParams, 0, sizeof(depthParams) );
|
||
|
|
||
|
depthParams.m_tex = m_pDepthStencil->m_tex;
|
||
|
|
||
|
EGLMFBOAttachment destAttach = (depthParams.m_tex->m_layout->m_format->m_glDataFormat != 34041) ? kAttDepth : kAttDepthStencil;
|
||
|
|
||
|
newFBO->TexAttach( &depthParams, destAttach );
|
||
|
nNumBound++;
|
||
|
}
|
||
|
|
||
|
(void)nNumBound;
|
||
|
|
||
|
Assert( nNumBound );
|
||
|
|
||
|
#if GLMDEBUG
|
||
|
Assert( newFBO->IsReady() );
|
||
|
#endif
|
||
|
|
||
|
m_ctx->m_drawingFBO = newFBO;
|
||
|
}
|
||
|
|
||
|
m_ctx->BindFBOToCtx( m_ctx->m_drawingFBO, GL_FRAMEBUFFER_EXT );
|
||
|
|
||
|
m_bFBODirty = false;
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::ResetFBOMap()
|
||
|
{
|
||
|
if ( !m_pFBOs )
|
||
|
return;
|
||
|
|
||
|
FOR_EACH_MAP_FAST( (*m_pFBOs), i )
|
||
|
{
|
||
|
const RenderTargetState_t &rtState = m_pFBOs->Key( i ); (void)rtState;
|
||
|
CGLMFBO *pFBO = (*m_pFBOs)[i];
|
||
|
|
||
|
m_ctx->DelFBO( pFBO );
|
||
|
}
|
||
|
|
||
|
m_pFBOs->Purge();
|
||
|
|
||
|
m_bFBODirty = true;
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::ScrubFBOMap( CGLMTex *pTex )
|
||
|
{
|
||
|
Assert( pTex );
|
||
|
|
||
|
if ( !m_pFBOs )
|
||
|
return;
|
||
|
|
||
|
CUtlVectorFixed< RenderTargetState_t, 128 > fbosToRemove;
|
||
|
|
||
|
FOR_EACH_MAP_FAST( (*m_pFBOs), i )
|
||
|
{
|
||
|
const RenderTargetState_t &rtState = m_pFBOs->Key( i );
|
||
|
CGLMFBO *pFBO = (*m_pFBOs)[i]; (void)pFBO;
|
||
|
|
||
|
if ( rtState.RefersTo( pTex ) )
|
||
|
{
|
||
|
fbosToRemove.AddToTail( rtState );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
for ( int i = 0; i < fbosToRemove.Count(); ++i )
|
||
|
{
|
||
|
const RenderTargetState_t &rtState = fbosToRemove[i];
|
||
|
|
||
|
CUtlMap < RenderTargetState_t, CGLMFBO * >::IndexType_t index = m_pFBOs->Find( rtState );
|
||
|
|
||
|
if ( !m_pFBOs->IsValidIndex( index ) )
|
||
|
{
|
||
|
Assert( 0 );
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
CGLMFBO *pFBO = (*m_pFBOs)[index];
|
||
|
|
||
|
m_ctx->DelFBO( pFBO );
|
||
|
|
||
|
m_pFBOs->RemoveAt( index );
|
||
|
|
||
|
m_bFBODirty = true;
|
||
|
}
|
||
|
|
||
|
//GLMDebugPrintf( "IDirect3DDevice9::ScrubFBOMap: Removed %u entries\n", fbosToRemove.Count() );
|
||
|
}
|
||
|
HRESULT IDirect3DDevice9::SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* pRenderTarget)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
tmZone( TELEMETRY_LEVEL2, TMZF_NONE, "%s", __FUNCTION__ );
|
||
|
|
||
|
Assert( RenderTargetIndex < 4 );
|
||
|
|
||
|
HRESULT result = S_OK;
|
||
|
|
||
|
GLMPRINTF(("-F- SetRenderTarget index=%d, surface=%8x (tex=%8x %s)",
|
||
|
RenderTargetIndex,
|
||
|
pRenderTarget,
|
||
|
pRenderTarget ? pRenderTarget->m_tex : NULL,
|
||
|
pRenderTarget ? pRenderTarget->m_tex->m_layout->m_layoutSummary : ""
|
||
|
));
|
||
|
|
||
|
// note that it is OK to pass NULL for pRenderTarget, it implies that you would like to detach any color buffer from that target index
|
||
|
|
||
|
// behaviors...
|
||
|
// if new surf is same as old surf, no change in refcount, in fact, it's early exit
|
||
|
IDirect3DSurface9 *oldTarget = m_pRenderTargets[RenderTargetIndex];
|
||
|
|
||
|
if (pRenderTarget == oldTarget)
|
||
|
{
|
||
|
GLMPRINTF(("-F- --> no change",RenderTargetIndex));
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Fix this if porting to x86_64
|
||
|
if ( m_pRenderTargets[RenderTargetIndex] )
|
||
|
|
||
|
|
||
|
{
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
// we now know that the new surf is not the same as the old surf.
|
||
|
// you can't assume either one is non NULL here though.
|
||
|
|
||
|
m_pRenderTargets[RenderTargetIndex]->Release( 1, "-A SetRenderTarget private release" );
|
||
|
}
|
||
|
|
||
|
if (pRenderTarget)
|
||
|
{
|
||
|
pRenderTarget->AddRef( 1, "+A SetRenderTarget private addref" ); // again, private refcount being raised
|
||
|
}
|
||
|
m_pRenderTargets[RenderTargetIndex] = pRenderTarget;
|
||
|
|
||
|
m_bFBODirty = true;
|
||
|
|
||
|
/*
|
||
|
if (!pRenderTarget)
|
||
|
{
|
||
|
GLMPRINTF(("-F- --> Setting NULL render target on index=%d ",RenderTargetIndex));
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
GLMPRINTF(("-F- --> attaching index=%d on drawing FBO (%8x)",RenderTargetIndex, m_drawableFBO));
|
||
|
// attach color to FBO
|
||
|
GLMFBOTexAttachParams rtParams;
|
||
|
memset( &rtParams, 0, sizeof(rtParams) );
|
||
|
|
||
|
rtParams.m_tex = pRenderTarget->m_tex;
|
||
|
rtParams.m_face = pRenderTarget->m_face;
|
||
|
rtParams.m_mip = pRenderTarget->m_mip;
|
||
|
rtParams.m_zslice = 0; // FIXME if you ever want to be able to render to slices of a 3D tex..
|
||
|
|
||
|
m_drawableFBO->TexAttach( &rtParams, (EGLMFBOAttachment)(kAttColor0 + RenderTargetIndex) );
|
||
|
}
|
||
|
*/
|
||
|
|
||
|
#if GL_BATCH_PERF_ANALYSIS && GL_BATCH_PERF_ANALYSIS_WRITE_PNGS
|
||
|
if ( m_pBatch_vis_bitmap && m_pBatch_vis_bitmap->is_valid() && !RenderTargetIndex )
|
||
|
{
|
||
|
m_pBatch_vis_bitmap->fill_box(0, m_nBatchVisY, m_pBatch_vis_bitmap->width(), 1, 30, 20, 20);
|
||
|
m_nBatchVisY += 1;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
|
||
|
HRESULT IDirect3DDevice9::GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9** ppRenderTarget)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
if ( !m_pRenderTargets[ RenderTargetIndex ] )
|
||
|
return D3DERR_NOTFOUND;
|
||
|
|
||
|
if ( ( RenderTargetIndex > 4 ) || !ppRenderTarget )
|
||
|
return D3DERR_INVALIDCALL;
|
||
|
|
||
|
// safe because of early exit on NULL above
|
||
|
m_pRenderTargets[ RenderTargetIndex ]->AddRef(0, "+B GetRenderTarget public addref"); // per http://msdn.microsoft.com/en-us/library/bb174404(VS.85).aspx
|
||
|
|
||
|
*ppRenderTarget = m_pRenderTargets[ RenderTargetIndex ];
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreateOffscreenPlainSurface( UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
// set surf->m_restype to D3DRTYPE_SURFACE...
|
||
|
|
||
|
// this is almost identical to CreateRenderTarget..
|
||
|
|
||
|
HRESULT result = S_OK;
|
||
|
|
||
|
m_ObjectStats.m_nTotalSurfaces++;
|
||
|
m_ObjectStats.m_nTotalRenderTargets++;
|
||
|
|
||
|
IDirect3DSurface9 *surf = new IDirect3DSurface9;
|
||
|
surf->m_restype = D3DRTYPE_SURFACE;
|
||
|
|
||
|
surf->m_device = this; // always set device on creations!
|
||
|
|
||
|
GLMTexLayoutKey rtkey;
|
||
|
memset( &rtkey, 0, sizeof(rtkey) );
|
||
|
|
||
|
rtkey.m_texGLTarget = GL_TEXTURE_2D;
|
||
|
rtkey.m_xSize = Width;
|
||
|
rtkey.m_ySize = Height;
|
||
|
rtkey.m_zSize = 1;
|
||
|
|
||
|
rtkey.m_texFormat = Format;
|
||
|
rtkey.m_texFlags = kGLMTexRenderable;
|
||
|
|
||
|
surf->m_tex = m_ctx->NewTex( &rtkey, 1, "offscreen plain surface" );
|
||
|
surf->m_face = 0;
|
||
|
surf->m_mip = 0;
|
||
|
|
||
|
//desc
|
||
|
surf->m_desc.Format = Format;
|
||
|
surf->m_desc.Type = D3DRTYPE_SURFACE;
|
||
|
surf->m_desc.Usage = 0;
|
||
|
surf->m_desc.Pool = D3DPOOL_DEFAULT;
|
||
|
surf->m_desc.MultiSampleType = D3DMULTISAMPLE_NONE;
|
||
|
surf->m_desc.MultiSampleQuality = 0;
|
||
|
surf->m_desc.Width = Width;
|
||
|
surf->m_desc.Height = Height;
|
||
|
|
||
|
*ppSurface = (result==S_OK) ? surf : NULL;
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9** ppSurface,VD3DHANDLE* pSharedHandle)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
Assert( ( Format == D3DFMT_D16 ) || ( Format == D3DFMT_D24X8 ) || ( Format == D3DFMT_D24S8 ) );
|
||
|
HRESULT result = S_OK;
|
||
|
|
||
|
m_ObjectStats.m_nTotalSurfaces++;
|
||
|
m_ObjectStats.m_nTotalRenderTargets++;
|
||
|
|
||
|
IDirect3DSurface9 *surf = new IDirect3DSurface9;
|
||
|
surf->m_restype = D3DRTYPE_SURFACE;
|
||
|
|
||
|
surf->m_device = this; // always set device on creations!
|
||
|
|
||
|
GLMTexLayoutKey depthkey;
|
||
|
memset( &depthkey, 0, sizeof(depthkey) );
|
||
|
|
||
|
depthkey.m_texGLTarget = GL_TEXTURE_2D;
|
||
|
depthkey.m_xSize = Width;
|
||
|
depthkey.m_ySize = Height;
|
||
|
depthkey.m_zSize = 1;
|
||
|
|
||
|
depthkey.m_texFormat = Format;
|
||
|
depthkey.m_texFlags = kGLMTexRenderable | kGLMTexIsDepth;
|
||
|
|
||
|
if ( Format == D3DFMT_D24S8 )
|
||
|
{
|
||
|
depthkey.m_texFlags |= kGLMTexIsStencil;
|
||
|
}
|
||
|
|
||
|
if ( (MultiSample !=0) && (!m_ctx->Caps().m_nvG7x) )
|
||
|
{
|
||
|
depthkey.m_texFlags |= kGLMTexMultisampled;
|
||
|
depthkey.m_texSamples = MultiSample;
|
||
|
// FIXME no support for "MS quality" yet
|
||
|
}
|
||
|
|
||
|
surf->m_tex = m_ctx->NewTex( &depthkey, 1, "depth-stencil surface" );
|
||
|
surf->m_face = 0;
|
||
|
surf->m_mip = 0;
|
||
|
|
||
|
//desc
|
||
|
|
||
|
surf->m_desc.Format = Format;
|
||
|
surf->m_desc.Type = D3DRTYPE_SURFACE;
|
||
|
surf->m_desc.Usage = 0; //FIXME ???????????
|
||
|
surf->m_desc.Pool = D3DPOOL_DEFAULT; //FIXME ???????????
|
||
|
surf->m_desc.MultiSampleType = MultiSample;
|
||
|
surf->m_desc.MultiSampleQuality = MultisampleQuality;
|
||
|
surf->m_desc.Width = Width;
|
||
|
surf->m_desc.Height = Height;
|
||
|
|
||
|
*ppSurface = (result==S_OK) ? surf : NULL;
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetDepthStencilSurface( IDirect3DSurface9* pNewZStencil )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
HRESULT result = S_OK;
|
||
|
|
||
|
GLMPRINTF(("-F- SetDepthStencilSurface, surface=%8x (tex=%8x %s)",
|
||
|
pNewZStencil,
|
||
|
pNewZStencil ? pNewZStencil->m_tex : NULL,
|
||
|
pNewZStencil ? pNewZStencil->m_tex->m_layout->m_layoutSummary : ""
|
||
|
));
|
||
|
|
||
|
if ( pNewZStencil == m_pDepthStencil )
|
||
|
{
|
||
|
GLMPRINTF(("-F- --> no change"));
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
if ( pNewZStencil )
|
||
|
{
|
||
|
pNewZStencil->AddRef(1, "+A SetDepthStencilSurface private addref");
|
||
|
}
|
||
|
|
||
|
if ( m_pDepthStencil )
|
||
|
{
|
||
|
// Note this Release() could cause the surface to be deleted!
|
||
|
m_pDepthStencil->Release(1, "-A SetDepthStencilSurface private release");
|
||
|
}
|
||
|
|
||
|
m_pDepthStencil = pNewZStencil;
|
||
|
|
||
|
m_bFBODirty = true;
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::GetDepthStencilSurface(IDirect3DSurface9** ppZStencilSurface)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
if ( !ppZStencilSurface )
|
||
|
{
|
||
|
return D3DERR_INVALIDCALL;
|
||
|
}
|
||
|
|
||
|
if ( !m_pDepthStencil )
|
||
|
{
|
||
|
*ppZStencilSurface = NULL;
|
||
|
return D3DERR_NOTFOUND;
|
||
|
}
|
||
|
|
||
|
m_pDepthStencil->AddRef(0, "+B GetDepthStencilSurface public addref"); // per http://msdn.microsoft.com/en-us/library/bb174384(VS.85).aspx
|
||
|
|
||
|
*ppZStencilSurface = m_pDepthStencil;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::GetRenderTargetData(IDirect3DSurface9* pRenderTarget,IDirect3DSurface9* pDestSurface)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
// is it just a blit ?
|
||
|
|
||
|
this->StretchRect( pRenderTarget, NULL, pDestSurface, NULL, D3DTEXF_NONE ); // is this good enough ???
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9* pDestSurface)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::StretchRect(IDirect3DSurface9* pSourceSurface,CONST RECT* pSourceRect,IDirect3DSurface9* pDestSurface,CONST RECT* pDestRect,D3DTEXTUREFILTERTYPE Filter)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
// find relevant slices in GLM tex
|
||
|
|
||
|
if ( m_bFBODirty )
|
||
|
{
|
||
|
UpdateBoundFBO();
|
||
|
}
|
||
|
|
||
|
CGLMTex *srcTex = pSourceSurface->m_tex;
|
||
|
int srcSliceIndex = srcTex->CalcSliceIndex( pSourceSurface->m_face, pSourceSurface->m_mip );
|
||
|
GLMTexLayoutSlice *srcSlice = &srcTex->m_layout->m_slices[ srcSliceIndex ];
|
||
|
|
||
|
CGLMTex *dstTex = pDestSurface->m_tex;
|
||
|
int dstSliceIndex = dstTex->CalcSliceIndex( pDestSurface->m_face, pDestSurface->m_mip );
|
||
|
GLMTexLayoutSlice *dstSlice = &dstTex->m_layout->m_slices[ dstSliceIndex ];
|
||
|
|
||
|
if ( dstTex->m_rboName != 0 )
|
||
|
{
|
||
|
Assert(!"No path yet for blitting into an MSAA tex");
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
bool useFastBlit = (gl_blitmode.GetInt() != 0);
|
||
|
|
||
|
if ( !useFastBlit && (srcTex->m_rboName !=0)) // old way, we do a resolve to scratch tex first (necessitating two step blit)
|
||
|
{
|
||
|
m_ctx->ResolveTex( srcTex, true );
|
||
|
}
|
||
|
|
||
|
// set up source/dest rect in GLM form
|
||
|
GLMRect srcRect, dstRect;
|
||
|
|
||
|
// d3d nomenclature:
|
||
|
// Y=0 is the visual top and also aligned with V=0.
|
||
|
|
||
|
srcRect.xmin = pSourceRect ? pSourceRect->left : 0;
|
||
|
srcRect.xmax = pSourceRect ? pSourceRect->right : srcSlice->m_xSize;
|
||
|
srcRect.ymin = pSourceRect ? pSourceRect->top : 0;
|
||
|
srcRect.ymax = pSourceRect ? pSourceRect->bottom : srcSlice->m_ySize;
|
||
|
|
||
|
dstRect.xmin = pDestRect ? pDestRect->left : 0;
|
||
|
dstRect.xmax = pDestRect ? pDestRect->right : dstSlice->m_xSize;
|
||
|
dstRect.ymin = pDestRect ? pDestRect->top : 0;
|
||
|
dstRect.ymax = pDestRect ? pDestRect->bottom : dstSlice->m_ySize;
|
||
|
|
||
|
GLenum filterGL = 0;
|
||
|
switch(Filter)
|
||
|
{
|
||
|
case D3DTEXF_NONE:
|
||
|
case D3DTEXF_POINT:
|
||
|
filterGL = GL_NEAREST;
|
||
|
break;
|
||
|
|
||
|
case D3DTEXF_LINEAR:
|
||
|
filterGL = GL_LINEAR;
|
||
|
break;
|
||
|
|
||
|
default: // D3DTEXF_ANISOTROPIC
|
||
|
Assert(!"Impl aniso stretch");
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
if (useFastBlit)
|
||
|
{
|
||
|
m_ctx->Blit2( srcTex, &srcRect, pSourceSurface->m_face, pSourceSurface->m_mip,
|
||
|
dstTex, &dstRect, pDestSurface->m_face, pDestSurface->m_mip,
|
||
|
filterGL
|
||
|
);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_ctx->BlitTex( srcTex, &srcRect, pSourceSurface->m_face, pSourceSurface->m_mip,
|
||
|
dstTex, &dstRect, pDestSurface->m_face, pDestSurface->m_mip,
|
||
|
filterGL
|
||
|
);
|
||
|
}
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
// This totally sucks, but this information can't be gleaned any
|
||
|
// other way when translating from D3D to GL at this level
|
||
|
//
|
||
|
// This returns a mask, since multiple GLSL "varyings" can be tagged with centroid
|
||
|
static uint32 CentroidMaskFromName( bool bPixelShader, const char *pName )
|
||
|
{
|
||
|
// Important note: This code has been customized for TF2 - don't blindly merge it into other branches!
|
||
|
if ( !pName )
|
||
|
return 0;
|
||
|
|
||
|
// Important: The centroid bitflags must match between all linked vertex/pixel shaders!
|
||
|
if ( bPixelShader )
|
||
|
{
|
||
|
if ( V_stristr( pName, "lightmappedgeneric_ps" ) || V_strstr( pName, "worldtwotextureblend_ps" ) )
|
||
|
{
|
||
|
return (0x01 << 2) | (0x01 << 3); // iterators 2 and 3
|
||
|
}
|
||
|
else if ( V_stristr( pName, "lightmappedreflective_ps" ) )
|
||
|
{
|
||
|
return (0x01 << 6) | (0x01 << 7); // iterators 6 and 7
|
||
|
}
|
||
|
else if ( V_stristr( pName, "water_ps" ) )
|
||
|
{
|
||
|
return 0xC0;
|
||
|
}
|
||
|
else if ( V_stristr( pName, "shadow_ps" ) )
|
||
|
{
|
||
|
return 0x1F;
|
||
|
}
|
||
|
else if ( V_stristr( pName, "ShatteredGlass_ps" ) )
|
||
|
{
|
||
|
return 0xC;
|
||
|
}
|
||
|
else if ( V_stristr( pName, "WorldVertexAlpha_ps" ) || V_stristr( pName, "WorldVertexTransition_ps" ) )
|
||
|
{
|
||
|
// These pixel shaders want centroid but shouldn't be used
|
||
|
Assert(0);
|
||
|
return 0;
|
||
|
}
|
||
|
else if ( V_stristr( pName, "flashlight_ps" ) )
|
||
|
{
|
||
|
return 0xC;
|
||
|
}
|
||
|
}
|
||
|
else // vertex shader
|
||
|
{
|
||
|
// Vertex shaders also
|
||
|
if ( V_stristr( pName, "lightmappedgeneric_vs" ) )
|
||
|
{
|
||
|
return (0x01 << 2) | (0x01 << 3); // iterators 2 and 3
|
||
|
}
|
||
|
else if ( V_stristr( pName, "lightmappedreflective_vs" ) )
|
||
|
{
|
||
|
return (0x01 << 6) | (0x01 << 7); // iterators 6 and 7
|
||
|
}
|
||
|
else if ( V_stristr( pName, "water_vs" ) )
|
||
|
{
|
||
|
return 0xC0;
|
||
|
}
|
||
|
else if ( V_stristr( pName, "shadow_vs" ) )
|
||
|
{
|
||
|
return 0x1F;
|
||
|
}
|
||
|
else if ( V_stristr( pName, "ShatteredGlass_vs" ) )
|
||
|
{
|
||
|
return 0xC;
|
||
|
}
|
||
|
else if ( V_stristr( pName, "flashlight_vs" ) )
|
||
|
{
|
||
|
return 0xC;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// This shader doesn't have any centroid iterators
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
// This totally sucks, but this information can't be gleaned any
|
||
|
// other way when translating from D3D to GL at this level
|
||
|
static int ShadowDepthSamplerMaskFromName( const char *pName )
|
||
|
{
|
||
|
if ( !pName )
|
||
|
return 0;
|
||
|
|
||
|
if ( V_stristr( pName, "water_ps" ) )
|
||
|
{
|
||
|
return (1<<7);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "infected_ps" ) )
|
||
|
{
|
||
|
return (1<<1);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "phong_ps" ) )
|
||
|
{
|
||
|
return (1<<4) | (1<<15);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "vertexlit_and_unlit_generic_bump_ps" ) )
|
||
|
{
|
||
|
return (1<<8) | (1<<15);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "vertexlit_and_unlit_generic_ps" ) )
|
||
|
{
|
||
|
return (1<<8) | (1<<15);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "eye_refract_ps" ) )
|
||
|
{
|
||
|
return (1<<6);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "eyes_flashlight_ps" ) )
|
||
|
{
|
||
|
return (1<<4);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "worldtwotextureblend_ps" ) )
|
||
|
{
|
||
|
return (1<<7);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "teeth_flashlight_ps" ) )
|
||
|
{
|
||
|
return (1<<2);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "flashlight_ps" ) ) // substring of above, make sure this comes last!!
|
||
|
{
|
||
|
return (1<<7);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "lightmappedgeneric_ps" ) )
|
||
|
{
|
||
|
return (1<<15);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "deferred_global_light_ps" ) )
|
||
|
{
|
||
|
return (1<<14);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "global_lit_simple_ps" ) )
|
||
|
{
|
||
|
return (1<<14);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "lightshafts_ps" ) )
|
||
|
{
|
||
|
return (1<<1);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "multiblend_combined_ps" ) )
|
||
|
{
|
||
|
return (1<<14);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "multiblend_ps" ) )
|
||
|
{
|
||
|
return (1<<14);
|
||
|
}
|
||
|
else if ( V_stristr( pName, "customhero_ps" ) )
|
||
|
{
|
||
|
return (1<<14);
|
||
|
}
|
||
|
|
||
|
// This shader doesn't have a shadow depth map sampler
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Pixel Shaders - (IDirect3DDevice9)
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreatePixelShader(CONST DWORD* pFunction,IDirect3DPixelShader9** ppShader, const char *pShaderName, char *pDebugLabel, const uint32 *pCentroidMask )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
HRESULT result = D3DERR_INVALIDCALL;
|
||
|
*ppShader = NULL;
|
||
|
|
||
|
int nShadowDepthSamplerMask = ShadowDepthSamplerMaskFromName( pShaderName );
|
||
|
uint nCentroidMask = CentroidMaskFromName( true, pShaderName );
|
||
|
|
||
|
if ( pCentroidMask )
|
||
|
{
|
||
|
if ( *pCentroidMask != nCentroidMask )
|
||
|
{
|
||
|
GLMDebugPrintf( "IDirect3DDevice9::CreatePixelShader: shaderapi's centroid mask (0x%08X) differs from mask derived from shader name (0x%08X) for shader %s\n", *pCentroidMask, nCentroidMask, pDebugLabel );
|
||
|
}
|
||
|
// It would be great if we could use these centroid masks passed in from shaderapi - but unfortunately they're only available for pixel shaders, and we also need to compute matching masks for vertex shaders!
|
||
|
//nCentroidMask = *pCentroidMask;
|
||
|
}
|
||
|
|
||
|
{
|
||
|
int numTranslations = 1;
|
||
|
|
||
|
bool bVertexShader = false;
|
||
|
|
||
|
// we can do one or two translated forms. they go together in a single buffer with some markers to allow GLM to break it up.
|
||
|
// this also lets us mirror each set of translations to disk with a single file making it easier to view and edit side by side.
|
||
|
|
||
|
int maxTranslationSize = 50000; // size of any one translation
|
||
|
|
||
|
CUtlBuffer transbuf( 3000, numTranslations * maxTranslationSize, CUtlBuffer::TEXT_BUFFER );
|
||
|
CUtlBuffer tempbuf( 3000, maxTranslationSize, CUtlBuffer::TEXT_BUFFER );
|
||
|
|
||
|
transbuf.PutString( "//GLSLfp\n" ); // this is required so GLM can crack the text apart
|
||
|
|
||
|
// note the GLSL translator wants its own buffer
|
||
|
tempbuf.EnsureCapacity( maxTranslationSize );
|
||
|
|
||
|
uint glslPixelShaderOptions = D3DToGL_OptionUseEnvParams;// | D3DToGL_OptionAllowStaticControlFlow;
|
||
|
|
||
|
|
||
|
// Fake SRGB mode - needed on R500, probably indefinitely.
|
||
|
// Do this stuff if caps show m_needsFakeSRGB=true and the sRGBWrite state is true
|
||
|
// (but not if it's engine_post which is special)
|
||
|
|
||
|
if (!m_ctx->Caps().m_hasGammaWrites)
|
||
|
{
|
||
|
if ( pShaderName )
|
||
|
{
|
||
|
if ( !V_stristr( pShaderName, "engine_post" ) )
|
||
|
{
|
||
|
glslPixelShaderOptions |= D3DToGL_OptionSRGBWriteSuffix;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
g_D3DToOpenGLTranslatorGLSL.TranslateShader( (uint32 *) pFunction, &tempbuf, &bVertexShader, glslPixelShaderOptions, nShadowDepthSamplerMask, nCentroidMask, pDebugLabel );
|
||
|
|
||
|
transbuf.PutString( (char*)tempbuf.Base() );
|
||
|
transbuf.PutString( "\n\n" ); // whitespace
|
||
|
|
||
|
if ( bVertexShader )
|
||
|
{
|
||
|
// don't cross the streams
|
||
|
Assert(!"Can't accept vertex shader in CreatePixelShader");
|
||
|
result = D3DERR_INVALIDCALL;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_ObjectStats.m_nTotalPixelShaders++;
|
||
|
|
||
|
IDirect3DPixelShader9 *newprog = new IDirect3DPixelShader9;
|
||
|
|
||
|
newprog->m_pixHighWater = 0;
|
||
|
newprog->m_pixSamplerMask = 0;
|
||
|
newprog->m_pixSamplerTypes = 0;
|
||
|
|
||
|
newprog->m_pixProgram = m_ctx->NewProgram( kGLMFragmentProgram, (char *)transbuf.Base(), pShaderName ? pShaderName : "?" ) ;
|
||
|
newprog->m_pixProgram->m_nCentroidMask = nCentroidMask;
|
||
|
newprog->m_pixProgram->m_nShadowDepthSamplerMask = nShadowDepthSamplerMask;
|
||
|
|
||
|
newprog->m_pixProgram->m_bTranslatedProgram = true;
|
||
|
newprog->m_pixProgram->m_maxVertexAttrs = 0;
|
||
|
|
||
|
newprog->m_device = this;
|
||
|
|
||
|
//------ find the frag program metadata and extract it..
|
||
|
|
||
|
|
||
|
{
|
||
|
// find the highwater mark
|
||
|
char *highWaterPrefix = "//HIGHWATER-"; // try to arrange this so it can work with pure GLSL if needed
|
||
|
char *highWaterStr = strstr( (char *)transbuf.Base(), highWaterPrefix );
|
||
|
if (highWaterStr)
|
||
|
{
|
||
|
char *highWaterActualData = highWaterStr + strlen( highWaterPrefix );
|
||
|
|
||
|
int value = -1;
|
||
|
sscanf( highWaterActualData, "%d", &value );
|
||
|
|
||
|
newprog->m_pixHighWater = value;
|
||
|
newprog->m_pixProgram->m_descs[kGLMGLSL].m_highWater = value;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
Assert(!"couldn't find sampler map in pixel shader");
|
||
|
}
|
||
|
}
|
||
|
|
||
|
{
|
||
|
// find the sampler map
|
||
|
char *samplerMaskPrefix = "//SAMPLERMASK-"; // try to arrange this so it can work with pure GLSL if needed
|
||
|
|
||
|
char *samplerMaskStr = strstr( (char *)transbuf.Base(), samplerMaskPrefix );
|
||
|
if (samplerMaskStr)
|
||
|
{
|
||
|
char *samplerMaskActualData = samplerMaskStr + strlen( samplerMaskPrefix );
|
||
|
|
||
|
int value = -1;
|
||
|
sscanf( samplerMaskActualData, "%04x", &value );
|
||
|
|
||
|
newprog->m_pixSamplerMask = value;
|
||
|
newprog->m_pixProgram->m_samplerMask = value; // helps GLM maintain a better linked pair cache even when SRGB sampler state changes
|
||
|
|
||
|
int nMaxReg;
|
||
|
for ( nMaxReg = 31; nMaxReg >= 0; --nMaxReg )
|
||
|
if ( value & ( 1 << nMaxReg ) )
|
||
|
break;
|
||
|
|
||
|
newprog->m_pixProgram->m_maxSamplers = nMaxReg + 1;
|
||
|
|
||
|
int nNumUsedSamplers = 0;
|
||
|
for ( int i = 31; i >= 0; --i)
|
||
|
if ( value & ( 1 << i ) )
|
||
|
nNumUsedSamplers++;
|
||
|
newprog->m_pixProgram->m_nNumUsedSamplers = nNumUsedSamplers;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
Assert(!"couldn't find sampler map in pixel shader");
|
||
|
}
|
||
|
}
|
||
|
|
||
|
{
|
||
|
// find the sampler map
|
||
|
char *samplerTypesPrefix = "//SAMPLERTYPES-"; // try to arrange this so it can work with pure GLSL if needed
|
||
|
|
||
|
char *samplerTypesStr = strstr( (char *)transbuf.Base(), samplerTypesPrefix );
|
||
|
if (samplerTypesStr)
|
||
|
{
|
||
|
char *samplerTypesActualData = samplerTypesStr + strlen( samplerTypesPrefix );
|
||
|
|
||
|
int value = -1;
|
||
|
sscanf( samplerTypesActualData, "%08x", &value );
|
||
|
|
||
|
newprog->m_pixSamplerTypes = value;
|
||
|
newprog->m_pixProgram->m_samplerTypes = value; // helps GLM maintain a better linked pair cache even when SRGB sampler state changes
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
Assert(!"couldn't find sampler types in pixel shader");
|
||
|
}
|
||
|
}
|
||
|
|
||
|
{
|
||
|
// find the fb outputs used by this shader/combo
|
||
|
const GLenum buffers[] = { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT };
|
||
|
|
||
|
char *fragDataMaskPrefix = "//FRAGDATAMASK-";
|
||
|
|
||
|
char *fragDataMaskStr = strstr( (char *)transbuf.Base(), fragDataMaskPrefix );
|
||
|
if ( fragDataMaskStr )
|
||
|
{
|
||
|
char *fragDataActualData = fragDataMaskStr + strlen( fragDataMaskPrefix );
|
||
|
|
||
|
int value = -1;
|
||
|
sscanf( fragDataActualData, "%04x", &value );
|
||
|
|
||
|
newprog->m_pixFragDataMask = value;
|
||
|
newprog->m_pixProgram->m_fragDataMask = value;
|
||
|
|
||
|
newprog->m_pixProgram->m_numDrawBuffers = 0;
|
||
|
for( int i = 0; i < 4; i++ )
|
||
|
{
|
||
|
if( newprog->m_pixProgram->m_fragDataMask & ( 1 << i ) )
|
||
|
{
|
||
|
newprog->m_pixProgram->m_drawBuffers[ newprog->m_pixProgram->m_numDrawBuffers ] = buffers[ i ];
|
||
|
newprog->m_pixProgram->m_numDrawBuffers++;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if( newprog->m_pixProgram->m_numDrawBuffers == 0 )
|
||
|
{
|
||
|
Assert(!"couldn't find fragment output in pixel shader");
|
||
|
newprog->m_pixProgram->m_drawBuffers[ 0 ] = buffers[ 0 ];
|
||
|
newprog->m_pixProgram->m_numDrawBuffers = 1;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
newprog->m_pixFragDataMask = 0;
|
||
|
newprog->m_pixProgram->m_fragDataMask = 0;
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
*ppShader = newprog;
|
||
|
|
||
|
result = S_OK;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
IDirect3DPixelShader9::~IDirect3DPixelShader9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
GLMPRINTF(( ">-A- ~IDirect3DPixelShader9" ));
|
||
|
|
||
|
if (m_device)
|
||
|
{
|
||
|
m_device->ReleasedPixelShader( this );
|
||
|
|
||
|
if (m_pixProgram)
|
||
|
{
|
||
|
m_pixProgram->m_ctx->DelProgram( m_pixProgram );
|
||
|
m_pixProgram = NULL;
|
||
|
}
|
||
|
m_device = NULL;
|
||
|
}
|
||
|
|
||
|
GLMPRINTF(( "<-A- ~IDirect3DPixelShader9" ));
|
||
|
}
|
||
|
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetPixelShaderNonInline(IDirect3DPixelShader9* pShader)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
|
||
|
m_ctx->SetFragmentProgram( pShader ? pShader->m_pixProgram : NULL );
|
||
|
m_pixelShader = pShader;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetPixelShaderConstantFNonInline(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
TOGL_NULL_DEVICE_CHECK;
|
||
|
#if 0
|
||
|
const uint nRegToWatch = 3;
|
||
|
if ( ( ( StartRegister + Vector4fCount ) > nRegToWatch ) && ( StartRegister <= nRegToWatch ) )
|
||
|
{
|
||
|
GLMDebugPrintf( "-- %f %f %f %f\n", pConstantData[(nRegToWatch - StartRegister)*4+0], pConstantData[(nRegToWatch - StartRegister)*4+1], pConstantData[(nRegToWatch - StartRegister)*4+2], pConstantData[(nRegToWatch - StartRegister)*4+3] );
|
||
|
}
|
||
|
#endif
|
||
|
m_ctx->SetProgramParametersF( kGLMFragmentProgram, StartRegister, (float *)pConstantData, Vector4fCount );
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetPixelShaderConstantB(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
TOGL_NULL_DEVICE_CHECK;
|
||
|
m_ctx->SetProgramParametersB( kGLMFragmentProgram, StartRegister, (int *)pConstantData, BoolCount );
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetPixelShaderConstantI(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
TOGL_NULL_DEVICE_CHECK;
|
||
|
GLMPRINTF(("-X- Ignoring IDirect3DDevice9::SetPixelShaderConstantI call, count was %d", Vector4iCount ));
|
||
|
// m_ctx->SetProgramParametersI( kGLMFragmentProgram, StartRegister, pConstantData, Vector4iCount );
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Vertex Shaders - (IDirect3DDevice9)
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreateVertexShader(CONST DWORD* pFunction, IDirect3DVertexShader9** ppShader, const char *pShaderName, char *pDebugLabel)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
HRESULT result = D3DERR_INVALIDCALL;
|
||
|
*ppShader = NULL;
|
||
|
|
||
|
uint32 nCentroidMask = CentroidMaskFromName( false, pShaderName );
|
||
|
|
||
|
{
|
||
|
int numTranslations = 1;
|
||
|
|
||
|
bool bVertexShader = false;
|
||
|
|
||
|
// we can do one or two translated forms. they go together in a single buffer with some markers to allow GLM to break it up.
|
||
|
// this also lets us mirror each set of translations to disk with a single file making it easier to view and edit side by side.
|
||
|
|
||
|
int maxTranslationSize = 500000; // size of any one translation
|
||
|
|
||
|
CUtlBuffer transbuf( 1000, numTranslations * maxTranslationSize, CUtlBuffer::TEXT_BUFFER );
|
||
|
CUtlBuffer tempbuf( 1000, maxTranslationSize, CUtlBuffer::TEXT_BUFFER );
|
||
|
|
||
|
transbuf.PutString( "//GLSLvp\n" ); // this is required so GLM can crack the text apart
|
||
|
|
||
|
// note the GLSL translator wants its own buffer
|
||
|
tempbuf.EnsureCapacity( maxTranslationSize );
|
||
|
|
||
|
uint glslVertexShaderOptions = D3DToGL_OptionUseEnvParams | D3DToGL_OptionDoFixupZ | D3DToGL_OptionDoFixupY;
|
||
|
|
||
|
if ( m_ctx->Caps().m_hasNativeClipVertexMode )
|
||
|
{
|
||
|
// note the matched trickery over in IDirect3DDevice9::FlushStates -
|
||
|
// if on a chipset that does no have native gl_ClipVertex support, then
|
||
|
// omit writes to gl_ClipVertex, and instead submit plane equations that have been altered,
|
||
|
// and clipping will take place in GL space using gl_Position instead of gl_ClipVertex.
|
||
|
|
||
|
// note that this is very much a hack to mate up with ATI R5xx hardware constraints, and with older
|
||
|
// drivers even for later ATI parts like r6xx/r7xx. And it doesn't work on NV parts, so you really
|
||
|
// do have to choose the right way to go.
|
||
|
|
||
|
glslVertexShaderOptions |= D3DToGL_OptionDoUserClipPlanes;
|
||
|
}
|
||
|
|
||
|
if ( !CommandLine()->CheckParm("-disableboneuniformbuffers") )
|
||
|
{
|
||
|
// If using GLSL, enabling a uniform buffer specifically for bone registers. (Not currently supported with ARB shaders, which are not optimized at all anyway.)
|
||
|
glslVertexShaderOptions |= D3DToGL_OptionGenerateBoneUniformBuffer;
|
||
|
}
|
||
|
|
||
|
g_D3DToOpenGLTranslatorGLSL.TranslateShader( (uint32 *) pFunction, &tempbuf, &bVertexShader, glslVertexShaderOptions, -1, nCentroidMask, pDebugLabel );
|
||
|
|
||
|
transbuf.PutString( (char*)tempbuf.Base() );
|
||
|
transbuf.PutString( "\n\n" ); // whitespace
|
||
|
|
||
|
if ( !bVertexShader )
|
||
|
{
|
||
|
// don't cross the streams
|
||
|
Assert(!"Can't accept pixel shader in CreateVertexShader");
|
||
|
result = D3DERR_INVALIDCALL;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_ObjectStats.m_nTotalVertexShaders++;
|
||
|
|
||
|
IDirect3DVertexShader9 *newprog = new IDirect3DVertexShader9;
|
||
|
|
||
|
newprog->m_device = this;
|
||
|
|
||
|
newprog->m_vtxProgram = m_ctx->NewProgram( kGLMVertexProgram, (char *)transbuf.Base(), pShaderName ? pShaderName : "?" ) ;
|
||
|
newprog->m_vtxProgram->m_nCentroidMask = nCentroidMask;
|
||
|
|
||
|
newprog->m_vtxProgram->m_bTranslatedProgram = true;
|
||
|
newprog->m_vtxProgram->m_maxVertexAttrs = 0;
|
||
|
newprog->m_maxVertexAttrs = 0;
|
||
|
|
||
|
// find the highwater mark..
|
||
|
|
||
|
char *highWaterPrefix = "//HIGHWATER-"; // try to arrange this so it can work with pure GLSL if needed
|
||
|
char *highWaterStr = strstr( (char *)transbuf.Base(), highWaterPrefix );
|
||
|
if (highWaterStr)
|
||
|
{
|
||
|
char *highWaterActualData = highWaterStr + strlen( highWaterPrefix );
|
||
|
|
||
|
int value = -1;
|
||
|
sscanf( highWaterActualData, "%d", &value );
|
||
|
|
||
|
newprog->m_vtxHighWater = value;
|
||
|
newprog->m_vtxProgram->m_descs[kGLMGLSL].m_highWater = value;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
Assert(!"couldn't find highwater mark in vertex shader");
|
||
|
}
|
||
|
|
||
|
char *highWaterBonePrefix = "//HIGHWATERBONE-"; // try to arrange this so it can work with pure GLSL if needed
|
||
|
char *highWaterBoneStr = strstr( (char *)transbuf.Base(), highWaterBonePrefix );
|
||
|
if (highWaterBoneStr)
|
||
|
{
|
||
|
char *highWaterActualData = highWaterBoneStr + strlen( highWaterBonePrefix );
|
||
|
|
||
|
int value = -1;
|
||
|
sscanf( highWaterActualData, "%d", &value );
|
||
|
|
||
|
newprog->m_vtxHighWaterBone = value;
|
||
|
newprog->m_vtxProgram->m_descs[kGLMGLSL].m_VSHighWaterBone = value;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
newprog->m_vtxHighWaterBone = 0;
|
||
|
newprog->m_vtxProgram->m_descs[kGLMGLSL].m_VSHighWaterBone = 0;
|
||
|
}
|
||
|
|
||
|
// find the attrib map..
|
||
|
char *attribMapPrefix = "//ATTRIBMAP-"; // try to arrange this so it can work with pure GLSL if needed
|
||
|
char *attribMapStr = strstr( (char *)transbuf.Base(), attribMapPrefix );
|
||
|
|
||
|
if (attribMapStr)
|
||
|
{
|
||
|
char *attribMapActualData = attribMapStr + strlen( attribMapPrefix );
|
||
|
uint nMaxVertexAttribs = 0;
|
||
|
for( int i=0; i<16; i++)
|
||
|
{
|
||
|
int value = -1;
|
||
|
char *dataItem = attribMapActualData + (i*3);
|
||
|
sscanf( dataItem, "%02x", &value );
|
||
|
if (value >=0)
|
||
|
{
|
||
|
// make sure it's not a terminator
|
||
|
if (value == 0xBB)
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// probably an 'xx'... check
|
||
|
if ( (dataItem[0] != 'x') || (dataItem[1] != 'x') )
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR(); // bad news
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
value = 0xBB; // not likely to see one of these... "fog with usage index 11"
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( value != 0xBB )
|
||
|
nMaxVertexAttribs = i;
|
||
|
|
||
|
newprog->m_vtxAttribMap[i] = value;
|
||
|
}
|
||
|
|
||
|
newprog->m_vtxProgram->m_maxVertexAttrs = nMaxVertexAttribs + 1;
|
||
|
newprog->m_maxVertexAttrs = nMaxVertexAttribs + 1;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR(); // that's bad...
|
||
|
}
|
||
|
|
||
|
*ppShader = newprog;
|
||
|
|
||
|
result = S_OK;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
IDirect3DVertexShader9::~IDirect3DVertexShader9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
GLMPRINTF(( ">-A- ~IDirect3DVertexShader9" ));
|
||
|
|
||
|
if (m_device)
|
||
|
{
|
||
|
m_device->ReleasedVertexShader( this );
|
||
|
|
||
|
if (m_vtxProgram)
|
||
|
{
|
||
|
m_vtxProgram->m_ctx->DelProgram( m_vtxProgram );
|
||
|
m_vtxProgram = NULL;
|
||
|
}
|
||
|
m_device = NULL;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
GLMPRINTF(( "<-A- ~IDirect3DVertexShader9" ));
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetVertexShaderNonInline(IDirect3DVertexShader9* pShader)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
m_ctx->SetVertexProgram( pShader ? pShader->m_vtxProgram : NULL );
|
||
|
m_vertexShader = pShader;
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetVertexShaderConstantFNonInline(UINT StartRegister,CONST float* pConstantData,UINT Vector4fCount) // groups of 4 floats!
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
TOGL_NULL_DEVICE_CHECK;
|
||
|
m_ctx->SetProgramParametersF( kGLMVertexProgram, StartRegister, (float *)pConstantData, Vector4fCount );
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetVertexShaderConstantBNonInline(UINT StartRegister,CONST BOOL* pConstantData,UINT BoolCount) // individual bool count!
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
TOGL_NULL_DEVICE_CHECK;
|
||
|
m_ctx->SetProgramParametersB( kGLMVertexProgram, StartRegister, (int *)pConstantData, BoolCount );
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetVertexShaderConstantINonInline(UINT StartRegister,CONST int* pConstantData,UINT Vector4iCount) // groups of 4 ints!
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
TOGL_NULL_DEVICE_CHECK;
|
||
|
m_ctx->SetProgramParametersI( kGLMVertexProgram, StartRegister, (int *)pConstantData, Vector4iCount );
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Shader Pairs - (IDirect3DDevice9)
|
||
|
|
||
|
#endif
|
||
|
|
||
|
// callers need to ifdef POSIX this, because this method does not exist on real DX9
|
||
|
HRESULT IDirect3DDevice9::LinkShaderPair( IDirect3DVertexShader9* vs, IDirect3DPixelShader9* ps )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
// these are really GLSL "shaders" not "programs" but the old reference to "program" persists due to the assembler heritage
|
||
|
if (vs->m_vtxProgram && ps->m_pixProgram)
|
||
|
{
|
||
|
m_ctx->LinkShaderPair( vs->m_vtxProgram, ps->m_pixProgram );
|
||
|
}
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::ValidateShaderPair( IDirect3DVertexShader9* vs, IDirect3DPixelShader9* ps )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
// these are really GLSL "shaders" not "programs" but the old reference to "program" persists due to the assembler heritage
|
||
|
if (vs->m_vtxProgram && ps->m_pixProgram)
|
||
|
{
|
||
|
m_ctx->ValidateShaderPair( vs->m_vtxProgram, ps->m_pixProgram );
|
||
|
}
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
// callers need to ifdef POSIX this, because this method does not exist on real DX9
|
||
|
//
|
||
|
HRESULT IDirect3DDevice9::QueryShaderPair( int index, GLMShaderPairInfo *infoOut )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
// these are really GLSL "shaders" not "programs" ...
|
||
|
|
||
|
m_ctx->QueryShaderPair( index, infoOut );
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Vertex Buffers and Vertex Declarations - (IDirect3DDevice9)
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreateVertexDeclaration(CONST D3DVERTEXELEMENT9* pVertexElements,IDirect3DVertexDeclaration9** ppDecl)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
*ppDecl = NULL;
|
||
|
|
||
|
// the goal here is to arrive at something which lets us quickly generate GLMVertexSetups.
|
||
|
|
||
|
// the information we don't have, that must be inferred from the decls, is:
|
||
|
// -> how many unique streams (buffers) are used - pure curiosity
|
||
|
// -> what the stride and offset is for each decl. Size you can figure out on the spot, stride requires surveying all the components in each stream first.
|
||
|
// so init an array of per-stream offsets to 0.
|
||
|
// each one is a cursor that gets bumped by decls.
|
||
|
uint streamOffsets[ D3D_MAX_STREAMS ];
|
||
|
uint streamCount = 0;
|
||
|
|
||
|
uint attribMap[16];
|
||
|
uint attribMapIndex = 0;
|
||
|
memset( attribMap, 0xFF, sizeof( attribMap ) );
|
||
|
|
||
|
memset( streamOffsets, 0, sizeof( streamOffsets ) );
|
||
|
|
||
|
m_ObjectStats.m_nTotalVertexDecls++;
|
||
|
|
||
|
IDirect3DVertexDeclaration9 *decl9 = new IDirect3DVertexDeclaration9;
|
||
|
decl9->m_device = this;
|
||
|
|
||
|
decl9->m_elemCount = 0;
|
||
|
|
||
|
for (const D3DVERTEXELEMENT9 *src = pVertexElements; (src->Stream != 0xFF); src++)
|
||
|
{
|
||
|
// element
|
||
|
D3DVERTEXELEMENT9_GL *elem = &decl9->m_elements[ decl9->m_elemCount++ ];
|
||
|
|
||
|
// copy the D3D decl wholesale.
|
||
|
elem->m_dxdecl = *src;
|
||
|
|
||
|
// latch current offset in this stream.
|
||
|
elem->m_gldecl.m_offset = streamOffsets[ elem->m_dxdecl.Stream ];
|
||
|
|
||
|
// figure out size of this attr and move the cursor
|
||
|
// if cursor was on zero, bump the active stream count
|
||
|
|
||
|
if (!streamOffsets[ elem->m_dxdecl.Stream ])
|
||
|
streamCount++;
|
||
|
|
||
|
int bytes = 0;
|
||
|
switch( elem->m_dxdecl.Type )
|
||
|
{
|
||
|
case D3DDECLTYPE_FLOAT1: elem->m_gldecl.m_nCompCount = 1; elem->m_gldecl.m_datatype = GL_FLOAT; elem->m_gldecl.m_normalized=0; bytes = 4; break;
|
||
|
case D3DDECLTYPE_FLOAT2: elem->m_gldecl.m_nCompCount = 2; elem->m_gldecl.m_datatype = GL_FLOAT; elem->m_gldecl.m_normalized=0; bytes = 8; break;
|
||
|
|
||
|
//case D3DVSDT_FLOAT3:
|
||
|
case D3DDECLTYPE_FLOAT3: elem->m_gldecl.m_nCompCount = 3; elem->m_gldecl.m_datatype = GL_FLOAT; elem->m_gldecl.m_normalized=0; bytes = 12; break;
|
||
|
|
||
|
//case D3DVSDT_FLOAT4:
|
||
|
case D3DDECLTYPE_FLOAT4: elem->m_gldecl.m_nCompCount = 4; elem->m_gldecl.m_datatype = GL_FLOAT; elem->m_gldecl.m_normalized=0; bytes = 16; break;
|
||
|
|
||
|
// case D3DVSDT_UBYTE4:
|
||
|
case D3DDECLTYPE_D3DCOLOR:
|
||
|
case D3DDECLTYPE_UBYTE4:
|
||
|
case D3DDECLTYPE_UBYTE4N:
|
||
|
|
||
|
// Force this path since we're on 10.6.2 and can't rely on EXT_vertex_array_bgra
|
||
|
if ( 1 )
|
||
|
{
|
||
|
// pass 4 UB's but we know this is out of order compared to D3DCOLOR data
|
||
|
elem->m_gldecl.m_nCompCount = 4; elem->m_gldecl.m_datatype = GL_UNSIGNED_BYTE;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// pass a GL BGRA color courtesy of http://www.opengl.org/registry/specs/ARB/vertex_array_bgra.txt
|
||
|
elem->m_gldecl.m_nCompCount = GL_BGRA; elem->m_gldecl.m_datatype = GL_UNSIGNED_BYTE;
|
||
|
}
|
||
|
|
||
|
elem->m_gldecl.m_normalized = ( (elem->m_dxdecl.Type == D3DDECLTYPE_D3DCOLOR) ||
|
||
|
(elem->m_dxdecl.Type == D3DDECLTYPE_UBYTE4N) );
|
||
|
|
||
|
bytes = 4;
|
||
|
break;
|
||
|
|
||
|
case D3DDECLTYPE_SHORT2:
|
||
|
// pass 2 US's but we know this is out of order compared to D3DCOLOR data
|
||
|
elem->m_gldecl.m_nCompCount = 2; elem->m_gldecl.m_datatype = GL_SHORT;
|
||
|
|
||
|
elem->m_gldecl.m_normalized = 0;
|
||
|
bytes = 4;
|
||
|
break;
|
||
|
|
||
|
default: DXABSTRACT_BREAK_ON_ERROR(); return D3DERR_INVALIDCALL; break;
|
||
|
|
||
|
/*
|
||
|
typedef enum _D3DDECLTYPE
|
||
|
{
|
||
|
D3DDECLTYPE_FLOAT1 = 0, // 1D float expanded to (value, 0., 0., 1.)
|
||
|
D3DDECLTYPE_FLOAT2 = 1, // 2D float expanded to (value, value, 0., 1.)
|
||
|
D3DDECLTYPE_FLOAT3 = 2, // 3D float expanded to (value, value, value, 1.)
|
||
|
D3DDECLTYPE_FLOAT4 = 3, // 4D float
|
||
|
D3DDECLTYPE_D3DCOLOR = 4, // 4D packed unsigned bytes mapped to 0. to 1. range
|
||
|
// Input is in D3DCOLOR format (ARGB) expanded to (R, G, B, A)
|
||
|
D3DDECLTYPE_UBYTE4 = 5, // 4D unsigned byte
|
||
|
D3DDECLTYPE_SHORT2 = 6, // 2D signed short expanded to (value, value, 0., 1.)
|
||
|
D3DDECLTYPE_SHORT4 = 7, // 4D signed short
|
||
|
|
||
|
// The following types are valid only with vertex shaders >= 2.0
|
||
|
|
||
|
|
||
|
D3DDECLTYPE_UBYTE4N = 8, // Each of 4 bytes is normalized by dividing to 255.0
|
||
|
D3DDECLTYPE_SHORT2N = 9, // 2D signed short normalized (v[0]/32767.0,v[1]/32767.0,0,1)
|
||
|
D3DDECLTYPE_SHORT4N = 10, // 4D signed short normalized (v[0]/32767.0,v[1]/32767.0,v[2]/32767.0,v[3]/32767.0)
|
||
|
D3DDECLTYPE_USHORT2N = 11, // 2D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,0,1)
|
||
|
D3DDECLTYPE_USHORT4N = 12, // 4D unsigned short normalized (v[0]/65535.0,v[1]/65535.0,v[2]/65535.0,v[3]/65535.0)
|
||
|
D3DDECLTYPE_UDEC3 = 13, // 3D unsigned 10 10 10 format expanded to (value, value, value, 1)
|
||
|
D3DDECLTYPE_DEC3N = 14, // 3D signed 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)
|
||
|
D3DDECLTYPE_FLOAT16_2 = 15, // Two 16-bit floating point values, expanded to (value, value, 0, 1)
|
||
|
D3DDECLTYPE_FLOAT16_4 = 16, // Four 16-bit floating point values
|
||
|
D3DDECLTYPE_UNUSED = 17, // When the type field in a decl is unused.
|
||
|
} D3DDECLTYPE;
|
||
|
*/
|
||
|
}
|
||
|
|
||
|
// write the offset and move the cursor
|
||
|
elem->m_gldecl.m_offset = streamOffsets[elem->m_dxdecl.Stream];
|
||
|
streamOffsets[ elem->m_dxdecl.Stream ] += bytes;
|
||
|
|
||
|
// cannot write m_stride yet, so zero it
|
||
|
elem->m_gldecl.m_stride = 0;
|
||
|
|
||
|
elem->m_gldecl.m_pBuffer = NULL; // must be filled in at draw time..
|
||
|
|
||
|
// elem count was already bumped.
|
||
|
|
||
|
// update attrib map
|
||
|
attribMap[ attribMapIndex++ ] = (elem->m_dxdecl.Usage << 4) | (elem->m_dxdecl.UsageIndex);
|
||
|
}
|
||
|
// the loop is done, we now know how many active streams there are, how many atribs are active in the declaration,
|
||
|
// and how big each one is in terms of stride.
|
||
|
|
||
|
// all that is left is to go back and write the strides - the stride comes from the stream offset cursors accumulated earlier.
|
||
|
for( uint j=0; j< decl9->m_elemCount; j++)
|
||
|
{
|
||
|
D3DVERTEXELEMENT9_GL *elem = &decl9->m_elements[ j ];
|
||
|
|
||
|
elem->m_gldecl.m_stride = streamOffsets[ elem->m_dxdecl.Stream ];
|
||
|
}
|
||
|
|
||
|
memset( decl9->m_VertexAttribDescToStreamIndex, 0xFF, sizeof( decl9->m_VertexAttribDescToStreamIndex ) );
|
||
|
D3DVERTEXELEMENT9_GL *pDeclElem = decl9->m_elements;
|
||
|
for( uint j = 0; j < decl9->m_elemCount; j++, pDeclElem++)
|
||
|
{
|
||
|
uint nPackedVertexAttribDesc = ( pDeclElem->m_dxdecl.Usage << 4 ) | pDeclElem->m_dxdecl.UsageIndex;
|
||
|
if ( nPackedVertexAttribDesc == 0xBB )
|
||
|
{
|
||
|
// 0xBB is a reserved packed vertex attrib value - shouldn't encounter in practice
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
decl9->m_VertexAttribDescToStreamIndex[ nPackedVertexAttribDesc ] = j;
|
||
|
}
|
||
|
|
||
|
*ppDecl = decl9;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
IDirect3DVertexDeclaration9::~IDirect3DVertexDeclaration9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
GLMPRINTF(("-A- ~IDirect3DVertexDeclaration9 signpost"));
|
||
|
|
||
|
m_device->ReleasedVertexDeclaration( this );
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetVertexDeclarationNonInline(IDirect3DVertexDeclaration9* pDecl)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
m_pVertDecl = pDecl;
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetFVF(DWORD FVF)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::GetFVF(DWORD* pFVF)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Vertex Buffers and Streams - (IDirect3DDevice9)
|
||
|
|
||
|
#pragma mark ----- Create function moved to be adjacent to other buffer methods
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetStreamSourceNonInline(UINT StreamNumber,IDirect3DVertexBuffer9* pStreamData,UINT OffsetInBytes,UINT Stride)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
Assert( StreamNumber < D3D_MAX_STREAMS );
|
||
|
Assert( ( Stride & 3 ) == 0 ); // we support non-DWORD aligned strides, but on some drivers (like AMD's) perf goes off a cliff
|
||
|
|
||
|
// perfectly legal to see a vertex buffer of NULL get passed in here.
|
||
|
// so we need an array to track these.
|
||
|
// OK, we are being given the stride, we don't need to calc it..
|
||
|
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::SetStreamSource setting stream #%d to D3D buf %p (GL name %d); offset %d, stride %d", StreamNumber, pStreamData, (pStreamData) ? pStreamData->m_vtxBuffer->m_nHandle: -1, OffsetInBytes, Stride));
|
||
|
|
||
|
if ( !pStreamData )
|
||
|
{
|
||
|
OffsetInBytes = 0;
|
||
|
Stride = 0;
|
||
|
|
||
|
m_vtx_buffers[ StreamNumber ] = m_pDummy_vtx_buffer;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// We do not support strides of 0
|
||
|
Assert( Stride > 0 );
|
||
|
m_vtx_buffers[ StreamNumber ] = pStreamData->m_vtxBuffer;
|
||
|
}
|
||
|
|
||
|
m_streams[ StreamNumber ].m_vtxBuffer = pStreamData;
|
||
|
m_streams[ StreamNumber ].m_offset = OffsetInBytes;
|
||
|
m_streams[ StreamNumber ].m_stride = Stride;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Index Buffers - (IDirect3DDevice9)
|
||
|
#pragma mark ----- Creatue function relocated to be adjacent to the rest of the index buffer methods
|
||
|
|
||
|
#endif
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetIndicesNonInline(IDirect3DIndexBuffer9* pIndexData)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
// just latch it.
|
||
|
m_indices.m_idxBuffer = pIndexData;
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Release Handlers - (IDirect3DDevice9)
|
||
|
|
||
|
#endif
|
||
|
|
||
|
void IDirect3DDevice9::ReleasedVertexDeclaration( IDirect3DVertexDeclaration9 *pDecl )
|
||
|
{
|
||
|
m_ctx->ClearCurAttribs();
|
||
|
|
||
|
Assert( m_ObjectStats.m_nTotalVertexDecls >= 1 );
|
||
|
m_ObjectStats.m_nTotalVertexDecls--;
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::ReleasedTexture( IDirect3DBaseTexture9 *baseTex )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
TOGL_NULL_DEVICE_CHECK_RET_VOID;
|
||
|
|
||
|
// see if this texture is referenced in any of the texture units and scrub it if so.
|
||
|
for( int i=0; i< GLM_SAMPLER_COUNT; i++)
|
||
|
{
|
||
|
if (m_textures[i] == baseTex)
|
||
|
{
|
||
|
m_textures[i] = NULL;
|
||
|
m_ctx->SetSamplerTex( i, NULL ); // texture sets go straight through to GLM, no dirty bit
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::ReleasedCGLMTex( CGLMTex *pTex)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
TOGL_NULL_DEVICE_CHECK_RET_VOID;
|
||
|
|
||
|
ScrubFBOMap( pTex );
|
||
|
if ( pTex->m_layout )
|
||
|
{
|
||
|
if ( pTex->m_layout->m_key.m_texFlags & kGLMTexRenderable )
|
||
|
{
|
||
|
Assert( m_ObjectStats.m_nTotalRenderTargets >= 1 );
|
||
|
m_ObjectStats.m_nTotalRenderTargets--;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
void IDirect3DDevice9::ReleasedSurface( IDirect3DSurface9 *pSurface )
|
||
|
{
|
||
|
for( int i = 0; i < 4; i++ )
|
||
|
{
|
||
|
if ( m_pRenderTargets[i] == pSurface )
|
||
|
{
|
||
|
// this was a surprise release... scrub it
|
||
|
m_pRenderTargets[i] = NULL;
|
||
|
m_bFBODirty = true;
|
||
|
GLMPRINTF(( "-A- Scrubbed pSurface %08x from m_pRenderTargets[%d]", pSurface, i ));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if ( m_pDepthStencil == pSurface )
|
||
|
{
|
||
|
m_pDepthStencil = NULL;
|
||
|
m_bFBODirty = true;
|
||
|
GLMPRINTF(( "-A- Scrubbed pSurface %08x from m_pDepthStencil", pSurface ));
|
||
|
}
|
||
|
|
||
|
if ( m_pDefaultColorSurface == pSurface )
|
||
|
{
|
||
|
m_pDefaultColorSurface = NULL;
|
||
|
GLMPRINTF(( "-A- Scrubbed pSurface %08x from m_pDefaultColorSurface", pSurface ));
|
||
|
}
|
||
|
|
||
|
if ( m_pDefaultDepthStencilSurface == pSurface )
|
||
|
{
|
||
|
m_pDefaultDepthStencilSurface = NULL;
|
||
|
GLMPRINTF(( "-A- Scrubbed pSurface %08x from m_pDefaultDepthStencilSurface", pSurface ));
|
||
|
}
|
||
|
|
||
|
Assert( m_ObjectStats.m_nTotalSurfaces >= 1 );
|
||
|
m_ObjectStats.m_nTotalSurfaces--;
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::ReleasedPixelShader( IDirect3DPixelShader9 *pixelShader )
|
||
|
{
|
||
|
if ( m_pixelShader == pixelShader )
|
||
|
{
|
||
|
m_pixelShader = NULL;
|
||
|
GLMPRINTF(( "-A- Scrubbed pixel shader %08x from m_pixelShader", pixelShader ));
|
||
|
}
|
||
|
m_ctx->ReleasedShader();
|
||
|
|
||
|
Assert( m_ObjectStats.m_nTotalPixelShaders >= 1 );
|
||
|
m_ObjectStats.m_nTotalPixelShaders--;
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::ReleasedVertexShader( IDirect3DVertexShader9 *vertexShader )
|
||
|
{
|
||
|
if ( m_vertexShader == vertexShader )
|
||
|
{
|
||
|
m_vertexShader = NULL;
|
||
|
GLMPRINTF(( "-A- Scrubbed vertex shader %08x from m_vertexShader", vertexShader ));
|
||
|
}
|
||
|
m_ctx->ClearCurAttribs();
|
||
|
m_ctx->ReleasedShader();
|
||
|
|
||
|
Assert( m_ObjectStats.m_nTotalVertexShaders >= 1 );
|
||
|
m_ObjectStats.m_nTotalVertexShaders--;
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::ReleasedVertexBuffer( IDirect3DVertexBuffer9 *vertexBuffer )
|
||
|
{
|
||
|
for (int i=0; i< D3D_MAX_STREAMS; i++)
|
||
|
{
|
||
|
if ( m_streams[i].m_vtxBuffer == vertexBuffer )
|
||
|
{
|
||
|
m_streams[i].m_vtxBuffer = NULL;
|
||
|
m_vtx_buffers[i] = m_pDummy_vtx_buffer;
|
||
|
|
||
|
GLMPRINTF(( "-A- Scrubbed vertex buffer %08x from m_streams[%d]", vertexBuffer, i ));
|
||
|
}
|
||
|
}
|
||
|
m_ctx->ClearCurAttribs();
|
||
|
|
||
|
Assert( m_ObjectStats.m_nTotalVertexBuffers >= 1 );
|
||
|
m_ObjectStats.m_nTotalVertexBuffers--;
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::ReleasedIndexBuffer( IDirect3DIndexBuffer9 *indexBuffer )
|
||
|
{
|
||
|
if ( m_indices.m_idxBuffer == indexBuffer )
|
||
|
{
|
||
|
m_indices.m_idxBuffer = NULL;
|
||
|
GLMPRINTF(( "-A- Scrubbed index buffer %08x from m_indices", indexBuffer ));
|
||
|
}
|
||
|
|
||
|
Assert( m_ObjectStats.m_nTotalIndexBuffers >= 1 );
|
||
|
m_ObjectStats.m_nTotalIndexBuffers--;
|
||
|
}
|
||
|
|
||
|
|
||
|
void IDirect3DDevice9::ReleasedQuery( IDirect3DQuery9 *query )
|
||
|
{
|
||
|
Assert( m_ObjectStats.m_nTotalQueries >= 1 );
|
||
|
m_ObjectStats.m_nTotalQueries--;
|
||
|
}
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Queries - (IDirect3DDevice9)
|
||
|
|
||
|
#endif
|
||
|
|
||
|
// note that detection of whether queries are supported is done by trying to create one.
|
||
|
// so for GL, be observant here of whether we have that capability or not.
|
||
|
// pretty much have this everywhere but i950.
|
||
|
|
||
|
HRESULT IDirect3DDevice9::CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9** ppQuery)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
if (m_ctx->Caps().m_hasOcclusionQuery)
|
||
|
{
|
||
|
m_ObjectStats.m_nTotalQueries++;
|
||
|
|
||
|
IDirect3DQuery9 *newquery = new IDirect3DQuery9;
|
||
|
|
||
|
newquery->m_device = this;
|
||
|
|
||
|
newquery->m_type = Type;
|
||
|
newquery->m_ctx = m_ctx;
|
||
|
newquery->m_nIssueStartThreadID = 0;
|
||
|
newquery->m_nIssueEndThreadID = 0;
|
||
|
newquery->m_nIssueStartDrawCallIndex = 0;
|
||
|
newquery->m_nIssueEndDrawCallIndex = 0;
|
||
|
|
||
|
GLMQueryParams params;
|
||
|
memset( ¶ms, 0, sizeof(params) );
|
||
|
|
||
|
//bool known = false;
|
||
|
switch(newquery->m_type)
|
||
|
{
|
||
|
case D3DQUERYTYPE_OCCLUSION: /* D3DISSUE_BEGIN, D3DISSUE_END */
|
||
|
// create an occlusion query
|
||
|
params.m_type = EOcclusion;
|
||
|
break;
|
||
|
|
||
|
case D3DQUERYTYPE_EVENT: /* D3DISSUE_END */
|
||
|
params.m_type = EFence;
|
||
|
break;
|
||
|
|
||
|
case D3DQUERYTYPE_RESOURCEMANAGER: /* D3DISSUE_END */
|
||
|
case D3DQUERYTYPE_TIMESTAMP: /* D3DISSUE_END */
|
||
|
case D3DQUERYTYPE_TIMESTAMPFREQ: /* D3DISSUE_END */
|
||
|
case D3DQUERYTYPE_INTERFACETIMINGS: /* D3DISSUE_BEGIN, D3DISSUE_END */
|
||
|
case D3DQUERYTYPE_PIXELTIMINGS: /* D3DISSUE_BEGIN, D3DISSUE_END */
|
||
|
case D3DQUERYTYPE_CACHEUTILIZATION: /* D3DISSUE_BEGIN, D3DISSUE_END */
|
||
|
Assert( !"Un-implemented query type" );
|
||
|
break;
|
||
|
|
||
|
default:
|
||
|
Assert( !"Unknown query type" );
|
||
|
break;
|
||
|
}
|
||
|
newquery->m_query = m_ctx->NewQuery( ¶ms );
|
||
|
|
||
|
*ppQuery = newquery;
|
||
|
return S_OK;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
*ppQuery = NULL;
|
||
|
return -1; // failed
|
||
|
}
|
||
|
|
||
|
}
|
||
|
|
||
|
IDirect3DQuery9::~IDirect3DQuery9()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( m_device );
|
||
|
GLMPRINTF((">-A- ~IDirect3DQuery9"));
|
||
|
|
||
|
if (m_device)
|
||
|
{
|
||
|
m_device->ReleasedQuery( this );
|
||
|
|
||
|
if (m_query)
|
||
|
{
|
||
|
GLMPRINTF((">-A- ~IDirect3DQuery9 freeing m_query"));
|
||
|
|
||
|
m_query->m_ctx->DelQuery( m_query );
|
||
|
m_query = NULL;
|
||
|
|
||
|
GLMPRINTF(("<-A- ~IDirect3DQuery9 freeing m_query done"));
|
||
|
}
|
||
|
m_device = NULL;
|
||
|
}
|
||
|
|
||
|
GLMPRINTF(("<-A- ~IDirect3DQuery9"));
|
||
|
}
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Render States - (IDirect3DDevice9)
|
||
|
|
||
|
#endif
|
||
|
|
||
|
#define D3DRS_VALUE_LIMIT 210
|
||
|
|
||
|
struct D3D_RSINFO
|
||
|
{
|
||
|
int m_class;
|
||
|
D3DRENDERSTATETYPE m_state;
|
||
|
DWORD m_defval;
|
||
|
// m_class runs 0-3.
|
||
|
// 3 = must implement - fully general - "obey"
|
||
|
// 2 = implement setup to the default value (it has a GL effect but does not change later) "obey once"
|
||
|
// 1 = "fake implement" setup to the default value no GL effect, debug break if anything but default value comes through - "ignore"
|
||
|
// 0 = game never ever sets this one, break if someone even tries. "complain"
|
||
|
};
|
||
|
|
||
|
D3D_RSINFO g_D3DRS_INFO_unpacked[ D3DRS_VALUE_LIMIT+1 ];
|
||
|
|
||
|
#ifdef D3D_RSI
|
||
|
#error macro collision... rename this
|
||
|
#else
|
||
|
#define D3D_RSI(nclass,nstate,ndefval) { nclass, nstate, ndefval }
|
||
|
#endif
|
||
|
|
||
|
// FP conversions to hex courtesy of http://babbage.cs.qc.cuny.edu/IEEE-754/Decimal.html
|
||
|
#define CONST_DZERO 0x00000000
|
||
|
#define CONST_DONE 0x3F800000
|
||
|
#define CONST_D64 0x42800000
|
||
|
#define DONT_KNOW_YET 0x31415926
|
||
|
|
||
|
|
||
|
// see http://www.toymaker.info/Games/html/render_states.html
|
||
|
|
||
|
D3D_RSINFO g_D3DRS_INFO_packed[] =
|
||
|
{
|
||
|
// these do not have to be in any particular order. they get unpacked into the empty array above for direct indexing.
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_ZENABLE, DONT_KNOW_YET ), // enable Z test (or W buffering)
|
||
|
D3D_RSI( 3, D3DRS_ZWRITEENABLE, DONT_KNOW_YET ), // enable Z write
|
||
|
D3D_RSI( 3, D3DRS_ZFUNC, DONT_KNOW_YET ), // select Z func
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_COLORWRITEENABLE, TRUE ), // see transitiontable.cpp "APPLY_RENDER_STATE_FUNC( D3DRS_COLORWRITEENABLE, ColorWriteEnable )"
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_CULLMODE, D3DCULL_CCW ), // backface cull control
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_ALPHABLENDENABLE, DONT_KNOW_YET ), // ->CTransitionTable::ApplySeparateAlphaBlend and ApplyAlphaBlend
|
||
|
D3D_RSI( 3, D3DRS_BLENDOP, D3DBLENDOP_ADD ),
|
||
|
D3D_RSI( 3, D3DRS_SRCBLEND, DONT_KNOW_YET ),
|
||
|
D3D_RSI( 3, D3DRS_DESTBLEND, DONT_KNOW_YET ),
|
||
|
|
||
|
D3D_RSI( 1, D3DRS_SEPARATEALPHABLENDENABLE, FALSE ), // hit in CTransitionTable::ApplySeparateAlphaBlend
|
||
|
D3D_RSI( 1, D3DRS_SRCBLENDALPHA, D3DBLEND_ONE ), // going to demote these to class 1 until I figure out if they are implementable
|
||
|
D3D_RSI( 1, D3DRS_DESTBLENDALPHA, D3DBLEND_ZERO ),
|
||
|
D3D_RSI( 1, D3DRS_BLENDOPALPHA, D3DBLENDOP_ADD ),
|
||
|
|
||
|
// what is the deal with alpha test... looks like it is inited to off.
|
||
|
D3D_RSI( 3, D3DRS_ALPHATESTENABLE, 0 ),
|
||
|
D3D_RSI( 3, D3DRS_ALPHAREF, 0 ),
|
||
|
D3D_RSI( 3, D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL ),
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_STENCILENABLE, FALSE ),
|
||
|
D3D_RSI( 3, D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP ),
|
||
|
D3D_RSI( 3, D3DRS_STENCILZFAIL, D3DSTENCILOP_KEEP ),
|
||
|
D3D_RSI( 3, D3DRS_STENCILPASS, D3DSTENCILOP_KEEP ),
|
||
|
D3D_RSI( 3, D3DRS_STENCILFUNC, D3DCMP_ALWAYS ),
|
||
|
D3D_RSI( 3, D3DRS_STENCILREF, 0 ),
|
||
|
D3D_RSI( 3, D3DRS_STENCILMASK, 0xFFFFFFFF ),
|
||
|
D3D_RSI( 3, D3DRS_STENCILWRITEMASK, 0xFFFFFFFF ),
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_TWOSIDEDSTENCILMODE, FALSE ),
|
||
|
D3D_RSI( 3, D3DRS_CCW_STENCILFAIL, D3DSTENCILOP_KEEP ),
|
||
|
D3D_RSI( 3, D3DRS_CCW_STENCILZFAIL, D3DSTENCILOP_KEEP ),
|
||
|
D3D_RSI( 3, D3DRS_CCW_STENCILPASS, D3DSTENCILOP_KEEP ),
|
||
|
D3D_RSI( 3, D3DRS_CCW_STENCILFUNC, D3DCMP_ALWAYS ),
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_FOGENABLE, FALSE ), // see CShaderAPIDx8::FogMode and friends - be ready to do the ARB fog linear option madness
|
||
|
D3D_RSI( 3, D3DRS_FOGCOLOR, 0 ),
|
||
|
D3D_RSI( 3, D3DRS_FOGTABLEMODE, D3DFOG_NONE ),
|
||
|
D3D_RSI( 3, D3DRS_FOGSTART, CONST_DZERO ),
|
||
|
D3D_RSI( 3, D3DRS_FOGEND, CONST_DONE ),
|
||
|
D3D_RSI( 3, D3DRS_FOGDENSITY, CONST_DZERO ),
|
||
|
D3D_RSI( 3, D3DRS_RANGEFOGENABLE, FALSE ),
|
||
|
D3D_RSI( 3, D3DRS_FOGVERTEXMODE, D3DFOG_NONE ), // watch out for CShaderAPIDx8::CommitPerPassFogMode....
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_MULTISAMPLEANTIALIAS, TRUE ),
|
||
|
D3D_RSI( 3, D3DRS_MULTISAMPLEMASK, 0xFFFFFFFF ),
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_SCISSORTESTENABLE, FALSE ), // heed IDirect3DDevice9::SetScissorRect
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_DEPTHBIAS, CONST_DZERO ),
|
||
|
D3D_RSI( 3, D3DRS_SLOPESCALEDEPTHBIAS, CONST_DZERO ),
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_COLORWRITEENABLE1, 0x0000000f ),
|
||
|
D3D_RSI( 3, D3DRS_COLORWRITEENABLE2, 0x0000000f ),
|
||
|
D3D_RSI( 3, D3DRS_COLORWRITEENABLE3, 0x0000000f ),
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_SRGBWRITEENABLE, 0 ), // heeded but ignored..
|
||
|
|
||
|
D3D_RSI( 2, D3DRS_CLIPPING, TRUE ), // um, yeah, clipping is enabled (?)
|
||
|
D3D_RSI( 3, D3DRS_CLIPPLANEENABLE, 0 ), // mask 1<<n of active user clip planes.
|
||
|
|
||
|
D3D_RSI( 0, D3DRS_LIGHTING, 0 ), // strange, someone turns it on then off again. move to class 0 and just ignore it (lie)?
|
||
|
|
||
|
D3D_RSI( 3, D3DRS_FILLMODE, D3DFILL_SOLID ),
|
||
|
|
||
|
D3D_RSI( 1, D3DRS_SHADEMODE, D3DSHADE_GOURAUD ),
|
||
|
D3D_RSI( 1, D3DRS_LASTPIXEL, TRUE ),
|
||
|
D3D_RSI( 1, D3DRS_DITHERENABLE, 0 ), //set to false by game, no one sets it to true
|
||
|
D3D_RSI( 1, D3DRS_SPECULARENABLE, FALSE ),
|
||
|
D3D_RSI( 1, D3DRS_TEXTUREFACTOR, 0xFFFFFFFF ), // watch out for CShaderAPIDx8::Color3f et al.
|
||
|
D3D_RSI( 1, D3DRS_WRAP0, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP1, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP2, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP3, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP4, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP5, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP6, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP7, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_AMBIENT, 0 ), // FF lighting, no
|
||
|
D3D_RSI( 1, D3DRS_COLORVERTEX, TRUE ), // FF lighing again
|
||
|
D3D_RSI( 1, D3DRS_LOCALVIEWER, TRUE ), // FF lighting
|
||
|
D3D_RSI( 1, D3DRS_NORMALIZENORMALS, FALSE ), // FF mode I think. CShaderAPIDx8::SetVertexBlendState says it might switch this on when skinning is in play
|
||
|
D3D_RSI( 1, D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL ), // hit only in CShaderAPIDx8::ResetRenderState
|
||
|
D3D_RSI( 1, D3DRS_SPECULARMATERIALSOURCE, D3DMCS_COLOR2 ),
|
||
|
D3D_RSI( 1, D3DRS_AMBIENTMATERIALSOURCE, D3DMCS_MATERIAL ),
|
||
|
D3D_RSI( 1, D3DRS_EMISSIVEMATERIALSOURCE, D3DMCS_MATERIAL ),
|
||
|
D3D_RSI( 1, D3DRS_VERTEXBLEND, D3DVBF_DISABLE ), // also being set by CShaderAPIDx8::SetVertexBlendState, so might be FF
|
||
|
D3D_RSI( 1, D3DRS_POINTSIZE, CONST_DONE ),
|
||
|
D3D_RSI( 1, D3DRS_POINTSIZE_MIN, CONST_DONE ),
|
||
|
D3D_RSI( 1, D3DRS_POINTSPRITEENABLE, FALSE ),
|
||
|
D3D_RSI( 1, D3DRS_POINTSCALEENABLE, FALSE ),
|
||
|
D3D_RSI( 1, D3DRS_POINTSCALE_A, CONST_DONE ),
|
||
|
D3D_RSI( 1, D3DRS_POINTSCALE_B, CONST_DZERO ),
|
||
|
D3D_RSI( 1, D3DRS_POINTSCALE_C, CONST_DZERO ),
|
||
|
D3D_RSI( 1, D3DRS_PATCHEDGESTYLE, D3DPATCHEDGE_DISCRETE ),
|
||
|
D3D_RSI( 1, D3DRS_DEBUGMONITORTOKEN, D3DDMT_ENABLE ),
|
||
|
D3D_RSI( 1, D3DRS_POINTSIZE_MAX, CONST_D64 ),
|
||
|
D3D_RSI( 1, D3DRS_INDEXEDVERTEXBLENDENABLE, FALSE ),
|
||
|
D3D_RSI( 1, D3DRS_TWEENFACTOR, CONST_DZERO ),
|
||
|
D3D_RSI( 1, D3DRS_POSITIONDEGREE, D3DDEGREE_CUBIC ),
|
||
|
D3D_RSI( 1, D3DRS_NORMALDEGREE, D3DDEGREE_LINEAR ),
|
||
|
D3D_RSI( 1, D3DRS_ANTIALIASEDLINEENABLE, FALSE ), // just ignore it
|
||
|
D3D_RSI( 1, D3DRS_MINTESSELLATIONLEVEL, CONST_DONE ),
|
||
|
D3D_RSI( 1, D3DRS_MAXTESSELLATIONLEVEL, CONST_DONE ),
|
||
|
D3D_RSI( 1, D3DRS_ADAPTIVETESS_X, CONST_DZERO ),
|
||
|
D3D_RSI( 1, D3DRS_ADAPTIVETESS_Y, CONST_DZERO ), // Overridden as Alpha-to-coverage contrl
|
||
|
D3D_RSI( 1, D3DRS_ADAPTIVETESS_Z, CONST_DONE ),
|
||
|
D3D_RSI( 1, D3DRS_ADAPTIVETESS_W, CONST_DZERO ),
|
||
|
D3D_RSI( 1, D3DRS_ENABLEADAPTIVETESSELLATION, FALSE ),
|
||
|
D3D_RSI( 1, D3DRS_BLENDFACTOR, 0xffffffff ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP8, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP9, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP10, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP11, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP12, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP13, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP14, 0 ),
|
||
|
D3D_RSI( 1, D3DRS_WRAP15, 0 ),
|
||
|
D3D_RSI( -1, (D3DRENDERSTATETYPE)0, 0 ) // terminator
|
||
|
};
|
||
|
|
||
|
void UnpackD3DRSITable( void )
|
||
|
{
|
||
|
memset (g_D3DRS_INFO_unpacked, 0, sizeof(g_D3DRS_INFO_unpacked) );
|
||
|
|
||
|
for( D3D_RSINFO *packed = g_D3DRS_INFO_packed; packed->m_class >= 0; packed++ )
|
||
|
{
|
||
|
if ( (packed->m_state <0) || (packed->m_state >= D3DRS_VALUE_LIMIT) )
|
||
|
{
|
||
|
// bad
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
// dispatch it to the unpacked array
|
||
|
g_D3DRS_INFO_unpacked[ packed->m_state ] = *packed;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// convenience functions
|
||
|
|
||
|
#ifdef OSX
|
||
|
|
||
|
#pragma mark ----- Sampler States - (IDirect3DDevice9)
|
||
|
|
||
|
#endif
|
||
|
|
||
|
void IDirect3DDevice9::FlushClipPlaneEquation()
|
||
|
{
|
||
|
for( int x=0; x<kGLMUserClipPlanes; x++)
|
||
|
{
|
||
|
GLClipPlaneEquation_t temp1; // Antonio's way
|
||
|
GLClipPlaneEquation_t temp2; // our way
|
||
|
|
||
|
// if we don't have native clip vertex support. then munge the plane coeffs
|
||
|
// this should engage on ALL ATI PARTS < 10.6.4
|
||
|
// and should continue to engage on R5xx forever.
|
||
|
|
||
|
if ( !m_ctx->Caps().m_hasNativeClipVertexMode )
|
||
|
{
|
||
|
// hacked coeffs = { src->x, -src->y, 0.5f * src->z, src->w + (0.5f * src->z) };
|
||
|
// Antonio's trick - so we can use gl_Position as the clippee, not gl_ClipVertex.
|
||
|
|
||
|
GLClipPlaneEquation_t *equ = &gl.m_ClipPlaneEquation[x];
|
||
|
|
||
|
///////////////// temp1
|
||
|
temp1.x = equ->x;
|
||
|
temp1.y = equ->y * -1.0;
|
||
|
temp1.z = equ->z * 0.5;
|
||
|
temp1.w = equ->w + (equ->z * 0.5);
|
||
|
|
||
|
|
||
|
//////////////// temp2
|
||
|
VMatrix mat1( 1, 0, 0, 0,
|
||
|
0, -1, 0, 0,
|
||
|
0, 0, 2, -1,
|
||
|
0, 0, 0, 1
|
||
|
);
|
||
|
//mat1 = mat1.Transpose();
|
||
|
|
||
|
VMatrix mat2;
|
||
|
bool success = mat1.InverseGeneral( mat2 );
|
||
|
|
||
|
if (success)
|
||
|
{
|
||
|
VMatrix mat3;
|
||
|
mat3 = mat2.Transpose();
|
||
|
|
||
|
VPlane origPlane( Vector( equ->x, equ->y, equ->z ), equ->w );
|
||
|
VPlane newPlane;
|
||
|
|
||
|
newPlane = mat3 * origPlane /* * mat3 */;
|
||
|
|
||
|
VPlane finalPlane = newPlane;
|
||
|
|
||
|
temp2.x = newPlane.m_Normal.x;
|
||
|
temp2.y = newPlane.m_Normal.y;
|
||
|
temp2.z = newPlane.m_Normal.z;
|
||
|
temp2.w = newPlane.m_Dist;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
temp2.x = 0;
|
||
|
temp2.y = 0;
|
||
|
temp2.z = 0;
|
||
|
temp2.w = 0;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
temp1 = temp2 = gl.m_ClipPlaneEquation[x];
|
||
|
}
|
||
|
|
||
|
if (1) //GLMKnob("caps-key",NULL)==0.0)
|
||
|
{
|
||
|
m_ctx->WriteClipPlaneEquation( &temp1, x ); // no caps lock = Antonio or classic
|
||
|
|
||
|
/*
|
||
|
if (x<1)
|
||
|
{
|
||
|
GLMPRINTF(( " plane %d √vers1[ %5.2f %5.2f %5.2f %5.2f ] vers2[ %5.2f %5.2f %5.2f %5.2f ]",
|
||
|
x,
|
||
|
temp1.x,temp1.y,temp1.z,temp1.w,
|
||
|
temp2.x,temp2.y,temp2.z,temp2.w
|
||
|
));
|
||
|
}
|
||
|
*/
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
m_ctx->WriteClipPlaneEquation( &temp2, x ); // caps = our way or classic
|
||
|
|
||
|
/*
|
||
|
if (x<1)
|
||
|
{
|
||
|
GLMPRINTF(( " plane %d vers1[ %5.2f %5.2f %5.2f %5.2f ] √vers2[ %5.2f %5.2f %5.2f %5.2f ]",
|
||
|
x,
|
||
|
temp1.x,temp1.y,temp1.z,temp1.w,
|
||
|
temp2.x,temp2.y,temp2.z,temp2.w
|
||
|
));
|
||
|
}
|
||
|
*/
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::InitStates()
|
||
|
{
|
||
|
m_ctx->m_AlphaTestEnable.Read( &gl.m_AlphaTestEnable, 0 );
|
||
|
m_ctx->m_AlphaTestFunc.Read( &gl.m_AlphaTestFunc, 0 );
|
||
|
m_ctx->m_CullFaceEnable.Read( &gl.m_CullFaceEnable, 0 );
|
||
|
m_ctx->m_DepthBias.Read( &gl.m_DepthBias, 0 );
|
||
|
m_ctx->m_ScissorEnable.Read( &gl.m_ScissorEnable, 0 );
|
||
|
m_ctx->m_ScissorBox.Read( &gl.m_ScissorBox, 0 );
|
||
|
m_ctx->m_ViewportBox.Read( &gl.m_ViewportBox, 0 );
|
||
|
m_ctx->m_ViewportDepthRange.Read( &gl.m_ViewportDepthRange, 0 );
|
||
|
|
||
|
for( int x=0; x<kGLMUserClipPlanes; x++)
|
||
|
m_ctx->m_ClipPlaneEnable.ReadIndex( &gl.m_ClipPlaneEnable[x], x, 0 );
|
||
|
|
||
|
m_ctx->m_PolygonMode.Read( &gl.m_PolygonMode, 0 );
|
||
|
m_ctx->m_CullFrontFace.Read( &gl.m_CullFrontFace, 0 );
|
||
|
m_ctx->m_AlphaToCoverageEnable.Read( &gl.m_AlphaToCoverageEnable, 0 );
|
||
|
m_ctx->m_BlendEquation.Read( &gl.m_BlendEquation, 0 );
|
||
|
m_ctx->m_BlendColor.Read( &gl.m_BlendColor, 0 );
|
||
|
|
||
|
for( int x=0; x<kGLMUserClipPlanes; x++)
|
||
|
m_ctx->m_ClipPlaneEquation.ReadIndex( &gl.m_ClipPlaneEquation[x], x, 0 );
|
||
|
|
||
|
m_ctx->m_ColorMaskSingle.Read( &gl.m_ColorMaskSingle, 0 );
|
||
|
|
||
|
m_ctx->m_BlendEnable.Read( &gl.m_BlendEnable, 0 );
|
||
|
m_ctx->m_BlendFactor.Read( &gl.m_BlendFactor, 0 );
|
||
|
m_ctx->m_BlendEnableSRGB.Read( &gl.m_BlendEnableSRGB, 0 );
|
||
|
m_ctx->m_DepthTestEnable.Read( &gl.m_DepthTestEnable, 0 );
|
||
|
m_ctx->m_DepthFunc.Read( &gl.m_DepthFunc, 0 );
|
||
|
m_ctx->m_DepthMask.Read( &gl.m_DepthMask, 0 );
|
||
|
m_ctx->m_StencilTestEnable.Read( &gl.m_StencilTestEnable, 0 );
|
||
|
m_ctx->m_StencilFunc.Read( &gl.m_StencilFunc, 0 );
|
||
|
|
||
|
m_ctx->m_StencilOp.ReadIndex( &gl.m_StencilOp, 0, 0 );
|
||
|
m_ctx->m_StencilOp.ReadIndex( &gl.m_StencilOp, 1, 0 );
|
||
|
|
||
|
m_ctx->m_StencilWriteMask.Read( &gl.m_StencilWriteMask, 0 );
|
||
|
m_ctx->m_ClearColor.Read( &gl.m_ClearColor, 0 );
|
||
|
m_ctx->m_ClearDepth.Read( &gl.m_ClearDepth, 0 );
|
||
|
m_ctx->m_ClearStencil.Read( &gl.m_ClearStencil, 0 );
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::FullFlushStates()
|
||
|
{
|
||
|
m_ctx->WriteAlphaTestEnable( &gl.m_AlphaTestEnable );
|
||
|
m_ctx->WriteAlphaTestFunc( &gl.m_AlphaTestFunc );
|
||
|
m_ctx->WriteCullFaceEnable( &gl.m_CullFaceEnable );
|
||
|
m_ctx->WriteDepthBias( &gl.m_DepthBias );
|
||
|
m_ctx->WriteScissorEnable( &gl.m_ScissorEnable );
|
||
|
m_ctx->WriteScissorBox( &gl.m_ScissorBox );
|
||
|
m_ctx->WriteViewportBox( &gl.m_ViewportBox );
|
||
|
m_ctx->WriteViewportDepthRange( &gl.m_ViewportDepthRange );
|
||
|
|
||
|
for( int x=0; x<kGLMUserClipPlanes; x++)
|
||
|
m_ctx->WriteClipPlaneEnable( &gl.m_ClipPlaneEnable[x], x );
|
||
|
|
||
|
m_ctx->WritePolygonMode( &gl.m_PolygonMode );
|
||
|
m_ctx->WriteCullFrontFace( &gl.m_CullFrontFace );
|
||
|
m_ctx->WriteAlphaToCoverageEnable( &gl.m_AlphaToCoverageEnable );
|
||
|
m_ctx->WriteBlendEquation( &gl.m_BlendEquation );
|
||
|
m_ctx->WriteBlendColor( &gl.m_BlendColor );
|
||
|
FlushClipPlaneEquation();
|
||
|
m_ctx->WriteColorMaskSingle( &gl.m_ColorMaskSingle );
|
||
|
|
||
|
m_ctx->WriteBlendEnable( &gl.m_BlendEnable );
|
||
|
m_ctx->WriteBlendFactor( &gl.m_BlendFactor );
|
||
|
m_ctx->WriteBlendEnableSRGB( &gl.m_BlendEnableSRGB );
|
||
|
m_ctx->WriteDepthTestEnable( &gl.m_DepthTestEnable );
|
||
|
m_ctx->WriteDepthFunc( &gl.m_DepthFunc );
|
||
|
m_ctx->WriteDepthMask( &gl.m_DepthMask );
|
||
|
m_ctx->WriteStencilTestEnable( &gl.m_StencilTestEnable );
|
||
|
m_ctx->WriteStencilFunc( &gl.m_StencilFunc );
|
||
|
|
||
|
m_ctx->WriteStencilOp( &gl.m_StencilOp,0 );
|
||
|
m_ctx->WriteStencilOp( &gl.m_StencilOp,1 ); // ********* need to recheck this
|
||
|
|
||
|
m_ctx->WriteStencilWriteMask( &gl.m_StencilWriteMask );
|
||
|
m_ctx->WriteClearColor( &gl.m_ClearColor );
|
||
|
m_ctx->WriteClearDepth( &gl.m_ClearDepth );
|
||
|
m_ctx->WriteClearStencil( &gl.m_ClearStencil );
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
// 7LS - TODO
|
||
|
#ifndef DX_TO_GL_ABSTRACTION
|
||
|
HRESULT IDirect3DDevice9::DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCountx,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride)
|
||
|
{
|
||
|
// 7LS
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
// Type
|
||
|
// [in] Member of the D3DPRIMITIVETYPE enumerated type, describing the type of primitive to render. D3DPT_POINTLIST is not supported with this method. See Remarks.
|
||
|
|
||
|
// BaseVertexIndex
|
||
|
// [in] Offset from the start of the vertex buffer to the first vertex. See Scenario 4.
|
||
|
|
||
|
// MinIndex
|
||
|
// [in] Minimum vertex index for vertices used during this call. This is a zero based index relative to BaseVertexIndex.
|
||
|
|
||
|
// NumVertices
|
||
|
// [in] Number of vertices used during this call. The first vertex is located at index: BaseVertexIndex + MinIndex.
|
||
|
|
||
|
// StartIndex
|
||
|
// [in] Index of the first index to use when accessing the index buffer.
|
||
|
|
||
|
// PrimitiveCount
|
||
|
// [in] Number of primitives to render. The number of vertices used is a function of the primitive count and the primitive type. The maximum number of primitives allowed is determined by checking the MaxPrimitiveCount member of the D3DCAPS9 structure.
|
||
|
|
||
|
// BE VERY CAREFUL what you do in this function. It's extremely hot, and calling the wrong GL API's in here will crush perf. on NVidia threaded drivers.
|
||
|
#ifndef OSX
|
||
|
|
||
|
HRESULT IDirect3DDevice9::DrawIndexedPrimitive( D3DPRIMITIVETYPE Type, INT BaseVertexIndex, UINT MinVertexIndex, UINT NumVertices, UINT startIndex, UINT primCount )
|
||
|
{
|
||
|
tmZone( TELEMETRY_LEVEL2, TMZF_NONE, "%s", __FUNCTION__ );
|
||
|
Assert( m_ctx->m_nCurOwnerThreadId == ThreadGetCurrentId() );
|
||
|
|
||
|
TOGL_NULL_DEVICE_CHECK;
|
||
|
if ( m_bFBODirty )
|
||
|
{
|
||
|
UpdateBoundFBO();
|
||
|
}
|
||
|
|
||
|
g_nTotalDrawsOrClears++;
|
||
|
|
||
|
#if GL_BATCH_PERF_ANALYSIS
|
||
|
m_nTotalPrims += primCount;
|
||
|
CFastTimer tm;
|
||
|
CFlushDrawStatesStats& flushStats = m_ctx->m_FlushStats;
|
||
|
tm.Start();
|
||
|
flushStats.Clear();
|
||
|
#endif
|
||
|
|
||
|
#if GLMDEBUG
|
||
|
if ( gl.m_FogEnable )
|
||
|
{
|
||
|
GLMPRINTF(("-D- IDirect3DDevice9::DrawIndexedPrimitive is seeing enabled fog..."));
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
if ( ( !m_indices.m_idxBuffer ) || ( !m_vertexShader ) )
|
||
|
goto draw_failed;
|
||
|
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
|
||
|
m_ctx->FlushDrawStates( MinVertexIndex, MinVertexIndex + NumVertices - 1, BaseVertexIndex );
|
||
|
|
||
|
{
|
||
|
#if !GL_TELEMETRY_ZONES && GL_BATCH_TELEMETRY_ZONES
|
||
|
tmZone( TELEMETRY_LEVEL2, TMZF_NONE, "glDrawRangeElements %u", primCount );
|
||
|
#endif
|
||
|
Assert( ( D3DPT_LINELIST == 2 ) && ( D3DPT_TRIANGLELIST == 4 ) && ( D3DPT_TRIANGLESTRIP == 5 ) );
|
||
|
|
||
|
static const struct prim_t
|
||
|
{
|
||
|
GLenum m_nType;
|
||
|
uint m_nPrimMul;
|
||
|
uint m_nPrimAdd;
|
||
|
} s_primTypes[6] =
|
||
|
{
|
||
|
{ 0, 0, 0 }, // 0
|
||
|
{ 0, 0, 0 }, // 1
|
||
|
{ GL_LINES, 2, 0 }, // 2 D3DPT_LINELIST
|
||
|
{ 0, 0, 0 }, // 3
|
||
|
{ GL_TRIANGLES, 3, 0 }, // 4 D3DPT_TRIANGLELIST
|
||
|
{ GL_TRIANGLE_STRIP, 1, 2 } // 5 D3DPT_TRIANGLESTRIP
|
||
|
};
|
||
|
|
||
|
if ( Type <= D3DPT_TRIANGLESTRIP )
|
||
|
{
|
||
|
const prim_t& p = s_primTypes[Type];
|
||
|
Assert( p.m_nType );
|
||
|
Assert( NumVertices >= 1 );
|
||
|
|
||
|
m_ctx->DrawRangeElements( p.m_nType, (GLuint)MinVertexIndex, (GLuint)( MinVertexIndex + NumVertices - 1 ), (GLsizei)p.m_nPrimAdd + primCount * p.m_nPrimMul, (GLenum)GL_UNSIGNED_SHORT, (const GLvoid *)( startIndex * sizeof(short) ), BaseVertexIndex, m_indices.m_idxBuffer->m_idxBuffer );
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#if GL_BATCH_PERF_ANALYSIS
|
||
|
if ( s_rdtsc_to_ms == 0.0f )
|
||
|
{
|
||
|
TmU64 t0 = Plat_Rdtsc();
|
||
|
double d0 = Plat_FloatTime();
|
||
|
|
||
|
ThreadSleep( 1000 );
|
||
|
|
||
|
TmU64 t1 = Plat_Rdtsc();
|
||
|
double d1 = Plat_FloatTime();
|
||
|
|
||
|
s_rdtsc_to_ms = ( 1000.0f * ( d1 - d0 ) ) / ( t1 - t0 );
|
||
|
}
|
||
|
|
||
|
#if GL_BATCH_PERF_ANALYSIS_WRITE_PNGS
|
||
|
if ( m_pBatch_vis_bitmap && m_pBatch_vis_bitmap->is_valid() )
|
||
|
{
|
||
|
double t = tm.GetDurationInProgress().GetMillisecondsF();
|
||
|
|
||
|
uint h = 1;
|
||
|
if ( gl_batch_vis_y_scale.GetFloat() > 0.0f)
|
||
|
{
|
||
|
h = ceil( t / gl_batch_vis_y_scale.GetFloat() );
|
||
|
h = MAX(h, 1);
|
||
|
}
|
||
|
|
||
|
// Total time spent inside any and all our "D3D9" calls
|
||
|
double flTotalD3DTime = g_nTotalD3DCycles * s_rdtsc_to_ms;
|
||
|
m_pBatch_vis_bitmap->fill_box(0, m_nBatchVisY, (uint)(.5f + flTotalD3DTime / gl_batch_vis_abs_scale.GetFloat() * m_pBatch_vis_bitmap->width()), h, 150, 150, 150);
|
||
|
|
||
|
// Total total spent processing just DrawIndexedPrimitive() for this batch.
|
||
|
m_pBatch_vis_bitmap->fill_box(0, m_nBatchVisY, (uint)(.5f + t / gl_batch_vis_abs_scale.GetFloat() * m_pBatch_vis_bitmap->width()), h, 70, 70, 70);
|
||
|
|
||
|
double flTotalGLMS = gGL->m_nTotalGLCycles * s_rdtsc_to_ms;
|
||
|
|
||
|
// Total time spent inside of all OpenGL calls
|
||
|
m_pBatch_vis_bitmap->additive_fill_box(0, m_nBatchVisY, (uint)(.5f + flTotalGLMS / gl_batch_vis_abs_scale.GetFloat() * m_pBatch_vis_bitmap->width()), h, 0, 0, 64);
|
||
|
|
||
|
if (flushStats.m_nNewVS) m_pBatch_vis_bitmap->additive_fill_box(80-16, m_nBatchVisY, 8, h, 0, 110, 0);
|
||
|
if (flushStats.m_nNewPS) m_pBatch_vis_bitmap->additive_fill_box(80-8, m_nBatchVisY, 8, h, 110, 0, 110);
|
||
|
|
||
|
int lm = 80;
|
||
|
m_pBatch_vis_bitmap->fill_box(lm+0+flushStats.m_nFirstVSConstant, m_nBatchVisY, flushStats.m_nNumVSConstants, h, 64, 255, 255);
|
||
|
m_pBatch_vis_bitmap->fill_box(lm+64, m_nBatchVisY, flushStats.m_nNumVSBoneConstants, h, 255, 64, 64);
|
||
|
m_pBatch_vis_bitmap->fill_box(lm+64+256+flushStats.m_nFirstPSConstant, m_nBatchVisY, flushStats.m_nNumPSConstants, h, 64, 64, 255);
|
||
|
|
||
|
m_pBatch_vis_bitmap->fill_box(lm+64+256+32, m_nBatchVisY, flushStats.m_nNumChangedSamplers, h, 255, 255, 255);
|
||
|
m_pBatch_vis_bitmap->fill_box(lm+64+256+32+16, m_nBatchVisY, flushStats.m_nNumSamplingParamsChanged, h, 92, 128, 255);
|
||
|
|
||
|
if ( flushStats.m_nVertexBufferChanged ) m_pBatch_vis_bitmap->fill_box(lm+64+256+32+16+64, m_nBatchVisY, 16, h, 128, 128, 128);
|
||
|
if ( flushStats.m_nIndexBufferChanged ) m_pBatch_vis_bitmap->fill_box(lm+64+256+32+16+64+16, m_nBatchVisY, 16, h, 128, 128, 255);
|
||
|
|
||
|
m_pBatch_vis_bitmap->fill_box(lm+64+256+32+16+64+16+16, m_nBatchVisY, ( ( g_nTotalVBLockBytes + g_nTotalIBLockBytes ) * 64 + 2047 ) / 2048, h, 120, 120, 120 );
|
||
|
m_pBatch_vis_bitmap->additive_fill_box(lm+64+256+32+16+64+16+16, m_nBatchVisY, ( g_nTotalVBLockBytes * 64 + 2047 ) / 2048, h, 120, 0, 0);
|
||
|
|
||
|
m_nBatchVisY += h;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
m_nNumProgramChanges += ((flushStats.m_nNewVS + flushStats.m_nNewPS) != 0);
|
||
|
|
||
|
m_flTotalD3DTime += g_nTotalD3DCycles * s_rdtsc_to_ms;
|
||
|
m_nTotalD3DCalls += g_nTotalD3DCalls;
|
||
|
g_nTotalD3DCycles = 0;
|
||
|
g_nTotalD3DCalls = 0;
|
||
|
|
||
|
m_flTotalGLTime += gGL->m_nTotalGLCycles * s_rdtsc_to_ms;
|
||
|
m_nTotalGLCalls += gGL->m_nTotalGLCalls;
|
||
|
gGL->m_nTotalGLCycles = 0;
|
||
|
gGL->m_nTotalGLCalls = 0;
|
||
|
|
||
|
g_nTotalVBLockBytes = 0;
|
||
|
g_nTotalIBLockBytes = 0;
|
||
|
#endif
|
||
|
|
||
|
return S_OK;
|
||
|
|
||
|
draw_failed:
|
||
|
Assert( 0 );
|
||
|
return E_FAIL;
|
||
|
}
|
||
|
|
||
|
#else
|
||
|
|
||
|
// OSX 10.6 support
|
||
|
|
||
|
HRESULT IDirect3DDevice9::FlushIndexBindings( void )
|
||
|
{
|
||
|
// push index buffer state
|
||
|
m_ctx->SetIndexBuffer( m_indices.m_idxBuffer->m_idxBuffer );
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::FlushVertexBindings( uint baseVertexIndex )
|
||
|
{
|
||
|
// push vertex buffer state for the current vertex decl
|
||
|
// in this variant we just walk the attrib map in the VS and do a pull for each one.
|
||
|
// if we can't find a match in the vertex decl, we may fall back to the secret 'dummy' VBO that GLM maintains
|
||
|
|
||
|
GLMVertexSetup setup;
|
||
|
memset( &setup, 0, sizeof( setup ) );
|
||
|
|
||
|
IDirect3DVertexDeclaration9 *vxdecl = m_pVertDecl;
|
||
|
unsigned char *vshAttribMap = m_vertexShader->m_vtxAttribMap;
|
||
|
|
||
|
// this loop could be tightened if we knew the number of live entries in the shader attrib map.
|
||
|
// which of course would be easy to do in the create shader function or even in the translator.
|
||
|
|
||
|
GLMVertexAttributeDesc *dstAttr = setup.m_attrs;
|
||
|
for( int i=0; i<16; i++,dstAttr++ )
|
||
|
{
|
||
|
unsigned char vshattrib = vshAttribMap[ i ];
|
||
|
if (vshattrib != 0xBB)
|
||
|
{
|
||
|
// try to find the match in the decl.
|
||
|
// idea: put some inverse table in the decl which could accelerate this search.
|
||
|
|
||
|
D3DVERTEXELEMENT9_GL *elem = m_pVertDecl->m_elements;
|
||
|
for( int j=0; j< m_pVertDecl->m_elemCount; j++,elem++)
|
||
|
{
|
||
|
// if it matches, install it, change vshattrib so the code below does not trigger, then end the loop
|
||
|
if ( ((vshattrib>>4) == elem->m_dxdecl.Usage) && ((vshattrib & 0x0F) == elem->m_dxdecl.UsageIndex) )
|
||
|
{
|
||
|
// targeting attribute #i in the setup with element data #j from the decl
|
||
|
|
||
|
*dstAttr = elem->m_gldecl;
|
||
|
|
||
|
// then fix buffer, stride, offset - note that we honor the base vertex index here by fiddling the offset
|
||
|
int streamIndex = elem->m_dxdecl.Stream;
|
||
|
dstAttr->m_pBuffer = m_streams[ streamIndex ].m_vtxBuffer->m_vtxBuffer;
|
||
|
dstAttr->m_stride = m_streams[ streamIndex ].m_stride;
|
||
|
dstAttr->m_offset += m_streams[ streamIndex ].m_offset + (baseVertexIndex * dstAttr->m_stride);
|
||
|
|
||
|
// set mask
|
||
|
setup.m_attrMask |= (1 << i);
|
||
|
|
||
|
// end loop
|
||
|
vshattrib = 0xBB;
|
||
|
j = 999;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// if vshattrib is not 0xBB here, that means we could not find a source in the decl for it
|
||
|
if (vshattrib != 0xBB)
|
||
|
{
|
||
|
// fill out attr the same way as usual, we just pass NULL for the buffer and ask GLM to have mercy on us
|
||
|
|
||
|
dstAttr->m_pBuffer = NULL;
|
||
|
dstAttr->m_stride = 0;
|
||
|
dstAttr->m_offset = 0;
|
||
|
|
||
|
// only implement certain usages... if we haven't seen it before, stop.
|
||
|
switch (vshattrib >> 4) // aka usage
|
||
|
{
|
||
|
case D3DDECLUSAGE_POSITION:
|
||
|
case D3DDECLUSAGE_BLENDWEIGHT:
|
||
|
case D3DDECLUSAGE_BLENDINDICES:
|
||
|
Debugger();
|
||
|
break;
|
||
|
|
||
|
case D3DDECLUSAGE_NORMAL:
|
||
|
dstAttr->m_nCompCount = 3;
|
||
|
dstAttr->m_datatype = GL_FLOAT;
|
||
|
dstAttr->m_normalized = false;
|
||
|
break;
|
||
|
|
||
|
case D3DDECLUSAGE_PSIZE:
|
||
|
Debugger();
|
||
|
break;
|
||
|
|
||
|
case D3DDECLUSAGE_TEXCOORD:
|
||
|
dstAttr->m_nCompCount = 3;
|
||
|
dstAttr->m_datatype = GL_FLOAT;
|
||
|
dstAttr->m_normalized = false;
|
||
|
break;
|
||
|
|
||
|
case D3DDECLUSAGE_TANGENT:
|
||
|
case D3DDECLUSAGE_BINORMAL:
|
||
|
case D3DDECLUSAGE_TESSFACTOR:
|
||
|
case D3DDECLUSAGE_PLUGH:
|
||
|
Debugger();
|
||
|
break;
|
||
|
|
||
|
case D3DDECLUSAGE_COLOR:
|
||
|
dstAttr->m_nCompCount = 4;
|
||
|
dstAttr->m_datatype = GL_UNSIGNED_BYTE;
|
||
|
dstAttr->m_normalized = true;
|
||
|
break;
|
||
|
|
||
|
case D3DDECLUSAGE_FOG:
|
||
|
case D3DDECLUSAGE_DEPTH:
|
||
|
case D3DDECLUSAGE_SAMPLE:
|
||
|
Debugger();
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// copy active program's vertex attrib map into the vert setup info
|
||
|
memcpy(&setup.m_vtxAttribMap, m_vertexShader->m_vtxAttribMap, sizeof(m_vertexShader->m_vtxAttribMap));
|
||
|
|
||
|
m_ctx->SetVertexAttributes(&setup);
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
// OSX path offering support for 10.6 (we do not have support for glDrawRangeElementsBaseVertex)
|
||
|
HRESULT IDirect3DDevice9::DrawIndexedPrimitive( D3DPRIMITIVETYPE Type,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount )
|
||
|
{
|
||
|
Assert( m_ctx->m_nCurOwnerThreadId == ThreadGetCurrentId() );
|
||
|
|
||
|
TOGL_NULL_DEVICE_CHECK;
|
||
|
if ( m_bFBODirty )
|
||
|
{
|
||
|
UpdateBoundFBO();
|
||
|
}
|
||
|
|
||
|
g_nTotalDrawsOrClears++;
|
||
|
|
||
|
#if GL_BATCH_PERF_ANALYSIS
|
||
|
m_nTotalPrims += primCount;
|
||
|
CFastTimer tm;
|
||
|
CFlushDrawStatesStats& flushStats = m_ctx->m_FlushStats;
|
||
|
tm.Start();
|
||
|
flushStats.Clear();
|
||
|
#endif
|
||
|
|
||
|
#if GLMDEBUG
|
||
|
if ( gl.m_FogEnable )
|
||
|
{
|
||
|
GLMPRINTF(("-D- IDirect3DDevice9::DrawIndexedPrimitive is seeing enabled fog..."));
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
if ( ( !m_indices.m_idxBuffer ) || ( !m_vertexShader ) )
|
||
|
goto draw_failed;
|
||
|
|
||
|
this->FlushIndexBindings( );
|
||
|
this->FlushVertexBindings( BaseVertexIndex );
|
||
|
m_ctx->FlushDrawStates( MinVertexIndex, MinVertexIndex + NumVertices - 1, 0 );
|
||
|
|
||
|
if (gl.m_FogEnable)
|
||
|
{
|
||
|
GLMPRINTF(("-D- IDirect3DDevice9::DrawIndexedPrimitive is seeing enabled fog..."));
|
||
|
}
|
||
|
|
||
|
switch(Type)
|
||
|
{
|
||
|
case D3DPT_POINTLIST:
|
||
|
Debugger();
|
||
|
break;
|
||
|
|
||
|
case D3DPT_LINELIST:
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::DrawIndexedPrimitive( D3DPT_LINELIST ) - ignored."));
|
||
|
// Debugger();
|
||
|
m_ctx->DrawRangeElements( (GLenum)GL_LINES, (GLuint)MinVertexIndex, (GLuint)(MinVertexIndex + NumVertices), (GLsizei)primCount*2, (GLenum)GL_UNSIGNED_SHORT, (const GLvoid *)(startIndex * sizeof(short)), m_indices.m_idxBuffer->m_idxBuffer );
|
||
|
break;
|
||
|
|
||
|
case D3DPT_TRIANGLELIST:
|
||
|
m_ctx->DrawRangeElements(GL_TRIANGLES, (GLuint)MinVertexIndex, (GLuint)(MinVertexIndex + NumVertices), (GLsizei)primCount*3, (GLenum)GL_UNSIGNED_SHORT, (const GLvoid *)(startIndex * sizeof(short)), m_indices.m_idxBuffer->m_idxBuffer );
|
||
|
break;
|
||
|
|
||
|
case D3DPT_TRIANGLESTRIP:
|
||
|
// enabled... Debugger();
|
||
|
m_ctx->DrawRangeElements(GL_TRIANGLE_STRIP, (GLuint)MinVertexIndex, (GLuint)(MinVertexIndex + NumVertices), (GLsizei)(2+primCount), (GLenum)GL_UNSIGNED_SHORT, (const GLvoid *)(startIndex * sizeof(short)), m_indices.m_idxBuffer->m_idxBuffer );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
return S_OK;
|
||
|
|
||
|
draw_failed:
|
||
|
Assert( 0 );
|
||
|
return E_FAIL;
|
||
|
}
|
||
|
|
||
|
#endif // #ifndef OSX
|
||
|
|
||
|
HRESULT IDirect3DDevice9::DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,CONST void* pIndexData,D3DFORMAT IndexDataFormat,CONST void* pVertexStreamZeroData,UINT VertexStreamZeroStride)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
BOOL IDirect3DDevice9::ShowCursor(BOOL bShow)
|
||
|
{
|
||
|
// FIXME NOP
|
||
|
//DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
void d3drect_to_glmbox( D3DRECT *src, GLScissorBox_t *dst )
|
||
|
{
|
||
|
// to convert from a d3d rect to a GL rect you have to fix up the vertical axis, since D3D Y=0 is the top, but GL Y=0 is the bottom.
|
||
|
// you can't fix it without knowing the height.
|
||
|
|
||
|
dst->width = src->x2 - src->x1;
|
||
|
dst->x = src->x1; // left edge
|
||
|
|
||
|
dst->height = src->y2 - src->y1;
|
||
|
dst->y = src->y1; // bottom edge - take large Y from d3d and subtract from surf height.
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::Clear(DWORD Count,CONST D3DRECT* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
|
||
|
if ( m_bFBODirty )
|
||
|
{
|
||
|
UpdateBoundFBO();
|
||
|
}
|
||
|
|
||
|
g_nTotalDrawsOrClears++;
|
||
|
|
||
|
m_ctx->FlushDrawStatesNoShaders();
|
||
|
|
||
|
|
||
|
//debugging Color = (rand() | 0xFF0000FF) & 0xFF3F3FFF;
|
||
|
if (!Count)
|
||
|
{
|
||
|
// run clear with no added rectangle
|
||
|
m_ctx->Clear( (Flags&D3DCLEAR_TARGET)!=0, Color,
|
||
|
(Flags&D3DCLEAR_ZBUFFER)!=0, Z,
|
||
|
(Flags&D3DCLEAR_STENCIL)!=0, Stencil,
|
||
|
NULL
|
||
|
);
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
GLScissorBox_t tempbox;
|
||
|
|
||
|
// do the rects one by one and convert each one to GL form
|
||
|
for( uint i=0; i<Count; i++)
|
||
|
{
|
||
|
D3DRECT d3dtempbox = pRects[i];
|
||
|
d3drect_to_glmbox( &d3dtempbox, &tempbox );
|
||
|
|
||
|
m_ctx->Clear( (Flags&D3DCLEAR_TARGET)!=0, Color,
|
||
|
(Flags&D3DCLEAR_ZBUFFER)!=0, Z,
|
||
|
(Flags&D3DCLEAR_STENCIL)!=0, Stencil,
|
||
|
&tempbox
|
||
|
);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetTransform(D3DTRANSFORMSTATETYPE State,CONST D3DMATRIX* pMatrix)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::ValidateDevice(DWORD* pNumPasses)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetMaterial(CONST D3DMATERIAL9* pMaterial)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::SetMaterial - ignored."));
|
||
|
// DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
HRESULT IDirect3DDevice9::LightEnable(DWORD Index,BOOL Enable)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetScissorRect(CONST RECT* pRect)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
//int nSurfaceHeight = m_ctx->m_drawingFBO->m_attach[ kAttColor0 ].m_tex->m_layout->m_key.m_ySize;
|
||
|
|
||
|
GLScissorBox_t newScissorBox = { pRect->left, pRect->top, pRect->right - pRect->left, pRect->bottom - pRect->top };
|
||
|
gl.m_ScissorBox = newScissorBox;
|
||
|
m_ctx->WriteScissorBox( &gl.m_ScissorBox );
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::GetDeviceCaps(D3DCAPS9* pCaps)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
|
||
|
// "Adapter" is used to index amongst the set of fake-adapters maintained in the display DB
|
||
|
GLMDisplayDB *db = GetDisplayDB();
|
||
|
int glmRendererIndex = -1;
|
||
|
int glmDisplayIndex = -1;
|
||
|
|
||
|
GLMRendererInfoFields glmRendererInfo;
|
||
|
GLMDisplayInfoFields glmDisplayInfo;
|
||
|
|
||
|
bool result = db->GetFakeAdapterInfo( m_params.m_adapter, &glmRendererIndex, &glmDisplayIndex, &glmRendererInfo, &glmDisplayInfo ); (void)result;
|
||
|
Assert (!result);
|
||
|
// just leave glmRendererInfo filled out for subsequent code to look at as needed.
|
||
|
|
||
|
FillD3DCaps9( glmRendererInfo, pCaps );
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
HRESULT IDirect3DDevice9::TestCooperativeLevel()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
// game calls this to see if device was lost.
|
||
|
// last I checked the device was still attached to the computer.
|
||
|
// so, return OK.
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetClipPlane(DWORD Index,CONST float* pPlane)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
Assert(Index<2);
|
||
|
|
||
|
// We actually push the clip plane coeffs to two places
|
||
|
// - into a shader param for ARB mode
|
||
|
// - and into the API defined clip plane slots for GLSL mode.
|
||
|
|
||
|
// if ARB mode... THIS NEEDS TO GO... it's messing up the dirty ranges..
|
||
|
{
|
||
|
// this->SetVertexShaderConstantF( DXABSTRACT_VS_CLIP_PLANE_BASE+Index, pPlane, 1 ); // stash the clip plane values into shader param - translator knows where to look
|
||
|
}
|
||
|
|
||
|
// if GLSL mode... latch it and let FlushStates push it out
|
||
|
{
|
||
|
GLClipPlaneEquation_t peq;
|
||
|
peq.x = pPlane[0];
|
||
|
peq.y = pPlane[1];
|
||
|
peq.z = pPlane[2];
|
||
|
peq.w = pPlane[3];
|
||
|
|
||
|
gl.m_ClipPlaneEquation[ Index ] = peq;
|
||
|
FlushClipPlaneEquation();
|
||
|
|
||
|
// m_ctx->WriteClipPlaneEquation( &peq, Index );
|
||
|
}
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::EvictManagedResources()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::EvictManagedResources --> IGNORED"));
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetLight(DWORD Index,CONST D3DLIGHT9*)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::SetGammaRamp(UINT iSwapChain,DWORD Flags,CONST D3DGAMMARAMP* pRamp)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
Assert( GetCurrentOwnerThreadId() == ThreadGetCurrentId() );
|
||
|
|
||
|
if ( g_pLauncherMgr )
|
||
|
{
|
||
|
g_pLauncherMgr->SetGammaRamp( pRamp->red, pRamp->green, pRamp->blue );
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void TOGLMETHODCALLTYPE IDirect3DDevice9::SaveGLState()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
void TOGLMETHODCALLTYPE IDirect3DDevice9::RestoreGLState()
|
||
|
{
|
||
|
m_ctx->ForceFlushStates();
|
||
|
|
||
|
m_bFBODirty = true;
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::AcquireThreadOwnership( )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
m_ctx->MakeCurrent( true );
|
||
|
}
|
||
|
|
||
|
|
||
|
void IDirect3DDevice9::ReleaseThreadOwnership( )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
m_ctx->ReleaseCurrent( true );
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::SetMaxUsedVertexShaderConstantsHintNonInline( uint nMaxReg )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
m_ctx->SetMaxUsedVertexShaderConstantsHint( nMaxReg );
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetRenderState( D3DRENDERSTATETYPE State, DWORD Value )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
TOGL_NULL_DEVICE_CHECK;
|
||
|
|
||
|
#if GLMDEBUG
|
||
|
// None of this is needed normally.
|
||
|
char rsSpew = 1;
|
||
|
char ignored = 0;
|
||
|
|
||
|
if (State >= D3DRS_VALUE_LIMIT)
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR(); // bad
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
const D3D_RSINFO *info = &g_D3DRS_INFO_unpacked[ State ];
|
||
|
if (info->m_state != State)
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR(); // bad - we never set up that state in our list
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
if (rsSpew)
|
||
|
{
|
||
|
GLMPRINTF(("-X- IDirect3DDevice9::SetRenderState: set %s(%d) to %d(0x%08x) ( class %d, defval is %d(0x%08x) )", GLMDecode( eD3D_RSTATE,State),State, Value,Value, info->m_class, info->m_defval,info->m_defval ));
|
||
|
}
|
||
|
|
||
|
switch( info->m_class )
|
||
|
{
|
||
|
case 0: // just ignore quietly. example: D3DRS_LIGHTING
|
||
|
ignored = 1;
|
||
|
break;
|
||
|
|
||
|
case 1:
|
||
|
{
|
||
|
// no GL response - and no error as long as the write value matches the default
|
||
|
if (Value != info->m_defval)
|
||
|
{
|
||
|
static char stop_here_1 = 0;
|
||
|
if (stop_here_1)
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case 2:
|
||
|
{
|
||
|
// provide GL response, but only support known default value
|
||
|
if (Value != info->m_defval)
|
||
|
{
|
||
|
static char stop_here_2 = 0;
|
||
|
if (stop_here_2)
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
// fall through to mode 3
|
||
|
}
|
||
|
case 3:
|
||
|
// normal case - the switch statement below will handle this
|
||
|
break;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
switch (State)
|
||
|
{
|
||
|
case D3DRS_ZENABLE: // kGLDepthTestEnable
|
||
|
{
|
||
|
gl.m_DepthTestEnable.enable = Value;
|
||
|
m_ctx->WriteDepthTestEnable( &gl.m_DepthTestEnable );
|
||
|
break;
|
||
|
}
|
||
|
case D3DRS_ZWRITEENABLE: // kGLDepthMask
|
||
|
{
|
||
|
gl.m_DepthMask.mask = Value;
|
||
|
m_ctx->WriteDepthMask( &gl.m_DepthMask );
|
||
|
break;
|
||
|
}
|
||
|
case D3DRS_ZFUNC:
|
||
|
{
|
||
|
// kGLDepthFunc
|
||
|
GLenum func = D3DCompareFuncToGL( Value );
|
||
|
gl.m_DepthFunc.func = func;
|
||
|
m_ctx->WriteDepthFunc( &gl.m_DepthFunc );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_COLORWRITEENABLE: // kGLColorMaskSingle
|
||
|
{
|
||
|
gl.m_ColorMaskSingle.r = ((Value & D3DCOLORWRITEENABLE_RED) != 0) ? 0xFF : 0x00;
|
||
|
gl.m_ColorMaskSingle.g = ((Value & D3DCOLORWRITEENABLE_GREEN)!= 0) ? 0xFF : 0x00;
|
||
|
gl.m_ColorMaskSingle.b = ((Value & D3DCOLORWRITEENABLE_BLUE) != 0) ? 0xFF : 0x00;
|
||
|
gl.m_ColorMaskSingle.a = ((Value & D3DCOLORWRITEENABLE_ALPHA)!= 0) ? 0xFF : 0x00;
|
||
|
m_ctx->WriteColorMaskSingle( &gl.m_ColorMaskSingle );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_CULLMODE: // kGLCullFaceEnable / kGLCullFrontFace
|
||
|
{
|
||
|
switch (Value)
|
||
|
{
|
||
|
case D3DCULL_NONE:
|
||
|
{
|
||
|
gl.m_CullFaceEnable.enable = false;
|
||
|
gl.m_CullFrontFace.value = GL_CCW; //doesn't matter
|
||
|
|
||
|
m_ctx->WriteCullFaceEnable( &gl.m_CullFaceEnable );
|
||
|
m_ctx->WriteCullFrontFace( &gl.m_CullFrontFace );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DCULL_CW:
|
||
|
{
|
||
|
gl.m_CullFaceEnable.enable = true;
|
||
|
gl.m_CullFrontFace.value = GL_CW; //origGL_CCW;
|
||
|
|
||
|
m_ctx->WriteCullFaceEnable( &gl.m_CullFaceEnable );
|
||
|
m_ctx->WriteCullFrontFace( &gl.m_CullFrontFace );
|
||
|
break;
|
||
|
}
|
||
|
case D3DCULL_CCW:
|
||
|
{
|
||
|
gl.m_CullFaceEnable.enable = true;
|
||
|
gl.m_CullFrontFace.value = GL_CCW; //origGL_CW;
|
||
|
|
||
|
m_ctx->WriteCullFaceEnable( &gl.m_CullFaceEnable );
|
||
|
m_ctx->WriteCullFrontFace( &gl.m_CullFrontFace );
|
||
|
break;
|
||
|
}
|
||
|
default:
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
//-------------------------------------------------------------------------------------------- alphablend stuff
|
||
|
|
||
|
case D3DRS_ALPHABLENDENABLE: // kGLBlendEnable
|
||
|
{
|
||
|
gl.m_BlendEnable.enable = Value;
|
||
|
m_ctx->WriteBlendEnable( &gl.m_BlendEnable );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_BLENDOP: // kGLBlendEquation // D3D blend-op ==> GL blend equation
|
||
|
{
|
||
|
GLenum equation = D3DBlendOperationToGL( Value );
|
||
|
gl.m_BlendEquation.equation = equation;
|
||
|
m_ctx->WriteBlendEquation( &gl.m_BlendEquation );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_SRCBLEND: // kGLBlendFactor // D3D blend-factor ==> GL blend factor
|
||
|
case D3DRS_DESTBLEND: // kGLBlendFactor
|
||
|
{
|
||
|
GLenum factor = D3DBlendFactorToGL( Value );
|
||
|
|
||
|
if (State==D3DRS_SRCBLEND)
|
||
|
{
|
||
|
gl.m_BlendFactor.srcfactor = factor;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
gl.m_BlendFactor.dstfactor = factor;
|
||
|
}
|
||
|
m_ctx->WriteBlendFactor( &gl.m_BlendFactor );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_SRGBWRITEENABLE: // kGLBlendEnableSRGB
|
||
|
{
|
||
|
gl.m_BlendEnableSRGB.enable = Value;
|
||
|
m_ctx->WriteBlendEnableSRGB( &gl.m_BlendEnableSRGB );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
//-------------------------------------------------------------------------------------------- alphatest stuff
|
||
|
|
||
|
case D3DRS_ALPHATESTENABLE:
|
||
|
{
|
||
|
gl.m_AlphaTestEnable.enable = Value;
|
||
|
m_ctx->WriteAlphaTestEnable( &gl.m_AlphaTestEnable );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_ALPHAREF:
|
||
|
{
|
||
|
gl.m_AlphaTestFunc.ref = Value / 255.0f;
|
||
|
m_ctx->WriteAlphaTestFunc( &gl.m_AlphaTestFunc );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_ALPHAFUNC:
|
||
|
{
|
||
|
GLenum func = D3DCompareFuncToGL( Value );;
|
||
|
gl.m_AlphaTestFunc.func = func;
|
||
|
m_ctx->WriteAlphaTestFunc( &gl.m_AlphaTestFunc );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
//-------------------------------------------------------------------------------------------- stencil stuff
|
||
|
|
||
|
case D3DRS_STENCILENABLE: // GLStencilTestEnable_t
|
||
|
{
|
||
|
gl.m_StencilTestEnable.enable = Value;
|
||
|
m_ctx->WriteStencilTestEnable( &gl.m_StencilTestEnable );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_STENCILFAIL: // GLStencilOp_t "what do you do if stencil test fails"
|
||
|
{
|
||
|
GLenum stencilop = D3DStencilOpToGL( Value );
|
||
|
gl.m_StencilOp.sfail = stencilop;
|
||
|
|
||
|
m_ctx->WriteStencilOp( &gl.m_StencilOp,0 );
|
||
|
m_ctx->WriteStencilOp( &gl.m_StencilOp,1 ); // ********* need to recheck this
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_STENCILZFAIL: // GLStencilOp_t "what do you do if stencil test passes *but* depth test fails, if depth test happened"
|
||
|
{
|
||
|
GLenum stencilop = D3DStencilOpToGL( Value );
|
||
|
gl.m_StencilOp.dpfail = stencilop;
|
||
|
|
||
|
m_ctx->WriteStencilOp( &gl.m_StencilOp,0 );
|
||
|
m_ctx->WriteStencilOp( &gl.m_StencilOp,1 ); // ********* need to recheck this
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_STENCILPASS: // GLStencilOp_t "what do you do if stencil test and depth test both pass"
|
||
|
{
|
||
|
GLenum stencilop = D3DStencilOpToGL( Value );
|
||
|
gl.m_StencilOp.dppass = stencilop;
|
||
|
|
||
|
m_ctx->WriteStencilOp( &gl.m_StencilOp,0 );
|
||
|
m_ctx->WriteStencilOp( &gl.m_StencilOp,1 ); // ********* need to recheck this
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_STENCILFUNC: // GLStencilFunc_t
|
||
|
{
|
||
|
GLenum stencilfunc = D3DCompareFuncToGL( Value );
|
||
|
gl.m_StencilFunc.frontfunc = gl.m_StencilFunc.backfunc = stencilfunc;
|
||
|
|
||
|
m_ctx->WriteStencilFunc( &gl.m_StencilFunc );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_STENCILREF: // GLStencilFunc_t
|
||
|
{
|
||
|
gl.m_StencilFunc.ref = Value;
|
||
|
m_ctx->WriteStencilFunc( &gl.m_StencilFunc );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_STENCILMASK: // GLStencilFunc_t
|
||
|
{
|
||
|
gl.m_StencilFunc.mask = Value;
|
||
|
m_ctx->WriteStencilFunc( &gl.m_StencilFunc );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_STENCILWRITEMASK: // GLStencilWriteMask_t
|
||
|
{
|
||
|
gl.m_StencilWriteMask.mask = Value;
|
||
|
m_ctx->WriteStencilWriteMask( &gl.m_StencilWriteMask );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_FOGENABLE: // none of these are implemented yet... erk
|
||
|
{
|
||
|
gl.m_FogEnable = (Value != 0);
|
||
|
GLMPRINTF(("-D- fogenable = %d",Value ));
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_SCISSORTESTENABLE: // kGLScissorEnable
|
||
|
{
|
||
|
gl.m_ScissorEnable.enable = Value;
|
||
|
m_ctx->WriteScissorEnable( &gl.m_ScissorEnable );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_DEPTHBIAS: // kGLDepthBias
|
||
|
{
|
||
|
// the value in the dword is actually a float
|
||
|
float fvalue = *(float*)&Value;
|
||
|
gl.m_DepthBias.units = fvalue;
|
||
|
|
||
|
m_ctx->WriteDepthBias( &gl.m_DepthBias );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
// good ref on these: http://aras-p.info/blog/2008/06/12/depth-bias-and-the-power-of-deceiving-yourself/
|
||
|
case D3DRS_SLOPESCALEDEPTHBIAS:
|
||
|
{
|
||
|
// the value in the dword is actually a float
|
||
|
float fvalue = *(float*)&Value;
|
||
|
gl.m_DepthBias.factor = fvalue;
|
||
|
|
||
|
m_ctx->WriteDepthBias( &gl.m_DepthBias );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
// Alpha to coverage
|
||
|
case D3DRS_ADAPTIVETESS_Y:
|
||
|
{
|
||
|
gl.m_AlphaToCoverageEnable.enable = Value;
|
||
|
m_ctx->WriteAlphaToCoverageEnable( &gl.m_AlphaToCoverageEnable );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
case D3DRS_CLIPPLANEENABLE: // kGLClipPlaneEnable
|
||
|
{
|
||
|
// d3d packs all the enables into one word.
|
||
|
// we break that out so we don't do N glEnable calls to sync -
|
||
|
// GLM is tracking one unique enable per plane.
|
||
|
for( int i=0; i<kGLMUserClipPlanes; i++)
|
||
|
{
|
||
|
gl.m_ClipPlaneEnable[i].enable = (Value & (1<<i)) != 0;
|
||
|
}
|
||
|
|
||
|
for( int x=0; x<kGLMUserClipPlanes; x++)
|
||
|
m_ctx->WriteClipPlaneEnable( &gl.m_ClipPlaneEnable[x], x );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
//-------------------------------------------------------------------------------------------- polygon/fill mode
|
||
|
|
||
|
case D3DRS_FILLMODE:
|
||
|
{
|
||
|
GLuint mode = 0;
|
||
|
switch(Value)
|
||
|
{
|
||
|
case D3DFILL_POINT: mode = GL_POINT; break;
|
||
|
case D3DFILL_WIREFRAME: mode = GL_LINE; break;
|
||
|
case D3DFILL_SOLID: mode = GL_FILL; break;
|
||
|
default: DXABSTRACT_BREAK_ON_ERROR(); break;
|
||
|
}
|
||
|
gl.m_PolygonMode.values[0] = gl.m_PolygonMode.values[1] = mode;
|
||
|
m_ctx->WritePolygonMode( &gl.m_PolygonMode );
|
||
|
break;
|
||
|
}
|
||
|
|
||
|
#if GLMDEBUG
|
||
|
case D3DRS_MULTISAMPLEANTIALIAS:
|
||
|
case D3DRS_MULTISAMPLEMASK:
|
||
|
case D3DRS_FOGCOLOR:
|
||
|
case D3DRS_FOGTABLEMODE:
|
||
|
case D3DRS_FOGSTART:
|
||
|
case D3DRS_FOGEND:
|
||
|
case D3DRS_FOGDENSITY:
|
||
|
case D3DRS_RANGEFOGENABLE:
|
||
|
case D3DRS_FOGVERTEXMODE:
|
||
|
case D3DRS_COLORWRITEENABLE1: // kGLColorMaskMultiple
|
||
|
case D3DRS_COLORWRITEENABLE2: // kGLColorMaskMultiple
|
||
|
case D3DRS_COLORWRITEENABLE3: // kGLColorMaskMultiple
|
||
|
case D3DRS_SEPARATEALPHABLENDENABLE:
|
||
|
case D3DRS_BLENDOPALPHA:
|
||
|
case D3DRS_SRCBLENDALPHA:
|
||
|
case D3DRS_DESTBLENDALPHA:
|
||
|
case D3DRS_TWOSIDEDSTENCILMODE: // -> GL_STENCIL_TEST_TWO_SIDE_EXT... not yet implemented ?
|
||
|
case D3DRS_CCW_STENCILFAIL: // GLStencilOp_t
|
||
|
case D3DRS_CCW_STENCILZFAIL: // GLStencilOp_t
|
||
|
case D3DRS_CCW_STENCILPASS: // GLStencilOp_t
|
||
|
case D3DRS_CCW_STENCILFUNC: // GLStencilFunc_t
|
||
|
case D3DRS_CLIPPING: // ???? is clipping ever turned off ??
|
||
|
case D3DRS_LASTPIXEL:
|
||
|
case D3DRS_DITHERENABLE:
|
||
|
case D3DRS_SHADEMODE:
|
||
|
default:
|
||
|
ignored = 1;
|
||
|
break;
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
#if GLMDEBUG
|
||
|
if (rsSpew && ignored)
|
||
|
{
|
||
|
GLMPRINTF(("-X- (ignored)"));
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetSamplerStateNonInline( DWORD Sampler, D3DSAMPLERSTATETYPE Type, DWORD Value )
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
|
||
|
Assert( Sampler < GLM_SAMPLER_COUNT );
|
||
|
|
||
|
m_ctx->SetSamplerDirty( Sampler );
|
||
|
|
||
|
switch( Type )
|
||
|
{
|
||
|
case D3DSAMP_ADDRESSU:
|
||
|
m_ctx->SetSamplerAddressU( Sampler, Value );
|
||
|
break;
|
||
|
case D3DSAMP_ADDRESSV:
|
||
|
m_ctx->SetSamplerAddressV( Sampler, Value );
|
||
|
break;
|
||
|
case D3DSAMP_ADDRESSW:
|
||
|
m_ctx->SetSamplerAddressW( Sampler, Value );
|
||
|
break;
|
||
|
case D3DSAMP_BORDERCOLOR:
|
||
|
m_ctx->SetSamplerBorderColor( Sampler, Value );
|
||
|
break;
|
||
|
case D3DSAMP_MAGFILTER:
|
||
|
m_ctx->SetSamplerMagFilter( Sampler, Value );
|
||
|
break;
|
||
|
case D3DSAMP_MIPFILTER:
|
||
|
m_ctx->SetSamplerMipFilter( Sampler, Value );
|
||
|
break;
|
||
|
case D3DSAMP_MINFILTER:
|
||
|
m_ctx->SetSamplerMinFilter( Sampler, Value );
|
||
|
break;
|
||
|
case D3DSAMP_MIPMAPLODBIAS:
|
||
|
m_ctx->SetSamplerMipMapLODBias( Sampler, Value );
|
||
|
break;
|
||
|
case D3DSAMP_MAXMIPLEVEL:
|
||
|
m_ctx->SetSamplerMaxMipLevel( Sampler, Value);
|
||
|
break;
|
||
|
case D3DSAMP_MAXANISOTROPY:
|
||
|
m_ctx->SetSamplerMaxAnisotropy( Sampler, Value);
|
||
|
break;
|
||
|
case D3DSAMP_SRGBTEXTURE:
|
||
|
//m_samplers[ Sampler ].m_srgb = Value;
|
||
|
m_ctx->SetSamplerSRGBTexture(Sampler, Value);
|
||
|
break;
|
||
|
case D3DSAMP_SHADOWFILTER:
|
||
|
m_ctx->SetShadowFilter(Sampler, Value);
|
||
|
break;
|
||
|
|
||
|
default: DXABSTRACT_BREAK_ON_ERROR(); break;
|
||
|
}
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
void IDirect3DDevice9::SetSamplerStatesNonInline(
|
||
|
DWORD Sampler, DWORD AddressU, DWORD AddressV, DWORD AddressW,
|
||
|
DWORD MinFilter, DWORD MagFilter, DWORD MipFilter,
|
||
|
DWORD MinLod, float LodBias)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
|
||
|
Assert( Sampler < GLM_SAMPLER_COUNT);
|
||
|
|
||
|
m_ctx->SetSamplerDirty( Sampler );
|
||
|
|
||
|
m_ctx->SetSamplerStates( Sampler, AddressU, AddressV, AddressW, MinFilter, MagFilter, MipFilter, MinLod, LodBias );
|
||
|
}
|
||
|
|
||
|
HRESULT IDirect3DDevice9::SetTextureNonInline(DWORD Stage,IDirect3DBaseTexture9* pTexture)
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
GL_PUBLIC_ENTRYPOINT_CHECKS( this );
|
||
|
Assert( Stage < GLM_SAMPLER_COUNT );
|
||
|
m_textures[Stage] = pTexture;
|
||
|
m_ctx->SetSamplerTex( Stage, pTexture ? pTexture->m_tex : NULL );
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
void* ID3DXBuffer::GetBufferPointer()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
DWORD ID3DXBuffer::GetBufferSize()
|
||
|
{
|
||
|
GL_BATCH_PERF_CALL_TIMER;
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
#ifndef _MSC_VER
|
||
|
#pragma mark ----- More D3DX stuff
|
||
|
#endif
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
// D3DX stuff.
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
// matrix stack...
|
||
|
|
||
|
HRESULT D3DXCreateMatrixStack( DWORD Flags, LPD3DXMATRIXSTACK* ppStack)
|
||
|
{
|
||
|
|
||
|
*ppStack = new ID3DXMatrixStack;
|
||
|
|
||
|
(*ppStack)->Create();
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
ID3DXMatrixStack::ID3DXMatrixStack( void )
|
||
|
{
|
||
|
m_refcount[0] = 1;
|
||
|
m_refcount[1] = 0;
|
||
|
};
|
||
|
|
||
|
void ID3DXMatrixStack::AddRef( int which, char *comment )
|
||
|
{
|
||
|
Assert( which >= 0 );
|
||
|
Assert( which < 2 );
|
||
|
m_refcount[which]++;
|
||
|
};
|
||
|
|
||
|
ULONG ID3DXMatrixStack::Release( int which, char *comment )
|
||
|
{
|
||
|
Assert( which >= 0 );
|
||
|
Assert( which < 2 );
|
||
|
|
||
|
bool deleting = false;
|
||
|
|
||
|
m_refcount[which]--;
|
||
|
if ( (!m_refcount[0]) && (!m_refcount[1]) )
|
||
|
{
|
||
|
deleting = true;
|
||
|
}
|
||
|
|
||
|
if (deleting)
|
||
|
{
|
||
|
if (m_mark)
|
||
|
{
|
||
|
GLMPRINTF(("")) ; // place to hang a breakpoint
|
||
|
}
|
||
|
delete this;
|
||
|
return 0;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
return m_refcount[0];
|
||
|
}
|
||
|
};
|
||
|
|
||
|
|
||
|
HRESULT ID3DXMatrixStack::Create()
|
||
|
{
|
||
|
m_stack.EnsureCapacity( 16 ); // 1KB ish
|
||
|
m_stack.AddToTail();
|
||
|
m_stackTop = 0; // top of stack is at index 0 currently
|
||
|
|
||
|
LoadIdentity();
|
||
|
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
D3DXMATRIX* ID3DXMatrixStack::GetTop()
|
||
|
{
|
||
|
return (D3DXMATRIX*)&m_stack[ m_stackTop ];
|
||
|
}
|
||
|
|
||
|
void ID3DXMatrixStack::Push()
|
||
|
{
|
||
|
D3DMATRIX temp = m_stack[ m_stackTop ];
|
||
|
m_stack.AddToTail( temp );
|
||
|
m_stackTop ++;
|
||
|
}
|
||
|
|
||
|
void ID3DXMatrixStack::Pop()
|
||
|
{
|
||
|
int elem = m_stackTop--;
|
||
|
m_stack.Remove( elem );
|
||
|
}
|
||
|
|
||
|
void ID3DXMatrixStack::LoadIdentity()
|
||
|
{
|
||
|
D3DXMATRIX *mat = GetTop();
|
||
|
|
||
|
D3DXMatrixIdentity( mat );
|
||
|
}
|
||
|
|
||
|
void ID3DXMatrixStack::LoadMatrix( const D3DXMATRIX *pMat )
|
||
|
{
|
||
|
*(GetTop()) = *pMat;
|
||
|
}
|
||
|
|
||
|
|
||
|
void ID3DXMatrixStack::MultMatrix( const D3DXMATRIX *pMat )
|
||
|
{
|
||
|
|
||
|
// http://msdn.microsoft.com/en-us/library/bb174057(VS.85).aspx
|
||
|
// This method right-multiplies the given matrix to the current matrix
|
||
|
// (transformation is about the current world origin).
|
||
|
// m_pstack[m_currentPos] = m_pstack[m_currentPos] * (*pMat);
|
||
|
// This method does not add an item to the stack, it replaces the current
|
||
|
// matrix with the product of the current matrix and the given matrix.
|
||
|
|
||
|
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
|
||
|
void ID3DXMatrixStack::MultMatrixLocal( const D3DXMATRIX *pMat )
|
||
|
{
|
||
|
// http://msdn.microsoft.com/en-us/library/bb174058(VS.85).aspx
|
||
|
// This method left-multiplies the given matrix to the current matrix
|
||
|
// (transformation is about the local origin of the object).
|
||
|
// m_pstack[m_currentPos] = (*pMat) * m_pstack[m_currentPos];
|
||
|
// This method does not add an item to the stack, it replaces the current
|
||
|
// matrix with the product of the given matrix and the current matrix.
|
||
|
|
||
|
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
}
|
||
|
|
||
|
HRESULT ID3DXMatrixStack::ScaleLocal(FLOAT x, FLOAT y, FLOAT z)
|
||
|
{
|
||
|
// http://msdn.microsoft.com/en-us/library/bb174066(VS.85).aspx
|
||
|
// Scale the current matrix about the object origin.
|
||
|
// This method left-multiplies the current matrix with the computed
|
||
|
// scale matrix. The transformation is about the local origin of the object.
|
||
|
//
|
||
|
// D3DXMATRIX tmp;
|
||
|
// D3DXMatrixScaling(&tmp, x, y, z);
|
||
|
// m_stack[m_currentPos] = tmp * m_stack[m_currentPos];
|
||
|
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
HRESULT ID3DXMatrixStack::RotateAxisLocal(CONST D3DXVECTOR3* pV, FLOAT Angle)
|
||
|
{
|
||
|
// http://msdn.microsoft.com/en-us/library/bb174062(VS.85).aspx
|
||
|
// Left multiply the current matrix with the computed rotation
|
||
|
// matrix, counterclockwise about the given axis with the given angle.
|
||
|
// (rotation is about the local origin of the object)
|
||
|
|
||
|
// D3DXMATRIX tmp;
|
||
|
// D3DXMatrixRotationAxis( &tmp, pV, angle );
|
||
|
// m_stack[m_currentPos] = tmp * m_stack[m_currentPos];
|
||
|
// Because the rotation is left-multiplied to the matrix stack, the rotation
|
||
|
// is relative to the object's local coordinate space.
|
||
|
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
HRESULT ID3DXMatrixStack::TranslateLocal(FLOAT x, FLOAT y, FLOAT z)
|
||
|
{
|
||
|
// http://msdn.microsoft.com/en-us/library/bb174068(VS.85).aspx
|
||
|
// Left multiply the current matrix with the computed translation
|
||
|
// matrix. (transformation is about the local origin of the object)
|
||
|
|
||
|
// D3DXMATRIX tmp;
|
||
|
// D3DXMatrixTranslation( &tmp, x, y, z );
|
||
|
// m_stack[m_currentPos] = tmp * m_stack[m_currentPos];
|
||
|
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
|
||
|
const char* D3DXGetPixelShaderProfile( IDirect3DDevice9 *pDevice )
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return "";
|
||
|
}
|
||
|
|
||
|
#ifdef _MSC_VER
|
||
|
#pragma warning (push)
|
||
|
#pragma warning (disable:4701) // potentially uninitialized local variable 'temp' used
|
||
|
#endif
|
||
|
D3DXMATRIX* D3DXMatrixMultiply( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM1, CONST D3DXMATRIX *pM2 )
|
||
|
{
|
||
|
D3DXMATRIX temp;
|
||
|
|
||
|
for( int i=0; i<4; i++)
|
||
|
{
|
||
|
for( int j=0; j<4; j++)
|
||
|
{
|
||
|
temp.m[i][j] = (pM1->m[ i ][ 0 ] * pM2->m[ 0 ][ j ])
|
||
|
+ (pM1->m[ i ][ 1 ] * pM2->m[ 1 ][ j ])
|
||
|
+ (pM1->m[ i ][ 2 ] * pM2->m[ 2 ][ j ])
|
||
|
+ (pM1->m[ i ][ 3 ] * pM2->m[ 3 ][ j ]);
|
||
|
}
|
||
|
}
|
||
|
*pOut = temp;
|
||
|
return pOut;
|
||
|
}
|
||
|
#ifdef _MSC_VER
|
||
|
#pragma warning(pop)
|
||
|
#endif
|
||
|
|
||
|
// Transform a 3D vector by a given matrix, projecting the result back into w = 1
|
||
|
// http://msdn.microsoft.com/en-us/library/ee417622(VS.85).aspx
|
||
|
D3DXVECTOR3* D3DXVec3TransformCoord(D3DXVECTOR3 *pOut, CONST D3DXVECTOR3 *pV, CONST D3DXMATRIX *pM)
|
||
|
{
|
||
|
D3DXVECTOR3 vOut;
|
||
|
|
||
|
float norm = (pM->m[0][3] * pV->x) + (pM->m[1][3] * pV->y) + (pM->m[2][3] *pV->z) + pM->m[3][3];
|
||
|
if ( norm )
|
||
|
{
|
||
|
float norm_inv = 1.0f / norm;
|
||
|
vOut.x = (pM->m[0][0] * pV->x + pM->m[1][0] * pV->y + pM->m[2][0] * pV->z + pM->m[3][0]) * norm_inv;
|
||
|
vOut.y = (pM->m[0][1] * pV->x + pM->m[1][1] * pV->y + pM->m[2][1] * pV->z + pM->m[3][1]) * norm_inv;
|
||
|
vOut.z = (pM->m[0][2] * pV->x + pM->m[1][2] * pV->y + pM->m[2][2] * pV->z + pM->m[3][2]) * norm_inv;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
vOut.x = vOut.y = vOut.z = 0.0f;
|
||
|
}
|
||
|
|
||
|
*pOut = vOut;
|
||
|
|
||
|
return pOut;
|
||
|
}
|
||
|
|
||
|
|
||
|
void D3DXMatrixIdentity( D3DXMATRIX *mat )
|
||
|
{
|
||
|
for( int i=0; i<4; i++)
|
||
|
{
|
||
|
for( int j=0; j<4; j++)
|
||
|
{
|
||
|
mat->m[i][j] = (i==j) ? 1.0f : 0.0f; // 1's on the diagonal.
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
D3DXMATRIX* D3DXMatrixTranslation( D3DXMATRIX *pOut, FLOAT x, FLOAT y, FLOAT z )
|
||
|
{
|
||
|
D3DXMatrixIdentity( pOut );
|
||
|
pOut->m[3][0] = x;
|
||
|
pOut->m[3][1] = y;
|
||
|
pOut->m[3][2] = z;
|
||
|
return pOut;
|
||
|
}
|
||
|
|
||
|
D3DXMATRIX* D3DXMatrixInverse( D3DXMATRIX *pOut, FLOAT *pDeterminant, CONST D3DXMATRIX *pM )
|
||
|
{
|
||
|
Assert( sizeof( D3DXMATRIX ) == (16 * sizeof(float) ) );
|
||
|
Assert( sizeof( VMatrix ) == (16 * sizeof(float) ) );
|
||
|
Assert( pDeterminant == NULL ); // homey don't play that
|
||
|
|
||
|
VMatrix *origM = (VMatrix*)pM;
|
||
|
VMatrix *destM = (VMatrix*)pOut;
|
||
|
|
||
|
bool success = MatrixInverseGeneral( *origM, *destM ); (void)success;
|
||
|
Assert( success );
|
||
|
|
||
|
return pOut;
|
||
|
}
|
||
|
|
||
|
|
||
|
D3DXMATRIX* D3DXMatrixTranspose( D3DXMATRIX *pOut, CONST D3DXMATRIX *pM )
|
||
|
{
|
||
|
if (pOut != pM)
|
||
|
{
|
||
|
for( int i=0; i<4; i++)
|
||
|
{
|
||
|
for( int j=0; j<4; j++)
|
||
|
{
|
||
|
pOut->m[i][j] = pM->m[j][i];
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
D3DXMATRIX temp = *pM;
|
||
|
D3DXMatrixTranspose( pOut, &temp );
|
||
|
}
|
||
|
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
|
||
|
D3DXPLANE* D3DXPlaneNormalize( D3DXPLANE *pOut, CONST D3DXPLANE *pP)
|
||
|
{
|
||
|
// not very different from normalizing a vector.
|
||
|
// figure out the square root of the sum-of-squares of the x,y,z components
|
||
|
// make sure that's non zero
|
||
|
// then divide all four components by that value
|
||
|
// or return some dummy plane like 0,0,1,0 if it fails
|
||
|
|
||
|
float len = sqrt( (pP->a * pP->a) + (pP->b * pP->b) + (pP->c * pP->c) );
|
||
|
if (len > 1e-10) //FIXME need a real epsilon here ?
|
||
|
{
|
||
|
pOut->a = pP->a / len; pOut->b = pP->b / len; pOut->c = pP->c / len; pOut->d = pP->d / len;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
pOut->a = 0.0f; pOut->b = 0.0f; pOut->c = 1.0f; pOut->d = 0.0f;
|
||
|
}
|
||
|
return pOut;
|
||
|
}
|
||
|
|
||
|
|
||
|
D3DXVECTOR4* D3DXVec4Transform( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV, CONST D3DXMATRIX *pM )
|
||
|
{
|
||
|
VMatrix *mat = (VMatrix*)pM;
|
||
|
Vector4D *vIn = (Vector4D*)pV;
|
||
|
Vector4D *vOut = (Vector4D*)pOut;
|
||
|
|
||
|
Vector4DMultiplyTranspose( *mat, *vIn, *vOut );
|
||
|
|
||
|
return pOut;
|
||
|
}
|
||
|
|
||
|
|
||
|
|
||
|
D3DXVECTOR4* D3DXVec4Normalize( D3DXVECTOR4 *pOut, CONST D3DXVECTOR4 *pV )
|
||
|
{
|
||
|
Vector4D *vIn = (Vector4D*) pV;
|
||
|
Vector4D *vOut = (Vector4D*) pOut;
|
||
|
|
||
|
*vOut = *vIn;
|
||
|
Vector4DNormalize( *vOut );
|
||
|
|
||
|
return pOut;
|
||
|
}
|
||
|
|
||
|
|
||
|
D3DXMATRIX* D3DXMatrixOrthoOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn,FLOAT zf )
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
|
||
|
D3DXMATRIX* D3DXMatrixPerspectiveRH( D3DXMATRIX *pOut, FLOAT w, FLOAT h, FLOAT zn, FLOAT zf )
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
|
||
|
D3DXMATRIX* D3DXMatrixPerspectiveOffCenterRH( D3DXMATRIX *pOut, FLOAT l, FLOAT r, FLOAT b, FLOAT t, FLOAT zn, FLOAT zf )
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR();
|
||
|
return NULL;
|
||
|
}
|
||
|
|
||
|
|
||
|
D3DXPLANE* D3DXPlaneTransform( D3DXPLANE *pOut, CONST D3DXPLANE *pP, CONST D3DXMATRIX *pM )
|
||
|
{
|
||
|
float *out = &pOut->a;
|
||
|
|
||
|
// dot dot dot
|
||
|
for( int x=0; x<4; x++ )
|
||
|
{
|
||
|
out[x] = (pM->m[0][x] * pP->a)
|
||
|
+ (pM->m[1][x] * pP->b)
|
||
|
+ (pM->m[2][x] * pP->c)
|
||
|
+ (pM->m[3][x] * pP->d);
|
||
|
}
|
||
|
|
||
|
return pOut;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
IDirect3D9 *Direct3DCreate9(UINT SDKVersion)
|
||
|
{
|
||
|
GLMPRINTF(( "-X- Direct3DCreate9: %d", SDKVersion ));
|
||
|
|
||
|
return new IDirect3D9;
|
||
|
}
|
||
|
|
||
|
// ------------------------------------------------------------------------------------------------------------------------------ //
|
||
|
|
||
|
void D3DPERF_SetOptions( DWORD dwOptions )
|
||
|
{
|
||
|
}
|
||
|
|
||
|
|
||
|
HRESULT D3DXCompileShader(
|
||
|
LPCSTR pSrcData,
|
||
|
UINT SrcDataLen,
|
||
|
CONST D3DXMACRO* pDefines,
|
||
|
LPD3DXINCLUDE pInclude,
|
||
|
LPCSTR pFunctionName,
|
||
|
LPCSTR pProfile,
|
||
|
DWORD Flags,
|
||
|
LPD3DXBUFFER* ppShader,
|
||
|
LPD3DXBUFFER* ppErrorMsgs,
|
||
|
LPD3DXCONSTANTTABLE* ppConstantTable)
|
||
|
{
|
||
|
DXABSTRACT_BREAK_ON_ERROR(); // is anyone calling this ?
|
||
|
return S_OK;
|
||
|
}
|
||
|
|
||
|
#if defined(DX_TO_GL_ABSTRACTION)
|
||
|
void toglGetClientRect( void *hWnd, RECT *destRect )
|
||
|
{
|
||
|
// the only useful answer this call can offer, is the size of the canvas.
|
||
|
// actually getting the window bounds is not useful.
|
||
|
// so, see if a D3D device is up and running, and if so,
|
||
|
// dig in and find out its backbuffer size and use that.
|
||
|
|
||
|
uint width, height;
|
||
|
g_pLauncherMgr->RenderedSize( width, height, false ); // false = get them, don't set them
|
||
|
Assert( width!=0 && height!=0 );
|
||
|
|
||
|
destRect->left = 0;
|
||
|
destRect->top = 0;
|
||
|
destRect->right = width;
|
||
|
destRect->bottom = height;
|
||
|
|
||
|
//GLMPRINTF(( "-D- GetClientRect returning rect of (0,0, %d,%d)",width,height ));
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
#endif
|
||
|
|
||
|
#endif
|