Renegade/Code/Tools/WWConfig/PerformanceConfigDialog.cpp

/*
**	Command & Conquer Renegade(tm)
**	Copyright 2025 Electronic Arts Inc.
**
**	This program is free software: you can redistribute it and/or modify
**	it under the terms of the GNU General Public License as published by
**	the Free Software Foundation, either version 3 of the License, or
**	(at your option) any later version.
**
**	This program is distributed in the hope that it will be useful,
**	but WITHOUT ANY WARRANTY; without even the implied warranty of
**	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**	GNU General Public License for more details.
**
**	You should have received a copy of the GNU General Public License
**	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// PerformanceConfigDialog.cpp : implementation file
//

#include "stdafx.h"
#include "wwconfig.h"
#include "performanceconfigdialog.h"
#include "registry.h"
#include "ww3d.h"
#include "pscene.h"
#include "rendobj.h"
#include "phys.h"
#include "videoconfigdialog.h"
#include "dx8caps.h"
#include "cpudetect.h"
#include "formconv.h"

#include "dx8wrapper.h"
#include "locale_api.h"
#include "wwconfig_ids.h"
#include "..\..\combat\specialbuilds.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

static bool CanDoMultiPass=true;

/////////////////////////////////////////////////////////////////////////////
// Structures and typedefs
/////////////////////////////////////////////////////////////////////////////
typedef struct _PERFORMANCE_SETTING
{
	int ctrl_id;
	int value;
} PERFORMANCE_SETTING;


/////////////////////////////////////////////////////////////////////////////
// Constants
/////////////////////////////////////////////////////////////////////////////

const int MAX_PERFORMANCE_LEVELS	= 4;
const int MAX_EXPERT_OPTIONS		= 8;

PERFORMANCE_SETTING _PerformanceLevels[MAX_PERFORMANCE_LEVELS][MAX_EXPERT_OPTIONS] = 
{
	//
	//	Low detail
	//
	{
		{IDC_CHAR_SHADOWS_SLIDER, 0},
		{IDC_TEXTURE_DETAIL_SLIDER, 0},
		{IDC_PARTICLE_DETAIL_SLIDER, 0},
		{IDC_SURFACE_DETAIL_SLIDER, 0},
		{IDC_GEOMETRY_DETAIL_SLIDER, 0},
		{IDC_TEXTURE_FILTER_COMBO, TextureClass::TEXTURE_FILTER_BILINEAR},
		{IDC_LIGHTING_MODE_COMBO, WW3D::PRELIT_MODE_VERTEX},
		{IDC_TERRAIN_SHADOW_CHECK, 0}
	},

	{
		{IDC_CHAR_SHADOWS_SLIDER, 1},
		{IDC_TEXTURE_DETAIL_SLIDER, 1},
		{IDC_PARTICLE_DETAIL_SLIDER, 0},
		{IDC_SURFACE_DETAIL_SLIDER, 0},
		{IDC_GEOMETRY_DETAIL_SLIDER, 0},
		{IDC_TEXTURE_FILTER_COMBO, TextureClass::TEXTURE_FILTER_BILINEAR},
		{IDC_LIGHTING_MODE_COMBO, WW3D::PRELIT_MODE_LIGHTMAP_MULTI_TEXTURE},
		{IDC_TERRAIN_SHADOW_CHECK, 0}
	},

	{
		{IDC_CHAR_SHADOWS_SLIDER, 2},
		{IDC_TEXTURE_DETAIL_SLIDER, 2},
		{IDC_PARTICLE_DETAIL_SLIDER, 1},
		{IDC_SURFACE_DETAIL_SLIDER, 1},
		{IDC_GEOMETRY_DETAIL_SLIDER, 1},
		{IDC_TEXTURE_FILTER_COMBO, TextureClass::TEXTURE_FILTER_TRILINEAR},
		{IDC_LIGHTING_MODE_COMBO, WW3D::PRELIT_MODE_LIGHTMAP_MULTI_TEXTURE},
		{IDC_TERRAIN_SHADOW_CHECK, 1}
	},

	//
	//	High detail
	//
	{
		{IDC_CHAR_SHADOWS_SLIDER, 3},
		{IDC_TEXTURE_DETAIL_SLIDER, 2},
		{IDC_PARTICLE_DETAIL_SLIDER, 2},
		{IDC_SURFACE_DETAIL_SLIDER, 2},
		{IDC_GEOMETRY_DETAIL_SLIDER, 2},
		{IDC_TEXTURE_FILTER_COMBO, TextureClass::TEXTURE_FILTER_TRILINEAR},
		{IDC_LIGHTING_MODE_COMBO, WW3D::PRELIT_MODE_LIGHTMAP_MULTI_TEXTURE},
		{IDC_TERRAIN_SHADOW_CHECK, 1}
	},
};


/////////////////////////////////////////////////////////////////////////////
// Registry Values
/////////////////////////////////////////////////////////////////////////////


/*
#ifdef MULTIPLAYERDEMO
const char *KEY_NAME_SETTINGS				= "Software\\Westwood\\RenegadeMPDemo\\System Settings";
const char *KEY_NAME_OPTIONS				= "Software\\Westwood\\RenegadeMPDemo\\Options";
#else
const char *KEY_NAME_SETTINGS				= "Software\\Westwood\\Renegade\\System Settings";
const char *KEY_NAME_OPTIONS				= "Software\\Westwood\\Renegade\\Options";
#endif // MULTIPLAYERDEMO
*/

#if	defined(FREEDEDICATEDSERVER)
const char *KEY_NAME_SETTINGS				= "Software\\Westwood\\RenegadeFDS\\System Settings";
const char *KEY_NAME_OPTIONS				= "Software\\Westwood\\RenegadeFDS\\Options";
#elif defined(MULTIPLAYERDEMO)
const char *KEY_NAME_SETTINGS				= "Software\\Westwood\\RenegadeMPDemo\\System Settings";
const char *KEY_NAME_OPTIONS				= "Software\\Westwood\\RenegadeMPDemo\\Options";
#elif defined(BETACLIENT)
const char *KEY_NAME_SETTINGS				= "Software\\Westwood\\RenegadeBeta\\System Settings";
const char *KEY_NAME_OPTIONS				= "Software\\Westwood\\RenegadeBeta\\Options";
#else
const char *KEY_NAME_SETTINGS				= "Software\\Westwood\\Renegade\\System Settings";
const char *KEY_NAME_OPTIONS				= "Software\\Westwood\\Renegade\\Options";
#endif

const char *VALUE_NAME_DYN_LOD			= "Dynamic_LOD_Budget";
const char *VALUE_NAME_STATIC_LOD		= "Static_LOD_Budget";
const char *VALUE_NAME_DYN_SHADOWS		= "Dynamic_Projectors";
const char *VALUE_NAME_TEXTURE_FILTER	= "Texture_Filter_Mode";
const char *VALUE_NAME_PRELIT_MODE		= "Prelit_Mode";
const char *VALUE_NAME_SHADOW_MODE		= "Shadow_Mode";
const char *VALUE_NAME_STATIC_SHADOWS	= "Static_Projectors";
const char *VALUE_NAME_TEXTURE_RES		= "Texture_Resolution";
const char *VALUE_NAME_SURFACE_EFFECT	= "Surface_Effect_Detail";
const char *VALUE_NAME_PARTICLE_DETAIL	= "Particle_Detail";


/////////////////////////////////////////////////////////////////////////////
//
// PerformanceConfigDialogClass
//
/////////////////////////////////////////////////////////////////////////////
PerformanceConfigDialogClass::PerformanceConfigDialogClass(CWnd* pParent /*=NULL*/)
	: CDialog (PerformanceConfigDialogClass::IDD, pParent)
{
	//{{AFX_DATA_INIT(PerformanceConfigDialogClass)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT
	CDialog::Create (PerformanceConfigDialogClass::IDD, pParent);
	return ;
}


/////////////////////////////////////////////////////////////////////////////
//
// DoDataExchange
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::DoDataExchange (CDataExchange *pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(PerformanceConfigDialogClass)
	DDX_Control(pDX, IDC_GEOMETRY_DETAIL_SLIDER, m_GeometrySlider);
	DDX_Control(pDX, IDC_CHAR_SHADOWS_SLIDER, m_CharShadowsSlider);
	DDX_Control(pDX, IDC_TEXTURE_DETAIL_SLIDER, m_TextureDetailSlider);
	DDX_Control(pDX, IDC_SURFACE_DETAIL_SLIDER, m_SurfaceEffectsSlider);
	DDX_Control(pDX, IDC_PERFORMANCE_SLIDER, m_PerformanceSlider);
	DDX_Control(pDX, IDC_PARTICLE_DETAIL_SLIDER, m_ParticleSlider);
	//}}AFX_DATA_MAP
	return ;
}


BEGIN_MESSAGE_MAP(PerformanceConfigDialogClass, CDialog)
	//{{AFX_MSG_MAP(PerformanceConfigDialogClass)
	ON_BN_CLICKED(IDC_EXPERT_CHECK, OnExpertCheck)
	ON_WM_HSCROLL()
	ON_BN_CLICKED(IDC_AUTO_CONFIG_BUTTON, OnGraphicsAutoSetup)
	ON_WM_SHOWWINDOW()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()



/////////////////////////////////////////////////////////////////////////////
//
// OnInitDialog
//
//	Modified: 12/06/2001 by	MML	- Retrieving strings from Locomoto file.
//
/////////////////////////////////////////////////////////////////////////////
BOOL
PerformanceConfigDialogClass::OnInitDialog (void)
{
	char string [_MAX_PATH];

	CDialog::OnInitDialog ();	

	//
	// Set all the static strings for this dialog.
	//
	SetDlgItemText( IDC_DETAIL,			 Locale_GetString( IDS_DETAIL, string ));
	SetDlgItemText( IDC_LOW_DESC,			 Locale_GetString( IDS_LOW_DESC, string ));
	SetDlgItemText( IDC_HIGH_DESC,		 Locale_GetString( IDS_HIGH_DESC, string ));
	SetDlgItemText( IDC_EXPERT_CHECK,	 Locale_GetString( IDS_EXPERT_MODE, string ));
	SetDlgItemText( IDC_EXPERT_SETTINGS, Locale_GetString( IDS_EXPERT_SETTINGS, string ));
	
	SetDlgItemText( IDC_AUTO_CONFIG_BUTTON, Locale_GetString( IDS_AUTOCONFIG, string ));
	
	SetDlgItemText( IDC_GEOMETRY_DETAIL,		 Locale_GetString( IDS_GEOMETRY_DETAIL, string ));
	SetDlgItemText( IDC_CHARACTER_SHADOWS,		 Locale_GetString( IDS_CHARACTER_SHADOWS, string ));
	SetDlgItemText( IDC_TEXTURE_DETAIL,			 Locale_GetString( IDS_TEXTURE_DETAIL, string ));
	SetDlgItemText( IDC_PARTICLE_DETAIL,		 Locale_GetString( IDS_PARTICLE_DETAIL, string ));
	SetDlgItemText( IDC_SURFACE_EFFECT_DETAIL, Locale_GetString( IDS_SURFACE_EFFECT_DETAIL, string ));

	Locale_GetString( IDS_LOW, string );
	SetDlgItemText( IDC_LOW1, string );
	SetDlgItemText( IDC_LOW2, string );
	SetDlgItemText( IDC_LOW3, string );
	SetDlgItemText( IDC_LOW4, string );
	SetDlgItemText( IDC_LOW5, string );

	Locale_GetString( IDS_HIGH, string );
	SetDlgItemText( IDC_HIGH1,	string );
	SetDlgItemText( IDC_HIGH2,	string );
	SetDlgItemText( IDC_HIGH3,	string );
	SetDlgItemText( IDC_HIGH4,	string );
	SetDlgItemText( IDC_HIGH5,	string );
	
	SetDlgItemText( IDC_LIGHTING_MODE,	Locale_GetString( IDS_LIGHTING_MODE, string ));
	SetDlgItemText( IDC_TEXTURE_FILTER,	Locale_GetString( IDS_TEXTURE_FILTER, string ));

	SetDlgItemText( IDC_TERRAIN_SHADOW_CHECK,	Locale_GetString( IDS_TERRAIN_SHADOWS, string ));

	//
	//	Configure the dialog controls
	//
	Setup_Controls ();
	Load_Values ();
//	Determine_Performance_Setting ();

	//
	//	Set the visibility of the expert windows controls
	//
	Build_Expert_Window_List ();
	Display_Expert_Settings (false);	

	return TRUE;
}


/////////////////////////////////////////////////////////////////////////////
//
// Build_Expert_Window_List
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::Build_Expert_Window_List (void)
{
	ExpertWindowList.Delete_All ();

	//
	//	Find the y-position of the expert mode checkbox
	//
	CRect rect;	
	::GetWindowRect (::GetDlgItem (m_hWnd, IDC_EXPERT_CHECK), &rect);
	float y_pos = rect.top;

	//
	//	Loop over all the child windows of the dialog
	//
	for (	HWND child_wnd = ::GetWindow (m_hWnd, GW_CHILD);
			child_wnd != NULL;
			child_wnd = ::GetWindow (child_wnd, GW_HWNDNEXT))
	{		
		//
		//	If this child window is below the expert checkbox then its
		// part of the expert settings
		//
		::GetWindowRect (child_wnd, &rect);
		if (rect.top > y_pos) {
			ExpertWindowList.Add (child_wnd);
		}
	}

	return ;
}


/////////////////////////////////////////////////////////////////////////////
//
// Display_Expert_Settings
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::Display_Expert_Settings (bool onoff)
{
	//
	//	Loop over all the expert settings windows and either
	// show or hide them...
	//
	for (int index = 0; index < ExpertWindowList.Count (); index ++) {
		::ShowWindow (ExpertWindowList[index], onoff ? SW_SHOW : SW_HIDE);
	}

	return ;
}


/////////////////////////////////////////////////////////////////////////////
//
// OnExpertCheck
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::OnExpertCheck (void)
{
	bool enabled = bool(SendDlgItemMessage (IDC_EXPERT_CHECK, BM_GETCHECK) == 1);
	Display_Expert_Settings (enabled);
	return ;
}


/////////////////////////////////////////////////////////////////////////////
//
// Setup_Controls
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::Setup_Controls (void)
{
	//
	//	Configure the main performance slider
	//
	m_PerformanceSlider.SetRange (0, MAX_PERFORMANCE_LEVELS - 1);

	//
	//	Configure the individual detail-setting sliders
	//
	m_CharShadowsSlider.SetRange (0, 3);
	m_GeometrySlider.SetRange (0, 2);
	m_TextureDetailSlider.SetRange (0, 2);
	m_SurfaceEffectsSlider.SetRange (0, 2);
	m_ParticleSlider.SetRange (0, 2);

	return ;
}


/////////////////////////////////////////////////////////////////////////////
//
// Load_Values
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::Load_Values (void)
{
	//
	//	Attempt to open the registry key 
	//
	RegistryClass registry (KEY_NAME_SETTINGS);
	if (registry.Is_Valid ()) {

		//
		//	Read the values from the registry
		//
		int dynamic_lod		= registry.Get_Int (VALUE_NAME_DYN_LOD, 3000);
		int static_lod			= registry.Get_Int (VALUE_NAME_STATIC_LOD, 3000);

		int dynamic_shadows	= registry.Get_Int (VALUE_NAME_DYN_SHADOWS, 1);
		int static_shadows	= registry.Get_Int (VALUE_NAME_STATIC_SHADOWS, 1);

		int prelit_mode		= registry.Get_Int (VALUE_NAME_PRELIT_MODE, WW3D::PRELIT_MODE_LIGHTMAP_MULTI_TEXTURE);
		int texture_filter	= registry.Get_Int (VALUE_NAME_TEXTURE_FILTER, TextureClass::TEXTURE_FILTER_BILINEAR);
		int shadow_mode		= registry.Get_Int (VALUE_NAME_SHADOW_MODE, PhysicsSceneClass::SHADOW_MODE_BLOBS_PLUS);		
		int texture_red		= registry.Get_Int (VALUE_NAME_TEXTURE_RES, 0);
		int surface_effect	= registry.Get_Int (VALUE_NAME_SURFACE_EFFECT, 1);
		int particle_detail	= registry.Get_Int (VALUE_NAME_PARTICLE_DETAIL, 1);

		//
		//	Set the slider's positions to reflect the loaded values
		//
		m_CharShadowsSlider.SetPos (min (shadow_mode, 3));
		m_TextureDetailSlider.SetPos (max (2 - texture_red, 0));		
		m_SurfaceEffectsSlider.SetPos (surface_effect);
		m_ParticleSlider.SetPos (particle_detail);

		//
		//	Choose a setting for the geometry slider based on
		// the dynamic and static LOD budgets
		//
		if (dynamic_lod < 1000 && static_lod < 1000) {
			m_GeometrySlider.SetPos (0);
		} else if (dynamic_lod <= 5000 && static_lod <= 5000) {
			m_GeometrySlider.SetPos (1);
		} else {
			m_GeometrySlider.SetPos (2);
		}

		//
		//	Check the checkbox controls (if necessary)
		//
		SendDlgItemMessage (IDC_TERRAIN_SHADOW_CHECK, BM_SETCHECK, (WPARAM)(static_shadows != 0));
		
		//
		//	Select the correct setting from the lighting mode combo box
		//
		SendDlgItemMessage (IDC_LIGHTING_MODE_COMBO, CB_SETCURSEL, prelit_mode);		

		//
		//	Select the correct setting from the texture filtering mode combo box
		//
		SendDlgItemMessage (IDC_TEXTURE_FILTER_COMBO, CB_SETCURSEL, texture_filter);		
	}

	return ;
}


/////////////////////////////////////////////////////////////////////////////
//
// Determine_Performance_Setting
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::Determine_Performance_Setting (void)
{
	float option_levels[MAX_EXPERT_OPTIONS] = { 0 };
	int count_per_option[MAX_EXPERT_OPTIONS] = { 0 };

	//
	//	Get the current values of each setting
	//
	DynamicVectorClass<int> option_values;
	Get_Settings (option_values);

	//
	// Find out which level each option is currently set at
	//
	for (int level = MAX_PERFORMANCE_LEVELS - 1; level >= 0; level --) {
		for (int index = 0; index < MAX_EXPERT_OPTIONS; index ++) {

			//
			//	If the values match, then record the current level for this option
			//
			if (option_values[index] == _PerformanceLevels[level][index].value) {
				option_levels[index] += level;
				count_per_option[index] ++;
			}
		}
	}

	//
	//	Add up all the levels
	//
	float level_sum = 0;
	for (int index = 0; index < MAX_EXPERT_OPTIONS; index ++) {
		level_sum += (option_levels[index] / count_per_option[index]);
	}

	//
	//	Take the average rating
	//
	float level_rating = level_sum / MAX_EXPERT_OPTIONS;

	//
	//	Set the slider's position
	//
	m_PerformanceSlider.SetPos (min (int(level_rating + 0.5F), MAX_EXPERT_OPTIONS - 1));
	return ;
}


/////////////////////////////////////////////////////////////////////////////
//
// Get_Settings
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::Get_Settings (DynamicVectorClass<int> &settings)
{
	//
	//	Determine what the value of each control is
	//
	for (int index = 0; index < MAX_EXPERT_OPTIONS; index ++) {

		//
		//	Determine what the value of this control is
		//
		int curr_value = 0;
		int ctrl_id = _PerformanceLevels[0][index].ctrl_id;
		switch (ctrl_id) {
			
			//
			//	Read any of the slider positions
			//
			case IDC_GEOMETRY_DETAIL_SLIDER:
			case IDC_CHAR_SHADOWS_SLIDER:
			case IDC_TEXTURE_DETAIL_SLIDER:
			case IDC_PARTICLE_DETAIL_SLIDER:
			case IDC_SURFACE_DETAIL_SLIDER:
				curr_value = SendDlgItemMessage (ctrl_id, TBM_GETPOS);
				break;

			//
			//	Read the values from the checkbox
			//
			case IDC_TERRAIN_SHADOW_CHECK:
				curr_value = SendDlgItemMessage (ctrl_id, BM_GETCHECK);
				break;

			//
			//	Read a value from a combo box.
			//
			case IDC_LIGHTING_MODE_COMBO:
			case IDC_TEXTURE_FILTER_COMBO:
				curr_value = SendDlgItemMessage (ctrl_id, CB_GETCURSEL);
				break;

		}

		//
		//	Add this value to the list
		//
		settings.Add (curr_value);
	}

	return ;
}


/////////////////////////////////////////////////////////////////////////////
//
// Update_Expert_Controls
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::Update_Expert_Controls (int level)
{
	for (int index = 0; index < MAX_EXPERT_OPTIONS; index ++) {

		//
		//	Determine which control we are updating
		//
		int ctrl_id = _PerformanceLevels[level][index].ctrl_id;
		switch (ctrl_id) {
			
			//
			//	Update any of the sliders via the same mechanism
			//
			case IDC_GEOMETRY_DETAIL_SLIDER:
			case IDC_CHAR_SHADOWS_SLIDER:
			case IDC_TEXTURE_DETAIL_SLIDER:
			case IDC_PARTICLE_DETAIL_SLIDER:
			case IDC_SURFACE_DETAIL_SLIDER:
				SendDlgItemMessage (ctrl_id, TBM_SETPOS, TRUE, _PerformanceLevels[level][index].value);
				break;

			//
			//	Update any of the check boxes via the same mechanism
			//
			case IDC_TERRAIN_SHADOW_CHECK:
				SendDlgItemMessage (ctrl_id, BM_SETCHECK, _PerformanceLevels[level][index].value);
				break;

			//
			//	Update any of the combo boxes.
			//
			case IDC_LIGHTING_MODE_COMBO:
			case IDC_TEXTURE_FILTER_COMBO:
				SendDlgItemMessage (ctrl_id, CB_SETCURSEL, _PerformanceLevels[level][index].value);
				break;

		}
	}

	return ;
}


/////////////////////////////////////////////////////////////////////////////
//
// OnHScroll
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::OnHScroll
(
	UINT				nSBCode,
	UINT				nPos,
	CScrollBar *	pScrollBar
)
{
	int ctrl_id = ::GetWindowLong (pScrollBar->m_hWnd, GWL_ID);
	
	//
	//	If this is the overall performance slider, then
	// update the expert controls to reflect the new setting
	//
	if (ctrl_id == IDC_PERFORMANCE_SLIDER) {
		int new_level = m_PerformanceSlider.GetPos ();
		Update_Expert_Controls (new_level);
	}

	CDialog::OnHScroll (nSBCode, nPos, pScrollBar);
	return ;
}


/////////////////////////////////////////////////////////////////////////////
//
// Apply_Changes
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::Apply_Changes (void)
{
	//
	//	Attempt to open the registry key 
	//
	RegistryClass registry (KEY_NAME_SETTINGS);
	if (registry.Is_Valid ()) {

		//
		//	Get the current settings from the dialog
		//
		int geometry_detail	= 	m_GeometrySlider.GetPos ();
		int shadow_mode		= 	m_CharShadowsSlider.GetPos ();
		int texture_red		= 	m_TextureDetailSlider.GetPos ();
		int surface_effect	= 	m_SurfaceEffectsSlider.GetPos ();
		int particle_detail	= 	m_ParticleSlider.GetPos ();
		int static_shadows	= SendDlgItemMessage (IDC_TERRAIN_SHADOW_CHECK, BM_GETCHECK);		
		int prelit_mode		= SendDlgItemMessage (IDC_LIGHTING_MODE_COMBO, CB_GETCURSEL);
		// If card can't do multi-pass, value 1 means multi-texture (multi-pass selection is missing from the combo box)
		if (!CanDoMultiPass) {
			if (prelit_mode==1) prelit_mode=WW3D::PRELIT_MODE_LIGHTMAP_MULTI_TEXTURE;
		}

		int texture_filter	= SendDlgItemMessage (IDC_TEXTURE_FILTER_COMBO, CB_GETCURSEL);

		//
		//	Determine a good LOD budget to use
		//
		int lod_budget = 0;
		if (geometry_detail == 0) {
			lod_budget = 0;
		} else if (geometry_detail == 1) {
			lod_budget = 5000;
		} else if (geometry_detail == 2) {
			lod_budget = 10000;
		}

		//
		//	Store the values in the registry
		//
		registry.Set_Int (VALUE_NAME_DYN_LOD, lod_budget);
		registry.Set_Int (VALUE_NAME_STATIC_LOD, lod_budget);

		registry.Set_Int (VALUE_NAME_DYN_SHADOWS, (shadow_mode != PhysicsSceneClass::SHADOW_MODE_NONE));
		registry.Set_Int (VALUE_NAME_STATIC_SHADOWS, static_shadows);

		registry.Set_Int (VALUE_NAME_PRELIT_MODE, prelit_mode);
		registry.Set_Int (VALUE_NAME_TEXTURE_FILTER, texture_filter);
		registry.Set_Int (VALUE_NAME_SHADOW_MODE, shadow_mode);
		registry.Set_Int (VALUE_NAME_TEXTURE_RES, max (2 - texture_red, 0));
		registry.Set_Int (VALUE_NAME_SURFACE_EFFECT, surface_effect);
		registry.Set_Int (VALUE_NAME_PARTICLE_DETAIL, particle_detail);
	}

	return ;
}


/////////////////////////////////////////////////////////////////////////////
//
// WindowProc
//
/////////////////////////////////////////////////////////////////////////////
LRESULT
PerformanceConfigDialogClass::WindowProc
(
	UINT		message,
	WPARAM	wParam,
	LPARAM	lParam
)
{
	if (message == (WM_USER + 101)) {
		Apply_Changes ();
	}

	return CDialog::WindowProc(message, wParam, lParam);
}
/*
//If really low texture memory such as 4 Mb (if possible to detect) set level 2
- If multtexturing available, default to multitextured lighting, otherwise multi pass
- If a low end card, default to vertex solve
- Default to 640x480, 800x600 or 1024x768 depending on video card
- Default to 32 bit display on HW T&L cards, 16 bit otherwise
- Default to fullscreen (do we even support windowed mode in the release?)
- The same for particle detail
*/

void AutoConfigSettings();


void PerformanceConfigDialogClass::OnGraphicsAutoSetup() 
{
	// TODO: Add your control notification handler code here

	AutoConfigSettings();
	Load_Values();
//	Apply_Changes();
};

/*
		registry.Set_Int (VALUE_NAME_DYN_LOD, lod_budget);
		registry.Set_Int (VALUE_NAME_STATIC_LOD, lod_budget);

		registry.Set_Int (VALUE_NAME_DYN_SHADOWS, (shadow_mode != PhysicsSceneClass::SHADOW_MODE_NONE));
		registry.Set_Int (VALUE_NAME_STATIC_SHADOWS, static_shadows);

		registry.Set_Int (VALUE_NAME_PRELIT_MODE, prelit_mode);
		registry.Set_Int (VALUE_NAME_SHADOW_MODE, shadow_mode);
		registry.Set_Int (VALUE_NAME_TEXTURE_RES, max (2 - texture_red, 0));
		registry.Set_Int (VALUE_NAME_SURFACE_EFFECT, surface_effect);
		registry.Set_Int (VALUE_NAME_PARTICLE_DETAIL, particle_detail);
*/
void AutoConfigSettings() 
{
	//
	//	Attempt to open the registry key 
	//
	RegistryClass registry (KEY_NAME_SETTINGS);
	if (!registry.Is_Valid()) return;

	// Access registry key "Render"
	RegistryClass render_registry(RENEGADE_SUB_KEY_NAME_RENDER);
	if ( !render_registry.Is_Valid() ) {
		return;
	}

	IDirect3D8* d3d=NULL;
	D3DCAPS8 tmp_caps;
	const D3DCAPS8* d3dcaps=NULL;
	D3DADAPTER_IDENTIFIER8 adapter_id;
	D3DFORMAT display_format;

	VideoConfigDialogClass* video=VideoConfigDialogClass::Get_Instance();
	if (video) {
		WW3D::Set_Texture_Bitdepth(16);
		render_registry.Set_Int( VALUE_NAME_RENDER_DEVICE_TEXTURE_DEPTH, 16 );
		d3d=DX8Wrapper::_Get_D3D8();
		d3d->AddRef();
		d3dcaps=&video->Get_Current_Caps();
		adapter_id=video->Get_Current_Adapter_Identifier();
		if (video->Get_Current_Bit_Depth()==32) {
			display_format=D3DFMT_X8R8G8B8;
		}
		else {
			display_format=D3DFMT_R5G6B5;
		}
	}
	else {
		// Init D3D
		Init_D3D_To_WW3_Conversion();
		d3d=Direct3DCreate8(D3D_SDK_VERSION);		// TODO: handle failure cases...
		if (!d3d) {
			return;
		}

		// Select device. If there is already a device selected in the registry, use it.

		int current_adapter_index=D3DADAPTER_DEFAULT;

		//
		//	Load the render device settings from the registry
		//
		char device_name[256] = { 0 };
		render_registry.Get_String( VALUE_NAME_RENDER_DEVICE_NAME, device_name, sizeof(device_name));

		int adapter_count = d3d->GetAdapterCount();
		for (int adapter_index=0; adapter_index<adapter_count; adapter_index++) {
			D3DADAPTER_IDENTIFIER8 id;
			::ZeroMemory(&id, sizeof(D3DADAPTER_IDENTIFIER8));
			HRESULT res = d3d->GetAdapterIdentifier(adapter_index,D3DENUM_NO_WHQL_LEVEL,&id);
			// If device ok, check if it matches the currently set adapter name
			if (res == D3D_OK) {
				StringClass name(id.Description,true);
				if (name==device_name) {
					current_adapter_index=adapter_index;
					break;
				}
			}
		}

		if (FAILED(d3d->GetDeviceCaps(
			current_adapter_index,
			D3DDEVTYPE_HAL,
			&tmp_caps))) {
			d3d->Release();
			return;
		}

		::ZeroMemory(&adapter_id, sizeof(D3DADAPTER_IDENTIFIER8));
		if (FAILED( d3d->GetAdapterIdentifier(
			current_adapter_index,
			D3DENUM_NO_WHQL_LEVEL,
			&adapter_id))) {
			d3d->Release();
			return;
		}

		// Store device name in registry
		render_registry.Set_String( VALUE_NAME_RENDER_DEVICE_NAME, adapter_id.Description);

		// Set resolution to 800 x 600 x 16
		render_registry.Set_Int( VALUE_NAME_RENDER_DEVICE_WIDTH, 800 );
		render_registry.Set_Int( VALUE_NAME_RENDER_DEVICE_HEIGHT, 600 );
		render_registry.Set_Int( VALUE_NAME_RENDER_DEVICE_DEPTH, 16 );
		render_registry.Set_Int( VALUE_NAME_RENDER_DEVICE_WINDOWED, 0 );
		render_registry.Set_Int( VALUE_NAME_RENDER_DEVICE_TEXTURE_DEPTH, 16 );

		d3dcaps=&tmp_caps;
		display_format=D3DFMT_R5G6B5;

		// Test if the card if new enough to do 32 bit...
		DX8Caps tmp_caps(d3d,*d3dcaps,WW3D_FORMAT_UNKNOWN,adapter_id);
		switch (tmp_caps.Get_Vendor()) {
		default:
			break;
		case DX8Caps::VENDOR_NVIDIA:
			switch (tmp_caps.Get_Device()) {
			default:
				display_format=D3DFMT_X8R8G8B8;
				render_registry.Set_Int( VALUE_NAME_RENDER_DEVICE_DEPTH, 32 );
				break;
			case DX8Caps::DEVICE_NVIDIA_TNT2_ALADDIN:
			case DX8Caps::DEVICE_NVIDIA_TNT2:
			case DX8Caps::DEVICE_NVIDIA_TNT2_ULTRA:
			case DX8Caps::DEVICE_NVIDIA_TNT2_VANTA:
			case DX8Caps::DEVICE_NVIDIA_TNT2_M64:
			case DX8Caps::DEVICE_NVIDIA_TNT:
			case DX8Caps::DEVICE_NVIDIA_RIVA_128:
			case DX8Caps::DEVICE_NVIDIA_TNT_VANTA:
			case DX8Caps::DEVICE_NVIDIA_NV1:
				break;
			}
			break;
		case DX8Caps::VENDOR_ATI:
			switch (tmp_caps.Get_Device()) {
			case DX8Caps::DEVICE_ATI_RAGE_II:
			case DX8Caps::DEVICE_ATI_RAGE_II_PLUS:
			case DX8Caps::DEVICE_ATI_RAGE_IIC_PCI:
			case DX8Caps::DEVICE_ATI_RAGE_IIC_AGP:
			case DX8Caps::DEVICE_ATI_RAGE_128_MOBILITY:
			case DX8Caps::DEVICE_ATI_RAGE_128_MOBILITY_M3:
			case DX8Caps::DEVICE_ATI_RAGE_128_MOBILITY_M4:
			case DX8Caps::DEVICE_ATI_RAGE_128_PRO_ULTRA:
			case DX8Caps::DEVICE_ATI_RAGE_128_4X:
			case DX8Caps::DEVICE_ATI_RAGE_128_PRO_GL:
			case DX8Caps::DEVICE_ATI_RAGE_128_PRO_VR:
			case DX8Caps::DEVICE_ATI_RAGE_128_GL:
			case DX8Caps::DEVICE_ATI_RAGE_128_VR:
			case DX8Caps::DEVICE_ATI_RAGE_PRO:
			case DX8Caps::DEVICE_ATI_RAGE_PRO_MOBILITY:
				break;
			default:
				display_format=D3DFMT_X8R8G8B8;
				render_registry.Set_Int( VALUE_NAME_RENDER_DEVICE_DEPTH, 32 );
				break;
			}
			break;
		}

	}

	DX8Caps caps(d3d,*d3dcaps,D3DFormat_To_WW3DFormat(display_format),adapter_id);
	CanDoMultiPass=caps.Can_Do_Multi_Pass();

	bool high_end_processor=CPUDetectClass::Has_SSE_Instruction_Set();
	if (CPUDetectClass::Get_Processor_Manufacturer()==CPUDetectClass::MANUFACTURER_AMD &&
		CPUDetectClass::Get_AMD_Processor()>=CPUDetectClass::AMD_PROCESSOR_ATHLON_025) {
		high_end_processor=true;
	}


//	If no texture compression, default to texture resolution 1
	if (caps.Support_DXTC()) {
		registry.Set_Int (VALUE_NAME_TEXTURE_RES, 0);
	}
	else {
		registry.Set_Int (VALUE_NAME_TEXTURE_RES, 1);
	}


// High geometry detail on T&L cards, medium on fast processors and low on slow ones
	if (caps.Support_TnL()) {
		registry.Set_Int (VALUE_NAME_DYN_LOD, 10000);
		registry.Set_Int (VALUE_NAME_STATIC_LOD, 10000);
	}
	else {
		// If T&L hardware present, set to medium or low. Set to medium if high end cpu.
		// TODO: Set to medium if Athlon detected.
		if (high_end_processor) {
			registry.Set_Int (VALUE_NAME_DYN_LOD, 5000);
			registry.Set_Int (VALUE_NAME_STATIC_LOD, 5000);
		}
		else {
			registry.Set_Int (VALUE_NAME_DYN_LOD, 0);
			registry.Set_Int (VALUE_NAME_STATIC_LOD, 0);
		}
	}

// Set high shadow detail if render to texture is supported AND HWTL available
// Set medium shadow detail if render to texture is supported but no HWTL
// Set low shadow detail if no render to texture is available
	if (caps.Support_Render_To_Texture_Format(D3DFormat_To_WW3DFormat(display_format))) {
		if (caps.Support_TnL()) {
			registry.Set_Int (VALUE_NAME_SHADOW_MODE, 3);
			registry.Set_Int (VALUE_NAME_STATIC_SHADOWS, 1);
		}
		else {
			registry.Set_Int (VALUE_NAME_SHADOW_MODE, 2);
			registry.Set_Int (VALUE_NAME_STATIC_SHADOWS, 0);
		}
	}
	else {
		registry.Set_Int (VALUE_NAME_STATIC_SHADOWS, 0);

		// Set to medium if high end cpu detected.
		// TODO: Set to medium if Athlon detected.
		if (high_end_processor) {
			registry.Set_Int (VALUE_NAME_SHADOW_MODE, 1);
		}
		else {
			registry.Set_Int (VALUE_NAME_SHADOW_MODE, 0);
		}
	}

// If a low end system turn surface effects off
	if (caps.Support_TnL()) {
		registry.Set_Int (VALUE_NAME_SURFACE_EFFECT, 2);
	}
	else {
		// Set to medium if high end cpu detected.
		// TODO: Set to medium if Athlon detected.
		if (high_end_processor) {
			registry.Set_Int (VALUE_NAME_SURFACE_EFFECT, 1);
		}
		else {
			registry.Set_Int (VALUE_NAME_SURFACE_EFFECT, 0);
		}
	}

// If HWTL and high end cpu, use highest particle detail
	if (caps.Support_TnL() && high_end_processor) {
		registry.Set_Int (VALUE_NAME_PARTICLE_DETAIL, 2);
	}
	// If one or the other, use medium particle detail
	else if (caps.Support_TnL() || high_end_processor) {
		registry.Set_Int (VALUE_NAME_PARTICLE_DETAIL, 1);
	}
	else {
		registry.Set_Int (VALUE_NAME_PARTICLE_DETAIL, 0);
	}


	// If the system has less than 100 Megs (64 or 96 most likely) of RAM, select vertex solve to
	// save memory.
	// If card can't do multi pass (which is the case if we've seen z-fighting problems when multi-passing)
	// select vertex solve.
	if (!caps.Can_Do_Multi_Pass() || CPUDetectClass::Get_Total_Physical_Memory()<100*1024*1024) {
		registry.Set_Int (VALUE_NAME_PRELIT_MODE, 0);
	}
	// Otherwise select multitexturing if card can do it, or multipass...
	else {
		if (caps.Get_Max_Textures_Per_Pass()>=2) {
			registry.Set_Int (VALUE_NAME_PRELIT_MODE, 2);
		}
		else {
			registry.Set_Int (VALUE_NAME_PRELIT_MODE, 1);
		}
	}

	RegistryClass registry_options (KEY_NAME_OPTIONS);
	if (!registry_options.Is_Valid()) return;

	// The uv bias setting for most of the cards
	// (PowerVR Kyro and Kyro II and ATI Rage Pro need different UV bias and the rest of the cards.)
	registry_options.Set_Int( "ScreenUVBias", 1 );

	switch (caps.Get_Vendor()) {
	default:
		registry.Set_Int(VALUE_NAME_TEXTURE_FILTER,0);	// Most cards default to bilinear filtering
		break;
	case DX8Caps::VENDOR_NVIDIA:
		switch (caps.Get_Device()) {
		case DX8Caps::DEVICE_NVIDIA_TNT2_ALADDIN:
		case DX8Caps::DEVICE_NVIDIA_TNT2:
		case DX8Caps::DEVICE_NVIDIA_TNT2_ULTRA:
		case DX8Caps::DEVICE_NVIDIA_TNT2_VANTA:
		case DX8Caps::DEVICE_NVIDIA_TNT2_M64:
		case DX8Caps::DEVICE_NVIDIA_TNT:
		case DX8Caps::DEVICE_NVIDIA_RIVA_128:
		case DX8Caps::DEVICE_NVIDIA_TNT_VANTA:
		case DX8Caps::DEVICE_NVIDIA_NV1:
			registry.Set_Int(VALUE_NAME_TEXTURE_FILTER,0);
			break;
		default:
			registry.Set_Int(VALUE_NAME_TEXTURE_FILTER,1);	// New NVidia cards default to trilinear
		}
		break;
	case DX8Caps::VENDOR_ATI:
		switch (caps.Get_Device()) {
		case DX8Caps::DEVICE_ATI_RAGE_II:
		case DX8Caps::DEVICE_ATI_RAGE_II_PLUS:
		case DX8Caps::DEVICE_ATI_RAGE_IIC_PCI:
		case DX8Caps::DEVICE_ATI_RAGE_IIC_AGP:
		case DX8Caps::DEVICE_ATI_RAGE_128_MOBILITY:
		case DX8Caps::DEVICE_ATI_RAGE_128_MOBILITY_M3:
		case DX8Caps::DEVICE_ATI_RAGE_128_MOBILITY_M4:
		case DX8Caps::DEVICE_ATI_RAGE_128_PRO_ULTRA:
		case DX8Caps::DEVICE_ATI_RAGE_128_4X:
		case DX8Caps::DEVICE_ATI_RAGE_128_PRO_GL:
		case DX8Caps::DEVICE_ATI_RAGE_128_PRO_VR:
		case DX8Caps::DEVICE_ATI_RAGE_128_GL:
		case DX8Caps::DEVICE_ATI_RAGE_128_VR:
		case DX8Caps::DEVICE_ATI_RAGE_PRO:
		case DX8Caps::DEVICE_ATI_RAGE_PRO_MOBILITY:
			registry.Set_Int(VALUE_NAME_TEXTURE_FILTER,0);

			// It seems the bias needs to be adjusted on Rage128 as well...
			if (caps.Get_Device()==DX8Caps::DEVICE_ATI_RAGE_PRO ||
				caps.Get_Device()==DX8Caps::DEVICE_ATI_RAGE_PRO_MOBILITY ||
				caps.Get_Device()==DX8Caps::DEVICE_ATI_RAGE_128_MOBILITY ||
				caps.Get_Device()==DX8Caps::DEVICE_ATI_RAGE_128_MOBILITY_M3 ||
				caps.Get_Device()==DX8Caps::DEVICE_ATI_RAGE_128_MOBILITY_M4 ||
				caps.Get_Device()==DX8Caps::DEVICE_ATI_RAGE_128_PRO_ULTRA) {
				registry_options.Set_Int( "ScreenUVBias", 0 );
			}
			break;
		default:
			registry.Set_Int(VALUE_NAME_TEXTURE_FILTER,1);	// New ATI cards default to trilinear
			break;
		}
		break;
	case DX8Caps::VENDOR_POWERVR:
		// not sure how this goes. Kyro at the office requires 1, but some other powervr
		// card seems to require 0...
		registry_options.Set_Int( "ScreenUVBias", 0 );
		switch (caps.Get_Device()) {
		case DX8Caps::DEVICE_POWERVR_KYRO:
			registry_options.Set_Int( "ScreenUVBias", 1 );
			break;
		}
		break;

	}

	d3d->Release();

}


/////////////////////////////////////////////////////////////////////////////
//
//	OnShowWindow
//
//	Modified: 12/06/2001 by	MML	- Retrieving strings from Locomoto file.
//
/////////////////////////////////////////////////////////////////////////////
void
PerformanceConfigDialogClass::OnShowWindow(BOOL bShow, UINT nStatus) 
{
	char string[ _MAX_PATH ];

	CDialog::OnShowWindow(bShow, nStatus);
	if (bShow) {

		//
		//	Insert code here
		//

		RegistryClass registry (KEY_NAME_SETTINGS);
		if (!registry.Is_Valid ()) return;

		VideoConfigDialogClass* video=VideoConfigDialogClass::Get_Instance();
		if (video) {

			IDirect3D8* d3d=DX8Wrapper::_Get_D3D8();
			d3d->AddRef();
			D3DADAPTER_IDENTIFIER8 adapter_id=video->Get_Current_Adapter_Identifier();

			D3DFORMAT display_format;
			if (video->Get_Current_Bit_Depth()==32) {
				display_format=D3DFMT_X8R8G8B8;
			}
			else {
				display_format=D3DFMT_R5G6B5;
			}

			DX8Caps caps(d3d,video->Get_Current_Caps(),D3DFormat_To_WW3DFormat(display_format),adapter_id);
			CanDoMultiPass=caps.Can_Do_Multi_Pass();

			//
			//	Populate the lighting combobox
			//

			// Get the current selection
			char cur_sel_string[256];
			unsigned sel=SendDlgItemMessage (IDC_LIGHTING_MODE_COMBO, CB_GETCURSEL, 0, 0);
			if (sel!=CB_ERR) {
				SendDlgItemMessage (IDC_LIGHTING_MODE_COMBO, CB_GETLBTEXT, sel, (LPARAM)cur_sel_string);
			}
			else {
				cur_sel_string[0]=0;
				sel=registry.Get_Int (VALUE_NAME_PRELIT_MODE, WW3D::PRELIT_MODE_LIGHTMAP_MULTI_TEXTURE);
			}

			// Reset content and add available modes
			SendDlgItemMessage (IDC_LIGHTING_MODE_COMBO, CB_RESETCONTENT, 0, 0);
			SendDlgItemMessage (IDC_LIGHTING_MODE_COMBO, CB_ADDSTRING, 0, (LPARAM)Locale_GetString( IDS_VERTEX, string ));
			if (caps.Can_Do_Multi_Pass()) {
				SendDlgItemMessage (IDC_LIGHTING_MODE_COMBO, CB_ADDSTRING, 0, (LPARAM)Locale_GetString( IDS_MULTI_PASS, string ));
			}
			if (caps.Get_Max_Textures_Per_Pass()>1) {
				SendDlgItemMessage (IDC_LIGHTING_MODE_COMBO, CB_ADDSTRING, 0, (LPARAM)Locale_GetString( IDS_MULTI_TEXTURE, string ));	
			}

			// Try to set the previous selection
			unsigned res=SendDlgItemMessage (IDC_LIGHTING_MODE_COMBO, CB_FINDSTRINGEXACT, -1, (LPARAM)cur_sel_string);
			if (res==CB_ERR) {
				if (sel==0) res=0;
				else {
					res=SendDlgItemMessage (IDC_LIGHTING_MODE_COMBO, CB_GETCOUNT, 0, 0)-1;
					if (sel<res) res=sel;
				}
			}
			SendDlgItemMessage (IDC_LIGHTING_MODE_COMBO, CB_SETCURSEL, res, 0);

			//
			//	Populate the texture filtering combobox
			//

			// Get the current selection
			sel=SendDlgItemMessage (IDC_TEXTURE_FILTER_COMBO, CB_GETCURSEL, 0, 0);
			if (sel!=CB_ERR) {
				SendDlgItemMessage (IDC_TEXTURE_FILTER_COMBO, CB_GETLBTEXT, sel, (LPARAM)cur_sel_string);
			}
			else {
				cur_sel_string[0]=0;
				sel=registry.Get_Int (VALUE_NAME_TEXTURE_FILTER, TextureClass::TEXTURE_FILTER_BILINEAR);
			}
			SendDlgItemMessage (IDC_TEXTURE_FILTER_COMBO, CB_RESETCONTENT, 0, 0);
			SendDlgItemMessage (IDC_TEXTURE_FILTER_COMBO, CB_ADDSTRING, 0, (LPARAM)Locale_GetString( IDS_BILINEAR, string ));
			SendDlgItemMessage (IDC_TEXTURE_FILTER_COMBO, CB_ADDSTRING, 0, (LPARAM)Locale_GetString( IDS_TRILINEAR, string ));
			if (caps.Support_Anisotropic_Filtering()) {
				SendDlgItemMessage (IDC_TEXTURE_FILTER_COMBO, CB_ADDSTRING, 0, (LPARAM)Locale_GetString( IDS_ANISOTROPIC, string ));	
			}

			// Try to set the previous selection
			res=SendDlgItemMessage (IDC_TEXTURE_FILTER_COMBO, CB_FINDSTRINGEXACT, -1, (LPARAM)cur_sel_string);
			if (res==CB_ERR) {
				if (sel==0) res=0;
				else {
					res=SendDlgItemMessage (IDC_TEXTURE_FILTER_COMBO, CB_GETCOUNT, 0, 0)-1;
					if (sel<res) res=sel;
				}
			}
			SendDlgItemMessage (IDC_TEXTURE_FILTER_COMBO, CB_SETCURSEL, res, 0);

			d3d->Release();

			Determine_Performance_Setting ();
		}
	}

	return ;
}