d3dsettings.cpp

java实现的简单的分形树。简单易学！是学习分形知识的很好的例子。其java语法简单

 *  Respond to a change of windowed/fullscreen state by rebuilding the adapter
 *  format list, resolution list, and refresh rate list. Updating the selected
 *  adapter format will trigger updates of the rest of the dialog.
 */
void CD3DSettingsDialog::windowedFullscreenChanged()
{
	const SD3DAdapterInfo* adInfo = (const SD3DAdapterInfo*)comboBoxSelected( IDC_ADAPTER_COMBO );
	const SD3DDeviceInfo* devInfo = (const SD3DDeviceInfo*)comboBoxSelected( IDC_DEVICE_COMBO );
	if( adInfo == NULL || devInfo == NULL )
		return;
	
	if( IsDlgButtonChecked( mDlg, IDC_WINDOW ) ) {

		//
		// windowed

		mSettings.mMode = CD3DSettings::WINDOWED;
		mSettings.mSettings[mSettings.mMode].adapterInfo = adInfo;
		mSettings.mSettings[mSettings.mMode].deviceInfo = devInfo;
		
		const D3DDISPLAYMODE& dm = mSettings.getDisplayMode();

		// Update adapter format combo box
		comboBoxClear( IDC_ADAPTERFORMAT_COMBO );
		comboBoxAdd( IDC_ADAPTERFORMAT_COMBO, ULongToPtr(dm.Format), dingus::convertD3DFormatToString( dm.Format ) );
		comboBoxSelectIndex( IDC_ADAPTERFORMAT_COMBO, 0 );
		EnableWindow( GetDlgItem( mDlg, IDC_ADAPTERFORMAT_COMBO ), false );
		
		// update resolution combo box
		DWORD dwResolutionData;
		TCHAR strResolution[50];
		dwResolutionData = MAKELONG( dm.Width, dm.Height );
		_sntprintf( strResolution, 50, TEXT("%d x %d"), dm.Width, dm.Height );
		strResolution[49] = 0;
		comboBoxClear( IDC_RESOLUTION_COMBO );
		comboBoxAdd( IDC_RESOLUTION_COMBO, ULongToPtr(dwResolutionData), strResolution );
		comboBoxSelectIndex( IDC_RESOLUTION_COMBO, 0 );
		EnableWindow( GetDlgItem( mDlg, IDC_RESOLUTION_COMBO ), false );
		
		// update refresh rate combo box
		TCHAR strRefreshRate[50];
		if( dm.RefreshRate == 0 )
			lstrcpy( strRefreshRate, TEXT("Default rate") );
		else
			_sntprintf( strRefreshRate, 50, TEXT("%d Hz"), dm.RefreshRate );
		strRefreshRate[49] = 0;
		comboBoxClear( IDC_REFRESHRATE_COMBO );
		comboBoxAdd( IDC_REFRESHRATE_COMBO, ULongToPtr(dm.RefreshRate),
			strRefreshRate );
		comboBoxSelectIndex( IDC_REFRESHRATE_COMBO, 0 );
		EnableWindow( GetDlgItem( mDlg, IDC_REFRESHRATE_COMBO ), false );

	} else {

		//
		// fullscreen

		mSettings.mMode = CD3DSettings::FULLSCREEN;
		mSettings.mSettings[mSettings.mMode].adapterInfo = adInfo;
		mSettings.mSettings[mSettings.mMode].deviceInfo = devInfo;
		
		const D3DDISPLAYMODE& dm = mSettings.getDisplayMode();

		// update adapter format combo box
		comboBoxClear( IDC_ADAPTERFORMAT_COMBO );
		for( int idc = 0; idc < devInfo->deviceCombos.size(); ++idc ) {
			const SD3DDeviceCombo* devCombo = devInfo->deviceCombos[idc];
			D3DFORMAT fmt = devCombo->adapterFormat;
			if( !comboBoxContainsText( IDC_ADAPTERFORMAT_COMBO, dingus::convertD3DFormatToString( fmt ) ) ) {
				comboBoxAdd( IDC_ADAPTERFORMAT_COMBO, ULongToPtr(fmt), 
					dingus::convertD3DFormatToString( fmt ) );
				if( fmt == dm.Format )
					comboBoxSelect( IDC_ADAPTERFORMAT_COMBO, ULongToPtr(fmt) );
			}
		}
		if( !comboBoxSomethingSelected( IDC_ADAPTERFORMAT_COMBO ) && comboBoxCount( IDC_ADAPTERFORMAT_COMBO ) > 0 )
			comboBoxSelectIndex( IDC_ADAPTERFORMAT_COMBO, 0 );

		EnableWindow( GetDlgItem( mDlg, IDC_ADAPTERFORMAT_COMBO), true );
		
		// update resolution combo box
		EnableWindow( GetDlgItem( mDlg, IDC_RESOLUTION_COMBO), true );
		
		// update refresh rate combo box
		EnableWindow( GetDlgItem( mDlg, IDC_REFRESHRATE_COMBO), true );
	}
}


/**
 *  Respond to a change of selected adapter format by rebuilding the resolution
 *  list and back buffer format list. Updating the selected resolution and back
 *  buffer format will trigger updates of the rest of the dialog.
 */
void CD3DSettingsDialog::adapterFormatChanged()
{
	if( !IsDlgButtonChecked( mDlg, IDC_WINDOW ) ) {

		//
		// fullscreen

		const SD3DAdapterInfo* adInfo = (const SD3DAdapterInfo*)comboBoxSelected( IDC_ADAPTER_COMBO );
		D3DFORMAT fmt = (D3DFORMAT)PtrToUlong( comboBoxSelected( IDC_ADAPTERFORMAT_COMBO ) );
		mSettings.mSettings[CD3DSettings::FULLSCREEN].displayMode.Format = fmt;

		const D3DDISPLAYMODE& fullscreenDM = mSettings.mSettings[CD3DSettings::FULLSCREEN].displayMode;
		
		comboBoxClear( IDC_RESOLUTION_COMBO );
		for( int idm = 0; idm < adInfo->displayModes.size(); ++idm ) {
			const D3DDISPLAYMODE& dm = adInfo->displayModes[idm];
			if( dm.Format == fmt ) {
				DWORD dwResolutionData;
				TCHAR strResolution[50];
				dwResolutionData = MAKELONG( dm.Width, dm.Height );
				_sntprintf( strResolution, 50, TEXT("%d x %d"), dm.Width, dm.Height );
				strResolution[49] = 0;
				if( !comboBoxContainsText( IDC_RESOLUTION_COMBO, strResolution ) ) {
					comboBoxAdd( IDC_RESOLUTION_COMBO, ULongToPtr( dwResolutionData ), strResolution );
					if( fullscreenDM.Width == dm.Width && fullscreenDM.Height == dm.Height)
						comboBoxSelect( IDC_RESOLUTION_COMBO, ULongToPtr( dwResolutionData ) );
				}
			}
		}
		if( !comboBoxSomethingSelected( IDC_RESOLUTION_COMBO ) && comboBoxCount( IDC_RESOLUTION_COMBO ) > 0 )
			comboBoxSelectIndex( IDC_RESOLUTION_COMBO, 0 );
	}
	
	// update backbuffer format combo box
	const SD3DDeviceInfo* devInfo = (const SD3DDeviceInfo*)comboBoxSelected( IDC_DEVICE_COMBO );
	if( devInfo == NULL )
		return;

	comboBoxClear( IDC_BACKBUFFERFORMAT_COMBO );
	for( int idc = 0; idc < devInfo->deviceCombos.size(); ++idc ) {
		const SD3DDeviceCombo* devCombo = devInfo->deviceCombos[idc];
		bool settingsWnd = (mSettings.mMode == CD3DSettings::WINDOWED);

		if( devCombo->isWindowed == settingsWnd && devCombo->adapterFormat == mSettings.getDisplayMode().Format ) {
			if( !comboBoxContainsText( IDC_BACKBUFFERFORMAT_COMBO, dingus::convertD3DFormatToString( devCombo->backBufferFormat ) ) ) {
				comboBoxAdd( IDC_BACKBUFFERFORMAT_COMBO, ULongToPtr(devCombo->backBufferFormat),
					dingus::convertD3DFormatToString( devCombo->backBufferFormat ) );
				if( devCombo->backBufferFormat == mSettings.getBackBufferFormat() )
					comboBoxSelect( IDC_BACKBUFFERFORMAT_COMBO, ULongToPtr(devCombo->backBufferFormat) );
			}
		}
	}
	if( !comboBoxSomethingSelected( IDC_BACKBUFFERFORMAT_COMBO ) && comboBoxCount( IDC_BACKBUFFERFORMAT_COMBO ) > 0 )
		comboBoxSelectIndex( IDC_BACKBUFFERFORMAT_COMBO, 0 );
};


/** Respond to a change of selected resolution by rebuilding the refresh rate list. */
void CD3DSettingsDialog::resolutionChanged()
{
	if( mSettings.mMode	== CD3DSettings::WINDOWED )
		return;
	
	const SD3DAdapterInfo* adInfo = (const SD3DAdapterInfo*)comboBoxSelected( IDC_ADAPTER_COMBO );
	if( adInfo == NULL )
		return;
	
	// update settings with new resolution
	DWORD dwResolutionData = PtrToUlong( comboBoxSelected( IDC_RESOLUTION_COMBO ) );
	UINT width = LOWORD( dwResolutionData );
	UINT height = HIWORD( dwResolutionData );
	mSettings.getDisplayMode().Width = width;
	mSettings.getDisplayMode().Height = height;
	
	// update refresh rate list based on new resolution
	D3DFORMAT adapterFormat = (D3DFORMAT)PtrToUlong( comboBoxSelected( IDC_ADAPTERFORMAT_COMBO ) );
	comboBoxClear( IDC_REFRESHRATE_COMBO );
	for( int idm = 0; idm < adInfo->displayModes.size(); ++idm ) {
		const D3DDISPLAYMODE& dm = adInfo->displayModes[idm];
		if( dm.Format == adapterFormat &&
			dm.Width  == width &&
			dm.Height == height )
		{
			TCHAR strRefreshRate[50];
			if( dm.RefreshRate == 0 )
				lstrcpy( strRefreshRate, TEXT("Default Rate") );
			else
				_sntprintf( strRefreshRate, 50, TEXT("%d Hz"), dm.RefreshRate );
			strRefreshRate[49] = 0;
			if( !comboBoxContainsText( IDC_REFRESHRATE_COMBO, strRefreshRate ) ) {
				comboBoxAdd( IDC_REFRESHRATE_COMBO, UlongToPtr( dm.RefreshRate ), strRefreshRate );
				if( mSettings.getDisplayMode().RefreshRate == dm.RefreshRate )
					comboBoxSelect( IDC_REFRESHRATE_COMBO, UlongToPtr( dm.RefreshRate ) );
			}
		}
	}
	if( !comboBoxSomethingSelected( IDC_REFRESHRATE_COMBO ) && comboBoxCount( IDC_REFRESHRATE_COMBO ) > 0 )
		comboBoxSelectIndex( IDC_REFRESHRATE_COMBO, 0 );
}


/** Respond to a change of selected refresh rate. */
void CD3DSettingsDialog::refreshRateChanged()
{
	if( mSettings.mMode	== CD3DSettings::WINDOWED )
		return;
	
	// update settings with new refresh rate
	int refreshRate = PtrToUlong( comboBoxSelected( IDC_REFRESHRATE_COMBO ) );
	mSettings.getDisplayMode().RefreshRate = refreshRate;
}


/**
 *  Respond to a change of selected back buffer format by rebuilding the
 *  depth/stencil format list, multisample type list, and vertex processing list.
 */
void CD3DSettingsDialog::backBufferFormatChanged()
{
	const SD3DDeviceInfo* devInfo = (const SD3DDeviceInfo*)comboBoxSelected( IDC_DEVICE_COMBO );
	D3DFORMAT adapterFormat = (D3DFORMAT)PtrToUlong( comboBoxSelected( IDC_ADAPTERFORMAT_COMBO ) );
	D3DFORMAT backBufferFormat = (D3DFORMAT)PtrToUlong( comboBoxSelected( IDC_BACKBUFFERFORMAT_COMBO ) );
	if( devInfo == NULL )
		return;
	
	for( int idc = 0; idc < devInfo->deviceCombos.size(); ++idc ) {
		const SD3DDeviceCombo* devCombo = devInfo->deviceCombos[idc];
		bool settingsWnd = (mSettings.mMode == CD3DSettings::WINDOWED);
		if( devCombo->isWindowed == settingsWnd &&
			devCombo->adapterFormat == adapterFormat &&
			devCombo->backBufferFormat == backBufferFormat )
		{
			mSettings.mSettings[mSettings.mMode].deviceCombo = devCombo;
			
			comboBoxClear( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO );
			if( mEnumeration->mUsesDepthBuffer ) {
				for( int ifmt = 0; ifmt < devCombo->depthStencilFormats.size(); ++ifmt ) {
					D3DFORMAT fmt = (D3DFORMAT)devCombo->depthStencilFormats[ifmt];
					comboBoxAdd( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO, ULongToPtr(fmt), 
						dingus::convertD3DFormatToString(fmt) );
					if( fmt == mSettings.getDepthStencilFormat() )
						comboBoxSelect( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO, ULongToPtr(fmt) );
				}
				if( !comboBoxSomethingSelected( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO ) && 
					comboBoxCount( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO ) > 0 )
				{
					comboBoxSelectIndex( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO, 0 );
				}
			} else {
				EnableWindow( GetDlgItem( mDlg, IDC_DEPTHSTENCILBUFFERFORMAT_COMBO ), false );
				comboBoxAdd( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO, NULL, TEXT("(not used)") );
				comboBoxSelectIndex( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO, 0 );
			}
			
			comboBoxClear( IDC_VERTEXPROCESSING_COMBO );
			for( int ivpt = 0; ivpt < devCombo->vertexProcessings.size(); ++ivpt ) {
				eVertexProcessing vpt = (eVertexProcessing)devCombo->vertexProcessings[ivpt];
				comboBoxAdd( IDC_VERTEXPROCESSING_COMBO, ULongToPtr(vpt), gVertexProcessingToString(vpt) );
				if( vpt == mSettings.getVertexProcessing() )
					comboBoxSelect( IDC_VERTEXPROCESSING_COMBO, ULongToPtr(vpt) );
			}
			if( !comboBoxSomethingSelected( IDC_VERTEXPROCESSING_COMBO ) && 
				comboBoxCount( IDC_VERTEXPROCESSING_COMBO ) > 0 )
			{
				comboBoxSelectIndex( IDC_VERTEXPROCESSING_COMBO, 0 );
			}
			
			comboBoxClear( IDC_PRESENTINTERVAL_COMBO );
			for( int ipi = 0; ipi < devCombo->presentIntervals.size(); ++ipi ) {
				int pi = devCombo->presentIntervals[ipi];
				comboBoxAdd( IDC_PRESENTINTERVAL_COMBO, UlongToPtr( pi ), gPresentIntervalToString(pi) );
				if( pi == mSettings.getPresentInterval() )
					comboBoxSelect( IDC_PRESENTINTERVAL_COMBO, UlongToPtr( pi ) );
			}
			if( !comboBoxSomethingSelected( IDC_PRESENTINTERVAL_COMBO ) && 
				comboBoxCount( IDC_PRESENTINTERVAL_COMBO ) > 0 )
			{
				comboBoxSelectIndex( IDC_PRESENTINTERVAL_COMBO, 0 );
			}
			
			break;
		}
	}
}

/** Respond to a change of selected depth/stencil buffer format. */
void CD3DSettingsDialog::depthStencilBufferChanged()
{
	D3DFORMAT fmt = (D3DFORMAT)PtrToUlong( comboBoxSelected( IDC_DEPTHSTENCILBUFFERFORMAT_COMBO ) );
	if( mEnumeration->mUsesDepthBuffer )
		mSettings.setDepthStencilFormat( fmt );
	
	// build multisample list
	const SD3DDeviceCombo& devCombo = mSettings.getDeviceCombo();
	comboBoxClear( IDC_MULTISAMPLE_COMBO );
	for( int ims = 0; ims < devCombo.multiSampleTypes.size(); ++ims ) {
		D3DMULTISAMPLE_TYPE msType = (D3DMULTISAMPLE_TYPE)devCombo.multiSampleTypes[ims];
		
		// check for DS/MS conflicts
		bool conflictFound = false;
		for( int iconf = 0; iconf < devCombo.conflicts.size(); ++iconf ) {
			const SD3DDeviceCombo::SDSMSConflict& conf = devCombo.conflicts[iconf];
			if( conf.format == fmt && conf.type == msType ) {
				conflictFound = true;
				break;
			}
		}
		if( !conflictFound ) {
			comboBoxAdd( IDC_MULTISAMPLE_COMBO, ULongToPtr(msType), gMultiSampleTypeToString(msType) );
			if( msType == mSettings.getMultiSampleType() )
				comboBoxSelect( IDC_MULTISAMPLE_COMBO, ULongToPtr(msType) );
		}
	}
	if( !comboBoxSomethingSelected( IDC_MULTISAMPLE_COMBO ) && comboBoxCount( IDC_MULTISAMPLE_COMBO ) > 0 )
		comboBoxSelectIndex( IDC_MULTISAMPLE_COMBO, 0 );
}


/** Respond to a change of selected multisample type. */
void CD3DSettingsDialog::multiSampleTypeChanged()
{
	D3DMULTISAMPLE_TYPE mst = (D3DMULTISAMPLE_TYPE)PtrToUlong( comboBoxSelected( IDC_MULTISAMPLE_COMBO ) );
	mSettings.setMultiSampleType( mst );
	
	// set up max quality for this mst
	const SD3DDeviceCombo& devCombo = mSettings.getDeviceCombo();
	DWORD maxQuality = 0;
	
	for( int ims = 0; ims < devCombo.multiSampleTypes.size(); ++ims ) {
		D3DMULTISAMPLE_TYPE msType = (D3DMULTISAMPLE_TYPE)devCombo.multiSampleTypes[ims];
		if( msType == mst ) {
			maxQuality = devCombo.multiSampleQualities[ims];
			break;
		}
	}
	
	comboBoxClear( IDC_MULTISAMPLE_QUALITY_COMBO );
	for( int msq = 0; msq < maxQuality; msq++ ) {
		TCHAR str[100];
		wsprintf( str, TEXT("%d"), msq );
		comboBoxAdd( IDC_MULTISAMPLE_QUALITY_COMBO, UlongToPtr( msq ), str );
		if( msq == mSettings.getMultiSampleQuality() )
			comboBoxSelect( IDC_MULTISAMPLE_QUALITY_COMBO, UlongToPtr( msq ) );
	}
	if( !comboBoxSomethingSelected( IDC_MULTISAMPLE_QUALITY_COMBO ) && comboBoxCount( IDC_MULTISAMPLE_QUALITY_COMBO ) > 0 )
		comboBoxSelectIndex( IDC_MULTISAMPLE_QUALITY_COMBO, 0 );
}


/** Respond to a change of selected multisample quality. */
void CD3DSettingsDialog::multiSampleQualityChanged( void )
{
	DWORD msq = (DWORD)PtrToUlong( comboBoxSelected( IDC_MULTISAMPLE_QUALITY_COMBO ) );
	mSettings.setMultiSampleQuality( msq );
}


/** Respond to a change of selected vertex processing type. */
void CD3DSettingsDialog::vertexProcessingChanged( void )
{
	eVertexProcessing vpt = (eVertexProcessing)PtrToUlong( comboBoxSelected( IDC_VERTEXPROCESSING_COMBO ) );
	mSettings.setVertexProcessing( vpt );
}


/** Respond to a change of selected present interval. */
void CD3DSettingsDialog::presentIntervalChanged( void )
{
	UINT pi = PtrToUlong( comboBoxSelected( IDC_PRESENTINTERVAL_COMBO ) );
	mSettings.setPresentInterval( pi );
}