launcher(android): fix crashhandler initialization

VTF 7.5 support was added some time ago, the issue #83 was solved. 
This is important for making artists, mappers and modelers know.

.github/workflows/build.yml

@@ -0,0 +1,77 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - "*"
+  pull_request:
+    branches:
+      - "*"
+
+jobs:
+  build-linux-i386:
+    runs-on: ubuntu-18.04
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build linux-i386
+      run: |
+        scripts/build-ubuntu-i386.sh
+
+  build-linux-amd64:
+    runs-on: ubuntu-18.04
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build linux-amd64
+      run: |
+        scripts/build-ubuntu-amd64.sh
+
+  build-android-armv7a:
+    runs-on: ubuntu-18.04
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build android-armv7a
+      run: |
+        scripts/build-android-armv7a.sh
+
+  build-windows-i386:
+    runs-on: windows-2019
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build windows-i386
+      run: |
+        git submodule init && git submodule update
+        ./waf.bat configure -T debug
+        ./waf.bat build
+
+  build-dedicated-windows-i386:
+    runs-on: windows-2019
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build dedicated windows-i386
+      run: |
+        git submodule init && git submodule update
+        ./waf.bat configure -T debug -d
+        ./waf.bat build
+
+  build-dedicated-linux-i386:
+    runs-on: ubuntu-18.04
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build dedicated linux-i386
+      run: |
+        scripts/build-ubuntu-i386.sh -d
+
+  build-dedicated-linux-amd64:
+    runs-on: ubuntu-18.04
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Build dedicated linux-amd64
+      run: |
+        scripts/build-ubuntu-amd64.sh -d

.github/workflows/tests.yml

@@ -0,0 +1,42 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - "*"
+  pull_request:
+    branches:
+      - "*"
+
+jobs:
+  tests-linux-i386:
+    runs-on: ubuntu-18.04
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Run tests linux-i386
+      run: |
+        scripts/tests-ubuntu-i386.sh
+
+  tests-linux-amd64:
+    runs-on: ubuntu-18.04
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Run tests linux-amd64
+      run: |
+        scripts/tests-ubuntu-amd64.sh
+
+  tests-windows-i386:
+    runs-on: windows-2019
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Run tests windows-i386
+      run: |
+        git submodule init && git submodule update
+        ./waf.bat configure -T release --tests --prefix=out/
+        ./waf.bat install
+        cd out
+        $env:Path = "bin";
+        ./unittest.exe

.gitignore

@@ -1,10 +1,41 @@
 *.mak
 *.mak.vpc_crc
 *.vpc_crc
+*.vpc.*
 *.project
 *obj_*
-build/
 .waf*
 .lock-waf*
 __pycache__
 *.pyc
+.vs/
+Debug/
+Debug_*/
+Release/
+Release_*/
+*.tlog/
+*.obj
+*.pch
+*.log
+*.idb
+*.pdb
+*.rc
+*.bin
+*.vcxproj*
+*.sln
+*.dll*
+*.exp
+*.ilk
+ValveETWProviderEvents.h
+game/client/*/client.lib
+game/server/*/server.lib
+.DS_Store
+build*/
+.cache/
+.ccache/
+waf3*/
+.vscode/
+.depproj/
+source-engine.sln
+hl2/
+

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "ivp"]
 	path = ivp
 	url = https://github.com/nillerusr/source-physics
+[submodule "lib"]
+	path = lib
+	url = https://github.com/nillerusr/source-engine-libs.git

README.md

@@ -1,36 +1,49 @@
-# source-engine
+# Source Engine
+[![GitHub Actions Status](https://github.com/nillerusr/source-engine/actions/workflows/build.yml/badge.svg)](https://github.com/nillerusr/source-engine/actions/workflows/build.yml) [![GitHub Actions Status](https://github.com/nillerusr/source-engine/actions/workflows/tests.yml/badge.svg)](https://github.com/nillerusr/source-engine/actions/workflows/tests.yml)
+ Discord: [![Discord Server](https://img.shields.io/discord/672055862608658432.svg)](https://discord.gg/hZRB7WMgGw)
+ 
 
-# Goals
-* fixing bugs
-* ~~NEON support~~
-* DXVK support
-* remove unnecessary dependencies
-* Elbrus port
-* ~~Arm(android) port~~
-* improve performance
-* ~~replace current buildsystem with waf~~
-* rewrite achivement system( to work without steam )
-* 64-bit support
+Information from [wikipedia](https://wikipedia.org/wiki/Source_(game_engine)):
+
+Source is a 3D game engine developed by Valve.
+It debuted as the successor to GoldSrc with Half-Life: Source in June 2004,
+followed by Counter-Strike: Source and Half-Life 2 later that year.
+Source does not have a concise version numbering scheme; instead, it was released in incremental versions
+
+Source code is based on TF2 2018 leak. Don't use it for commercial purposes.
+
+This project is using waf buildsystem. If you have waf-related questions look https://waf.io/book
+
+# Features:
+- Android, OSX, FreeBSD, Windows support
+- Arm support( except windows )
+- 64bit support
+- Modern toolchains support
+- Fixed many undefined behaviours
+- Touch support( even on windows/linux/osx )
+- VTF 7.5 support
+- PBR support
+- bsp v19-v21 support( bsp v21 support is partial, portal 2 and csgo maps works fine )
+- mdl v46-49 support
+- Removed useless/unnecessary dependencies
+- Achivement system working without steam
+- Fixed many bugs
+
+# Current tasks
+- Rewrite materialsystem for OpenGL render
+- dxvk-native support
+- Elbrus port
+- Bink audio support( for video_bink )
+- Rewrite serverbrowser to work without steam
 
 # How to Build?
-Clone repo and change directory:
-```
-git clone https://github.com/nillerusr/source-engine --recursive --depth 1
-cd source-engine
-```
-On Linux:
+- [Windows](https://github.com/nillerusr/source-engine/wiki/How-to-build#on-windows)
+- [Linux](https://github.com/nillerusr/source-engine/wiki/How-to-build#on-linux)
+- [For Android under Linux](https://github.com/nillerusr/source-engine/wiki/How-to-build#on-linux-for-android)
 
-dependencies:
-fontconfig, freetype2, OpenAL, SDL2, libbz2, libcurl, libjpeg, libpng, zlib
-```
-./waf configure -T debug
-./waf build
-```
-On Linux for Android(**Note: only Android NDK r10e is supported**):
-```
-export ANDROID_NDK=/path/to/ndk
-./waf configure -T debug --android=armeabi-v7a,4.9,21
-./waf build
-```
-On Windows/MacOS:
-**TODO(WAF is not configured for Windows/MacOS. Use VPC as temporary solution)**
+# Support me
+BTC: `bc1qnjq92jj9uqjtafcx2zvnwd48q89hgtd6w8a6na`
+
+ETH: `0x5d0D561146Ed758D266E59B56e85Af0b03ABAF46`
+
+XMR: `48iXvX61MU24m5VGc77rXQYKmoww3dZh6hn7mEwDaLVTfGhyBKq2teoPpeBq6xvqj4itsGh6EzNTzBty6ZDDevApCFNpsJ`

appframework/VguiMatSysApp.cpp

@@ -28,14 +28,6 @@
 #include "tier3/tier3.h"
 
 
-//-----------------------------------------------------------------------------
-// Constructor
-//-----------------------------------------------------------------------------
-CVguiMatSysApp::CVguiMatSysApp()
-{
-}
-
-
 //-----------------------------------------------------------------------------
 // Create all singleton systems
 //-----------------------------------------------------------------------------

appframework/glmdisplaydb_linuxwin.inl

@@ -631,8 +631,8 @@ void    GLMDisplayInfo::Dump( int which )
 {
         SDLAPP_FUNC;
 
-        GLMPRINTF(("\n         #%d: GLMDisplayInfo @ %08x, pixwidth=%d  pixheight=%d",
-                           which, (int)this,  m_info.m_displayPixelWidth,  m_info.m_displayPixelHeight ));
+        GLMPRINTF(("\n         #%d: GLMDisplayInfo @ %p, pixwidth=%d  pixheight=%d",
+                           which, this,  m_info.m_displayPixelWidth,  m_info.m_displayPixelHeight ));
 
         FOR_EACH_VEC( *m_modes, i )
         {

appframework/glmrendererinfo_osx.mm

@@ -206,7 +206,7 @@ GLMRendererInfo::GLMRendererInfo( GLMRendererInfoFields *info )
 		kCGLPFADoubleBuffer, kCGLPFANoRecovery, kCGLPFAAccelerated,
 		kCGLPFADepthSize, 0,
 		kCGLPFAColorSize, 32,
-		kCGLPFARendererID, info->m_rendererID,
+		kCGLPFARendererID, (unsigned int)info->m_rendererID,
 		0
 	};
 
@@ -859,7 +859,7 @@ void	GLMDisplayDB::PopulateRenderers( void )
 					{
 						// grab the OS version
 
-						long vMajor = 0;	long vMinor = 0;	long vMinorMinor = 0;
+                        SInt32 vMajor = 0;	SInt32 vMinor = 0;	SInt32 vMinorMinor = 0;
 						
 						OSStatus gestalt_err = 0;
 						gestalt_err = Gestalt(gestaltSystemVersionMajor, &vMajor);
@@ -1374,7 +1374,7 @@ bool	GLMDisplayDB::GetModeInfo( int rendererIndex, int displayIndex, int modeInd
 		{
 			int modeIndex=0;
 			number = (CFNumberRef)CFDictionaryGetValue(curModeDict, kCGDisplayMode);
-			CFNumberGetValue(number, kCFNumberLongType, &modeIndex);
+			CFNumberGetValue(number, kCFNumberIntType, &modeIndex);
 
 			// grab the width and height, I am unclear on whether this is the displayed FB width or the display device width.
 			int screenWidth=0;
@@ -1382,11 +1382,11 @@ bool	GLMDisplayDB::GetModeInfo( int rendererIndex, int displayIndex, int modeInd
 			int refreshHz=0;
 			
 			number = (CFNumberRef)CFDictionaryGetValue(curModeDict, kCGDisplayWidth);
-			CFNumberGetValue(number, kCFNumberLongType, &screenWidth);
+			CFNumberGetValue(number, kCFNumberIntType, &screenWidth);
 			number = (CFNumberRef)CFDictionaryGetValue(curModeDict, kCGDisplayHeight);
-			CFNumberGetValue(number, kCFNumberLongType, &screenHeight);
+			CFNumberGetValue(number, kCFNumberIntType, &screenHeight);
 			number = (CFNumberRef)CFDictionaryGetValue(curModeDict, kCGDisplayRefreshRate);
-			CFNumberGetValue(number, kCFNumberLongType, &refreshHz);
+			CFNumberGetValue(number, kCFNumberIntType, &refreshHz);
 			
 			GLMPRINTF(( "-D- GLMDisplayDB::GetModeInfo sees mode-index=%d, width=%d, height=%d on CGID %08x (display index %d on rendererindex %d)", 
 				modeIndex,
@@ -1574,7 +1574,7 @@ void	GLMDisplayInfo::PopulateModes( void )
 
 void	GLMDisplayInfo::Dump( int which )
 {
-	GLMPRINTF(("\n         #%d: GLMDisplayInfo @ %08x, cg-id=%08x  display-mask=%08x  pixwidth=%d  pixheight=%d", which, (int)this, m_info.m_cgDisplayID, m_info.m_glDisplayMask, m_info.m_displayPixelWidth,  m_info.m_displayPixelHeight ));
+	GLMPRINTF(("\n         #%d: GLMDisplayInfo @ %08x, cg-id=%08x  display-mask=%08x  pixwidth=%d  pixheight=%d", which, (int)(intp)this, m_info.m_cgDisplayID, m_info.m_glDisplayMask, m_info.m_displayPixelWidth,  m_info.m_displayPixelHeight ));
 
 	FOR_EACH_VEC( *m_modes, i )
 	{

appframework/sdlmgr.cpp

@@ -19,7 +19,9 @@
 
 #include "tier1/utllinkedlist.h"
 #include "tier1/convar.h"
+#ifdef TOGLES
 #include <EGL/egl.h>
+#endif
 
 // NOTE: This has to be the last file included! (turned off below, since this is included like a header)
 #include "tier0/memdbgon.h"
@@ -34,8 +36,8 @@
 #define GLMPRINTF(args)
 #endif
 
-#ifdef OSX
-ConVar osx_rawinput_set_one_time( "osx_rawinput_set_one_time", "0", FCVAR_ARCHIVE|FCVAR_HIDDEN, "");
+#if defined( OSX ) || defined( ANDROID )
+ConVar rawinput_set_one_time( "rawinput_set_one_time", "0", FCVAR_ARCHIVE|FCVAR_HIDDEN, "");
 #endif
 
 ConVar gl_blit_halfx( "gl_blit_halfx", "0" );
@@ -204,8 +206,6 @@ void *VoidFnPtrLookup_GlMgr(const char *fn, bool &okay, const bool bRequired, vo
 	{
 		retval = _glGetProcAddress(fn);
 
-		Msg("_glGetProcAddress(%s) = %x\n", fn, retval);
-
 		if( !retval && l_gles )
 			retval = dlsym( l_gles, fn );
 	}
@@ -270,7 +270,7 @@ public:
 
 	// Get the next N events. The function returns the number of events that were filled into your array.
 	virtual int GetEvents( CCocoaEvent *pEvents, int nMaxEventsToReturn, bool debugEvents = false );
-#ifdef LINUX
+#if defined(LINUX) || defined(PLATFORM_BSD)
 	virtual int PeekAndRemoveKeyboardEvents( bool *pbEsc, bool *pbReturn, bool *pbSpace, bool debugEvent = false );
 #endif
 
@@ -612,10 +612,10 @@ InitReturnVal_t CSDLMgr::Init()
 	_eglGetDisplay = (t_eglGetDisplay)dlsym(l_egl, "eglGetDisplay");
 	_eglQueryString = (t_eglQueryString)dlsym(l_egl, "eglQueryString");
 
-	if( _eglInitialize && _eglInitialize && _eglQueryString)
+	if( _eglInitialize && _eglInitialize && _eglQueryString )
 	{
 		EGLDisplay display = _eglGetDisplay(EGL_DEFAULT_DISPLAY);
-		if( _eglInitialize(display, NULL, NULL) != -1 
+		if( _eglInitialize(display, NULL, NULL) != -1
 			&& strstr(_eglQueryString(display, EGL_EXTENSIONS) ,"EGL_KHR_gl_colorspace") )
 				SET_GL_ATTR(SDL_GL_FRAMEBUFFER_SRGB_CAPABLE, 1)
 	}
@@ -1004,7 +1004,7 @@ int CSDLMgr::GetEvents( CCocoaEvent *pEvents, int nMaxEventsToReturn, bool debug
 	return nToWrite;
 }
 
-#ifdef LINUX
+#if defined(LINUX) || defined(PLATFORM_BSD)
 
 int CSDLMgr::PeekAndRemoveKeyboardEvents( bool *pbEsc, bool *pbReturn, bool *pbSpace, bool debugEvent )
 {
@@ -1139,17 +1139,15 @@ void CSDLMgr::OnFrameRendered()
 
 		ConVarRef rawinput( "m_rawinput" );
 
-		
-#ifdef OSX
-		// We default raw input to on on Mac and set it one time for all users since
+#if defined( OSX ) || defined( ANDROID )
+		// We default raw input to on on Mac/Android and set it one time for all users since
 		// it didn't used to be the default.
-		if ( !osx_rawinput_set_one_time.GetBool() )
+		if ( !rawinput_set_one_time.GetBool() )
 		{
-			osx_rawinput_set_one_time.SetValue( 1 );
+			rawinput_set_one_time.SetValue( 1 );
 			rawinput.SetValue( 1 );
 		}
 #endif
-
 		m_bRawInput = !m_bCursorVisible && rawinput.IsValid() && rawinput.GetBool();
 
 		SDL_bool bWindowGrab = !m_bCursorVisible ? SDL_TRUE : SDL_FALSE;

appframework/wscript

@@ -18,13 +18,28 @@ def build(bld):
 	source = [
 		'AppSystemGroup.cpp',
 		'../public/filesystem_init.cpp',
-#		'vguimatsysapp.cpp'	[$WIN32]
-#		'winapp.cpp'		[$WIN32]
-		'posixapp.cpp',#		[$POSIX]
-		'sdlmgr.cpp'#		[$SDL]
-#		'glmrendererinfo_osx.mm'		[$OSXALL]
 	]
 
+	if bld.env.SDL:
+		source += [
+			'sdlmgr.cpp'
+		]
+	
+	if bld.env.DEST_OS == 'darwin':
+		source += [
+			'glmrendererinfo_osx.mm'
+		]
+
+	if bld.env.DEST_OS == 'win32':
+		source += [
+			'vguimatsysapp.cpp',
+			'winapp.cpp'
+		]
+	else:
+		source += [
+			'posixapp.cpp',#		[$POSIX]
+		]
+
 	includes = [
 		'.',
 		'../public',
@@ -36,6 +51,9 @@ def build(bld):
 
 	libs = []
 
+	if bld.env.DEST_OS == 'darwin':
+		libs += ['FOUNDATION', 'APPKIT', 'IOKIT']
+
 	bld.stlib(
 		source   = source,
 		target   = PROJECT_NAME,

bitmap/bitmap.vpc

@@ -15,6 +15,8 @@ $Configuration
 		$AdditionalIncludeDirectories	"$BASE;$SRCDIR\dx9sdk\include"					[$WINDOWS]
 		$AdditionalIncludeDirectories	"$BASE;$SRCDIR\x360xdk\include\win32\vs2005"	[$WINDOWS]
 		$AdditionalIncludeDirectories	"$BASE;$SRCDIR\thirdparty\stb"
+		
+		$PreprocessorDefinitions		"$BASE;NO_X360_XDK;" [!$X360]
 	}
 }
 

bitmap/colorconversion.cpp

@@ -10,7 +10,6 @@
 #include "bitmap/imageformat.h"
 #include "basetypes.h"
 #include "tier0/dbg.h"
-#include <malloc.h>
 #include <memory.h>
 #include "mathlib/mathlib.h"
 #include "mathlib/vector.h"
@@ -435,7 +434,8 @@ static inline void DecodeAlpha3BitLinear( CDestPixel *pImPos, DXTAlphaBlock3BitL
 	// pRows = (Alpha3BitRows*) & ( pAlphaBlock->stuff[0] );
 	const DWORD mask = 0x00000007;		// bits = 00 00 01 11
 
-	DWORD bits = *( (DWORD*) & ( pAlphaBlock->stuff[0] ));
+	DWORD bits;
+	memcpy( &bits, &(pAlphaBlock->stuff[0]), sizeof(DWORD) );
 
 	gBits[0][0] = (BYTE)( bits & mask );
 	bits >>= 3;
@@ -454,7 +454,7 @@ static inline void DecodeAlpha3BitLinear( CDestPixel *pImPos, DXTAlphaBlock3BitL
 	gBits[1][3] = (BYTE)( bits & mask );
 
 	// now for last two rows:
-	bits = *( (DWORD*) & ( pAlphaBlock->stuff[3] ));		// last 3 bytes
+	memcpy( &bits, &(pAlphaBlock->stuff[3]), sizeof(DWORD) );
 
 	gBits[2][0] = (BYTE)( bits & mask );
 	bits >>= 3;
@@ -828,7 +828,7 @@ bool ConvertToATIxN(  const uint8 *src, ImageFormat srcImageFormat,
 					  uint8 *dst, ImageFormat dstImageFormat,
 					  int width, int height, int srcStride, int dstStride )
 {
-#if !defined( _X360 ) && !defined( POSIX )
+#if 0
 
 	// from rgb(a) to ATIxN
 	if( srcStride != 0 || dstStride != 0 )
@@ -877,7 +877,7 @@ bool ConvertToDXTLegacy(  const uint8 *src, ImageFormat srcImageFormat,
  						  uint8 *dst, ImageFormat dstImageFormat, 
 					      int width, int height, int srcStride, int dstStride )
 {
-#if !defined( _X360 ) && !defined( POSIX )
+#if 0
 	// from rgb(a) to dxtN
 	if( srcStride != 0 || dstStride != 0 )
 		return false;

bitmap/float_bm.cpp

@@ -311,13 +311,16 @@ FloatBitMap_t *FloatBitMap_t::QuarterSize(void) const
 
 	FloatBitMap_t *newbm=new FloatBitMap_t(Width/2,Height/2);
 	for(int y=0;y<Height/2;y++)
+	{
 		for(int x=0;x<Width/2;x++)
 		{
 			for(int c=0;c<4;c++)
 				newbm->Pixel(x,y,c)=((Pixel(x*2,y*2,c)+Pixel(x*2+1,y*2,c)+
 				Pixel(x*2,y*2+1,c)+Pixel(x*2+1,y*2+1,c))/4);
 		}
-		return newbm;
+	}
+
+	return newbm;
 }
 
 FloatBitMap_t *FloatBitMap_t::QuarterSizeBlocky(void) const
@@ -326,12 +329,14 @@ FloatBitMap_t *FloatBitMap_t::QuarterSizeBlocky(void) const
 
 	FloatBitMap_t *newbm=new FloatBitMap_t(Width/2,Height/2);
 	for(int y=0;y<Height/2;y++)
+	{
 		for(int x=0;x<Width/2;x++)
 		{
 			for(int c=0;c<4;c++)
 				newbm->Pixel(x,y,c)=Pixel(x*2,y*2,c);
 		}
-		return newbm;
+	}
+	return newbm;
 }
 
 Vector FloatBitMap_t::AverageColor(void)
@@ -349,12 +354,15 @@ float FloatBitMap_t::BrightestColor(void)
 {
 	float ret=0.0;
 	for(int y=0;y<Height;y++)
+	{
 		for(int x=0;x<Width;x++)
 		{
 			Vector v(Pixel(x,y,0),Pixel(x,y,1),Pixel(x,y,2));
 			ret=max(ret,v.Length());
 		}
-		return ret;
+	}
+
+	return ret;
 }
 
 template <class T> static inline void SWAP(T & a, T & b)
@@ -394,6 +402,7 @@ void FloatBitMap_t::UnLogize(void)
 void FloatBitMap_t::Clear(float r, float g, float b, float alpha)
 {
 	for(int y=0;y<Height;y++)
+	{
 		for(int x=0;x<Width;x++)
 		{
 			Pixel(x,y,0)=r;
@@ -401,6 +410,7 @@ void FloatBitMap_t::Clear(float r, float g, float b, float alpha)
 			Pixel(x,y,2)=b;
 			Pixel(x,y,3)=alpha;
 		}
+	}
 }
 
 void FloatBitMap_t::ScaleRGB(float scale_factor)
@@ -418,68 +428,77 @@ static int dy[4]={-1,0,0,1};
 
 void FloatBitMap_t::SmartPaste(FloatBitMap_t const &b, int xofs, int yofs, uint32 Flags)
 {
-	// now, need to make Difference map
-	FloatBitMap_t DiffMap0(this);
-	FloatBitMap_t DiffMap1(this);
-	FloatBitMap_t DiffMap2(this);
-	FloatBitMap_t DiffMap3(this);
-	FloatBitMap_t *deltas[4]={&DiffMap0,&DiffMap1,&DiffMap2,&DiffMap3};
-	for(int x=0;x<Width;x++)
-		for(int y=0;y<Height;y++)
-			for(int c=0;c<3;c++)
+	   	// now, need to make Difference map
+		FloatBitMap_t DiffMap0(this);
+		FloatBitMap_t DiffMap1(this);
+		FloatBitMap_t DiffMap2(this);
+		FloatBitMap_t DiffMap3(this);
+		FloatBitMap_t *deltas[4] = { &DiffMap0, &DiffMap1, &DiffMap2, &DiffMap3};
+		for (int x = 0; x < Width; x++)
+		{
+			for (int y = 0; y < Height; y++)
 			{
-				for(int i=0;i<NDELTAS;i++)
+				for (int c = 0; c < 3; c++)
 				{
-					int x1=x+dx[i];
-					int y1=y+dy[i];
-					x1=MAX(0,x1);
-					x1=MIN(Width-1,x1);
-					y1=MAX(0,y1);
-					y1=MIN(Height-1,y1);
-					float dx1=Pixel(x,y,c)-Pixel(x1,y1,c);
-					deltas[i]->Pixel(x,y,c)=dx1;
+					for (int i = 0; i < NDELTAS; i++)
+					{
+						int x1 = x + dx[i];
+						int y1 = y + dy[i];
+						x1 = MAX(0, x1);
+						x1 = MIN(Width - 1, x1);
+						y1 = MAX(0, y1);
+						y1 = MIN(Height - 1, y1);
+						float dx1 = Pixel(x, y, c) - Pixel(x1, y1, c);
+						deltas[i]->Pixel(x, y, c) = dx1;
+					}
 				}
 			}
-			for(int x=1;x<b.Width-1;x++)
-				for(int y=1;y<b.Height-1;y++)
-					for(int c=0;c<3;c++)
+		}
+
+		for (int x = 1; x < b.Width - 1; x++)
+		{
+			for (int y = 1; y < b.Height - 1; y++)
+			{
+				for (int c = 0; c < 3; c++)
+				{
+					for (int i = 0; i < NDELTAS; i++)
 					{
-						for(int i=0;i<NDELTAS;i++)
+						float diff = b.Pixel(x, y, c) - b.Pixel(x + dx[i], y + dy[i], c);
+						deltas[i]->Pixel(x + xofs, y + yofs, c) = diff;
+						if (Flags & SPFLAGS_MAXGRADIENT)
 						{
-							float diff=b.Pixel(x,y,c)-b.Pixel(x+dx[i],y+dy[i],c);
-							deltas[i]->Pixel(x+xofs,y+yofs,c)=diff;
-							if (Flags & SPFLAGS_MAXGRADIENT)
-							{
-								float dx1=Pixel(x+xofs,y+yofs,c)-Pixel(x+dx[i]+xofs,y+dy[i]+yofs,c);
-								if (fabs(dx1)>fabs(diff))
-									deltas[i]->Pixel(x+xofs,y+yofs,c)=dx1;
-							}
+							float dx1 = Pixel(x + xofs, y + yofs, c) - Pixel(x + dx[i] + xofs, y + dy[i] + yofs, c);
+							if (fabs(dx1) > fabs(diff))
+								deltas[i]->Pixel(x + xofs, y + yofs, c) = dx1;
 						}
 					}
+				}
+			}
+		}
 
-					// now, calculate modifiability
-					for(int x=0;x<Width;x++)
-						for(int y=0;y<Height;y++)
-						{
-							float modify=0;
-							if (
-								(x>xofs+1) && (x<=xofs+b.Width-2) &&
-								(y>yofs+1) && (y<=yofs+b.Height-2))
-								modify=1;
-							Alpha(x,y)=modify;
-						}
-
-						//   // now, force a fex pixels in center to be constant
-						//   int midx=xofs+b.Width/2;
-						//   int midy=yofs+b.Height/2;
-						//   for(x=midx-10;x<midx+10;x++)
-						//     for(int y=midy-10;y<midy+10;y++)
-						//     {
-						//       Alpha(x,y)=0;
-						//       for(int c=0;c<3;c++)
-						//         Pixel(x,y,c)=b.Pixel(x-xofs,y-yofs,c);
-						//     }
-						Poisson(deltas,6000,Flags);
+	   	// now, calculate modifiability
+		for (int x = 0; x < Width; x++)
+		{
+			for (int y = 0; y < Height; y++)
+			{
+				float modify = 0;
+				if ( (x > xofs + 1) && (x <= xofs + b.Width - 2) &&
+					(y > yofs + 1) && (y <= yofs + b.Height - 2))
+					modify = 1;
+				Alpha(x, y) = modify;
+			}
+		}
+	   	//  	// now, force a fex pixels in center to be constant
+	   	//   int midx=xofs+b.Width/2;
+	   	//   int midy=yofs+b.Height/2;
+	   	//   for(x=midx-10;x<midx+10;x++)
+	   	//	 for(int y=midy-10;y<midy+10;y++)
+	   	//	 {
+	   	//	   Alpha(x,y)=0;
+	   	//	   for(int c=0;c < 3;c++)
+	   	//		 Pixel(x,y,c)=b.Pixel(x-xofs,y-yofs,c);
+	   	//	 }
+		Poisson(deltas, 6000, Flags);
 }
 
 void FloatBitMap_t::ScaleGradients(void)
@@ -489,57 +508,57 @@ void FloatBitMap_t::ScaleGradients(void)
 	FloatBitMap_t DiffMap1(this);
 	FloatBitMap_t DiffMap2(this);
 	FloatBitMap_t DiffMap3(this);
-	FloatBitMap_t *deltas[4]={&DiffMap0,&DiffMap1,&DiffMap2,&DiffMap3};
-	double gsum=0.0;
-	for(int x=0;x<Width;x++)
-		for(int y=0;y<Height;y++)
-			for(int c=0;c<3;c++)
+	FloatBitMap_t *deltas[4] = { &DiffMap0, &DiffMap1, &DiffMap2, &DiffMap3
+	};
+	double gsum = 0.0;
+	for (int x = 0; x < Width; x++)
+		for (int y = 0; y < Height; y++)
+			for (int c = 0; c < 3; c++)
 			{
-				for(int i=0;i<NDELTAS;i++)
+				for (int i = 0; i < NDELTAS; i++)
 				{
-					int x1=x+dx[i];
-					int y1=y+dy[i];
-					x1=MAX(0,x1);
-					x1=MIN(Width-1,x1);
-					y1=MAX(0,y1);
-					y1=MIN(Height-1,y1);
-					float dx1=Pixel(x,y,c)-Pixel(x1,y1,c);
-					deltas[i]->Pixel(x,y,c)=dx1;
-					gsum+=fabs(dx1);
+					int x1 = x + dx[i];
+					int y1 = y + dy[i];
+					x1 = MAX(0, x1);
+					x1 = MIN(Width - 1, x1);
+					y1 = MAX(0, y1);
+					y1 = MIN(Height - 1, y1);
+					float dx1 = Pixel(x, y, c) - Pixel(x1, y1, c);
+					deltas[i]->Pixel(x, y, c) = dx1;
+					gsum += fabs(dx1);
+				}
+			}
+	// now, reduce gradient changes
+	//  float gavg=gsum/(Width*Height);
+	for (int x = 0; x < Width; x++)
+		for (int y = 0; y < Height; y++)
+			for (int c = 0; c < 3; c++)
+			{
+				for (int i = 0; i < NDELTAS; i++)
+				{
+					float norml = 1.1 *deltas[i]->Pixel(x, y, c);
+					//		   if (norml < 0.0)
+					//			 norml=-pow(-norml,1.2);
+					//		   else
+					//			 norml=pow(norml,1.2);
+					deltas[i]->Pixel(x, y, c) = norml;
 				}
 			}
-			// now, reduce gradient changes
-			//  float gavg=gsum/(Width*Height);
-			for(int x=0;x<Width;x++)
-				for(int y=0;y<Height;y++)
-					for(int c=0;c<3;c++)
-					{
-						for(int i=0;i<NDELTAS;i++)
-						{
-							float norml=1.1*deltas[i]->Pixel(x,y,c);
-							//           if (norml<0.0)
-							//             norml=-pow(-norml,1.2);
-							//           else
-							//             norml=pow(norml,1.2);
-							deltas[i]->Pixel(x,y,c)=norml;
-						}
-					}
 
-					// now, calculate modifiability
-					for(int x=0;x<Width;x++)
-						for(int y=0;y<Height;y++)
-						{
-							float modify=0;
-							if (
-								(x>0) && (x<Width-1) &&
-								(y) && (y<Height-1))
-							{
-								modify=1;
-								Alpha(x,y)=modify;
-							}
-						}
+	// now, calculate modifiability
+	for (int x = 0; x < Width; x++)
+		for (int y = 0; y < Height; y++)
+		{
+			float modify = 0;
+			if (				(x > 0) && (x < Width - 1) &&
+				(y) && (y < Height - 1))
+			{
+				modify = 1;
+				Alpha(x, y) = modify;
+			}
+		}
 
-						Poisson(deltas,2200,0);
+	Poisson(deltas, 2200, 0);
 }
 
 
@@ -553,7 +572,9 @@ void FloatBitMap_t::MakeTileable(void)
 	// set each pixel=avg-pixel
 	FloatBitMap_t *cursrc=&rslta;
 	for(int x=1;x<Width-1;x++)
+	{
 		for(int y=1;y<Height-1;y++)
+		{
 			for(int c=0;c<3;c++)
 			{
 				DiffMapX.Pixel(x,y,c)=Pixel(x,y,c)-Pixel(x+1,y,c);
@@ -586,7 +607,9 @@ void FloatBitMap_t::MakeTileable(void)
 			{
 				float error=0.0;
 				for(int x=1;x<Width-1;x++)
+				{
 					for(int y=1;y<Height-1;y++)
+					{
 						for(int c=0;c<3;c++)
 						{
 							float desiredx=DiffMapX.Pixel(x,y,c)+cursrc->Pixel(x+1,y,c);
@@ -596,12 +619,16 @@ void FloatBitMap_t::MakeTileable(void)
 							error+=SQ(desired-cursrc->Pixel(x,y,c));
 						}
 						SWAP(cursrc,curdst);
+					}
+				}
 			}
 			// paste result
 			for(int x=0;x<Width;x++)
 				for(int y=0;y<Height;y++)
 					for(int c=0;c<3;c++)
 						Pixel(x,y,c)=curdst->Pixel(x,y,c);
+		}
+	}
 }
 
 
@@ -613,15 +640,18 @@ void FloatBitMap_t::GetAlphaBounds(int &minx, int &miny, int &maxx,int &maxy)
 		for(y=0;y<Height;y++)
 			if (Alpha(minx,y))
 				break;
+
 		if (y!=Height)
 			break;
 	}
+
 	for(maxx=Width-1;maxx>=0;maxx--)
 	{
 		int y;
 		for(y=0;y<Height;y++)
 			if (Alpha(maxx,y))
 				break;
+
 		if (y!=Height)
 			break;
 	}
@@ -631,6 +661,7 @@ void FloatBitMap_t::GetAlphaBounds(int &minx, int &miny, int &maxx,int &maxy)
 		for(x=minx;x<=maxx;x++)
 			if (Alpha(x,miny))
 				break;
+
 		if (x<maxx)
 			break;
 	}
@@ -640,6 +671,7 @@ void FloatBitMap_t::GetAlphaBounds(int &minx, int &miny, int &maxx,int &maxy)
 		for(x=minx;x<=maxx;x++)
 			if (Alpha(x,maxy))
 				break;
+
 		if (x<maxx)
 			break;
 	}
@@ -647,7 +679,7 @@ void FloatBitMap_t::GetAlphaBounds(int &minx, int &miny, int &maxx,int &maxy)
 
 void FloatBitMap_t::Poisson(FloatBitMap_t *deltas[4],
 							int n_iters,
-							uint32 flags                                  // SPF_xxx
+							uint32 flags								  // SPF_xxx
 							)
 {
 	int minx,miny,maxx,maxy;
@@ -666,9 +698,13 @@ void FloatBitMap_t::Poisson(FloatBitMap_t *deltas[4],
 		tmp->Poisson(lowdeltas,n_iters*4,flags);
 		// now, propagate results from tmp to us
 		for(int x=0;x<tmp->Width;x++)
+		{
 			for(int y=0;y<tmp->Height;y++)
+			{
 				for(int xi=0;xi<2;xi++)
+				{
 					for(int yi=0;yi<2;yi++)
+					{
 						if (Alpha(x*2+xi,y*2+yi))
 						{
 							for(int c=0;c<3;c++)
@@ -683,6 +719,10 @@ void FloatBitMap_t::Poisson(FloatBitMap_t *deltas[4],
 						delete tmp;
 						for(int i=0;i<NDELTAS;i++)
 							delete lowdeltas[i];
+					}
+				}
+			}
+		}
 	}
 	FloatBitMap_t work1(this);
 	FloatBitMap_t work2(this);
@@ -704,7 +744,7 @@ void FloatBitMap_t::Poisson(FloatBitMap_t *deltas[4],
 						for(int i=0;i<NDELTAS;i++)
 							desired+=deltas[i]->Pixel(x,y,c)+cursrc->Pixel(x+dx[i],y+dy[i],c);
 						desired*=(1.0/NDELTAS);
-						//            desired=FLerp(Pixel(x,y,c),desired,Alpha(x,y));
+						//			desired=FLerp(Pixel(x,y,c),desired,Alpha(x,y));
 						curdst->Pixel(x,y,c)=FLerp(cursrc->Pixel(x,y,c),desired,0.5);
 						error+=SQ(desired-cursrc->Pixel(x,y,c));
 					}

bitmap/float_bm4.cpp

@@ -40,7 +40,7 @@ struct SSBumpCalculationContext								// what each thread needs to see
 };
 
 
-static unsigned SSBumpCalculationThreadFN( void * ctx1 )
+static uintp SSBumpCalculationThreadFN( void * ctx1 )
 {
 	SSBumpCalculationContext *ctx = ( SSBumpCalculationContext * ) ctx1;
 

bitmap/float_bm_bilateral_filter.cpp

@@ -24,7 +24,7 @@ struct TBFCalculationContext
 	FloatBitMap_t *dest_bm;
 };
 
-static unsigned TBFCalculationThreadFN( void *ctx1 )
+static uintp TBFCalculationThreadFN( void *ctx1 )
 {
 	TBFCalculationContext *ctx = (TBFCalculationContext *) ctx1;
 	for(int y=ctx->min_y; y <= ctx->max_y; y++)

bitmap/imageformat.cpp

@@ -11,7 +11,6 @@
 #include "bitmap/imageformat.h"
 #include "basetypes.h"
 #include "tier0/dbg.h"
-#include <malloc.h>
 #include <memory.h>
 #include "nvtc.h"
 #include "mathlib/mathlib.h"

bitmap/resample.cpp

@@ -8,7 +8,6 @@
 #include "bitmap/imageformat.h"
 #include "basetypes.h"
 #include "tier0/dbg.h"
-#include <malloc.h>
 #include <memory.h>
 #include "mathlib/mathlib.h"
 #include "mathlib/vector.h"
@@ -785,6 +784,50 @@ bool ResampleRGB323232F( const ResampleInfo_t& info )
 	return true;
 }
 
+bool ResampleRGBA32323232F( const ResampleInfo_t& info )
+{
+	// HDRFIXME: This is some lame shit right here. (We need to get NICE working, etc, etc.)
+
+	// Make sure everything is power of two.
+	Assert( ( info.m_nSrcWidth & ( info.m_nSrcWidth - 1 ) ) == 0 );
+	Assert( ( info.m_nSrcHeight & ( info.m_nSrcHeight - 1 ) ) == 0 );
+	Assert( ( info.m_nDestWidth & ( info.m_nDestWidth - 1 ) ) == 0 );
+	Assert( ( info.m_nDestHeight & ( info.m_nDestHeight - 1 ) ) == 0 );
+
+	// Make sure that we aren't upscaling the image. . .we don't support that very well.
+	Assert( info.m_nSrcWidth >= info.m_nDestWidth );
+	Assert( info.m_nSrcHeight >= info.m_nDestHeight );
+
+	int nSampleWidth = info.m_nSrcWidth / info.m_nDestWidth;
+	int nSampleHeight = info.m_nSrcHeight / info.m_nDestHeight;
+
+	float *pSrc = ( float * )info.m_pSrc;
+	float *pDst = ( float * )info.m_pDest;
+	for( int y = 0; y < info.m_nDestHeight; y++ )
+	{
+		for( int x = 0; x < info.m_nDestWidth; x++ )
+		{
+			float accum[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+			for( int nSampleY = 0; nSampleY < nSampleHeight; nSampleY++ )
+			{
+				for( int nSampleX = 0; nSampleX < nSampleWidth; nSampleX++ )
+				{
+					accum[0] += pSrc[((x*nSampleWidth+nSampleX)+(y*nSampleHeight+nSampleY)*info.m_nSrcWidth)*4+0];
+					accum[1] += pSrc[((x*nSampleWidth+nSampleX)+(y*nSampleHeight+nSampleY)*info.m_nSrcWidth)*4+1];
+					accum[2] += pSrc[((x*nSampleWidth+nSampleX)+(y*nSampleHeight+nSampleY)*info.m_nSrcWidth)*4+2];
+					accum[3] += pSrc[((x*nSampleWidth+nSampleX)+(y*nSampleHeight+nSampleY)*info.m_nSrcWidth)*4+3];
+				}
+			}
+			for( int i = 0; i < 4; i++ )
+			{
+				accum[i] /= ( nSampleWidth * nSampleHeight );
+				pDst[(x+y*info.m_nDestWidth)*4+i] = accum[i];
+			}
+		}
+	}
+	return true;
+}
+
 //-----------------------------------------------------------------------------
 // Generates mipmap levels
 //-----------------------------------------------------------------------------

bitmap/tgawriter.cpp

@@ -7,7 +7,6 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include "tier0/dbg.h"
-#include <malloc.h>
 #include "filesystem.h"
 #include "bitmap/tgawriter.h"
 #include "tier1/utlbuffer.h"

bitmap/wscript

@@ -21,7 +21,6 @@ def build(bld):
 		'float_bm.cpp',
 		'float_bm2.cpp',
 		'float_bm3.cpp',
-		 #'float_bm4.cpp',	[$WINDOWS]
 		'float_bm_bilateral_filter.cpp',
 		'float_cube.cpp',
 		'imageformat.cpp',
@@ -31,6 +30,11 @@ def build(bld):
 		'tgawriter.cpp',
 		'bitmap.cpp'
 	]
+	
+	if bld.env.DEST_OS == 'win32':
+		source += [
+			'float_bm4.cpp'
+		]
 
 	includes = [
 		'.',
@@ -43,6 +47,9 @@ def build(bld):
 	defines = []
 
 	libs = []
+	
+	#if bld.env.DEST_OS == 'win32':
+	#	libs += ['NVTC', 'ATI_COMPRESS_MT_VC10']
 
 	bld.stlib(
 		source   = source,

build.sh

@@ -1,5 +0,0 @@
-#!/bin/sh
-
-# example: ./build.sh everything togl
-
-make MAKE_VERBOSE=1 NO_CHROOT=1 -f $1.mak $2 -j$(nproc --all)

common/GameUI/IGameConsole.h

@@ -33,7 +33,7 @@ public:
 	// return true if the console has focus
 	virtual bool IsConsoleVisible() = 0;
 
-	virtual void SetParent( int parent ) = 0;
+	virtual void SetParent( intp parent ) = 0;
 };
 
 #define GAMECONSOLE_INTERFACE_VERSION "GameConsole004"

common/GameUI/ObjectList.cpp

@@ -6,7 +6,11 @@
 //
 //=============================================================================//
 #include <stdio.h>
+#ifdef OSX
+#include <malloc/malloc.h>
+#else
 #include <malloc.h>
+#endif
 #include "ObjectList.h"
 #include "tier1/strtools.h"
 

common/GameUI/scriptobject.cpp

@@ -15,6 +15,7 @@
 #include "filesystem.h"
 #include "tier1/convar.h"
 #include "cdll_int.h"
+#include "vcrmode.h"
 
 // memdbgon must be the last include file in a .cpp file!!!
 #include "tier0/memdbgon.h"
@@ -1150,4 +1151,4 @@ void CInfoDescription::WriteFileHeader( FileHandle_t fp )
 	g_pFullFileSystem->FPrintf( fp, "//\r\n//\r\n// Cvar\t-\tSetting\r\n\r\n" );
 }
 
-//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------

common/ServerBrowser/blacklisted_server_manager.cpp

@@ -53,12 +53,12 @@ int CBlacklistedServerManager::LoadServersFromFile( const char *pszFilename, boo
 	{
 		const char *pszName = pData->GetString( "name" );
 
-		uint32 ulDate = pData->GetInt( "date" );
+		uint64 ullDate = pData->GetUint64( "date" );
 		if ( bResetTimes )
 		{
 			time_t today;
 			time( &today );
-			ulDate = today;
+			ullDate = (uint64)today;
 		}
 
 		const char *pszNetAddr = pData->GetString( "addr" );
@@ -68,7 +68,7 @@ int CBlacklistedServerManager::LoadServersFromFile( const char *pszFilename, boo
 
 			m_Blacklist[iIdx].m_nServerID = m_iNextServerID++;
 			V_strncpy( m_Blacklist[iIdx].m_szServerName, pszName, sizeof( m_Blacklist[iIdx].m_szServerName ) );
-			m_Blacklist[iIdx].m_ulTimeBlacklistedAt = ulDate;
+			m_Blacklist[iIdx].m_ullTimeBlacklistedAt = ullDate;
 			m_Blacklist[iIdx].m_NetAdr.SetFromString( pszNetAddr );
 
 			++count;
@@ -92,7 +92,7 @@ void CBlacklistedServerManager::SaveToFile( const char *pszFilename )
 	{
 		KeyValues *pSubKey = new KeyValues( "server" );
 		pSubKey->SetString( "name", m_Blacklist[i].m_szServerName );
-		pSubKey->SetInt( "date", m_Blacklist[i].m_ulTimeBlacklistedAt );
+		pSubKey->SetUint64( "date", m_Blacklist[i].m_ullTimeBlacklistedAt );
 		pSubKey->SetString( "addr", m_Blacklist[i].m_NetAdr.ToString() );
 		pKV->AddSubKey( pSubKey );
 	}
@@ -120,7 +120,7 @@ blacklisted_server_t *CBlacklistedServerManager::AddServer( gameserveritem_t &se
 
 	time_t today;
 	time( &today );
-	m_Blacklist[iIdx].m_ulTimeBlacklistedAt = today;
+	m_Blacklist[iIdx].m_ullTimeBlacklistedAt = (uint64)today;
 	m_Blacklist[iIdx].m_NetAdr = netAdr;
 	m_Blacklist[iIdx].m_nServerID = m_iNextServerID++;
 
@@ -145,7 +145,7 @@ blacklisted_server_t *CBlacklistedServerManager::AddServer( const char *serverNa
 
 	time_t today;
 	time( &today );
-	m_Blacklist[iIdx].m_ulTimeBlacklistedAt = today;
+	m_Blacklist[iIdx].m_ullTimeBlacklistedAt = (uint64)today;
 
 	m_Blacklist[iIdx].m_NetAdr = netAdr;
 	m_Blacklist[iIdx].m_nServerID = m_iNextServerID++;
@@ -157,7 +157,7 @@ blacklisted_server_t *CBlacklistedServerManager::AddServer( const char *serverNa
 //-----------------------------------------------------------------------------
 // Purpose: Add the given server to the blacklist. Return added server.
 //-----------------------------------------------------------------------------
-blacklisted_server_t *CBlacklistedServerManager::AddServer( const char *serverName, const char *netAddressString, uint32 timestamp )
+blacklisted_server_t *CBlacklistedServerManager::AddServer( const char *serverName, const char *netAddressString, uint64 timestamp )
 {
 	netadr_t netAdr( netAddressString );
 
@@ -168,7 +168,7 @@ blacklisted_server_t *CBlacklistedServerManager::AddServer( const char *serverNa
 	int iIdx = m_Blacklist.AddToTail();
 
 	V_strncpy( m_Blacklist[iIdx].m_szServerName, serverName, sizeof( m_Blacklist[iIdx].m_szServerName ) );
-	m_Blacklist[iIdx].m_ulTimeBlacklistedAt = timestamp;
+	m_Blacklist[iIdx].m_ullTimeBlacklistedAt = timestamp;
 	m_Blacklist[iIdx].m_NetAdr = netAdr;
 	m_Blacklist[iIdx].m_nServerID = m_iNextServerID++;
 

common/ServerBrowser/blacklisted_server_manager.h

@@ -23,7 +23,7 @@ struct blacklisted_server_t
 {
 	int m_nServerID;
 	char m_szServerName[64];
-	uint32 m_ulTimeBlacklistedAt;
+	uint64 m_ullTimeBlacklistedAt;
 	netadr_t m_NetAdr;
 };
 
@@ -40,7 +40,7 @@ public:
 
 	blacklisted_server_t *AddServer( gameserveritem_t &server );
 	blacklisted_server_t *AddServer( const char *serverName, uint32 serverIP, int serverPort );
-	blacklisted_server_t *AddServer( const char *serverName, const char *netAddressString, uint32 timestamp );
+	blacklisted_server_t *AddServer( const char *serverName, const char *netAddressString, uint64 timestamp );
 
 	void RemoveServer( int iServerID );		// remove server with matching 'server id' from list
 

common/engine/idownloadsystem.h

@@ -32,7 +32,7 @@ struct RequestContext_t;
 class IDownloadSystem : public IBaseInterface
 {
 public:
-	virtual DWORD CreateDownloadThread( RequestContext_t *pContext ) = 0;
+	virtual uintp CreateDownloadThread( RequestContext_t *pContext ) = 0;
 };
 
 //----------------------------------------------------------------------------------------

common/freetype/config/ftconfig.h

@@ -3,6 +3,8 @@
 
 #ifdef ANDROID
 #include <sys/cdefs.h>
+#elif defined(OSX) || defined(PLATFORM_BSD)
+#include <stdint.h>
 #else
 #include <bits/wordsize.h>
 #endif

common/imageutils.cpp

@@ -54,6 +54,8 @@ extern void longjmp( jmp_buf, int ) __attribute__((noreturn));
 	extern IEngineReplay *g_pEngine;
 #elif ENGINE_DLL
 	#include "EngineInterface.h"
+#elif UTILS
+	// OwO
 #else
 	#include "cdll_int.h"
 	extern IVEngineClient *engine;
@@ -61,10 +63,23 @@ extern void longjmp( jmp_buf, int ) __attribute__((noreturn));
 
 // use the JPEGLIB_USE_STDIO define so that we can read in jpeg's from outside the game directory tree.
 #define JPEGLIB_USE_STDIO
+#if ANDROID
+#include "android/jpeglib/jpeglib.h"
+#else
 #include "jpeglib/jpeglib.h"
+#endif
 #undef JPEGLIB_USE_STDIO
 
+
+#if HAVE_PNG
+
+#if ANDROID || WIN32
 #include "libpng/png.h"
+#else
+#include <png.h>
+#endif
+
+#endif
 
 #include <setjmp.h>
 
@@ -93,6 +108,8 @@ extern void longjmp( jmp_buf, int ) __attribute__((noreturn));
 //-----------------------------------------------------------------------------
 // Purpose: 
 //-----------------------------------------------------------------------------
+#if HAVE_JPEG
+
 struct ValveJpegErrorHandler_t 
 {
 	// The default manager
@@ -129,12 +146,12 @@ static void ValveJpegErrorHandler( j_common_ptr cinfo )
 	// Bail
 	longjmp( pError->m_ErrorContext, 1 );
 }
-
+#endif
 
 // convert the JPEG file given to a TGA file at the given output path.
 ConversionErrorType ImgUtl_ConvertJPEGToTGA( const char *jpegpath, const char *tgaPath, bool bRequirePowerOfTwo )
 {
-#if !defined( _X360 )
+#if !defined( _X360 ) && HAVE_JPEG
 
 	//
 	// !FIXME! This really probably should use ImgUtl_ReadJPEGAsRGBA, to avoid duplicated code.
@@ -485,7 +502,7 @@ unsigned char * ImgUtl_ReadTGAAsRGBA(const char *tgaPath, int &width, int &heigh
 
 unsigned char *ImgUtl_ReadJPEGAsRGBA( const char *jpegPath, int &width, int &height, ConversionErrorType &errcode )
 {
-#if !defined( _X360 )
+#if !defined( _X360 ) && HAVE_JPEG
 	struct jpeg_decompress_struct jpegInfo;
 	struct ValveJpegErrorHandler_t jerr;
 	JSAMPROW row_pointer[1];
@@ -636,6 +653,7 @@ unsigned char *ImgUtl_ReadJPEGAsRGBA( const char *jpegPath, int &width, int &hei
 #endif
 }
 
+#if HAVE_PNG
 static void ReadPNGData( png_structp png_ptr, png_bytep outBytes, png_size_t byteCountToRead )
 {
 
@@ -654,19 +672,37 @@ static void ReadPNGData( png_structp png_ptr, png_bytep outBytes, png_size_t byt
 	// Read the bytes
 	pBuf->Get( outBytes, byteCountToRead );
 }
-
+#endif
 
 unsigned char *ImgUtl_ReadPNGAsRGBA( const char *pngPath, int &width, int &height, ConversionErrorType &errcode )
 {
-#if !defined( _X360 )
+#if !defined( _X360 ) && HAVE_PNG
 
 	// Just load the whole file into a memory buffer
 	CUtlBuffer bufFileContents;
+
+#if UTILS
+	static char buf[8192];
+	FILE *readfile = fopen(pngPath, "rb");
+	if( !readfile )
+	{
+		errcode = CE_CANT_OPEN_SOURCE_FILE;
+		return NULL;
+	}
+
+	size_t size;
+	while( ( size = fread(buf, 1, sizeof(buf), readfile ) ) > 0 )
+		bufFileContents.Put( buf, size );
+
+	// Load it
+	return ImgUtl_ReadPNGAsRGBAFromBuffer( bufFileContents, width, height, errcode );
+#else
 	if ( !g_pFullFileSystem->ReadFile( pngPath, NULL, bufFileContents ) )
 	{
 		errcode = CE_CANT_OPEN_SOURCE_FILE;
 		return NULL;
 	}
+#endif
 
 	// Load it
 	return ImgUtl_ReadPNGAsRGBAFromBuffer( bufFileContents, width, height, errcode );
@@ -679,7 +715,7 @@ unsigned char *ImgUtl_ReadPNGAsRGBA( const char *pngPath, int &width, int &heigh
 
 unsigned char		*ImgUtl_ReadPNGAsRGBAFromBuffer( CUtlBuffer &buffer, int &width, int &height, ConversionErrorType &errcode )
 {
-#if !defined( _X360 )
+#if !defined( _X360 ) && HAVE_PNG
 
 	png_const_bytep pngData = (png_const_bytep)buffer.Base();
 	if (png_sig_cmp( pngData, 0, 8))
@@ -1470,7 +1506,7 @@ ConversionErrorType ImgUtl_ConvertTGAToVTF(const char *tgaPath, int nMaxWidth/*=
 	inbuf.SeekPut( CUtlBuffer::SEEK_HEAD, nBytesRead );
 
 	// load vtex_dll.dll and get the interface to it.
-	CSysModule *vtexmod = Sys_LoadModule("vtex_dll");
+	CSysModule *vtexmod = Sys_LoadModule("vtex_dll" DLL_EXT_STRING);
 	if (vtexmod == NULL)
 	{
 		Msg( "Failed to open TGA conversion module vtex_dll: %s\n", tgaPath);
@@ -1519,6 +1555,17 @@ static void DoCopyFile( const char *source, const char *destination )
 	::COM_CopyFile( source, destination );
 #elif REPLAY_DLL
 	g_pEngine->CopyFile( source, destination );
+#elif UTILS
+	static char buf[16384];
+	FILE *readfile = fopen(source, "rb");
+	FILE *writefile = fopen(destination, "wb");
+
+	size_t size = 0;
+	while( (size = fread(buf, sizeof(buf), 1, readfile)) != 0 )
+		fwrite(buf, size, 1, writefile);
+
+	fclose(readfile);
+	fclose(writefile);
 #else
 	engine->CopyLocalFile( source, destination );
 #endif
@@ -1709,12 +1756,12 @@ ConversionErrorType	ImgUtl_ConvertToVTFAndDumpVMT( const char *pInPath, const ch
 		Q_strncpy(finalPath, com_gamedir, sizeof(finalPath));
 #elif REPLAY_DLL
 		Q_strncpy(finalPath, g_pEngine->GetGameDir(), sizeof(finalPath));
-#else
+#elif !UTILS
 		Q_strncpy(finalPath, engine->GetGameDirectory(), sizeof(finalPath));
 #endif
 		Q_strncat(finalPath, szOutDir, sizeof(finalPath), COPY_ALL_CHARACTERS);
 		Q_strncat(finalPath, vtfFilename, sizeof(finalPath), COPY_ALL_CHARACTERS);
-	
+
 		c = finalPath + strlen(finalPath);
 		while ((c > finalPath) && (*(c-1) != '.'))
 		{
@@ -1826,6 +1873,7 @@ ConversionErrorType ImgUtl_WriteGenericVMT( const char *vtfPath, const char *pMa
 	return CE_SUCCESS;
 }
 
+#if HAVE_PNG
 static void WritePNGData( png_structp png_ptr, png_bytep inBytes, png_size_t byteCountToWrite )
 {
 
@@ -1927,11 +1975,13 @@ fail:
 	return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED;
 #endif
 }
+#endif
 
 //-----------------------------------------------------------------------------
 // Purpose:  Initialize destination --- called by jpeg_start_compress
 //  before any data is actually written.
 //-----------------------------------------------------------------------------
+#if HAVE_JPEG
 METHODDEF(void) init_destination (j_compress_ptr cinfo)
 {
 	JPEGDestinationManager_t *dest = ( JPEGDestinationManager_t *) cinfo->dest;
@@ -2012,12 +2062,14 @@ GLOBAL(void) jpeg_UtlBuffer_dest (j_compress_ptr cinfo, CUtlBuffer *pBuffer )
     dest->pub.term_destination      = term_destination;
     dest->pBuffer                   = pBuffer;
 }
+#endif
 
 //-----------------------------------------------------------------------------
 // Purpose: Write three channel RGB data to a JPEG file
 //-----------------------------------------------------------------------------
 bool ImgUtl_WriteRGBToJPEG( unsigned char *pSrcBuf, unsigned int nSrcWidth, unsigned int nSrcHeight, const char *lpszFilename )
 {
+#if HAVE_JPEG
 	CUtlBuffer dstBuf;
 
 	JSAMPROW row_pointer[1];     // pointer to JSAMPLE row[s]
@@ -2067,13 +2119,16 @@ bool ImgUtl_WriteRGBToJPEG( unsigned char *pSrcBuf, unsigned int nSrcWidth, unsi
 
 	// Cleanup
 	jpeg_destroy_compress(&cinfo);
-	
+
 	return CE_SUCCESS;
+#else
+	return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED;
+#endif
 }
 
 ConversionErrorType ImgUtl_WriteRGBAAsJPEGToBuffer( const unsigned char *pRGBAData, int nWidth, int nHeight, CUtlBuffer &bufOutData, int nStride )
 {
-#if !defined( _X360 )
+#if !defined( _X360 ) && HAVE_JPEG
 
 	JSAMPROW row_pointer[1];     // pointer to JSAMPLE row[s]
 	int row_stride;              // physical row width in image buffer
@@ -2214,6 +2269,7 @@ ConversionErrorType ImgUtl_SaveBitmapToBuffer( CUtlBuffer &fileData, const Bitma
 
 ConversionErrorType ImgUtl_LoadPNGBitmapFromBuffer( CUtlBuffer &fileData, Bitmap_t &bitmap )
 {
+#if HAVE_PNG
 	bitmap.Clear();
 	ConversionErrorType nErrorCode;
 	int width, height;
@@ -2226,10 +2282,14 @@ ConversionErrorType ImgUtl_LoadPNGBitmapFromBuffer( CUtlBuffer &fileData, Bitmap
 	// Install the buffer into the bitmap, and transfer ownership
 	bitmap.SetBuffer( width, height, IMAGE_FORMAT_RGBA8888, buffer, true, width*4 );
 	return CE_SUCCESS;
+#else
+	return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED;
+#endif
 }
 
 ConversionErrorType ImgUtl_SavePNGBitmapToBuffer( CUtlBuffer &fileData, const Bitmap_t &bitmap )
 {
+#if HAVE_PNG
 	if ( !bitmap.IsValid() )
 	{
 		Assert( bitmap.IsValid() );
@@ -2252,6 +2312,9 @@ ConversionErrorType ImgUtl_SavePNGBitmapToBuffer( CUtlBuffer &fileData, const Bi
 		bitmap.Stride()
 	);
 	return result;
+#else
+	return CE_SOURCE_FILE_FORMAT_NOT_SUPPORTED;
+#endif
 }
 
 ConversionErrorType ImgUtl_ResizeBitmap( Bitmap_t &destBitmap, int nWidth, int nHeight, const Bitmap_t *pImgSource )

common/openal/alc.h

@@ -22,7 +22,7 @@ extern "C" {
  #define ALC_APIENTRY
 #endif
 
-#if TARGET_OS_MAC
+#if defined(TARGET_OS_MAC) && TARGET_OS_MAC
  #pragma export on
 #endif
 
@@ -279,7 +279,7 @@ typedef void           (ALC_APIENTRY *LPALCCAPTURESAMPLES)( ALCdevice *device, A
 
 #endif /* ALC_NO_PROTOTYPES */
 
-#if TARGET_OS_MAC
+#if defined(TARGET_OS_MAC) && TARGET_OS_MAC
  #pragma export off
 #endif
 

common/studiobyteswap.cpp

@@ -16,10 +16,10 @@
 #undef ALIGN4
 #undef ALIGN16
 #undef ALIGN32
-#define ALIGN4( a ) a = (byte *)((int)((byte *)a + 3) & ~ 3)
-#define ALIGN16( a ) a = (byte *)((int)((byte *)a + 15) & ~ 15)
-#define ALIGN32( a ) a = (byte *)((int)((byte *)a + 31) & ~ 31)
-#define ALIGN64( a ) a = (byte *)((int)((byte *)a + 63) & ~ 63)
+#define ALIGN4( a ) a = (byte *)((intp)((byte *)a + 3) & ~ 3)
+#define ALIGN16( a ) a = (byte *)((intp)((byte *)a + 15) & ~ 15)
+#define ALIGN32( a ) a = (byte *)((intp)((byte *)a + 31) & ~ 31)
+#define ALIGN64( a ) a = (byte *)((intp)((byte *)a + 63) & ~ 63)
 
 // Fixup macros create variables that may not be referenced
 #pragma warning( push )
@@ -1228,8 +1228,8 @@ int ByteswapANI( studiohdr_t* pHdr, void *pDestBase, const void *pSrcBase, const
 		V_memcpy( pNewDest, pDestBase, pAnimBlock->datastart );
 		pNewDest += pAnimBlock->datastart;
 
-		int padding = AlignValue( (unsigned int)pNewDest - (unsigned int)pNewDestBase, 2048 );
-		padding -= (unsigned int)pNewDest - (unsigned int)pNewDestBase;
+		int padding = AlignValue( (uintp)pNewDest - (uintp)pNewDestBase, 2048 );
+		padding -= (uintp)pNewDest - (uintp)pNewDestBase;
 		pNewDest += padding;
 
 		// iterate and compress anim blocks
@@ -1240,7 +1240,7 @@ int ByteswapANI( studiohdr_t* pHdr, void *pDestBase, const void *pSrcBase, const
 			void *pInput = (byte *)pDestBase + pAnimBlock->datastart;
 			int inputSize = pAnimBlock->dataend - pAnimBlock->datastart;
 
-			pAnimBlock->datastart = (unsigned int)pNewDest - (unsigned int)pNewDestBase;
+			pAnimBlock->datastart = (uintp)pNewDest - (uintp)pNewDestBase;
 
 			void *pOutput;
 			int outputSize;
@@ -1257,11 +1257,11 @@ int ByteswapANI( studiohdr_t* pHdr, void *pDestBase, const void *pSrcBase, const
 				pNewDest += inputSize;
 			}
 
-			padding = AlignValue( (unsigned int)pNewDest - (unsigned int)pNewDestBase, 2048 );
-			padding -= (unsigned int)pNewDest - (unsigned int)pNewDestBase;
+			padding = AlignValue( (uintp)pNewDest - (uintp)pNewDestBase, 2048 );
+			padding -= (uintp)pNewDest - (uintp)pNewDestBase;
 			pNewDest += padding;
 
-			pAnimBlock->dataend = (unsigned int)pNewDest - (unsigned int)pNewDestBase;
+			pAnimBlock->dataend = (uintp)pNewDest - (uintp)pNewDestBase;
 		}
 
 		fixedFileSize = pNewDest - pNewDestBase;
@@ -2522,14 +2522,14 @@ BEGIN_BYTESWAP_DATADESC( studiohdr_t )
 	DEFINE_FIELD( contents, FIELD_INTEGER ),
 	DEFINE_FIELD( numincludemodels, FIELD_INTEGER ),
 	DEFINE_INDEX( includemodelindex, FIELD_INTEGER ),
-	DEFINE_FIELD( virtualModel, FIELD_INTEGER ),				// void*
+	DEFINE_FIELD( unused_virtualModel, FIELD_INTEGER ),				// void*
 	DEFINE_INDEX( szanimblocknameindex, FIELD_INTEGER ),	
 	DEFINE_FIELD( numanimblocks, FIELD_INTEGER ),
 	DEFINE_INDEX( animblockindex, FIELD_INTEGER ),
-	DEFINE_FIELD( animblockModel, FIELD_INTEGER ),				// void*
+	DEFINE_FIELD( unused_animblockModel, FIELD_INTEGER ),				// void*
 	DEFINE_INDEX( bonetablebynameindex, FIELD_INTEGER ),
-	DEFINE_FIELD( pVertexBase, FIELD_INTEGER ),					// void*
-	DEFINE_FIELD( pIndexBase, FIELD_INTEGER ),					// void*
+	DEFINE_FIELD( unused_pVertexBase, FIELD_INTEGER ),					// void*
+	DEFINE_FIELD( unused_pIndexBase, FIELD_INTEGER ),					// void*
 	DEFINE_FIELD( constdirectionallightdot, FIELD_CHARACTER ),	// byte
 	DEFINE_FIELD( rootLOD, FIELD_CHARACTER ),					// byte
 	DEFINE_FIELD( numAllowedRootLODs, FIELD_CHARACTER ),		// byte
@@ -2985,7 +2985,11 @@ BEGIN_BYTESWAP_DATADESC( mstudiomesh_t )
 END_BYTESWAP_DATADESC()
 
 BEGIN_BYTESWAP_DATADESC( mstudio_meshvertexdata_t )
+#ifdef PLATFORM_64BITS
+	DEFINE_FIELD( index_ptr_modelvertexdata, FIELD_INTEGER ),	// mstudio_modelvertexdata_t*
+#else
 	DEFINE_FIELD( modelvertexdata, FIELD_INTEGER ),	// mstudio_modelvertexdata_t*
+#endif
 	DEFINE_ARRAY( numLODVertexes, FIELD_INTEGER, MAX_NUM_LODS ),
 END_BYTESWAP_DATADESC()
 

common/vgui_surfacelib/FontManager.h

@@ -17,7 +17,7 @@
 #include "filesystem.h"
 #include "vguifont.h"
 
-#ifdef LINUX
+#ifdef POSIX
 #include <ft2build.h>
 #include FT_FREETYPE_H
 typedef void *(*FontDataHelper)( const char *pchFontName, int &size, const char *fontFileName );
@@ -71,7 +71,7 @@ public:
 	IFileSystem *FileSystem() { return m_pFileSystem; }
 	IMaterialSystem *MaterialSystem() { return m_pMaterialSystem; }
 
-#ifdef LINUX
+#ifdef POSIX
 	FT_Library GetFontLibraryHandle() { return library; }
 	void SetFontDataHelper( FontDataHelper helper ) { m_pFontDataHelper = helper; }
 #endif
@@ -96,7 +96,7 @@ private:
 	CUtlVector<CFontAmalgam> m_FontAmalgams;
 	CUtlVector<font_t *> m_Win32Fonts;
 
-#ifdef LINUX
+#ifdef POSIX
 	FT_Library library; 
 	FontDataHelper m_pFontDataHelper;
 #endif

common/vgui_surfacelib/vguifont.h

@@ -23,10 +23,7 @@ struct newChar_t
 #ifdef WIN32
 #include "Win32Font.h"
 typedef CWin32Font font_t;
-#elif defined(OSX)
-#include "osxfont.h"
-typedef COSXFont font_t;
-#elif defined(LINUX)
+#elif defined(POSIX)
 #include "linuxfont.h"
 typedef CLinuxFont font_t;
 #else
@@ -34,4 +31,4 @@ typedef CLinuxFont font_t;
 #endif
 
 
-#endif //VGUIFONT_H 
+#endif //VGUIFONT_H 

createallprojects

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-pushd `dirname $0`
-devtools/bin/vpc /f /hl2 +everything /mksln everything
-popd

createallprojects.bat

@@ -1 +0,0 @@
-devtools\bin\vpc.exe /2013 +everything /mksln everything.sln

datacache/datacache.h

@@ -39,7 +39,7 @@ struct DataCacheItemData_t
 
 //-------------------------------------
 
-#define DC_NO_NEXT_LOCKED ((DataCacheItem_t *)0xffffffff)
+#define DC_NO_NEXT_LOCKED ((DataCacheItem_t *)-1)
 #define DC_MAX_THREADS_FRAMELOCKED 4
 
 struct DataCacheItem_t : DataCacheItemData_t
@@ -181,10 +181,9 @@ private:
 		DataCacheItem_t *m_pFirst;
 		int				m_iThread;
 	};
-	typedef CThreadLocal<FrameLock_t *> CThreadFrameLock;
 
 	CDataCacheLRU &		m_LRU;
-	CThreadFrameLock	m_ThreadFrameLock;
+	CTHREADLOCAL(FrameLock_t*)	m_ThreadFrameLock;
 	DataCacheStatus_t	m_status;
 	DataCacheLimits_t	m_limits;
 	IDataCacheClient *	m_pClient;
@@ -381,4 +380,4 @@ inline void CDataCacheSection::NoteUnlock( int size )
 
 //-----------------------------------------------------------------------------
 
-#endif // DATACACHE_H
+#endif // DATACACHE_H

datacache/datacache.vpc

@@ -5,7 +5,7 @@
 //-----------------------------------------------------------------------------
 
 $macro SRCDIR		".."
-$Macro OUTBINDIR	"$LIBPUBLIC"
+$Macro OUTBINDIR	"$SRCDIR\..\game\bin"
 
 $include "$SRCDIR\vpc_scripts\source_dll_base.vpc"
 

datacache/mdlcache.cpp

@@ -126,7 +126,7 @@ struct studiodata_t
 	// array of cache handles to demand loaded virtual model data
 	int					m_nAnimBlockCount;
 	DataCacheHandle_t	*m_pAnimBlock;
-	unsigned long	 	*m_iFakeAnimBlockStall;
+	unsigned int	 	*m_iFakeAnimBlockStall;
 
 	// vertex data is usually compressed to save memory (model decal code only needs some data)
 	DataCacheHandle_t	m_VertexCache;
@@ -235,11 +235,11 @@ struct AsyncInfo_t
 	int					iAnimBlock;
 };
 
-const int NO_ASYNC = CUtlLinkedList< AsyncInfo_t >::InvalidIndex();
+const intp NO_ASYNC = CUtlFixedLinkedList< AsyncInfo_t >::InvalidIndex();
 
 //-------------------------------------
 
-CUtlMap<int, int> g_AsyncInfoMap( DefLessFunc( int ) );
+CUtlMap<int, intp> g_AsyncInfoMap( DefLessFunc( int ) );
 CThreadFastMutex g_AsyncInfoMapMutex;
 
 inline int MakeAsyncInfoKey( MDLHandle_t hModel, MDLCacheDataType_t type, int iAnimBlock )
@@ -248,7 +248,7 @@ inline int MakeAsyncInfoKey( MDLHandle_t hModel, MDLCacheDataType_t type, int iA
 	return ( ( ( (int)hModel) << 16 ) | ( (int)type << 13 ) | iAnimBlock );
 }
 
-inline int GetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, int iAnimBlock = 0 )
+inline intp GetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, int iAnimBlock = 0 )
 {
 	AUTO_LOCK( g_AsyncInfoMapMutex );
 	int key = MakeAsyncInfoKey( hModel, type, iAnimBlock );
@@ -260,7 +260,7 @@ inline int GetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, int i
 	return g_AsyncInfoMap[i];
 }
 
-inline int SetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, int iAnimBlock, int index )
+inline intp SetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, int iAnimBlock, intp index )
 {
 	AUTO_LOCK( g_AsyncInfoMapMutex );
 	Assert( index == NO_ASYNC || GetAsyncInfoIndex( hModel, type, iAnimBlock ) == NO_ASYNC );
@@ -277,7 +277,7 @@ inline int SetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, int i
 	return index;
 }
 
-inline int SetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, int index )
+inline intp SetAsyncInfoIndex( MDLHandle_t hModel, MDLCacheDataType_t type, intp index )
 {
 	return SetAsyncInfoIndex( hModel, type, 0, index );
 }
@@ -507,7 +507,7 @@ private:
 	bool BuildHardwareData( MDLHandle_t handle, studiodata_t *pStudioData, studiohdr_t *pStudioHdr, OptimizedModel::FileHeader_t *pVtxHdr );
 	void ConvertFlexData( studiohdr_t *pStudioHdr );
 
-	int ProcessPendingAsync( int iAsync );
+	int ProcessPendingAsync( intp iAsync );
 	void ProcessPendingAsyncs( MDLCacheDataType_t type = MDLCACHE_NONE );
 	bool ClearAsync( MDLHandle_t handle, MDLCacheDataType_t type, int iAnimBlock, bool bAbort = false );
 
@@ -523,7 +523,7 @@ private:
 	int UpdateOrCreate( studiohdr_t *pHdr, const char *pFilename, char *pX360Filename, int maxLen, const char *pPathID, bool bForce = false );
 
 	// Attempts to read the platform native file - on 360 it can read and swap Win32 file as a fallback
-	bool ReadFileNative( char *pFileName, const char *pPath, CUtlBuffer &buf, int nMaxBytes = 0 );
+	bool ReadFileNative( char *pFileName, const char *pPath, CUtlBuffer &buf, int nMaxBytes = 0, MDLCacheDataType_t type = MDLCACHE_NONE );
 
 	// Creates a thin cache entry (to be used for model decals) from fat vertex data
 	vertexFileHeader_t * CreateThinVertexes( vertexFileHeader_t * originalData, const studiohdr_t * pStudioHdr, int * cacheLength );
@@ -879,7 +879,7 @@ void CMDLCache::SetCacheNotify( IMDLCacheNotify *pNotify )
 //-----------------------------------------------------------------------------
 const char *CMDLCache::GetModelName( MDLHandle_t handle )
 {
-	if ( handle == MDLHANDLE_INVALID )
+	if ( handle == MDLHANDLE_INVALID  )
 		return ERROR_MODEL;
 
 	return m_MDLDict.GetElementName( handle );
@@ -909,7 +909,7 @@ void CMDLCache::MakeFilename( MDLHandle_t handle, const char *pszExtension, char
 	Q_strncpy( pszFileName, GetActualModelName( handle ), nMaxLength );
 	Q_SetExtension( pszFileName, pszExtension, nMaxLength );
 	Q_FixSlashes( pszFileName );
-#ifdef _LINUX
+#ifdef POSIX
 	Q_strlower( pszFileName );
 #endif
 }
@@ -1004,7 +1004,7 @@ void CMDLCache::UnserializeVCollide( MDLHandle_t handle, bool synchronousLoad )
 	// FIXME: Should the vcollde be played into cacheable memory?
 	studiodata_t *pStudioData = m_MDLDict[handle];
 
-	int iAsync = GetAsyncInfoIndex( handle, MDLCACHE_VCOLLIDE );
+	intp iAsync = GetAsyncInfoIndex( handle, MDLCACHE_VCOLLIDE );
 
 	if ( iAsync == NO_ASYNC )
 	{
@@ -1025,7 +1025,7 @@ void CMDLCache::UnserializeVCollide( MDLHandle_t handle, bool synchronousLoad )
 			{
 				for ( int i = 1; i < pVirtualModel->m_group.Count(); i++ )
 				{
-					MDLHandle_t sharedHandle = (MDLHandle_t) (int)pVirtualModel->m_group[i].cache & 0xffff;
+					MDLHandle_t sharedHandle = VoidPtrToMDLHandle(pVirtualModel->m_group[i].cache);
 					studiodata_t *pData = m_MDLDict[sharedHandle];
 					if ( !(pData->m_nFlags & STUDIODATA_FLAGS_VCOLLISION_LOADED) )
 					{
@@ -1169,8 +1169,8 @@ void CMDLCache::AllocateAnimBlocks( studiodata_t *pStudioData, int nCount )
 
 	memset( pStudioData->m_pAnimBlock, 0, sizeof(DataCacheHandle_t) * pStudioData->m_nAnimBlockCount );
 
-	pStudioData->m_iFakeAnimBlockStall = new unsigned long [pStudioData->m_nAnimBlockCount];
-	memset( pStudioData->m_iFakeAnimBlockStall, 0, sizeof( unsigned long ) * pStudioData->m_nAnimBlockCount );
+	pStudioData->m_iFakeAnimBlockStall = new unsigned int [pStudioData->m_nAnimBlockCount];
+	memset( pStudioData->m_iFakeAnimBlockStall, 0, sizeof( unsigned int ) * pStudioData->m_nAnimBlockCount );
 }
 
 void CMDLCache::FreeAnimBlocks( MDLHandle_t handle )
@@ -1219,7 +1219,7 @@ unsigned char *CMDLCache::UnserializeAnimBlock( MDLHandle_t handle, int nBlock )
 
 	studiodata_t *pStudioData = m_MDLDict[handle];
 
-	int iAsync = GetAsyncInfoIndex( handle, MDLCACHE_ANIMBLOCK, nBlock );
+	intp iAsync = GetAsyncInfoIndex( handle, MDLCACHE_ANIMBLOCK, nBlock );
 
 	if ( iAsync == NO_ASYNC )
 	{
@@ -1238,7 +1238,7 @@ unsigned char *CMDLCache::UnserializeAnimBlock( MDLHandle_t handle, int nBlock )
 		char pFileName[MAX_PATH];
 		Q_strncpy( pFileName, pModelName, sizeof(pFileName) );
 		Q_FixSlashes( pFileName );
-#ifdef _LINUX
+#ifdef POSIX
 		Q_strlower( pFileName );
 #endif
 		if ( IsX360() )
@@ -1398,12 +1398,12 @@ void CMDLCache::FreeVirtualModel( MDLHandle_t handle )
 	if ( pStudioData && pStudioData->m_pVirtualModel )
 	{
 		int nGroupCount = pStudioData->m_pVirtualModel->m_group.Count();
-		Assert( (nGroupCount >= 1) && pStudioData->m_pVirtualModel->m_group[0].cache == (void*)(uintp)handle );
+		Assert( (nGroupCount >= 1) && pStudioData->m_pVirtualModel->m_group[0].cache == MDLHandleToVirtual(handle) );
 
 		// NOTE: Start at *1* here because the 0th element contains a reference to *this* handle
 		for ( int i = 1; i < nGroupCount; ++i )
 		{
-			MDLHandle_t h = (MDLHandle_t)(int)pStudioData->m_pVirtualModel->m_group[i].cache&0xffff;
+			MDLHandle_t h = VoidPtrToMDLHandle( pStudioData->m_pVirtualModel->m_group[i].cache );
 			FreeVirtualModel( h );
 			Release( h );
 		}
@@ -1453,7 +1453,7 @@ virtualmodel_t *CMDLCache::GetVirtualModelFast( const studiohdr_t *pStudioHdr, M
 		// Group has to be zero to ensure refcounting is correct
 		int nGroup = pStudioData->m_pVirtualModel->m_group.AddToTail( );
 		Assert( nGroup == 0 );
-		pStudioData->m_pVirtualModel->m_group[nGroup].cache = (void *)(uintp)handle;
+		pStudioData->m_pVirtualModel->m_group[nGroup].cache = MDLHandleToVirtual(handle);
 
 		// Add all dependent data
 		pStudioData->m_pVirtualModel->AppendModels( 0, pStudioHdr );
@@ -1550,7 +1550,7 @@ bool CMDLCache::LoadHardwareData( MDLHandle_t handle )
 		return false;
 	}
 
-	int iAsync = GetAsyncInfoIndex( handle, MDLCACHE_STUDIOHWDATA );
+	intp iAsync = GetAsyncInfoIndex( handle, MDLCACHE_STUDIOHWDATA );
 
 	if ( iAsync == NO_ASYNC )
 	{
@@ -1680,6 +1680,36 @@ bool CMDLCache::BuildHardwareData( MDLHandle_t handle, studiodata_t *pStudioData
 
 	Assert( GetVertexData( handle ) );
 
+	if( pStudioHdr->version == 49 )
+	{
+		for( int i = 0; i < pVtxHdr->numBodyParts; i++)
+		{
+			OptimizedModel::BodyPartHeader_t *pBodyPartHdr = pVtxHdr->pBodyPart(i);
+
+			for( int j = 0; j < pBodyPartHdr->numModels; j++ )
+			{
+				OptimizedModel::ModelHeader_t *pModelHdr = pBodyPartHdr->pModel(j);
+
+				for( int k = 0; k < pModelHdr->numLODs; k++)
+				{
+					OptimizedModel::ModelLODHeader_t *pModelLODHdr = pModelHdr->pLOD(k);
+
+					for( int l = 0; l < pModelLODHdr->numMeshes; l++ )
+					{
+						OptimizedModel::MeshHeader_t *pMeshHdr = pModelLODHdr->pMesh(l);
+						pMeshHdr->flags |= OptimizedModel::MESH_IS_MDL49;
+
+						for( int m = 0; m < pMeshHdr->numStripGroups; m++ )
+						{
+							OptimizedModel::StripGroupHeader_t *pStripGroupHdr = pMeshHdr->pStripGroup(m);
+							pStripGroupHdr->flags |= OptimizedModel::STRIPGROUP_IS_MDL49;
+						}
+					}
+				}
+			}
+		}
+	}
+
 	BeginLock();
 	bool bLoaded = g_pStudioRender->LoadModel( pStudioHdr, pVtxHdr, &pStudioData->m_HardwareData );
 	EndLock();
@@ -1910,7 +1940,7 @@ int CMDLCache::UpdateOrCreate( studiohdr_t *pHdr, const char *pSourceName, char
 //-----------------------------------------------------------------------------
 // Purpose: Attempts to read a file native to the current platform
 //-----------------------------------------------------------------------------
-bool CMDLCache::ReadFileNative( char *pFileName, const char *pPath, CUtlBuffer &buf, int nMaxBytes )
+bool CMDLCache::ReadFileNative( char *pFileName, const char *pPath, CUtlBuffer &buf, int nMaxBytes, MDLCacheDataType_t type )
 {
 	bool bOk = false;
 
@@ -1925,6 +1955,32 @@ bool CMDLCache::ReadFileNative( char *pFileName, const char *pPath, CUtlBuffer &
 	{
 		// Read the PC version
 		bOk = g_pFullFileSystem->ReadFile( pFileName, pPath, buf, nMaxBytes );
+
+		if( bOk && type == MDLCACHE_STUDIOHDR )
+		{
+			studiohdr_t* pStudioHdr = ( studiohdr_t* ) buf.PeekGet();
+
+			if ( pStudioHdr->studiohdr2index == 0 )
+			{
+				// We always need this now, so make room for it in the buffer now.
+				int bufferContentsEnd = buf.TellMaxPut();
+				int maskBits = VALIGNOF( studiohdr2_t ) - 1;
+				int offsetStudiohdr2 = ( bufferContentsEnd + maskBits ) & ~maskBits;
+				int sizeIncrease = ( offsetStudiohdr2 - bufferContentsEnd )  + sizeof( studiohdr2_t );
+				buf.SeekPut( CUtlBuffer::SEEK_CURRENT, sizeIncrease );
+
+				// Re-get the pointer after resizing, because it has probably moved.
+				pStudioHdr = ( studiohdr_t* ) buf.Base();
+				studiohdr2_t* pStudioHdr2 = ( studiohdr2_t* ) ( ( byte * ) pStudioHdr + offsetStudiohdr2 );
+				memset( pStudioHdr2, 0, sizeof( studiohdr2_t ) );
+				pStudioHdr2->flMaxEyeDeflection = 0.866f; // Matches studio.h.
+
+				pStudioHdr->studiohdr2index = offsetStudiohdr2;
+				// Also make sure the structure knows about the extra bytes 
+				// we've added so they get copied around.
+				pStudioHdr->length += sizeIncrease;
+			}
+		}
 	}
 
 	return bOk;
@@ -1970,7 +2026,7 @@ studiohdr_t *CMDLCache::UnserializeMDL( MDLHandle_t handle, void *pData, int nDa
 
 	// critical! store a back link to our data
 	// this is fetched when re-establishing dependent cached data (vtx/vvd)
-	pStudioHdrIn->virtualModel = (void *)(uintp)handle;
+	pStudioHdrIn->SetVirtualModel( MDLHandleToVirtual( handle ) );
 
 	MdlCacheMsg( "MDLCache: Alloc studiohdr %s\n", GetModelName( handle ) );
 
@@ -2022,7 +2078,7 @@ bool CMDLCache::ReadMDLFile( MDLHandle_t handle, const char *pMDLFileName, CUtlB
 	char pFileName[ MAX_PATH ];
 	Q_strncpy( pFileName, pMDLFileName, sizeof( pFileName ) );
 	Q_FixSlashes( pFileName );
-#ifdef _LINUX
+#ifdef POSIX
 	Q_strlower( pFileName );
 #endif
 
@@ -2030,7 +2086,7 @@ bool CMDLCache::ReadMDLFile( MDLHandle_t handle, const char *pMDLFileName, CUtlB
 
 	MEM_ALLOC_CREDIT();
 
-	bool bOk = ReadFileNative( pFileName, "GAME", buf );
+	bool bOk = ReadFileNative( pFileName, "GAME", buf, 0, MDLCACHE_STUDIOHDR );
 	if ( !bOk )
 	{
 		DevWarning( "Failed to load %s!\n", pMDLFileName );
@@ -2059,6 +2115,12 @@ bool CMDLCache::ReadMDLFile( MDLHandle_t handle, const char *pMDLFileName, CUtlB
 		}
 	}
 
+    if ( buf.Size() < sizeof(studiohdr_t) )
+    {
+        DevWarning( "Empty model %s\n", pMDLFileName );
+        return false;
+    }
+
 	studiohdr_t *pStudioHdr = (studiohdr_t*)buf.PeekGet();
 	if ( !pStudioHdr )
 	{
@@ -2073,7 +2135,7 @@ bool CMDLCache::ReadMDLFile( MDLHandle_t handle, const char *pMDLFileName, CUtlB
 
 	// critical! store a back link to our data
 	// this is fetched when re-establishing dependent cached data (vtx/vvd)
-	pStudioHdr->virtualModel = (void*)(uintp)handle;
+	pStudioHdr->SetVirtualModel( MDLHandleToVirtual( handle ) );
 
 	// Make sure all dependent files are valid
 	if ( !VerifyHeaders( pStudioHdr ) )
@@ -2138,6 +2200,11 @@ studiohdr_t *CMDLCache::GetStudioHdr( MDLHandle_t handle )
 	// Assert( m_pModelCacheSection->IsFrameLocking() );
 	// Assert( m_pMeshCacheSection->IsFrameLocking() );
 
+	studiodata_t *pStudioData = m_MDLDict[handle];
+
+	if( !pStudioData )
+		return NULL;
+
 #if _DEBUG
 	VPROF_INCREMENT_COUNTER( "GetStudioHdr", 1 );
 #endif
@@ -2236,7 +2303,7 @@ void CMDLCache::TouchAllData( MDLHandle_t handle )
 		// ensure all sub models are cached
 		for ( int i=1; i<pVModel->m_group.Count(); ++i )
 		{
-			MDLHandle_t childHandle = (MDLHandle_t)(int)pVModel->m_group[i].cache&0xffff;
+			MDLHandle_t childHandle = VoidPtrToMDLHandle( pVModel->m_group[i].cache );
 			if ( childHandle != MDLHANDLE_INVALID )
 			{
 				// FIXME: Should this be calling TouchAllData on the child?
@@ -2301,7 +2368,7 @@ bool CMDLCache::HandleCacheNotification( const DataCacheNotification_t &notifica
 		{
 			MdlCacheMsg( "MDLCache: Data cache discard %s %s\n", g_ppszTypes[TypeFromCacheID( notification.clientId )], GetModelName( HandleFromCacheID( notification.clientId ) ) );
 
-			if ( (DataCacheClientID_t)notification.pItemData == notification.clientId ||
+			if ( (DataCacheClientID_t)(intp)notification.pItemData == notification.clientId ||
 				 TypeFromCacheID(notification.clientId) != MDLCACHE_STUDIOHWDATA )
 			{
 				Assert( notification.pItemData );
@@ -2320,7 +2387,7 @@ bool CMDLCache::HandleCacheNotification( const DataCacheNotification_t &notifica
 
 bool CMDLCache::GetItemName( DataCacheClientID_t clientId, const void *pItem, char *pDest, unsigned nMaxLen  )
 {
-	if ( (DataCacheClientID_t)pItem == clientId )
+	if ( (DataCacheClientID_t)(uintp)pItem == clientId )
 	{
 		return false;
 	}
@@ -2426,7 +2493,7 @@ void CMDLCache::FinishPendingLoads()
 	AUTO_LOCK( m_AsyncMutex );
 
 	// finish just our known jobs
-	int iAsync = m_PendingAsyncs.Head();
+	intp iAsync = m_PendingAsyncs.Head();
 	while ( iAsync != m_PendingAsyncs.InvalidIndex() )
 	{
 		AsyncInfo_t &info = m_PendingAsyncs[iAsync];
@@ -2581,7 +2648,7 @@ bool CMDLCache::VerifyHeaders( studiohdr_t *pStudioHdr )
 	}
 
 	char pFileName[ MAX_PATH ];
-	MDLHandle_t handle = (MDLHandle_t)(int)pStudioHdr->virtualModel&0xffff;
+	MDLHandle_t handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() );
 
 	MakeFilename( handle, ".vvd", pFileName, sizeof(pFileName) );
 
@@ -2642,7 +2709,7 @@ vertexFileHeader_t *CMDLCache::CacheVertexData( studiohdr_t *pStudioHdr )
 
 	Assert( pStudioHdr );
 
-	handle = (MDLHandle_t)(int)pStudioHdr->virtualModel&0xffff;
+	handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() );
 	Assert( handle != MDLHANDLE_INVALID );
 
 	pVvdHdr = (vertexFileHeader_t *)CheckData( m_MDLDict[handle]->m_VertexCache, MDLCACHE_VERTEXES );
@@ -3037,7 +3104,7 @@ bool CMDLCache::ProcessDataIntoCache( MDLHandle_t handle, MDLCacheDataType_t typ
 //	=0: pending
 //	>0:	completed
 //-----------------------------------------------------------------------------
-int CMDLCache::ProcessPendingAsync( int iAsync )
+int CMDLCache::ProcessPendingAsync( intp iAsync )
 {
 	if ( !ThreadInMainThread() )
 	{
@@ -3122,10 +3189,10 @@ void CMDLCache::ProcessPendingAsyncs( MDLCacheDataType_t type )
 	// things -- the LRU is in correct order, and it catches precached items lurking
 	// in the async queue that have only been requested once (thus aren't being cached
 	// and might lurk forever, e.g., wood gibs in the citadel)
-	int current = m_PendingAsyncs.Head();
+	intp current = m_PendingAsyncs.Head();
 	while ( current != m_PendingAsyncs.InvalidIndex() )
 	{
-		int next = m_PendingAsyncs.Next( current );
+		intp next = m_PendingAsyncs.Next( current );
 
 		if ( type == MDLCACHE_NONE || m_PendingAsyncs[current].type == type )
 		{
@@ -3148,7 +3215,7 @@ void CMDLCache::ProcessPendingAsyncs( MDLCacheDataType_t type )
 //-----------------------------------------------------------------------------
 bool CMDLCache::ClearAsync( MDLHandle_t handle, MDLCacheDataType_t type, int iAnimBlock, bool bAbort )
 {
-	int iAsyncInfo = GetAsyncInfoIndex( handle, type, iAnimBlock );
+	intp iAsyncInfo = GetAsyncInfoIndex( handle, type, iAnimBlock );
 	if ( iAsyncInfo != NO_ASYNC )
 	{
 		AsyncInfo_t *pInfo;
@@ -3242,7 +3309,7 @@ bool CMDLCache::SetAsyncLoad( MDLCacheDataType_t type, bool bAsync )
 //-----------------------------------------------------------------------------
 vertexFileHeader_t *CMDLCache::BuildAndCacheVertexData( studiohdr_t *pStudioHdr, vertexFileHeader_t *pRawVvdHdr  )
 {
-	MDLHandle_t	handle = (MDLHandle_t)(int)pStudioHdr->virtualModel&0xffff;
+	MDLHandle_t	handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() );
 	vertexFileHeader_t *pVvdHdr;
 
 	MdlCacheMsg( "MDLCache: Load VVD for %s\n", pStudioHdr->pszName() );
@@ -3330,7 +3397,7 @@ vertexFileHeader_t *CMDLCache::LoadVertexData( studiohdr_t *pStudioHdr )
 	MDLHandle_t			handle;
 
 	Assert( pStudioHdr );
-	handle = (MDLHandle_t)(int)pStudioHdr->virtualModel&0xffff;
+	handle = VoidPtrToMDLHandle( pStudioHdr->VirtualModel() );
 	Assert( !m_MDLDict[handle]->m_VertexCache );
 
 	studiodata_t *pStudioData = m_MDLDict[handle];
@@ -3340,7 +3407,7 @@ vertexFileHeader_t *CMDLCache::LoadVertexData( studiohdr_t *pStudioHdr )
 		return NULL;
 	}
 
-	int iAsync = GetAsyncInfoIndex( handle, MDLCACHE_VERTEXES );
+	intp iAsync = GetAsyncInfoIndex( handle, MDLCACHE_VERTEXES );
 
 	if ( iAsync == NO_ASYNC )
 	{
@@ -3420,7 +3487,7 @@ void CMDLCache::CacheData( DataCacheHandle_t *c, void *pData, int size, const ch
 	}
 
 	if ( id == (DataCacheClientID_t)-1 )
-		id = (DataCacheClientID_t)pData;
+		id = (DataCacheClientID_t)(intp)pData;
 
 	GetCacheSection( type )->Add(id, pData, size, c );
 }
@@ -3584,7 +3651,7 @@ void CMDLCache::QueuedLoaderCallback_MDL( void *pContext, void *pContext2, const
 
 	// journal each incoming buffer
 	ModelParts_t *pModelParts = (ModelParts_t *)pContext;
-	ModelParts_t::BufferType_t bufferType = static_cast< ModelParts_t::BufferType_t >((int)pContext2);
+	ModelParts_t::BufferType_t bufferType = static_cast< ModelParts_t::BufferType_t >((intp)pContext2);
 	pModelParts->Buffers[bufferType].SetExternalBuffer( (void *)pData, nSize, nSize, CUtlBuffer::READ_ONLY );
 	pModelParts->nLoadedParts += (1 << bufferType);
 
@@ -3895,7 +3962,7 @@ void CMDLCache::MarkFrame()
 const studiohdr_t *studiohdr_t::FindModel( void **cache, char const *pModelName ) const
 {
 	MDLHandle_t handle = g_MDLCache.FindMDL( pModelName );
-	*cache = (void*)(uintp)handle;
+	*cache = MDLHandleToVirtual(handle);
 	return g_MDLCache.GetStudioHdr( handle );
 }
 
@@ -3904,21 +3971,21 @@ virtualmodel_t *studiohdr_t::GetVirtualModel( void ) const
 	if (numincludemodels == 0)
 		return NULL;
 
-	return g_MDLCache.GetVirtualModelFast( this, (MDLHandle_t)(int)virtualModel&0xffff );
+    return g_MDLCache.GetVirtualModelFast( this, VoidPtrToMDLHandle( VirtualModel() ) );
 }
 
 byte *studiohdr_t::GetAnimBlock( int i ) const
 {
-	return g_MDLCache.GetAnimBlock( (MDLHandle_t)(int)virtualModel&0xffff, i );
+	return g_MDLCache.GetAnimBlock( VoidPtrToMDLHandle( VirtualModel() ), i );
 }
 
 int studiohdr_t::GetAutoplayList( unsigned short **pOut ) const
 {
-	return g_MDLCache.GetAutoplayList( (MDLHandle_t)(int)virtualModel&0xffff, pOut );
+	return g_MDLCache.GetAutoplayList( VoidPtrToMDLHandle( VirtualModel() ), pOut );
 }
 
 const studiohdr_t *virtualgroup_t::GetStudioHdr( void ) const
 {
-	return g_MDLCache.GetStudioHdr( (MDLHandle_t)(int)cache&0xffff );
+	return g_MDLCache.GetStudioHdr( VoidPtrToMDLHandle( cache ) );
 }
 

datacache/wscript

@@ -20,7 +20,8 @@ def build(bld):
 		'mdlcache.cpp',
 		'../public/studio.cpp',
 		'../public/studio_virtualmodel.cpp',
-		'../common/studiobyteswap.cpp'
+		'../common/studiobyteswap.cpp',
+		'../public/tier0/memoverride.cpp'
 	]
 
 	includes = [

datamodel/clipboardmanager.cpp

@@ -8,7 +8,7 @@
 #include "datamodel.h"
 #include "tier1/KeyValues.h"
 
-#ifndef _LINUX
+#ifdef _WIN32
 #define USE_WINDOWS_CLIPBOARD
 #endif
 

datamodel/datamodel.cpp

@@ -901,7 +901,9 @@ bool CDataModel::Unserialize( CUtlBuffer &inBuf, const char *pEncodingName, cons
 		return false;
 	}
 
+#if !defined(NO_MALLOC_OVERRIDE)
 	g_pMemAlloc->heapchk();
+#endif
 
 	DmxHeader_t header;
 	bool bStoresVersionInFile = pSerializer->StoresVersionInFile();
@@ -1656,7 +1658,7 @@ DmAttributeReferenceIterator_t CDataModel::FirstAttributeReferencingElement( DmE
 	if ( !pRef || pRef->m_attributes.m_hAttribute == DMATTRIBUTE_HANDLE_INVALID )
 		return DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
 
-	return ( DmAttributeReferenceIterator_t )( int )&pRef->m_attributes;
+	return ( DmAttributeReferenceIterator_t )( intp )&pRef->m_attributes;
 }
 
 DmAttributeReferenceIterator_t CDataModel::NextAttributeReferencingElement( DmAttributeReferenceIterator_t hAttrIter )
@@ -1665,7 +1667,7 @@ DmAttributeReferenceIterator_t CDataModel::NextAttributeReferencingElement( DmAt
 	if ( !pList )
 		return DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
 
-	return ( DmAttributeReferenceIterator_t )( int )pList->m_pNext;
+	return ( DmAttributeReferenceIterator_t )( intp )pList->m_pNext;
 }
 
 CDmAttribute *CDataModel::GetAttribute( DmAttributeReferenceIterator_t hAttrIter )

datamodel/datamodel.h

@@ -377,7 +377,7 @@ private:
 	{
 		DmObjectId_t m_id;
 		DmElementReference_t m_ref;
-		ElementIdHandlePair_t() {}
+		ElementIdHandlePair_t() = default;
 		explicit ElementIdHandlePair_t( const DmObjectId_t &id ) : m_ref()
 		{
 			CopyUniqueId( id, &m_id );

datamodel/dependencygraph.cpp

@@ -67,7 +67,7 @@ bool HashEntryCompareFunc( CAttributeNode *const& lhs, CAttributeNode *const& rh
 
 uint HashEntryKeyFunc( CAttributeNode *const& keyinfo )
 {
-	uint i = (uint)keyinfo->m_attribute;
+	uintp i = (uintp)keyinfo->m_attribute;
 	return i >> 2; // since memory is allocated on a 4-byte (at least!) boundary
 }
 

datamodel/dmelementdictionary.h

@@ -86,7 +86,7 @@ private:
 	{
 		DmObjectId_t m_oldId;
 		DmObjectId_t m_newId;
-		DmIdPair_t() {}
+		DmIdPair_t() = default;
 		DmIdPair_t( const DmObjectId_t &id )
 		{
 			CopyUniqueId( id, &m_oldId );

datamodel/dmserializerkeyvalues.cpp

@@ -264,7 +264,7 @@ DmAttributeType_t CDmSerializerKeyValues::DetermineAttributeType( KeyValues *pKe
 			if ( sscanf( pKeyValues->GetString(), "%f %f", &f1, &f2 ) == 2 )
 				return AT_VECTOR2;
 
-			int i = pKeyValues->GetInt( NULL, INT_MAX );
+			int i = pKeyValues->GetInt( nullptr, INT_MAX );
 			if ( ( sscanf( pKeyValues->GetString(), "%d", &i ) == 1 ) && 
 				 ( !strchr( pKeyValues->GetString(), '.' ) ) )
 				return AT_INT;

dedicated/dedicated.vpc

@@ -5,7 +5,7 @@
 //-----------------------------------------------------------------------------
 
 $Macro SRCDIR		".."
-$Macro OUTBINDIR	"$LIBPUBLIC"
+$Macro OUTBINDIR	"$SRCDIR\..\game\bin"
 
 $Include "$SRCDIR\vpc_scripts\source_dll_base.vpc"
 $include "$SRCDIR\vpc_scripts\source_cryptlib_include.vpc"
@@ -142,6 +142,7 @@ $Project "Dedicated"
 		$Lib	tier2
 		$Lib	tier3
 		$Lib	vgui_controls [$WIN32]
+		$Lib 	vpklib
 		$LibExternal "$SRCDIR/thirdparty/libedit-3.1/src/.libs/libedit" [$LINUXALL]
 		$ImpLibExternal steam_api
 		$ImpLib SDL2 [$SDL]

dedicated/filesystem.cpp

@@ -13,7 +13,11 @@
 #include <stdlib.h>
 #include "interface.h"
 #include <string.h>
+#ifdef OSX
+#include <malloc/malloc.h>
+#else
 #include <malloc.h>
+#endif
 #include "tier1/strtools.h"
 #include "tier0/icommandline.h"
 #include "tier0/dbg.h"

dedicated/sys_linux.cpp

@@ -12,7 +12,11 @@
 #include <stdarg.h>
 #include <sys/types.h>
 #include <sys/time.h>
+#ifdef OSX
+#include <malloc/malloc.h>
+#else
 #include <malloc.h>
+#endif
 #include <stdio.h>
 #include <stdlib.h>
 #include <dlfcn.h>

dedicated/wscript

@@ -24,11 +24,8 @@ def build(bld):
 		'../common/SteamAppStartup.cpp',
 		'sys_common.cpp',
 		'sys_ded.cpp',
-		#'sys_windows.cpp', [$WINDOWS]
-		'sys_linux.cpp', # [$POSIX]
 		'console/conproc.cpp',
 		'console/textconsole.cpp',
-		'console/TextConsoleUnix.cpp', # [$POSIX]
 		'../filesystem/filetracker.cpp',
 		'../filesystem/basefilesystem.cpp',
 		'../filesystem/packfile.cpp',
@@ -36,9 +33,20 @@ def build(bld):
 		'../filesystem/filesystem_stdio.cpp',
 		'../filesystem/QueuedLoader.cpp',
 		'../public/zip_utils.cpp',
-		'../filesystem/linux_support.cpp' # [$POSIX]
+		'../public/tier0/memoverride.cpp'
 	]
 
+	if bld.env.DEST_OS == 'win32':
+		source += [
+			'sys_windows.cpp'
+		]
+	else:
+		source += [
+			'sys_linux.cpp', # [$POSIX]
+			'console/TextConsoleUnix.cpp', # [$POSIX]
+			'../filesystem/linux_support.cpp' # [$POSIX]
+		]
+
 	includes = [
 		'.',
 		'../public',

dedicated_main/main.cpp

@@ -206,11 +206,11 @@ int main( int argc, char *argv[] )
 	void *tier0 = dlopen( "libtier0" DLL_EXT_STRING, RTLD_NOW );
 	void *vstdlib = dlopen( "libvstdlib" DLL_EXT_STRING, RTLD_NOW );
 
-	const char *pBinaryName = "dedicated" DLL_EXT_STRING;
+	const char *pBinaryName = "bin/dedicated" DLL_EXT_STRING;
 
 	void *dedicated = dlopen( pBinaryName, RTLD_NOW );
 	if ( !dedicated )
-		dedicated = dlopen( "libdedicated" DLL_EXT_STRING, RTLD_NOW );
+		dedicated = dlopen( "bin/libdedicated" DLL_EXT_STRING, RTLD_NOW );
 
 	if ( !dedicated )
 	{

dmxloader/dmxattribute.cpp

@@ -73,8 +73,10 @@ struct CSizeTest
 		COMPILE_TIME_ASSERT( sizeof( QAngle )		== 12 );
 		COMPILE_TIME_ASSERT( sizeof( Quaternion )	== 16 );
 		COMPILE_TIME_ASSERT( sizeof( VMatrix )		== 64 );
+#if !defined( PLATFORM_64BITS )
 		COMPILE_TIME_ASSERT( sizeof( CUtlString )	== 4 );
 		COMPILE_TIME_ASSERT( sizeof( CUtlBinaryBlock ) == 16 );
+#endif
 		COMPILE_TIME_ASSERT( sizeof( DmObjectId_t )	== 16 );
 	};
 };

dmxloader/dmxloadertext.cpp

@@ -231,7 +231,7 @@ enum
 class CDmxElementDictionary
 {
 public:
-	CDmxElementDictionary();
+	CDmxElementDictionary() = default;
 
 	DmxElementDictHandle_t InsertElement( CDmxElement *pElement );
 	CDmxElement *GetElement( DmxElementDictHandle_t handle );
@@ -287,15 +287,6 @@ private:
 	AttributeList_t m_ArrayAttributes;
 };
 
-
-//-----------------------------------------------------------------------------
-// Constructor
-//-----------------------------------------------------------------------------
-CDmxElementDictionary::CDmxElementDictionary()
-{
-}
-
-
 //-----------------------------------------------------------------------------
 // Clears the dictionary
 //-----------------------------------------------------------------------------

dx9sdk/include/d3dx9math.h

@@ -56,7 +56,7 @@ typedef struct D3DXFLOAT16
 {
 #ifdef __cplusplus
 public:
-    D3DXFLOAT16() {};
+    D3DXFLOAT16() = default;
     D3DXFLOAT16( FLOAT );
     D3DXFLOAT16( CONST D3DXFLOAT16& );
 
@@ -88,7 +88,7 @@ typedef struct D3DXVECTOR2
 {
 #ifdef __cplusplus
 public:
-    D3DXVECTOR2() {};
+    D3DXVECTOR2() = default;
     D3DXVECTOR2( CONST FLOAT * );
     D3DXVECTOR2( CONST D3DXFLOAT16 * );
     D3DXVECTOR2( FLOAT x, FLOAT y );
@@ -134,7 +134,7 @@ typedef struct D3DXVECTOR2_16F
 {
 #ifdef __cplusplus
 public:
-    D3DXVECTOR2_16F() {};
+    D3DXVECTOR2_16F() = default;
     D3DXVECTOR2_16F( CONST FLOAT * );
     D3DXVECTOR2_16F( CONST D3DXFLOAT16 * );
     D3DXVECTOR2_16F( CONST D3DXFLOAT16 &x, CONST D3DXFLOAT16 &y );
@@ -162,7 +162,7 @@ public:
 typedef struct D3DXVECTOR3 : public D3DVECTOR
 {
 public:
-    D3DXVECTOR3() {};
+    D3DXVECTOR3() = default;
     D3DXVECTOR3( CONST FLOAT * );
     D3DXVECTOR3( CONST D3DVECTOR& );
     D3DXVECTOR3( CONST D3DXFLOAT16 * );
@@ -208,7 +208,7 @@ typedef struct D3DXVECTOR3_16F
 {
 #ifdef __cplusplus
 public:
-    D3DXVECTOR3_16F() {};
+    D3DXVECTOR3_16F() = default;
     D3DXVECTOR3_16F( CONST FLOAT * );
     D3DXVECTOR3_16F( CONST D3DVECTOR& );
     D3DXVECTOR3_16F( CONST D3DXFLOAT16 * );
@@ -237,7 +237,7 @@ typedef struct D3DXVECTOR4
 {
 #ifdef __cplusplus
 public:
-    D3DXVECTOR4() {};
+    D3DXVECTOR4() = default;
     D3DXVECTOR4( CONST FLOAT* );
     D3DXVECTOR4( CONST D3DXFLOAT16* );
     D3DXVECTOR4( CONST D3DVECTOR& xyz, FLOAT w );
@@ -281,7 +281,7 @@ typedef struct D3DXVECTOR4_16F
 {
 #ifdef __cplusplus
 public:
-    D3DXVECTOR4_16F() {};
+    D3DXVECTOR4_16F() = default;
     D3DXVECTOR4_16F( CONST FLOAT * );
     D3DXVECTOR4_16F( CONST D3DXFLOAT16* );
     D3DXVECTOR4_16F( CONST D3DXVECTOR3_16F& xyz, CONST D3DXFLOAT16& w );
@@ -426,7 +426,7 @@ typedef struct D3DXQUATERNION
 {
 #ifdef __cplusplus
 public:
-    D3DXQUATERNION() {}
+    D3DXQUATERNION() = default;
     D3DXQUATERNION( CONST FLOAT * );
     D3DXQUATERNION( CONST D3DXFLOAT16 * );
     D3DXQUATERNION( FLOAT x, FLOAT y, FLOAT z, FLOAT w );
@@ -472,7 +472,7 @@ typedef struct D3DXPLANE
 {
 #ifdef __cplusplus
 public:
-    D3DXPLANE() {}
+    D3DXPLANE() = default;
     D3DXPLANE( CONST FLOAT* );
     D3DXPLANE( CONST D3DXFLOAT16* );
     D3DXPLANE( FLOAT a, FLOAT b, FLOAT c, FLOAT d );
@@ -513,7 +513,7 @@ typedef struct D3DXCOLOR
 {
 #ifdef __cplusplus
 public:
-    D3DXCOLOR() {}
+    D3DXCOLOR() = default;
     D3DXCOLOR( DWORD argb );
     D3DXCOLOR( CONST FLOAT * );
     D3DXCOLOR( CONST D3DXFLOAT16 * );

dx9sdk/lib/DxErr8.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3e3a0893326c705d44a13d9263681df9b50a3112f37c45488f5e4919f3b3d26e
-size 1083572

dx9sdk/lib/DxErr9.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0dcf72695c4dc029768d2d8fadb5d61d56dcf896bb9683dc936f8a046c608495
-size 3901404

dx9sdk/lib/XInput.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ef5622f062ea151ea49aee29903562b819bd65c90b052877c127ebcd428895dd
-size 3436

dx9sdk/lib/amstrmid.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:11049ebe22f538fd6ca0d6231012c01bf7b867ee181c976fdeba2a666926ae24
-size 272820

dx9sdk/lib/d3d8.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5f410143bdc4fd43a2de62f03837aae135009952c08a1dfef19dcf2d898e75f7
-size 2466

dx9sdk/lib/d3d9.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:461a9baf9d7a3e6ce4b04ef7814296c0fcad36ec77deb7566b361cbdabf6e3d7
-size 4988

dx9sdk/lib/d3dx.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2a7302d67797790fa68dd8c42308621e90971dc71179c702574208b3e56b351f
-size 614522

dx9sdk/lib/d3dx8.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0d5bd10baa80550e2a063e16867723f2fa6a7269a4afef86517a46293958849d
-size 2151212

dx9sdk/lib/d3dx8d.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2b4f081d23b65686c5d0821eb3fb5f3aaf08972f9539a9ce589499700c227c74
-size 53414

dx9sdk/lib/d3dx8dt.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:eddac0b46ac664863136e9c3aa85fa5276e029b8972433fdf1cc40dcc3aefe8f
-size 2467156

dx9sdk/lib/d3dx9.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0b1cd009d5e5ed15080c4d7ad0245a273242da07e0747921e80ac3ccf9bc0fc2
-size 87600

dx9sdk/lib/d3dx9d.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f97e80701a1ed7a4d13bc3315a76512ff9abe7dff595d4dd50c323aaf5147185
-size 82790

dx9sdk/lib/d3dx9dt.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:fd431d9ec65c3d3fd401b89aba77d83551e06ef80dcb725fdc89b8d78e90cf79
-size 6980296

dx9sdk/lib/d3dxd.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2fa2491ea3fc524799b6a66e23b2f10c5f6ac028f1f53f37d53361978ebc9cce
-size 565570

dx9sdk/lib/d3dxof.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6e02101d54f570d2bbb985292f4c6f0db105b067d32e865991a698faa78a34e6
-size 1722

dx9sdk/lib/ddraw.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6e9e94271645a16f5dee111cf380eaea1dd03bafcfab676d4198cfd7900de036
-size 4540

dx9sdk/lib/dinput.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6cefbeaf8688ea42259a055f84feec0410a666be6ddfdcc745c2661edeb123da
-size 17790

dx9sdk/lib/dinput8.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:277158fb325b22fd10680779e73b7dec1b2f577c7129ac25f632168325bd4f5e
-size 284368

dx9sdk/lib/dmoguids.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3fdecc54f091efe3f1888879e0f166c753a86984fb5624f96244f7abb45a3bb7
-size 18408

dx9sdk/lib/dplayx.lib

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0ec0bb6a248ddb690ef60d05a8f04003005a1c231e6e4fa42b1b013cca2900aa
-size 3142