d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
551 Commits
25 Branches
6 Tags
221 MiB
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
source-engine/hammer/options.cpp

1082 lines
35 KiB
Raw Permalink Normal View History Unescape

1
5 years ago
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Manages the set of application configuration options.
//
//=============================================================================//
#include "stdafx.h"
#include "Options.h"
#include "hammer.h"
#include "MainFrm.h"
#include "mapdoc.h"
#include "KeyValues.h"
#include "ConfigManager.h"
#include "GlobalFunctions.h"
#include "CustomMessages.h"
#include "OptionProperties.h"
#include <process.h>
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
const char GAMECFG_SIG[] = "Game Configurations File\r\n\x1a";
const float GAMECFG_VERSION = 1.4f;
static const char *pszGeneral = "General";
static const char *pszView2D = "2D Views";
static const char *pszView3D = "3D Views";
static const char *g_szColors = "Custom2DColors";
const int iThisVersion = 2;
// So File | Open will be in the right directory.
char *g_pMapDir = NULL;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
COptionsConfigs::COptionsConfigs(void)
{
nConfigs = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output :
//-----------------------------------------------------------------------------
COptionsConfigs::~COptionsConfigs(void)
{
for (int i = 0; i < nConfigs; i++)
{
CGameConfig *pConfig = Configs[i];
if (!pConfig)
continue;
delete pConfig;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output :
//-----------------------------------------------------------------------------
CGameConfig *COptionsConfigs::AddConfig(void)
{
CGameConfig *pConfig = new CGameConfig;
Configs.SetAtGrow(nConfigs++, pConfig);
return pConfig;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : dwID -
// piIndex -
// Output :
//-----------------------------------------------------------------------------
CGameConfig *COptionsConfigs::FindConfig(DWORD dwID, int *piIndex)
{
for(int i = 0; i < nConfigs; i++)
{
if(Configs[i]->dwID == dwID)
{
if(piIndex)
piIndex[0] = i;
return Configs[i];
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Looks for a game configuration with a given mod directory.
//-----------------------------------------------------------------------------
CGameConfig *COptionsConfigs::FindConfigForGame(const char *szGame)
{
for (int i = 0; i < nConfigs; i++)
{
char *pszGameDir = Configs[i]->m_szModDir;
if ( Q_stricmp( pszGameDir, szGame ) == 0 )
return Configs[i];
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns the number of game configurations successfully imported.
//-----------------------------------------------------------------------------
int COptionsConfigs::ImportOldGameConfigs(const char *pszFileName)
{
int nConfigsRead = 0;
char szRootDir[MAX_PATH];
char szFullPath[MAX_PATH];
APP()->GetDirectory(DIR_PROGRAM, szRootDir);
Q_MakeAbsolutePath( szFullPath, MAX_PATH, pszFileName, szRootDir );
std::fstream file( szFullPath, std::ios::in | std::ios::binary );
if (file.is_open())
{
// Read sig.
char szSig[sizeof(GAMECFG_SIG)];
file.read(szSig, sizeof szSig);
if (!memcmp(szSig, GAMECFG_SIG, sizeof szSig))
{
// Read version.
float fThisVersion;
file.read((char *)&fThisVersion, sizeof(fThisVersion));
if ((fThisVersion >= 1.0) && (fThisVersion <= GAMECFG_VERSION))
{
// Read number of configs.
int nTotalConfigs;
file.read((char *)&nTotalConfigs, sizeof(nTotalConfigs));
// Load each config.
for (int i = 0; i < nTotalConfigs; i++)
{
CGameConfig *pConfig = AddConfig();
pConfig->Import(file, fThisVersion);
nConfigsRead++;
if (!g_pMapDir)
{
g_pMapDir = (char *)pConfig->szMapDir;
}
}
}
}
file.close();
}
return(nConfigsRead);
}
// Our call to "new" will be hosed without this header
#include "tier0/memdbgoff.h"
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool COptionsConfigs::ResetGameConfigs( bool bOverwrite )
{
CGameConfigManager mgr;
int nNumLoaded = 0;
mgr.SetBaseDirectory( m_strConfigDir );
if ( bOverwrite )
{
// Reset the configurations on the disk
mgr.ResetConfigs();
// Load the newly changed game configs
nNumLoaded = LoadGameConfigs();
}
else
{
// Simply get the keyvalue block from the manager and parse that
KeyValues *pDefaultConfigs = new KeyValues( "Defaults" );
if ( mgr.GetDefaultGameBlock( pDefaultConfigs ) == false )
return false;
// Load from the blocks
nNumLoaded = LoadGameConfigsBlock( pDefaultConfigs );
// Clean up
pDefaultConfigs->deleteThis();
}
return ( nNumLoaded > 0 );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pBlock -
// Output : int
//-----------------------------------------------------------------------------
int COptionsConfigs::LoadGameConfigsBlock( KeyValues *pBlock )
{
if ( pBlock == NULL )
return 0;
int nConfigsRead = 0;
for ( KeyValues *pKey = pBlock->GetFirstTrueSubKey(); pKey; pKey = pKey->GetNextTrueSubKey() )
{
CGameConfig *pConfig = AddConfig();
if ( pConfig != NULL )
{
if ( pConfig->Load( pKey ) )
{
nConfigsRead++;
}
}
}
return nConfigsRead;
}
//-----------------------------------------------------------------------------
// Purpose: Loads all the game configs from disk.
// Output : Returns the number of game configurations successfully loaded.
//-----------------------------------------------------------------------------
int COptionsConfigs::LoadGameConfigs()
{
//
// Read game configs - this is from an external file so we can distribute it
// with the editor as a set of defaults.
//
// Older versions of the editor used a binary file. Try that first.
//
int nConfigsRead = ImportOldGameConfigs("GameCfg.wc");
if (nConfigsRead > 0)
{
// This will cause a double conversion, from .wc to .ini to .txt, but oh well...
char szRootDir[MAX_PATH];
char szFullPath[MAX_PATH];
APP()->GetDirectory(DIR_PROGRAM, szRootDir);
Q_MakeAbsolutePath( szFullPath, MAX_PATH, "GameCfg.wc", szRootDir );
remove( szFullPath );
char szSaveName[MAX_PATH];
strcpy(szSaveName, m_strConfigDir);
Q_AppendSlash(szSaveName, sizeof(szSaveName));
Q_strcat(szSaveName, "GameCfg.ini", sizeof(szSaveName));
SaveGameConfigs();
return(nConfigsRead);
}
CGameConfigManager mgr;
if ( !mgr.LoadConfigs( m_strConfigDir ) )
return 0;
KeyValues *pGame = mgr.GetGameBlock();
if (!pGame)
return 0;
// Install the message handler for error messages.
GDSetMessageFunc(Msg);
// Load from the blocks
nConfigsRead = LoadGameConfigsBlock( pGame );
return nConfigsRead;
}
//-----------------------------------------------------------------------------
// Purpose: Saves all the cgame configurations to disk.
// Input : *pszFileName -
//-----------------------------------------------------------------------------
void COptionsConfigs::SaveGameConfigs()
{
// Only do this if we've got configs to save!
if ( GetGameConfigCount() == 0 )
return;
CGameConfigManager mgr;
if ( mgr.LoadConfigs( m_strConfigDir ) == false )
return;
// Get the global configuration data
KeyValues *pGame = mgr.GetGameBlock();
// For each Hammer known configuation, update the values in the global configs
for ( int i = 0; i < nConfigs; i++ )
{
KeyValues *pConfig = pGame->FindKey(Configs.GetAt(i)->szName);
// Add the configuration if it wasn't found
if ( pConfig == NULL )
{
pConfig = pGame->CreateNewKey();
if ( pConfig == NULL )
{
// FIXME: fatal error
return;
}
}
// Update the changes
Configs.GetAt(i)->Save(pConfig);
}
// For each global configuration, remove any configs Hammer has deleted
bool bFoundConfig;
KeyValues *pConfig = pGame->GetFirstTrueSubKey();
while ( pConfig != NULL )
{
// Search through all the configs Hammer knows of for a matching name
bFoundConfig = false;
for ( int i = 0; i < nConfigs; i++ )
{
if ( !Q_stricmp( pConfig->GetName(), Configs.GetAt(i)->szName ) )
{
bFoundConfig = true;
break;
}
}
// Move along to the next config
if ( bFoundConfig )
{
pConfig = pConfig->GetNextTrueSubKey();
continue;
}
// Delete the configuration block if we didn't find it
KeyValues *pNextConfig = pConfig->GetNextTrueSubKey();
pGame->RemoveSubKey( pConfig );
pConfig->deleteThis();
pConfig = pNextConfig;
}
// Save the resulting changes
mgr.SaveConfigs( m_strConfigDir );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
COptions::COptions(void)
{
}
//-----------------------------------------------------------------------------
// Purpose: Looks for the Valve Hammer Editor registry settings and returns whether
// they were found.
//-----------------------------------------------------------------------------
static bool HammerSettingsFound(void)
{
bool bFound = false;
HKEY hkeySoftware;
if (RegOpenKeyEx(HKEY_CURRENT_USER, "Software", 0, KEY_READ | KEY_WRITE, &hkeySoftware) == ERROR_SUCCESS)
{
HKEY hkeyValve;
if (RegOpenKeyEx(hkeySoftware, "Valve", 0, KEY_READ | KEY_WRITE, &hkeyValve) == ERROR_SUCCESS)
{
HKEY hkeyHammer;
if (RegOpenKeyEx(hkeyValve, "Hammer", 0, KEY_READ | KEY_WRITE, &hkeyHammer) == ERROR_SUCCESS)
{
HKEY hkeyConfigured;
if (RegOpenKeyEx(hkeyHammer, "Configured", 0, KEY_READ | KEY_WRITE, &hkeyConfigured) == ERROR_SUCCESS)
{
bFound = true;
RegCloseKey(hkeyConfigured);
}
RegCloseKey(hkeyHammer);
}
RegCloseKey(hkeyValve);
}
RegCloseKey(hkeySoftware);
}
return bFound;
}
//-----------------------------------------------------------------------------
// Purpose: Looks for the Valve Hammer Editor registry settings and returns whether
// they were found.
//-----------------------------------------------------------------------------
static bool ValveHammerEditorSettingsFound(void)
{
bool bFound = false;
HKEY hkeySoftware;
if (RegOpenKeyEx(HKEY_CURRENT_USER, "Software", 0, KEY_READ | KEY_WRITE, &hkeySoftware) == ERROR_SUCCESS)
{
HKEY hkeyValve;
if (RegOpenKeyEx(hkeySoftware, "Valve", 0, KEY_READ | KEY_WRITE, &hkeyValve) == ERROR_SUCCESS)
{
HKEY hkeyHammer;
if (RegOpenKeyEx(hkeyValve, "Valve Hammer Editor", 0, KEY_READ | KEY_WRITE, &hkeyHammer) == ERROR_SUCCESS)
{
HKEY hkeyConfigured;
if (RegOpenKeyEx(hkeyHammer, "Configured", 0, KEY_READ | KEY_WRITE, &hkeyConfigured) == ERROR_SUCCESS)
{
bFound = true;
RegCloseKey(hkeyConfigured);
}
RegCloseKey(hkeyHammer);
}
RegCloseKey(hkeyValve);
}
RegCloseKey(hkeySoftware);
}
return bFound;
}
//-----------------------------------------------------------------------------
// Purpose: Looks for the Worldcraft registry settings and returns whether they
// were found.
//-----------------------------------------------------------------------------
static bool WorldcraftSettingsFound(void)
{
bool bFound = false;
HKEY hkeySoftware;
if (RegOpenKeyEx(HKEY_CURRENT_USER, "Software", 0, KEY_READ | KEY_WRITE, &hkeySoftware) == ERROR_SUCCESS)
{
HKEY hkeyValve;
if (RegOpenKeyEx(hkeySoftware, "Valve", 0, KEY_READ | KEY_WRITE, &hkeyValve) == ERROR_SUCCESS)
{
HKEY hkeyWorldcraft;
if (RegOpenKeyEx(hkeyValve, "Worldcraft", 0, KEY_READ | KEY_WRITE, &hkeyWorldcraft) == ERROR_SUCCESS)
{
bFound = true;
RegCloseKey(hkeyWorldcraft);
}
RegCloseKey(hkeyValve);
}
RegCloseKey(hkeySoftware);
}
return bFound;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool COptions::Init(void)
{
//
// If the we have no registry settings and the "Valve Hammer Editor" registry tree exists,
// import settings from there. If that isn't found, try "Worldcraft".
//
bool bWCSettingsFound = false;
bool bVHESettingsFound = false;
if (!HammerSettingsFound())
{
bVHESettingsFound = ValveHammerEditorSettingsFound();
if (!bVHESettingsFound)
{
bWCSettingsFound = WorldcraftSettingsFound();
}
}
if (bVHESettingsFound)
{
APP()->BeginImportVHESettings();
}
else if (bWCSettingsFound)
{
APP()->BeginImportWCSettings();
}
SetDefaults();
if (!Read())
{
return false;
}
if (bVHESettingsFound || bWCSettingsFound)
{
APP()->EndImportSettings();
}
//
// Notify appropriate windows of new settings.
// dvs: is all this necessary?
//
CMainFrame *pMainWnd = GetMainWnd();
if (pMainWnd != NULL)
{
pMainWnd->SetBrightness(textures.fBrightness);
pMainWnd->UpdateAllDocViews( MAPVIEW_OPTIONS_CHANGED );
// FIXME: can't do this before the filesystem is initialized
//pMainWnd->GlobalNotify(WM_GAME_CHANGED);
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Enables or disables texture locking.
// Input : b - TRUE to enable texture locking, FALSE to disable.
// Output : Returns the previous value of the texture locking flag.
//-----------------------------------------------------------------------------
BOOL COptions::SetLockingTextures(BOOL b)
{
BOOL bOld = general.bLockingTextures;
general.bLockingTextures = b;
return(bOld);
}
//-----------------------------------------------------------------------------
// Purpose: Returns TRUE if texture locking is enabled, FALSE if not.
//-----------------------------------------------------------------------------
BOOL COptions::IsLockingTextures(void)
{
return(general.bLockingTextures);
}
BOOL COptions::SetScaleLockingTextures(BOOL b)
{
BOOL bOld = general.bScaleLockingTextures;
general.bScaleLockingTextures = b;
return(bOld);
}
BOOL COptions::IsScaleLockingTextures(void)
{
return general.bScaleLockingTextures;
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether new faces should be world aligned or face aligned.
//-----------------------------------------------------------------------------
TextureAlignment_t COptions::GetTextureAlignment(void)
{
return(general.eTextureAlignment);
}
//-----------------------------------------------------------------------------
// Purpose: Sets whether new faces should be world aligned or face aligned.
// Input : eTextureAlignment - TEXTURE_ALIGN_WORLD or TEXTURE_ALIGN_FACE.
// Output : Returns the old setting for texture alignment.
//-----------------------------------------------------------------------------
TextureAlignment_t COptions::SetTextureAlignment(TextureAlignment_t eTextureAlignment)
{
TextureAlignment_t eOld = general.eTextureAlignment;
general.eTextureAlignment = eTextureAlignment;
return(eOld);
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether helpers should be hidden or shown.
//-----------------------------------------------------------------------------
bool COptions::GetShowHelpers(void)
{
return (general.bShowHelpers == TRUE);
}
bool COptions::IsVGUIModelBrowserEnabled()
{
return (general.bUseVGUIModelBrowser == TRUE);
}
//-----------------------------------------------------------------------------
// Purpose: Sets whether helpers should be hidden or shown.
//-----------------------------------------------------------------------------
void COptions::SetShowHelpers(bool bShow)
{
general.bShowHelpers = bShow ? TRUE : FALSE;
}
//-----------------------------------------------------------------------------
// Purpose: Loads the application configuration settings.
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
bool COptions::Read(void)
{
if (!APP()->GetProfileInt("Configured", "Configured", 0))
{
return false;
}
DWORD dwTime = APP()->GetProfileInt("Configured", "Installed", time(NULL));
CTimeSpan ts(time(NULL) - dwTime);
uDaysSinceInstalled = ts.GetDays();
int i, iSize;
CString str;
// read texture info - it's stored in the general section from
// an old version, but this doesn't matter much.
iSize = APP()->GetProfileInt(pszGeneral, "TextureFileCount", 0);
if(iSize)
{
// make sure default is removed
textures.nTextureFiles = 0;
textures.TextureFiles.RemoveAll();
// read texture file names
for(i = 0; i < iSize; i++)
{
str.Format("TextureFile%d", i);
str = APP()->GetProfileString(pszGeneral, str);
if(GetFileAttributes(str) == 0xffffffff)
{
// can't find
continue;
}
textures.TextureFiles.Add(str);
textures.nTextureFiles++;
}
}
else
{
// SetDefaults() added 'textures.wad' to the list
}
textures.fBrightness = float(APP()->GetProfileInt(pszGeneral, "Brightness", 10)) / 10.0;
// load general info
general.nMaxCameras = APP()->GetProfileInt(pszGeneral, "Max Cameras", 100);
general.iUndoLevels = APP()->GetProfileInt(pszGeneral, "Undo Levels", 50);
general.bLockingTextures = APP()->GetProfileInt(pszGeneral, "Locking Textures", TRUE);
general.bScaleLockingTextures = APP()->GetProfileInt(pszGeneral, "Scale Locking Textures", FALSE);
general.eTextureAlignment = (TextureAlignment_t)APP()->GetProfileInt(pszGeneral, "Texture Alignment", TEXTURE_ALIGN_WORLD);
general.bLoadwinpos = APP()->GetProfileInt(pszGeneral, "Load Default Positions", TRUE);
general.bIndependentwin = APP()->GetProfileInt(pszGeneral, "Independent Windows", FALSE);
general.bGroupWhileIgnore = APP()->GetProfileInt(pszGeneral, "GroupWhileIgnore", FALSE);
general.bStretchArches = APP()->GetProfileInt(pszGeneral, "StretchArches", TRUE);
general.bShowHelpers = APP()->GetProfileInt(pszGeneral, "Show Helpers", TRUE);
general.bCheckVisibleMapErrors = APP()->GetProfileInt(pszGeneral, "Visible Map Errors", FALSE);
general.iTimeBetweenSaves = APP()->GetProfileInt(pszGeneral, "Time Between Saves", 15);
general.iMaxAutosaveSpace = APP()->GetProfileInt(pszGeneral, "Max Autosave Space", 100);
general.iMaxAutosavesPerMap = APP()->GetProfileInt(pszGeneral, "Max Saves Per Map", 5);
general.bEnableAutosave = APP()->GetProfileInt(pszGeneral, "Autosaves Enabled", 1);
general.bClosedCorrectly = APP()->GetProfileInt(pszGeneral, "Closed Correctly", TRUE);
general.bUseVGUIModelBrowser = APP()->GetProfileInt(pszGeneral, "VGUI Model Browser", TRUE);
general.bShowHiddenTargetsAsBroken = APP()->GetProfileInt(pszGeneral, "Show Hidden Targets As Broken", TRUE);
general.bRadiusCulling = APP()->GetProfileInt(pszGeneral, "Use Radius Culling", FALSE);
char szDefaultAutosavePath[MAX_PATH];
V_strcpy_safe( szDefaultAutosavePath, APP()->GetProfileString( pszGeneral, "Directory", "C:" ) );
V_strcpy_safe( szDefaultAutosavePath, "\\HammerAutosave\\" );
strcpy( general.szAutosaveDir, APP()->GetProfileString("General", "Autosave Dir", szDefaultAutosavePath));
if ( Q_strlen( general.szAutosaveDir ) == 0 )
{
strcpy( general.szAutosaveDir, szDefaultAutosavePath );
}
APP()->SetDirectory( DIR_AUTOSAVE, general.szAutosaveDir );
// read view2d
view2d.bCrosshairs = APP()->GetProfileInt(pszView2D, "Crosshairs", FALSE);
view2d.bGroupCarve = APP()->GetProfileInt(pszView2D, "GroupCarve", TRUE);
view2d.bScrollbars = APP()->GetProfileInt(pszView2D, "Scrollbars", TRUE);
view2d.bRotateConstrain = APP()->GetProfileInt(pszView2D, "RotateConstrain", FALSE);
view2d.bDrawVertices = APP()->GetProfileInt(pszView2D, "Draw Vertices", TRUE);
view2d.bDrawModels = APP()->GetProfileInt(pszView2D, "Draw Models", TRUE);
view2d.bWhiteOnBlack = APP()->GetProfileInt(pszView2D, "WhiteOnBlack", TRUE);
view2d.bGridHigh1024 = APP()->GetProfileInt(pszView2D, "GridHigh1024", TRUE);
view2d.bGridHigh10 = APP()->GetProfileInt(pszView2D, "GridHigh10", TRUE);
view2d.bHideSmallGrid = APP()->GetProfileInt(pszView2D, "HideSmallGrid", TRUE);
view2d.bNudge = APP()->GetProfileInt(pszView2D, "Nudge", FALSE);
view2d.bOrientPrimitives = APP()->GetProfileInt(pszView2D, "OrientPrimitives", FALSE);
view2d.bAutoSelect = APP()->GetProfileInt(pszView2D, "AutoSelect", FALSE);
view2d.bSelectbyhandles = APP()->GetProfileInt(pszView2D, "SelectByHandles", FALSE);
view2d.iGridIntensity = APP()->GetProfileInt(pszView2D, "GridIntensity", 30);
view2d.iDefaultGrid = APP()->GetProfileInt(pszView2D, "Default Grid", 64);
view2d.iGridHighSpec = APP()->GetProfileInt(pszView2D, "GridHighSpec", 8);
view2d.bKeepclonegroup = APP()->GetProfileInt(pszView2D, "Keepclonegroup", TRUE);
view2d.bGridHigh64 = APP()->GetProfileInt(pszView2D, "Gridhigh64", TRUE);
view2d.bGridDots = APP()->GetProfileInt(pszView2D, "GridDots", FALSE);
view2d.bCenteroncamera = APP()->GetProfileInt(pszView2D, "Centeroncamera", FALSE);
view2d.bUsegroupcolors = APP()->GetProfileInt(pszView2D, "Usegroupcolors", TRUE);
// read view3d
view3d.bHardware = APP()->GetProfileInt(pszView3D, "Hardware", FALSE);
view3d.bReverseY = APP()->GetProfileInt(pszView3D, "Reverse Y", TRUE);
view3d.iBackPlane = APP()->GetProfileInt(pszView3D, "BackPlane", 5000);
view3d.bUseMouseLook = APP()->GetProfileInt(pszView3D, "UseMouseLook", TRUE);
view3d.nModelDistance = APP()->GetProfileInt(pszView3D, "ModelDistance", 400);
view3d.nDetailDistance = APP()->GetProfileInt(pszView3D, "DetailDistance", 1200);
view3d.bAnimateModels = APP()->GetProfileInt(pszView3D, "AnimateModels", FALSE);
view3d.nForwardSpeedMax = APP()->GetProfileInt(pszView3D, "ForwardSpeedMax", 1000);
view3d.nTimeToMaxSpeed = APP()->GetProfileInt(pszView3D, "TimeToMaxSpeed", 500);
view3d.bFilterTextures = APP()->GetProfileInt(pszView3D, "FilterTextures", TRUE);
view3d.bReverseSelection = APP()->GetProfileInt(pszView3D, "ReverseSelection", FALSE);
view3d.fFOV = 90;
view3d.fLightConeLength = 10;
ReadColorSettings();
//
// If we can't load any game configurations, pop up the options screen.
//
if (configs.LoadGameConfigs() == 0)
{
if (!RunConfigurationDialog())
return false;
}
//
// By default use the first config.
//
if (configs.nConfigs > 0)
{
g_pGameConfig = configs.Configs.GetAt(0);
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool COptions::RunConfigurationDialog()
{
CString strText;
strText.LoadString(IDS_NO_CONFIGS_AVAILABLE);
if (MessageBox(NULL, strText, "First Time Setup", MB_ICONQUESTION | MB_YESNO) == IDYES)
{
APP()->OpenURL(ID_HELP_FIRST_TIME_SETUP, GetMainWnd()->GetSafeHwnd());
}
COptionProperties dlg("Configure Hammer");
do
{
if (dlg.DoModal() != IDOK)
{
return false;
}
if (configs.nConfigs == 0)
{
MessageBox(NULL, "You must create at least one game configuration before using Hammer.", "First Time Setup", MB_ICONEXCLAMATION | MB_OK);
}
} while (configs.nConfigs == 0);
Options.Write( TRUE, TRUE );
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void COptions::ReadColorSettings(void)
{
colors.bUseCustom = (APP()->GetProfileInt(g_szColors, "UseCustom", 0) != 0);
if (colors.bUseCustom)
{
colors.clrAxis = APP()->GetProfileColor(g_szColors, "Grid0", 0 , 100, 100);
colors.bScaleAxisColor = (APP()->GetProfileInt(g_szColors, "ScaleGrid0", 0) != 0);
colors.clrGrid = APP()->GetProfileColor(g_szColors, "Grid", 50 , 50, 50);
colors.bScaleGridColor = (APP()->GetProfileInt(g_szColors, "ScaleGrid", 1) != 0);
colors.clrGrid10 = APP()->GetProfileColor(g_szColors, "Grid10", 40 , 40, 40);
colors.bScaleGrid10Color = (APP()->GetProfileInt(g_szColors, "ScaleGrid10", 1) != 0);
colors.clrGrid1024 = APP()->GetProfileColor(g_szColors, "Grid1024", 40 , 40, 40);
colors.bScaleGrid1024Color = (APP()->GetProfileInt(g_szColors, "ScaleGrid1024", 1) != 0);
colors.clrGridDot = APP()->GetProfileColor(g_szColors, "GridDot", 128, 128, 128);
colors.bScaleGridDotColor = (APP()->GetProfileInt(g_szColors, "ScaleGridDot", 1) != 0);
colors.clrBrush = APP()->GetProfileColor(g_szColors, "LineColor", 0, 0, 0);
colors.clrEntity = APP()->GetProfileColor(g_szColors, "Entity", 220, 30, 220);
colors.clrVertex = APP()->GetProfileColor(g_szColors, "Vertex", 0, 0, 0);
colors.clrBackground = APP()->GetProfileColor(g_szColors, "Background", 0, 0, 0);
colors.clrToolHandle = APP()->GetProfileColor(g_szColors, "HandleColor", 0, 0, 0);
colors.clrToolBlock = APP()->GetProfileColor(g_szColors, "BoxColor", 0, 0, 0);
colors.clrToolSelection = APP()->GetProfileColor(g_szColors, "ToolSelect", 0, 0, 0);
colors.clrToolMorph = APP()->GetProfileColor(g_szColors, "Morph", 255, 0, 0);
colors.clrToolPath = APP()->GetProfileColor(g_szColors, "Path", 255, 0, 0);
colors.clrSelection = APP()->GetProfileColor(g_szColors, "Selection", 220, 0, 0);
colors.clrToolDrag = APP()->GetProfileColor(g_szColors, "ToolDrag", 255, 255, 0);
}
else
{
if (Options.view2d.bWhiteOnBlack)
{
// BLACK BACKGROUND
colors.clrBackground = RGB(0, 0, 0);
colors.clrGrid = RGB(255, 255, 255);
colors.clrGridDot = RGB(255, 255, 255);
colors.clrGrid1024 = RGB(100, 50, 5);
colors.clrGrid10 = RGB(255, 255, 255);
colors.clrAxis = RGB(0, 100, 100);
colors.clrBrush = RGB(255, 255, 255);
colors.clrVertex = RGB(255, 255, 255);
colors.clrToolHandle = RGB(255, 255, 255);
colors.clrToolBlock = RGB(255, 255, 255);
colors.clrToolDrag = RGB(255, 255, 0);
}
else
{
// WHITE BACKGROUND
colors.clrBackground = RGB(255, 255, 255);
colors.clrGrid = RGB(50, 50, 50);
colors.clrGridDot = RGB(40, 40, 40);
colors.clrGrid1024 = RGB(200, 100, 10);
colors.clrGrid10 = RGB(40, 40, 40);
colors.clrAxis = RGB(0, 100, 100);
colors.clrBrush = RGB(0, 0, 0);
colors.clrVertex = RGB(0, 0, 0);
colors.clrToolHandle = RGB(0, 0, 0);
colors.clrToolBlock = RGB(0, 0, 0);
colors.clrToolDrag = RGB(0, 0, 255);
}
colors.bScaleAxisColor = false;
colors.bScaleGridColor = true;
colors.bScaleGrid10Color = true;
colors.bScaleGrid1024Color = false;
colors.bScaleGridDotColor = true;
colors.clrToolSelection = RGB(255, 255, 0);
colors.clrSelection = RGB(255, 0, 0);
colors.clrToolMorph = RGB(255, 0, 0);
colors.clrToolPath = RGB(255, 0, 0);
colors.clrEntity = RGB(220, 30, 220);
colors.clrModelCollisionWireframe = RGB( 255, 255, 0 );
colors.clrModelCollisionWireframeDisabled = RGB( 220, 30, 220 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : fOverwrite -
//-----------------------------------------------------------------------------
void COptions::Write( BOOL fOverwrite, BOOL fSaveConfigs )
{
APP()->WriteProfileInt("Configured", "Configured", iThisVersion);
int i, iSize;
CString str;
// write texture info - remember, it's stored in general
iSize = textures.nTextureFiles;
APP()->WriteProfileInt(pszGeneral, "TextureFileCount", iSize);
for(i = 0; i < iSize; i++)
{
str.Format("TextureFile%d", i);
APP()->WriteProfileString(pszGeneral, str, textures.TextureFiles[i]);
}
APP()->WriteProfileInt(pszGeneral, "Brightness", int(textures.fBrightness * 10));
// write general
APP()->WriteProfileInt(pszGeneral, "Max Cameras", general.nMaxCameras);
APP()->WriteProfileInt(pszGeneral, "Undo Levels", general.iUndoLevels);
APP()->WriteProfileInt(pszGeneral, "Locking Textures", general.bLockingTextures);
APP()->WriteProfileInt(pszGeneral, "Scale Locking Textures", general.bScaleLockingTextures);
APP()->WriteProfileInt(pszGeneral, "Texture Alignment", general.eTextureAlignment);
APP()->WriteProfileInt(pszGeneral, "Independent Windows", general.bIndependentwin);
APP()->WriteProfileInt(pszGeneral, "Load Default Positions", general.bLoadwinpos);
APP()->WriteProfileInt(pszGeneral, "GroupWhileIgnore", general.bGroupWhileIgnore);
APP()->WriteProfileInt(pszGeneral, "StretchArches", general.bStretchArches);
APP()->WriteProfileInt(pszGeneral, "Show Helpers", general.bShowHelpers);
APP()->WriteProfileInt(pszGeneral, "Visible Map Errors", general.bCheckVisibleMapErrors);
APP()->WriteProfileInt(pszGeneral, "Time Between Saves", general.iTimeBetweenSaves);
APP()->WriteProfileInt(pszGeneral, "Max Autosave Space", general.iMaxAutosaveSpace);
APP()->WriteProfileInt(pszGeneral, "Max Saves Per Map", general.iMaxAutosavesPerMap);
APP()->WriteProfileInt(pszGeneral, "Autosaves Enabled", general.bEnableAutosave);
APP()->WriteProfileInt(pszGeneral, "Closed Correctly", general.bClosedCorrectly);
APP()->WriteProfileString(pszGeneral, "Autosave Dir", general.szAutosaveDir);
APP()->SetDirectory( DIR_AUTOSAVE, general.szAutosaveDir );
APP()->WriteProfileInt(pszGeneral, "VGUI Model Browser", general.bUseVGUIModelBrowser );
APP()->WriteProfileInt(pszGeneral, "Show Hidden Targets As Broken", general.bShowHiddenTargetsAsBroken);
APP()->WriteProfileInt(pszGeneral, "Use Radius Culling", general.bRadiusCulling);
// write view2d
APP()->WriteProfileInt(pszView2D, "Crosshairs", view2d.bCrosshairs);
APP()->WriteProfileInt(pszView2D, "GroupCarve", view2d.bGroupCarve);
APP()->WriteProfileInt(pszView2D, "Scrollbars", view2d.bScrollbars);
APP()->WriteProfileInt(pszView2D, "RotateConstrain", view2d.bRotateConstrain);
APP()->WriteProfileInt(pszView2D, "Draw Vertices", view2d.bDrawVertices);
APP()->WriteProfileInt(pszView2D, "Draw Models", view2d.bDrawModels);
APP()->WriteProfileInt(pszView2D, "Default Grid", view2d.iDefaultGrid);
APP()->WriteProfileInt(pszView2D, "WhiteOnBlack", view2d.bWhiteOnBlack);
APP()->WriteProfileInt(pszView2D, "GridHigh1024", view2d.bGridHigh1024);
APP()->WriteProfileInt(pszView2D, "GridHigh10", view2d.bGridHigh10);
APP()->WriteProfileInt(pszView2D, "GridIntensity", view2d.iGridIntensity);
APP()->WriteProfileInt(pszView2D, "HideSmallGrid", view2d.bHideSmallGrid);
APP()->WriteProfileInt(pszView2D, "Nudge", view2d.bNudge);
APP()->WriteProfileInt(pszView2D, "OrientPrimitives", view2d.bOrientPrimitives);
APP()->WriteProfileInt(pszView2D, "AutoSelect", view2d.bAutoSelect);
APP()->WriteProfileInt(pszView2D, "SelectByHandles", view2d.bSelectbyhandles);
APP()->WriteProfileInt(pszView2D, "GridHighSpec", view2d.iGridHighSpec);
APP()->WriteProfileInt(pszView2D, "KeepCloneGroup", view2d.bKeepclonegroup);
APP()->WriteProfileInt(pszView2D, "Gridhigh64", view2d.bGridHigh64);
APP()->WriteProfileInt(pszView2D, "GridDots", view2d.bGridDots);
APP()->WriteProfileInt(pszView2D, "Centeroncamera", view2d.bCenteroncamera);
APP()->WriteProfileInt(pszView2D, "Usegroupcolors", view2d.bUsegroupcolors);
// write view3d
APP()->WriteProfileInt(pszView3D, "Hardware", view3d.bHardware);
APP()->WriteProfileInt(pszView3D, "Reverse Y", view3d.bReverseY);
APP()->WriteProfileInt(pszView3D, "BackPlane", view3d.iBackPlane);
APP()->WriteProfileInt(pszView3D, "UseMouseLook", view3d.bUseMouseLook);
APP()->WriteProfileInt(pszView3D, "ModelDistance", view3d.nModelDistance);
APP()->WriteProfileInt(pszView3D, "DetailDistance", view3d.nDetailDistance);
APP()->WriteProfileInt(pszView3D, "AnimateModels", view3d.bAnimateModels);
APP()->WriteProfileInt(pszView3D, "ForwardSpeedMax", view3d.nForwardSpeedMax);
APP()->WriteProfileInt(pszView3D, "TimeToMaxSpeed", view3d.nTimeToMaxSpeed);
APP()->WriteProfileInt(pszView3D, "FilterTextures", view3d.bFilterTextures);
APP()->WriteProfileInt(pszView3D, "ReverseSelection", view3d.bReverseSelection);
//
// We don't write custom color settings because there is no GUI for them yet.
//
// Write out the game configurations
if ( fSaveConfigs )
{
configs.SaveGameConfigs();
}
}
void COptions::SetClosedCorrectly(BOOL bClosed)
{
APP()->WriteProfileInt( pszGeneral, "Closed Correctly", bClosed );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void COptions::SetDefaults(void)
{
BOOL bWrite = FALSE;
if (APP()->GetProfileInt("Configured", "Configured", 0) != iThisVersion)
{
bWrite = TRUE;
}
if (APP()->GetProfileInt("Configured", "Installed", 42151) == 42151)
{
APP()->WriteProfileInt("Configured", "Installed", time(NULL));
}
uDaysSinceInstalled = 0;
// textures
textures.nTextureFiles = 1;
textures.TextureFiles.Add("textures.wad");
textures.fBrightness = 1.0;
// general
general.bIndependentwin = FALSE;
general.bLoadwinpos = TRUE;
general.iUndoLevels = 50;
general.nMaxCameras = 100;
general.bGroupWhileIgnore = FALSE;
general.bStretchArches = TRUE;
general.bLockingTextures = TRUE;
general.bScaleLockingTextures = FALSE;
general.bShowHelpers = TRUE;
general.iTimeBetweenSaves = 15;
general.iMaxAutosaveSpace = 100;
general.iMaxAutosavesPerMap = 5;
general.bEnableAutosave = TRUE;
general.bClosedCorrectly = TRUE;
general.bUseVGUIModelBrowser = TRUE;
general.bShowCollisionModels = FALSE;
general.bShowDetailObjects = TRUE;
general.bShowNoDrawBrushes = TRUE;
// view2d
view2d.bCrosshairs = FALSE;
view2d.bGroupCarve = TRUE;
view2d.bScrollbars = TRUE;
view2d.bRotateConstrain = FALSE;
view2d.bDrawVertices = TRUE;
view2d.bDrawModels = TRUE;
view2d.iDefaultGrid = 64;
view2d.bWhiteOnBlack = TRUE;
view2d.bGridHigh1024 = TRUE;
view2d.bGridHigh10 = TRUE;
view2d.iGridIntensity = 30;
view2d.bHideSmallGrid = TRUE;
view2d.bNudge = FALSE;
view2d.bOrientPrimitives = FALSE;
view2d.bAutoSelect = FALSE;
view2d.bSelectbyhandles = FALSE;
view2d.iGridHighSpec = 8;
view2d.bKeepclonegroup = TRUE;
view2d.bGridHigh64 = FALSE;
view2d.bGridDots = FALSE;
view2d.bCenteroncamera = FALSE;
view2d.bUsegroupcolors = TRUE;
// view3d
view3d.bUseMouseLook = TRUE;
view3d.bHardware = FALSE;
view3d.bReverseY = FALSE;
view3d.iBackPlane = 5000;
view3d.nModelDistance = 400;
view3d.nDetailDistance = 1200;
view3d.bAnimateModels = FALSE;
view3d.nForwardSpeedMax = 1000;
view3d.nTimeToMaxSpeed = 500;
view3d.bFilterTextures = TRUE;
view3d.bReverseSelection = FALSE;
view3d.bPreviewModelFade = false;
if ( bWrite )
{
Write( FALSE, FALSE );
}
}
//-----------------------------------------------------------------------------
// Purpose: This is called by the user interface itself when changes are made.
// tells the COptions object to notify the parts of the interface.
// Input : dwOptionsChanged - Flags indicating which options changed.
//-----------------------------------------------------------------------------
void COptions::PerformChanges(DWORD dwOptionsChanged)
{
CMainFrame *pMainWnd = GetMainWnd();
if (dwOptionsChanged & secTextures)
{
if (pMainWnd != NULL)
{
pMainWnd->SetBrightness(textures.fBrightness);
}
}
if (dwOptionsChanged & secView2D)
{
ReadColorSettings();
if (pMainWnd != NULL)
{
pMainWnd->UpdateAllDocViews( MAPVIEW_UPDATE_ONLY_2D | MAPVIEW_OPTIONS_CHANGED | MAPVIEW_RENDER_NOW );
}
}
if (dwOptionsChanged & secView3D)
{
if (pMainWnd != NULL)
{
pMainWnd->UpdateAllDocViews(MAPVIEW_UPDATE_ONLY_3D | MAPVIEW_OPTIONS_CHANGED | MAPVIEW_RENDER_NOW );
}
}
if (dwOptionsChanged & secConfigs)
{
if (pMainWnd != NULL)
{
pMainWnd->GlobalNotify(WM_GAME_CHANGED);
}
}
}