1HEADmaster

1 files changed, 650 insertions, 0 deletions

diff --git a/external/vpc/public/tier0/basetypes.h b/external/vpc/public/tier0/basetypes.h
new file mode 100644
index 0000000..caa297e
--- /dev/null
+++ b/external/vpc/public/tier0/basetypes.h
@@ -0,0 +1,650 @@
+//========= Copyright 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef BASETYPES_H
+#define BASETYPES_H
+
+#ifdef COMPILER_MSVC
+#pragma once
+#endif
+
+// This is a trick to get the DLL extension off the -D option on the command line.
+#define DLLExtTokenPaste(x) #x
+#define DLLExtTokenPaste2(x) DLLExtTokenPaste(x)
+#define DLL_EXT_STRING DLLExtTokenPaste2( _DLL_EXT )
+
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef schema
+#define schema namespace ValveSchemaMarker {}
+#endif
+
+#ifdef COMPILING_SCHEMA
+#define UNSCHEMATIZED_METHOD( x )
+#else
+#define UNSCHEMATIZED_METHOD( x ) x
+#endif
+
+//////////////////////////////////////////////////////////////////////////
+
+#include "tier0/platform.h"
+#include "commonmacros.h"
+#include "wchartypes.h"
+#ifdef _PS3
+#include <float.h>
+#elif defined( PLATFORM_POSIX )
+#include <math.h>
+#endif
+
+#include "tier0/valve_off.h"
+
+// There's a different version of this file in the xbox codeline
+// so the PC version built in the xbox branch includes things like 
+// tickrate changes.
+#include "xbox_codeline_defines.h"
+
+#if defined(_PS3)
+#include <ppu_intrinsics.h>
+#include <sys/fs.h>
+#define PATH_MAX CELL_FS_MAX_FS_PATH_LENGTH
+#define _MAX_PATH PATH_MAX
+#endif
+// stdio.h
+#ifndef NULL
+#define NULL 0
+#endif
+
+#ifdef PLATFORM_POSIX
+#include <stdint.h>
+
+template<class T>
+T abs( const T &a )
+{
+	if ( a < 0 )
+		return -a;
+	else
+		return a;
+}
+#endif
+
+#define ExecuteNTimes( nTimes, x )	\
+	{								\
+	static int __executeCount=0;\
+	if ( __executeCount < nTimes )\
+		{							\
+			++__executeCount;		\
+			x;						\
+		}							\
+	}
+
+
+#define ExecuteOnce( x )			ExecuteNTimes( 1, x )
+
+
+
+// Pad a number so it lies on an N byte boundary.
+// So PAD_NUMBER(0,4) is 0 and PAD_NUMBER(1,4) is 4
+#define PAD_NUMBER(number, boundary) \
+	( ((number) + ((boundary)-1)) / (boundary) ) * (boundary)
+
+// In case this ever changes
+#ifndef M_PI
+#define M_PI			3.14159265358979323846
+#endif
+
+
+// #define COMPILETIME_MAX and COMPILETIME_MIN for max/min in constant expressions
+#define COMPILETIME_MIN( a, b ) ( ( ( a ) < ( b ) ) ? ( a ) : ( b ) )
+#define COMPILETIME_MAX( a, b ) ( ( ( a ) > ( b ) ) ? ( a ) : ( b ) )
+#ifndef MIN
+#define MIN( a, b ) ( ( ( a ) < ( b ) ) ? ( a ) : ( b ) )
+#endif
+
+#ifndef MAX
+#define MAX( a, b ) ( ( ( a ) > ( b ) ) ? ( a ) : ( b ) )
+#endif
+
+
+
+
+#ifdef __cplusplus
+
+template< class T, class Y, class X >
+inline T clamp( T const &val, Y const &minVal, X const &maxVal )
+{
+	if( val < minVal )
+		return minVal;
+	else if( val > maxVal )
+		return maxVal;
+	else
+		return val;
+}
+
+#else
+
+#define clamp(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
+
+#endif
+
+#ifndef FALSE
+#define FALSE 0
+#define TRUE (!FALSE)
+#endif
+
+//-----------------------------------------------------------------------------
+// fsel
+//-----------------------------------------------------------------------------
+#if !defined(_PS3) && !defined(_X360)
+
+#define fsel(c,x,y) ( (c) >= 0 ? (x) : (y) )
+
+// integer conditional move
+// if a >= 0, return x, else y
+#define isel(a,x,y) ( ((a) >= 0) ? (x) : (y) )
+
+// if x = y, return a, else b
+#define ieqsel(x,y,a,b) (( (x) == (y) ) ? (a) : (b))
+
+// if the nth bit of a is set (counting with 0 = LSB),
+// return x, else y
+// this is fast if nbit is a compile-time immediate 
+#define ibitsel(a, nbit, x, y) ( ( ((a) & (1 << (nbit))) != 0 ) ? (x) : (y) )
+
+
+FORCEINLINE double fpmin( double a, double b )
+{
+	return a > b  ? b : a;
+}
+
+FORCEINLINE double fpmax( double a, double b )
+{
+	return a >= b ? a : b;
+}
+
+// clamp x to lie inside [a,b]. Assumes b>a
+FORCEINLINE float fclamp( float x, float a, float b )
+{
+	return fpmin( fpmax( x, a ), b );
+}
+// clamp x to lie inside [a,b]. Assumes b>a
+FORCEINLINE double fclamp( double x, double a, double b )
+{
+	return fpmin( fpmax( x, a ), b );
+}
+
+// At some point, we will need a unified API.
+#define imin( x, y ) ( (x) < (y) ? (x) : (y) )
+#define imax( x, y ) ( (x) > (y) ? (x) : (y) )
+#define iclamp clamp
+
+#else
+
+// __fsel(double fComparand, double fValGE, double fLT) == fComparand >= 0 ? fValGE : fLT
+// this is much faster than if ( aFloat > 0 ) { x = .. }
+// the XDK defines two intrinsics, one for floats and one for doubles -- it's the same
+// opcode, but the __fself version tells the compiler not to do a wasteful unnecessary
+// rounding op after each sel.
+// #define fsel __fsel
+#ifdef _X360
+FORCEINLINE double fsel(double fComparand, double fValGE, double fLT) { return __fsel( fComparand, fValGE, fLT ); }
+FORCEINLINE float fsel(float fComparand, float fValGE, float fLT) { return __fself( fComparand, fValGE, fLT ); }
+#else
+FORCEINLINE double fsel(double fComparand, double fValGE, double fLT) { return __fsel( fComparand, fValGE, fLT ); }
+FORCEINLINE float fsel(float fComparand, float fValGE, float fLT) { return __fsels( fComparand, fValGE, fLT ); }
+#endif
+
+#if !defined(_X360)
+FORCEINLINE float fpmin( float a, float b )
+{
+	return fsel( a-b, b,a);
+}
+FORCEINLINE double fpmin( double a, double b )
+{
+	return fsel( a-b, b,a);
+}
+
+FORCEINLINE float fpmax( float a, float b )
+{
+	return fsel( a-b, a,b);
+}
+FORCEINLINE double fpmax( double a, double b )
+{
+	return fsel( a-b, a,b);
+}
+
+// any mixed calls should promote to double
+FORCEINLINE double fpmax(float a, double b)
+{
+	return fpmax( (double) a, b );
+}
+// any mixed calls should promote to double
+FORCEINLINE double fpmax(double a, float b)
+{
+	return fpmax( (double) a, (double) b );
+}
+#endif
+
+// clamp x to lie inside [a,b]. Assumes b>a
+FORCEINLINE float fclamp( float x, float a, float b )
+{
+	return fpmin( fpmax( x, a ), b );
+}
+// clamp x to lie inside [a,b]. Assumes b>a
+FORCEINLINE double fclamp( double x, double a, double b )
+{
+	return fpmin( fpmax( x, a ), b );
+}
+
+// if a >= 0, return x, else y
+FORCEINLINE int isel( int a, int x, int y )
+{
+	int mask = a >> 31; // arithmetic shift right, splat out the sign bit
+	return x + ((y - x) & mask);
+};
+
+// if a >= 0, return x, else y
+FORCEINLINE unsigned isel( int a, unsigned x, unsigned y )
+{
+	int mask = a >> 31; // arithmetic shift right, splat out the sign bit
+	return x + ((y - x) & mask);
+};
+
+// ( x == y ) ? a : b
+FORCEINLINE unsigned ieqsel( unsigned x, unsigned y, unsigned a, unsigned b )
+{
+	unsigned mask = (x == y) ? 0 : -1;
+	return a + ((b - a) & mask);
+};
+
+// ( x == y ) ? a : b
+FORCEINLINE int ieqsel( int x, int y, int a, int b )
+{
+	int mask = (x == y) ? 0 : -1;
+	return a + ((b - a) & mask);
+};
+
+FORCEINLINE int imin( int x, int y )
+{
+	int nMaxSign = x - y;									// Positive if x greater than y
+	int nMaxMask = nMaxSign >> 31;							// 0 if x greater than y, 0xffffffff if x smaller than y
+	int nMaxSaturated = y + ( nMaxSign & nMaxMask );
+	return nMaxSaturated;
+}
+
+FORCEINLINE int imax( int x, int y )
+{
+	int nMinSign = y - x;									// Positive if x smaller than y
+	int nMinMask = nMinSign >> 31;							// 0 if x smaller than y, 0xffffffff if x greater than y
+	int nMinSaturated = y - ( nMinSign & nMinMask);
+	return nMinSaturated;
+}
+
+FORCEINLINE int iclamp( int x, int min, int max )
+{
+	int nResult = imin( x, max );
+	return imax( nResult, min );
+}
+
+// if the nth bit of a is set (counting with 0 = LSB),
+// return x, else y
+// this is fast if nbit is a compile-time immediate 
+#define ibitsel(a, nbit, x, y) ( (x) + (((y) - (x)) & (((a) & (1 << (nbit))) ? 0 : -1)) )
+
+#endif
+
+#if CROSS_PLATFORM_VERSION < 1
+
+#ifndef DONT_DEFINE_BOOL // Needed for Cocoa stuff to compile.
+typedef int BOOL;
+#endif
+
+typedef int qboolean;
+//typedef uint32 ULONG;
+typedef uint8 BYTE;
+typedef uint8 byte;
+typedef uint16 word;
+#endif
+
+#if defined( _WIN32 ) || defined( _PS3 )
+typedef wchar_t ucs2; // under windows & PS3 wchar_t is ucs2
+#else
+typedef unsigned short ucs2;
+#endif
+
+enum ThreeState_t
+{
+	TRS_FALSE,
+	TRS_TRUE,
+	TRS_NONE,
+};
+
+typedef float vec_t;
+#ifdef _WIN32
+typedef __int32 vec_t_as_gpr; // a general purpose register type equal in size to a vec_t (in case we have to avoid the fpu for some reason)
+#endif
+
+
+template <typename T>
+inline T AlignValue( T val, uintp alignment )
+{
+	return (T)( ( (uintp)val + alignment - 1 ) & ~( alignment - 1 ) );
+}
+
+
+// FIXME: this should move 
+#ifndef __cplusplus
+#define true TRUE
+#define false FALSE
+#endif
+
+//-----------------------------------------------------------------------------
+// look for NANs, infinities, and underflows. 
+// This assumes the ANSI/IEEE 754-1985 standard
+//-----------------------------------------------------------------------------
+
+#ifdef __cplusplus
+
+inline uint32 FloatBits( const vec_t &f )
+{
+	union Convertor_t
+	{
+		vec_t f;
+		uint32 ul;
+	}tmp;
+	
+	switch( false ) { case false: ; case (sizeof( tmp ) == 4 && sizeof( tmp.f ) == 4 && sizeof( tmp.ul ) == 4):; };
+	tmp.f = f;
+	return tmp.ul;
+}
+
+inline vec_t BitsToFloat( uint32 i )
+{
+	union Convertor_t
+	{
+		vec_t f;
+		uint32 ul;
+	}tmp;
+	switch( false ) { case false: ; case (sizeof( tmp ) == 4 && sizeof( tmp.f ) == 4 && sizeof( tmp.ul ) == 4 ):; };
+	tmp.ul = i;
+	return tmp.f;
+}
+
+inline bool IsFinite( const vec_t &f )
+{
+#ifdef _GAMECONSOLE
+	return f == f && fabs(f) <= FLT_MAX;
+#else
+	return ((FloatBits(f) & 0x7F800000) != 0x7F800000);
+#endif
+}
+
+#if defined( WIN32 )
+
+//#include <math.h>
+// Just use prototype from math.h
+#ifdef __cplusplus
+extern "C" 
+{
+#endif
+	double __cdecl fabs(double);
+	//_CRT_JIT_INTRINSIC  _CRTIMP float  __cdecl fabsf( __in float  _X);
+	float __cdecl fabsf( _In_ float );
+#ifdef __cplusplus
+}
+#endif
+
+// In win32 try to use the intrinsic fabs so the optimizer can do it's thing inline in the code
+#pragma intrinsic( fabs )
+// Also, alias float make positive to use fabs, too
+// NOTE:  Is there a perf issue with double<->float conversion?
+inline float FloatMakePositive( vec_t f )
+{
+	return fabsf( f );
+}
+#else
+inline float FloatMakePositive( vec_t f )
+{
+	return fabsf(f); // was since 2002: BitsToFloat( FloatBits(f) & 0x7FFFFFFF ); fixed in 2010
+}
+#endif
+
+inline float FloatNegate( vec_t f )
+{
+	return -f; //BitsToFloat( FloatBits(f) ^ 0x80000000 );
+}
+
+
+#define FLOAT32_NAN_BITS     (uint32)0x7FC00000	// not a number!
+#define FLOAT32_NAN          BitsToFloat( FLOAT32_NAN_BITS )
+
+#define VEC_T_NAN FLOAT32_NAN
+
+#endif
+
+inline float FloatMakeNegative( vec_t f )
+{
+	return -fabsf( f );// was since 2002: BitsToFloat( FloatBits(f) | 0x80000000 ); fixed in 2010
+}
+
+
+// FIXME: why are these here?  Hardly anyone actually needs them.
+struct color24
+{
+	byte r, g, b;
+};
+
+typedef struct color32_s
+{
+	bool operator!=( const struct color32_s &other ) const;
+	byte r, g, b, a; 
+
+	// assign and copy by using the whole register rather
+	// than byte-by-byte copy. (No, the compiler is not
+	// smart enough to do this for you. /FAcs if you 
+	// don't believe me.)
+	inline unsigned *asInt(void) { return reinterpret_cast<unsigned*>(this); }
+	inline const unsigned *asInt(void) const { return reinterpret_cast<const unsigned*>(this); } 
+	// This thing is in a union elsewhere, and union members can't have assignment
+	// operators, so you have to explicitly assign using this, or be slow. SUCK.
+	inline void Copy(const color32_s &rhs)
+	{
+		*asInt() = *rhs.asInt();
+	}
+
+} color32;
+
+inline bool color32::operator!=( const color32 &other ) const
+{
+	return r != other.r || g != other.g || b != other.b || a != other.a;
+}
+
+struct colorVec
+{
+	unsigned r, g, b, a;
+};
+
+
+#ifndef NOTE_UNUSED
+#define NOTE_UNUSED(arg) ((void)arg)	// for pesky compiler / lint warnings
+#endif
+#ifdef __cplusplus
+
+struct vrect_t
+{
+	int				x,y,width,height;
+	vrect_t			*pnext;
+};
+
+#endif
+
+
+//-----------------------------------------------------------------------------
+// MaterialRect_t struct - used for DrawDebugText
+//-----------------------------------------------------------------------------
+struct Rect_t
+{
+	int x, y;
+	int width, height;
+};
+
+struct Rect3D_t
+{
+	int x, y, z;
+	int width, height, depth;
+
+	FORCEINLINE Rect3D_t( int nX, int nY, int nZ, int nWidth, int nHeight, int nDepth )
+	{
+		x = nX;
+		y = nY;
+		z = nZ;
+		width = nWidth;
+		height = nHeight;
+		depth = nDepth;
+	}
+
+	FORCEINLINE Rect3D_t( void )
+	{
+	}
+
+};
+
+
+
+//-----------------------------------------------------------------------------
+// Interval, used by soundemittersystem + the game
+//-----------------------------------------------------------------------------
+struct interval_t
+{
+	float start;
+	float range;
+};
+
+
+//-----------------------------------------------------------------------------
+// Declares a type-safe handle type; you can't assign one handle to the next
+//-----------------------------------------------------------------------------
+
+// 32-bit pointer handles.
+
+// Typesafe 8-bit and 16-bit handles.
+template< class HandleType >
+class CBaseIntHandle
+{
+public:
+
+	inline bool			operator==( const CBaseIntHandle &other )	{ return m_Handle == other.m_Handle; }
+	inline bool			operator!=( const CBaseIntHandle &other )	{ return m_Handle != other.m_Handle; }
+
+	// Only the code that doles out these handles should use these functions.
+	// Everyone else should treat them as a transparent type.
+	inline HandleType	GetHandleValue()					{ return m_Handle; }
+	inline void			SetHandleValue( HandleType val )	{ m_Handle = val; }
+
+	typedef HandleType	HANDLE_TYPE;
+
+protected:
+
+	HandleType	m_Handle;
+};
+
+template< class DummyType >
+class CIntHandle16 : public CBaseIntHandle< unsigned short >
+{
+public:
+	inline			CIntHandle16() {}
+
+	static inline	CIntHandle16<DummyType> MakeHandle( HANDLE_TYPE val )
+	{
+		return CIntHandle16<DummyType>( val );
+	}
+
+protected:
+	inline			CIntHandle16( HANDLE_TYPE val )
+	{
+		m_Handle = val;
+	}
+};
+
+
+template< class DummyType >
+class CIntHandle32 : public CBaseIntHandle< uint32 >
+{
+public:
+	inline			CIntHandle32() {}
+
+	static inline	CIntHandle32<DummyType> MakeHandle( HANDLE_TYPE val )
+	{
+		return CIntHandle32<DummyType>( val );
+	}
+
+protected:
+	inline			CIntHandle32( HANDLE_TYPE val )
+	{
+		m_Handle = val;
+	}
+};
+
+
+// NOTE: This macro is the same as windows uses; so don't change the guts of it
+#define DECLARE_HANDLE_16BIT(name)	typedef CIntHandle16< struct name##__handle * > name;
+#define DECLARE_HANDLE_32BIT(name)	typedef CIntHandle32< struct name##__handle * > name;
+
+#define DECLARE_POINTER_HANDLE(name) struct name##__ { int unused; }; typedef struct name##__ *name
+#define FORWARD_DECLARE_HANDLE(name) typedef struct name##__ *name
+
+#define DECLARE_DERIVED_POINTER_HANDLE( _name, _basehandle ) struct _name##__ : public _basehandle##__ {}; typedef struct _name##__ *_name
+#define DECLARE_ALIASED_POINTER_HANDLE( _name, _alias ) typedef struct _alias##__ *name
+
+// @TODO: Find a better home for this
+#if !defined(_STATIC_LINKED) && !defined(PUBLISH_DLL_SUBSYSTEM)
+// for platforms built with dynamic linking, the dll interface does not need spoofing
+#define PUBLISH_DLL_SUBSYSTEM()
+#endif
+
+#define UID_PREFIX generated_id_
+#define UID_CAT1(a,c) a ## c
+#define UID_CAT2(a,c) UID_CAT1(a,c)
+#define EXPAND_CONCAT(a,c) UID_CAT1(a,c)
+#ifdef _MSC_VER
+#define UNIQUE_ID UID_CAT2(UID_PREFIX,__COUNTER__)
+#else
+#define UNIQUE_ID UID_CAT2(UID_PREFIX,__LINE__)
+#endif
+
+#define _MKSTRING(arg) #arg
+#define MKSTRING(arg) _MKSTRING(arg)
+
+
+// this allows enumerations to be used as flags, and still remain type-safe!
+#define DEFINE_ENUM_BITWISE_OPERATORS( Type ) \
+	inline Type  operator|  ( Type  a, Type b ) { return Type( int( a ) | int( b ) ); } \
+	inline Type  operator&  ( Type  a, Type b ) { return Type( int( a ) & int( b ) ); } \
+	inline Type  operator^  ( Type  a, Type b ) { return Type( int( a ) ^ int( b ) ); } \
+	inline Type  operator<< ( Type  a, int  b ) { return Type( int( a ) << b ); } \
+	inline Type  operator>> ( Type  a, int  b ) { return Type( int( a ) >> b ); } \
+	inline Type &operator|= ( Type &a, Type b ) { return a = a |  b; } \
+	inline Type &operator&= ( Type &a, Type b ) { return a = a &  b; } \
+	inline Type &operator^= ( Type &a, Type b ) { return a = a ^  b; } \
+	inline Type &operator<<=( Type &a, int  b ) { return a = a << b; } \
+	inline Type &operator>>=( Type &a, int  b ) { return a = a >> b; } \
+	inline Type  operator~( Type a ) { return Type( ~int( a ) ); }
+
+// defines increment/decrement operators for enums for easy iteration
+#define DEFINE_ENUM_INCREMENT_OPERATORS( Type ) \
+	inline Type &operator++( Type &a      ) { return a = Type( int( a ) + 1 ); } \
+	inline Type &operator--( Type &a      ) { return a = Type( int( a ) - 1 ); } \
+	inline Type  operator++( Type &a, int ) { Type t = a; ++a; return t; } \
+	inline Type  operator--( Type &a, int ) { Type t = a; --a; return t; }
+
+// Max 2 player splitscreen in portal (don't merge this back), saves a bunch of memory [8/31/2010 tom]
+#define MAX_SPLITSCREEN_CLIENT_BITS 1
+// this should == MAX_JOYSTICKS in InputEnums.h
+#define MAX_SPLITSCREEN_CLIENTS	( 1 << MAX_SPLITSCREEN_CLIENT_BITS ) // 2
+
+#include "tier0/valve_on.h"
+
+#endif // BASETYPES_H