/*
===========================================================================
maya2q3 - export .md3 files from maya
Copyright (C) 2007 HermitWorks Entertainment Corporation

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
===========================================================================
*/

#ifndef INC__util_h_
#define INC__util_h_

#define null 0

void demand( bool cond, const char *msg );

#ifdef assert
#undef assert
#endif

#ifdef _DEBUG
#define assert demand
#else
#define assert( cond, msg )
#endif

void fail( const char *msg );
void warn( const char *msg );
void trace( const char *msg );

#define asserta( cond ) assert( cond, #cond )

const char* va( const char *s, ... );

#define DECLARE_ENUM( E )							\
struct E											\
{													\
public:												\
	enum Values										\
	{


#define END_OPEN_ENUM( E ) }

#define END_ENUM_OPEN( E )							\
	};												\
													\
private:											\
	Values v;										\
													\
public:												\
	E() { }											\
	E( const Values src ) : v( src ) { }			\
													\
	E & operator = ( const Values src )				\
	{												\
		v = src;									\
													\
		return *this;								\
	}												\
													\
	operator Values () const						\
	{												\
		return v;									\
	}												\
													\
	E& operator |= ( const E& e )					\
	{												\
		v = (Values)(v | e.v);						\
		return *this;								\
	}												\
													\
	E& operator &= ( const E& e )					\
	{												\
		v = (Values)(v & e.v);						\
		return *this;								\
	}												\
													\
	E operator ~ ( void ) const						\
	{												\
		return E( (Values)~v );						\
	}

#define END_ENUM( E )								\
	END_ENUM_OPEN( E )								\
END_OPEN_ENUM( E )

#define END_ENUM_WITH_TYPE_OPEN( E, T )				\
	};												\
													\
private:											\
	T v;											\
													\
public:												\
	E() { }											\
	E( const Values src ) : v( (T)src ) { }			\
	E( const T src ) : v( src ) { }					\
													\
	E & operator = ( const Values src )				\
	{												\
		v = (T)src;									\
													\
		return *this;								\
	}												\
													\
	operator Values () const						\
	{												\
		return (Values)v;							\
	}												\
													\
	E operator | ( const E &e ) const				\
	{												\
		return E( (Values)(v | e.v) );				\
	}												\
													\
	E& operator |= ( const E &e )					\
	{												\
		v |= e.v;									\
		return *this;								\
	}												\
													\
	E& operator &= ( const E &e )					\
	{												\
		v &= e.v;									\
		return *this;								\
	}												\
													\
	E operator ~ ( void ) const						\
	{												\
		return E( ~v );								\
	}												\

#define END_ENUM_WITH_TYPE( E, T )					\
	END_ENUM_WITH_TYPE_OPEN( E, T )					\
END_OPEN_ENUM( E )

class bad_int_cast : public std::exception
{
public:
	bad_int_cast( void ) : std::exception( "Integer conversion caused loss of data." ) { }
	virtual ~bad_int_cast( void ) { }
};

template< typename T, size_t num_bits = sizeof( T ) * CHAR_BIT >
struct integer_traits
{
private:
	template< size_t num_bits >
	struct signed_max
	{
		static const T val = (T)(signed_max< num_bits - 1 >::val << 1) | 0x1;
	};

	template< >
	struct signed_max< 2 >
	{
		static const T val = (T)0x1;
	};

	template< >
	struct signed_max< 1 >
	{
		//can't have a 1-bit signed value
	};

	template< >
	struct signed_max< 0 >
	{
		//can't have a 0-bit signed value
	};

	template< size_t num_bits >
	struct signed_min
	{
		static const T val = (T)((signed_min< num_bits - 1 >::val) << 1);
	};

	template< >
	struct signed_min< 2 >
	{
		static const T val = (T)0x2;
	};

	template< >
	struct signed_min< 1 >
	{
		//can't have a 1-bit signed value
	};

	template< >
	struct signed_min< 0 >
	{
		//can't have a 0-bit signed value
	};

	template< size_t num_bits >
	struct unsigned_max
	{
		static const T val = (T)(unsigned_max< num_bits - 1 >::val << 1) | 0x1;
	};

	template< >
	struct unsigned_max< 1 >
	{
		static const T val = (T)0x1;
	};

	template< >
	struct unsigned_max< 0 >
	{
		//can'g have a 0-bit unsigned value
	};

public:
	static const bool is_signed = (((T)-1) < 0);
	static const T max_val = is_signed ? signed_max< num_bits >::val : unsigned_max< num_bits >::val;
	static const T min_val = is_signed ? signed_min< num_bits >::val : (T)0;

	static const T bit_width = num_bits;
};

#pragma warning( push )
#pragma warning( disable : 4127 ) //constant conditional --by design

template< typename O, typename I >
inline O checked_int_cast( const I &in )
{
	typedef integer_traits<O> ot;

	if( in < ot::min_val || in > ot::max_val )
		throw bad_int_cast();

	return static_cast< O >( in );
}

#pragma warning( pop )

#define lengthof( a ) (sizeof( a ) / sizeof( (a)[0] ))

template< typename T >
inline T align( T p, T a )
{
	return ((p + a - (T)1) / a) * a;
}

template< typename T >
inline T* align( T *p, intptr_t a )
{
	return (T*)align( (intptr_t)p, a );
}

template< typename T >
inline bool is_pow_2( T i )
{
	return (i & (i - 1)) == 0;
}

template< typename T >
inline int log2_fast( T i )
{
	for( int log = 0; log < integer_traits< T >::bit_width; log++ )
		if( (T)1 << log == i )
			return log;

	return -1;
}

typedef unsigned char byte;
typedef signed char sbyte;
typedef unsigned short ushort;
typedef unsigned int uint;
typedef signed long long huge;
typedef unsigned long long uhuge;

#ifndef __intptr_t_defined

typedef INT_PTR intptr;
typedef UINT_PTR uintptr;

#else

typedef intptr_t intptr;
typedef uintptr_t uintptr;

#endif

struct argb
{
	uint argb_value;

	byte a() const { return (byte)((argb_value >> 24) & 0xFF); }
	byte r() const { return (byte)((argb_value >> 16) & 0xFF); }
	byte g() const { return (byte)((argb_value >> 8) & 0xFF); }
	byte b() const { return (byte)(argb_value & 0xFF); }

	void set_value( byte a, byte r, byte g, byte b )
	{
		argb_value = (a << 24) | (r << 16) | (g << 8) | b;
	}
	void set_value( float a, float r, float g, float b )
	{
		uint ua = (uint)(saturate( a ) * 0xFF);
		uint ur = (uint)(saturate( r ) * 0xFF);
		uint ug = (uint)(saturate( g ) * 0xFF);
		uint ub = (uint)(saturate( b ) * 0xFF);

		set_value( (byte)ua, (byte)ur, (byte)ug, (byte)ub );
	}
};

inline argb argbc( byte r, byte g, byte b ) { argb ret; ret.set_value( 0xFF, r, g, b ); return ret; }
inline argb argbc( byte a, byte r, byte g, byte b ) { argb ret; ret.set_value( a, r, g, b ); return ret; }
inline argb argbc( uint c ) { argb ret; ret.argb_value = c; return ret; }

#endif