int IsTextureFormatOk( D3DFORMAT TextureFormat, D3DFORMAT AdapterFormat )
{
int ret=0;
HRESULT hr;
hr = pD3D->CheckDeviceFormat( D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
AdapterFormat,
0,
D3DRTYPE_TEXTURE,
TextureFormat );
if(D3D_OK == hr){
ret=1;
}
hr = pD3D->CheckDeviceFormat( D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
AdapterFormat,
D3DUSAGE_RENDERTARGET,
D3DRTYPE_TEXTURE,
TextureFormat );
if(D3D_OK == hr){
ret=2;
}
return ret;
}
void XBVideoConfig::GetModes(LPDIRECT3D8 pD3D)
{
bHasPAL = false;
bHasNTSC = false;
DWORD numModes = pD3D->GetAdapterModeCount(D3DADAPTER_DEFAULT);
D3DDISPLAYMODE mode;
CLog::Log(LOGINFO, "Available videomodes:");
for ( DWORD i = 0; i < numModes; i++ )
{
pD3D->EnumAdapterModes( 0, i, &mode );
// Skip modes we don't care about
if ( mode.Format != D3DFMT_LIN_A8R8G8B8 )
continue;
// ignore 640 wide modes
if ( mode.Width < 720)
continue;
// If we get here, we found an acceptable mode
CLog::Log(LOGINFO, "Found mode: %ix%i at %iHz", mode.Width, mode.Height, mode.RefreshRate);
if (mode.Width == 720 && mode.Height == 576 && mode.RefreshRate == 50)
bHasPAL = true;
if (mode.Width == 720 && mode.Height == 480 && mode.RefreshRate == 60)
bHasNTSC = true;
}
}
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
// Create the D3D object.
if( NULL == ( g_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
return E_FAIL;
// Get the current desktop display mode, so we can set up a back
// buffer of the same format
D3DDISPLAYMODE d3ddm;
if( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
return E_FAIL;
// Set up the structure used to create the D3DDevice
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = d3ddm.Format;
// Create the D3DDevice
if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &g_pd3dDevice ) ) )
{
return E_FAIL;
}
// Turn off culling, so we see the front and back of the triangle
g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
// Turn off D3D lighting, since we are providing our own vertex colors
g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
return S_OK;
}
//Get a supported front buffer format
bool WINDOW::GetFullscreenFrontBufferFormat(D3DFORMAT requestedFormat, D3DFORMAT & resultFormat,
LPDIRECT3D8 d3d)
{
//See if the requested front buffer format is supported
HRESULT hr;
bool requestedFormatSupported=false;
bool X8R8G8B8Supported=false;
bool R5G6B5Supported=false;
//Get the number of available display modes
unsigned int numModes=d3d->GetAdapterModeCount(D3DADAPTER_DEFAULT);
//Loop through the modes to see if the formats are supported
for(unsigned int i=0; i<numModes; ++i)
{
D3DDISPLAYMODE mode;
hr=d3d->EnumAdapterModes(D3DADAPTER_DEFAULT, i, &mode);
if(mode.Format==requestedFormat)
requestedFormatSupported=true;
if(mode.Format==D3DFMT_X8R8G8B8)
X8R8G8B8Supported=true;
if(mode.Format==D3DFMT_R5G6B5)
R5G6B5Supported=true;
}
//Return the best supported format
if(requestedFormatSupported)
{
LOG::Instance()->OutputSuccess("Chosen front buffer format is available in fullscreen mode");
resultFormat=requestedFormat;
return true;
}
if(X8R8G8B8Supported)
{
LOG::Instance()->OutputMisc("D3DFMT_X8R8G8B8 will be used instead of chosen front buffer format in %s mode");
resultFormat=D3DFMT_X8R8G8B8;
return true;
}
if(R5G6B5Supported)
{
LOG::Instance()->OutputMisc("D3DFMT_R5G6B5 will be used instead of chosen front buffer format in %s mode");
resultFormat=D3DFMT_R5G6B5;
return true;
}
//No color formats supported
LOG::Instance()->OutputError("No suitable front buffer formats supported in fullscreen mode");
return false;
}
void RageDisplay_D3D::GetDisplayResolutions( DisplayResolutions &out ) const
{
out.clear();
int iCnt = g_pd3d->GetAdapterModeCount( D3DADAPTER_DEFAULT );
for( int i = 0; i < iCnt; ++i )
{
D3DDISPLAYMODE mode;
g_pd3d->EnumAdapterModes( D3DADAPTER_DEFAULT, i, &mode );
DisplayResolution res = { mode.Width, mode.Height };
out.insert( res );
}
}
RageDisplay_D3D::~RageDisplay_D3D()
{
LOG->Trace( "RageDisplay_D3D::~RageDisplay()" );
GraphicsWindow::Shutdown();
if( g_pd3dDevice )
{
g_pd3dDevice->Release();
g_pd3dDevice = NULL;
}
if( g_pd3d )
{
g_pd3d->Release();
g_pd3d = NULL;
}
/* Even after we call Release(), D3D may still affect our window. It seems
* to subclass the window, and never release it. Free the DLL after
* destroying the window. */
if( g_D3D8_Module )
{
FreeLibrary( g_D3D8_Module );
g_D3D8_Module = NULL;
}
}
bool RageDisplay_D3D::SupportsTextureFormat( PixelFormat pixfmt, bool realtime )
{
#if defined(XBOX)
// Lazy... Xbox handles paletted textures completely differently
// than D3D and I don't want to add a bunch of code for it. Also,
// paletted textures result in worse cache efficiency (see "Xbox
// Palettized Texture Performance" in XDK). So, we'll force 32bit
// ARGB textures. -Chris
// This is also needed for XGSwizzleRect().
return pixfmt == FMT_RGBA8;
#endif
// Some cards (Savage) don't support alpha in palettes.
// Don't allow paletted textures if this is the case.
if( pixfmt == FMT_PAL && !(g_DeviceCaps.TextureCaps & D3DPTEXTURECAPS_ALPHAPALETTE) )
return false;
if( D3DFORMATS[pixfmt] == D3DFMT_UNKNOWN )
return false;
D3DFORMAT d3dfmt = D3DFORMATS[pixfmt];
HRESULT hr = g_pd3d->CheckDeviceFormat(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
g_d3dpp.BackBufferFormat,
0,
D3DRTYPE_TEXTURE,
d3dfmt);
return SUCCEEDED( hr );
}
void cleanup() // it's a dirty job.. but some function has to do it...
{
if (myRect1)
delete myRect1;
if (myRect2)
delete myRect2;
if (myRect3)
delete myRect3;
if (myRect4)
delete myRect4;
if (myRect5)
delete myRect5;
if( lpD3DDevice8 != NULL )
lpD3DDevice8->Release();
if( lpD3D8 != NULL )
lpD3D8->Release();
if( lpD3DXFont != NULL )
lpD3DXFont->Release();
if( lpD3DTex1 != NULL )
lpD3DTex1->Release();
}
//-----------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
VOID Cleanup()
{
if( g_pd3dDevice != NULL)
g_pd3dDevice->Release();
if( g_pD3D != NULL)
g_pD3D->Release();
}
//Get a supported back buffer format
bool WINDOW::GetBackBufferFormat( D3DFORMAT requestedFormat, D3DFORMAT & resultFormat,
D3DFORMAT frontBufferFormat,
LPDIRECT3D8 d3d, bool windowed)
{
//See if the requested back buffer format is supported
HRESULT hr;
hr=d3d->CheckDeviceType( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, frontBufferFormat,
requestedFormat, windowed);
if(SUCCEEDED(hr))
{
LOG::Instance()->OutputSuccess("Chosen back buffer format is available in %s mode",
windowed ? "windowed" : "fullscreen");
resultFormat=requestedFormat;
return true;
}
//If failed, try A8R8G8B8, X8R8G8B8, R5G6B5
D3DFORMAT testFormats[3]={D3DFMT_A8R8G8B8, D3DFMT_X8R8G8B8, D3DFMT_R5G6B5};
char * testStrings[3]={"D3DFMT_A8R8G8B8", "D3DFMT_X8R8G8B8", "D3DFMT_R5G6B5"};
for(int i=0; i<3; ++i)
{
D3DFORMAT currentTestFormat=testFormats[i];
if(FAILED(hr))
{
hr=d3d->CheckDeviceType( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, frontBufferFormat,
currentTestFormat, windowed);
if(SUCCEEDED(hr))
{
LOG::Instance()->OutputMisc("%s will be used instead of chosen back buffer format in %s mode",
testStrings[i],
windowed ? "windowed" : "fullscreen");
resultFormat=testFormats[i];
return true;
}
}
}
//If still failed, no color formats supported
LOG::Instance()->OutputError("No suitable back buffer formats supported in %s mode",
windowed ? "windowed" : "fullscreen");
return false;
}
D3DFORMAT FindBackBufferType(bool bWindowed, int iBPP)
{
HRESULT hr;
// If windowed, then bpp is ignored. Use whatever works.
vector<D3DFORMAT> vBackBufferFormats; // throw all possibilities in here
/* When windowed, add all formats; otherwise add only formats that match dwBPP. */
if( iBPP == 16 || bWindowed )
{
vBackBufferFormats.push_back( D3DFMT_R5G6B5 );
vBackBufferFormats.push_back( D3DFMT_X1R5G5B5 );
vBackBufferFormats.push_back( D3DFMT_A1R5G5B5 );
}
if( iBPP == 32 || bWindowed )
{
#if !defined(XBOX)
vBackBufferFormats.push_back( D3DFMT_R8G8B8 );
#endif
vBackBufferFormats.push_back( D3DFMT_X8R8G8B8 );
vBackBufferFormats.push_back( D3DFMT_A8R8G8B8 );
}
if( !bWindowed && iBPP != 16 && iBPP != 32 )
{
GraphicsWindow::Shutdown();
RageException::Throw( "Invalid BPP '%i' specified", iBPP );
}
// Test each back buffer format until we find something that works.
for( unsigned i=0; i < vBackBufferFormats.size(); i++ )
{
D3DFORMAT fmtBackBuffer = vBackBufferFormats[i];
D3DFORMAT fmtDisplay;
if( bWindowed )
fmtDisplay = g_DesktopMode.Format;
else // Fullscreen
fmtDisplay = vBackBufferFormats[i];
LOG->Trace( "Testing format: display %d, back buffer %d, windowed %d...",
fmtDisplay, fmtBackBuffer, bWindowed );
hr = g_pd3d->CheckDeviceType( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
fmtDisplay, fmtBackBuffer, bWindowed );
if( FAILED(hr) )
continue; // skip
// done searching
LOG->Trace( "This will work." );
return fmtBackBuffer;
}
LOG->Trace( "Couldn't find an appropriate back buffer format." );
return D3DFMT_UNKNOWN;
}
//pre: XBVideoConfig::GetModes has been called before this function
RESOLUTION XBVideoConfig::GetInitialMode(LPDIRECT3D8 pD3D, D3DPRESENT_PARAMETERS *p3dParams)
{
bool bHasPal = HasPAL();
DWORD numModes = pD3D->GetAdapterModeCount(D3DADAPTER_DEFAULT);
D3DDISPLAYMODE mode;
for ( DWORD i = 0; i < numModes; i++ )
{
pD3D->EnumAdapterModes( 0, i, &mode );
// ignore 640 wide modes
if ( mode.Width < 720)
continue;
p3dParams->BackBufferWidth = mode.Width;
p3dParams->BackBufferHeight = mode.Height;
p3dParams->FullScreen_RefreshRateInHz = mode.RefreshRate;
if ((bHasPal) && ((mode.Height != 576) || (mode.RefreshRate != 50)))
{
continue;
}
//take the first available mode
}
if (HasPAL())
{
if (HasWidescreen() && (p3dParams->Flags & D3DPRESENTFLAG_WIDESCREEN))
{
return PAL_16x9;
}
else
{
return PAL_4x3;
}
}
if (HasWidescreen() && (p3dParams->Flags & D3DPRESENTFLAG_WIDESCREEN))
{
return NTSC_16x9;
}
else
{
return NTSC_4x3;
}
}
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
// Create the D3D object, which is needed to create the D3DDevice.
if( NULL == ( g_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
return E_FAIL;
// Get the current desktop display mode
D3DDISPLAYMODE d3ddm;
if( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
return E_FAIL;
// Set up the structure used to create the D3DDevice. Most parameters are
// zeroed out. We set Windowed to TRUE, since we want to do D3D in a
// window, and then set the SwapEffect to "discard", which is the most
// efficient method of presenting the back buffer to the display. And
// we request a back buffer format that matches the current desktop display
// format.
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = d3ddm.Format;
// Create the Direct3D device. Here we are using the default adapter (most
// systems only have one, unless they have multiple graphics hardware cards
// installed) and requesting the HAL (which is saying we want the hardware
// device rather than a software one). Software vertex processing is
// specified since we know it will work on all cards. On cards that support
// hardware vertex processing, though, we would see a big performance gain
// by specifying hardware vertex processing.
if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &g_pd3dDevice ) ) )
{
return E_FAIL;
}
// Device state would normally be set here
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT InitD3D( HWND hWnd )
{
// Create the D3D object.
if( NULL == ( g_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
return E_FAIL;
// Get the current desktop display mode, so we can set up a back
// buffer of the same format
D3DDISPLAYMODE d3ddm;
if( FAILED( g_pD3D->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm ) ) )
return E_FAIL;
// Set up the structure used to create the D3DDevice. Since we are now
// using more complex geometry, we will create a device with a zbuffer.
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = d3ddm.Format;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
// Create the D3DDevice
if( FAILED( g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &g_pd3dDevice ) ) )
{
return E_FAIL;
}
// Turn off culling
g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
// Turn off D3D lighting
g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
// Turn on the zbuffer
g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
return S_OK;
}
void EnumAdapters( int nAdapter )
{
int i,n;
char buf[128];
n = pD3D->GetAdapterModeCount(nAdapter);
D3DCapsStruct.m_DisplayModeNum = n;
if( D3DCapsStruct.m_DisplayMode==NULL )
D3DCapsStruct.m_DisplayMode = (D3DDISPLAYMODE*)GAlloc( sizeof(D3DDISPLAYMODE)*n );
for( i=0 ; i<n ; i++ ){
if( pD3D->EnumAdapterModes(nAdapter,i,&D3DCapsStruct.m_DisplayMode[i]) == D3D_OK){
wsprintf( buf, "%d x %d (%d Hz) - %s\n",
D3DCapsStruct.m_DisplayMode[i].Width,
D3DCapsStruct.m_DisplayMode[i].Height,
D3DCapsStruct.m_DisplayMode[i].RefreshRate,
TxFmtMode[ LIM(D3DCapsStruct.m_DisplayMode[i].Format,0,D3DFMT_D3DD_MAX-1) ] );
DebugPrintf( buf );
}
}
}
//-----------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
VOID Cleanup()
{
if( g_pTexture != NULL )
g_pTexture->Release();
if( g_pVB != NULL )
g_pVB->Release();
if( g_pd3dDevice != NULL )
g_pd3dDevice->Release();
if( g_pD3D != NULL )
g_pD3D->Release();
}
BOOL Init_DX( HWND hWnd )
{
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory ( &d3dpp, sizeof ( d3dpp ) );
d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_FLIP;
d3dpp.BackBufferWidth = SCREENWIDTH;
d3dpp.BackBufferHeight = SCREENHEIGHT;
d3dpp.BackBufferFormat = D3DFMT_R5G6B5;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
lpD3D = Direct3DCreate8 ( D3D_SDK_VERSION ) ;
if( FAILED( lpD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &lpDevice ) ) )
{
d3dpp.BackBufferFormat = D3DFMT_X1R5G5B5;
if ( FAILED ( lpD3D->CreateDevice ( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &lpDevice ) ) )
return false;
}
D3DCAPS8 DevCaps;
ZeroMemory( &DevCaps, sizeof ( D3DCAPS8 ) );
lpDevice->GetDeviceCaps ( &DevCaps );
return TRUE;
}
void InitialiseD3D()
{
g_pD3D = Direct3DCreate8(D3D_SDK_VERSION);
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory(&d3dpp, sizeof(d3dpp));
d3dpp.BackBufferWidth = 640;
d3dpp.BackBufferHeight = 480;
d3dpp.BackBufferFormat = D3DFMT_LIN_X8R8G8B8;
d3dpp.BackBufferCount = 1;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
g_pD3D->CreateDevice(0, D3DDEVTYPE_HAL, NULL,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&d3dpp, &g_pD3DDevice);
g_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
g_pD3DDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
g_pD3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
g_pD3DDevice->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG1);
g_pD3DDevice->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_DIFFUSE);
g_pD3DDevice->SetTextureStageState(0, D3DTSS_COLORKEYOP, D3DTCOLORKEYOP_KILL);
g_pD3DDevice->SetTextureStageState(0, D3DTSS_COLORKEYCOLOR, D3DCOLOR_XRGB( 150, 200, 250));
g_pD3DDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
g_pD3DDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
g_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
g_pD3DDevice->SetTextureStageState(0,D3DTSS_MAGFILTER, D3DTEXF_ANISOTROPIC);
g_pD3DDevice->SetTextureStageState(0,D3DTSS_MINFILTER, D3DTEXF_ANISOTROPIC);
g_pD3DDevice->SetTextureStageState(0, D3DTSS_MAXANISOTROPY, 1 );
g_pD3DDevice->SetTextureStageState(0, D3DTSS_MIPMAPLODBIAS, *((LPDWORD)(&g_fMipMapLodBias)));
g_pD3DDevice->SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
}
RageDisplay_D3D::~RageDisplay_D3D()
{
LOG->Trace( "RageDisplay_D3D::~RageDisplay()" );
if( g_pd3dDevice )
g_pd3dDevice->Release();
if( g_pd3d )
g_pd3d->Release();
#if !defined(XBOX)
if( g_D3D8_Module )
{
FreeLibrary( g_D3D8_Module );
g_D3D8_Module = NULL;
}
#endif
GraphicsWindow::Shutdown();
}
LRESULT CALLBACK WindowProc(HWND hWnd, unsigned uMsg, WPARAM wParam, LPARAM lParam)
{
int i;
switch ( uMsg )
{
case WM_DESTROY:
rendering = 0;
FreeBrushes ( Brushes, BrushCount );
if ( FinalBSP ) delete FinalBSP;
for ( i = 0; i < 3; i++ )
{
lpTextureSurface [ i ]->Release ( );
}
lpDevice->Release ( );
lpD3D->Release ( );
PostQuitMessage ( 0 );
break;
case WM_MOUSEMOVE:
SetCursor ( NULL );
break;
case WM_KEYUP:
switch ( wParam )
{
case VK_ESCAPE:
quit = 1;
DestroyWindow ( hWnd );
break;
}
break;
default:
return DefWindowProc ( hWnd, uMsg, wParam, lParam );
}
return 0L;
}
bool RageDisplay_D3D::SupportsTextureFormat( PixelFormat pixfmt, bool realtime )
{
// Some cards (Savage) don't support alpha in palettes.
// Don't allow paletted textures if this is the case.
if( pixfmt == PixelFormat_PAL && !(g_DeviceCaps.TextureCaps & D3DPTEXTURECAPS_ALPHAPALETTE) )
return false;
if( D3DFORMATS[pixfmt] == D3DFMT_UNKNOWN )
return false;
D3DFORMAT d3dfmt = D3DFORMATS[pixfmt];
HRESULT hr = g_pd3d->CheckDeviceFormat(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
g_d3dpp.BackBufferFormat,
0,
D3DRTYPE_TEXTURE,
d3dfmt);
return SUCCEEDED( hr );
}
//-----------------------------------------------------------------------------
// Name: InitD3D()
// Desc: Initializes Direct3D
//-----------------------------------------------------------------------------
HRESULT Renderer::InitD3D()
{
// Create the D3D object.
if( nullptr == ( g_pD3D = Direct3DCreate8( D3D_SDK_VERSION ) ) )
return E_FAIL;
// Set up the structure used to create the D3DDevice.
D3DPRESENT_PARAMETERS d3dpp;
ZeroMemory( &d3dpp, sizeof(d3dpp) );
d3dpp.BackBufferWidth = 640;
d3dpp.BackBufferHeight = 480;
d3dpp.BackBufferFormat = D3DFMT_X8R8G8B8;
d3dpp.BackBufferCount = 1;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
// Create the Direct3D device.
if( FAILED( g_pD3D->CreateDevice( 0, D3DDEVTYPE_HAL, nullptr,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
&d3dpp, &g_pd3dDevice ) ) )
return E_FAIL;
// Turn off culling
g_pd3dDevice->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
// Turn off D3D lighting
g_pd3dDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
// Turn on the zbuffer
g_pd3dDevice->SetRenderState( D3DRS_ZENABLE, TRUE );
g_pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
g_pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, FALSE );
//g_pd3dDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
//g_pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name: Cleanup()
// Desc: Releases all previously initialized objects
//-----------------------------------------------------------------------------
VOID Cleanup()
{
if( g_pMeshMaterials != NULL )
delete[] g_pMeshMaterials;
if( g_pMeshTextures )
{
for( DWORD i = 0; i < g_dwNumMaterials; i++ )
{
if( g_pMeshTextures[i] )
g_pMeshTextures[i]->Release();
}
delete[] g_pMeshTextures;
}
if( g_pMesh != NULL )
g_pMesh->Release();
if( g_pd3dDevice != NULL )
g_pd3dDevice->Release();
if( g_pD3D != NULL )
g_pD3D->Release();
}
RString SetD3DParams( bool &bNewDeviceOut )
{
if( g_pd3dDevice == NULL ) // device is not yet created. We need to create it
{
bNewDeviceOut = true;
HRESULT hr = g_pd3d->CreateDevice(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
GraphicsWindow::GetHwnd(),
D3DCREATE_SOFTWARE_VERTEXPROCESSING | D3DCREATE_MULTITHREADED,
&g_d3dpp,
&g_pd3dDevice );
if( FAILED(hr) )
{
// Likely D3D_ERR_INVALIDCALL. The driver probably doesn't support this video mode.
return ssprintf( "CreateDevice failed: '%s'", GetErrorString(hr).c_str() );
}
}
else
{
bNewDeviceOut = false;
//LOG->Warn( "Resetting D3D device" );
HRESULT hr = g_pd3dDevice->Reset( &g_d3dpp );
if( FAILED(hr) )
{
// Likely D3D_ERR_INVALIDCALL. The driver probably doesn't support this video mode.
return ssprintf("g_pd3dDevice->Reset failed: '%s'", GetErrorString(hr).c_str() );
}
}
g_pd3dDevice->SetRenderState( D3DRS_NORMALIZENORMALS, TRUE );
// Palettes were lost by Reset(), so mark them unloaded.
g_TexResourceToPaletteIndex.clear();
return RString();
}
CString SetD3DParams( bool &bNewDeviceOut )
{
if( g_pd3dDevice == NULL ) // device is not yet created. We need to create it
{
bNewDeviceOut = true;
HRESULT hr = g_pd3d->CreateDevice(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
#if !defined(XBOX)
GraphicsWindow::GetHwnd(),
D3DCREATE_SOFTWARE_VERTEXPROCESSING | D3DCREATE_MULTITHREADED,
#else
NULL,
D3DCREATE_HARDWARE_VERTEXPROCESSING,
#endif
&g_d3dpp,
&g_pd3dDevice );
if( FAILED(hr) )
{
// Likely D3D_ERR_INVALIDCALL. The driver probably doesn't support this video mode.
return ssprintf( "CreateDevice failed: '%s'", GetErrorString(hr).c_str() );
}
}
else
{
bNewDeviceOut = false;
HRESULT hr = g_pd3dDevice->Reset( &g_d3dpp );
if( FAILED(hr) )
{
// Likely D3D_ERR_INVALIDCALL. The driver probably doesn't support this video mode.
return ssprintf("g_pd3dDevice->Reset failed: '%s'", GetErrorString(hr).c_str() );
}
}
return "";
}
int main(int argc, char* argv[])
{
int NoProtect = 0;
AllowLinear = true;
double MaxMSE = 4.0;
CmdLineArgs args;
if (args.size() == 1)
{
Usage();
return 1;
}
const char* InputDir = NULL;
const char* OutputFilename = "Textures.xpr";
for (unsigned int i = 1; i < args.size(); ++i)
{
if (!stricmp(args[i], "-help") || !stricmp(args[i], "-h") || !stricmp(args[i], "-?"))
{
Usage();
return 1;
}
else if (!stricmp(args[i], "-input") || !stricmp(args[i], "-i"))
{
InputDir = args[++i];
}
else if (!stricmp(args[i], "-output") || !stricmp(args[i], "-o"))
{
OutputFilename = args[++i];
}
else if (!stricmp(args[i], "-noprotect") || !stricmp(args[i], "-p"))
{
NoProtect = 1;
}
else if (!stricmp(args[i], "-onlyswizzled") || !stricmp(args[i], "-s"))
{
AllowLinear = false;
}
else if (!stricmp(args[i], "-quality") || !stricmp(args[i], "-q"))
{
++i;
if (!stricmp(args[i], "min"))
{
MaxMSE = DBL_MAX;
}
else if (!stricmp(args[i], "low"))
{
MaxMSE = 20.0;
}
else if (!stricmp(args[i], "normal"))
{
MaxMSE = 4.0;
}
else if (!stricmp(args[i], "high"))
{
MaxMSE = 1.5;
}
else if (!stricmp(args[i], "max"))
{
MaxMSE = 0.0;
}
else
{
printf("Unrecognised quality setting: %s\n", args[i]);
}
}
else
{
printf("Unrecognised command line flag: %s\n", args[i]);
}
}
// Initialize DirectDraw
pD3D = Direct3DCreate8(D3D_SDK_VERSION);
if (pD3D == NULL)
{
puts("Cannot init D3D");
return 1;
}
HRESULT hr;
D3DDISPLAYMODE dispMode;
D3DPRESENT_PARAMETERS presentParams;
pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &dispMode);
ZeroMemory(&presentParams, sizeof(presentParams));
presentParams.Windowed = TRUE;
presentParams.hDeviceWindow = GetConsoleWindow();
presentParams.SwapEffect = D3DSWAPEFFECT_COPY;
presentParams.BackBufferWidth = 8;
presentParams.BackBufferHeight = 8;
presentParams.BackBufferFormat = dispMode.Format;
hr = pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, NULL, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &presentParams, &pD3DDevice);
if (FAILED(hr))
{
printf("Cannot init D3D device: %08x\n", hr);
pD3D->Release();
return 1;
}
char HomeDir[MAX_PATH];
GetCurrentDirectory(MAX_PATH, HomeDir);
XPRFile.OutputBuf = (char*)VirtualAlloc(0, 64 * 1024 * 1024, MEM_RESERVE, PAGE_NOACCESS);
if (!XPRFile.OutputBuf)
{
printf("Memory allocation failure: %08x\n", GetLastError());
pD3DDevice->Release();
pD3D->Release();
return 1;
}
Bundler.StartBundle();
// Scan the input directory (or current dir if false) for media files
ConvertDirectory(InputDir, NULL, MaxMSE);
VirtualFree(XPRFile.OutputBuf, 0, MEM_RELEASE);
pD3DDevice->Release();
pD3D->Release();
SetCurrentDirectory(HomeDir);
DWORD attr = GetFileAttributes(OutputFilename);
if (attr != -1 && (attr & FILE_ATTRIBUTE_DIRECTORY))
{
SetCurrentDirectory(OutputFilename);
OutputFilename = "Textures.xpr";
}
printf("\nWriting bundle: %s", OutputFilename);
int BundleSize = Bundler.WriteBundle(OutputFilename, NoProtect);
if (BundleSize == -1)
{
printf("\nERROR: %08x\n", GetLastError());
return 1;
}
printf("\nUncompressed texture size: %6dkB\nCompressed texture size: %8dkB\nBundle size: %8dkB\n\nWasted Pixels: %u/%u (%5.2f%%)\n",
(UncompressedSize + 1023) / 1024, (((CompressedSize + 1023) / 1024) + 3) & ~3, (BundleSize + 1023) / 1024,
TotalDstPixels - TotalSrcPixels, TotalDstPixels, 100.f * (float)(TotalDstPixels - TotalSrcPixels) / (float)TotalDstPixels);
return 0;
}
/* If the given parameters have failed, try to lower them. */
bool D3DReduceParams( D3DPRESENT_PARAMETERS *pp )
{
D3DDISPLAYMODE current;
current.Format = pp->BackBufferFormat;
current.Height = pp->BackBufferHeight;
current.Width = pp->BackBufferWidth;
current.RefreshRate = pp->FullScreen_RefreshRateInHz;
const int iCnt = g_pd3d->GetAdapterModeCount( D3DADAPTER_DEFAULT );
int iBest = -1;
int iBestScore = 0;
LOG->Trace( "cur: %ux%u %uHz, format %i", current.Width, current.Height, current.RefreshRate, current.Format );
for( int i = 0; i < iCnt; ++i )
{
D3DDISPLAYMODE mode;
g_pd3d->EnumAdapterModes( D3DADAPTER_DEFAULT, i, &mode );
/* Never change the format. */
if( mode.Format != current.Format )
continue;
/* Never increase the parameters. */
if( mode.Height > current.Height || mode.Width > current.Width || mode.RefreshRate > current.RefreshRate )
continue;
/* Never go below 640x480 unless we already are. */
if( (current.Width >= 640 && current.Height >= 480) && (mode.Width < 640 || mode.Height < 480) )
continue;
/* Never go below 60Hz. */
if( mode.RefreshRate && mode.RefreshRate < 60 )
continue;
/* If mode.RefreshRate is 0, it means "default". We don't know what that means;
* assume it's 60Hz. */
/* Higher scores are better. */
int iScore = 0;
if( current.RefreshRate >= 70 && mode.RefreshRate < 70 )
{
/* Top priority: we really want to avoid dropping to a refresh rate that's
* below 70Hz. */
iScore -= 100000;
}
else if( mode.RefreshRate < current.RefreshRate )
{
/* Low priority: We're lowering the refresh rate, but not too far. current.RefreshRate
* might be 0, in which case this simply gives points for higher refresh
* rates. */
iScore += (mode.RefreshRate - current.RefreshRate);
}
/* Medium priority: */
int iResolutionDiff = (current.Height - mode.Height) + (current.Width - mode.Width);
iScore -= iResolutionDiff * 100;
if( iBest == -1 || iScore > iBestScore )
{
iBest = i;
iBestScore = iScore;
}
LOG->Trace( "try: %ux%u %uHz, format %i: score %i", mode.Width, mode.Height, mode.RefreshRate, mode.Format, iScore );
}
if( iBest == -1 )
return false;
D3DDISPLAYMODE BestMode;
g_pd3d->EnumAdapterModes( D3DADAPTER_DEFAULT, iBest, &BestMode );
pp->BackBufferHeight = BestMode.Height;
pp->BackBufferWidth = BestMode.Width;
pp->FullScreen_RefreshRateInHz = BestMode.RefreshRate;
return true;
}
CString RageDisplay_D3D::Init( VideoModeParams p )
{
GraphicsWindow::Initialize();
LOG->Trace( "RageDisplay_D3D::RageDisplay_D3D()" );
LOG->MapLog("renderer", "Current renderer: Direct3D");
typedef IDirect3D8 * (WINAPI * Direct3DCreate8_t) (UINT SDKVersion);
Direct3DCreate8_t pDirect3DCreate8;
#if defined(XBOX)
pDirect3DCreate8 = Direct3DCreate8;
#else
g_D3D8_Module = LoadLibrary("D3D8.dll");
if(!g_D3D8_Module)
return D3D_NOT_INSTALLED;
pDirect3DCreate8 = (Direct3DCreate8_t) GetProcAddress(g_D3D8_Module, "Direct3DCreate8");
if(!pDirect3DCreate8)
{
LOG->Trace( "Direct3DCreate8 not found" );
return D3D_NOT_INSTALLED;
}
#endif
g_pd3d = pDirect3DCreate8( D3D_SDK_VERSION );
if(!g_pd3d)
{
LOG->Trace( "Direct3DCreate8 failed" );
return D3D_NOT_INSTALLED;
}
if( FAILED( g_pd3d->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &g_DeviceCaps) ) )
return
"Your system is reporting that Direct3D hardware acceleration is not available. "
"Please obtain an updated driver from your video card manufacturer.\n\n";
D3DADAPTER_IDENTIFIER8 identifier;
g_pd3d->GetAdapterIdentifier( D3DADAPTER_DEFAULT, 0, &identifier );
LOG->Trace(
"Driver: %s\n"
"Description: %s\n"
"Max texture size: %d\n"
"Alpha in palette: %s\n",
identifier.Driver,
identifier.Description,
g_DeviceCaps.MaxTextureWidth,
(g_DeviceCaps.TextureCaps & D3DPTEXTURECAPS_ALPHAPALETTE) ? "yes" : "no" );
LOG->Trace( "This display adaptor supports the following modes:" );
D3DDISPLAYMODE mode;
for( UINT u=0; u<g_pd3d->GetAdapterModeCount(D3DADAPTER_DEFAULT); u++ )
if( SUCCEEDED( g_pd3d->EnumAdapterModes( D3DADAPTER_DEFAULT, u, &mode ) ) )
LOG->Trace( " %ux%u %uHz, format %d", mode.Width, mode.Height, mode.RefreshRate, mode.Format );
g_PaletteIndex.clear();
for( int i = 0; i < 256; ++i )
g_PaletteIndex.push_back(i);
// Save the original desktop format.
g_pd3d->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &g_DesktopMode );
/* Up until now, all we've done is set up g_pd3d and do some queries. Now,
* actually initialize the window. Do this after as many error conditions
* as possible, because if we have to shut it down again we'll flash a window
* briefly. */
bool bIgnore = false;
return SetVideoMode( p, bIgnore );
}
int APIENTRY WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
// TODO: Place code here.
HWND hwnd;
MSG msg;
char appname[6];
strcpy(appname,"test1");
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = NULL;
wc.hCursor = LoadCursor(NULL,IDC_ARROW);
wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = NULL;
wc.lpszClassName = appname;
RegisterClass(&wc);
hwnd = CreateWindowEx(0/*WS_EX_TOPMOST*/,appname,NULL,WS_VISIBLE | WS_BORDER | WS_SYSMENU,0,0,800,600,NULL,NULL,hInstance,NULL);
ShowWindow(hwnd,SW_SHOW);
SetFocus(hwnd);
if(NULL == (pd3d = Direct3DCreate8( D3D_SDK_VERSION )))
{
MessageBox(hwnd,"Failed to create D3D object",ERROR,MB_ICONERROR | MB_OK | MB_SYSTEMMODAL);
//PostQuitMessage(0);
return false;
}
D3DPRESENT_PARAMETERS d3dpp;
D3DDISPLAYMODE d3ddm;
/*d3ddm.Width = 800;
d3ddm.Height = 600;
d3ddm.RefreshRate = 0;
d3ddm.Format = D3DFMT_A8R8G8B8;
*/pd3d->GetAdapterDisplayMode( D3DADAPTER_DEFAULT, &d3ddm );
ZeroMemory( &d3dpp, sizeof(d3dpp) );
/*d3dpp.BackBufferWidth = 800;
d3dpp.BackBufferHeight = 600;
d3dpp.BackBufferCount = 1;
d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp.Windowed = FALSE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = d3ddm.Format;
d3dpp.hDeviceWindow = NULL;
d3dpp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER ;
d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
d3dpp.FullScreen_PresentationInterval = D3DPRESENT_INTERVAL_ONE;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
*/d3dpp.Windowed = TRUE;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.BackBufferFormat = d3ddm.Format;
d3dpp.EnableAutoDepthStencil = TRUE;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8;
if(FAILED(pd3d->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &d3ddevice )))
{
MessageBox(hwnd,"Failed to Initialize D3D object",ERROR,MB_ICONERROR | MB_OK | MB_SYSTEMMODAL);
//PostQuitMessage(0);
return false;
}
setup();
SetTimer(hwnd,1,20,NULL);
//ShowCursor(false);
while(!done)
{
while(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
//if(msg.message == WM_QUIT) break;
StartFrame();
Render();
EndFrame();
}
KillTimer(hwnd,1);
shutdown();
if( d3ddevice != NULL)
d3ddevice->Release();
if( pd3d != NULL)
pd3d->Release();
//ShowCursor(true);
return 0;
}
//*******
// this function initializes Direct3D...
bool init3D(HWND hWnd)
{
D3DDISPLAYMODE d3ddm; // Direct3D Display Mode..
D3DPRESENT_PARAMETERS d3dpp; // d3d present parameters..details on how it should present
// a scene.. such as swap effect.. size.. windowed or full screen..
HFONT fnt;
// create D3D8.. if error (like that ever happens..) return false..
if (NULL == (lpD3D8 = Direct3DCreate8(D3D_SDK_VERSION)))
return false;
// get display adapter mode.. if error return false..
if (FAILED(lpD3D8->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm)))
return false;
// NOTE: it's possible that this example will not work as is
// in windowed mode due to display format and depth buffer format
ZeroMemory(&d3dpp, sizeof(d3dpp)); // blank the memory for good measure..
// d3dpp.Windowed = true; // use this for window mode..
d3dpp.Windowed = false; // use this for full screen... it's that easy!
d3dpp.BackBufferWidth = 1024; // rather useless for windowed version
d3dpp.BackBufferHeight = 768; // ditto..but left it in anyway for full screen
d3dpp.SwapEffect = D3DSWAPEFFECT_FLIP; // flip using a back buffer...easy performance
d3dpp.BackBufferFormat = D3DFMT_R5G6B5; // just set back buffer format from display mode
d3dpp.EnableAutoDepthStencil = true;
d3dpp.AutoDepthStencilFormat = D3DFMT_D16; // 16 bit depth buffer..
// Create the D3DDevice
if (FAILED(lpD3D8->CreateDevice(D3DADAPTER_DEFAULT, // which display adapter..
D3DDEVTYPE_HAL,
hWnd, D3DCREATE_MIXED_VERTEXPROCESSING, // mixed, software, or hardware..
&d3dpp, &lpD3DDevice8))) // sends stuff.. and to receive
{ // if it fails to create with HAL, then try (usually succeeds) to create
// with ref (software) using a much lower screen res
d3dpp.BackBufferWidth = 320;
d3dpp.BackBufferHeight = 240;
d3dpp.Windowed = false;
if (FAILED(lpD3D8->CreateDevice(D3DADAPTER_DEFAULT,
D3DDEVTYPE_REF,
hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING,
&d3dpp, &lpD3DDevice8)))
{
return false;
}
else
{ // create smaller font for software... lower res..
fnt = CreateFont(20, 10, 2, 0, 500, 0, 0, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FF_MODERN, 0);
// disable dithering for software..
lpD3DDevice8->SetRenderState( D3DRS_DITHERENABLE, false);
}
}
else
{ // create larger font for hardware.. higher res
fnt = CreateFont(50, 22, 2, 0, 500, 0, 0, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, FF_MODERN, 0);
// enable dithering for hardware...
lpD3DDevice8->SetRenderState( D3DRS_DITHERENABLE, true);
}
lpD3DDevice8->SetRenderState( D3DRS_CULLMODE, D3DCULL_NONE );
lpD3DDevice8->SetRenderState( D3DRS_ZENABLE, false);
lpD3DDevice8->SetRenderState( D3DRS_LIGHTING, false );
// create a D3DXFont from a windows font created above...
// for use in drawing text with D3D
D3DXCreateFont(lpD3DDevice8, fnt, &lpD3DXFont);
lpD3DDevice8->SetRenderState(D3DRS_ALPHABLENDENABLE , true);
lpD3DDevice8->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
lpD3DDevice8->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_SRCALPHA);
return true;
}
