mirror of
https://github.com/id-Software/DOOM-3-BFG.git
synced 2024-11-22 20:31:04 +00:00
359 lines
10 KiB
C++
359 lines
10 KiB
C++
|
/*
|
|||
|
|
===========================================================================
|
|||
|
|
|
|||
|
|
Doom 3 BFG Edition GPL Source Code
|
|||
|
|
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
|
|||
|
|
|
|||
|
|
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
|
|||
|
|
|
|||
|
|
Doom 3 BFG Edition 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 BFG Edition 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 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|||
|
|
|
|||
|
|
In addition, the Doom 3 BFG Edition 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 BFG Edition 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.
|
|||
|
|
|
|||
|
|
===========================================================================
|
|||
|
|
*/
|
|||
|
|
#pragma hdrstop
|
|||
|
|
#include "../../precompiled.h"
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
================================================================================================
|
|||
|
|
================================================================================================
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
#define MS_VC_EXCEPTION 0x406D1388
|
|||
|
|
|
|||
|
|
typedef struct tagTHREADNAME_INFO {
|
|||
|
|
DWORD dwType; // Must be 0x1000.
|
|||
|
|
LPCSTR szName; // Pointer to name (in user addr space).
|
|||
|
|
DWORD dwThreadID; // Thread ID (-1=caller thread).
|
|||
|
|
DWORD dwFlags; // Reserved for future use, must be zero.
|
|||
|
|
} THREADNAME_INFO;
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_SetThreadName
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_SetThreadName( DWORD threadID, const char * name ) {
|
|||
|
|
THREADNAME_INFO info;
|
|||
|
|
info.dwType = 0x1000;
|
|||
|
|
info.szName = name;
|
|||
|
|
info.dwThreadID = threadID;
|
|||
|
|
info.dwFlags = 0;
|
|||
|
|
|
|||
|
|
__try {
|
|||
|
|
RaiseException( MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(DWORD), (const ULONG_PTR *)&info );
|
|||
|
|
}
|
|||
|
|
// this much is just to keep /analyze quiet
|
|||
|
|
__except( GetExceptionCode() == MS_VC_EXCEPTION ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH ) {
|
|||
|
|
info.dwFlags = 0;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_SetCurrentThreadName
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_SetCurrentThreadName( const char * name ) {
|
|||
|
|
Sys_SetThreadName( GetCurrentThreadId(), name );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_Createthread
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
uintptr_t Sys_CreateThread( xthread_t function, void *parms, xthreadPriority priority, const char *name, core_t core, int stackSize, bool suspended ) {
|
|||
|
|
|
|||
|
|
DWORD flags = ( suspended ? CREATE_SUSPENDED : 0 );
|
|||
|
|
// Without this flag the 'dwStackSize' parameter to CreateThread specifies the "Stack Commit Size"
|
|||
|
|
// and the "Stack Reserve Size" is set to the value specified at link-time.
|
|||
|
|
// With this flag the 'dwStackSize' parameter to CreateThread specifies the "Stack Reserve Size"
|
|||
|
|
// and the <20>Stack Commit Size<7A> is set to the value specified at link-time.
|
|||
|
|
// For various reasons (some of which historic) we reserve a large amount of stack space in the
|
|||
|
|
// project settings. By setting this flag and by specifying 64 kB for the "Stack Commit Size" in
|
|||
|
|
// the project settings we can create new threads with a much smaller reserved (and committed)
|
|||
|
|
// stack space. It is very important that the "Stack Commit Size" is set to a small value in
|
|||
|
|
// the project settings. If it is set to a large value we may be both reserving and committing
|
|||
|
|
// a lot of memory by setting the STACK_SIZE_PARAM_IS_A_RESERVATION flag. There are some
|
|||
|
|
// 50 threads allocated for normal game play. If, for instance, the commit size is set to 16 MB
|
|||
|
|
// then by adding this flag we would be reserving and committing 50 x 16 = 800 MB of memory.
|
|||
|
|
// On the other hand, if this flag is not set and the "Stack Reserve Size" is set to 16 MB in the
|
|||
|
|
// project settings, then we would still be reserving 50 x 16 = 800 MB of virtual address space.
|
|||
|
|
flags |= STACK_SIZE_PARAM_IS_A_RESERVATION;
|
|||
|
|
|
|||
|
|
DWORD threadId;
|
|||
|
|
HANDLE handle = CreateThread( NULL, // LPSECURITY_ATTRIBUTES lpsa, //-V513
|
|||
|
|
stackSize,
|
|||
|
|
(LPTHREAD_START_ROUTINE)function,
|
|||
|
|
parms,
|
|||
|
|
flags,
|
|||
|
|
&threadId);
|
|||
|
|
if ( handle == 0 ) {
|
|||
|
|
idLib::common->FatalError( "CreateThread error: %i", GetLastError() );
|
|||
|
|
return (uintptr_t)0;
|
|||
|
|
}
|
|||
|
|
Sys_SetThreadName( threadId, name );
|
|||
|
|
if ( priority == THREAD_HIGHEST ) {
|
|||
|
|
SetThreadPriority( (HANDLE)handle, THREAD_PRIORITY_HIGHEST ); // we better sleep enough to do this
|
|||
|
|
} else if ( priority == THREAD_ABOVE_NORMAL ) {
|
|||
|
|
SetThreadPriority( (HANDLE)handle, THREAD_PRIORITY_ABOVE_NORMAL );
|
|||
|
|
} else if ( priority == THREAD_BELOW_NORMAL ) {
|
|||
|
|
SetThreadPriority( (HANDLE)handle, THREAD_PRIORITY_BELOW_NORMAL );
|
|||
|
|
} else if ( priority == THREAD_LOWEST ) {
|
|||
|
|
SetThreadPriority( (HANDLE)handle, THREAD_PRIORITY_LOWEST );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Under Windows, we don't set the thread affinity and let the OS deal with scheduling
|
|||
|
|
|
|||
|
|
return (uintptr_t)handle;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_GetCurrentThreadID
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
uintptr_t Sys_GetCurrentThreadID() {
|
|||
|
|
return GetCurrentThreadId();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_WaitForThread
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_WaitForThread( uintptr_t threadHandle ) {
|
|||
|
|
WaitForSingleObject( (HANDLE)threadHandle, INFINITE );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_DestroyThread
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_DestroyThread( uintptr_t threadHandle ) {
|
|||
|
|
if ( threadHandle == 0 ) {
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
WaitForSingleObject( (HANDLE)threadHandle, INFINITE );
|
|||
|
|
CloseHandle( (HANDLE)threadHandle );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_Yield
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_Yield() {
|
|||
|
|
SwitchToThread();
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
================================================================================================
|
|||
|
|
|
|||
|
|
Signal
|
|||
|
|
|
|||
|
|
================================================================================================
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_SignalCreate
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_SignalCreate( signalHandle_t & handle, bool manualReset ) {
|
|||
|
|
handle = CreateEvent( NULL, manualReset, FALSE, NULL );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_SignalDestroy
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_SignalDestroy( signalHandle_t &handle ) {
|
|||
|
|
CloseHandle( handle );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_SignalRaise
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_SignalRaise( signalHandle_t & handle ) {
|
|||
|
|
SetEvent( handle );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_SignalClear
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_SignalClear( signalHandle_t & handle ) {
|
|||
|
|
// events are created as auto-reset so this should never be needed
|
|||
|
|
ResetEvent( handle );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_SignalWait
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
bool Sys_SignalWait( signalHandle_t & handle, int timeout ) {
|
|||
|
|
DWORD result = WaitForSingleObject( handle, timeout == idSysSignal::WAIT_INFINITE ? INFINITE : timeout );
|
|||
|
|
assert( result == WAIT_OBJECT_0 || ( timeout != idSysSignal::WAIT_INFINITE && result == WAIT_TIMEOUT ) );
|
|||
|
|
return ( result == WAIT_OBJECT_0 );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
================================================================================================
|
|||
|
|
|
|||
|
|
Mutex
|
|||
|
|
|
|||
|
|
================================================================================================
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_MutexCreate
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_MutexCreate( mutexHandle_t & handle ) {
|
|||
|
|
InitializeCriticalSection( &handle );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_MutexDestroy
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_MutexDestroy( mutexHandle_t & handle ) {
|
|||
|
|
DeleteCriticalSection( &handle );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_MutexLock
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
bool Sys_MutexLock( mutexHandle_t & handle, bool blocking ) {
|
|||
|
|
if ( TryEnterCriticalSection( &handle ) == 0 ) {
|
|||
|
|
if ( !blocking ) {
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
EnterCriticalSection( &handle );
|
|||
|
|
}
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_MutexUnlock
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void Sys_MutexUnlock( mutexHandle_t & handle ) {
|
|||
|
|
LeaveCriticalSection( & handle );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
================================================================================================
|
|||
|
|
|
|||
|
|
Interlocked Integer
|
|||
|
|
|
|||
|
|
================================================================================================
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_InterlockedIncrement
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
interlockedInt_t Sys_InterlockedIncrement( interlockedInt_t & value ) {
|
|||
|
|
return InterlockedIncrementAcquire( & value );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_InterlockedDecrement
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
interlockedInt_t Sys_InterlockedDecrement( interlockedInt_t & value ) {
|
|||
|
|
return InterlockedDecrementRelease( & value );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_InterlockedAdd
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
interlockedInt_t Sys_InterlockedAdd( interlockedInt_t & value, interlockedInt_t i ) {
|
|||
|
|
return InterlockedExchangeAdd( & value, i ) + i;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_InterlockedSub
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
interlockedInt_t Sys_InterlockedSub( interlockedInt_t & value, interlockedInt_t i ) {
|
|||
|
|
return InterlockedExchangeAdd( & value, - i ) - i;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_InterlockedExchange
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
interlockedInt_t Sys_InterlockedExchange( interlockedInt_t & value, interlockedInt_t exchange ) {
|
|||
|
|
return InterlockedExchange( & value, exchange );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_InterlockedCompareExchange
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
interlockedInt_t Sys_InterlockedCompareExchange( interlockedInt_t & value, interlockedInt_t comparand, interlockedInt_t exchange ) {
|
|||
|
|
return InterlockedCompareExchange( & value, exchange, comparand );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
================================================================================================
|
|||
|
|
|
|||
|
|
Interlocked Pointer
|
|||
|
|
|
|||
|
|
================================================================================================
|
|||
|
|
*/
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_InterlockedExchangePointer
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void *Sys_InterlockedExchangePointer( void *& ptr, void * exchange ) {
|
|||
|
|
return InterlockedExchangePointer( & ptr, exchange );
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
========================
|
|||
|
|
Sys_InterlockedCompareExchangePointer
|
|||
|
|
========================
|
|||
|
|
*/
|
|||
|
|
void * Sys_InterlockedCompareExchangePointer( void * & ptr, void * comparand, void * exchange ) {
|
|||
|
|
return InterlockedCompareExchangePointer( & ptr, exchange, comparand );
|
|||
|
|
}
|