Merge pull request #135 from nillerusr/optimization

Optimization branch

appframework/VguiMatSysApp.cpp

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

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/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 );

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 * );

engine/cbenchmark.cpp

@@ -71,13 +71,16 @@ void CBenchmarkResults::StartBenchmark( const CCommand &args )
 	SetResultsFilename( pszFilename );
 
 	// set any necessary settings
-	host_framerate.SetValue( (float)(1.0f / host_state.interval_per_tick) );
+	//host_framerate.SetValue( (float)(1.0f / host_state.interval_per_tick) );
 
 	// get the current frame and time
 	m_iStartFrame = host_framecount;
 	m_flStartTime = realtime;
+
+	m_flNextSecondTime = realtime + 1.0f;
+	m_iNextSecondFrame = host_framecount;
 }
-	
+
 //-----------------------------------------------------------------------------
 // Purpose: writes out results to file
 //-----------------------------------------------------------------------------
@@ -86,7 +89,7 @@ void CBenchmarkResults::StopBenchmark()
 	m_bIsTestRunning = false;
 
 	// reset
-	host_framerate.SetValue( 0 );
+	//host_framerate.SetValue( 0 );
 
 	// print out some stats
 	int numticks = host_framecount - m_iStartFrame;
@@ -103,12 +106,23 @@ void CBenchmarkResults::StopBenchmark()
 	kv->SetFloat( "framerate", framerate );
 	kv->SetInt( "build", build_number() );
 
+	CUtlString str;
+	for( int i = 0; i < m_FPSInfo.Count(); i++ )
+	{
+		str += m_FPSInfo[i];
+		if( i != m_FPSInfo.Count()-1 )
+			str += ',';
+	}
+	kv->SetString( "framerates", str );
+
 	// get material system info
 	GetMaterialSystemConfigForBenchmarkUpload( kv );
 
 	// save
 	kv->SaveToFile( g_pFileSystem, szFilename, "MOD" );
 	kv->deleteThis();
+
+	m_FPSInfo.Purge();
 }
 
 //-----------------------------------------------------------------------------
@@ -152,6 +166,20 @@ void CBenchmarkResults::Upload()
 #endif
 }
 
+void CBenchmarkResults::Frame()
+{
+	if( !m_bIsTestRunning )
+		return;
+
+	if( m_flNextSecondTime <= realtime )
+	{
+		m_FPSInfo.AddToTail( host_framecount-m_iNextSecondFrame );
+		m_flNextSecondTime += 1.0f;
+		m_iNextSecondFrame = host_framecount;
+	}
+}
+
+
 CON_COMMAND_F( bench_start, "Starts gathering of info. Arguments: filename to write results into", FCVAR_CHEAT )
 {
 	GetBenchResultsMgr()->StartBenchmark( args );

engine/cbenchmark.h

@@ -34,13 +34,19 @@ public:
 	void StopBenchmark();
 	void SetResultsFilename( const char *pFilename );
 	void Upload();
+	void Frame();
 
 private:
 	bool m_bIsTestRunning;
 	char m_szFilename[256];
 
-	int m_flStartTime;
+	float m_flStartTime;
 	int m_iStartFrame;
+
+	float m_flNextSecondTime;
+	int m_iNextSecondFrame;
+
+	CUtlVector<int> m_FPSInfo;
 };
 
 inline CBenchmarkResults *GetBenchResultsMgr()

engine/cl_demo.cpp

@@ -637,10 +637,6 @@ void CDemoRecorder::StartupDemoFile( void )
 	g_ClientDLL->OnDemoRecordStart( m_szDemoBaseName );
 }
 
-CDemoRecorder::CDemoRecorder()
-{
-}
-
 CDemoRecorder::~CDemoRecorder()
 {
 	CloseDemoFile();	

engine/cl_demo.h

@@ -123,7 +123,7 @@ class CDemoRecorder : public IDemoRecorder
 {
 public:
 	~CDemoRecorder();
-	CDemoRecorder();
+	CDemoRecorder() = default;
 
 	CDemoFile *GetDemoFile( void );
 	int		GetRecordingTick( void );

engine/cmodel.cpp

@@ -56,9 +56,7 @@ CTSPool<TraceInfo_t> g_TraceInfoPool;
 class CTraceInfoPool : public CTSList<TraceInfo_t *>
 {
 public:
-	CTraceInfoPool()
+	CTraceInfoPool() = default;
-	{
-	}
 };
 
 CTraceInfoPool g_TraceInfoPool;

engine/colorcorrectionpanel.cpp

@@ -345,7 +345,7 @@ public:
 class CColorOperationList
 {
 public:
-	CColorOperationList();
+	CColorOperationList() = default;
 
 	// Clears the list
 	void Clear();
@@ -376,14 +376,6 @@ private:
 };
 
 
-//-----------------------------------------------------------------------------
-// Constructor
-//-----------------------------------------------------------------------------
-CColorOperationList::CColorOperationList()
-{
-}
-
-
 //-----------------------------------------------------------------------------
 // Clears the list
 //-----------------------------------------------------------------------------

engine/dispnode.h

@@ -47,7 +47,7 @@ public:
     //
     // Construction/Decontruction
     //
-    CDispNode() {};
+    CDispNode() = default;
     ~CDispNode() {};
 
     //=========================================================================

engine/dt_recv_decoder.cpp

@@ -29,12 +29,6 @@ CClientSendProp::~CClientSendProp()
 	delete [] m_pTableName;
 }
 
-
-CClientSendTable::CClientSendTable()
-{
-}
-
-
 CClientSendTable::~CClientSendTable()
 {
 	delete [] m_SendTable.m_pNetTableName;

engine/dt_recv_decoder.h

@@ -50,7 +50,7 @@ private:
 class CClientSendTable
 {
 public:
-								CClientSendTable();
+								CClientSendTable() = default;
 								~CClientSendTable();
 	
 	int							GetNumProps() const		{ return m_SendTable.m_nProps; }

engine/gl_rlight.cpp

@@ -37,9 +37,7 @@ ConVar r_visualizelighttracesshowfulltrace( "r_visualizelighttracesshowfulltrace
 //-----------------------------------------------------------------------------
 struct LightVecState_t
 {
-	LightVecState_t()
+	LightVecState_t() = default;
-	{
-	}
 	Ray_t	m_Ray;
 	float	m_HitFrac;
 	float*	m_pTextureS;

engine/host_state.cpp

@@ -67,7 +67,7 @@ typedef enum
 class CHostState
 {
 public:
-				CHostState();
+				CHostState() = default;
 	void		Init();
 	void		FrameUpdate( float time );
 	void		SetNextState( HOSTSTATES nextState );
@@ -275,10 +275,6 @@ static void WatchDogHandler()
 // Class implementation
 //-----------------------------------------------------------------------------
 
-CHostState::CHostState()
-{
-}
-
 void CHostState::Init()
 {
 	SetState( HS_RUN, true );

engine/l_studio.cpp

@@ -1868,7 +1868,7 @@ struct ModelDebugOverlayData_t
 	DrawModelResults_t m_ModelResults;
 	Vector m_Origin;
 
-	ModelDebugOverlayData_t() {}
+	ModelDebugOverlayData_t() = default;
 
 private:
 	ModelDebugOverlayData_t( const ModelDebugOverlayData_t &vOther );

engine/pure_server.cpp

@@ -26,10 +26,6 @@ extern ConVar sv_pure_consensus;
 extern ConVar sv_pure_retiretime;
 extern ConVar sv_pure_trace;
 
-CPureServerWhitelist::CCommand::CCommand()
-{
-}
-
 CPureServerWhitelist::CCommand::~CCommand()
 {
 }

engine/pure_server.h

@@ -69,7 +69,7 @@ private:
 	class CCommand
 	{
 	public:
-		CCommand();
+		CCommand() = default;
 		~CCommand();
 
 		EPureServerFileClass m_eFileClass;

engine/spatialpartition.cpp

@@ -168,7 +168,7 @@ class CVoxelHash
 {
 public:
 	// Constructor, destructor
-	CVoxelHash();
+	CVoxelHash() = default;
 	~CVoxelHash();
 
 	// Call this to clear out the spatial partition and to re-initialize it given a particular world size (ISpatialPartitionInternal)
@@ -481,10 +481,6 @@ inline CVoxelTree *CSpatialPartition::VoxelTreeForHandle( SpatialPartitionHandle
 //-----------------------------------------------------------------------------
 // Constructor, destructor
 //-----------------------------------------------------------------------------
-CVoxelHash::CVoxelHash( )
-{
-}
-
 CVoxelHash::~CVoxelHash()
 {
 	Shutdown();

engine/sv_main.cpp

@@ -72,6 +72,7 @@
 #include "cl_rcon.h"
 #include "host_state.h"
 #include "voice.h"
+#include "cbenchmark.h"
 
 // memdbgon must be the last include file in a .cpp file!!!
 #include "tier0/memdbgon.h"
@@ -2845,6 +2846,9 @@ void SV_Think( bool bIsSimulating )
 	bIsSimulating =  bIsSimulating && ( sv.IsMultiplayer() || cl.IsActive() );
 
 	g_pServerPluginHandler->GameFrame( bIsSimulating );
+
+	if( bIsSimulating )
+		GetBenchResultsMgr()->Frame();
 }
 
 //-----------------------------------------------------------------------------
@@ -2920,6 +2924,7 @@ void SV_Frame( bool finalTick )
 	// unlock sting tables to allow changes, helps to find unwanted changes (bebug build only)
 	networkStringTableContainerServer->Lock( false );
 	
+
 	// Run any commands from client and play client Think functions if it is time.
 	sv.RunFrame(); // read network input etc
 

filesystem/basefilesystem.cpp

@@ -227,7 +227,7 @@ CUtlVector< FileNameHandle_t > CBaseFileSystem::m_ExcludePaths;
 class CStoreIDEntry
 {
 public:
-	CStoreIDEntry() {}
+	CStoreIDEntry() = default;
 	CStoreIDEntry( const char *pPathIDStr, int storeID )
 	{
 		m_PathIDString = pPathIDStr;

game/client/c_weapon__stubs.h

@@ -28,7 +28,7 @@
 	public:															\
 		DECLARE_PREDICTABLE();										\
 		DECLARE_CLIENTCLASS();										\
-		C_##className() {};											\
+		C_##className() = default;											\
 	private:														\
 		C_##className( const C_##className & );						\
 	};																\

game/client/cdll_client_int.cpp

@@ -305,7 +305,7 @@ C_BaseEntityClassList::~C_BaseEntityClassList()
 class CDataChangedEvent
 {
 public:
-	CDataChangedEvent() {}
+	CDataChangedEvent() = default;
 	CDataChangedEvent( IClientNetworkable *ent, DataUpdateType_t updateType, int *pStoredEvent )
 	{
 		m_pEntity = ent;

game/client/interpolatedvar.h

@@ -273,7 +273,7 @@ private:
 template<typename Type>
 struct CInterpolatedVarEntryBase<Type, false>
 {
-	CInterpolatedVarEntryBase() {}
+	CInterpolatedVarEntryBase() = default;
 	~CInterpolatedVarEntryBase() {}
 
 	const Type *GetValue() const { return &value; }

game/client/movehelper_client.cpp

@@ -53,7 +53,7 @@ private:
 		Vector	deltavelocity;
 		trace_t trace;
 
-		touchlist_t() {}
+		touchlist_t() = default;
 
 	private:
 		touchlist_t( const touchlist_t &src );
@@ -278,4 +278,4 @@ void CMoveHelperClient::PlayerSetAnimation( PLAYER_ANIM eAnim )
 bool CMoveHelperClient::IsWorldEntity( const CBaseHandle &handle )
 {
 	return handle == cl_entitylist->GetNetworkableHandle( 0 );
-}
+}

game/client/physics.cpp

@@ -41,7 +41,7 @@ extern IVEngineClient *engine;
 class CCollisionEvent : public IPhysicsCollisionEvent, public IPhysicsCollisionSolver, public IPhysicsObjectEvent
 {
 public:
-	CCollisionEvent( void );
+	CCollisionEvent( void ) = default;
 
 	void	ObjectSound( int index, vcollisionevent_t *pEvent );
 	void	PreCollision( vcollisionevent_t *pEvent ) {}
@@ -479,12 +479,6 @@ void PhysicsSimulate()
 	g_PhysicsSystem.PhysicsSimulate();
 }
 
-
-
-CCollisionEvent::CCollisionEvent( void ) 
-{ 
-}
-
 void CCollisionEvent::ObjectSound( int index, vcollisionevent_t *pEvent )
 {
 	IPhysicsObject *pObject = pEvent->pObjects[index];

game/client/view_effects.cpp

@@ -715,9 +715,7 @@ class CViewEffectsSaveRestoreBlockHandler :	public CDefSaveRestoreBlockHandler
 {
 	struct QueuedItem_t;
 public:
-	CViewEffectsSaveRestoreBlockHandler()
+	CViewEffectsSaveRestoreBlockHandler() = default;
-	{
-	}
 
 	const char *GetBlockName()
 	{

game/client/viewrender.cpp

@@ -259,10 +259,8 @@ private:
 class CWorldListCache
 {
 public:
-	CWorldListCache()
+	CWorldListCache() = default;
-	{
 
-	}
 	void Flush()
 	{
 		for ( int i = m_Entries.FirstInorder(); i != m_Entries.InvalidIndex(); i = m_Entries.NextInorder( i ) )

game/server/ai_network.h

@@ -52,7 +52,7 @@ public:
 
 struct AI_NearNode_t
 {
-	AI_NearNode_t() {}
+	AI_NearNode_t() = default;
 	AI_NearNode_t( int index, float nodedist ) { dist = nodedist; nodeIndex = index; }
 	float	dist;
 	int		nodeIndex;

game/server/entityoutput.h

@@ -83,7 +83,7 @@ protected:
 	CEventAction *m_ActionList;
 	DECLARE_SIMPLE_DATADESC();
 
-	CBaseEntityOutput() {} // this class cannot be created, only it's children
+	CBaseEntityOutput() = default; // this class cannot be created, only it's children
 
 private:
 	CBaseEntityOutput( CBaseEntityOutput& ); // protect from accidental copying

game/server/hl2/ai_behavior_holster.cpp

@@ -17,10 +17,6 @@ END_DATADESC();
 //-----------------------------------------------------------------------------
 // Purpose: 
 //-----------------------------------------------------------------------------
-CAI_HolsterBehavior::CAI_HolsterBehavior()
-{
-	// m_AssaultCue = CUE_NO_ASSAULT;
-}
 
 
 //-----------------------------------------------------------------------------

game/server/hl2/ai_behavior_holster.h

@@ -25,8 +25,8 @@ class CAI_HolsterBehavior : public CAI_SimpleBehavior
 	DECLARE_CLASS( CAI_HolsterBehavior, CAI_SimpleBehavior );
 
 public:
-	CAI_HolsterBehavior();
+	CAI_HolsterBehavior() = default;
-	
+
 	virtual const char *GetName() {	return "Holster"; }
 
 	virtual bool 	CanSelectSchedule();

game/server/hl2/npc_metropolice.cpp

@@ -461,14 +461,6 @@ void CNPC_MetroPolice::NotifyDeadFriend( CBaseEntity* pFriend )
 	m_Sentences.Speak( "METROPOLICE_MAN_DOWN", SENTENCE_PRIORITY_MEDIUM );
 }
 
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-CNPC_MetroPolice::CNPC_MetroPolice()
-{
-}
-
-
 //-----------------------------------------------------------------------------
 // Purpose: 
 //-----------------------------------------------------------------------------

game/server/hl2/npc_metropolice.h

@@ -34,7 +34,7 @@ class CNPC_MetroPolice : public CAI_BaseActor
 	DECLARE_DATADESC();
 
 public:
-	CNPC_MetroPolice();
+	CNPC_MetroPolice() = default;
 
 	virtual bool CreateComponents();
 	bool CreateBehaviors();

game/server/hl2/npc_monk.cpp

@@ -37,7 +37,7 @@ class CNPC_Monk : public CAI_PlayerAlly
 
 public:
 
-	CNPC_Monk() {}
+	CNPC_Monk() = default;
 	void Spawn();
 	void Precache();
 

game/shared/ModelSoundsCache.cpp

@@ -33,10 +33,6 @@ void VerifySequenceIndex( CStudioHdr *pstudiohdr );
 
 extern ISoundEmitterSystemBase *soundemitterbase;
 
-CModelSoundsCache::CModelSoundsCache()
-{
-}
-
 CModelSoundsCache::CModelSoundsCache( const CModelSoundsCache& src )
 {
 	sounds = src.sounds;
@@ -214,4 +210,4 @@ void CModelSoundsCache::BuildAnimationEventSoundList( CStudioHdr *hdr, CUtlVecto
 			}
 		}
 	}
-}
+}

game/shared/ModelSoundsCache.h

@@ -23,7 +23,7 @@ class CModelSoundsCache : public IBaseCacheInfo
 public:
 	CUtlVector< unsigned short > sounds;
 
-	CModelSoundsCache();
+	CModelSoundsCache() = default;
 	CModelSoundsCache( const CModelSoundsCache& src );
 
 	void PrecacheSoundList();

game/shared/activitylist.h

@@ -44,9 +44,7 @@ class CActivityRemapCache
 {
 public:
 
-	CActivityRemapCache()
+	CActivityRemapCache() = default;
-	{
-	}
 
 	CActivityRemapCache( const CActivityRemapCache& src )
 	{

game/shared/cam_thirdperson.cpp

@@ -51,10 +51,6 @@ ConVar cl_thirdperson( "cl_thirdperson", "0", FCVAR_NOT_CONNECTED | FCVAR_USERIN
 
 #endif
 
-CThirdPersonManager::CThirdPersonManager( void )
-{
-}
-
 void CThirdPersonManager::Init( void )
 {
 	m_bOverrideThirdPerson = false;
@@ -227,4 +223,4 @@ bool CThirdPersonManager::WantToUseGameThirdPerson( void )
 }
 
 
-CThirdPersonManager g_ThirdPersonManager;
+CThirdPersonManager g_ThirdPersonManager;

game/shared/cam_thirdperson.h

@@ -41,7 +41,7 @@ class CThirdPersonManager
 {
 public:
 
-	CThirdPersonManager();
+	CThirdPersonManager() = default;
 	void	SetCameraOffsetAngles( Vector vecOffset ) { m_vecCameraOffset = vecOffset; }
 	Vector	GetCameraOffsetAngles( void ) { return m_vecCameraOffset; }
 	

game/shared/decals.cpp

@@ -62,9 +62,7 @@ private:
 
 	struct DecalEntry
 	{
-		DecalEntry()
+		DecalEntry() = default;
-		{
-		}
 
 		DecalEntry( const DecalEntry& src )
 		{

game/shared/ehandle.h

@@ -44,7 +44,7 @@ class CHandle : public CBaseHandle
 {
 public:
 
-			CHandle();
+			CHandle() = default;
 			CHandle( int iEntry, int iSerialNumber );
 			CHandle( const CBaseHandle &handle );
 			CHandle( T *pVal );
@@ -71,12 +71,6 @@ public:
 // Inlines.
 // ----------------------------------------------------------------------- //
 
-template<class T>
-CHandle<T>::CHandle()
-{
-}
-
-
 template<class T>
 CHandle<T>::CHandle( int iEntry, int iSerialNumber )
 {

game/shared/saverestore_bitstring.h

@@ -20,9 +20,7 @@ template <class BITSTRING>
 class CVarBitVecSaveRestoreOps : public CDefSaveRestoreOps
 {
 public:
-	CVarBitVecSaveRestoreOps()
+	CVarBitVecSaveRestoreOps() = default;
-	{
-	}
 
 	// save data type interface
 	virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave )

game/shared/shareddefs.h

@@ -30,7 +30,7 @@
 class CViewVectors
 {
 public:
-	CViewVectors() {}
+	CViewVectors() = default;
 
 	CViewVectors( 
 		Vector vView,

ivp

@@ -1 +1 @@
-Subproject commit 4b693fa4f36f254f3cb011e1ae62773e5e55c919
+Subproject commit 428231315f701259387d0720170b05c23263ff4c

launcher/android/main.cpp

@@ -20,7 +20,6 @@ GNU General Public License for more details.
 #include <string.h>
 #include <unistd.h>
 #include <SDL_hints.h>
-#include <SDL_version.h>
 #include "tier0/dbg.h"
 #include "tier0/threadtools.h"
 
@@ -29,7 +28,6 @@ char java_args[4096];
 int iLastArgs = 0;
 
 DLL_EXPORT int LauncherMain( int argc, char **argv ); // from launcher.cpp
-extern void InitCrashHandler();
 
 DLL_EXPORT int Java_com_valvesoftware_ValveActivity2_setenv(JNIEnv *jenv, jclass *jclass, jstring env, jstring value, jint over)
 {
@@ -120,18 +118,14 @@ void android_property_print(const char *name)
 
 DLL_EXPORT int LauncherMainAndroid( int argc, char **argv )
 {
-	SDL_version ver;
+	Msg("GetTotalMemory() = %.2f \n", GetTotalMemory());
-	SDL_GetVersion( &ver );
 
-	Msg("SDL version: %d.%d.%d rev: %s\n", (int)ver.major, (int)ver.minor, (int)ver.patch, SDL_GetRevision());
-	Msg("GetTotalMemory() = %.2f GiB\n", GetTotalMemory());
 	android_property_print("ro.build.version.sdk");
 	android_property_print("ro.product.device");
 	android_property_print("ro.product.manufacturer");
 	android_property_print("ro.product.model");
 	android_property_print("ro.product.name");
 
-	InitCrashHandler();
 	SetLauncherArgs();
 
 	SDL_SetHint(SDL_HINT_TOUCH_MOUSE_EVENTS, "0");

launcher/launcher.cpp

@@ -67,7 +67,8 @@
 #endif
 
 #if defined( USE_SDL )
-#include "SDL.h"
+#include <SDL.h>
+#include <SDL_version.h>
 
 #if !defined( _WIN32 )
 #define MB_OK 			0x00000001
@@ -1218,6 +1219,12 @@ DLL_EXPORT int LauncherMain( int argc, char **argv )
 
 #endif // LINUX
 
+#ifdef USE_SDL
+	SDL_version ver;
+	SDL_GetVersion( &ver );
+	Msg("SDL version: %d.%d.%d rev: %s\n", (int)ver.major, (int)ver.minor, (int)ver.patch, SDL_GetRevision());
+#endif
+
 #if defined LINUX && defined USE_SDL && defined TOGLES && !defined ANDROID
 	SDL_SetHint(SDL_HINT_VIDEO_X11_FORCE_EGL, "1");
 #endif

launcher/reslistgenerator.cpp

@@ -112,9 +112,7 @@ void MergeResLists( CUtlVector< CUtlString > &fileNames, char const *pchOutputFi
 class CWorkItem
 {
 public:
-	CWorkItem()
+	CWorkItem() = default;
-	{
-	}
 
 	CUtlString		m_sSubDir;
 	CUtlString		m_sAddCommands;

launcher/wscript

@@ -13,6 +13,8 @@ def options(opt):
 
 def configure(conf):
 	conf.define('LAUNCHERONLY',1)
+	conf.define('CFLAGS', conf.env.CFLAGS)
+	conf.define('LDFLAGS', conf.env.LINKFLAGS)
 
 def build(bld):
 	source = [

materialsystem/morph.cpp

@@ -80,7 +80,7 @@ private:
 	// A list of all vertices affecting a particular morph target
 	struct MorphVertexList_t
 	{
-		MorphVertexList_t() {}
+		MorphVertexList_t() = default;
 		MorphVertexList_t( const MorphVertexList_t& src ) : m_nMorphTargetId( src.m_nMorphTargetId ) {}
 
 		int m_nMorphTargetId;

materialsystem/shaderapidx9/shaderapidx8.cpp

@@ -325,7 +325,7 @@ struct DynamicState_t
 	bool	m_bBuffer2Frames;
 #endif
 	
-	DynamicState_t() {}
+	DynamicState_t() = default;
 
 private:
 	DynamicState_t( DynamicState_t const& );

mathlib/polyhedron.cpp

@@ -11,6 +11,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include "tier1/utlvector.h"
+#include "tier1/memhelpers.h"
 #ifdef COMPILER_MSVC
 #include <new>
 #endif
@@ -318,10 +319,10 @@ CPolyhedron *ClipPolyhedron( const CPolyhedron *pExistingPolyhedron, const float
 														pExistingPolyhedron->iPolygonCount );
 		}
 
-		memcpy( pReturn->pVertices, pExistingPolyhedron->pVertices, sizeof( Vector ) * pReturn->iVertexCount );
+		memutils::copy( pReturn->pVertices, pExistingPolyhedron->pVertices, pReturn->iVertexCount );
-		memcpy( pReturn->pLines, pExistingPolyhedron->pLines, sizeof( Polyhedron_IndexedLine_t ) * pReturn->iLineCount );
+		memutils::copy( pReturn->pLines, pExistingPolyhedron->pLines, pReturn->iLineCount );
-		memcpy( pReturn->pIndices, pExistingPolyhedron->pIndices, sizeof( Polyhedron_IndexedLineReference_t ) * pReturn->iIndexCount );
+		memutils::copy( pReturn->pIndices, pExistingPolyhedron->pIndices, pReturn->iIndexCount );
-		memcpy( pReturn->pPolygons, pExistingPolyhedron->pPolygons, sizeof( Polyhedron_IndexedPolygon_t ) * pReturn->iPolygonCount );
+		memutils::copy( pReturn->pPolygons, pExistingPolyhedron->pPolygons, pReturn->iPolygonCount );
 
 		return pReturn;
 	}

public/appframework/VguiMatSysApp.h

@@ -30,7 +30,7 @@ class CVguiMatSysApp : public CVguiSteamApp
 	typedef CVguiSteamApp BaseClass;
 
 public:
-	CVguiMatSysApp();
+	CVguiMatSysApp() = default;
 
 	// Methods of IApplication
 	virtual bool Create();

public/bitvec.h

@@ -373,7 +373,7 @@ public:
 	int		FindNextSetBit(int iStartBit) const; // returns -1 if no set bit was found
 
 protected:
-	CFixedBitVecBase()				{}
+	CFixedBitVecBase() = default;
 	CFixedBitVecBase(int numBits)	{ Assert( numBits == NUM_BITS ); } // doesn't make sense, really. Supported to simplify templates & allow easy replacement of variable 
 	
 	void 		ValidateOperand( const CFixedBitVecBase<NUM_BITS> &operand ) const	{ } // no need, compiler does so statically
@@ -428,10 +428,8 @@ template < int NUM_BITS >
 class CBitVec : public CBitVecT< CFixedBitVecBase<NUM_BITS> >
 {
 public:
-	CBitVec()
+	CBitVec() = default;
-	{
+
-	}
-	
 	CBitVec(int numBits)
 	 : CBitVecT< CFixedBitVecBase<NUM_BITS> >(numBits)
 	{

public/bone_setup.h

@@ -249,7 +249,7 @@ struct ikcontextikrule_t
 	Vector		kneeDir;
 	Vector		kneePos;
 
-	ikcontextikrule_t() {}
+	ikcontextikrule_t() = default;
 
 private:
 	// No copy constructors allowed

public/datamodel/dmattributevar.h

@@ -427,11 +427,11 @@ public:
 
 #define DECLARE_ATTRIBUTE_ARRAY_VARIABLE( _className, _elementType )	\
 	public:																\
-		_className() {}
+		_className() = default;
 
 #define DECLARE_ATTRIBUTE_ARRAY_REFERENCE( _className, _elementType )	\
 	public:																\
-		_className() {}													\
+		_className() = default;													\
 		_className( CDmAttribute* pAttribute ) { BaseClass::Init( pAttribute ); }	\
 		_className( CDmElement *pElement, const char *pAttributeName, bool bAddAttribute = false ) { BaseClass::Init( pElement, pAttributeName, bAddAttribute ); } \
 		_className( CDmaArray<_className>& var ) { BaseClass::Init( var.GetAttribute() ); } \
@@ -439,7 +439,7 @@ public:
 
 #define DECLARE_ATTRIBUTE_ARRAY_CONST_REFERENCE( _className, _elementType )	\
 	public:																	\
-		_className() {}														\
+		_className() = default;														\
 		_className( const CDmAttribute* pAttribute ) { BaseClass::Init( pAttribute ); } \
 		_className( const CDmElement *pElement, const char *pAttributeName ) { BaseClass::Init( pElement, pAttributeName ); } \
 		_className( const CDmaArray<_className>& var ) { BaseClass::Init( var.GetAttribute() ); } \

public/datamodel/dmelementfactoryhelper.h

@@ -116,7 +116,7 @@ template < class T >
 class CDmAbstractElementFactory : public IDmElementFactoryInternal
 {
 public:
-	CDmAbstractElementFactory() {}
+	CDmAbstractElementFactory() = default;
 
 	// Creation, destruction
 	virtual CDmElement* Create( DmElementHandle_t handle, const char *pElementType, const char *pElementName, DmFileId_t fileid, const DmObjectId_t &id )

public/disp_common.cpp

@@ -15,7 +15,7 @@
 class CNodeVert
 {
 public:
-						CNodeVert()					{}
+						CNodeVert() = default;
 						CNodeVert( int ix, int iy ) {x=ix; y=iy;}
 
 	inline int&			operator[]( int i )			{return ((int*)this)[i];}

public/disp_vertindex.h

@@ -22,7 +22,7 @@
 class CVertIndex
 {
 public:
-				CVertIndex();
+				CVertIndex() = default;
 				CVertIndex( short ix, short iy );
 	
 	void		Init( short ix, short iy );
@@ -62,11 +62,6 @@ inline CVertIndex BuildOffsetVertIndex(
 // CVertIndex inlines.
 // ------------------------------------------------------------------ //
 
-inline CVertIndex::CVertIndex()
-{
-}
-
-
 inline CVertIndex::CVertIndex( short ix, short iy )
 {
 	x = ix;

public/gametrace.h

@@ -72,7 +72,7 @@ public:
 	// Otherwise, this is the hitbox index.
 	int			hitbox;					// box hit by trace in studio
 
-	CGameTrace() {}
+	CGameTrace() = default;
 
 private:
 	// No copy constructors allowed

public/iscratchpad3d.h

@@ -54,7 +54,7 @@ public:
 class CSPVert
 {
 public:
-				CSPVert();
+				CSPVert() = default;
 				CSPVert( Vector const &vPos, const CSPColor &vColor=CSPColor( Vector(1, 1, 1), 1 ) );
 	
 	void		Init( Vector const &vPos, const CSPColor &vColor=CSPColor( Vector(1, 1, 1), 1 ) );
@@ -254,10 +254,6 @@ inline CTextParams::CTextParams()
 	m_flLetterWidth = 3;
 }
 
-inline CSPVert::CSPVert()
-{
-}
-
 inline CSPVert::CSPVert( Vector const &vPos, const CSPColor &vColor )
 {
 	Init( vPos, vColor );

public/materialsystem/imaterialsystem.h

@@ -30,7 +30,7 @@
 #include "materialsystem/deformations.h"
 #include "materialsystem/imaterialsystemhardwareconfig.h"
 #include "materialsystem/IColorCorrection.h"
-
+#include "tier1/memhelpers.h"
 
 //-----------------------------------------------------------------------------
 // forward declarations
@@ -1563,12 +1563,9 @@ public:
 
 template< class E > inline E* IMatRenderContext::LockRenderDataTyped( int nCount, const E* pSrcData )
 {
-	int nSizeInBytes = nCount * sizeof(E);
+	E *pDstData = (E*)LockRenderData( nCount*sizeof(E) );
-	E *pDstData = (E*)LockRenderData( nSizeInBytes );
 	if ( pSrcData && pDstData )
-	{
+		memutils::copy( pDstData, pSrcData, nCount );
-		memcpy( pDstData, pSrcData, nSizeInBytes );
-	}
 	return pDstData;
 }
 
@@ -1751,7 +1748,7 @@ class CMatRenderContextPtr : public CRefPtr<IMatRenderContext>
 {
 	typedef CRefPtr<IMatRenderContext> BaseClass;
 public:
-	CMatRenderContextPtr()																					{}
+	CMatRenderContextPtr() = default;
 	CMatRenderContextPtr( IMatRenderContext *pInit )			: BaseClass( pInit )						{ if ( BaseClass::m_pObject ) BaseClass::m_pObject->BeginRender(); }
 	CMatRenderContextPtr( IMaterialSystem *pFrom )				: BaseClass( pFrom->GetRenderContext() )	{ if ( BaseClass::m_pObject ) BaseClass::m_pObject->BeginRender(); }
 	~CMatRenderContextPtr()																					{ if ( BaseClass::m_pObject ) BaseClass::m_pObject->EndRender(); }

public/materialsystem/imesh.h

@@ -222,17 +222,13 @@ inline void IncrementFloatPointer( float* &pBufferPointer, int vertexSize )
 class CPrimList
 {
 public:
-	CPrimList();
+	CPrimList() = default;
 	CPrimList( int nFirstIndex, int nIndexCount );
 
 	int			m_FirstIndex;
 	int			m_NumIndices;
 };
 
-inline CPrimList::CPrimList()
-{
-}
-
 inline CPrimList::CPrimList( int nFirstIndex, int nIndexCount )
 {
 	m_FirstIndex = nFirstIndex;

public/mathlib/compressed_vector.h

@@ -149,7 +149,7 @@ class Quaternion64
 {
 public:
 	// Construction/destruction:
-	Quaternion64(void) {};
+	Quaternion64(void) = default;
 	Quaternion64(vec_t X, vec_t Y, vec_t Z);
 
 	// assignment
@@ -197,7 +197,7 @@ class Quaternion48
 {
 public:
 	// Construction/destruction:
-	Quaternion48(void) {};
+	Quaternion48(void) = default;
 	Quaternion48(vec_t X, vec_t Y, vec_t Z);
 
 	// assignment
@@ -501,7 +501,7 @@ protected:
 class float16_with_assign : public float16
 {
 public:
-	float16_with_assign() {}
+	float16_with_assign() = default;
 	float16_with_assign( float f ) { m_storage.rawWord = ConvertFloatTo16bits(f); }
 
 	float16& operator=(const float16 &other) { m_storage.rawWord = ((float16_with_assign &)other).m_storage.rawWord; return *this; }
@@ -518,7 +518,7 @@ class Vector48
 {
 public:
 	// Construction/destruction:
-	Vector48(void) {}
+	Vector48(void) = default;
 	Vector48(vec_t X, vec_t Y, vec_t Z) { x.SetFloat( X ); y.SetFloat( Y ); z.SetFloat( Z ); }
 
 	// assignment
@@ -562,7 +562,7 @@ class Vector2d32
 {
 public:
 	// Construction/destruction:
-	Vector2d32(void) {}
+	Vector2d32(void) = default;
 	Vector2d32(vec_t X, vec_t Y) { x.SetFloat( X ); y.SetFloat( Y ); }
 
 	// assignment

public/mathlib/mathlib.h

@@ -237,7 +237,7 @@ bool R_CullBoxSkipNear( const Vector& mins, const Vector& maxs, const Frustum_t
 
 struct matrix3x4_t
 {
-	matrix3x4_t() {}
+	matrix3x4_t() = default;
 	matrix3x4_t( 
 		float m00, float m01, float m02, float m03,
 		float m10, float m11, float m12, float m13,

public/mathlib/simdvectormatrix.h

@@ -20,6 +20,7 @@
 #include "tier0/dbg.h"
 #include "tier1/utlsoacontainer.h"
 #include "mathlib/ssemath.h"
+#include "tier1/memhelpers.h"
 
 class CSIMDVectorMatrix
 {
@@ -61,19 +62,19 @@ public:
 	// set up storage and fields for m x n matrix. destroys old data
 	void SetSize( int width, int height )
 	{
-		if ( ( ! m_pData ) || ( width != m_nWidth ) || ( height != m_nHeight ) )
+		if ( ( ! m_pData ) || ( width > m_nWidth ) || ( height > m_nHeight ) )
 		{
 			if ( m_pData )
 				delete[] m_pData;
-			
+
-			m_nWidth = width;
-			m_nHeight = height;
-			
 			m_nPaddedWidth = ( m_nWidth + 3) >> 2;
 			m_pData = NULL;
 			if ( width && height )
 				m_pData = new FourVectors[ m_nPaddedWidth * m_nHeight ];
 		}
+
+		m_nWidth = width;
+		m_nHeight = height;
 	}
 
 	CSIMDVectorMatrix( int width, int height )
@@ -86,7 +87,8 @@ public:
 	{
 		SetSize( src.m_nWidth, src.m_nHeight );
 		if ( m_pData )
-			memcpy( m_pData, src.m_pData, m_nHeight*m_nPaddedWidth*sizeof(m_pData[0]) ); 
+			memutils::copy( m_pData, src.m_pData, m_nHeight*m_nPaddedWidth );
+
 		return *this;
 	}
 
@@ -131,7 +133,9 @@ public:
 	void Clear( void )
 	{
 		Assert( m_pData );
-		memset( m_pData, 0, m_nHeight*m_nPaddedWidth*sizeof(m_pData[0]) );
+
+		static FourVectors value{Four_Zeros, Four_Zeros, Four_Zeros};
+		memutils::set( m_pData, value, m_nHeight*m_nPaddedWidth );
 	}
 
 	void RaiseToPower( float power );

public/mathlib/ssemath.h

@@ -2604,9 +2604,7 @@ public:
 		return Vector( X(idx), Y(idx), Z(idx) );
 	}
 	
-	FourVectors(void)
+	FourVectors(void) = default;
-	{
-	}
 
 	FourVectors( FourVectors const &src )
 	{
@@ -2615,6 +2613,13 @@ public:
 		z=src.z;
 	}
 
+	FourVectors( fltx4 x, fltx4 y, fltx4 z )
+	{
+		this->x=x;
+		this->y=y;
+		this->z=z;
+	}
+
 	FORCEINLINE void operator=( FourVectors const &src )
 	{
 		x=src.x;

public/mathlib/vector.h

@@ -70,7 +70,17 @@ public:
 	vec_t x, y, z;
 
 	// Construction/destruction:
-	Vector(void); 
+
+#if defined (_DEBUG) && defined (VECTOR_PARANOIA)
+	Vector(void)
+	{
+		// Initialize to NAN to catch errors
+		x = y = z = VEC_T_NAN;
+	}
+#else
+	Vector(void) = default;
+#endif
+
 	Vector(vec_t X, vec_t Y, vec_t Z);
 	explicit Vector(vec_t XYZ); ///< broadcast initialize
 
@@ -373,7 +383,7 @@ public:
 class ALIGN16 VectorAligned : public Vector
 {
 public:
-	inline VectorAligned(void) {};
+	inline VectorAligned(void) = default;
 	inline VectorAligned(vec_t X, vec_t Y, vec_t Z) 
 	{
 		Init(X,Y,Z);
@@ -497,19 +507,6 @@ float RandomVectorInUnitCircle( Vector2D *pVector );
 //-----------------------------------------------------------------------------
 
 
-//-----------------------------------------------------------------------------
-// constructors
-//-----------------------------------------------------------------------------
-inline Vector::Vector(void)									
-{ 
-#ifdef _DEBUG
-#ifdef VECTOR_PARANOIA
-	// Initialize to NAN to catch errors
-	x = y = z = VEC_T_NAN;
-#endif
-#endif
-}
-
 inline Vector::Vector(vec_t X, vec_t Y, vec_t Z)						
 { 
 	x = X; y = Y; z = Z;
@@ -1542,15 +1539,16 @@ class RadianEuler;
 class Quaternion				// same data-layout as engine's vec4_t,
 {								//		which is a vec_t[4]
 public:
-	inline Quaternion(void)	{ 
+#if defined (_DEBUG) && defined VECTOR_PARANOIA
-	
+	inline Quaternion(void)
-	// Initialize to NAN to catch errors
+	{
-#ifdef _DEBUG
+		// Initialize to NAN to catch errors
-#ifdef VECTOR_PARANOIA
 		x = y = z = w = VEC_T_NAN;
-#endif
-#endif
 	}
+#else
+	Quaternion(void) = default;
+#endif
+
 	inline Quaternion(vec_t ix, vec_t iy, vec_t iz, vec_t iw) : x(ix), y(iy), z(iz), w(iw) { }
 	inline Quaternion(RadianEuler const &angle);	// evil auto type promotion!!!
 
@@ -1624,7 +1622,7 @@ inline bool QuaternionsAreEqual( const Quaternion& src1, const Quaternion& src2,
 class ALIGN16 QuaternionAligned : public Quaternion
 {
 public:
-	inline QuaternionAligned(void) {};
+	inline QuaternionAligned(void) = default;
 	inline QuaternionAligned(vec_t X, vec_t Y, vec_t Z, vec_t W) 
 	{
 		Init(X,Y,Z,W);
@@ -1661,7 +1659,7 @@ class QAngle;
 class RadianEuler
 {
 public:
-	inline RadianEuler(void)							{ }
+	inline RadianEuler(void) = default;
 	inline RadianEuler(vec_t X, vec_t Y, vec_t Z)		{ x = X; y = Y; z = Z; }
 	inline RadianEuler(Quaternion const &q);	// evil auto type promotion!!!
 	inline RadianEuler(QAngle const &angles);	// evil auto type promotion!!!
@@ -1771,7 +1769,17 @@ public:
 	vec_t x, y, z;
 
 	// Construction/destruction
-	QAngle(void);
+
+#if defined (_DEBUG) && defined (VECTOR_PARANOIA)
+	inline QAngle(void)
+	{
+		// Initialize to NAN to catch errors
+		x = y = z = VEC_T_NAN;
+	}
+#else
+	QAngle(void) = default;
+#endif
+
 	QAngle(vec_t X, vec_t Y, vec_t Z);
 //	QAngle(RadianEuler const &angles);	// evil auto type promotion!!!
 
@@ -1871,16 +1879,6 @@ inline void VectorMA( const QAngle &start, float scale, const QAngle &direction,
 //-----------------------------------------------------------------------------
 // constructors
 //-----------------------------------------------------------------------------
-inline QAngle::QAngle(void)									
-{ 
-#ifdef _DEBUG
-#ifdef VECTOR_PARANOIA
-	// Initialize to NAN to catch errors
-	x = y = z = VEC_T_NAN;
-#endif
-#endif
-}
-
 inline QAngle::QAngle(vec_t X, vec_t Y, vec_t Z)						
 { 
 	x = X; y = Y; z = Z;

public/mathlib/vector2d.h

@@ -36,7 +36,16 @@ public:
 	vec_t x, y;
 
 	// Construction/destruction
-	Vector2D(void);
+#if defined( _DEBUG ) && defined( VECTOR_PARANOIA )
+	inline Vector2D(void)
+	{
+		// Initialize to NAN to catch errors
+		x = y = VEC_T_NAN;
+	}
+#else
+	Vector2D(void) = default;
+#endif
+
 	Vector2D(vec_t X, vec_t Y);
 	Vector2D(const float *pFloat);
 
@@ -194,15 +203,6 @@ void Vector2DLerp(const Vector2D& src1, const Vector2D& src2, vec_t t, Vector2D&
 //-----------------------------------------------------------------------------
 // constructors
 //-----------------------------------------------------------------------------
-
-inline Vector2D::Vector2D(void)									
-{ 
-#ifdef _DEBUG
-	// Initialize to NAN to catch errors
-	x = y = VEC_T_NAN;
-#endif
-}
-
 inline Vector2D::Vector2D(vec_t X, vec_t Y)						
 { 
 	x = X; y = Y;

public/mathlib/vector4d.h

@@ -42,7 +42,16 @@ public:
 	vec_t x, y, z, w;
 
 	// Construction/destruction
-	Vector4D(void);
+#if defined( _DEBUG ) && defined( VECTOR_PARANOIA )
+	inline Vector4D(void)
+	{
+		// Initialize to NAN to catch errors
+		x = y = z = w = VEC_T_NAN;
+	}
+#else
+	Vector4D(void) = default;
+#endif
+
 	Vector4D(vec_t X, vec_t Y, vec_t Z, vec_t W);
 	Vector4D(const float *pFloat);
 
@@ -139,7 +148,7 @@ const Vector4D vec4_invalid( FLT_MAX, FLT_MAX, FLT_MAX, FLT_MAX );
 class ALIGN16 Vector4DAligned : public Vector4D
 {
 public:
-	Vector4DAligned(void) {}
+	Vector4DAligned(void) = default;
 	Vector4DAligned( vec_t X, vec_t Y, vec_t Z, vec_t W );
 
 	inline void Set( vec_t X, vec_t Y, vec_t Z, vec_t W );
@@ -204,15 +213,6 @@ void Vector4DLerp(Vector4D const& src1, Vector4D const& src2, vec_t t, Vector4D&
 //-----------------------------------------------------------------------------
 // constructors
 //-----------------------------------------------------------------------------
-
-inline Vector4D::Vector4D(void)									
-{ 
-#ifdef _DEBUG
-	// Initialize to NAN to catch errors
-	x = y = z = w = VEC_T_NAN;
-#endif
-}
-
 inline Vector4D::Vector4D(vec_t X, vec_t Y, vec_t Z, vec_t W )
 { 
 	x = X; y = Y; z = Z; w = W;

public/mathlib/vplane.h

@@ -29,7 +29,7 @@ typedef int SideType;
 class VPlane
 {
 public:
-				VPlane();
+				VPlane() = default;
 				VPlane(const Vector &vNormal, vec_t dist);
 
 	void		Init(const Vector &vNormal, vec_t dist);
@@ -77,10 +77,6 @@ private:
 //-----------------------------------------------------------------------------
 // Inlines.
 //-----------------------------------------------------------------------------
-inline VPlane::VPlane()
-{
-}
-
 inline VPlane::VPlane(const Vector &vNormal, vec_t dist)
 {
 	m_Normal = vNormal;

public/particles/particles.h

@@ -1422,9 +1422,8 @@ public:
 class CM128AttributeWriteIterator : public CStridedPtr<fltx4>
 {
 public:
-	FORCEINLINE CM128AttributeWriteIterator( void )
+	FORCEINLINE CM128AttributeWriteIterator( void ) = default;
-	{
+
-	}
 	FORCEINLINE void Init ( int nAttribute, CParticleCollection *pParticles )
 	{
 		m_pData = pParticles->GetM128AttributePtrForWrite( nAttribute, &m_nStride );

public/saverestoretypes.h

@@ -278,7 +278,7 @@ private:
 
 		CHashElement( const CBaseEntity *pEntity, int index) : pEntity(pEntity), index(index) {}
 		CHashElement( const CBaseEntity *pEntity ) : pEntity(pEntity) {}
-		CHashElement() {}
+		CHashElement() = default;
 	};
 
 	class CHashFuncs

public/studio.h

@@ -147,7 +147,7 @@ struct mstudioaxisinterpbone_t
 	Vector			pos[6];	// X+, X-, Y+, Y-, Z+, Z-
 	Quaternion		quat[6];// X+, X-, Y+, Y-, Z+, Z-
 
-	mstudioaxisinterpbone_t(){}
+	mstudioaxisinterpbone_t() = default;
 private:
 	// No copy constructors allowed
 	mstudioaxisinterpbone_t(const mstudioaxisinterpbone_t& vOther);
@@ -162,7 +162,7 @@ struct mstudioquatinterpinfo_t
 	Vector			pos;		// new position
 	Quaternion		quat;		// new angle
 
-	mstudioquatinterpinfo_t(){}
+	mstudioquatinterpinfo_t() = default;
 private:
 	// No copy constructors allowed
 	mstudioquatinterpinfo_t(const mstudioquatinterpinfo_t& vOther);
@@ -176,7 +176,7 @@ struct mstudioquatinterpbone_t
 	int				triggerindex;
 	inline mstudioquatinterpinfo_t *pTrigger( int i ) const { return  (mstudioquatinterpinfo_t *)(((byte *)this) + triggerindex) + i; };
 
-	mstudioquatinterpbone_t(){}
+	mstudioquatinterpbone_t() = default;
 private:
 	// No copy constructors allowed
 	mstudioquatinterpbone_t(const mstudioquatinterpbone_t& vOther);
@@ -261,7 +261,7 @@ struct mstudioaimatbone_t
 	Vector			upvector;
 	Vector			basepos;
 
-	mstudioaimatbone_t() {}
+	mstudioaimatbone_t() = default;
 private:
 	// No copy constructors allowed
 	mstudioaimatbone_t(const mstudioaimatbone_t& vOther);
@@ -297,7 +297,7 @@ struct mstudiobone_t
 
 	int					unused[8];		// remove as appropriate
 
-	mstudiobone_t(){}
+	mstudiobone_t() = default;
 private:
 	// No copy constructors allowed
 	mstudiobone_t(const mstudiobone_t& vOther);
@@ -339,7 +339,7 @@ struct mstudiolinearbone_t
 
 	int unused[6];
 
-	mstudiolinearbone_t(){}
+	mstudiolinearbone_t() = default;
 private:
 	// No copy constructors allowed
 	mstudiolinearbone_t(const mstudiolinearbone_t& vOther);
@@ -370,7 +370,7 @@ struct mstudioboneflexdrivercontrol_t
 	float m_flMin;				// Min value of bone component mapped to 0 on flex controller
 	float m_flMax;				// Max value of bone component mapped to 1 on flex controller
 
-	mstudioboneflexdrivercontrol_t(){}
+	mstudioboneflexdrivercontrol_t() = default;
 private:
 	// No copy constructors allowed
 	mstudioboneflexdrivercontrol_t( const mstudioboneflexdrivercontrol_t &vOther );
@@ -396,7 +396,7 @@ struct mstudioboneflexdriver_t
 
 	int unused[3];
 
-	mstudioboneflexdriver_t(){}
+	mstudioboneflexdriver_t() = default;
 private:
 	// No copy constructors allowed
 	mstudioboneflexdriver_t( const mstudioboneflexdriver_t &vOther );
@@ -468,7 +468,7 @@ struct mstudiobbox_t
 		return ((const char*)this) + szhitboxnameindex;
 	}
 
-	mstudiobbox_t() {}
+	mstudiobbox_t() = default;
 
 private:
 	// No copy constructors allowed
@@ -532,7 +532,7 @@ struct mstudioikerror_t
 	Vector		pos;
 	Quaternion	q;
 
-	mstudioikerror_t() {}
+	mstudioikerror_t() = default;
 
 private:
 	// No copy constructors allowed
@@ -547,7 +547,7 @@ struct mstudiocompressedikerror_t
 	float	scale[6];
 	short	offset[6];
 	inline mstudioanimvalue_t *pAnimvalue( int i ) const { if (offset[i] > 0) return  (mstudioanimvalue_t *)(((byte *)this) + offset[i]); else return NULL; };
-	mstudiocompressedikerror_t(){}
+	mstudiocompressedikerror_t() = default;
 
 private:
 	// No copy constructors allowed
@@ -598,7 +598,7 @@ struct mstudioikrule_t
 
 	int			unused[7];
 
-	mstudioikrule_t() {}
+	mstudioikrule_t() = default;
 
 private:
 	// No copy constructors allowed
@@ -699,7 +699,8 @@ struct mstudiomovement_t
 	Vector				vector;		// movement vector relative to this blocks initial angle
 	Vector				position;	// relative to start of animation???
 
-	mstudiomovement_t(){}
+	mstudiomovement_t() = default;
+
 private:
 	// No copy constructors allowed
 	mstudiomovement_t(const mstudiomovement_t& vOther);
@@ -768,7 +769,7 @@ struct mstudioanimdesc_t
 	byte				*pZeroFrameData( ) const { if (zeroframeindex) return (((byte *)this) + zeroframeindex); else return NULL; };
 	mutable float		zeroframestalltime;		// saved during read stalls
 
-	mstudioanimdesc_t(){}
+	mstudioanimdesc_t() = default;
 private:
 	// No copy constructors allowed
 	mstudioanimdesc_t(const mstudioanimdesc_t& vOther);
@@ -900,7 +901,7 @@ struct mstudioseqdesc_t
 
 	int					unused[5];		// remove/add as appropriate (grow back to 8 ints on version change!)
 
-	mstudioseqdesc_t(){}
+	mstudioseqdesc_t() = default;
 private:
 	// No copy constructors allowed
 	mstudioseqdesc_t(const mstudioseqdesc_t& vOther);
@@ -1100,7 +1101,7 @@ public:
 	};
 	friend class CSortByIndex;
 
-	mstudiovertanim_t(){}
+	mstudiovertanim_t() = default;
 //private:
 // No copy constructors allowed, but it's needed for std::sort()
 //	mstudiovertanim_t(const mstudiovertanim_t& vOther);
@@ -1211,7 +1212,7 @@ struct mstudiovertex_t
 	Vector				m_vecNormal;
 	Vector2D			m_vecTexCoord;
 
-	mstudiovertex_t() {}
+	mstudiovertex_t() = default;
 
 private:
 	// No copy constructors allowed
@@ -1269,7 +1270,7 @@ struct mstudioeyeball_t
 	char	unused3[3];
 	int		unused4[7];
 
-	mstudioeyeball_t(){}
+	mstudioeyeball_t() = default;
 private:
 	// No copy constructors allowed
 	mstudioeyeball_t(const mstudioeyeball_t& vOther);
@@ -1284,7 +1285,7 @@ struct mstudioiklink_t
 	Vector	kneeDir;	// ideal bending direction (per link, if applicable)
 	Vector	unused0;	// unused
 
-	mstudioiklink_t(){}
+	mstudioiklink_t() = default;
 private:
 	// No copy constructors allowed
 	mstudioiklink_t(const mstudioiklink_t& vOther);
@@ -1411,7 +1412,7 @@ struct mstudiomesh_t
 	int					unused[8]; // remove as appropriate
 #endif
 
-	mstudiomesh_t(){}
+	mstudiomesh_t() = default;
 private:
 	// No copy constructors allowed
 	mstudiomesh_t(const mstudiomesh_t& vOther);
@@ -1697,7 +1698,7 @@ struct mstudiomouth_t
 	Vector				forward;
 	int					flexdesc;
 
-	mstudiomouth_t(){}
+	mstudiomouth_t() = default;
 private:
 	// No copy constructors allowed
 	mstudiomouth_t(const mstudiomouth_t& vOther);
@@ -3297,17 +3298,19 @@ inline int Studio_LoadVertexes( const vertexFileHeader_t *pTempVvdHdr, vertexFil
 		}
 
 		// copy vertexes
+
+		// TODO(nillerusr): That sucks and needs to be fixed
 		memcpy(
-			(mstudiovertex_t *)((byte *)pNewVvdHdr+pNewVvdHdr->vertexDataStart) + target,
+			(byte*)((mstudiovertex_t *)((byte *)pNewVvdHdr+pNewVvdHdr->vertexDataStart) + target),
-			(mstudiovertex_t *)((byte *)pTempVvdHdr+pTempVvdHdr->vertexDataStart) + pFixupTable[i].sourceVertexID,
+			(byte*)((mstudiovertex_t *)((byte *)pTempVvdHdr+pTempVvdHdr->vertexDataStart) + pFixupTable[i].sourceVertexID),
 			pFixupTable[i].numVertexes*sizeof(mstudiovertex_t) );
 
 		if (bNeedsTangentS)
 		{
 			// copy tangents
 			memcpy(
-				(Vector4D *)((byte *)pNewVvdHdr+pNewVvdHdr->tangentDataStart) + target,
+				(byte*)((Vector4D *)((byte *)pNewVvdHdr+pNewVvdHdr->tangentDataStart) + target),
-				(Vector4D *)((byte *)pTempVvdHdr+pTempVvdHdr->tangentDataStart) + pFixupTable[i].sourceVertexID,
+				(byte*)((Vector4D *)((byte *)pTempVvdHdr+pTempVvdHdr->tangentDataStart) + pFixupTable[i].sourceVertexID),
 				pFixupTable[i].numVertexes*sizeof(Vector4D) );
 		}
 

public/tier0/basetypes.h

@@ -325,7 +325,7 @@ template< class DummyType >
 class CIntHandle16 : public CBaseIntHandle< unsigned short >
 {
 public:
-	inline			CIntHandle16() {}
+	inline			CIntHandle16() = default;
 
 	static inline	CIntHandle16<DummyType> MakeHandle( HANDLE_TYPE val )
 	{
@@ -344,7 +344,7 @@ template< class DummyType >
 class CIntHandle32 : public CBaseIntHandle< unsigned long >
 {
 public:
-	inline			CIntHandle32() {}
+	inline			CIntHandle32() = default;
 
 	static inline	CIntHandle32<DummyType> MakeHandle( HANDLE_TYPE val )
 	{

public/tier0/dynfunction.h

@@ -118,7 +118,7 @@ template < class FunctionType >
 class CDynamicFunctionMustInit : public CDynamicFunction < FunctionType >
 {
 private:  // forbid default constructor.
-	CDynamicFunctionMustInit() {}
+	CDynamicFunctionMustInit() = default;
 
 public:
 	CDynamicFunctionMustInit(const char *libname, const char *fn, FunctionType fallback=NULL)

public/tier0/fasttimer.h

@@ -494,7 +494,7 @@ inline CAverageTimeMarker::~CAverageTimeMarker()
 class CLimitTimer
 {
 public:
-	CLimitTimer() {}
+	CLimitTimer() = default;
 	CLimitTimer( uint64 cMicroSecDuration ) { SetLimit( cMicroSecDuration ); }
 	void SetLimit( uint64 m_cMicroSecDuration );
 	bool BLimitReached() const;

public/tier0/platform.h

@@ -1266,12 +1266,12 @@ struct CPUInformation
 
 	uint8 m_nLogicalProcessors;		// Number op logical processors.
 	uint8 m_nPhysicalProcessors;	// Number of physical processors
-	
+
 	bool m_bSSE3 : 1,
 		 m_bSSSE3 : 1,
 		 m_bSSE4a : 1,
 		 m_bSSE41 : 1,
-		 m_bSSE42 : 1;	
+		 m_bSSE42 : 1;
 
 	int64 m_Speed;						// In cycles per second.
 
@@ -1280,7 +1280,7 @@ struct CPUInformation
 	uint32 m_nModel;
 	uint32 m_nFeatures[3];
 
-	CPUInformation(): m_Size(0){}
+	CPUInformation() = default;
 };
 
 // Have to return a pointer, not a reference, because references are not compatible with the

public/tier0/threadtools.h

@@ -609,7 +609,7 @@ private:
 	class CThreadLocalPtr : private CThreadLocalBase
 	{
 	public:
-		CThreadLocalPtr() {}
+		CThreadLocalPtr() = default;
 
 		operator const void *() const          					{ return (const T *)Get(); }
 		operator void *()                      					{ return (T *)Get(); }

public/tier0/tslist.h

@@ -433,7 +433,7 @@ class TSLIST_HEAD_ALIGN CTSList : public CTSListBase
 public:
 	struct TSLIST_NODE_ALIGN Node_t : public TSLNodeBase_t
 	{
-		Node_t() {}
+		Node_t() = default;
 		Node_t( const T &init ) : elem( init ) {}
 		T elem;
 
@@ -524,7 +524,7 @@ class TSLIST_HEAD_ALIGN CTSListWithFreeList : public CTSListBase
 public:
 	struct TSLIST_NODE_ALIGN Node_t : public TSLNodeBase_t
 	{
-		Node_t() {}
+		Node_t() = default;
 		Node_t( const T &init ) : elem( init ) {}
 
 		T elem;
@@ -692,7 +692,7 @@ public:
 			MemAlloc_FreeAligned( p );
 		}
 
-		Node_t() {}
+		Node_t() = default;
 		Node_t( const T &init ) : elem( init ) {}
 
 		Node_t *pNext;

public/tier1/memhelpers.h

@@ -0,0 +1,32 @@
+// ======= Copyright nillerusr, 2022 =======
+
+// Helper аunctions for setting/сopying memory ( specially for non-POD types )
+// FUCK STL
+
+#ifndef MEMHELPERS_H
+#define MEMHELPERS_H
+
+namespace memutils
+{
+	template<typename T>
+	inline void copy( T *dest, const T *src, size_t n )
+	{
+		do
+		{
+			--n;
+			*(dest+n) = *(src+n);
+	        } while( n );
+	}
+
+	template<typename T>
+	inline void set( T *dest, T value, size_t n )
+	{
+		do
+		{
+			--n;
+			*(dest+n) = value;
+		} while( n );
+	}
+}
+
+#endif //MEMHELPERS_H

public/tier1/refcount.h

@@ -167,7 +167,7 @@ class CRefPtr : public CBaseAutoPtr<T>
 {
 	typedef CBaseAutoPtr<T> BaseClass;
 public:
-	CRefPtr()												{}
+	CRefPtr() = default;
 	CRefPtr( T *pInit )										: BaseClass( pInit ) {}
 	CRefPtr( const CRefPtr<T> &from )						: BaseClass( from ) {}
 	~CRefPtr()												{ if ( BaseClass::m_pObject ) BaseClass::m_pObject->Release(); }

public/tier1/utlcommon.h

@@ -57,7 +57,7 @@ public:
 	K m_key;
 	V m_value;
 
-	CUtlKeyValuePair() {}
+	CUtlKeyValuePair() = default;
 
 	template < typename KInit >
 	explicit CUtlKeyValuePair( const KInit &k ) : m_key( k ) {}
@@ -76,7 +76,7 @@ public:
 	typedef const K ValueReturn_t;
 	K m_key;
 
-	CUtlKeyValuePair() {}
+	CUtlKeyValuePair() = default;
 
 	template < typename KInit >
 	explicit CUtlKeyValuePair( const KInit &k ) : m_key( k ) {}

public/tier1/utllinkedlist.h

@@ -257,9 +257,8 @@ public:
 		typedef _CUtlLinkedList_constiterator_t< List_t > Base;
 
 		// Default constructor -- gives a currently unusable iterator.
-		_CUtlLinkedList_iterator_t()
+		_CUtlLinkedList_iterator_t() = default;
-		{
+
-		}
 		// Normal constructor.
 		_CUtlLinkedList_iterator_t( const List_t& list, IndexType_t index )
 			: _CUtlLinkedList_constiterator_t< List_t >( list, index )
@@ -1231,7 +1230,7 @@ private:
 
 	struct Node_t
 	{
-		Node_t() {}
+		Node_t() = default;
 		Node_t( const T &_elem ) : elem( _elem ) {}
 
 		T elem;

public/tier1/utlmap.h

@@ -175,9 +175,7 @@ public:
 
 	struct Node_t
 	{
-		Node_t()
+		Node_t() = default;
-		{
-		}
 
 		Node_t( const Node_t &from )
 		  : key( from.key ),

public/tier1/utlpair.h

@@ -17,7 +17,7 @@ template<typename T1, typename T2>
 class CUtlPair
 {
 public:
-	CUtlPair() {}
+	CUtlPair() = default;
 	CUtlPair( T1 t1, T2 t2 ) : first( t1 ), second( t2 ) {}
 
 	bool operator<( const CUtlPair<T1,T2> &rhs ) const {

public/tier1/utlrbtree.h

@@ -32,7 +32,7 @@ template <typename T>
 class CDefLess
 {
 public:
-	CDefLess() {}
+	CDefLess() = default;
 	CDefLess( int i ) {}
 	inline bool operator()( const T &lhs, const T &rhs ) const { return ( lhs < rhs );	}
 	inline bool operator!() const { return false; }

public/tier1/utlsoacontainer.h

@@ -39,7 +39,7 @@ public:
 		m_nStride = nByteStride / sizeof( T );
 	}
 
-	FORCEINLINE CStridedPtr<T>( void ) {}
+	FORCEINLINE CStridedPtr<T>( void ) = default;
 	T *operator->(void) const
 	{
 		return m_pData;
@@ -81,7 +81,7 @@ public:
 		m_nStride = nByteStride / sizeof( T );
 	}
 
-	FORCEINLINE CStridedConstPtr<T>( void ) {}
+	FORCEINLINE CStridedConstPtr<T>( void ) = default;
 
 	const T *operator->(void) const
 	{

public/tier1/utlsymbol.h

@@ -138,9 +138,7 @@ protected:
 	class CStringPoolIndex
 	{
 	public:
-		inline CStringPoolIndex()
+		inline CStringPoolIndex() = default;
-		{
-		}
 
 		inline CStringPoolIndex( unsigned short iPool, unsigned short iOffset )
 			: 	m_iPool(iPool), m_iOffset(iOffset)

public/tier1/utlvector.h

@@ -1487,7 +1487,7 @@ public:
 		return strcmp( *sz1, *sz2 );
 	}
 
-	CUtlStringList(){}
+	CUtlStringList() = default;
 
 	CUtlStringList( char const *pString, char const *pSeparator )
 	{

public/tier2/p4helpers.h

@@ -69,9 +69,7 @@ public:
 class CP4Factory
 {
 public:
-	CP4Factory();
+	CP4Factory() = default;
-	~CP4Factory();
-
 public:
 	// Sets whether dummy objects are created by the factory.
 	// Returns the old state of the dummy mode.

public/trace.h

@@ -59,7 +59,7 @@ public:
 	bool			allsolid;				// if true, plane is not valid
 	bool			startsolid;				// if true, the initial point was in a solid area
 
-	CBaseTrace() {}
+	CBaseTrace() = default;
 
 private:
 	// No copy constructors allowed

public/vcollide_parse.h

@@ -30,7 +30,7 @@ struct fluid_t
 
 	fluidparams_t params;
 
-	fluid_t() {}
+	fluid_t() = default;
 	fluid_t( fluid_t const& src ) : params(src.params)
 	{
 		index = src.index;

public/vgui/Dar.h

@@ -30,9 +30,8 @@ template<class ELEMTYPE> class Dar : public CUtlVector< ELEMTYPE >
 	typedef CUtlVector< ELEMTYPE > BaseClass;
 	
 public:
-	Dar()
+	Dar() = default;
-	{
+
-	}
 	Dar(int initialCapacity) :
 		BaseClass( 0, initialCapacity )
 	{

public/vgui/ISurface.h

@@ -51,7 +51,7 @@ typedef unsigned long HFont;
 
 struct Vertex_t
 {
-	Vertex_t() {}
+	Vertex_t() = default;
 	Vertex_t( const Vector2D &pos, const Vector2D &coord = Vector2D( 0, 0 ) )
 	{
 		m_Position = pos;

public/vgui_controls/HTML.h

@@ -301,7 +301,7 @@ private:
 
 	struct CustomCursorCache_t
 	{
-		CustomCursorCache_t() {}
+		CustomCursorCache_t() = default;
 		CustomCursorCache_t( const void *pchData ) { m_pchData = pchData; }
 		float m_CacheTime; // the time we cached the cursor
 		CursorCode m_Cursor; // the vgui handle to it

public/vphysics/constraints.h

@@ -148,7 +148,7 @@ struct constraint_limitedhingeparams_t : public constraint_hingeparams_t
 	Vector							referencePerpAxisDirection;		// unit direction vector vector perpendicular to the hinge axis in world space
 	Vector							attachedPerpAxisDirection;		// unit direction vector vector perpendicular to the hinge axis in world space
 
-	constraint_limitedhingeparams_t() {}
+	constraint_limitedhingeparams_t() = default;
 	constraint_limitedhingeparams_t( const constraint_hingeparams_t &hinge )
 	{
 		static_cast<constraint_hingeparams_t &>(*this) = hinge;

public/vphysics_interface.h

@@ -1021,7 +1021,7 @@ struct fluidparams_t
 	bool		useAerodynamics;// true if this controller should calculate surface pressure
 	int			contents;
 
-	fluidparams_t() {}
+	fluidparams_t() = default;
 	fluidparams_t( fluidparams_t const& src )
 	{
 		Vector4DCopy( src.surfacePlane, surfacePlane );
@@ -1039,10 +1039,6 @@ struct fluidparams_t
 //-----------------------------------------------------------------------------
 struct springparams_t
 {
-	springparams_t()
-	{
-		memset( this, 0, sizeof(*this) );
-	}
 	float	constant;		// spring constant
 	float	naturalLength;// relaxed length
 	float	damping;		// damping factor