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

559 lines
12 KiB
Raw Blame History

//===== Copyright 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#include "pch_tier0.h"
#include <time.h>
#if defined(_WIN32) && !defined(_X360)
#define WINDOWS_LEAN_AND_MEAN
#define _WIN32_WINNT 0x0403
#include <windows.h>
#endif
#include <errno.h>
#include <assert.h>
#include "tier0/platform.h"
#if defined( _X360 )
#include "xbox/xbox_console.h"
#endif
#include "tier0/threadtools.h"
#include "tier0/memalloc.h"
#if defined( _PS3 )
#include <cell/fios/fios_common.h>
#include <cell/fios/fios_memory.h>
#include <cell/fios/fios_configuration.h>
#include <sys/process.h>
#if !defined(_CERT)
#include "sn/LibSN.h"
#endif
/*
#include <sys/types.h>
#include <sys/process.h>
#include <sys/prx.h>
#include <sysutil/sysutil_syscache.h>
#include <cell/sysmodule.h>
*/
#include <cell/fios/fios_time.h>
#endif // _PS3
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
#ifdef _WIN32
static LARGE_INTEGER g_PerformanceFrequency;
static LARGE_INTEGER g_MSPerformanceFrequency;
static LARGE_INTEGER g_ClockStart;
static bool s_bTimeInitted;
#endif
// Benchmark mode uses this heavy-handed method
static bool g_bBenchmarkMode = false;
#ifdef _WIN32
static double g_FakeBenchmarkTime = 0;
static double g_FakeBenchmarkTimeInc = 1.0 / 66.0;
#endif
static CThreadFastMutex g_LocalTimeMutex;
#ifdef _WIN32
static void InitTime()
{
if( !s_bTimeInitted )
{
s_bTimeInitted = true;
QueryPerformanceFrequency(&g_PerformanceFrequency);
g_MSPerformanceFrequency.QuadPart = g_PerformanceFrequency.QuadPart / 1000;
QueryPerformanceCounter(&g_ClockStart);
}
}
#endif
bool Plat_IsInBenchmarkMode()
{
return g_bBenchmarkMode;
}
void Plat_SetBenchmarkMode( bool bBenchmark )
{
g_bBenchmarkMode = bBenchmark;
}
#ifdef _PS3
cell::fios::abstime_t g_fiosLaunchTime = 0;
#endif
double Plat_FloatTime()
{
#ifdef _WIN32
if (! s_bTimeInitted )
InitTime();
if ( g_bBenchmarkMode )
{
g_FakeBenchmarkTime += g_FakeBenchmarkTimeInc;
return g_FakeBenchmarkTime;
}
LARGE_INTEGER CurrentTime;
QueryPerformanceCounter( &CurrentTime );
double fRawSeconds = (double)( CurrentTime.QuadPart - g_ClockStart.QuadPart ) / (double)(g_PerformanceFrequency.QuadPart);
return fRawSeconds;
#else
return cell::fios::FIOSAbstimeToMicroseconds( cell::fios::FIOSGetCurrentTime() - g_fiosLaunchTime ) * 1e-6;
#endif
}
uint32 Plat_MSTime()
{
#ifdef _WIN32
if (! s_bTimeInitted )
InitTime();
if ( g_bBenchmarkMode )
{
g_FakeBenchmarkTime += g_FakeBenchmarkTimeInc;
return (uint32)(g_FakeBenchmarkTime * 1000.0);
}
LARGE_INTEGER CurrentTime;
QueryPerformanceCounter( &CurrentTime );
return (uint32) ( ( CurrentTime.QuadPart - g_ClockStart.QuadPart ) / g_MSPerformanceFrequency.QuadPart);
#elif defined(_PS3)
return (uint32) cell::fios::FIOSAbstimeToMilliseconds( cell::fios::FIOSGetCurrentTime() - g_fiosLaunchTime );
#else
#error
#endif
}
uint64 Timer_GetTimeUS()
{
#ifdef _PS3
return cell::fios::FIOSAbstimeToMicroseconds( cell::fios::FIOSGetCurrentTime() - g_fiosLaunchTime );
#else
return uint64( Plat_FloatTime() * 1000000 );
#endif
}
uint64 Plat_GetClockStart()
{
#if defined( _WIN32 )
if ( !s_bTimeInitted )
InitTime();
return g_ClockStart.QuadPart;
#elif defined( _PS3 )
return g_fiosLaunchTime;
#else
return 0;
#endif
}
void Plat_GetLocalTime( struct tm *pNow )
{
// We just provide a wrapper on this function so we can protect access to time() everywhere.
time_t ltime;
time( &ltime );
Plat_ConvertToLocalTime( ltime, pNow );
}
void Plat_ConvertToLocalTime( uint64 nTime, struct tm *pNow )
{
// Since localtime() returns a global, we need to protect against multiple threads stomping it.
g_LocalTimeMutex.Lock();
time_t ltime = (time_t)nTime;
tm *pTime = localtime( &ltime );
if ( pTime )
*pNow = *pTime;
else
memset( pNow, 0, sizeof( *pNow ) );
g_LocalTimeMutex.Unlock();
}
void Plat_GetTimeString( struct tm *pTime, char *pOut, int nMaxBytes )
{
g_LocalTimeMutex.Lock();
char *pStr = asctime( pTime );
strncpy( pOut, pStr, nMaxBytes );
pOut[nMaxBytes-1] = 0;
g_LocalTimeMutex.Unlock();
}
void Plat_gmtime( uint64 nTime, struct tm *pTime )
{
time_t tmtTime = nTime;
#ifdef _PS3
struct tm * tmp = gmtime( &tmtTime );
* pTime = * tmp;
#else
gmtime_s( pTime, &tmtTime );
#endif
}
time_t Plat_timegm( struct tm *timeptr )
{
#ifndef _GAMECONSOLE
return _mkgmtime( timeptr );
#else
int *pnCrashHereBecauseConsolesDontSupportMkGmTime = 0;
*pnCrashHereBecauseConsolesDontSupportMkGmTime = 0;
return 0;
#endif
}
void Plat_GetModuleFilename( char *pOut, int nMaxBytes )
{
#ifdef PLATFORM_WINDOWS_PC
GetModuleFileName( NULL, pOut, nMaxBytes );
if ( GetLastError() != ERROR_SUCCESS )
Error( "Plat_GetModuleFilename: The buffer given is too small (%d bytes).", nMaxBytes );
#elif PLATFORM_X360
pOut[0] = 0x00; // return null string on Xbox 360
#else
// We shouldn't need this on POSIX.
Assert( false );
pOut[0] = 0x00; // Null the returned string in release builds
#endif
}
void Plat_ExitProcess( int nCode )
{
#if defined( _WIN32 ) && !defined( _X360 )
// We don't want global destructors in our process OR in any DLL to get executed.
// _exit() avoids calling global destructors in our module, but not in other DLLs.
TerminateProcess( GetCurrentProcess(), nCode );
#elif defined(_PS3)
// We do not use this path to exit on PS3 (naturally), rather we want a clear crash:
int *x = NULL; *x = 1;
#else
_exit( nCode );
#endif
}
void GetCurrentDate( int *pDay, int *pMonth, int *pYear )
{
struct tm long_time;
Plat_GetLocalTime( &long_time );
*pDay = long_time.tm_mday;
*pMonth = long_time.tm_mon + 1;
*pYear = long_time.tm_year + 1900;
}
// Wraps the thread-safe versions of asctime. buf must be at least 26 bytes
char *Plat_asctime( const struct tm *tm, char *buf, size_t bufsize )
{
#ifdef _PS3
snprintf( buf, bufsize, "%s", asctime(tm) );
return buf;
#else
if ( EINVAL == asctime_s( buf, bufsize, tm ) )
return NULL;
else
return buf;
#endif
}
// Wraps the thread-safe versions of ctime. buf must be at least 26 bytes
char *Plat_ctime( const time_t *timep, char *buf, size_t bufsize )
{
#ifdef _PS3
snprintf( buf, bufsize, "%s", ctime( timep ) );
return buf;
#else
if ( EINVAL == ctime_s( buf, bufsize, timep ) )
return NULL;
else
return buf;
#endif
}
// Wraps the thread-safe versions of gmtime
struct tm *Plat_gmtime( const time_t *timep, struct tm *result )
{
#ifdef _PS3
*result = *gmtime( timep );
return result;
#else
if ( EINVAL == gmtime_s( result, timep ) )
return NULL;
else
return result;
#endif
}
// Wraps the thread-safe versions of localtime
struct tm *Plat_localtime( const time_t *timep, struct tm *result )
{
#ifdef _PS3
*result = *localtime( timep );
return result;
#else
if ( EINVAL == localtime_s( result, timep ) )
return NULL;
else
return result;
#endif
}
bool vtune( bool resume )
{
#if IS_WINDOWS_PC
static bool bInitialized = false;
static void (__cdecl *VTResume)(void) = NULL;
static void (__cdecl *VTPause) (void) = NULL;
// Grab the Pause and Resume function pointers from the VTune DLL the first time through:
if( !bInitialized )
{
bInitialized = true;
HINSTANCE pVTuneDLL = LoadLibrary( "vtuneapi.dll" );
if( pVTuneDLL )
{
VTResume = (void(__cdecl *)())GetProcAddress( pVTuneDLL, "VTResume" );
VTPause = (void(__cdecl *)())GetProcAddress( pVTuneDLL, "VTPause" );
}
}
// Call the appropriate function, as indicated by the argument:
if( resume && VTResume )
{
VTResume();
return true;
}
else if( !resume && VTPause )
{
VTPause();
return true;
}
#endif
return false;
}
bool Plat_IsInDebugSession()
{
#if defined( _X360 )
return (XBX_IsDebuggerPresent() != 0);
#elif defined( _WIN32 )
return (IsDebuggerPresent() != 0);
#elif defined( _PS3 ) && !defined(_CERT)
return snIsDebuggerPresent();
#else
return false;
#endif
}
void Plat_DebugString( const char * psz )
{
#ifdef _CERT
return; // do nothing!
#endif
#if defined( _X360 )
XBX_OutputDebugString( psz );
#elif defined( _WIN32 )
::OutputDebugStringA( psz );
#elif defined(_PS3)
printf("%s",psz);
#else
// do nothing?
#endif
}
#if defined( PLATFORM_WINDOWS_PC )
void Plat_MessageBox( const char *pTitle, const char *pMessage )
{
MessageBox( NULL, pMessage, pTitle, MB_OK );
}
#endif
PlatOSVersion_t Plat_GetOSVersion()
{
#ifdef PLATFORM_WINDOWS_PC
OSVERSIONINFO info;
info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if ( GetVersionEx( &info ) )
return (PlatOSVersion_t)info.dwMajorVersion;
return PLAT_OS_VERSION_UNKNOWN;
#elif defined( PLATFORM_X360 )
return PLAT_OS_VERSION_XBOX360;
#else
return PLAT_OS_VERSION_UNKNOWN;
#endif
}
#if defined( PLATFORM_PS3 )
//copied from platform_posix.cpp
static char g_CmdLine[ 2048 ] = "";
PLATFORM_INTERFACE void Plat_SetCommandLine( const char *cmdLine )
{
strncpy( g_CmdLine, cmdLine, sizeof(g_CmdLine) );
g_CmdLine[ sizeof(g_CmdLine) -1 ] = 0;
}
#endif
PLATFORM_INTERFACE const tchar *Plat_GetCommandLine()
{
#if defined( _PS3 )
#pragma message("Plat_GetCommandLine() not implemented on PS3") // ****
return g_CmdLine;
#elif defined( TCHAR_IS_WCHAR )
return GetCommandLineW();
#else
return GetCommandLine();
#endif
}
PLATFORM_INTERFACE const char *Plat_GetCommandLineA()
{
#if defined( _PS3 )
#pragma message("Plat_GetCommandLineA() not implemented on PS3") // ****
return g_CmdLine;
#else
return GetCommandLineA();
#endif
}
//-----------------------------------------------------------------------------
// Dynamically load a function
//-----------------------------------------------------------------------------
#ifdef PLATFORM_WINDOWS
void *Plat_GetProcAddress( const char *pszModule, const char *pszName )
{
HMODULE hModule = ::LoadLibrary( pszModule );
return ( hModule ) ? ::GetProcAddress( hModule, pszName ) : NULL;
}
#endif
// -------------------------------------------------------------------------------------------------- //
// Memory stuff.
//
// DEPRECATED. Still here to support binary back compatability of tier0.dll
//
// -------------------------------------------------------------------------------------------------- //
#ifndef _X360
#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE)
typedef void (*Plat_AllocErrorFn)( unsigned long size );
void Plat_DefaultAllocErrorFn( unsigned long size )
{
}
Plat_AllocErrorFn g_AllocError = Plat_DefaultAllocErrorFn;
#endif
#if !defined( _X360 ) && !defined( _PS3 )
CRITICAL_SECTION g_AllocCS;
class CAllocCSInit
{
public:
CAllocCSInit()
{
InitializeCriticalSection( &g_AllocCS );
}
} g_AllocCSInit;
PLATFORM_INTERFACE void* Plat_Alloc( unsigned long size )
{
EnterCriticalSection( &g_AllocCS );
#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE)
void *pRet = MemAlloc_Alloc( size );
#else
void *pRet = malloc( size );
#endif
LeaveCriticalSection( &g_AllocCS );
if ( pRet )
{
return pRet;
}
else
{
#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE)
g_AllocError( size );
#endif
return 0;
}
}
PLATFORM_INTERFACE void* Plat_Realloc( void *ptr, unsigned long size )
{
EnterCriticalSection( &g_AllocCS );
#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE)
void *pRet = g_pMemAlloc->Realloc( ptr, size );
#else
void *pRet = realloc( ptr, size );
#endif
LeaveCriticalSection( &g_AllocCS );
if ( pRet )
{
return pRet;
}
else
{
#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE)
g_AllocError( size );
#endif
return 0;
}
}
PLATFORM_INTERFACE void Plat_Free( void *ptr )
{
EnterCriticalSection( &g_AllocCS );
#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE)
g_pMemAlloc->Free( ptr );
#else
free( ptr );
#endif
LeaveCriticalSection( &g_AllocCS );
}
#if !defined(STEAM) && !defined(NO_MALLOC_OVERRIDE)
PLATFORM_INTERFACE void Plat_SetAllocErrorFn( Plat_AllocErrorFn fn )
{
g_AllocError = fn;
}
#endif
#endif
#endif