mirror
/
JurassicParkTrespasser
mirror of https://github.com/OpenTrespasser/JurassicParkTrespasser.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
JurassicParkTrespasser/jp2_pc/Source/Trespass/dlgrender.cpp

826 lines
18 KiB
C++
Raw Permalink Blame History

//+--------------------------------------------------------------------------
//
// Copyright (C) DreamWorks Interactive, 1998.
//
// File: dlgrender.cpp
//
// Contents: User Dialog code to change the rendering statistics.
//
// Classes:
//
// Functions:
//
// History: 02-Jan-98 SHernd Created
//
//---------------------------------------------------------------------------
#include "precomp.h"
#pragma hdrstop
#include "supportfn.hpp"
#include "resource.h"
#include "main.h"
#include "uiwnd.h"
#include "uidlgs.h"
#include "tpassglobals.h"
#include "rasterdc.hpp"
#include "../Lib/Sys/reg.h"
#include "../Lib/Sys/RegInit.hpp"
#include "DDDevice.hpp"
#include "Lib/Std/MemLimits.hpp"
#include "Lib/View/DisplayMode.hpp"
//
// Constants.
//
// Texture resolution constants.
const char* strLow = "Low";
const char* strMedium = "Medium";
const char* strHigh = "High";
extern HINSTANCE g_hInst;
extern HWND g_hwnd;
int iNumResolutions = 0; // Number of DD devices.
SResolution arResolutions[20]; // More DD devices than can exist.
//+--------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
CConfigureWnd::CConfigureWnd()
{
}
CConfigureWnd::~CConfigureWnd()
{
if (penumdevDevices)
{
delete penumdevDevices;
penumdevDevices = 0;
}
}
BOOL CConfigureWnd::OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam)
{
// Initialize the enumeration.
if (!penumdevDevices)
penumdevDevices = new CEnumerateDevices();
//
// Determine if the dialog is worth running. If there is only one device on the system,
// it could only be the Trespasser software device.
//
if (penumdevDevices->iGetNumDevices() < 2)
{
ErrorDlg(NULL, IDS_ERR_NO_ACCELERATORS);
delete penumdevDevices;
penumdevDevices = 0;
bSetInitFlag(TRUE);
CMultiDlg::OnOK();
return FALSE;
}
CMultiDlg::OnInitDialog(hwnd, hwndFocus, lParam);
m_hwndResolutions = GetDlgItem(m_hwnd, IDC_COMBO_RESOLUTION);
m_hwndTextureSizes = GetDlgItem(m_hwnd, IDC_COMBO_TEXTURESIZE);
m_hwndWindowModes = GetDlgItem(m_hwnd, IDC_COMBO_WINDOWMODE);
m_hwndList = GetDlgItem(m_hwnd, IDC_LIST_CARD);
InitializeCardSelection();
return TRUE;
}
void CConfigureWnd::OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
// Check the water button.
if (id == IDC_CHECK_HARDWAREWATER)
{
}
// Check the water button.
if (id == IDHELP)
{
char str_cmd[512];
char str_dir[256];
// Create the command line.
GetRegString(REG_KEY_INSTALLED_DIR, str_dir, sizeof(str_dir), "");
strcpy(str_cmd, "Notepad.exe ");
strcat(str_cmd, str_dir);
strcat(str_cmd, "Readme.txt");
// Execute the command line.
int i_exec = WinExec(str_cmd, SW_SHOWDEFAULT);
// Any return value 31 or less is an error.
if (i_exec <= 31)
{
MsgDlg(NULL, MB_OK, IDS_TITLE, IDS_ERR_DISPLAY_README);
}
}
if (codeNotify == LBN_SELCHANGE && hwndCtl == m_hwndList)
{
OnSelchangeListCard();
return;
}
CMultiDlg::OnCommand(hwnd, id, hwndCtl, codeNotify);
}
static bool bMatchResolution(int i_width, int i_height)
{
SResolution res(i_width, i_height);
for (int i = 0; i < iNumResolutions; ++i)
{
if (arResolutions[i] == res)
return true;
}
return false;
}
void CConfigureWnd::InitializeResolutions()
{
int i_width;
int i_height;
char str_desc[32];
// Clear current selections.
ComboBox_ResetContent(m_hwndResolutions);
// Get the device currently selected.
GUID guid = penumdevDevices->devGetSelectedDevice().ddDevice.guidID;
// Get a list of supported resolutions for the guid.
bFindResolutions(guid, arResolutions, iNumResolutions);
// Add these devices to the combo box used for video modes.
for (int i = 0; i < iNumResolutions; ++i)
{
wsprintf(str_desc, "%ld x %ld", arResolutions[i].iWidth, arResolutions[i].iHeight);
ComboBox_AddString(m_hwndResolutions, str_desc);
}
// Try to select the preset resolution; if it is not available some other resolutions.
bGetDimensions(i_width, i_height);
if (!bMatchResolution(i_width, i_height))
{
// Try 400x300.
i_width = 400;
i_height = 300;
if (!bMatchResolution(i_width, i_height))
{
// Try 512x384.
i_width = 512;
i_height = 384;
if (!bMatchResolution(i_width, i_height))
{
// Try 640x480.
i_width = 640;
i_height = 480;
if (!bMatchResolution(i_width, i_height))
{
// Use first available resolution.
i_width = arResolutions[0].iWidth;
i_height = arResolutions[0].iHeight;
}
}
}
}
wsprintf(str_desc, "%ld x %ld", i_width, i_height);
// Select this in the Adapter listing
int i = ComboBox_SelectString(m_hwndResolutions, -1, str_desc);
if (i == CB_ERR)
{
// Set the first device as the default.
ComboBox_SetCurSel(m_hwndResolutions, 0);
}
}
void CConfigureWnd::InitializeTextureSizes()
{
// Clear current selections.
ComboBox_ResetContent(m_hwndTextureSizes);
bool b_disable_large = u4TotalPhysicalMemory() < 40 * 1024 * 1024;
// Add the available sizes.
ComboBox_AddString(m_hwndTextureSizes, strLow);
ComboBox_AddString(m_hwndTextureSizes, strMedium);
if (!b_disable_large)
ComboBox_AddString(m_hwndTextureSizes, strHigh);
// Get the recommended maximum texture dimension.
int i_dim = iGetRecommendedTextureMaxDim();
if (b_disable_large && i_dim > 64)
i_dim = 64;
if (i_dim > 64 && penumdevDevices->devGetSelectedDevice().d3dDevice.bSmallMemory)
i_dim = 64;
// Select the texture size.
int i_sel = 2;
switch (i_dim)
{
case 32:
i_sel = 0;
break;
case 64:
i_sel = 1;
break;
}
ComboBox_SetCurSel(m_hwndTextureSizes, i_sel);
}
void CConfigureWnd::InitializeWindowModes()
{
ComboBox_ResetContent(m_hwndWindowModes);
ComboBox_AddString(m_hwndWindowModes, "Window");
ComboBox_AddString(m_hwndWindowModes, "Borderless Window");
ComboBox_AddString(m_hwndWindowModes, "Exclusive Fullscreen");
int selected = static_cast<int>(GetWindowModeConfigured()) - 1;
ComboBox_SetCurSel(m_hwndWindowModes, selected);
}
void CConfigureWnd::InitializeCardSelection()
{
char str[2048];
// Clear the box.
ListBox_ResetContent(m_hwndList);
//
// List the enumerated devices.
//
for (int i = 0; i < penumdevDevices->iGetNumDevices(); ++i)
{
penumdevDevices->GetTitle(i, str);
ListBox_AddString(m_hwndList, str);
}
penumdevDevices->LoadSelectedDeviceFromRegistry();
int selectedDevice = penumdevDevices->GetSelectedDeviceIndex();
if (selectedDevice >= 0 && selectedDevice < iMaxDevices)
penumdevDevices->GetTitle(penumdevDevices->GetSelectedDeviceIndex(), str);
// Attempt to select a string.
ListBox_SelectString(m_hwndList, 0, str);
// Select card information.
OnSelchangeListCard();
}
void CConfigureWnd::OnSelchangeListCard()
{
// Select the device from the list.
{
int i_sel = ListBox_GetCurSel(m_hwndList);
if (i_sel == LB_ERR)
i_sel = 0;
int i_len = ListBox_GetTextLen(m_hwndList, i_sel);
char* str_cardname = new char[i_len + 1];
ListBox_GetText(m_hwndList, i_sel, str_cardname);
penumdevDevices->SelectDevice(str_cardname);
delete[] str_cardname;
}
// Output 3D driver information.
SD3DDevice d3ddev = penumdevDevices->devGetSelectedDevice().d3dDevice;
SetDlgItemText(m_hwnd, IDC_STATIC_VIDEODRIVER, d3ddev.strName);
SetDlgItemText(m_hwnd, IDC_STATIC_D3D, d3ddev.strDescription);
// If the card is a Voodoo 2, turn page management off.
switch (d3ddev.evcVideoCard)
{
case evcPermedia2:
case evcVoodoo2:
SetPageManaged(false);
break;
default:;
// Do nothing.
}
// Set the preferred state for water.
HWND hwnd_water_check = GetDlgItem(m_hwnd, IDC_CHECK_HARDWAREWATER);
if (d3ddev.bModulatedAlpha)
{
EnableWindow(hwnd_water_check, true);
CheckDlgButton(m_hwnd, IDC_CHECK_HARDWAREWATER, BST_CHECKED);
}
else
{
EnableWindow(hwnd_water_check, false);
CheckDlgButton(m_hwnd, IDC_CHECK_HARDWAREWATER, BST_UNCHECKED);
}
// Set the preferred state for triple buffering.
HWND hwnd_triple_check = GetDlgItem(m_hwnd, IDC_CHECK_TRIPLEBUFFER);
if (bGetTripleBuffer())
{
CheckDlgButton(m_hwnd, IDC_CHECK_TRIPLEBUFFER, BST_CHECKED);
}
else
{
CheckDlgButton(m_hwnd, IDC_CHECK_TRIPLEBUFFER, BST_UNCHECKED);
}
// Set the preferred state for page managed textures.
HWND hwnd_page_check = GetDlgItem(m_hwnd, IDC_CHECK_PAGEMANAGED);
if (bGetPageManaged())
{
CheckDlgButton(m_hwnd, IDC_CHECK_PAGEMANAGED, BST_CHECKED);
}
else
{
CheckDlgButton(m_hwnd, IDC_CHECK_PAGEMANAGED, BST_UNCHECKED);
}
// Set up the resolution combo box.
InitializeResolutions();
InitializeTextureSizes();
InitializeWindowModes();
// Set up dither check box.
CheckDlgButton(m_hwnd, IDC_CHECK_DITHER, (bGetDither()) ? (BST_CHECKED) : (BST_UNCHECKED));
// Grey out stuff.
HWND hwnd_dither_check = GetDlgItem(m_hwnd, IDC_CHECK_DITHER);
HWND hwnd_texres_check = GetDlgItem(m_hwnd, IDC_COMBO_TEXTURESIZE);
if (penumdevDevices->bSoftwareSelected())
{
EnableWindow(hwnd_triple_check, false);
EnableWindow(hwnd_dither_check, false);
EnableWindow(hwnd_texres_check, false);
EnableWindow(hwnd_page_check, false);
}
else
{
EnableWindow(hwnd_triple_check, true);
EnableWindow(hwnd_dither_check, true);
EnableWindow(hwnd_texres_check, true);
EnableWindow(hwnd_page_check, true);
}
}
void CConfigureWnd::OnCancel()
{
// Remove the device enumeration object.
delete penumdevDevices;
penumdevDevices = 0;
bSetInitFlag(TRUE);
CMultiDlg::OnCancel();
}
void CConfigureWnd::OnOK()
{
SD3DDevice d3ddev = penumdevDevices->devGetSelectedDevice().d3dDevice;
//
// Write the resolution currently selected to the registry.
//
int i_resolution = ComboBox_GetCurSel(m_hwndResolutions);
SetDimensions(arResolutions[i_resolution].iWidth, arResolutions[i_resolution].iHeight);
int i_sel = ComboBox_GetCurSel(m_hwndTextureSizes);
int i_recommended_max = 128;
switch (i_sel)
{
case 0:
i_recommended_max = 32;
break;
case 1:
i_recommended_max = 64;
break;
}
SetRecommendedTextureMaxDim(i_recommended_max);
// Write D3D settings to the registry.
penumdevDevices->WriteSelectedDeviceToRegistry();
// Save the hardware water flag to the registery.
SetRegValue(strHARDWARE_WATER, d3ddev.bModulatedAlpha && IsDlgButtonChecked(m_hwnd, IDC_CHECK_HARDWAREWATER));
// Set the page manager flag to the registry.
SetPageManaged(IsDlgButtonChecked(m_hwnd, IDC_CHECK_PAGEMANAGED));
// Set the triple buffer flag.
SetTripleBuffer(IsDlgButtonChecked(m_hwnd, IDC_CHECK_TRIPLEBUFFER));
// Set the dither flag.
SetDither(IsDlgButtonChecked(m_hwnd, IDC_CHECK_DITHER));
int selectedWindowMode = ComboBox_GetCurSel(m_hwndWindowModes);
SetWindowModeConfigured(static_cast<WindowMode>(selectedWindowMode + 1));
// Close the registry and exit.
CMultiDlg::OnOK();
// Remove the device enumeration object.
delete penumdevDevices;
penumdevDevices = nullptr;
//exit(0);
}
//+--------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
CRenderWnd::CRenderWnd(CUIManager * puimgr) : CUIDlg(puimgr)
{
m_guidDefAdapter = ReadDDGUID();
m_guidAdapter = m_guidDefAdapter;
m_guidDefD3D = ReadD3DGUID();
m_guidD3D = m_guidDefD3D;
bGetDimensions(m_iDefWidth, m_iDefHeight);
m_iWidth = m_iDefWidth;
m_iHeight = m_iDefHeight;
Video::SetToValidMode(m_iWidth, m_iHeight);
SetDimensions(m_iWidth, m_iHeight);
bFindResolutions(m_guidAdapter, arResolutions, iNumResolutions);
}
CRenderWnd::~CRenderWnd()
{
}
BOOL CRenderWnd::OnCreate()
{
CUISlider * pslider;
CUITextbox * ptext;
char sz[200];
//CUICheckbox * pcheck;
if (!CUIDlg::OnCreate())
{
TraceError(("CRenderWnd::OnCreate() -- base create failed"));
return FALSE;
}
AddResolutionsToList();
SelectCurrentResolution();
//
// Quality Settings
//
pslider = (CUISlider *)GetUICtrl(1006);
Assert(pslider != NULL);
m_iDefQuality = g_CTPassGlobals.GetRenderQuality();
pslider->SetCurrUnit(m_iDefQuality);
//
// Gamma Settings
//
pslider = (CUISlider *)GetUICtrl(1008);
Assert(pslider != NULL);
m_iDefGamma = g_CTPassGlobals.GetGamma();
pslider->SetCurrUnit(m_iDefGamma);
//
// Video Driver Name
//
ptext = (CUITextbox *)GetUICtrl(1011);
GetRegString(strD3D_TITLE, sz, sizeof(sz), "");
if (strlen(sz) == 0)
{
LoadString(g_hInst, IDS_SOFTWARE_DRIVER, sz, sizeof(sz));
}
ptext->SetText(sz);
//
// Screen Size
//
pslider = (CUISlider *)GetUICtrl(1012);
Assert(pslider != NULL);
m_iDefScreenSize = (VIEWPORT_INCREMENTS - 1) -
GetRegValue(REG_KEY_VIEWPORT_X, DEFAULT_VIEWPORT_X);
if (m_iDefScreenSize < 0)
{
m_iDefScreenSize = 0;
}
else if (m_iDefScreenSize >= VIEWPORT_INCREMENTS)
{
m_iDefScreenSize = VIEWPORT_INCREMENTS - 1;
}
pslider->SetCurrUnit(m_iDefScreenSize);
/*
pcheck = (CUICheckbox *)GetUICtrl(1003);
Assert(pcheck != NULL);
pcheck->SetDown(m_bUseHardware);
*/
CenterUIWindow(this);
return TRUE;
}
void CRenderWnd::GetWndFile(LPSTR psz, int ic)
{
strcpy(psz, "render.ddf");
}
void CRenderWnd::EnterVideoRes()
{
}
void CRenderWnd::UIButtonUp(CUIButton * pbutton)
{
switch (pbutton->GetID())
{
// Cancel
case 1000:
EndUIWnd(0);
break;
// OK
case 1001:
{
OnOk();
}
break;
// Select new driver.
case 1003:
{
OnSelectNewDriver();
}
break;
}
}
void CRenderWnd::OnOk()
{
CUIListbox * plist;
CUISlider * pslider;
//CUICheckbox * pcheck;
int i;
BOOL iChanges = 0;
BOOL bFullReset = FALSE;
// Get The current Resolution
plist = (CUIListbox *)GetUICtrl(1002);
Assert(plist != NULL);
i = plist->GetCurrSel();
m_iWidth = arResolutions[i].iWidth;
m_iHeight = arResolutions[i].iHeight;
if ((m_iWidth != m_iDefWidth) ||
(m_iHeight != m_iDefHeight))
{
iChanges++;
bFullReset = TRUE;
}
//
// Quality Settings
//
pslider = (CUISlider *)GetUICtrl(1006);
Assert(pslider != NULL);
i = pslider->GetCurrUnit();
if (m_iDefQuality != i)
{
iChanges++;
g_CTPassGlobals.SetRenderQuality(i);
}
//
// Gamma Settings
//
pslider = (CUISlider *)GetUICtrl(1008);
Assert(pslider != NULL);
i = pslider->GetCurrUnit();
if (m_iDefGamma != i)
{
iChanges++;
g_CTPassGlobals.SetGamma(i);
g_CTPassGlobals.InitGamma();
}
//
// Screen Size
//
pslider = (CUISlider *)GetUICtrl(1012);
Assert(pslider != NULL);
i = pslider->GetCurrUnit();
if (m_iDefScreenSize != i)
{
iChanges++;
i = (VIEWPORT_INCREMENTS - 1) - i;
SetRegValue(REG_KEY_VIEWPORT_X, i);
SetRegValue(REG_KEY_VIEWPORT_Y, i);
}
// Save out all the settings
Persist();
#if 0
if (!bGetInitFlag())
{
//
// BUGBUG!
//
// To do:
// Fix this problem.
//
//MessageBox(0, "Due to a minor bug, you must unfortunately fully exit the application!",
//"Sorry, Minor Bug", MB_OK | MB_ICONHAND);
//exit(0);
EndUIWnd(3);
}
else
#endif
if (bFullReset)
{
EndUIWnd(2);
}
else if (iChanges > 0)
{
EndUIWnd(1);
}
else
{
EndUIWnd(0);
}
}
void CRenderWnd::Persist()
{
if (m_iHeight != m_iDefHeight || m_iWidth != m_iDefWidth)
{
SetDimensions(m_iWidth, m_iHeight);
}
}
void CRenderWnd::AddAdaptersToList()
{
}
void CRenderWnd::SelectCurrentAdapter()
{
}
void CRenderWnd::ResetListItems()
{
}
void CRenderWnd::ChangeAdapter()
{
}
void CRenderWnd::AddResolutionsToList()
{
char szDesc[32];
int i;
CUIListbox * plist;
// Clear current selections.
plist = (CUIListbox *)GetUICtrl(1002);
// Add these devices to the combo box used for video modes.
for (i = 0; i < iNumResolutions; ++i)
{
if (arResolutions[i].iRefreshHz)
{
wsprintf(szDesc,
"%ld x %ld at %ld Hz",
arResolutions[i].iWidth,
arResolutions[i].iHeight,
arResolutions[i].iRefreshHz);
}
else
{
wsprintf(szDesc,
"%ld x %ld",
arResolutions[i].iWidth,
arResolutions[i].iHeight);
}
plist->AddItem(szDesc, 0, -1, 0);
}
}
void CRenderWnd::SelectCurrentResolution()
{
int i;
char sz[50];
CUIListbox * plistbox;
// Read in the current game dimensions
wsprintf(sz, "%ld x %ld", m_iWidth, m_iHeight);
plistbox = (CUIListbox *)GetUICtrl(1002);
i = plistbox->FindItem(sz);
if (i == -1)
{
// This Resolution mode doesn't exist on the currently
// selected device.
// try 640 x 480
wsprintf(sz, "%ld x %ld", DEFAULT_SIZE_WIDTH, DEFAULT_SIZE_HEIGHT);
i = plistbox->FindItem(sz);
if (i == -1)
{
// Man in the video card doesn't support 640x480 then we
// are completely fucked.
// BUGBUG: throw up an error dialog here
return;
}
// BUGBUG: We may want to have this saved out to the user's
// BUGBUG: registry potentially.
}
plistbox->SetCurrSel(i);
plistbox->ScrollToActive();
}
void CRenderWnd::AddD3DToList()
{
}
void CRenderWnd::SelectCurrentD3D()
{
}
void CRenderWnd::OnSelectNewDriver()
{
// Set flag to cause the card selection dialog to pop up on startup.
bSetInitFlag(false);
// Save out all the settings
Persist();
//
// Save out the current game in a temporary file if a game is loaded.
//
// To do:
// Get the correct way of determining if a level is loaded.
//
if (g_CTPassGlobals.bInGame)
{
//
// Note that the scene is saved out here instead of a savegame! The earlier system
// prevented the automatic restoring of a game after selecting a new video driver.
//
if (g_CTPassGlobals.bSaveScene(strTEMP_GAME))
SetAutoLoad(TRUE);
}
else
{
SetAutoLoad(FALSE);
}
// Kill Direct3D.
//d3dDriver.Uninitialize();
// Reboot the application.
EndUIWnd(3);
}
Reference in New Issue View Git Blame Copy Permalink