BotoX/hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
7d572a67ef
hl2_src-leak-2017/src/hammer/hammer.cpp

2475 lines
67 KiB
C++
Raw Normal View History

import hl2_src from full.7z source: magnet:?xt=urn:btih:21DDA6847DDE983F2F8063739249D2D1D09A5DDA
2020-12-25 16:26:23 +01:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: The application object.
//
//===========================================================================//
#include "stdafx.h"
#include <io.h>
#include <stdlib.h>
#include <direct.h>
#pragma warning(push, 1)
#pragma warning(disable:4701 4702 4530)
#include <fstream>
#pragma warning(pop)
#include "BuildNum.h"
#include "EditGameConfigs.h"
#include "Splash.h"
#include "Options.h"
#include "custommessages.h"
#include "MainFrm.h"
#include "MessageWnd.h"
#include "ChildFrm.h"
#include "MapDoc.h"
#include "Manifest.h"
#include "MapView3D.h"
#include "MapView2D.h"
#include "PakDoc.h"
#include "PakViewDirec.h"
#include "PakFrame.h"
#include "Prefabs.h"
#include "GlobalFunctions.h"
#include "Shell.h"
#include "ShellMessageWnd.h"
#include "Options.h"
#include "TextureSystem.h"
#include "ToolManager.h"
#include "Hammer.h"
#include "StudioModel.h"
#include "ibsplighting.h"
#include "statusbarids.h"
#include "tier0/icommandline.h"
#include "soundsystem.h"
#include "IHammer.h"
#include "op_entity.h"
#include "tier0/dbg.h"
#include "tier0/minidump.h"
#include "materialsystem/imaterialsystemhardwareconfig.h"
#include "istudiorender.h"
#include "filesystem.h"
#include "engine_launcher_api.h"
#include "filesystem_init.h"
#include "utlmap.h"
#include "progdlg.h"
#include "MapWorld.h"
#include "HammerVGui.h"
#include "vgui_controls/Controls.h"
#include "lpreview_thread.h"
#include "inputsystem/iinputsystem.h"
#include "datacache/idatacache.h"
#include "steam/steam_api.h"
#include "p4lib/ip4.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
//
// Note!
//
// If this DLL is dynamically linked against the MFC
// DLLs, any functions exported from this DLL which
// call into MFC must have the AFX_MANAGE_STATE macro
// added at the very beginning of the function.
//
// For example:
//
// extern "C" BOOL PASCAL EXPORT ExportedFunction()
// {
// AFX_MANAGE_STATE(AfxGetStaticModuleState());
// // normal function body here
// }
//
// It is very important that this macro appear in each
// function, prior to any calls into MFC. This means that
// it must appear as the first statement within the
// function, even before any object variable declarations
// as their constructors may generate calls into the MFC
// DLL.
//
// Please see MFC Technical Notes 33 and 58 for additional
// details.
//
// dvs: hack
extern LPCTSTR GetErrorString(void);
extern void MakePrefabLibrary(LPCTSTR pszName);
void EditorUtil_ConvertPath(CString &str, bool bSave);
static bool bMakeLib = false;
static float fSequenceVersion = 0.2f;
static char *pszSequenceHdr = "Worldcraft Command Sequences\r\n\x1a";
CHammer theApp;
COptions Options;
CShell g_Shell;
CShellMessageWnd g_ShellMessageWnd;
CMessageWnd *g_pwndMessage = NULL;
// IPC structures for lighting preview thread
CMessageQueue<MessageToLPreview> g_HammerToLPreviewMsgQueue;
CMessageQueue<MessageFromLPreview> g_LPreviewToHammerMsgQueue;
ThreadHandle_t g_LPreviewThread;
CSteamAPIContext g_SteamAPIContext;
CSteamAPIContext *steamapicontext = &g_SteamAPIContext;
bool CHammer::m_bIsNewDocumentVisible = true;
//-----------------------------------------------------------------------------
// Expose singleton
//-----------------------------------------------------------------------------
EXPOSE_SINGLE_INTERFACE_GLOBALVAR(CHammer, IHammer, INTERFACEVERSION_HAMMER, theApp);
//-----------------------------------------------------------------------------
// global interfaces
//-----------------------------------------------------------------------------
IBaseFileSystem *g_pFileSystem;
IEngineAPI *g_pEngineAPI;
CreateInterfaceFn g_Factory;
bool g_bHDR = true;
bool IsRunningInEngine()
{
return g_pEngineAPI != NULL;
}
struct MinidumpWrapperHelper_t
{
int (*m_pfn)(void *pParam);
void *m_pParam;
int m_iRetVal;
};
static void MinidumpWrapperHelper( void *arg )
{
MinidumpWrapperHelper_t *info = (MinidumpWrapperHelper_t *)arg;
info->m_iRetVal = info->m_pfn( info->m_pParam );
}
static int WrapFunctionWithMinidumpHandler( int (*pfn)(void *pParam), void *pParam )
{
int nRetVal;
if ( !Plat_IsInDebugSession() && !CommandLine()->FindParm( "-nominidumps") )
{
MinidumpWrapperHelper_t info;
info.m_pfn = pfn;
info.m_pParam = pParam;
info.m_iRetVal = 0;
CatchAndWriteMiniDumpForVoidPtrFn( MinidumpWrapperHelper, &info, true );
nRetVal = info.m_iRetVal;
}
else
{
nRetVal = pfn( pParam );
}
return nRetVal;
}
//-----------------------------------------------------------------------------
// Purpose: Outputs a formatted debug string.
// Input : fmt - format specifier.
// ... - arguments to format.
//-----------------------------------------------------------------------------
void DBG(const char *fmt, ...)
{
char ach[128];
va_list va;
va_start(va, fmt);
vsprintf(ach, fmt, va);
va_end(va);
OutputDebugString(ach);
}
void Msg(int type, const char *fmt, ...)
{
if ( !g_pwndMessage )
return;
va_list vl;
char szBuf[512];
va_start(vl, fmt);
int len = _vsnprintf(szBuf, 512, fmt, vl);
va_end(vl);
if ((type == mwError) || (type == mwWarning))
{
g_pwndMessage->ShowMessageWindow();
}
char temp = 0;
char *pMsg = szBuf;
do
{
if (len >= MESSAGE_WND_MESSAGE_LENGTH)
{
temp = pMsg[MESSAGE_WND_MESSAGE_LENGTH-1];
pMsg[MESSAGE_WND_MESSAGE_LENGTH-1] = '\0';
}
g_pwndMessage->AddMsg((MWMSGTYPE)type, pMsg);
if (len >= MESSAGE_WND_MESSAGE_LENGTH)
{
pMsg[MESSAGE_WND_MESSAGE_LENGTH-1] = temp;
pMsg += MESSAGE_WND_MESSAGE_LENGTH-1;
}
len -= MESSAGE_WND_MESSAGE_LENGTH-1;
} while (len > 0);
}
//-----------------------------------------------------------------------------
// Purpose: this routine calls the default doc template's OpenDocumentFile() but
// with the ability to override the visible flag
// Input : lpszPathName - the document to open
// bMakeVisible - ignored
// Output : returns the opened document if successful
//-----------------------------------------------------------------------------
CDocument *CHammerDocTemplate::OpenDocumentFile( LPCTSTR lpszPathName, BOOL bMakeVisible )
{
CDocument *pDoc = __super::OpenDocumentFile( lpszPathName, CHammer::IsNewDocumentVisible() );
return pDoc;
}
//-----------------------------------------------------------------------------
// Purpose: this function will attempt an orderly shutdown of all maps. It will attempt to
// close only documents that have no references, hopefully freeing up additional documents
// Input : bEndSession - ignored
//-----------------------------------------------------------------------------
void CHammerDocTemplate::CloseAllDocuments( BOOL bEndSession )
{
bool bFound = true;
// rough loop to always remove the first map doc that has no references, then start over, try again.
// if we still have maps with references ( that's bad ), we'll exit out of this loop and just do
// the default shutdown to force them all to close.
while( bFound )
{
bFound = false;
POSITION pos = GetFirstDocPosition();
while( pos != NULL )
{
CDocument *pDoc = GetNextDoc( pos );
CMapDoc *pMapDoc = dynamic_cast< CMapDoc * >( pDoc );
if ( pMapDoc && pMapDoc->GetReferenceCount() == 0 )
{
pDoc->OnCloseDocument();
bFound = true;
break;
}
}
}
#if 0
POSITION pos = GetFirstDocPosition();
while( pos != NULL )
{
CDocument *pDoc = GetNextDoc( pos );
CMapDoc *pMapDoc = dynamic_cast< CMapDoc * >( pDoc );
if ( pMapDoc )
{
pMapDoc->ForceNoReference();
}
}
__super::CloseAllDocuments( bEndSession );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: This function will allow hammer to control the initial visibility of an opening document
// Input : pFrame - the new document's frame
// pDoc - the new document
// bMakeVisible - ignored as a parameter
//-----------------------------------------------------------------------------
void CHammerDocTemplate::InitialUpdateFrame( CFrameWnd* pFrame, CDocument* pDoc, BOOL bMakeVisible )
{
bMakeVisible = CHammer::IsNewDocumentVisible();
__super::InitialUpdateFrame( pFrame, pDoc, bMakeVisible );
if ( bMakeVisible )
{
CMapDoc *pMapDoc = dynamic_cast< CMapDoc * >( pDoc );
if ( pMapDoc )
{
pMapDoc->SetInitialUpdate();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: this function will let all other maps know that an instanced map has been updated ( usually for volume size )
// Input : pInstanceMapDoc - the document that has been updated
//-----------------------------------------------------------------------------
void CHammerDocTemplate::UpdateInstanceMap( CMapDoc *pInstanceMapDoc )
{
POSITION pos = GetFirstDocPosition();
while( pos != NULL )
{
CDocument *pDoc = GetNextDoc( pos );
CMapDoc *pMapDoc = dynamic_cast< CMapDoc * >( pDoc );
if ( pMapDoc && pMapDoc != pInstanceMapDoc )
{
pMapDoc->UpdateInstanceMap( pInstanceMapDoc );
}
}
}
class CHammerCmdLine : public CCommandLineInfo
{
public:
CHammerCmdLine(void)
{
m_bShowLogo = true;
m_bGame = false;
m_bConfigDir = false;
}
void ParseParam(LPCTSTR lpszParam, BOOL bFlag, BOOL bLast)
{
if ((!m_bGame) && (bFlag && !stricmp(lpszParam, "game")))
{
m_bGame = true;
}
else if (m_bGame)
{
if (!bFlag)
{
m_strGame = lpszParam;
}
m_bGame = false;
}
else if (bFlag && !strcmpi(lpszParam, "nologo"))
{
m_bShowLogo = false;
}
else if (bFlag && !strcmpi(lpszParam, "makelib"))
{
bMakeLib = TRUE;
}
else if (!bFlag && bMakeLib)
{
MakePrefabLibrary(lpszParam);
}
else if ((!m_bConfigDir) && (bFlag && !stricmp(lpszParam, "configdir")))
{
m_bConfigDir = true;
}
else if (m_bConfigDir)
{
if ( !bFlag )
{
Options.configs.m_strConfigDir = lpszParam;
}
m_bConfigDir = false;
}
else
{
CCommandLineInfo::ParseParam(lpszParam, bFlag, bLast);
}
}
bool m_bShowLogo;
bool m_bGame; // Used to find and parse the "-game blah" parameter pair.
bool m_bConfigDir; // Used to find and parse the "-configdir blah" parameter pair.
CString m_strGame; // The name of the game to use for this session, ie "hl2" or "cstrike". This should match the mod dir, not the config name.
};
BEGIN_MESSAGE_MAP(CHammer, CWinApp)
//{{AFX_MSG_MAP(CHammer)
ON_COMMAND(ID_APP_ABOUT, OnAppAbout)
ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
ON_COMMAND(ID_FILE_NEW, OnFileNew)
ON_COMMAND(ID_FILE_OPEN, CWinApp::OnFileOpen)
ON_COMMAND(ID_FILE_PRINT_SETUP, CWinApp::OnFilePrintSetup)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
//-----------------------------------------------------------------------------
// Purpose: Constructor. Initializes member variables and creates a scratch
// buffer for use when loading WAD files.
//-----------------------------------------------------------------------------
CHammer::CHammer(void)
{
m_bActiveApp = true;
m_SuppressVideoAllocation = false;
m_bForceRenderNextFrame = false;
m_bClosing = false;
}
//-----------------------------------------------------------------------------
// Purpose: Destructor. Frees scratch buffer used when loading WAD files.
// Deletes all command sequences used when compiling maps.
//-----------------------------------------------------------------------------
CHammer::~CHammer(void)
{
}
//-----------------------------------------------------------------------------
// Inherited from IAppSystem
//-----------------------------------------------------------------------------
bool CHammer::Connect( CreateInterfaceFn factory )
{
if ( !BaseClass::Connect( factory ) )
return false;
// bool bCVarOk = ConnectStudioRenderCVars( factory );
g_pFileSystem = ( IBaseFileSystem * )factory( BASEFILESYSTEM_INTERFACE_VERSION, NULL );
g_pStudioRender = ( IStudioRender * )factory( STUDIO_RENDER_INTERFACE_VERSION, NULL );
g_pEngineAPI = ( IEngineAPI * )factory( VENGINE_LAUNCHER_API_VERSION, NULL );
g_pMDLCache = (IMDLCache*)factory( MDLCACHE_INTERFACE_VERSION, NULL );
p4 = ( IP4 * )factory( P4_INTERFACE_VERSION, NULL );
g_Factory = factory;
if ( !g_pMDLCache || !g_pFileSystem || !g_pFullFileSystem || !materials || !g_pMaterialSystemHardwareConfig || !g_pStudioRender )
return false;
// ensure we're in the same directory as the .EXE
char *p;
GetModuleFileName(NULL, m_szAppDir, MAX_PATH);
p = strrchr(m_szAppDir, '\\');
if(p)
{
// chop off \wc.exe
p[0] = 0;
}
if ( IsRunningInEngine() )
{
strcat( m_szAppDir, "\\bin" );
}
// Create the message window object for capturing errors and warnings.
// This does NOT create the window itself. That happens later in CMainFrame::Create.
g_pwndMessage = CMessageWnd::CreateMessageWndObject();
// Default location for GameConfig.txt is the same directory as Hammer.exe but this may be overridden on the command line
char szGameConfigDir[MAX_PATH];
APP()->GetDirectory( DIR_PROGRAM, szGameConfigDir );
Options.configs.m_strConfigDir = szGameConfigDir;
CHammerCmdLine cmdInfo;
ParseCommandLine(cmdInfo);
// Set up SteamApp() interface (for checking app ownership)
SteamAPI_InitSafe();
SteamAPI_SetTryCatchCallbacks( false ); // We don't use exceptions, so tell steam not to use try/catch in callback handlers
g_SteamAPIContext.Init();
// Load the options
// NOTE: Have to do this now, because we need it before Inits() are called
// NOTE: SetRegistryKey will cause hammer to look into the registry for its values
SetRegistryKey("Valve");
Options.Init();
return true;
}
void CHammer::Disconnect()
{
g_pStudioRender = NULL;
g_pFileSystem = NULL;
g_pEngineAPI = NULL;
g_pMDLCache = NULL;
BaseClass::Disconnect();
}
void *CHammer::QueryInterface( const char *pInterfaceName )
{
// We also implement the IMatSystemSurface interface
if (!Q_strncmp( pInterfaceName, INTERFACEVERSION_HAMMER, Q_strlen(INTERFACEVERSION_HAMMER) + 1))
return (IHammer*)this;
return NULL;
}
//-----------------------------------------------------------------------------
// Methods related to message pumping
//-----------------------------------------------------------------------------
bool CHammer::HammerPreTranslateMessage(MSG * pMsg)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
// Copy this into the current message, needed for MFC
#if _MSC_VER >= 1300
_AFX_THREAD_STATE* pState = AfxGetThreadState();
pState->m_msgCur = *pMsg;
#else
m_msgCur = *pMsg;
#endif
return (/*pMsg->message == WM_KICKIDLE ||*/ PreTranslateMessage(pMsg) != FALSE);
}
bool CHammer::HammerIsIdleMessage(MSG * pMsg)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
return IsIdleMessage(pMsg) != FALSE;
}
// return TRUE if more idle processing
bool CHammer::HammerOnIdle(long count)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
return OnIdle(count) != FALSE;
}
//-----------------------------------------------------------------------------
// Purpose: Adds a backslash to the end of a string if there isn't one already.
// Input : psz - String to add the backslash to.
//-----------------------------------------------------------------------------
static void EnsureTrailingBackslash(char *psz)
{
if ((psz[0] != '\0') && (psz[strlen(psz) - 1] != '\\'))
{
strcat(psz, "\\");
}
}
//-----------------------------------------------------------------------------
// Purpose: Tweaks our data members to enable us to import old Hammer settings
// from the registry.
//-----------------------------------------------------------------------------
static const char *s_pszOldAppName = NULL;
void CHammer::BeginImportWCSettings(void)
{
s_pszOldAppName = m_pszAppName;
m_pszAppName = "Worldcraft";
SetRegistryKey("Valve");
}
//-----------------------------------------------------------------------------
// Purpose: Tweaks our data members to enable us to import old Valve Hammer Editor
// settings from the registry.
//-----------------------------------------------------------------------------
void CHammer::BeginImportVHESettings(void)
{
s_pszOldAppName = m_pszAppName;
m_pszAppName = "Valve Hammer Editor";
SetRegistryKey("Valve");
}
//-----------------------------------------------------------------------------
// Purpose: Restores our tweaked data members to their original state.
//-----------------------------------------------------------------------------
void CHammer::EndImportSettings(void)
{
m_pszAppName = s_pszOldAppName;
SetRegistryKey("Valve");
}
//-----------------------------------------------------------------------------
// Purpose: Retrieves various important directories.
// Input : dir - Enumerated directory to retrieve.
// p - Pointer to buffer that receives the full path to the directory.
//-----------------------------------------------------------------------------
void CHammer::GetDirectory(DirIndex_t dir, char *p)
{
switch (dir)
{
case DIR_PROGRAM:
{
strcpy(p, m_szAppDir);
EnsureTrailingBackslash(p);
break;
}
case DIR_PREFABS:
{
strcpy(p, m_szAppDir);
EnsureTrailingBackslash(p);
strcat(p, "Prefabs");
//
// Make sure the prefabs directory exists.
//
if ((_access( p, 0 )) == -1)
{
CreateDirectory(p, NULL);
}
break;
}
//
// Get the game directory with a trailing backslash. This is
// where the base game's resources are, such as "C:\Half-Life\valve\".
//
case DIR_GAME_EXE:
{
strcpy(p, g_pGameConfig->m_szGameExeDir);
EnsureTrailingBackslash(p);
break;
}
//
// Get the mod directory with a trailing backslash. This is where
// the mod's resources are, such as "C:\Half-Life\tfc\".
//
case DIR_MOD:
{
strcpy(p, g_pGameConfig->m_szModDir);
EnsureTrailingBackslash(p);
break;
}
//
// Get the materials directory with a trailing backslash. This is where
// the mod's materials are, such as "C:\Half-Life\tfc\materials".
//
case DIR_MATERIALS:
{
strcpy(p, g_pGameConfig->m_szModDir);
EnsureTrailingBackslash(p);
Q_strcat(p, "materials\\", MAX_PATH);
break;
}
case DIR_AUTOSAVE:
{
strcpy( p, m_szAutosaveDir );
EnsureTrailingBackslash(p);
break;
}
}
}
void CHammer::SetDirectory(DirIndex_t dir, const char *p)
{
switch(dir)
{
case DIR_AUTOSAVE:
{
strcpy( m_szAutosaveDir, p );
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns a color from the application configuration storage.
//-----------------------------------------------------------------------------
COLORREF CHammer::GetProfileColor(const char *pszSection, const char *pszKey, int r, int g, int b)
{
int newR, newG, newB;
CString strDefault;
CString strReturn;
char szBuff[128];
sprintf(szBuff, "%i %i %i", r, g, b);
strDefault = szBuff;
strReturn = GetProfileString(pszSection, pszKey, strDefault);
if (strReturn.IsEmpty())
return 0;
// Parse out colors.
char *pStart;
char *pCurrent;
pStart = szBuff;
pCurrent = pStart;
strcpy( szBuff, (char *)(LPCSTR)strReturn );
while (*pCurrent && *pCurrent != ' ')
pCurrent++;
*pCurrent++ = 0;
newR = atoi(pStart);
pStart = pCurrent;
while (*pCurrent && *pCurrent != ' ')
pCurrent++;
*pCurrent++ = 0;
newG = atoi(pStart);
pStart = pCurrent;
while (*pCurrent)
pCurrent++;
*pCurrent++ = 0;
newB = atoi(pStart);
return COLORREF(RGB(newR, newG, newB));
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pszURL -
//-----------------------------------------------------------------------------
void CHammer::OpenURL(const char *pszURL, HWND hwnd)
{
if (HINSTANCE(32) > ::ShellExecute(hwnd, "open", pszURL, NULL, NULL, 0))
{
AfxMessageBox("The website couldn't be opened.");
}
}
//-----------------------------------------------------------------------------
// Purpose: Opens a URL in the default web browser by string ID.
//-----------------------------------------------------------------------------
void CHammer::OpenURL(UINT nID, HWND hwnd)
{
CString str;
str.LoadString(nID);
OpenURL(str, hwnd);
}
//-----------------------------------------------------------------------------
// Purpose: Launches the help system for the specified help topic.
// Input : pszTopic - Topic to open.
//-----------------------------------------------------------------------------
void CHammer::Help(const char *pszTopic)
{
//
// Get the directory that the help file should be in (our program directory).
//
/*char szHelpDir[MAX_PATH];
GetDirectory(DIR_PROGRAM, szHelpDir);
//
// Find the application that is associated with compiled HTML files.
//
char szHelpExe[MAX_PATH];
HINSTANCE hResult = FindExecutable("wc.chm", szHelpDir, szHelpExe);
if (hResult > (HINSTANCE)32)
{
//
// Build the full topic with which to launch the help application.
//
char szParam[2 * MAX_PATH];
strcpy(szParam, szHelpDir);
strcat(szParam, "wc.chm");
if (pszTopic != NULL)
{
strcat(szParam, "::/");
strcat(szParam, pszTopic);
}
//
// Launch the help application for the given topic.
//
hResult = ShellExecute(NULL, "open", szHelpExe, szParam, szHelpDir, SW_SHOW);
}
if (hResult <= (HINSTANCE)32)
{
char szError[MAX_PATH];
sprintf(szError, "The help system could not be launched. The the following error was returned:\n%s (0x%X)", GetErrorString(), hResult);
AfxMessageBox(szError);
}
*/
}
static SpewRetval_t HammerDbgOutput( SpewType_t spewType, char const *pMsg )
{
// FIXME: The messages we're getting from the material system
// are ones that we really don't care much about.
// I'm disabling this for now, we need to decide about what to do with this
switch( spewType )
{
case SPEW_ERROR:
MessageBox( NULL, (LPCTSTR)pMsg, "Fatal Error", MB_OK | MB_ICONINFORMATION );
#ifdef _DEBUG
return SPEW_DEBUGGER;
#else
TerminateProcess( GetCurrentProcess(), 1 );
return SPEW_ABORT;
#endif
default:
OutputDebugString( pMsg );
return (spewType == SPEW_ASSERT) ? SPEW_DEBUGGER : SPEW_CONTINUE;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static HANDLE dwChangeHandle = NULL;
void UpdatePrefabs_Init()
{
// Watch the prefabs tree for file or directory creation
// and deletion.
if (dwChangeHandle == NULL)
{
char szPrefabDir[MAX_PATH];
APP()->GetDirectory(DIR_PREFABS, szPrefabDir);
dwChangeHandle = FindFirstChangeNotification(
szPrefabDir, // directory to watch
TRUE, // watch the subtree
FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_FILE_NAME); // watch file and dir name changes
if (dwChangeHandle == INVALID_HANDLE_VALUE)
{
ExitProcess(GetLastError());
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void UpdatePrefabs()
{
// Wait for notification.
DWORD dwWaitStatus = WaitForSingleObject(dwChangeHandle, 0);
if (dwWaitStatus == WAIT_OBJECT_0)
{
// A file was created or deleted in the prefabs tree.
// Refresh the prefabs and restart the change notification.
CPrefabLibrary::FreeAllLibraries();
CPrefabLibrary::LoadAllLibraries();
GetMainWnd()->m_ObjectBar.UpdateListForTool(ToolManager()->GetActiveToolID());
if (FindNextChangeNotification(dwChangeHandle) == FALSE)
{
ExitProcess(GetLastError());
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void UpdatePrefabs_Shutdown()
{
FindCloseChangeNotification(dwChangeHandle);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
BOOL CHammer::InitInstance()
{
return TRUE;
}
//-----------------------------------------------------------------------------
// Purpose: Prompt the user to select a game configuration.
//-----------------------------------------------------------------------------
CGameConfig *CHammer::PromptForGameConfig()
{
CEditGameConfigs dlg(TRUE, GetMainWnd());
if (dlg.DoModal() != IDOK)
{
return NULL;
}
return dlg.GetSelectedGame();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CHammer::InitSessionGameConfig(const char *szGame)
{
CGameConfig *pConfig = NULL;
bool bManualChoice = false;
if ( CommandLine()->FindParm( "-chooseconfig" ) )
{
pConfig = PromptForGameConfig();
bManualChoice = true;
}
if (!bManualChoice)
{
if (szGame && szGame[0] != '\0')
{
// They passed in -game on the command line, use that.
pConfig = Options.configs.FindConfigForGame(szGame);
if (!pConfig)
{
Msg(mwError, "Invalid game \"%s\" specified on the command-line, ignoring.", szGame);
}
}
else
{
// No -game on the command line, try using VPROJECT.
const char *pszGameDir = getenv("vproject");
if ( pszGameDir )
{
pConfig = Options.configs.FindConfigForGame(pszGameDir);
if (!pConfig)
{
Msg(mwError, "Invalid game \"%s\" found in VPROJECT environment variable, ignoring.", pszGameDir);
}
}
}
}
if (pConfig == NULL)
{
// Nothing useful was passed in or found in VPROJECT.
// If there's only one config, use that.
if (Options.configs.GetGameConfigCount() == 1)
{
pConfig = Options.configs.GetGameConfig(0);
}
else
{
// Otherwise, prompt for a config to use.
pConfig = PromptForGameConfig();
}
}
if (pConfig)
{
CGameConfig::SetActiveGame(pConfig);
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Check for 16-bit color or higher.
//-----------------------------------------------------------------------------
bool CHammer::Check16BitColor()
{
// Check for 15-bit color or higher.
HDC hDC = ::CreateCompatibleDC(NULL);
if (hDC)
{
int bpp = GetDeviceCaps(hDC, BITSPIXEL);
if (bpp < 15)
{
AfxMessageBox("Your screen must be in 16-bit color or higher to run Hammer.");
return false;
}
::DeleteDC(hDC);
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if Hammer is in the process of shutting down.
//-----------------------------------------------------------------------------
InitReturnVal_t CHammer::Init()
{
return (InitReturnVal_t)WrapFunctionWithMinidumpHandler( &CHammer::StaticHammerInternalInit, this );
}
int CHammer::StaticHammerInternalInit( void *pParam )
{
return (int)((CHammer*)pParam)->HammerInternalInit();
}
InitReturnVal_t CHammer::HammerInternalInit()
{
SpewOutputFunc( HammerDbgOutput );
MathLib_Init( 2.2f, 2.2f, 0.0f, 2.0f, false, false, false, false );
InitReturnVal_t nRetVal = BaseClass::Init();
if ( nRetVal != INIT_OK )
return nRetVal;
if ( !Check16BitColor() )
return INIT_FAILED;
//
// Create a custom window class for this application so that engine's
// FindWindow will find us.
//
WNDCLASS wndcls;
memset(&wndcls, 0, sizeof(WNDCLASS));
wndcls.style = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
wndcls.lpfnWndProc = AfxWndProc;
wndcls.hInstance = AfxGetInstanceHandle();
wndcls.hIcon = LoadIcon(IDR_MAINFRAME);
wndcls.hCursor = LoadCursor( IDC_ARROW );
wndcls.hbrBackground = (HBRUSH)0; // (COLOR_WINDOW + 1);
wndcls.lpszMenuName = "IDR_MAINFRAME";
wndcls.cbWndExtra = 0;
// HL Shell class name
wndcls.lpszClassName = "VALVEWORLDCRAFT";
// Register it, exit if it fails
if(!AfxRegisterClass(&wndcls))
{
AfxMessageBox("Could not register Hammer's main window class");
return INIT_FAILED;
}
srand(time(NULL));
WriteProfileString("General", "Directory", m_szAppDir);
//
// Create a window to receive shell commands from the engine, and attach it
// to our shell processor.
//
g_ShellMessageWnd.Create();
g_ShellMessageWnd.SetShell(&g_Shell);
if (bMakeLib)
return INIT_FAILED; // made library .. don't want to enter program
CHammerCmdLine cmdInfo;
ParseCommandLine(cmdInfo);
//
// Create and optionally display the splash screen.
//
CSplashWnd::EnableSplashScreen(cmdInfo.m_bShowLogo);
LoadSequences(); // load cmd sequences - different from options because
// users might want to share (darn registry)
// other init:
randomize();
/*
#ifdef _AFXDLL
Enable3dControls(); // Call this when using MFC in a shared DLL
#else
Enable3dControlsStatic(); // Call this when linking to MFC statically
#endif
*/
LoadStdProfileSettings(); // Load standard INI file options (including MRU)
// Register the application's document templates. Document templates
// serve as the connection between documents, frame windows and views.
pMapDocTemplate = new CHammerDocTemplate(
IDR_MAPDOC,
RUNTIME_CLASS(CMapDoc),
RUNTIME_CLASS(CChildFrame), // custom MDI child frame
RUNTIME_CLASS(CMapView2D));
AddDocTemplate(pMapDocTemplate);
pManifestDocTemplate = new CHammerDocTemplate(
IDR_MANIFESTDOC,
RUNTIME_CLASS(CManifest),
RUNTIME_CLASS(CChildFrame), // custom MDI child frame
RUNTIME_CLASS(CMapView2D));
HINSTANCE hInst = AfxFindResourceHandle( MAKEINTRESOURCE( IDR_MAPDOC ), RT_MENU );
pManifestDocTemplate->m_hMenuShared = ::LoadMenu( hInst, MAKEINTRESOURCE( IDR_MAPDOC ) );
hInst = AfxFindResourceHandle( MAKEINTRESOURCE( IDR_MAPDOC ), RT_ACCELERATOR );
pManifestDocTemplate->m_hAccelTable = ::LoadAccelerators( hInst, MAKEINTRESOURCE( IDR_MAPDOC ) );
AddDocTemplate(pManifestDocTemplate);
// register shell file types
RegisterShellFileTypes();
//
// Initialize the rich edit control so we can use it in the entity help dialog.
//
AfxInitRichEdit();
//
// Create main MDI Frame window. Must be done AFTER registering the multidoc template!
//
CMainFrame *pMainFrame = new CMainFrame;
if (!pMainFrame->LoadFrame(IDR_MAINFRAME))
return INIT_FAILED;
m_pMainWnd = pMainFrame;
CSplashWnd::ShowSplashScreen(pMainFrame);
// try to init VGUI
HammerVGui()->Init( m_pMainWnd->GetSafeHwnd() );
// The main window has been initialized, so show and update it.
//
m_nCmdShow = SW_SHOWMAXIMIZED;
pMainFrame->ShowWindow(m_nCmdShow);
pMainFrame->UpdateWindow();
// Now that we've initialized the file system, we can parse this config's gameinfo.txt for the additional settings there.
g_pGameConfig->ParseGameInfo();
materials->ModInit();
//
// Initialize the texture manager and load all textures.
//
if (!g_Textures.Initialize(m_pMainWnd->m_hWnd))
{
Msg(mwError, "Failed to initialize texture system.");
}
else
{
//
// Initialize studio model rendering (must happen after g_Textures.Initialize since
// g_Textures.Initialize kickstarts the material system and sets up g_MaterialSystemClientFactory)
//
StudioModel::Initialize();
g_Textures.LoadAllGraphicsFiles();
g_Textures.SetActiveConfig(g_pGameConfig);
}
// Watch for changes to models.
InitStudioFileChangeWatcher();
LoadFileSystemDialogModule();
// Load detail object descriptions.
char szGameDir[_MAX_PATH];
APP()->GetDirectory(DIR_MOD, szGameDir);
DetailObjects::LoadEmitDetailObjectDictionary( szGameDir );
// Initialize the sound system
g_Sounds.Initialize();
UpdatePrefabs_Init();
// Indicate that we are ready to use.
m_pMainWnd->FlashWindow(TRUE);
// Parse command line for standard shell commands, DDE, file open
if ( !IsRunningInEngine() )
{
if ( Q_stristr( cmdInfo.m_strFileName, ".vmf" ) )
{
// we don't want to make a new file (default behavior if no file
// is specified on the commandline.)
// Dispatch commands specified on the command line
if (!ProcessShellCommand(cmdInfo))
return INIT_FAILED;
}
}
if ( Options.general.bClosedCorrectly == FALSE )
{
CString strLastGoodSave = APP()->GetProfileString("General", "Last Good Save", "");
if ( strLastGoodSave.GetLength() != 0 )
{
char msg[1024];
V_snprintf( msg, sizeof( msg ), "Hammer did not shut down correctly the last time it was used.\nWould you like to load the last saved file?\n(%s)", (const char*)strLastGoodSave );
if ( AfxMessageBox( msg, MB_YESNO ) == IDYES )
{
LoadLastGoodSave();
}
}
}
#ifdef VPROF_HAMMER
g_VProfCurrentProfile.Start();
#endif
CSplashWnd::HideSplashScreen();
// create the lighting preview thread
g_LPreviewThread = CreateSimpleThread( LightingPreviewThreadFN, 0 );
return INIT_OK;
}
int CHammer::MainLoop()
{
return WrapFunctionWithMinidumpHandler( StaticInternalMainLoop, this );
}
int CHammer::StaticInternalMainLoop( void *pParam )
{
return ((CHammer*)pParam)->InternalMainLoop();
}
int CHammer::InternalMainLoop()
{
MSG msg;
g_pDataCache->SetSize( 128 * 1024 * 1024 );
// For tracking the idle time state
bool bIdle = true;
long lIdleCount = 0;
// We've got our own message pump here
g_pInputSystem->EnableMessagePump( false );
// Acquire and dispatch messages until a WM_QUIT message is received.
for (;;)
{
RunFrame();
if ( bIdle && !HammerOnIdle(lIdleCount++) )
{
bIdle = false;
}
//
// Pump messages until the message queue is empty.
//
while (::PeekMessage(&msg, NULL, NULL, NULL, PM_REMOVE))
{
if ( msg.message == WM_QUIT )
return 1;
if ( !HammerPreTranslateMessage(&msg) )
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
// Reset idle state after pumping idle message.
if ( HammerIsIdleMessage(&msg) )
{
bIdle = true;
lIdleCount = 0;
}
}
}
Assert(0); // not reachable
}
//-----------------------------------------------------------------------------
// Shuts down hammer
//-----------------------------------------------------------------------------
void CHammer::Shutdown()
{
if ( g_LPreviewThread )
{
MessageToLPreview StopMsg( LPREVIEW_MSG_EXIT );
g_HammerToLPreviewMsgQueue.QueueMessage( StopMsg );
ThreadJoin( g_LPreviewThread );
g_LPreviewThread = 0;
}
#ifdef VPROF_HAMMER
g_VProfCurrentProfile.Stop();
#endif
// PrintBudgetGroupTimes_Recursive( g_VProfCurrentProfile.GetRoot() );
HammerVGui()->Shutdown();
UnloadFileSystemDialogModule();
// Delete the command sequences.
int nSequenceCount = m_CmdSequences.GetSize();
for (int i = 0; i < nSequenceCount; i++)
{
CCommandSequence *pSeq = m_CmdSequences[i];
if ( pSeq != NULL )
{
delete pSeq;
m_CmdSequences[i] = NULL;
}
}
g_Textures.ShutDown();
// Shutdown the sound system
g_Sounds.ShutDown();
materials->ModShutdown();
BaseClass::Shutdown();
}
//-----------------------------------------------------------------------------
// Methods used by the engine
//-----------------------------------------------------------------------------
const char *CHammer::GetDefaultMod()
{
return g_pGameConfig->GetMod();
}
const char *CHammer::GetDefaultGame()
{
return g_pGameConfig->GetGame();
}
const char *CHammer::GetDefaultModFullPath()
{
return g_pGameConfig->m_szModDir;
}
//-----------------------------------------------------------------------------
// Pops up the options dialog
//-----------------------------------------------------------------------------
RequestRetval_t CHammer::RequestNewConfig()
{
if ( !Options.RunConfigurationDialog() )
return REQUEST_QUIT;
return REQUEST_OK;
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if Hammer is in the process of shutting down.
//-----------------------------------------------------------------------------
bool CHammer::IsClosing()
{
return m_bClosing;
}
//-----------------------------------------------------------------------------
// Purpose: Signals the beginning of app shutdown. Should be called before
// rendering views.
//-----------------------------------------------------------------------------
void CHammer::BeginClosing()
{
m_bClosing = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CHammer::ExitInstance()
{
g_ShellMessageWnd.DestroyWindow();
UpdatePrefabs_Shutdown();
if ( GetSpewOutputFunc() == HammerDbgOutput )
{
SpewOutputFunc( NULL );
}
SaveStdProfileSettings();
return CWinApp::ExitInstance();
}
//-----------------------------------------------------------------------------
// Purpose: this function sets the global flag indicating if new documents should
// be visible.
// Input : bIsVisible - flag to indicate visibility status.
//-----------------------------------------------------------------------------
void CHammer::SetIsNewDocumentVisible( bool bIsVisible )
{
CHammer::m_bIsNewDocumentVisible = bIsVisible;
}
//-----------------------------------------------------------------------------
// Purpose: this functionr eturns the global flag indicating if new documents should
// be visible.
//-----------------------------------------------------------------------------
bool CHammer::IsNewDocumentVisible( void )
{
return CHammer::m_bIsNewDocumentVisible;
}
/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About
class CAboutDlg : public CDialog
{
public:
CAboutDlg();
// Dialog Data
//{{AFX_DATA(CAboutDlg)
enum { IDD = IDD_ABOUTBOX };
CStatic m_cRedHerring;
CButton m_Order;
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CAboutDlg)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
//{{AFX_MSG(CAboutDlg)
afx_msg void OnOrder();
virtual BOOL OnInitDialog();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
//{{AFX_DATA_INIT(CAboutDlg)
//}}AFX_DATA_INIT
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pDX -
//-----------------------------------------------------------------------------
void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAboutDlg)
DDX_Control(pDX, IDC_REDHERRING, m_cRedHerring);
DDX_Control(pDX, IDC_ORDER, m_Order);
//}}AFX_DATA_MAP
}
#include <process.h>
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAboutDlg::OnOrder()
{
char szBuf[MAX_PATH];
GetWindowsDirectory(szBuf, MAX_PATH);
strcat(szBuf, "\\notepad.exe");
_spawnl(_P_NOWAIT, szBuf, szBuf, "order.txt", NULL);
}
#define DEMO_VERSION 0
// 1, 4, 8, 17, 0, 0 // Encodes "Valve"
#if DEMO_VERSION
char gVersion[] = {
#if DEMO_VERSION==1
7, 38, 68, 32, 4, 77, 12, 1, 0 // Encodes "PC Gamer Demo"
#elif DEMO_VERSION==2
7, 38, 68, 32, 4, 77, 12, 0, 0 // Encodes "PC Games Demo"
#elif DEMO_VERSION==3
20, 10, 9, 23, 16, 84, 12, 1, 0, 38, 65, 25, 6, 1, 11, 119, 50, 11, 21, 9, 68, 0 // Encodes "Computer Gaming World Demo"
#elif DEMO_VERSION==4
25, 0, 28, 19, 72, 103, 12, 29, 69, 19, 65, 0, 6, 0, 2, 0 // Encodes "Next-Generation Demo"
#elif DEMO_VERSION==5
20, 10, 9, 23, 16, 84, 12, 1, 0, 38, 65, 25, 10, 79, 41, 57, 17, 1, 21, 17, 65, 0, 29, 77, 4, 78, 0, 0 // Encodes "Computer Game Entertainment"
#elif DEMO_VERSION==6
20, 10, 9, 23, 16, 84, 12, 1, 0, 0, 78, 16, 79, 33, 9, 35, 69, 52, 11, 4, 89, 12, 1, 0 // Encodes "Computer and Net Player"
#elif DEMO_VERSION==7
50, 72, 52, 43, 36, 121, 0 // Encodes "e-PLAY"
#elif DEMO_VERSION==8
4, 17, 22, 6, 17, 69, 14, 10, 0, 49, 76, 1, 28, 0 // Encodes "Strategy Plus"
#elif DEMO_VERSION==9
7, 38, 68, 42, 4, 71, 8, 9, 73, 15, 69, 0 // Encodes "PC Magazine"
#elif DEMO_VERSION==10
5, 10, 8, 11, 12, 78, 14, 83, 115, 21, 79, 26, 10, 0 // Encodes "Rolling Stone"
#elif DEMO_VERSION==11
16, 4, 9, 2, 22, 80, 6, 7, 0 // Encodes "Gamespot"
#endif
};
static char gKey[] = "Wedge is a tool"; // Decrypt key
// XOR a string with a key
void Encode( char *pstring, char *pkey, int strLen )
{
int i, len;
len = strlen( pkey );
for ( i = 0; i < strLen; i++ )
pstring[i] ^= pkey[ i % len ];
}
#endif // DEMO_VERSION
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns TRUE on success, FALSE on failure.
//-----------------------------------------------------------------------------
BOOL CAboutDlg::OnInitDialog(void)
{
CDialog::OnInitDialog();
m_Order.SetRedraw(FALSE);
#if DEMO_VERSION
static BOOL bFirst = TRUE;
if(bFirst)
{
Encode(gVersion, gKey, sizeof(gVersion)-1);
bFirst = FALSE;
}
CString str;
str.Format("%s Demo", gVersion);
m_cRedHerring.SetWindowText(str);
#endif // DEMO_VERSION
//
// Display the build number.
//
CWnd *pWnd = GetDlgItem(IDC_BUILD_NUMBER);
if (pWnd != NULL)
{
char szTemp1[MAX_PATH];
char szTemp2[MAX_PATH];
int nBuild = build_number();
pWnd->GetWindowText(szTemp1, sizeof(szTemp1));
sprintf(szTemp2, szTemp1, nBuild);
pWnd->SetWindowText(szTemp2);
}
//
// For SDK builds, append "SDK" to the version number.
//
#ifdef SDK_BUILD
char szTemp[MAX_PATH];
GetWindowText(szTemp, sizeof(szTemp));
strcat(szTemp, " SDK");
SetWindowText(szTemp);
#endif // SDK_BUILD
return TRUE;
}
BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
//{{AFX_MSG_MAP(CAboutDlg)
ON_BN_CLICKED(IDC_ORDER, OnOrder)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHammer::OnAppAbout(void)
{
CAboutDlg aboutDlg;
aboutDlg.DoModal();
#ifdef VPROF_HAMMER
g_VProfCurrentProfile.OutputReport();
g_VProfCurrentProfile.Reset();
g_pMemAlloc->DumpStats();
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHammer::OnFileNew(void)
{
pMapDocTemplate->OpenDocumentFile(NULL);
if(Options.general.bLoadwinpos && Options.general.bIndependentwin)
{
::GetMainWnd()->LoadWindowStates();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHammer::OnFileOpen(void)
{
static char szInitialDir[MAX_PATH] = "";
if (szInitialDir[0] == '\0')
{
strcpy(szInitialDir, g_pGameConfig->szMapDir);
}
// TODO: need to prevent (or handle) opening VMF files when using old map file formats
CFileDialog dlg(TRUE, NULL, NULL, OFN_LONGNAMES | OFN_HIDEREADONLY | OFN_NOCHANGEDIR, "Valve Map Files (*.vmf;*.vmm)|*.vmf;*.vmm|Valve Map Files Autosave (*.vmf_autosave)|*.vmf_autosave|Worldcraft RMFs (*.rmf)|*.rmf|Worldcraft Maps (*.map)|*.map||");
dlg.m_ofn.lpstrInitialDir = szInitialDir;
int iRvl = dlg.DoModal();
if (iRvl == IDCANCEL)
{
return;
}
//
// Get the directory they browsed to for next time.
//
CString str = dlg.GetPathName();
int nSlash = str.ReverseFind('\\');
if (nSlash != -1)
{
strcpy(szInitialDir, str.Left(nSlash));
}
if (str.Find('.') == -1)
{
switch (dlg.m_ofn.nFilterIndex)
{
case 1:
{
str += ".vmf";
break;
}
case 2:
{
str += ".vmf_autosave";
break;
}
case 3:
{
str += ".rmf";
break;
}
case 4:
{
str += ".map";
break;
}
}
}
OpenDocumentFile(str);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : lpszFileName -
// Output : CDocument*
//-----------------------------------------------------------------------------
CDocument* CHammer::OpenDocumentFile(LPCTSTR lpszFileName)
{
if(GetFileAttributes(lpszFileName) == 0xFFFFFFFF)
{
CString Message;
Message = "The file " + CString( lpszFileName ) + " does not exist.";
AfxMessageBox( Message );
return NULL;
}
CDocument *pDoc = m_pDocManager->OpenDocumentFile( lpszFileName );
CMapDoc *pMapDoc = dynamic_cast< CMapDoc * >( pDoc );
if ( pMapDoc )
{
CMapDoc::SetActiveMapDoc( pMapDoc );
}
if( pDoc && Options.general.bLoadwinpos && Options.general.bIndependentwin)
{
::GetMainWnd()->LoadWindowStates();
}
if ( pMapDoc && !CHammer::IsNewDocumentVisible() )
{
pMapDoc->ShowWindow( false );
}
else
{
pMapDoc->ShowWindow( true );
}
if ( pDoc && ((CMapDoc *)pDoc)->IsAutosave() )
{
char szRenameMessage[MAX_PATH+MAX_PATH+256];
CString newMapPath = *((CMapDoc *)pDoc)->AutosavedFrom();
sprintf( szRenameMessage, "This map was loaded from an autosave file.\nWould you like to rename it from \"%s\" to \"%s\"?\nNOTE: This will not save the file with the new name; it will only rename it.", lpszFileName, (const char*)newMapPath );
if ( AfxMessageBox( szRenameMessage, MB_YESNO ) == IDYES )
{
((CMapDoc *)pDoc)->SetPathName( newMapPath );
}
}
return pDoc;
}
//-----------------------------------------------------------------------------
// Returns true if this is a key message that is not a special dialog navigation message.
//-----------------------------------------------------------------------------
inline bool IsKeyStrokeMessage( MSG *pMsg )
{
if ( ( pMsg->message != WM_KEYDOWN ) && ( pMsg->message != WM_CHAR ) )
return false;
// Check for special dialog navigation characters -- they don't count
if ( ( pMsg->wParam == VK_ESCAPE ) || ( pMsg->wParam == VK_RETURN ) || ( pMsg->wParam == VK_TAB ) )
return false;
if ( ( pMsg->wParam == VK_UP ) || ( pMsg->wParam == VK_DOWN ) || ( pMsg->wParam == VK_LEFT ) || ( pMsg->wParam == VK_RIGHT ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
BOOL CHammer::PreTranslateMessage(MSG* pMsg)
{
// CG: The following lines were added by the Splash Screen component.
if (CSplashWnd::PreTranslateAppMessage(pMsg))
return TRUE;
// This is for raw input, these shouldn't be translated so skip that here.
if ( pMsg->message == WM_INPUT )
return TRUE;
// Suppress the accelerator table for edit controls so that users can type
// uppercase characters without invoking Hammer tools.
if ( IsKeyStrokeMessage( pMsg ) )
{
char className[80];
::GetClassNameA( pMsg->hwnd, className, sizeof( className ) );
// The classname of dialog window in the VGUI model browser and particle browser is AfxWnd100sd in Debug and AfxWnd100s in Release
if ( !V_stricmp( className, "edit" ) || V_stristr( className, "AfxWnd" ) )
{
// Typing in an edit control. Don't pretranslate, just translate/dispatch.
return FALSE;
}
}
return CWinApp::PreTranslateMessage(pMsg);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHammer::LoadSequences(void)
{
char szRootDir[MAX_PATH];
char szFullPath[MAX_PATH];
APP()->GetDirectory(DIR_PROGRAM, szRootDir);
Q_MakeAbsolutePath( szFullPath, MAX_PATH, "CmdSeq.wc", szRootDir );
std::ifstream file(szFullPath, std::ios::in | std::ios::binary);
if(!file.is_open())
return; // none to load
// skip past header & version
float fThisVersion;
file.seekg(strlen(pszSequenceHdr));
file.read((char*)&fThisVersion, sizeof fThisVersion);
// read number of sequences
DWORD dwSize;
int nSeq;
file.read((char*)&dwSize, sizeof dwSize);
nSeq = dwSize;
for(int i = 0; i < nSeq; i++)
{
CCommandSequence *pSeq = new CCommandSequence;
file.read(pSeq->m_szName, 128);
// read commands in sequence
file.read((char*)&dwSize, sizeof dwSize);
int nCmd = dwSize;
CCOMMAND cmd;
for(int iCmd = 0; iCmd < nCmd; iCmd++)
{
if(fThisVersion < 0.2f)
{
file.read((char*)&cmd, sizeof(CCOMMAND)-1);
cmd.bNoWait = FALSE;
}
else
{
file.read((char*)&cmd, sizeof(CCOMMAND));
}
pSeq->m_Commands.Add(cmd);
}
m_CmdSequences.Add(pSeq);
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CHammer::SaveSequences(void)
{
char szRootDir[MAX_PATH];
char szFullPath[MAX_PATH];
APP()->GetDirectory(DIR_PROGRAM, szRootDir);
Q_MakeAbsolutePath( szFullPath, MAX_PATH, "CmdSeq.wc", szRootDir );
std::ofstream file( szFullPath, std::ios::out | std::ios::binary );
// write header
file.write(pszSequenceHdr, Q_strlen(pszSequenceHdr));
// write out version
file.write((char*)&fSequenceVersion, sizeof(float));
// write out each sequence..
int i, nSeq = m_CmdSequences.GetSize();
DWORD dwSize = nSeq;
file.write((char*)&dwSize, sizeof dwSize);
for(i = 0; i < nSeq; i++)
{
CCommandSequence *pSeq = m_CmdSequences[i];
// write name of sequence
file.write(pSeq->m_szName, 128);
// write number of commands
int nCmd = pSeq->m_Commands.GetSize();
dwSize = nCmd;
file.write((char*)&dwSize, sizeof dwSize);
// write commands ..
for(int iCmd = 0; iCmd < nCmd; iCmd++)
{
CCOMMAND &cmd = pSeq->m_Commands[iCmd];
file.write((char*)&cmd, sizeof cmd);
}
}
}
void CHammer::SetForceRenderNextFrame()
{
m_bForceRenderNextFrame = true;
}
bool CHammer::GetForceRenderNextFrame()
{
return m_bForceRenderNextFrame;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pDoc -
//-----------------------------------------------------------------------------
void CHammer::UpdateLighting(CMapDoc *pDoc)
{
static int lastPercent = -20000;
int curPercent = -10000;
IBSPLighting *pLighting = pDoc->GetBSPLighting();
if ( pLighting )
{
// Update 5x / second.
static DWORD lastTime = 0;
DWORD curTime = GetTickCount();
if ( curTime - lastTime < 200 )
{
curPercent = lastPercent; // no change
}
else
{
curPercent = (int)( pLighting->GetPercentComplete() * 10000.0f );
lastTime = curTime;
}
// Redraw the views when new lightmaps are ready.
if ( pLighting->CheckForNewLightmaps() )
{
SetForceRenderNextFrame();
pDoc->UpdateAllViews( MAPVIEW_UPDATE_ONLY_3D );
}
}
// Update the status text.
if ( curPercent == -10000 )
{
SetStatusText( SBI_LIGHTPROGRESS, "<->" );
}
else if( curPercent != lastPercent )
{
char str[256];
sprintf( str, "%.2f%%", curPercent / 100.0f );
SetStatusText( SBI_LIGHTPROGRESS, str );
}
lastPercent = curPercent;
}
//-----------------------------------------------------------------------------
// Purpose: Performs idle processing. Runs the frame and does MFC idle processing.
// Input : lCount - The number of times OnIdle has been called in succession,
// indicating the relative length of time the app has been idle without
// user input.
// Output : Returns TRUE if there is more idle processing to do, FALSE if not.
//-----------------------------------------------------------------------------
BOOL CHammer::OnIdle(LONG lCount)
{
UpdatePrefabs();
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
if (pDoc)
{
UpdateLighting(pDoc);
}
g_Textures.UpdateFileChangeWatchers();
UpdateStudioFileChangeWatcher();
return(CWinApp::OnIdle(lCount));
}
//-----------------------------------------------------------------------------
// Purpose: Renders the realtime views.
//-----------------------------------------------------------------------------
void CHammer::RunFrame(void)
{
// Note: since hammer may well not even have a 3D window visible
// at any given time, we have to call into the material system to
// make it deal with device lost. Usually this happens during SwapBuffers,
// but we may well not call SwapBuffers at any given moment.
materials->HandleDeviceLost();
if (!IsActiveApp())
{
Sleep(50);
}
#ifdef VPROF_HAMMER
g_VProfCurrentProfile.MarkFrame();
#endif
HammerVGui()->Simulate();
if ( CMapDoc::GetActiveMapDoc() && !IsClosing() || m_bForceRenderNextFrame )
HandleLightingPreview();
// never render without document or when closing down
// usually only render when active, but not compiling a map unless forced
if ( CMapDoc::GetActiveMapDoc() && !IsClosing() &&
( ( !IsRunningCommands() && IsActiveApp() ) || m_bForceRenderNextFrame ) &&
CMapDoc::GetActiveMapDoc()->HasInitialUpdate() )
{
// get the time
CMapDoc::GetActiveMapDoc()->UpdateCurrentTime();
// run any animation
CMapDoc::GetActiveMapDoc()->UpdateAnimation();
// redraw the 3d views
CMapDoc::GetActiveMapDoc()->RenderAllViews();
}
// No matter what, we want to keep caching in materials...
if ( IsActiveApp() )
{
g_Textures.LazyLoadTextures();
}
m_bForceRenderNextFrame = false;
}
//-----------------------------------------------------------------------------
// Purpose: Overloaded Run so that we can control the frameratefor realtime
// rendering in the 3D view.
// Output : As MFC CWinApp::Run.
//-----------------------------------------------------------------------------
int CHammer::Run(void)
{
Assert(0);
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Returns true if the editor is the active app, false if not.
//-----------------------------------------------------------------------------
bool CHammer::IsActiveApp(void)
{
return m_bActiveApp;
}
//-----------------------------------------------------------------------------
// Purpose: Called from CMainFrame::OnSysCommand, this informs the app when it
// is minimized and unminimized. This allows us to stop rendering the
// 3D view when we are minimized.
// Input : bMinimized - TRUE when minmized, FALSE otherwise.
//-----------------------------------------------------------------------------
void CHammer::OnActivateApp(bool bActive)
{
// static int nCount = 0;
// if (bActive)
// DBG("ON %d\n", nCount);
// else
// DBG("OFF %d\n", nCount);
// nCount++;
m_bActiveApp = bActive;
}
//-----------------------------------------------------------------------------
// Purpose: Called from the shell to relinquish our video memory in favor of the
// engine. This is called by the engine when it starts up.
//-----------------------------------------------------------------------------
void CHammer::ReleaseVideoMemory()
{
POSITION pos = GetFirstDocTemplatePosition();
while (pos)
{
CDocTemplate* pTemplate = (CDocTemplate*)GetNextDocTemplate(pos);
POSITION pos2 = pTemplate->GetFirstDocPosition();
while (pos2)
{
CDocument * pDocument;
if ((pDocument=pTemplate->GetNextDoc(pos2)) != NULL)
{
static_cast<CMapDoc*>(pDocument)->ReleaseVideoMemory();
}
}
}
}
void CHammer::SuppressVideoAllocation( bool bSuppress )
{
m_SuppressVideoAllocation = bSuppress;
}
bool CHammer::CanAllocateVideo() const
{
return !m_SuppressVideoAllocation;
}
//-------------------------------------------------------------------------------
// Purpose: Runs through the autosave directory and fills the autosave map.
// Also sets the total amount of space used by the directory.
// Input : pFileMap - CUtlMap that will hold the list of files in the dir
// pdwTotalDirSize - pointer to the DWORD that will hold directory size
// pstrMapTitle - the name of the current map to be saved
// Output : returns an int containing the next number to use for the autosave
//-------------------------------------------------------------------------------
int CHammer::GetNextAutosaveNumber( CUtlMap<FILETIME, WIN32_FIND_DATA, int> *pFileMap, DWORD *pdwTotalDirSize, const CString *pstrMapTitle ) const
{
FILETIME oldestAutosaveTime;
oldestAutosaveTime.dwHighDateTime = 0;
oldestAutosaveTime.dwLowDateTime = 0;
char szRootDir[MAX_PATH];
APP()->GetDirectory(DIR_AUTOSAVE, szRootDir);
CString strAutosaveDirectory( szRootDir );
int nNumberActualAutosaves = 0;
int nCurrentAutosaveNumber = 1;
int nOldestAutosaveNumber = 1;
int nExpectedNextAutosaveNumber = 1;
int nLastHole = 0;
int nMaxAutosavesPerMap = Options.general.iMaxAutosavesPerMap;
WIN32_FIND_DATA fileData;
HANDLE hFile;
DWORD dwTotalAutosaveDirectorySize = 0;
hFile = FindFirstFile( strAutosaveDirectory + "*.vmf_autosave", &fileData );
if ( hFile != INVALID_HANDLE_VALUE )
{
//go through and for each file check to see if it is an autosave for this map; also keep track of total file size
//for directory.
while( GetLastError() != ERROR_NO_MORE_FILES && hFile != INVALID_HANDLE_VALUE )
{
(*pFileMap).Insert( fileData.ftLastAccessTime, fileData );
DWORD dwFileSize = fileData.nFileSizeLow;
dwTotalAutosaveDirectorySize += dwFileSize;
FILETIME fileAccessTime = fileData.ftLastAccessTime;
CString currentFilename( fileData.cFileName );
//every autosave file ends in three digits; this code separates the name from the digits
CString strMapName = currentFilename.Left( currentFilename.GetLength() - 17 );
CString strCurrentNumber = currentFilename.Mid( currentFilename.GetLength() - 16, 3 );
int nMapNumber = atoi( (char *)strCurrentNumber.GetBuffer() );
if ( strMapName.CompareNoCase( (*pstrMapTitle) ) == 0 )
{
//keep track of real number of autosaves with map name; deals with instance where older maps get deleted
//and create sequence holes in autosave map names.
nNumberActualAutosaves++;
if ( oldestAutosaveTime.dwLowDateTime == 0 )
{
//the first file is automatically the oldest
oldestAutosaveTime = fileAccessTime;
}
if ( nMapNumber != nExpectedNextAutosaveNumber )
{
//the current map number is different than what was expected
//there is a hole in the sequence
nLastHole = nMapNumber;
}
nExpectedNextAutosaveNumber = nMapNumber + 1;
if ( nExpectedNextAutosaveNumber > 999 )
{
nExpectedNextAutosaveNumber = 1;
}
if ( CompareFileTime( &fileAccessTime, &oldestAutosaveTime ) == -1 )
{
//this file is older than previous oldest file
oldestAutosaveTime = fileAccessTime;
nOldestAutosaveNumber = nMapNumber;
}
}
FindNextFile(hFile, &fileData);
}
FindClose(hFile);
}
if ( nNumberActualAutosaves < nMaxAutosavesPerMap )
{
//there are less autosaves than wanted for the map; use the larger
//of the next expected or the last found hole as the number.
nCurrentAutosaveNumber = max( nExpectedNextAutosaveNumber, nLastHole );
}
else
{
//there are no holes, use the oldest.
nCurrentAutosaveNumber = nOldestAutosaveNumber;
}
*pdwTotalDirSize = dwTotalAutosaveDirectorySize;
return nCurrentAutosaveNumber;
}
static bool LessFunc( const FILETIME &lhs, const FILETIME &rhs )
{
return CompareFileTime(&lhs, &rhs) < 0;
}
//-----------------------------------------------------------------------------
// Purpose: This is called when the autosave timer goes off. It checks to
// make sure the document has changed and handles deletion of old
// files when the total directory size is too big
//-----------------------------------------------------------------------------
void CHammer::Autosave( void )
{
if ( !Options.general.bEnableAutosave )
{
return;
}
if ( VerifyAutosaveDirectory() != true )
{
Options.general.bEnableAutosave = false;
return;
}
CMapDoc *pDoc = CMapDoc::GetActiveMapDoc();
//value from options is in megs
DWORD dwMaxAutosaveSpace = Options.general.iMaxAutosaveSpace * 1024 * 1024;
CUtlMap<FILETIME, WIN32_FIND_DATA, int> autosaveFiles;
autosaveFiles.SetLessFunc( LessFunc );
if ( pDoc && pDoc->NeedsAutosave() )
{
char szRootDir[MAX_PATH];
APP()->GetDirectory(DIR_AUTOSAVE, szRootDir);
CString strAutosaveDirectory( szRootDir );
//expand the path if $SteamUserDir etc are used for SDK users
EditorUtil_ConvertPath(strAutosaveDirectory, true);
CString strExtension = ".vmf";
//this will hold the name of the map w/o leading directory info or file extension
CString strMapTitle;
//full path of map file
CString strMapFilename = pDoc->GetPathName();
DWORD dwTotalAutosaveDirectorySize = 0;
int nCurrentAutosaveNumber = 0;
// the map hasn't been saved before and doesn't have a filename; using default: 'autosave'
if ( strMapFilename.IsEmpty() )
{
strMapTitle = "autosave";
}
// the map already has a filename
else
{
int nFilenameBeginOffset = strMapFilename.ReverseFind( '\\' ) + 1;
int nFilenameEndOffset = strMapFilename.Find( '.' );
//get the filename of the map, between the leading '\' and the '.'
strMapTitle = strMapFilename.Mid( nFilenameBeginOffset, nFilenameEndOffset - nFilenameBeginOffset );
}
nCurrentAutosaveNumber = GetNextAutosaveNumber( &autosaveFiles, &dwTotalAutosaveDirectorySize, &strMapTitle );
//creating the proper suffix for the autosave file
char szNumberChars[4];
CString strAutosaveString = itoa( nCurrentAutosaveNumber, szNumberChars, 10 );
CString strAutosaveNumber = "000";
strAutosaveNumber += strAutosaveString;
strAutosaveNumber = strAutosaveNumber.Right( 3 );
strAutosaveNumber = "_" + strAutosaveNumber;
CString strSaveName = strAutosaveDirectory + strMapTitle + strAutosaveNumber + strExtension + "_autosave";
pDoc->SaveVMF( (char *)strSaveName.GetBuffer(), SAVEFLAGS_AUTOSAVE );
//don't autosave again unless they make changes
pDoc->SetAutosaveFlag( FALSE );
//if there is too much space used for autosaves, delete the oldest file until the size is acceptable
while( dwTotalAutosaveDirectorySize > dwMaxAutosaveSpace )
{
int nFirstElementIndex = autosaveFiles.FirstInorder();
if ( !autosaveFiles.IsValidIndex( nFirstElementIndex ) )
{
Assert( false );
break;
}
WIN32_FIND_DATA fileData = autosaveFiles.Element( nFirstElementIndex );
DWORD dwOldestFileSize = fileData.nFileSizeLow;
char filename[MAX_PATH];
strcpy( filename, fileData.cFileName );
DeleteFile( strAutosaveDirectory + filename );
dwTotalAutosaveDirectorySize -= dwOldestFileSize;
autosaveFiles.RemoveAt( nFirstElementIndex );
}
autosaveFiles.RemoveAll();
}
}
//-----------------------------------------------------------------------------
// Purpose: Verifies that the autosave directory exists and attempts to create it if
// it doesn't. Also returns various failure errors.
// This function is now called at two different times: immediately after a new
// directory is entered in the options screen and during every autosave call.
// If called with a directory, the input directory is checked for correctness.
// Otherwise, the system directory DIR_AUTOSAVE is checked
//-----------------------------------------------------------------------------
bool CHammer::VerifyAutosaveDirectory( char *szAutosaveDirectory ) const
{
HANDLE hDir;
HANDLE hTestFile;
char szRootDir[MAX_PATH];
if ( szAutosaveDirectory )
{
strcpy( szRootDir, szAutosaveDirectory );
EnsureTrailingBackslash( szRootDir );
}
else
{
APP()->GetDirectory(DIR_AUTOSAVE, szRootDir);
}
if ( szRootDir[0] == 0 )
{
AfxMessageBox( "No autosave directory has been selected.\nThe autosave feature will be disabled until a directory is entered.", MB_OK );
return false;
}
CString strAutosaveDirectory( szRootDir );
{
EditorUtil_ConvertPath(strAutosaveDirectory, true);
if ( ( strAutosaveDirectory[1] != ':' ) || ( strAutosaveDirectory[2] != '\\' ) )
{
AfxMessageBox( "The current autosave directory does not have an absolute path.\nThe autosave feature will be disabled until a new directory is entered.", MB_OK );
return false;
}
}
hDir = CreateFile (
strAutosaveDirectory,
GENERIC_READ,
FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
NULL,
OPEN_EXISTING,
FILE_FLAG_BACKUP_SEMANTICS,
NULL
);
if ( hDir == INVALID_HANDLE_VALUE )
{
bool bDirResult = CreateDirectory( strAutosaveDirectory, NULL );
if ( !bDirResult )
{
AfxMessageBox( "The current autosave directory does not exist and could not be created. \nThe autosave feature will be disabled until a new directory is entered.", MB_OK );
return false;
}
}
else
{
CloseHandle( hDir );
hTestFile = CreateFile( strAutosaveDirectory + "test.txt",
GENERIC_READ,
FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
NULL,
CREATE_NEW,
FILE_FLAG_BACKUP_SEMANTICS,
NULL
);
if ( hTestFile == INVALID_HANDLE_VALUE )
{
if ( GetLastError() == ERROR_ACCESS_DENIED )
{
AfxMessageBox( "The autosave directory is marked as read only. Please remove the read only attribute or select a new directory in Tools->Options->General.\nThe autosave feature will be disabled.", MB_OK );
return false;
}
else
{
AfxMessageBox( "There is a problem with the autosave directory. Please select a new directory in Tools->Options->General.\nThe autosave feature will be disabled.", MB_OK );
return false;
}
}
CloseHandle( hTestFile );
DeleteFile( strAutosaveDirectory + "test.txt" );
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Called when Hammer starts after a crash. It loads the newest
// autosave file after Hammer has initialized.
//-----------------------------------------------------------------------------
void CHammer::LoadLastGoodSave( void )
{
CString strLastGoodSave = APP()->GetProfileString("General", "Last Good Save", "");
char szMapDir[MAX_PATH];
strcpy(szMapDir, g_pGameConfig->szMapDir);
CDocument *pCurrentDoc;
if ( !strLastGoodSave.IsEmpty() )
{
pCurrentDoc = APP()->OpenDocumentFile( strLastGoodSave );
if ( !pCurrentDoc )
{
AfxMessageBox( "There was an error loading the last saved file.", MB_OK );
return;
}
char szAutoSaveDir[MAX_PATH];
APP()->GetDirectory(DIR_AUTOSAVE, szAutoSaveDir);
if ( !((CMapDoc *)pCurrentDoc)->IsAutosave() && Q_stristr( pCurrentDoc->GetPathName(), szAutoSaveDir ) )
{
//This handles the case where someone recovers from a crash and tries to load an autosave file that doesn't have the new autosave chunk in it
//It assumes the file should go into the gameConfig map directory
char szRenameMessage[MAX_PATH+MAX_PATH+256];
char szLastSaveCopy[MAX_PATH];
Q_strcpy( szLastSaveCopy, strLastGoodSave );
char *pszFileName = Q_strrchr( strLastGoodSave, '\\') + 1;
char *pszFileNameEnd = Q_strrchr( strLastGoodSave, '_');
if ( !pszFileNameEnd )
{
pszFileNameEnd = Q_strrchr( strLastGoodSave, '.');
}
strcpy( pszFileNameEnd, ".vmf" );
CString newMapPath( szMapDir );
newMapPath.Append( "\\" );
newMapPath.Append( pszFileName );
sprintf( szRenameMessage, "The last saved map was found in the autosave directory.\nWould you like to rename it from \"%s\" to \"%s\"?\nNOTE: This will not save the file with the new name; it will only rename it.", szLastSaveCopy, (const char*)newMapPath );
if ( AfxMessageBox( szRenameMessage, MB_YESNO ) == IDYES )
{
pCurrentDoc->SetPathName( newMapPath );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Called from the General Options dialog when the autosave timer or
// directory values have changed.
//-----------------------------------------------------------------------------
void CHammer::ResetAutosaveTimer()
{
Options.general.bEnableAutosave = true;
CMainFrame *pMainWnd = ::GetMainWnd();
if ( pMainWnd )
{
pMainWnd->ResetAutosaveTimer();
}
}
Reference in New Issue Copy Permalink