mirror of
https://github.com/mapbase-source/source-sdk-2013.git
synced 2025-05-08 12:59:34 +03:00
beaae8ac45
* Adds support for Visual Studio 2012 and 2013 * VR Mode: . Switches from headtrack.dll to sourcevr.dll . Improved readability of the UI in VR . Removed the IPD calibration tool. TF2 will now obey the Oculus configuration file. Use the Oculus calibration tool in your SDK or install and run "OpenVR" under Tools in Steam to calibrate your IPD. . Added dropdown to enable VR mode in the Video options. Removed the -vr command line option. . Added the ability to switch in and out of VR mode without quitting the game . By default VR mode will run full screen. To switch back to a borderless window set the vr_force_windowed convar. . Added support for VR mode on Linux * Many assorted bug fixes and other changes from Team Fortress in various shared files
457 lines
11 KiB
C++
457 lines
11 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//=============================================================================//
|
|
// File extracted from MFC due to symbol conflicts
|
|
|
|
// This is a part of the Microsoft Foundation Classes C++ library.
|
|
// Copyright (C) Microsoft Corporation
|
|
// All rights reserved.
|
|
//
|
|
// This source code is only intended as a supplement to the
|
|
// Microsoft Foundation Classes Reference and related
|
|
// electronic documentation provided with the library.
|
|
// See these sources for detailed information regarding the
|
|
// Microsoft Foundation Classes product.
|
|
|
|
#include "stdafx.h"
|
|
|
|
#ifdef AFX_CORE1_SEG
|
|
#pragma code_seg(AFX_CORE1_SEG)
|
|
#endif
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Debug memory globals and implementation helpers
|
|
|
|
#ifdef _DEBUG // most of this file is for debugging
|
|
|
|
void* __cdecl operator new(size_t nSize, int nType, LPCSTR lpszFileName, int nLine);
|
|
#if _MSC_VER >= 1210
|
|
void* __cdecl operator new[](size_t nSize, int nType, LPCSTR lpszFileName, int nLine);
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// test allocation routines
|
|
|
|
void* PASCAL CObject::operator new(size_t nSize)
|
|
{
|
|
#ifdef _AFX_NO_DEBUG_CRT
|
|
return ::operator new(nSize);
|
|
#else
|
|
return ::operator new(nSize, _AFX_CLIENT_BLOCK, NULL, 0);
|
|
#endif // _AFX_NO_DEBUG_CRT
|
|
}
|
|
|
|
void PASCAL CObject::operator delete(void* p)
|
|
{
|
|
#ifdef _AFX_NO_DEBUG_CRT
|
|
free(p);
|
|
#else
|
|
_free_dbg(p, _AFX_CLIENT_BLOCK);
|
|
#endif
|
|
}
|
|
|
|
#if _MSC_VER >= 1200
|
|
void PASCAL CObject::operator delete(void* p, void*)
|
|
{
|
|
#ifdef _AFX_NO_DEBUG_CRT
|
|
free(p);
|
|
#else
|
|
_free_dbg(p, _AFX_CLIENT_BLOCK);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
#ifndef _AFX_NO_DEBUG_CRT
|
|
|
|
void* __cdecl operator new(size_t nSize, LPCSTR lpszFileName, int nLine)
|
|
{
|
|
return ::operator new(nSize, _NORMAL_BLOCK, lpszFileName, nLine);
|
|
}
|
|
|
|
#if _MSC_VER >= 1210
|
|
void* __cdecl operator new[](size_t nSize, LPCSTR lpszFileName, int nLine)
|
|
{
|
|
return ::operator new[](nSize, _NORMAL_BLOCK, lpszFileName, nLine);
|
|
}
|
|
#endif
|
|
|
|
#if _MSC_VER >= 1200
|
|
void __cdecl operator delete(void* pData, LPCSTR /* lpszFileName */,
|
|
int /* nLine */)
|
|
{
|
|
::operator delete(pData);
|
|
}
|
|
#endif
|
|
|
|
#if _MSC_VER >= 1210
|
|
void __cdecl operator delete[](void* pData, LPCSTR /* lpszFileName */,
|
|
int /* nLine */)
|
|
{
|
|
::operator delete(pData);
|
|
}
|
|
#endif
|
|
|
|
void* PASCAL
|
|
CObject::operator new(size_t nSize, LPCSTR lpszFileName, int nLine)
|
|
{
|
|
return ::operator new(nSize, _AFX_CLIENT_BLOCK, lpszFileName, nLine);
|
|
}
|
|
|
|
#if _MSC_VER >= 1200
|
|
void PASCAL
|
|
CObject::operator delete(void *pObject, LPCSTR /* lpszFileName */,
|
|
int /* nLine */)
|
|
{
|
|
#ifdef _AFX_NO_DEBUG_CRT
|
|
free(pObject);
|
|
#else
|
|
_free_dbg(pObject, _AFX_CLIENT_BLOCK);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
void* AFXAPI AfxAllocMemoryDebug(size_t nSize, BOOL bIsObject, LPCSTR lpszFileName, int nLine)
|
|
{
|
|
return _malloc_dbg(nSize, bIsObject ? _AFX_CLIENT_BLOCK : _NORMAL_BLOCK,
|
|
lpszFileName, nLine);
|
|
}
|
|
|
|
void AFXAPI AfxFreeMemoryDebug(void* pbData, BOOL bIsObject)
|
|
{
|
|
_free_dbg(pbData, bIsObject ? _AFX_CLIENT_BLOCK : _NORMAL_BLOCK);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// allocation failure hook, tracking turn on
|
|
|
|
BOOL AFXAPI _AfxDefaultAllocHook(size_t, BOOL, LONG)
|
|
{ return TRUE; }
|
|
|
|
AFX_STATIC_DATA AFX_ALLOC_HOOK pfnAllocHook = _AfxDefaultAllocHook;
|
|
|
|
AFX_STATIC_DATA _CRT_ALLOC_HOOK pfnCrtAllocHook = NULL;
|
|
#if _MSC_VER >= 1200
|
|
int __cdecl _AfxAllocHookProxy(int nAllocType, void * pvData, size_t nSize,
|
|
int nBlockUse, long lRequest, const unsigned char * szFilename, int nLine)
|
|
#else
|
|
int __cdecl _AfxAllocHookProxy(int nAllocType, void * pvData, size_t nSize,
|
|
int nBlockUse, long lRequest, const char * szFilename, int nLine)
|
|
#endif
|
|
{
|
|
#if _MSC_VER >= 1200
|
|
if (nAllocType != _HOOK_ALLOC)
|
|
return (pfnCrtAllocHook)(nAllocType, pvData, nSize,
|
|
nBlockUse, lRequest, (const unsigned char*) szFilename, nLine);
|
|
if ((pfnAllocHook)(nSize, _BLOCK_TYPE(nBlockUse) == _AFX_CLIENT_BLOCK, lRequest))
|
|
return (pfnCrtAllocHook)(nAllocType, pvData, nSize,
|
|
nBlockUse, lRequest, (const unsigned char*) szFilename, nLine);
|
|
#else
|
|
if (nAllocType != _HOOK_ALLOC)
|
|
return (pfnCrtAllocHook)(nAllocType, pvData, nSize,
|
|
nBlockUse, lRequest, szFilename, nLine);
|
|
if ((pfnAllocHook)(nSize, _BLOCK_TYPE(nBlockUse) == _AFX_CLIENT_BLOCK, lRequest))
|
|
return (pfnCrtAllocHook)(nAllocType, pvData, nSize,
|
|
nBlockUse, lRequest, szFilename, nLine);
|
|
#endif
|
|
return FALSE;
|
|
}
|
|
|
|
AFX_ALLOC_HOOK AFXAPI AfxSetAllocHook(AFX_ALLOC_HOOK pfnNewHook)
|
|
{
|
|
if (pfnCrtAllocHook == NULL)
|
|
pfnCrtAllocHook = _CrtSetAllocHook(_AfxAllocHookProxy);
|
|
|
|
AFX_ALLOC_HOOK pfnOldHook = pfnAllocHook;
|
|
pfnAllocHook = pfnNewHook;
|
|
return pfnOldHook;
|
|
}
|
|
|
|
// This can be set to TRUE to override all AfxEnableMemoryTracking calls,
|
|
// allowing all allocations, even MFC internal allocations to be tracked.
|
|
BOOL _afxMemoryLeakOverride = FALSE;
|
|
|
|
BOOL AFXAPI AfxEnableMemoryTracking(BOOL bTrack)
|
|
{
|
|
if (_afxMemoryLeakOverride)
|
|
return TRUE;
|
|
|
|
int nOldState = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
|
|
if (bTrack)
|
|
_CrtSetDbgFlag(nOldState | _CRTDBG_ALLOC_MEM_DF);
|
|
else
|
|
_CrtSetDbgFlag(nOldState & ~_CRTDBG_ALLOC_MEM_DF);
|
|
return nOldState & _CRTDBG_ALLOC_MEM_DF;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// stop on a specific memory request
|
|
|
|
// Obsolete API
|
|
void AFXAPI AfxSetAllocStop(LONG lRequestNumber)
|
|
{
|
|
_CrtSetBreakAlloc(lRequestNumber);
|
|
}
|
|
|
|
BOOL AFXAPI AfxCheckMemory()
|
|
// check all of memory (look for memory tromps)
|
|
{
|
|
return _CrtCheckMemory();
|
|
}
|
|
|
|
// -- true if block of exact size, allocated on the heap
|
|
// -- set *plRequestNumber to request number (or 0)
|
|
BOOL AFXAPI AfxIsMemoryBlock(const void* pData, UINT nBytes,
|
|
LONG* plRequestNumber)
|
|
{
|
|
return _CrtIsMemoryBlock(pData, nBytes, plRequestNumber, NULL, NULL);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMemoryState
|
|
|
|
CMemoryState::CMemoryState()
|
|
{
|
|
memset(this, 0, sizeof(*this));
|
|
}
|
|
|
|
void CMemoryState::UpdateData()
|
|
{
|
|
for(int i = 0; i < nBlockUseMax; i++)
|
|
{
|
|
m_lCounts[i] = m_memState.lCounts[i];
|
|
m_lSizes[i] = m_memState.lSizes[i];
|
|
}
|
|
m_lHighWaterCount = m_memState.lHighWaterCount;
|
|
m_lTotalCount = m_memState.lTotalCount;
|
|
}
|
|
|
|
// fills 'this' with the difference, returns TRUE if significant
|
|
BOOL CMemoryState::Difference(const CMemoryState& oldState,
|
|
const CMemoryState& newState)
|
|
{
|
|
int nResult = _CrtMemDifference(&m_memState, &oldState.m_memState, &newState.m_memState);
|
|
UpdateData();
|
|
return nResult != 0;
|
|
}
|
|
|
|
void CMemoryState::DumpStatistics() const
|
|
{
|
|
_CrtMemDumpStatistics(&m_memState);
|
|
}
|
|
|
|
// -- fill with current memory state
|
|
void CMemoryState::Checkpoint()
|
|
{
|
|
_CrtMemCheckpoint(&m_memState);
|
|
UpdateData();
|
|
}
|
|
|
|
// Dump objects created after this memory state was checkpointed
|
|
// Will dump all objects if this memory state wasn't checkpointed
|
|
// Dump all objects, report about non-objects also
|
|
// List request number in {}
|
|
void CMemoryState::DumpAllObjectsSince() const
|
|
{
|
|
_CrtMemDumpAllObjectsSince(&m_memState);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Enumerate all objects allocated in the diagnostic memory heap
|
|
|
|
struct _AFX_ENUM_CONTEXT
|
|
{
|
|
void (*m_pfn)(CObject*,void*);
|
|
void* m_pContext;
|
|
};
|
|
|
|
AFX_STATIC void _AfxDoForAllObjectsProxy(void* pObject, void* pContext)
|
|
{
|
|
_AFX_ENUM_CONTEXT* p = (_AFX_ENUM_CONTEXT*)pContext;
|
|
(*p->m_pfn)((CObject*)pObject, p->m_pContext);
|
|
}
|
|
|
|
void AFXAPI
|
|
AfxDoForAllObjects(void (AFX_CDECL *pfn)(CObject*, void*), void* pContext)
|
|
{
|
|
if (pfn == NULL)
|
|
{
|
|
AfxThrowInvalidArgException();
|
|
}
|
|
_AFX_ENUM_CONTEXT context;
|
|
context.m_pfn = pfn;
|
|
context.m_pContext = pContext;
|
|
_CrtDoForAllClientObjects(_AfxDoForAllObjectsProxy, &context);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Automatic debug memory diagnostics
|
|
|
|
BOOL AFXAPI AfxDumpMemoryLeaks()
|
|
{
|
|
return _CrtDumpMemoryLeaks();
|
|
}
|
|
|
|
#endif // _AFX_NO_DEBUG_CRT
|
|
#endif // _DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Non-diagnostic memory routines
|
|
|
|
int AFX_CDECL AfxNewHandler(size_t /* nSize */)
|
|
{
|
|
AfxThrowMemoryException();
|
|
}
|
|
|
|
#pragma warning(disable: 4273)
|
|
|
|
#ifndef _AFXDLL
|
|
_PNH _afxNewHandler = &AfxNewHandler;
|
|
#endif
|
|
|
|
_PNH AFXAPI AfxGetNewHandler(void)
|
|
{
|
|
#ifdef _AFXDLL
|
|
AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
|
|
return pState->m_pfnNewHandler;
|
|
#else
|
|
return _afxNewHandler;
|
|
#endif
|
|
}
|
|
|
|
_PNH AFXAPI AfxSetNewHandler(_PNH pfnNewHandler)
|
|
{
|
|
#ifdef _AFXDLL
|
|
AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
|
|
_PNH pfnOldHandler = pState->m_pfnNewHandler;
|
|
pState->m_pfnNewHandler = pfnNewHandler;
|
|
return pfnOldHandler;
|
|
#else
|
|
_PNH pfnOldHandler = _afxNewHandler;
|
|
_afxNewHandler = pfnNewHandler;
|
|
return pfnOldHandler;
|
|
#endif
|
|
}
|
|
|
|
AFX_STATIC_DATA const _PNH _pfnUninitialized = (_PNH)-1;
|
|
|
|
void* __cdecl operator new(size_t nSize)
|
|
{
|
|
void* pResult;
|
|
#ifdef _AFXDLL
|
|
_PNH pfnNewHandler = _pfnUninitialized;
|
|
#endif
|
|
for (;;)
|
|
{
|
|
#if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG)
|
|
pResult = _malloc_dbg(nSize, _NORMAL_BLOCK, NULL, 0);
|
|
#else
|
|
pResult = malloc(nSize);
|
|
#endif
|
|
if (pResult != NULL)
|
|
return pResult;
|
|
|
|
#ifdef _AFXDLL
|
|
if (pfnNewHandler == _pfnUninitialized)
|
|
{
|
|
AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
|
|
pfnNewHandler = pState->m_pfnNewHandler;
|
|
}
|
|
if (pfnNewHandler == NULL || (*pfnNewHandler)(nSize) == 0)
|
|
break;
|
|
#else
|
|
if (_afxNewHandler == NULL || (*_afxNewHandler)(nSize) == 0)
|
|
break;
|
|
#endif
|
|
}
|
|
return pResult;
|
|
}
|
|
|
|
void __cdecl operator delete(void* p)
|
|
{
|
|
#if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG)
|
|
_free_dbg(p, _NORMAL_BLOCK);
|
|
#else
|
|
free(p);
|
|
#endif
|
|
}
|
|
|
|
#if _MSC_VER >= 1210
|
|
void* __cdecl operator new[](size_t nSize)
|
|
{
|
|
return ::operator new(nSize);
|
|
}
|
|
|
|
void __cdecl operator delete[](void* p)
|
|
{
|
|
::operator delete(p);
|
|
}
|
|
#endif
|
|
|
|
#ifdef _DEBUG
|
|
|
|
void* __cdecl operator new(size_t nSize, int nType, LPCSTR lpszFileName, int nLine)
|
|
{
|
|
#ifdef _AFX_NO_DEBUG_CRT
|
|
UNUSED_ALWAYS(nType);
|
|
UNUSED_ALWAYS(lpszFileName);
|
|
UNUSED_ALWAYS(nLine);
|
|
return ::operator new(nSize);
|
|
#else
|
|
void* pResult;
|
|
#ifdef _AFXDLL
|
|
_PNH pfnNewHandler = _pfnUninitialized;
|
|
#endif
|
|
for (;;)
|
|
{
|
|
pResult = _malloc_dbg(nSize, nType, lpszFileName, nLine);
|
|
if (pResult != NULL)
|
|
return pResult;
|
|
|
|
#ifdef _AFXDLL
|
|
if (pfnNewHandler == _pfnUninitialized)
|
|
{
|
|
AFX_MODULE_THREAD_STATE* pState = AfxGetModuleThreadState();
|
|
pfnNewHandler = pState->m_pfnNewHandler;
|
|
}
|
|
if (pfnNewHandler == NULL || (*pfnNewHandler)(nSize) == 0)
|
|
break;
|
|
#else
|
|
if (_afxNewHandler == NULL || (*_afxNewHandler)(nSize) == 0)
|
|
break;
|
|
#endif
|
|
}
|
|
return pResult;
|
|
#endif
|
|
}
|
|
|
|
#if _MSC_VER >= 1700
|
|
void __cdecl operator delete(void* p, int nType, LPCSTR /* lpszFileName */, int /* nLine */)
|
|
{
|
|
#if !defined(_AFX_NO_DEBUG_CRT) && defined(_DEBUG)
|
|
_free_dbg(p, nType);
|
|
#else
|
|
free(p);
|
|
#endif
|
|
}
|
|
#endif // _MSC_VER >= 1200
|
|
|
|
#if _MSC_VER >= 1700
|
|
void* __cdecl operator new[](size_t nSize, int nType, LPCSTR lpszFileName, int nLine)
|
|
{
|
|
return ::operator new(nSize, nType, lpszFileName, nLine);
|
|
}
|
|
void __cdecl operator delete[](void* p, int nType, LPCSTR lpszFileName, int nLine)
|
|
{
|
|
::operator delete(p, nType, lpszFileName, nLine);
|
|
}
|
|
#endif // _MSC_VER >= 1210
|
|
|
|
#endif //_DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|