mirror of
https://github.com/dhewm/dhewm3.git
synced 2024-12-01 00:31:28 +00:00
f9dd2f93eb
Thread return types are different between platforms, and its probably not a good idea to return something of a different size, cast the callback and expect it to not crash.
1617 lines
40 KiB
C++
1617 lines
40 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "../../idlib/precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include <errno.h>
|
|
#include <float.h>
|
|
#include <fcntl.h>
|
|
#include <direct.h>
|
|
#include <io.h>
|
|
#include <conio.h>
|
|
#include <mapi.h>
|
|
#include <ShellAPI.h>
|
|
|
|
#ifndef __MRC__
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#endif
|
|
|
|
#include "../sys_local.h"
|
|
#include "win_local.h"
|
|
#include "rc/CreateResourceIDs.h"
|
|
#include "../../renderer/tr_local.h"
|
|
|
|
idCVar Win32Vars_t::sys_arch( "sys_arch", "", CVAR_SYSTEM | CVAR_INIT, "" );
|
|
idCVar Win32Vars_t::sys_cpustring( "sys_cpustring", "detect", CVAR_SYSTEM | CVAR_INIT, "" );
|
|
idCVar Win32Vars_t::in_mouse( "in_mouse", "1", CVAR_SYSTEM | CVAR_BOOL, "enable mouse input" );
|
|
idCVar Win32Vars_t::win_allowAltTab( "win_allowAltTab", "0", CVAR_SYSTEM | CVAR_BOOL, "allow Alt-Tab when fullscreen" );
|
|
idCVar Win32Vars_t::win_notaskkeys( "win_notaskkeys", "0", CVAR_SYSTEM | CVAR_INTEGER, "disable windows task keys" );
|
|
idCVar Win32Vars_t::win_username( "win_username", "", CVAR_SYSTEM | CVAR_INIT, "windows user name" );
|
|
idCVar Win32Vars_t::win_xpos( "win_xpos", "3", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_INTEGER, "horizontal position of window" );
|
|
idCVar Win32Vars_t::win_ypos( "win_ypos", "22", CVAR_SYSTEM | CVAR_ARCHIVE | CVAR_INTEGER, "vertical position of window" );
|
|
idCVar Win32Vars_t::win_outputDebugString( "win_outputDebugString", "0", CVAR_SYSTEM | CVAR_BOOL, "" );
|
|
idCVar Win32Vars_t::win_outputEditString( "win_outputEditString", "1", CVAR_SYSTEM | CVAR_BOOL, "" );
|
|
idCVar Win32Vars_t::win_viewlog( "win_viewlog", "0", CVAR_SYSTEM | CVAR_INTEGER, "" );
|
|
idCVar Win32Vars_t::win_timerUpdate( "win_timerUpdate", "0", CVAR_SYSTEM | CVAR_BOOL, "allows the game to be updated while dragging the window" );
|
|
idCVar Win32Vars_t::win_allowMultipleInstances( "win_allowMultipleInstances", "0", CVAR_SYSTEM | CVAR_BOOL, "allow multiple instances running concurrently" );
|
|
|
|
Win32Vars_t win32;
|
|
|
|
static char sys_cmdline[MAX_STRING_CHARS];
|
|
|
|
// not a hard limit, just what we keep track of for debugging
|
|
xthreadInfo *g_threads[MAX_THREADS];
|
|
|
|
int g_thread_count = 0;
|
|
|
|
static sysMemoryStats_t exeLaunchMemoryStats;
|
|
|
|
static xthreadInfo threadInfo;
|
|
static HANDLE hTimer;
|
|
|
|
/*
|
|
================
|
|
Sys_GetExeLaunchMemoryStatus
|
|
================
|
|
*/
|
|
void Sys_GetExeLaunchMemoryStatus( sysMemoryStats_t &stats ) {
|
|
stats = exeLaunchMemoryStats;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Sys_Createthread
|
|
==================
|
|
*/
|
|
void Sys_CreateThread( xthread_t function, void *parms, xthreadPriority priority, xthreadInfo &info, const char *name, xthreadInfo *threads[MAX_THREADS], int *thread_count ) {
|
|
HANDLE temp = CreateThread( NULL, // LPSECURITY_ATTRIBUTES lpsa,
|
|
0, // DWORD cbStack,
|
|
function, // LPTHREAD_START_ROUTINE lpStartAddr,
|
|
parms, // LPVOID lpvThreadParm,
|
|
0, // DWORD fdwCreate,
|
|
&info.threadId);
|
|
info.threadHandle = (intptr_t) temp;
|
|
if (priority == THREAD_HIGHEST) {
|
|
SetThreadPriority( (HANDLE)info.threadHandle, THREAD_PRIORITY_HIGHEST ); // we better sleep enough to do this
|
|
} else if (priority == THREAD_ABOVE_NORMAL ) {
|
|
SetThreadPriority( (HANDLE)info.threadHandle, THREAD_PRIORITY_ABOVE_NORMAL );
|
|
}
|
|
info.name = name;
|
|
if ( *thread_count < MAX_THREADS ) {
|
|
threads[(*thread_count)++] = &info;
|
|
} else {
|
|
common->DPrintf("WARNING: MAX_THREADS reached\n");
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Sys_DestroyThread
|
|
==================
|
|
*/
|
|
void Sys_DestroyThread( xthreadInfo& info ) {
|
|
WaitForSingleObject( (HANDLE)info.threadHandle, INFINITE);
|
|
CloseHandle( (HANDLE)info.threadHandle );
|
|
info.threadHandle = 0;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Sys_Sentry
|
|
==================
|
|
*/
|
|
void Sys_Sentry() {
|
|
int j = 0;
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Sys_GetThreadName
|
|
==================
|
|
*/
|
|
const char* Sys_GetThreadName(int *index) {
|
|
size_t id = GetCurrentThreadId();
|
|
for( int i = 0; i < g_thread_count; i++ ) {
|
|
if ( id == g_threads[i]->threadId ) {
|
|
if ( index ) {
|
|
*index = i;
|
|
}
|
|
return g_threads[i]->name;
|
|
}
|
|
}
|
|
if ( index ) {
|
|
*index = -1;
|
|
}
|
|
return "main";
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
Sys_EnterCriticalSection
|
|
==================
|
|
*/
|
|
void Sys_EnterCriticalSection( int index ) {
|
|
assert( index >= 0 && index < MAX_CRITICAL_SECTIONS );
|
|
if ( TryEnterCriticalSection( &win32.criticalSections[index] ) == 0 ) {
|
|
EnterCriticalSection( &win32.criticalSections[index] );
|
|
// Sys_DebugPrintf( "busy lock '%s' in thread '%s'\n", lock->name, Sys_GetThreadName() );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Sys_LeaveCriticalSection
|
|
==================
|
|
*/
|
|
void Sys_LeaveCriticalSection( int index ) {
|
|
assert( index >= 0 && index < MAX_CRITICAL_SECTIONS );
|
|
LeaveCriticalSection( &win32.criticalSections[index] );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Sys_WaitForEvent
|
|
==================
|
|
*/
|
|
void Sys_WaitForEvent( int index ) {
|
|
assert( index == 0 );
|
|
if ( !win32.backgroundDownloadSemaphore ) {
|
|
win32.backgroundDownloadSemaphore = CreateEvent( NULL, TRUE, FALSE, NULL );
|
|
}
|
|
WaitForSingleObject( win32.backgroundDownloadSemaphore, INFINITE );
|
|
ResetEvent( win32.backgroundDownloadSemaphore );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Sys_TriggerEvent
|
|
==================
|
|
*/
|
|
void Sys_TriggerEvent( int index ) {
|
|
assert( index == 0 );
|
|
SetEvent( win32.backgroundDownloadSemaphore );
|
|
}
|
|
|
|
|
|
|
|
#pragma optimize( "", on )
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
|
static unsigned int debug_total_alloc = 0;
|
|
static unsigned int debug_total_alloc_count = 0;
|
|
static unsigned int debug_current_alloc = 0;
|
|
static unsigned int debug_current_alloc_count = 0;
|
|
static unsigned int debug_frame_alloc = 0;
|
|
static unsigned int debug_frame_alloc_count = 0;
|
|
|
|
idCVar sys_showMallocs( "sys_showMallocs", "0", CVAR_SYSTEM, "" );
|
|
|
|
// _HOOK_ALLOC, _HOOK_REALLOC, _HOOK_FREE
|
|
|
|
typedef struct CrtMemBlockHeader
|
|
{
|
|
struct _CrtMemBlockHeader *pBlockHeaderNext; // Pointer to the block allocated just before this one:
|
|
struct _CrtMemBlockHeader *pBlockHeaderPrev; // Pointer to the block allocated just after this one
|
|
char *szFileName; // File name
|
|
int nLine; // Line number
|
|
size_t nDataSize; // Size of user block
|
|
int nBlockUse; // Type of block
|
|
long lRequest; // Allocation number
|
|
byte gap[4]; // Buffer just before (lower than) the user's memory:
|
|
} CrtMemBlockHeader;
|
|
|
|
#include <crtdbg.h>
|
|
|
|
/*
|
|
==================
|
|
Sys_AllocHook
|
|
|
|
called for every malloc/new/free/delete
|
|
==================
|
|
*/
|
|
int Sys_AllocHook( int nAllocType, void *pvData, size_t nSize, int nBlockUse, long lRequest, const unsigned char * szFileName, int nLine )
|
|
{
|
|
CrtMemBlockHeader *pHead;
|
|
byte *temp;
|
|
|
|
if ( nBlockUse == _CRT_BLOCK )
|
|
{
|
|
return( TRUE );
|
|
}
|
|
|
|
// get a pointer to memory block header
|
|
temp = ( byte * )pvData;
|
|
temp -= 32;
|
|
pHead = ( CrtMemBlockHeader * )temp;
|
|
|
|
switch( nAllocType ) {
|
|
case _HOOK_ALLOC:
|
|
debug_total_alloc += nSize;
|
|
debug_current_alloc += nSize;
|
|
debug_frame_alloc += nSize;
|
|
debug_total_alloc_count++;
|
|
debug_current_alloc_count++;
|
|
debug_frame_alloc_count++;
|
|
break;
|
|
|
|
case _HOOK_FREE:
|
|
assert( pHead->gap[0] == 0xfd && pHead->gap[1] == 0xfd && pHead->gap[2] == 0xfd && pHead->gap[3] == 0xfd );
|
|
|
|
debug_current_alloc -= pHead->nDataSize;
|
|
debug_current_alloc_count--;
|
|
debug_total_alloc_count++;
|
|
debug_frame_alloc_count++;
|
|
break;
|
|
|
|
case _HOOK_REALLOC:
|
|
assert( pHead->gap[0] == 0xfd && pHead->gap[1] == 0xfd && pHead->gap[2] == 0xfd && pHead->gap[3] == 0xfd );
|
|
|
|
debug_current_alloc -= pHead->nDataSize;
|
|
debug_total_alloc += nSize;
|
|
debug_current_alloc += nSize;
|
|
debug_frame_alloc += nSize;
|
|
debug_total_alloc_count++;
|
|
debug_current_alloc_count--;
|
|
debug_frame_alloc_count++;
|
|
break;
|
|
}
|
|
return( TRUE );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Sys_DebugMemory_f
|
|
==================
|
|
*/
|
|
void Sys_DebugMemory_f( void ) {
|
|
common->Printf( "Total allocation %8dk in %d blocks\n", debug_total_alloc / 1024, debug_total_alloc_count );
|
|
common->Printf( "Current allocation %8dk in %d blocks\n", debug_current_alloc / 1024, debug_current_alloc_count );
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Sys_MemFrame
|
|
==================
|
|
*/
|
|
void Sys_MemFrame( void ) {
|
|
if( sys_showMallocs.GetInteger() ) {
|
|
common->Printf("Frame: %8dk in %5d blocks\n", debug_frame_alloc / 1024, debug_frame_alloc_count );
|
|
}
|
|
|
|
debug_frame_alloc = 0;
|
|
debug_frame_alloc_count = 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
==================
|
|
Sys_FlushCacheMemory
|
|
|
|
On windows, the vertex buffers are write combined, so they
|
|
don't need to be flushed from the cache
|
|
==================
|
|
*/
|
|
void Sys_FlushCacheMemory( void *base, int bytes ) {
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Sys_Error
|
|
|
|
Show the early console as an error dialog
|
|
=============
|
|
*/
|
|
void Sys_Error( const char *error, ... ) {
|
|
va_list argptr;
|
|
char text[4096];
|
|
MSG msg;
|
|
|
|
va_start( argptr, error );
|
|
vsprintf( text, error, argptr );
|
|
va_end( argptr);
|
|
|
|
Conbuf_AppendText( text );
|
|
Conbuf_AppendText( "\n" );
|
|
|
|
Win_SetErrorText( text );
|
|
Sys_ShowConsole( 1, true );
|
|
|
|
timeEndPeriod( 1 );
|
|
|
|
Sys_ShutdownInput();
|
|
|
|
GLimp_Shutdown();
|
|
|
|
// wait for the user to quit
|
|
while ( 1 ) {
|
|
if ( !GetMessage( &msg, NULL, 0, 0 ) ) {
|
|
common->Quit();
|
|
}
|
|
TranslateMessage( &msg );
|
|
DispatchMessage( &msg );
|
|
}
|
|
|
|
Sys_DestroyConsole();
|
|
|
|
exit (1);
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_Quit
|
|
==============
|
|
*/
|
|
void Sys_Quit( void ) {
|
|
timeEndPeriod( 1 );
|
|
Sys_ShutdownInput();
|
|
Sys_DestroyConsole();
|
|
ExitProcess( 0 );
|
|
}
|
|
|
|
|
|
/*
|
|
==============
|
|
Sys_Printf
|
|
==============
|
|
*/
|
|
#define MAXPRINTMSG 4096
|
|
void Sys_Printf( const char *fmt, ... ) {
|
|
char msg[MAXPRINTMSG];
|
|
|
|
va_list argptr;
|
|
va_start(argptr, fmt);
|
|
idStr::vsnPrintf( msg, MAXPRINTMSG-1, fmt, argptr );
|
|
va_end(argptr);
|
|
msg[sizeof(msg)-1] = '\0';
|
|
|
|
if ( win32.win_outputDebugString.GetBool() ) {
|
|
OutputDebugString( msg );
|
|
}
|
|
if ( win32.win_outputEditString.GetBool() ) {
|
|
Conbuf_AppendText( msg );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_DebugPrintf
|
|
==============
|
|
*/
|
|
#define MAXPRINTMSG 4096
|
|
void Sys_DebugPrintf( const char *fmt, ... ) {
|
|
char msg[MAXPRINTMSG];
|
|
|
|
va_list argptr;
|
|
va_start( argptr, fmt );
|
|
idStr::vsnPrintf( msg, MAXPRINTMSG-1, fmt, argptr );
|
|
msg[ sizeof(msg)-1 ] = '\0';
|
|
va_end( argptr );
|
|
|
|
OutputDebugString( msg );
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_DebugVPrintf
|
|
==============
|
|
*/
|
|
void Sys_DebugVPrintf( const char *fmt, va_list arg ) {
|
|
char msg[MAXPRINTMSG];
|
|
|
|
idStr::vsnPrintf( msg, MAXPRINTMSG-1, fmt, arg );
|
|
msg[ sizeof(msg)-1 ] = '\0';
|
|
|
|
OutputDebugString( msg );
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_Sleep
|
|
==============
|
|
*/
|
|
void Sys_Sleep( int msec ) {
|
|
Sleep( msec );
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_ShowWindow
|
|
==============
|
|
*/
|
|
void Sys_ShowWindow( bool show ) {
|
|
::ShowWindow( win32.hWnd, show ? SW_SHOW : SW_HIDE );
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_IsWindowVisible
|
|
==============
|
|
*/
|
|
bool Sys_IsWindowVisible( void ) {
|
|
return ( ::IsWindowVisible( win32.hWnd ) != 0 );
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_Mkdir
|
|
==============
|
|
*/
|
|
void Sys_Mkdir( const char *path ) {
|
|
_mkdir (path);
|
|
}
|
|
|
|
/*
|
|
=================
|
|
Sys_FileTimeStamp
|
|
=================
|
|
*/
|
|
ID_TIME_T Sys_FileTimeStamp( FILE *fp ) {
|
|
struct _stat st;
|
|
_fstat( _fileno( fp ), &st );
|
|
return (long) st.st_mtime;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_Cwd
|
|
==============
|
|
*/
|
|
const char *Sys_Cwd( void ) {
|
|
static char cwd[MAX_OSPATH];
|
|
|
|
_getcwd( cwd, sizeof( cwd ) - 1 );
|
|
cwd[MAX_OSPATH-1] = 0;
|
|
|
|
return cwd;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_DefaultCDPath
|
|
==============
|
|
*/
|
|
const char *Sys_DefaultCDPath( void ) {
|
|
return "";
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_DefaultBasePath
|
|
==============
|
|
*/
|
|
const char *Sys_DefaultBasePath( void ) {
|
|
return Sys_Cwd();
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_DefaultSavePath
|
|
==============
|
|
*/
|
|
const char *Sys_DefaultSavePath( void ) {
|
|
return cvarSystem->GetCVarString( "fs_basepath" );
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_EXEPath
|
|
==============
|
|
*/
|
|
const char *Sys_EXEPath( void ) {
|
|
static char exe[ MAX_OSPATH ];
|
|
GetModuleFileName( NULL, exe, sizeof( exe ) - 1 );
|
|
return exe;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_ListFiles
|
|
==============
|
|
*/
|
|
int Sys_ListFiles( const char *directory, const char *extension, idStrList &list ) {
|
|
idStr search;
|
|
struct _finddata_t findinfo;
|
|
int findhandle;
|
|
int flag;
|
|
|
|
if ( !extension) {
|
|
extension = "";
|
|
}
|
|
|
|
// passing a slash as extension will find directories
|
|
if ( extension[0] == '/' && extension[1] == 0 ) {
|
|
extension = "";
|
|
flag = 0;
|
|
} else {
|
|
flag = _A_SUBDIR;
|
|
}
|
|
|
|
sprintf( search, "%s\\*%s", directory, extension );
|
|
|
|
// search
|
|
list.Clear();
|
|
|
|
findhandle = _findfirst( search, &findinfo );
|
|
if ( findhandle == -1 ) {
|
|
return -1;
|
|
}
|
|
|
|
do {
|
|
if ( flag ^ ( findinfo.attrib & _A_SUBDIR ) ) {
|
|
list.Append( findinfo.name );
|
|
}
|
|
} while ( _findnext( findhandle, &findinfo ) != -1 );
|
|
|
|
_findclose( findhandle );
|
|
|
|
return list.Num();
|
|
}
|
|
|
|
|
|
/*
|
|
================
|
|
Sys_GetClipboardData
|
|
================
|
|
*/
|
|
char *Sys_GetClipboardData( void ) {
|
|
char *data = NULL;
|
|
char *cliptext;
|
|
|
|
if ( OpenClipboard( NULL ) != 0 ) {
|
|
HANDLE hClipboardData;
|
|
|
|
if ( ( hClipboardData = GetClipboardData( CF_TEXT ) ) != 0 ) {
|
|
if ( ( cliptext = (char *)GlobalLock( hClipboardData ) ) != 0 ) {
|
|
data = (char *)Mem_Alloc( GlobalSize( hClipboardData ) + 1 );
|
|
strcpy( data, cliptext );
|
|
GlobalUnlock( hClipboardData );
|
|
|
|
strtok( data, "\n\r\b" );
|
|
}
|
|
}
|
|
CloseClipboard();
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_SetClipboardData
|
|
================
|
|
*/
|
|
void Sys_SetClipboardData( const char *string ) {
|
|
HGLOBAL HMem;
|
|
char *PMem;
|
|
|
|
// allocate memory block
|
|
HMem = (char *)::GlobalAlloc( GMEM_MOVEABLE | GMEM_DDESHARE, strlen( string ) + 1 );
|
|
if ( HMem == NULL ) {
|
|
return;
|
|
}
|
|
// lock allocated memory and obtain a pointer
|
|
PMem = (char *)::GlobalLock( HMem );
|
|
if ( PMem == NULL ) {
|
|
return;
|
|
}
|
|
// copy text into allocated memory block
|
|
lstrcpy( PMem, string );
|
|
// unlock allocated memory
|
|
::GlobalUnlock( HMem );
|
|
// open Clipboard
|
|
if ( !OpenClipboard( 0 ) ) {
|
|
::GlobalFree( HMem );
|
|
return;
|
|
}
|
|
// remove current Clipboard contents
|
|
EmptyClipboard();
|
|
// supply the memory handle to the Clipboard
|
|
SetClipboardData( CF_TEXT, HMem );
|
|
HMem = 0;
|
|
// close Clipboard
|
|
CloseClipboard();
|
|
}
|
|
|
|
/*
|
|
========================================================================
|
|
|
|
DLL Loading
|
|
|
|
========================================================================
|
|
*/
|
|
|
|
/*
|
|
=====================
|
|
Sys_DLL_Load
|
|
=====================
|
|
*/
|
|
uintptr_t Sys_DLL_Load( const char *dllName ) {
|
|
HINSTANCE libHandle;
|
|
libHandle = LoadLibrary( dllName );
|
|
if ( libHandle ) {
|
|
// since we can't have LoadLibrary load only from the specified path, check it did the right thing
|
|
char loadedPath[ MAX_OSPATH ];
|
|
GetModuleFileName( libHandle, loadedPath, sizeof( loadedPath ) - 1 );
|
|
if ( idStr::IcmpPath( dllName, loadedPath ) ) {
|
|
Sys_Printf( "ERROR: LoadLibrary '%s' wants to load '%s'\n", dllName, loadedPath );
|
|
Sys_DLL_Unload( (int)libHandle );
|
|
return 0;
|
|
}
|
|
}
|
|
return (uintptr_t)libHandle;
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
Sys_DLL_GetProcAddress
|
|
=====================
|
|
*/
|
|
void *Sys_DLL_GetProcAddress( uintptr_t dllHandle, const char *procName ) {
|
|
return GetProcAddress( (HINSTANCE)dllHandle, procName );
|
|
}
|
|
|
|
/*
|
|
=====================
|
|
Sys_DLL_Unload
|
|
=====================
|
|
*/
|
|
void Sys_DLL_Unload( uintptr_t dllHandle ) {
|
|
if ( !dllHandle ) {
|
|
return;
|
|
}
|
|
if ( FreeLibrary( (HINSTANCE)dllHandle ) == 0 ) {
|
|
int lastError = GetLastError();
|
|
LPVOID lpMsgBuf;
|
|
FormatMessage(
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER,
|
|
NULL,
|
|
lastError,
|
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
|
|
(LPTSTR) &lpMsgBuf,
|
|
0,
|
|
NULL
|
|
);
|
|
Sys_Error( "Sys_DLL_Unload: FreeLibrary failed - %s (%d)", lpMsgBuf, lastError );
|
|
}
|
|
}
|
|
|
|
/*
|
|
========================================================================
|
|
|
|
EVENT LOOP
|
|
|
|
========================================================================
|
|
*/
|
|
|
|
#define MAX_QUED_EVENTS 256
|
|
#define MASK_QUED_EVENTS ( MAX_QUED_EVENTS - 1 )
|
|
|
|
sysEvent_t eventQue[MAX_QUED_EVENTS];
|
|
int eventHead = 0;
|
|
int eventTail = 0;
|
|
|
|
/*
|
|
================
|
|
Sys_QueEvent
|
|
|
|
Ptr should either be null, or point to a block of data that can
|
|
be freed by the game later.
|
|
================
|
|
*/
|
|
void Sys_QueEvent( int time, sysEventType_t type, int value, int value2, int ptrLength, void *ptr ) {
|
|
sysEvent_t *ev;
|
|
|
|
ev = &eventQue[ eventHead & MASK_QUED_EVENTS ];
|
|
|
|
if ( eventHead - eventTail >= MAX_QUED_EVENTS ) {
|
|
common->Printf("Sys_QueEvent: overflow\n");
|
|
// we are discarding an event, but don't leak memory
|
|
if ( ev->evPtr ) {
|
|
Mem_Free( ev->evPtr );
|
|
}
|
|
eventTail++;
|
|
}
|
|
|
|
eventHead++;
|
|
|
|
ev->evType = type;
|
|
ev->evValue = value;
|
|
ev->evValue2 = value2;
|
|
ev->evPtrLength = ptrLength;
|
|
ev->evPtr = ptr;
|
|
}
|
|
|
|
/*
|
|
=============
|
|
Sys_PumpEvents
|
|
|
|
This allows windows to be moved during renderbump
|
|
=============
|
|
*/
|
|
void Sys_PumpEvents( void ) {
|
|
MSG msg;
|
|
|
|
// pump the message loop
|
|
while( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) ) {
|
|
if ( !GetMessage( &msg, NULL, 0, 0 ) ) {
|
|
common->Quit();
|
|
}
|
|
|
|
// save the msg time, because wndprocs don't have access to the timestamp
|
|
if ( win32.sysMsgTime && win32.sysMsgTime > (int)msg.time ) {
|
|
// don't ever let the event times run backwards
|
|
// common->Printf( "Sys_PumpEvents: win32.sysMsgTime (%i) > msg.time (%i)\n", win32.sysMsgTime, msg.time );
|
|
} else {
|
|
win32.sysMsgTime = msg.time;
|
|
}
|
|
|
|
#ifdef ID_ALLOW_TOOLS
|
|
if ( GUIEditorHandleMessage ( &msg ) ) {
|
|
continue;
|
|
}
|
|
#endif
|
|
|
|
TranslateMessage (&msg);
|
|
DispatchMessage (&msg);
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_GenerateEvents
|
|
================
|
|
*/
|
|
void Sys_GenerateEvents( void ) {
|
|
static int entered = false;
|
|
char *s;
|
|
|
|
if ( entered ) {
|
|
return;
|
|
}
|
|
entered = true;
|
|
|
|
// pump the message loop
|
|
Sys_PumpEvents();
|
|
|
|
// make sure mouse and joystick are only called once a frame
|
|
IN_Frame();
|
|
|
|
// check for console commands
|
|
s = Sys_ConsoleInput();
|
|
if ( s ) {
|
|
char *b;
|
|
int len;
|
|
|
|
len = strlen( s ) + 1;
|
|
b = (char *)Mem_Alloc( len );
|
|
strcpy( b, s );
|
|
Sys_QueEvent( 0, SE_CONSOLE, 0, 0, len, b );
|
|
}
|
|
|
|
entered = false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_ClearEvents
|
|
================
|
|
*/
|
|
void Sys_ClearEvents( void ) {
|
|
eventHead = eventTail = 0;
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_GetEvent
|
|
================
|
|
*/
|
|
sysEvent_t Sys_GetEvent( void ) {
|
|
sysEvent_t ev;
|
|
|
|
// return if we have data
|
|
if ( eventHead > eventTail ) {
|
|
eventTail++;
|
|
return eventQue[ ( eventTail - 1 ) & MASK_QUED_EVENTS ];
|
|
}
|
|
|
|
// return the empty event
|
|
memset( &ev, 0, sizeof( ev ) );
|
|
|
|
return ev;
|
|
}
|
|
|
|
//================================================================
|
|
|
|
/*
|
|
=================
|
|
Sys_In_Restart_f
|
|
|
|
Restart the input subsystem
|
|
=================
|
|
*/
|
|
void Sys_In_Restart_f( const idCmdArgs &args ) {
|
|
Sys_ShutdownInput();
|
|
Sys_InitInput();
|
|
}
|
|
|
|
|
|
/*
|
|
==================
|
|
Sys_AsyncThread
|
|
==================
|
|
*/
|
|
static THREAD_RETURN_TYPE Sys_AsyncThread( void *parm ) {
|
|
int wakeNumber;
|
|
int startTime;
|
|
|
|
startTime = Sys_Milliseconds();
|
|
wakeNumber = 0;
|
|
|
|
while ( 1 ) {
|
|
#ifdef WIN32
|
|
// this will trigger 60 times a second
|
|
int r = WaitForSingleObject( hTimer, 100 );
|
|
if ( r != WAIT_OBJECT_0 ) {
|
|
OutputDebugString( "idPacketServer::PacketServerInterrupt: bad wait return" );
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
wakeNumber++;
|
|
int msec = Sys_Milliseconds();
|
|
int deltaTime = msec - startTime;
|
|
startTime = msec;
|
|
|
|
char str[1024];
|
|
sprintf( str, "%i ", deltaTime );
|
|
OutputDebugString( str );
|
|
#endif
|
|
|
|
|
|
common->Async();
|
|
}
|
|
|
|
return (THREAD_RETURN_TYPE) 0;
|
|
}
|
|
|
|
/*
|
|
==============
|
|
Sys_StartAsyncThread
|
|
|
|
Start the thread that will call idCommon::Async()
|
|
==============
|
|
*/
|
|
void Sys_StartAsyncThread( void ) {
|
|
// create an auto-reset event that happens 60 times a second
|
|
hTimer = CreateWaitableTimer( NULL, false, NULL );
|
|
if ( !hTimer ) {
|
|
common->Error( "idPacketServer::Spawn: CreateWaitableTimer failed" );
|
|
}
|
|
|
|
LARGE_INTEGER t;
|
|
t.HighPart = t.LowPart = 0;
|
|
SetWaitableTimer( hTimer, &t, USERCMD_MSEC, NULL, NULL, TRUE );
|
|
|
|
Sys_CreateThread( Sys_AsyncThread, NULL, THREAD_ABOVE_NORMAL, threadInfo, "Async", g_threads, &g_thread_count );
|
|
|
|
#ifdef SET_THREAD_AFFINITY
|
|
// give the async thread an affinity for the second cpu
|
|
SetThreadAffinityMask( (HANDLE)threadInfo.threadHandle, 2 );
|
|
#endif
|
|
|
|
if ( !threadInfo.threadHandle ) {
|
|
common->Error( "Sys_StartAsyncThread: failed" );
|
|
}
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_AlreadyRunning
|
|
|
|
returns true if there is a copy of D3 running already
|
|
================
|
|
*/
|
|
bool Sys_AlreadyRunning( void ) {
|
|
#ifndef DEBUG
|
|
if ( !win32.win_allowMultipleInstances.GetBool() ) {
|
|
HANDLE hMutexOneInstance = ::CreateMutex( NULL, FALSE, "DOOM3" );
|
|
if ( ::GetLastError() == ERROR_ALREADY_EXISTS || ::GetLastError() == ERROR_ACCESS_DENIED ) {
|
|
return true;
|
|
}
|
|
}
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_Init
|
|
|
|
The cvar system must already be setup
|
|
================
|
|
*/
|
|
#define OSR2_BUILD_NUMBER 1111
|
|
#define WIN98_BUILD_NUMBER 1998
|
|
|
|
void Sys_Init( void ) {
|
|
|
|
CoInitialize( NULL );
|
|
|
|
// make sure the timer is high precision, otherwise
|
|
// NT gets 18ms resolution
|
|
timeBeginPeriod( 1 );
|
|
|
|
// get WM_TIMER messages pumped every millisecond
|
|
// SetTimer( NULL, 0, 100, NULL );
|
|
|
|
cmdSystem->AddCommand( "in_restart", Sys_In_Restart_f, CMD_FL_SYSTEM, "restarts the input system" );
|
|
#ifdef DEBUG
|
|
cmdSystem->AddCommand( "createResourceIDs", CreateResourceIDs_f, CMD_FL_TOOL, "assigns resource IDs in _resouce.h files" );
|
|
#endif
|
|
#if 0
|
|
cmdSystem->AddCommand( "setAsyncSound", Sys_SetAsyncSound_f, CMD_FL_SYSTEM, "set the async sound option" );
|
|
#endif
|
|
|
|
//
|
|
// Windows user name
|
|
//
|
|
win32.win_username.SetString( Sys_GetCurrentUser() );
|
|
|
|
//
|
|
// Windows version
|
|
//
|
|
win32.osversion.dwOSVersionInfoSize = sizeof( win32.osversion );
|
|
|
|
if ( !GetVersionEx( (LPOSVERSIONINFO)&win32.osversion ) )
|
|
Sys_Error( "Couldn't get OS info" );
|
|
|
|
if ( win32.osversion.dwMajorVersion < 4 ) {
|
|
Sys_Error( GAME_NAME " requires Windows version 4 (NT) or greater" );
|
|
}
|
|
if ( win32.osversion.dwPlatformId == VER_PLATFORM_WIN32s ) {
|
|
Sys_Error( GAME_NAME " doesn't run on Win32s" );
|
|
}
|
|
|
|
if( win32.osversion.dwPlatformId == VER_PLATFORM_WIN32_NT ) {
|
|
if( win32.osversion.dwMajorVersion <= 4 ) {
|
|
win32.sys_arch.SetString( "WinNT (NT)" );
|
|
} else if( win32.osversion.dwMajorVersion == 5 && win32.osversion.dwMinorVersion == 0 ) {
|
|
win32.sys_arch.SetString( "Win2K (NT)" );
|
|
} else if( win32.osversion.dwMajorVersion == 5 && win32.osversion.dwMinorVersion == 1 ) {
|
|
win32.sys_arch.SetString( "WinXP (NT)" );
|
|
} else if ( win32.osversion.dwMajorVersion == 6 ) {
|
|
win32.sys_arch.SetString( "Vista" );
|
|
} else {
|
|
win32.sys_arch.SetString( "Unknown NT variant" );
|
|
}
|
|
} else if( win32.osversion.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS ) {
|
|
if( win32.osversion.dwMajorVersion == 4 && win32.osversion.dwMinorVersion == 0 ) {
|
|
// Win95
|
|
if( win32.osversion.szCSDVersion[1] == 'C' ) {
|
|
win32.sys_arch.SetString( "Win95 OSR2 (95)" );
|
|
} else {
|
|
win32.sys_arch.SetString( "Win95 (95)" );
|
|
}
|
|
} else if( win32.osversion.dwMajorVersion == 4 && win32.osversion.dwMinorVersion == 10 ) {
|
|
// Win98
|
|
if( win32.osversion.szCSDVersion[1] == 'A' ) {
|
|
win32.sys_arch.SetString( "Win98SE (95)" );
|
|
} else {
|
|
win32.sys_arch.SetString( "Win98 (95)" );
|
|
}
|
|
} else if( win32.osversion.dwMajorVersion == 4 && win32.osversion.dwMinorVersion == 90 ) {
|
|
// WinMe
|
|
win32.sys_arch.SetString( "WinMe (95)" );
|
|
} else {
|
|
win32.sys_arch.SetString( "Unknown 95 variant" );
|
|
}
|
|
} else {
|
|
win32.sys_arch.SetString( "unknown Windows variant" );
|
|
}
|
|
|
|
//
|
|
// CPU type
|
|
//
|
|
if ( !idStr::Icmp( win32.sys_cpustring.GetString(), "detect" ) ) {
|
|
idStr string;
|
|
|
|
common->Printf( "%1.0f MHz ", Sys_ClockTicksPerSecond() / 1000000.0f );
|
|
|
|
win32.cpuid = Sys_GetCPUId();
|
|
|
|
string.Clear();
|
|
|
|
if ( win32.cpuid & CPUID_AMD ) {
|
|
string += "AMD CPU";
|
|
} else if ( win32.cpuid & CPUID_INTEL ) {
|
|
string += "Intel CPU";
|
|
} else if ( win32.cpuid & CPUID_UNSUPPORTED ) {
|
|
string += "unsupported CPU";
|
|
} else {
|
|
string += "generic CPU";
|
|
}
|
|
|
|
string += " with ";
|
|
if ( win32.cpuid & CPUID_MMX ) {
|
|
string += "MMX & ";
|
|
}
|
|
if ( win32.cpuid & CPUID_3DNOW ) {
|
|
string += "3DNow! & ";
|
|
}
|
|
if ( win32.cpuid & CPUID_SSE ) {
|
|
string += "SSE & ";
|
|
}
|
|
if ( win32.cpuid & CPUID_SSE2 ) {
|
|
string += "SSE2 & ";
|
|
}
|
|
if ( win32.cpuid & CPUID_SSE3 ) {
|
|
string += "SSE3 & ";
|
|
}
|
|
if ( win32.cpuid & CPUID_HTT ) {
|
|
string += "HTT & ";
|
|
}
|
|
string.StripTrailing( " & " );
|
|
string.StripTrailing( " with " );
|
|
win32.sys_cpustring.SetString( string );
|
|
} else {
|
|
common->Printf( "forcing CPU type to " );
|
|
idLexer src( win32.sys_cpustring.GetString(), idStr::Length( win32.sys_cpustring.GetString() ), "sys_cpustring" );
|
|
idToken token;
|
|
|
|
int id = CPUID_NONE;
|
|
while( src.ReadToken( &token ) ) {
|
|
if ( token.Icmp( "generic" ) == 0 ) {
|
|
id |= CPUID_GENERIC;
|
|
} else if ( token.Icmp( "intel" ) == 0 ) {
|
|
id |= CPUID_INTEL;
|
|
} else if ( token.Icmp( "amd" ) == 0 ) {
|
|
id |= CPUID_AMD;
|
|
} else if ( token.Icmp( "mmx" ) == 0 ) {
|
|
id |= CPUID_MMX;
|
|
} else if ( token.Icmp( "3dnow" ) == 0 ) {
|
|
id |= CPUID_3DNOW;
|
|
} else if ( token.Icmp( "sse" ) == 0 ) {
|
|
id |= CPUID_SSE;
|
|
} else if ( token.Icmp( "sse2" ) == 0 ) {
|
|
id |= CPUID_SSE2;
|
|
} else if ( token.Icmp( "sse3" ) == 0 ) {
|
|
id |= CPUID_SSE3;
|
|
} else if ( token.Icmp( "htt" ) == 0 ) {
|
|
id |= CPUID_HTT;
|
|
}
|
|
}
|
|
if ( id == CPUID_NONE ) {
|
|
common->Printf( "WARNING: unknown sys_cpustring '%s'\n", win32.sys_cpustring.GetString() );
|
|
id = CPUID_GENERIC;
|
|
}
|
|
win32.cpuid = (cpuid_t) id;
|
|
}
|
|
|
|
common->Printf( "%s\n", win32.sys_cpustring.GetString() );
|
|
common->Printf( "%d MB System Memory\n", Sys_GetSystemRam() );
|
|
common->Printf( "%d MB Video Memory\n", Sys_GetVideoRam() );
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_Shutdown
|
|
================
|
|
*/
|
|
void Sys_Shutdown( void ) {
|
|
CoUninitialize();
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_GetProcessorId
|
|
================
|
|
*/
|
|
cpuid_t Sys_GetProcessorId( void ) {
|
|
return win32.cpuid;
|
|
}
|
|
|
|
/*
|
|
================
|
|
Sys_GetProcessorString
|
|
================
|
|
*/
|
|
const char *Sys_GetProcessorString( void ) {
|
|
return win32.sys_cpustring.GetString();
|
|
}
|
|
|
|
//=======================================================================
|
|
|
|
//#define SET_THREAD_AFFINITY
|
|
|
|
|
|
/*
|
|
====================
|
|
Win_Frame
|
|
====================
|
|
*/
|
|
void Win_Frame( void ) {
|
|
// if "viewlog" has been modified, show or hide the log console
|
|
if ( win32.win_viewlog.IsModified() ) {
|
|
if ( !com_skipRenderer.GetBool() && idAsyncNetwork::serverDedicated.GetInteger() != 1 ) {
|
|
Sys_ShowConsole( win32.win_viewlog.GetInteger(), false );
|
|
}
|
|
win32.win_viewlog.ClearModified();
|
|
}
|
|
}
|
|
|
|
extern "C" { void _chkstk( int size ); };
|
|
void clrstk( void );
|
|
|
|
/*
|
|
====================
|
|
TestChkStk
|
|
====================
|
|
*/
|
|
void TestChkStk( void ) {
|
|
int buffer[0x1000];
|
|
|
|
buffer[0] = 1;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
HackChkStk
|
|
====================
|
|
*/
|
|
void HackChkStk( void ) {
|
|
DWORD old;
|
|
VirtualProtect( _chkstk, 6, PAGE_EXECUTE_READWRITE, &old );
|
|
*(byte *)_chkstk = 0xe9;
|
|
*(int *)((int)_chkstk+1) = (int)clrstk - (int)_chkstk - 5;
|
|
|
|
TestChkStk();
|
|
}
|
|
|
|
/*
|
|
====================
|
|
GetExceptionCodeInfo
|
|
====================
|
|
*/
|
|
const char *GetExceptionCodeInfo( UINT code ) {
|
|
switch( code ) {
|
|
case EXCEPTION_ACCESS_VIOLATION: return "The thread tried to read from or write to a virtual address for which it does not have the appropriate access.";
|
|
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED: return "The thread tried to access an array element that is out of bounds and the underlying hardware supports bounds checking.";
|
|
case EXCEPTION_BREAKPOINT: return "A breakpoint was encountered.";
|
|
case EXCEPTION_DATATYPE_MISALIGNMENT: return "The thread tried to read or write data that is misaligned on hardware that does not provide alignment. For example, 16-bit values must be aligned on 2-byte boundaries; 32-bit values on 4-byte boundaries, and so on.";
|
|
case EXCEPTION_FLT_DENORMAL_OPERAND: return "One of the operands in a floating-point operation is denormal. A denormal value is one that is too small to represent as a standard floating-point value.";
|
|
case EXCEPTION_FLT_DIVIDE_BY_ZERO: return "The thread tried to divide a floating-point value by a floating-point divisor of zero.";
|
|
case EXCEPTION_FLT_INEXACT_RESULT: return "The result of a floating-point operation cannot be represented exactly as a decimal fraction.";
|
|
case EXCEPTION_FLT_INVALID_OPERATION: return "This exception represents any floating-point exception not included in this list.";
|
|
case EXCEPTION_FLT_OVERFLOW: return "The exponent of a floating-point operation is greater than the magnitude allowed by the corresponding type.";
|
|
case EXCEPTION_FLT_STACK_CHECK: return "The stack overflowed or underflowed as the result of a floating-point operation.";
|
|
case EXCEPTION_FLT_UNDERFLOW: return "The exponent of a floating-point operation is less than the magnitude allowed by the corresponding type.";
|
|
case EXCEPTION_ILLEGAL_INSTRUCTION: return "The thread tried to execute an invalid instruction.";
|
|
case EXCEPTION_IN_PAGE_ERROR: return "The thread tried to access a page that was not present, and the system was unable to load the page. For example, this exception might occur if a network connection is lost while running a program over the network.";
|
|
case EXCEPTION_INT_DIVIDE_BY_ZERO: return "The thread tried to divide an integer value by an integer divisor of zero.";
|
|
case EXCEPTION_INT_OVERFLOW: return "The result of an integer operation caused a carry out of the most significant bit of the result.";
|
|
case EXCEPTION_INVALID_DISPOSITION: return "An exception handler returned an invalid disposition to the exception dispatcher. Programmers using a high-level language such as C should never encounter this exception.";
|
|
case EXCEPTION_NONCONTINUABLE_EXCEPTION: return "The thread tried to continue execution after a noncontinuable exception occurred.";
|
|
case EXCEPTION_PRIV_INSTRUCTION: return "The thread tried to execute an instruction whose operation is not allowed in the current machine mode.";
|
|
case EXCEPTION_SINGLE_STEP: return "A trace trap or other single-instruction mechanism signaled that one instruction has been executed.";
|
|
case EXCEPTION_STACK_OVERFLOW: return "The thread used up its stack.";
|
|
default: return "Unknown exception";
|
|
}
|
|
}
|
|
|
|
/*
|
|
====================
|
|
EmailCrashReport
|
|
|
|
emailer originally from Raven/Quake 4
|
|
====================
|
|
*/
|
|
void EmailCrashReport( LPSTR messageText ) {
|
|
LPMAPISENDMAIL MAPISendMail;
|
|
MapiMessage message;
|
|
static int lastEmailTime = 0;
|
|
|
|
if ( Sys_Milliseconds() < lastEmailTime + 10000 ) {
|
|
return;
|
|
}
|
|
|
|
lastEmailTime = Sys_Milliseconds();
|
|
|
|
HINSTANCE mapi = LoadLibrary( "MAPI32.DLL" );
|
|
if( mapi ) {
|
|
MAPISendMail = ( LPMAPISENDMAIL )GetProcAddress( mapi, "MAPISendMail" );
|
|
if( MAPISendMail ) {
|
|
MapiRecipDesc toProgrammers =
|
|
{
|
|
0, // ulReserved
|
|
MAPI_TO, // ulRecipClass
|
|
"DOOM 3 Crash", // lpszName
|
|
"SMTP:programmers@idsoftware.com", // lpszAddress
|
|
0, // ulEIDSize
|
|
0 // lpEntry
|
|
};
|
|
|
|
memset( &message, 0, sizeof( message ) );
|
|
message.lpszSubject = "DOOM 3 Fatal Error";
|
|
message.lpszNoteText = messageText;
|
|
message.nRecipCount = 1;
|
|
message.lpRecips = &toProgrammers;
|
|
|
|
MAPISendMail(
|
|
0, // LHANDLE lhSession
|
|
0, // ULONG ulUIParam
|
|
&message, // lpMapiMessage lpMessage
|
|
MAPI_DIALOG, // FLAGS flFlags
|
|
0 // ULONG ulReserved
|
|
);
|
|
}
|
|
FreeLibrary( mapi );
|
|
}
|
|
}
|
|
|
|
int Sys_FPU_PrintStateFlags( char *ptr, int ctrl, int stat, int tags, int inof, int inse, int opof, int opse );
|
|
|
|
/*
|
|
====================
|
|
_except_handler
|
|
====================
|
|
*/
|
|
EXCEPTION_DISPOSITION __cdecl _except_handler( struct _EXCEPTION_RECORD *ExceptionRecord, void * EstablisherFrame,
|
|
struct _CONTEXT *ContextRecord, void * DispatcherContext ) {
|
|
|
|
static char msg[ 8192 ];
|
|
char FPUFlags[2048];
|
|
|
|
Sys_FPU_PrintStateFlags( FPUFlags, ContextRecord->FloatSave.ControlWord,
|
|
ContextRecord->FloatSave.StatusWord,
|
|
ContextRecord->FloatSave.TagWord,
|
|
ContextRecord->FloatSave.ErrorOffset,
|
|
ContextRecord->FloatSave.ErrorSelector,
|
|
ContextRecord->FloatSave.DataOffset,
|
|
ContextRecord->FloatSave.DataSelector );
|
|
|
|
|
|
sprintf( msg,
|
|
"Please describe what you were doing when DOOM 3 crashed!\n"
|
|
"If this text did not pop into your email client please copy and email it to programmers@idsoftware.com\n"
|
|
"\n"
|
|
"-= FATAL EXCEPTION =-\n"
|
|
"\n"
|
|
"%s\n"
|
|
"\n"
|
|
"0x%x at address 0x%08x\n"
|
|
"\n"
|
|
"%s\n"
|
|
"\n"
|
|
"EAX = 0x%08x EBX = 0x%08x\n"
|
|
"ECX = 0x%08x EDX = 0x%08x\n"
|
|
"ESI = 0x%08x EDI = 0x%08x\n"
|
|
"EIP = 0x%08x ESP = 0x%08x\n"
|
|
"EBP = 0x%08x EFL = 0x%08x\n"
|
|
"\n"
|
|
"CS = 0x%04x\n"
|
|
"SS = 0x%04x\n"
|
|
"DS = 0x%04x\n"
|
|
"ES = 0x%04x\n"
|
|
"FS = 0x%04x\n"
|
|
"GS = 0x%04x\n"
|
|
"\n"
|
|
"%s\n",
|
|
com_version.GetString(),
|
|
ExceptionRecord->ExceptionCode,
|
|
ExceptionRecord->ExceptionAddress,
|
|
GetExceptionCodeInfo( ExceptionRecord->ExceptionCode ),
|
|
ContextRecord->Eax, ContextRecord->Ebx,
|
|
ContextRecord->Ecx, ContextRecord->Edx,
|
|
ContextRecord->Esi, ContextRecord->Edi,
|
|
ContextRecord->Eip, ContextRecord->Esp,
|
|
ContextRecord->Ebp, ContextRecord->EFlags,
|
|
ContextRecord->SegCs,
|
|
ContextRecord->SegSs,
|
|
ContextRecord->SegDs,
|
|
ContextRecord->SegEs,
|
|
ContextRecord->SegFs,
|
|
ContextRecord->SegGs,
|
|
FPUFlags
|
|
);
|
|
|
|
EmailCrashReport( msg );
|
|
common->FatalError( msg );
|
|
|
|
// Tell the OS to restart the faulting instruction
|
|
return ExceptionContinueExecution;
|
|
}
|
|
|
|
#define TEST_FPU_EXCEPTIONS /* FPU_EXCEPTION_INVALID_OPERATION | */ \
|
|
/* FPU_EXCEPTION_DENORMALIZED_OPERAND | */ \
|
|
/* FPU_EXCEPTION_DIVIDE_BY_ZERO | */ \
|
|
/* FPU_EXCEPTION_NUMERIC_OVERFLOW | */ \
|
|
/* FPU_EXCEPTION_NUMERIC_UNDERFLOW | */ \
|
|
/* FPU_EXCEPTION_INEXACT_RESULT | */ \
|
|
0
|
|
|
|
/*
|
|
==================
|
|
WinMain
|
|
==================
|
|
*/
|
|
int WINAPI WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow ) {
|
|
|
|
const HCURSOR hcurSave = ::SetCursor( LoadCursor( 0, IDC_WAIT ) );
|
|
|
|
Sys_SetPhysicalWorkMemory( 192 << 20, 1024 << 20 );
|
|
|
|
Sys_GetCurrentMemoryStatus( exeLaunchMemoryStats );
|
|
|
|
#if 0
|
|
DWORD handler = (DWORD)_except_handler;
|
|
__asm
|
|
{ // Build EXCEPTION_REGISTRATION record:
|
|
push handler // Address of handler function
|
|
push FS:[0] // Address of previous handler
|
|
mov FS:[0],ESP // Install new EXECEPTION_REGISTRATION
|
|
}
|
|
#endif
|
|
|
|
win32.hInstance = hInstance;
|
|
idStr::Copynz( sys_cmdline, lpCmdLine, sizeof( sys_cmdline ) );
|
|
|
|
// done before Com/Sys_Init since we need this for error output
|
|
Sys_CreateConsole();
|
|
|
|
// no abort/retry/fail errors
|
|
SetErrorMode( SEM_FAILCRITICALERRORS );
|
|
|
|
for ( int i = 0; i < MAX_CRITICAL_SECTIONS; i++ ) {
|
|
InitializeCriticalSection( &win32.criticalSections[i] );
|
|
}
|
|
|
|
// get the initial time base
|
|
Sys_Milliseconds();
|
|
|
|
#ifdef DEBUG
|
|
// disable the painfully slow MS heap check every 1024 allocs
|
|
_CrtSetDbgFlag( 0 );
|
|
#endif
|
|
|
|
// Sys_FPU_EnableExceptions( TEST_FPU_EXCEPTIONS );
|
|
Sys_FPU_SetPrecision( FPU_PRECISION_DOUBLE_EXTENDED );
|
|
|
|
common->Init( 0, NULL, lpCmdLine );
|
|
|
|
#if TEST_FPU_EXCEPTIONS != 0
|
|
common->Printf( Sys_FPU_GetState() );
|
|
#endif
|
|
|
|
#ifndef ID_DEDICATED
|
|
if ( win32.win_notaskkeys.GetInteger() ) {
|
|
DisableTaskKeys( TRUE, FALSE, /*( win32.win_notaskkeys.GetInteger() == 2 )*/ FALSE );
|
|
}
|
|
#endif
|
|
|
|
Sys_StartAsyncThread();
|
|
|
|
// hide or show the early console as necessary
|
|
if ( win32.win_viewlog.GetInteger() || com_skipRenderer.GetBool() || idAsyncNetwork::serverDedicated.GetInteger() ) {
|
|
Sys_ShowConsole( 1, true );
|
|
} else {
|
|
Sys_ShowConsole( 0, false );
|
|
}
|
|
|
|
#ifdef SET_THREAD_AFFINITY
|
|
// give the main thread an affinity for the first cpu
|
|
SetThreadAffinityMask( GetCurrentThread(), 1 );
|
|
#endif
|
|
|
|
::SetCursor( hcurSave );
|
|
|
|
// Launch the script debugger
|
|
if ( strstr( lpCmdLine, "+debugger" ) ) {
|
|
// DebuggerClientInit( lpCmdLine );
|
|
return 0;
|
|
}
|
|
|
|
::SetFocus( win32.hWnd );
|
|
|
|
// main game loop
|
|
while( 1 ) {
|
|
|
|
Win_Frame();
|
|
|
|
#ifdef DEBUG
|
|
Sys_MemFrame();
|
|
#endif
|
|
|
|
// set exceptions, even if some crappy syscall changes them!
|
|
Sys_FPU_EnableExceptions( TEST_FPU_EXCEPTIONS );
|
|
|
|
#ifdef ID_ALLOW_TOOLS
|
|
if ( com_editors ) {
|
|
if ( com_editors & EDITOR_GUI ) {
|
|
// GUI editor
|
|
GUIEditorRun();
|
|
} else if ( com_editors & EDITOR_RADIANT ) {
|
|
// Level Editor
|
|
RadiantRun();
|
|
}
|
|
else if (com_editors & EDITOR_MATERIAL ) {
|
|
//BSM Nerve: Add support for the material editor
|
|
MaterialEditorRun();
|
|
}
|
|
else {
|
|
if ( com_editors & EDITOR_LIGHT ) {
|
|
// in-game Light Editor
|
|
LightEditorRun();
|
|
}
|
|
if ( com_editors & EDITOR_SOUND ) {
|
|
// in-game Sound Editor
|
|
SoundEditorRun();
|
|
}
|
|
if ( com_editors & EDITOR_DECL ) {
|
|
// in-game Declaration Browser
|
|
DeclBrowserRun();
|
|
}
|
|
if ( com_editors & EDITOR_AF ) {
|
|
// in-game Articulated Figure Editor
|
|
AFEditorRun();
|
|
}
|
|
if ( com_editors & EDITOR_PARTICLE ) {
|
|
// in-game Particle Editor
|
|
ParticleEditorRun();
|
|
}
|
|
if ( com_editors & EDITOR_SCRIPT ) {
|
|
// in-game Script Editor
|
|
ScriptEditorRun();
|
|
}
|
|
if ( com_editors & EDITOR_PDA ) {
|
|
// in-game PDA Editor
|
|
PDAEditorRun();
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
// run the game
|
|
common->Frame();
|
|
}
|
|
|
|
// never gets here
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
====================
|
|
clrstk
|
|
|
|
I tried to get the run time to call this at every function entry, but
|
|
====================
|
|
*/
|
|
static int parmBytes;
|
|
__declspec( naked ) void clrstk( void ) {
|
|
// eax = bytes to add to stack
|
|
__asm {
|
|
mov [parmBytes],eax
|
|
neg eax ; compute new stack pointer in eax
|
|
add eax,esp
|
|
add eax,4
|
|
xchg eax,esp
|
|
mov eax,dword ptr [eax] ; copy the return address
|
|
push eax
|
|
|
|
; clear to zero
|
|
push edi
|
|
push ecx
|
|
mov edi,esp
|
|
add edi,12
|
|
mov ecx,[parmBytes]
|
|
shr ecx,2
|
|
xor eax,eax
|
|
cld
|
|
rep stosd
|
|
pop ecx
|
|
pop edi
|
|
|
|
ret
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idSysLocal::OpenURL
|
|
==================
|
|
*/
|
|
void idSysLocal::OpenURL( const char *url, bool doexit ) {
|
|
static bool doexit_spamguard = false;
|
|
HWND wnd;
|
|
|
|
if (doexit_spamguard) {
|
|
common->DPrintf( "OpenURL: already in an exit sequence, ignoring %s\n", url );
|
|
return;
|
|
}
|
|
|
|
common->Printf("Open URL: %s\n", url);
|
|
|
|
if ( !ShellExecute( NULL, "open", url, NULL, NULL, SW_RESTORE ) ) {
|
|
common->Error( "Could not open url: '%s' ", url );
|
|
return;
|
|
}
|
|
|
|
wnd = GetForegroundWindow();
|
|
if ( wnd ) {
|
|
ShowWindow( wnd, SW_MAXIMIZE );
|
|
}
|
|
|
|
if ( doexit ) {
|
|
doexit_spamguard = true;
|
|
cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "quit\n" );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
idSysLocal::StartProcess
|
|
==================
|
|
*/
|
|
void idSysLocal::StartProcess( const char *exePath, bool doexit ) {
|
|
TCHAR szPathOrig[_MAX_PATH];
|
|
STARTUPINFO si;
|
|
PROCESS_INFORMATION pi;
|
|
|
|
ZeroMemory( &si, sizeof(si) );
|
|
si.cb = sizeof(si);
|
|
|
|
strncpy( szPathOrig, exePath, _MAX_PATH );
|
|
|
|
if( !CreateProcess( NULL, szPathOrig, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi ) ) {
|
|
common->Error( "Could not start process: '%s' ", szPathOrig );
|
|
return;
|
|
}
|
|
|
|
if ( doexit ) {
|
|
cmdSystem->BufferCommandText( CMD_EXEC_APPEND, "quit\n" );
|
|
}
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Sys_SetFatalError
|
|
==================
|
|
*/
|
|
void Sys_SetFatalError( const char *error ) {
|
|
}
|
|
|
|
/*
|
|
==================
|
|
Sys_DoPreferences
|
|
==================
|
|
*/
|
|
void Sys_DoPreferences( void ) {
|
|
}
|