path: root/Runtime/GfxDevice/d3d/D3D9Enumeration.cpp

#include "UnityPrefix.h"
#include "D3D9Enumeration.h"
#include "D3D9Utils.h"
#include "Runtime/GfxDevice/VramLimits.h"

// ---------------------------------------------------------------------------


const int kMinDisplayWidth = 512;
const int kMinDisplayHeight = 384;
const int kMinColorBits = 4;
const int kMinAlphaBits = 0;

extern D3DDEVTYPE g_D3DDevType;
extern DWORD g_D3DAdapter;

// ---------------------------------------------------------------------------

static int GetFormatColorBits( D3DFORMAT fmt ) {
	switch( fmt ) {
	case D3DFMT_A2B10G10R10:
	case D3DFMT_A2R10G10B10:	return 10;
	case D3DFMT_R8G8B8:
	case D3DFMT_A8R8G8B8:
	case D3DFMT_X8R8G8B8:		return 8;
	case D3DFMT_R5G6B5:
	case D3DFMT_X1R5G5B5:
	case D3DFMT_A1R5G5B5:		return 5;
	case D3DFMT_A4R4G4B4:
	case D3DFMT_X4R4G4B4:		return 4;
	case D3DFMT_R3G3B2:
	case D3DFMT_A8R3G3B2:		return 2;
	default:					return 0;
	}
}

static int GetFormatAlphaBits( D3DFORMAT fmt ) {
	switch( fmt ) {
	case D3DFMT_R8G8B8:
	case D3DFMT_X8R8G8B8:
	case D3DFMT_R5G6B5:
	case D3DFMT_X1R5G5B5:
	case D3DFMT_R3G3B2:
	case D3DFMT_X4R4G4B4:		return 0;
	case D3DFMT_A8R8G8B8:
	case D3DFMT_A8R3G3B2:		return 8;
	case D3DFMT_A1R5G5B5:		return 1;
	case D3DFMT_A4R4G4B4:		return 4;
	case D3DFMT_A2B10G10R10:
	case D3DFMT_A2R10G10B10:	return 2;
	default:					return 0;
	}
}

int GetFormatDepthBits( D3DFORMAT fmt ) {
	switch( fmt ) {
	case D3DFMT_D16:		return 16;
	case D3DFMT_D15S1:		return 15;
	case D3DFMT_D24X8:
	case D3DFMT_D24S8:
	case D3DFMT_D24X4S4:	return 24;
	case D3DFMT_D32:		return 32;
	default:				return 0;
	}
}

static D3DFORMAT ConvertToAlphaFormat( D3DFORMAT fmt )
{
	if( fmt == D3DFMT_X8R8G8B8 )
		fmt = D3DFMT_A8R8G8B8;
	else if( fmt == D3DFMT_X4R4G4B4 )
		fmt = D3DFMT_A4R4G4B4;
	else if( fmt == D3DFMT_X1R5G5B5 )
		fmt = D3DFMT_A1R5G5B5;
	return fmt;
}

// -----------------------------------------------------------------------------


static UInt32 buildVertexProcessings( const D3DCAPS9& caps )
{
	UInt32 result =  0;

	// TODO: check vertex shader version

	DWORD devCaps = caps.DevCaps;
	if( devCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ) {
		if( devCaps & D3DDEVCAPS_PUREDEVICE ) {
			result |= (1<<kVPPureHardware);
		}
		result |= (1<<kVPHardware);
		result |= (1<<kVPMixed);
	}

	result |= (1<<kVPSoftware);

	return result;
}


static void buildDepthStencilFormats( IDirect3D9& d3d, D3DDeviceCombo& devCombo )
{
	const D3DFORMAT dsFormats[] = {
		D3DFMT_D24S8, D3DFMT_D24X8, D3DFMT_D24X4S4, D3DFMT_D16, D3DFMT_D15S1, D3DFMT_D32,
	};
	const int dsFormatCount = sizeof(dsFormats) / sizeof(dsFormats[0]);
	
	for( int idsf = 0; idsf < dsFormatCount; ++idsf ) {
		D3DFORMAT format = dsFormats[idsf];
		if( SUCCEEDED( d3d.CheckDeviceFormat( g_D3DAdapter, g_D3DDevType, devCombo.adapterFormat, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_SURFACE, format ) ) )
		{
			if( SUCCEEDED( d3d.CheckDepthStencilMatch( g_D3DAdapter, g_D3DDevType, devCombo.adapterFormat, devCombo.backBufferFormat, format ) ) )
			{
				devCombo.depthStencilFormats.push_back( format );
			}
		}
	}
}


static void buildMultiSampleTypes( IDirect3D9& d3d, D3DDeviceCombo& devCombo )
{
	const size_t kMaxSamples = 16;
	devCombo.multiSampleTypes.reserve( kMaxSamples );
	devCombo.multiSampleTypes.push_back( D3DMULTISAMPLE_NONE );

	for( int samples = 2; samples <= kMaxSamples; ++samples ) {
		D3DMULTISAMPLE_TYPE	msType = GetD3DMultiSampleType( samples );
		DWORD msQuality;
		if( SUCCEEDED( d3d.CheckDeviceMultiSampleType( g_D3DAdapter, g_D3DDevType, devCombo.backBufferFormat, devCombo.isWindowed, msType, NULL ) ) )
			devCombo.multiSampleTypes.push_back( samples );
	}
}


static void buildConflicts( IDirect3D9& d3d, D3DDeviceCombo& devCombo )
{
	for( size_t ids = 0; ids < devCombo.depthStencilFormats.size(); ++ids ) {
		D3DFORMAT format = (D3DFORMAT)devCombo.depthStencilFormats[ids];
		for( size_t ims = 0; ims < devCombo.multiSampleTypes.size(); ++ims ) {
			D3DMULTISAMPLE_TYPE msType = (D3DMULTISAMPLE_TYPE)devCombo.multiSampleTypes[ims];
			if( FAILED( d3d.CheckDeviceMultiSampleType(
				g_D3DAdapter, g_D3DDevType,
				format, devCombo.isWindowed, msType, NULL ) ) )
			{
				D3DDeviceCombo::MultiSampleConflict conflict;
				conflict.format = format;
				conflict.type = msType;
				devCombo.conflicts.push_back( conflict );
			}
		}
	}
}


static bool enumerateDeviceCombos( IDirect3D9& d3d, const D3DCAPS9& caps, const DwordVector& adapterFormats, D3DDeviceComboVector& outCombos )
{
	const D3DFORMAT bbufferFormats[] = {
		D3DFMT_A8R8G8B8, D3DFMT_X8R8G8B8, D3DFMT_A2R10G10B10,
		D3DFMT_R5G6B5, D3DFMT_A1R5G5B5, D3DFMT_X1R5G5B5
	};
	const int bbufferFormatCount = sizeof(bbufferFormats) / sizeof(bbufferFormats[0]);

	bool isWindowedArray[] = { false, true };

	// see which adapter formats are supported by this device
	for( size_t iaf = 0; iaf < adapterFormats.size(); ++iaf )
	{
		D3DFORMAT format = (D3DFORMAT)adapterFormats[iaf];
		for( int ibbf = 0; ibbf < bbufferFormatCount; ibbf++ )
		{
			D3DFORMAT bbufferFormat = bbufferFormats[ibbf];
			if( GetFormatAlphaBits(bbufferFormat) < kMinAlphaBits )
				continue;
			for( int iiw = 0; iiw < 2; ++iiw ) {
				bool isWindowed = isWindowedArray[iiw];
				if( FAILED( d3d.CheckDeviceType( g_D3DAdapter, g_D3DDevType, format, bbufferFormat, isWindowed ) ) )
					continue;

				// Here, we have an adapter format / backbuffer format/ windowed
				// combo that is supported by the system. We still need to find one or
				// more suitable depth/stencil buffer format, multisample type,
				// vertex processing type, and vsync.
				D3DDeviceCombo devCombo;

				devCombo.adapterFormat = format;
				devCombo.backBufferFormat = bbufferFormat;
				devCombo.isWindowed = isWindowed;
				devCombo.presentationIntervals = caps.PresentationIntervals;

				buildDepthStencilFormats( d3d, devCombo );
				if( devCombo.depthStencilFormats.empty() )
					continue;

				buildMultiSampleTypes( d3d, devCombo );
				if( devCombo.multiSampleTypes.empty() )
					continue;

				buildConflicts( d3d, devCombo );

				outCombos.push_back( devCombo );
			}
		}
	}

	return !outCombos.empty();
}


bool D3D9FormatCaps::Enumerate( IDirect3D9& d3d )
{
	AssertIf( !m_Combos.empty() );
	HRESULT hr;

	const D3DFORMAT allowedFormats[] = {
		D3DFMT_X8R8G8B8, D3DFMT_X1R5G5B5, D3DFMT_R5G6B5, D3DFMT_A2R10G10B10
	};
	const int allowedFormatCount = sizeof(allowedFormats) / sizeof(allowedFormats[0]);

	m_AdapterFormatForChecks = D3DFMT_UNKNOWN;

	// build a list of all display adapter formats
	DwordVector adapterFormatList; // D3DFORMAT

	for( size_t ifmt = 0; ifmt < allowedFormatCount; ++ifmt )
	{
		D3DFORMAT format = allowedFormats[ifmt];
		int modeCount = d3d.GetAdapterModeCount( g_D3DAdapter, format );
		for( int mode = 0; mode < modeCount; ++mode ) {
			D3DDISPLAYMODE dm;
			d3d.EnumAdapterModes( g_D3DAdapter, format, mode, &dm );
			if( dm.Width < (UINT)kMinDisplayWidth || dm.Height < (UINT)kMinDisplayHeight || GetFormatColorBits(dm.Format) < kMinColorBits )
				continue;
			// adapterInfo->displayModes.push_back( dm );
			if( std::find(adapterFormatList.begin(),adapterFormatList.end(),dm.Format) == adapterFormatList.end() ) {
				adapterFormatList.push_back( dm.Format );
				if( m_AdapterFormatForChecks == D3DFMT_UNKNOWN )
					m_AdapterFormatForChecks = format;
			}
		}
	}

	if( m_AdapterFormatForChecks == D3DFMT_UNKNOWN ) // for some reason no format was selected for checks, use default
		m_AdapterFormatForChecks = allowedFormats[0];

	// get info for device on this adapter
	D3DCAPS9 caps;
	if( FAILED( d3d.GetDeviceCaps( g_D3DAdapter, g_D3DDevType, &caps ) ) )
		return false;

	// find suitable vertex processing modes (if any)
	m_VertexProcessings = buildVertexProcessings( caps );
	AssertIf( !m_VertexProcessings );

	// get info for each device combo on this device
	if( !enumerateDeviceCombos( d3d, caps, adapterFormatList, m_Combos ) )
		return false;

	return true;
}


void D3D9FormatCaps::FindBestPresentationParams( int width, int height, D3DFORMAT desktopMode, bool windowed, int vBlankCount, int multiSample, D3DPRESENT_PARAMETERS& outParams ) const
{
	const D3DDeviceCombo* bestCombo = NULL;
	int bestScore = -1;

	for( size_t idc = 0; idc < m_Combos.size(); ++idc )
	{
		const D3DDeviceCombo& devCombo = m_Combos[idc];
		if( windowed && !devCombo.isWindowed )
			continue;
		if( !windowed && devCombo.isWindowed )
			continue;
		if( windowed )
		{
			if( devCombo.adapterFormat != desktopMode )
				continue;
		}

		int score = 0;

		bool matchesBB = (devCombo.backBufferFormat == ConvertToAlphaFormat(devCombo.adapterFormat));
		bool matchesDesktop = (devCombo.adapterFormat == desktopMode);

		if( matchesBB )
			score += 1;
		if( matchesDesktop )
			score += 1;
		if( GetFormatAlphaBits(devCombo.backBufferFormat) > 0 )
			score += 1;

		if( score > bestScore )
		{
			bestScore = score;
			bestCombo = &devCombo;
		}
	}

	if( !bestCombo )
	{
		// This can happen if we're debugging force-16BPP modes on a 32BPP desktop, and so on
		outParams.BackBufferFormat = desktopMode;
		outParams.AutoDepthStencilFormat = D3DFMT_D16;
		outParams.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
		outParams.MultiSampleType = D3DMULTISAMPLE_NONE;
		outParams.MultiSampleQuality = 0;
		return;
	}

	outParams.BackBufferFormat = bestCombo->backBufferFormat;
	outParams.AutoDepthStencilFormat = (D3DFORMAT)bestCombo->depthStencilFormats[0];

	// No support for intervals above 1 in windowed mode (case 497116)
	if (windowed && vBlankCount > 1)
		vBlankCount = 1;

	// best possible vsync parameter (if device doesn't support 2 fall back to 1)
	DWORD intervals = bestCombo->presentationIntervals;
	outParams.PresentationInterval = ( vBlankCount >= 2 ) && ( intervals & D3DPRESENT_INTERVAL_TWO ) ? D3DPRESENT_INTERVAL_TWO :
									 ( vBlankCount >= 1 ) && ( intervals & D3DPRESENT_INTERVAL_ONE ) ? D3DPRESENT_INTERVAL_ONE :
									 ( vBlankCount == 0 ) && ( intervals & D3DPRESENT_INTERVAL_IMMEDIATE ) ? D3DPRESENT_INTERVAL_IMMEDIATE :
									 D3DPRESENT_INTERVAL_DEFAULT;

	// Here we already know backbuffer, depth buffer formats and so on, so we can also clamp used FSAA to sane VRAM limits.
	int backbufferBPP = GetBPPFromD3DFormat(outParams.BackBufferFormat)/8;
	int frontbufferBPP = GetBPPFromD3DFormat(desktopMode)/8;
	int depthBPP = GetBPPFromD3DFormat(outParams.AutoDepthStencilFormat)/8;
	multiSample = ChooseSuitableFSAALevel( width, height, backbufferBPP, frontbufferBPP, depthBPP, multiSample );

	// Find out best matched multi sample type.
	int msIdx = 0;
	if( multiSample > 1 )
	{
		while( msIdx < bestCombo->multiSampleTypes.size() && bestCombo->multiSampleTypes[msIdx] <= multiSample )
			++msIdx;
		--msIdx;
		AssertIf( msIdx < 0 );
	}
	outParams.MultiSampleType = GetD3DMultiSampleType(bestCombo->multiSampleTypes[msIdx]);
	outParams.MultiSampleQuality = 0;
}