Fixed bitbuf compilation

external/sourcesdk/bitbuf.cpp

@@ -7,11 +7,8 @@
 //=============================================================================//
 
 #include "bitbuf.h"
-#include "coordsize.h"
+#include <string.h>
-#include "mathlib/vector.h"
+#include <math.h>
-#include "mathlib/mathlib.h"
-#include "tier1/strtools.h"
-#include "bitvec.h"
 
 // FIXME: Can't use this until we get multithreaded allocations in tier0 working for tools
 // This is used by VVIS and fails to link
@@ -476,7 +473,7 @@ bool bf_write::WriteBits(const void *pInData, int nBits)
 		int numbytes = nBitsLeft >> 3; 
 		int numbits = numbytes << 3;
 		
-		Q_memcpy( (char*)m_pData+(m_iCurBit>>3), pOut, numbytes );
+		memcpy( (char*)m_pData+(m_iCurBit>>3), pOut, numbytes );
 		pOut += numbytes;
 		nBitsLeft -= numbits;
 		m_iCurBit += numbits;
@@ -1446,7 +1443,7 @@ void bf_read::ExciseBits( int startbit, int bitstoremove )
 	m_nDataBytes = m_nDataBits >> 3;
 }
 
-int bf_read::CompareBitsAt( int offset, bf_read * RESTRICT other, int otherOffset, int numbits ) RESTRICT
+int bf_read::CompareBitsAt( int offset, bf_read * __restrict other, int otherOffset, int numbits ) __restrict
 {
 	extern unsigned long g_ExtraMasks[33];
 

external/sourcesdk/bitbuf.h

@@ -8,25 +8,9 @@
 
 // NOTE: bf_read is guaranteed to return zeros if it overflows.
 
-#ifndef BITBUF_H
-#define BITBUF_H
-
-#ifdef _WIN32
 #pragma once
-#endif
 
-
+#include "valve_support.h"
-#include "mathlib/mathlib.h"
-#include "mathlib/vector.h"
-#include "basetypes.h"
-#include "tier0/dbg.h"
-
-
-#if _DEBUG
-#define BITBUF_INLINE inline
-#else
-#define BITBUF_INLINE FORCEINLINE
-#endif
 
 //-----------------------------------------------------------------------------
 // Forward declarations.
@@ -255,7 +239,7 @@ public:
 
 public:
 	// The current buffer.
-	unsigned long* RESTRICT m_pData;
+	unsigned long* __restrict m_pData;
 	int				m_nDataBytes;
 	int				m_nDataBits;
 	
@@ -312,7 +296,7 @@ inline const unsigned char* bf_write::GetData()	const
 	return (unsigned char*) m_pData;
 }
 
-BITBUF_INLINE bool bf_write::CheckForOverflow(int nBits)
+inline bool bf_write::CheckForOverflow(int nBits)
 {
 	if ( m_iCurBit + nBits > m_nDataBits )
 	{
@@ -323,7 +307,7 @@ BITBUF_INLINE bool bf_write::CheckForOverflow(int nBits)
 	return m_bOverflow;
 }
 
-BITBUF_INLINE void bf_write::SetOverflowFlag()
+inline void bf_write::SetOverflowFlag()
 {
 #ifdef DBGFLAG_ASSERT
 	if ( m_bAssertOnOverflow )
@@ -334,7 +318,7 @@ BITBUF_INLINE void bf_write::SetOverflowFlag()
 	m_bOverflow = true;
 }
 
-BITBUF_INLINE void bf_write::WriteOneBitNoCheck(int nValue)
+inline void bf_write::WriteOneBitNoCheck(int nValue)
 {
 #if __i386__
 	if(nValue)
@@ -387,7 +371,7 @@ inline void	bf_write::WriteOneBitAt( int iBit, int nValue )
 #endif
 }
 
-BITBUF_INLINE void bf_write::WriteUBitLong( unsigned int curData, int numbits, bool bCheckRange ) RESTRICT
+inline void bf_write::WriteUBitLong( unsigned int curData, int numbits, bool bCheckRange ) __restrict
 {
 #ifdef _DEBUG
 	// Make sure it doesn't overflow.
@@ -414,8 +398,8 @@ BITBUF_INLINE void bf_write::WriteUBitLong( unsigned int curData, int numbits, b
 	m_iCurBit += numbits;
 
 	// Mask in a dword.
-	Assert( (iDWord*4 + sizeof(long)) <= (unsigned int)m_nDataBytes );
+	assert( (iDWord*4 + sizeof(long)) <= (unsigned int)m_nDataBytes );
-	unsigned long * RESTRICT pOut = &m_pData[iDWord];
+	unsigned long * __restrict pOut = &m_pData[iDWord];
 
 	// Rotate data into dword alignment
 	curData = (curData << iCurBitMasked) | (curData >> (32 - iCurBitMasked));
@@ -440,7 +424,7 @@ BITBUF_INLINE void bf_write::WriteUBitLong( unsigned int curData, int numbits, b
 }
 
 // writes an unsigned integer with variable bit length
-BITBUF_INLINE void bf_write::WriteUBitVar( unsigned int data )
+inline void bf_write::WriteUBitVar( unsigned int data )
 {
 	/* Reference:
 	if ( data < 0x10u )
@@ -463,7 +447,7 @@ BITBUF_INLINE void bf_write::WriteUBitVar( unsigned int data )
 }
 
 // write raw IEEE float bits in little endian form
-BITBUF_INLINE void bf_write::WriteBitFloat(float val)
+inline void bf_write::WriteBitFloat(float val)
 {
 	long intVal;
 
@@ -542,7 +526,7 @@ public:
 	// Get the base pointer.
 	const unsigned char*	GetBasePointer() { return m_pData; }
 
-	BITBUF_INLINE int TotalBytesAvailable( void ) const
+	inline int TotalBytesAvailable( void ) const
 	{
 		return m_nDataBytes;
 	}
@@ -565,8 +549,8 @@ public:
 	
 	float			ReadBitAngle( int numbits );
 
-	unsigned int	ReadUBitLong( int numbits ) RESTRICT;
+	unsigned int	ReadUBitLong( int numbits ) __restrict;
-	unsigned int	ReadUBitLongNoInline( int numbits ) RESTRICT;
+	unsigned int	ReadUBitLongNoInline( int numbits ) __restrict;
 	unsigned int	PeekUBitLong( int numbits );
 	int				ReadSBitLong( int numbits );
 
@@ -599,11 +583,11 @@ public:
 // Byte functions (these still read data in bit-by-bit).
 public:
 	
-	BITBUF_INLINE int	ReadChar() { return (char)ReadUBitLong(8); }
+	inline int	ReadChar() { return (char)ReadUBitLong(8); }
-	BITBUF_INLINE int	ReadByte() { return ReadUBitLong(8); }
+	inline int	ReadByte() { return ReadUBitLong(8); }
-	BITBUF_INLINE int	ReadShort() { return (short)ReadUBitLong(16); }
+	inline int	ReadShort() { return (short)ReadUBitLong(16); }
-	BITBUF_INLINE int	ReadWord() { return ReadUBitLong(16); }
+	inline int	ReadWord() { return ReadUBitLong(16); }
-	BITBUF_INLINE long ReadLong() { return ReadUBitLong(32); }
+	inline long ReadLong() { return ReadUBitLong(32); }
 	int64			ReadLongLong();
 	float			ReadFloat();
 	bool			ReadBytes(void *pOut, int nBytes);
@@ -628,8 +612,8 @@ public:
 	char*			ReadAndAllocateString( bool *pOverflow = 0 );
 
 	// Returns nonzero if any bits differ
-	int				CompareBits( bf_read * RESTRICT other, int bits ) RESTRICT;
+	int				CompareBits( bf_read * __restrict other, int bits ) __restrict;
-	int				CompareBitsAt( int offset, bf_read * RESTRICT other, int otherOffset, int bits ) RESTRICT;
+	int				CompareBitsAt( int offset, bf_read * __restrict other, int otherOffset, int bits ) __restrict;
 
 // Status.
 public:
@@ -651,7 +635,7 @@ public:
 public:
 
 	// The current buffer.
-	const unsigned char* RESTRICT m_pData;
+	const unsigned char* __restrict m_pData;
 	int						m_nDataBytes;
 	int						m_nDataBits;
 	
@@ -727,13 +711,19 @@ inline bool bf_read::CheckForOverflow(int nBits)
 
 inline int bf_read::ReadOneBitNoCheck()
 {
-#if VALVE_LITTLE_ENDIAN
+	int ret;
-	unsigned int value = ((unsigned long * RESTRICT)m_pData)[m_iCurBit >> 5] >> (m_iCurBit & 31);
+	if (is_little_endian())
-#else
+	{
+		unsigned int value = ((unsigned long * __restrict)m_pData)[m_iCurBit >> 5] >> (m_iCurBit & 31);
+		ret = value & 1;
+	}
+	else
+	{
 		unsigned char value = m_pData[m_iCurBit >> 3] >> (m_iCurBit & 7);
-#endif
+		ret = value & 1;
+	}
 	++m_iCurBit;
-	return value & 1;
+	return ret;
 }
 
 inline int bf_read::ReadOneBit()
@@ -753,7 +743,7 @@ inline float bf_read::ReadBitFloat()
 	return c.f;
 }
 
-BITBUF_INLINE unsigned int bf_read::ReadUBitVar()
+inline unsigned int bf_read::ReadUBitVar()
 {
 	// six bits: low 2 bits for encoding + first 4 bits of value
 	unsigned int sixbits = ReadUBitLong(6);
@@ -766,7 +756,7 @@ BITBUF_INLINE unsigned int bf_read::ReadUBitVar()
 	return sixbits >> 2;
 }
 
-BITBUF_INLINE unsigned int bf_read::ReadUBitLong( int numbits ) RESTRICT
+inline unsigned int bf_read::ReadUBitLong( int numbits ) __restrict
 {
 	Assert( numbits > 0 && numbits <= 32 );
 
@@ -791,19 +781,14 @@ BITBUF_INLINE unsigned int bf_read::ReadUBitLong( int numbits ) RESTRICT
 	unsigned int bitmask = g_ExtraMasks[numbits];
 #endif
 
-	unsigned int dw1 = LoadLittleDWord( (unsigned long* RESTRICT)m_pData, iWordOffset1 ) >> iStartBit;
+	unsigned int dw1 = LoadLittleDWord( (unsigned long* __restrict)m_pData, iWordOffset1 ) >> iStartBit;
-	unsigned int dw2 = LoadLittleDWord( (unsigned long* RESTRICT)m_pData, iWordOffset2 ) << (32 - iStartBit);
+	unsigned int dw2 = LoadLittleDWord( (unsigned long* __restrict)m_pData, iWordOffset2 ) << (32 - iStartBit);
 
 	return (dw1 | dw2) & bitmask;
 }
 
-BITBUF_INLINE int bf_read::CompareBits( bf_read * RESTRICT other, int numbits ) RESTRICT
+inline int bf_read::CompareBits( bf_read * __restrict other, int numbits ) __restrict
 {
 	return (ReadUBitLong(numbits) != other->ReadUBitLong(numbits));
 }
 
-
-#endif
-
-
-

external/sourcesdk/valve_support.h

@@ -0,0 +1,158 @@
+
+#pragma once
+
+#include <cstdint>
+#include <cassert>
+#include "vector.h"
+
+using uint64 = std::uint64_t;
+using uint32 = std::uint32_t;
+using uint16 = std::uint16_t;
+using uint8 = std::uint8_t;
+using int64 = std::int64_t;
+using int32 = std::int32_t;
+using int16 = std::int16_t;
+using int8 = std::int8_t;
+using uint = unsigned int;
+using byte = char;
+
+#if defined(_M_IX86)
+#define __i386__ 1
+#endif
+
+#define IsPC() true
+#ifdef _WIN64
+    #define PLATFORM_WINDOWS_PC64 1
+#endif
+
+#define NULL nullptr
+
+#define Assert(x) assert(x)
+#define AssertMsg(x, ...) assert(x)
+#define AssertMsg2(x, ...) assert(x)
+#define AssertFatalMsg(x, ...) assert(x)
+
+#define Q_memcpy memcpy
+
+bool is_little_endian()
+{
+    union {
+        uint32 i;
+        uint8 c[4];
+    } bint = { 0x01020304 };
+
+    return bint.c[0] == 4;
+}
+
+// OVERALL Coordinate Size Limits used in COMMON.C MSG_*BitCoord() Routines (and someday the HUD)
+#define	COORD_INTEGER_BITS			14
+#define COORD_FRACTIONAL_BITS		5
+#define COORD_DENOMINATOR			(1<<(COORD_FRACTIONAL_BITS))
+#define COORD_RESOLUTION			(1.0/(COORD_DENOMINATOR))
+
+// Special threshold for networking multiplayer origins
+#define COORD_INTEGER_BITS_MP		11
+#define COORD_FRACTIONAL_BITS_MP_LOWPRECISION 3
+#define COORD_DENOMINATOR_LOWPRECISION			(1<<(COORD_FRACTIONAL_BITS_MP_LOWPRECISION))
+#define COORD_RESOLUTION_LOWPRECISION			(1.0/(COORD_DENOMINATOR_LOWPRECISION))
+
+#define NORMAL_FRACTIONAL_BITS		11
+#define NORMAL_DENOMINATOR			( (1<<(NORMAL_FRACTIONAL_BITS)) - 1 )
+#define NORMAL_RESOLUTION			(1.0/(NORMAL_DENOMINATOR))
+
+template <typename T>
+inline T DWordSwapC( T dw )
+{
+   uint32 temp;
+   temp  =   *((uint32 *)&dw)               >> 24;
+   temp |= ((*((uint32 *)&dw) & 0x00FF0000) >> 8);
+   temp |= ((*((uint32 *)&dw) & 0x0000FF00) << 8);
+   temp |= ((*((uint32 *)&dw) & 0x000000FF) << 24);
+   return *((T*)&temp);
+}
+
+#if defined( _MSC_VER ) && !defined( PLATFORM_WINDOWS_PC64 )
+    #define DWordSwap  DWordSwapAsm
+    #pragma warning(push)
+    #pragma warning (disable:4035) // no return value
+    template <typename T>
+    inline T DWordSwapAsm( T dw )
+    {
+        __asm
+        {
+            mov eax, dw
+            bswap eax
+        }
+    }
+    #pragma warning(pop)
+#else
+    #define DWordSwap DWordSwapC
+#endif
+
+inline unsigned long LoadLittleDWord(const unsigned long *base, unsigned int dwordIndex)
+{
+    return (is_little_endian() ? base[dwordIndex] : (DWordSwap(base[dwordIndex])));
+}
+
+inline void StoreLittleDWord(unsigned long *base, unsigned int dwordIndex, unsigned long dword)
+{
+    base[dwordIndex] = (is_little_endian() ? dword : (DWordSwap(dword)));
+}
+
+// If a swapped float passes through the fpu, the bytes may get changed.
+// Prevent this by swapping floats as DWORDs.
+#define SafeSwapFloat( pOut, pIn ) (*((uint*)pOut) = DWordSwap( *((uint*)pIn) ))
+
+inline void LittleFloat(float* pOut, float* pIn)
+{
+    if (is_little_endian())
+    {
+        *pOut = *pIn;
+    }
+    else
+    {
+        SafeSwapFloat(pOut, pIn);
+    }
+}
+
+#define BITS_PER_INT 32
+
+inline int GetBitForBitnum( int bitNum ) 
+{ 
+    static int bitsForBitnum[] = 
+    {
+        ( 1 << 0 ),
+        ( 1 << 1 ),
+        ( 1 << 2 ),
+        ( 1 << 3 ),
+        ( 1 << 4 ),
+        ( 1 << 5 ),
+        ( 1 << 6 ),
+        ( 1 << 7 ),
+        ( 1 << 8 ),
+        ( 1 << 9 ),
+        ( 1 << 10 ),
+        ( 1 << 11 ),
+        ( 1 << 12 ),
+        ( 1 << 13 ),
+        ( 1 << 14 ),
+        ( 1 << 15 ),
+        ( 1 << 16 ),
+        ( 1 << 17 ),
+        ( 1 << 18 ),
+        ( 1 << 19 ),
+        ( 1 << 20 ),
+        ( 1 << 21 ),
+        ( 1 << 22 ),
+        ( 1 << 23 ),
+        ( 1 << 24 ),
+        ( 1 << 25 ),
+        ( 1 << 26 ),
+        ( 1 << 27 ),
+        ( 1 << 28 ),
+        ( 1 << 29 ),
+        ( 1 << 30 ),
+        ( 1 << 31 ),
+    };
+    return bitsForBitnum[ (bitNum) & (BITS_PER_INT-1) ]; 
+}

external/sourcesdk/vector.h

@@ -0,0 +1,53 @@
+
+#pragma once
+
+#include <cassert>
+
+class QAngle
+{
+public:
+    float x, y, z;
+    void Init( void )
+    {
+        x = y = z = 0.0f;
+    }
+    void Init( float _x, float _y, float _z )
+    {
+        x = _x;
+        y = _y;
+        z = _z;
+    }
+};
+
+class Vector
+{
+public:
+    float x, y, z;
+    Vector()
+    {
+    }
+    Vector(float X, float Y, float Z)
+    {
+        x = X; y = Y; z = Z;
+    }
+    void Init( void )
+    {
+        x = y = z = 0.0f;
+    }
+    void Init( float _x, float _y, float _z )
+    {
+        x = _x;
+        y = _y;
+        z = _z;
+    }
+    float& Vector::operator[](int i)
+    {
+        assert( (i >= 0) && (i < 3) );
+        return ((float*)this)[i];
+    }
+    float Vector::operator[](int i) const
+    {
+        assert( (i >= 0) && (i < 3) );
+        return ((float*)this)[i];
+    }
+};