/*
===========================================================================

Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.

This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").

Doom 3 BFG Edition Source Code 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 3 of the License, or
(at your option) any later version.

Doom 3 BFG Edition Source Code 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 Doom 3 BFG Edition Source Code.  If not, see <http://www.gnu.org/licenses/>.

In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code.  If not, please request a copy in writing from id Software at the address below.

If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.

===========================================================================
*/
#ifndef __BITMSG_H__
#define __BITMSG_H__

/*
================================================
idBitMsg operates on a sequence of individual bits. It handles byte ordering and
avoids alignment errors. It allows concurrent writing and reading. The data set with Init
is never free-d.
================================================
*/
class idBitMsg
{
public:
	idBitMsg()
	{
		InitWrite( NULL, 0 );
	}
	idBitMsg( byte* data, int length )
	{
		InitWrite( data, length );
	}
	idBitMsg( const byte* data, int length )
	{
		InitRead( data, length );
	}
	
	// both read & write
	void			InitWrite( byte* data, int length );
	
	// read only
	void			InitRead( const byte* data, int length );
	
	// get data for writing
	byte* 			GetWriteData();
	
	// get data for reading
	const byte* 	GetReadData() const;
	
	// get the maximum message size
	int				GetMaxSize() const;
	
	// generate error if not set and message is overflowed
	void			SetAllowOverflow( bool set );
	
	// returns true if the message was overflowed
	bool			IsOverflowed() const;
	
	// size of the message in bytes
	int				GetSize() const;
	
	// set the message size
	void			SetSize( int size );
	
	// get current write bit
	int				GetWriteBit() const;
	
	// set current write bit
	void			SetWriteBit( int bit );
	
	// returns number of bits written
	int				GetNumBitsWritten() const;
	
	// space left in bytes for writing
	int				GetRemainingSpace() const;
	
	// space left in bits for writing
	int				GetRemainingWriteBits() const;
	
	//------------------------
	// Write State
	//------------------------
	
	// save the write state
	void			SaveWriteState( int& s, int& b, uint64& t ) const;
	
	// restore the write state
	void			RestoreWriteState( int s, int b, uint64 t );
	
	//------------------------
	// Reading
	//------------------------
	
	// bytes read so far
	int				GetReadCount() const;
	
	// set the number of bytes and bits read
	void			SetReadCount( int bytes );
	
	// get current read bit
	int				GetReadBit() const;
	
	// set current read bit
	void			SetReadBit( int bit );
	
	// returns number of bits read
	int				GetNumBitsRead() const;
	
	// number of bytes left to read
	int				GetRemainingData() const;
	
	// number of bits left to read
	int				GetRemainingReadBits() const;
	
	// save the read state
	void			SaveReadState( int& c, int& b ) const;
	
	// restore the read state
	void			RestoreReadState( int c, int b );
	
	//------------------------
	// Writing
	//------------------------
	
	// begin writing
	void			BeginWriting();
	
	// write up to the next byte boundary
	void			WriteByteAlign();
	
	// write the specified number of bits
	void			WriteBits( int value, int numBits );
	
	void			WriteBool( bool c );
	void			WriteChar( int8 c );
	void			WriteByte( uint8 c );
	void			WriteShort( int16 c );
	void			WriteUShort( uint16 c );
	void			WriteLong( int32 c );
	void			WriteLongLong( int64 c );
	void			WriteFloat( float f );
	void			WriteFloat( float f, int exponentBits, int mantissaBits );
	void			WriteAngle8( float f );
	void			WriteAngle16( float f );
	void			WriteDir( const idVec3& dir, int numBits );
	void			WriteString( const char* s, int maxLength = -1, bool make7Bit = true );
	void			WriteData( const void* data, int length );
	void			WriteNetadr( const netadr_t adr );
	
	void			WriteUNorm8( float f )
	{
		WriteByte( idMath::Ftob( f * 255.0f ) );
	}
	void			WriteUNorm16( float f )
	{
		WriteUShort( idMath::Ftoi( f * 65535.0f ) );
	}
	void			WriteNorm16( float f )
	{
		WriteShort( idMath::Ftoi( f * 32767.0f ) );
	}
	
	void			WriteDeltaChar( int8 oldValue, int8 newValue )
	{
		WriteByte( newValue - oldValue );
	}
	void			WriteDeltaByte( uint8 oldValue, uint8 newValue )
	{
		WriteByte( newValue - oldValue );
	}
	void			WriteDeltaShort( int16 oldValue, int16 newValue )
	{
		WriteUShort( newValue - oldValue );
	}
	void			WriteDeltaUShort( uint16 oldValue, uint16 newValue )
	{
		WriteUShort( newValue - oldValue );
	}
	void			WriteDeltaLong( int32 oldValue, int32 newValue )
	{
		WriteLong( newValue - oldValue );
	}
	void			WriteDeltaFloat( float oldValue, float newValue )
	{
		WriteFloat( newValue - oldValue );
	}
	void			WriteDeltaFloat( float oldValue, float newValue, int exponentBits, int mantissaBits )
	{
		WriteFloat( newValue - oldValue, exponentBits, mantissaBits );
	}
	
	bool			WriteDeltaDict( const idDict& dict, const idDict* base );
	
	template< int _max_, int _numBits_ >
	void			WriteQuantizedFloat( float value );
	template< int _max_, int _numBits_ >
	void			WriteQuantizedUFloat( float value );		// Quantize a float to a variable number of bits (assumes unsigned, uses simple quantization)
	
	template< typename T >
	void			WriteVectorFloat( const T& v )
	{
		for( int i = 0; i < v.GetDimension(); i++ )
		{
			WriteFloat( v[i] );
		}
	}
	template< typename T >
	void			WriteVectorUNorm8( const T& v )
	{
		for( int i = 0; i < v.GetDimension(); i++ )
		{
			WriteUNorm8( v[i] );
		}
	}
	template< typename T >
	void			WriteVectorUNorm16( const T& v )
	{
		for( int i = 0; i < v.GetDimension(); i++ )
		{
			WriteUNorm16( v[i] );
		}
	}
	template< typename T >
	void			WriteVectorNorm16( const T& v )
	{
		for( int i = 0; i < v.GetDimension(); i++ )
		{
			WriteNorm16( v[i] );
		}
	}
	
	// Compress a vector to a variable number of bits (assumes signed, uses simple quantization)
	template< typename T, int _max_, int _numBits_  >
	void			WriteQuantizedVector( const T& v )
	{
		for( int i = 0; i < v.GetDimension(); i++ )
		{
			WriteQuantizedFloat< _max_, _numBits_ >( v[i] );
		}
	}
	
	// begin reading.
	void			BeginReading() const;
	
	// read up to the next byte boundary
	void			ReadByteAlign() const;
	
	// read the specified number of bits
	int				ReadBits( int numBits ) const;
	
	bool			ReadBool() const;
	int				ReadChar() const;
	int				ReadByte() const;
	int				ReadShort() const;
	int				ReadUShort() const;
	int				ReadLong() const;
	int64			ReadLongLong() const;
	float			ReadFloat() const;
	float			ReadFloat( int exponentBits, int mantissaBits ) const;
	float			ReadAngle8() const;
	float			ReadAngle16() const;
	idVec3			ReadDir( int numBits ) const;
	int				ReadString( char* buffer, int bufferSize ) const;
	int				ReadString( idStr& str ) const;
	int				ReadData( void* data, int length ) const;
	void			ReadNetadr( netadr_t* adr ) const;
	
	float			ReadUNorm8() const
	{
		return ReadByte() / 255.0f;
	}
	float			ReadUNorm16() const
	{
		return ReadUShort() / 65535.0f;
	}
	float			ReadNorm16() const
	{
		return ReadShort() / 32767.0f;
	}
	
	int8			ReadDeltaChar( int8 oldValue ) const
	{
		return oldValue + ReadByte();
	}
	uint8			ReadDeltaByte( uint8 oldValue ) const
	{
		return oldValue + ReadByte();
	}
	int16			ReadDeltaShort( int16 oldValue ) const
	{
		return oldValue + ReadUShort();
	}
	uint16			ReadDeltaUShort( uint16 oldValue ) const
	{
		return oldValue + ReadUShort();
	}
	int32			ReadDeltaLong( int32 oldValue ) const
	{
		return oldValue + ReadLong();
	}
	float			ReadDeltaFloat( float oldValue ) const
	{
		return oldValue + ReadFloat();
	}
	float			ReadDeltaFloat( float oldValue, int exponentBits, int mantissaBits ) const
	{
		return oldValue + ReadFloat( exponentBits, mantissaBits );
	}
	bool			ReadDeltaDict( idDict& dict, const idDict* base ) const;
	
	template< int _max_, int _numBits_ >
	float			ReadQuantizedFloat() const;
	template< int _max_, int _numBits_ >
	float			ReadQuantizedUFloat() const;
	
	template< typename T >
	void			ReadVectorFloat( T& v ) const
	{
		for( int i = 0; i < v.GetDimension(); i++ )
		{
			v[i] = ReadFloat();
		}
	}
	template< typename T >
	void			ReadVectorUNorm8( T& v ) const
	{
		for( int i = 0; i < v.GetDimension(); i++ )
		{
			v[i] = ReadUNorm8();
		}
	}
	template< typename T >
	void			ReadVectorUNorm16( T& v ) const
	{
		for( int i = 0; i < v.GetDimension(); i++ )
		{
			v[i] = ReadUNorm16();
		}
	}
	template< typename T >
	void			ReadVectorNorm16( T& v ) const
	{
		for( int i = 0; i < v.GetDimension(); i++ )
		{
			v[i] = ReadNorm16();
		}
	}
	template< typename T, int _max_, int _numBits_ >
	void			ReadQuantizedVector( T& v ) const
	{
		for( int i = 0; i < v.GetDimension(); i++ )
		{
			v[i] = ReadQuantizedFloat< _max_, _numBits_ >();
		}
	}
	
	static int		DirToBits( const idVec3& dir, int numBits );
	static idVec3	BitsToDir( int bits, int numBits );
	
	void			SetHasChanged( bool b )
	{
		hasChanged = b;
	}
	bool			HasChanged() const
	{
		return hasChanged;
	}
	
private:
	byte* 			writeData;		// pointer to data for writing
	const byte* 	readData;		// pointer to data for reading
	int				maxSize;		// maximum size of message in bytes
	int				curSize;		// current size of message in bytes
	mutable int		writeBit;		// number of bits written to the last written byte
	mutable int		readCount;		// number of bytes read so far
	mutable int		readBit;		// number of bits read from the last read byte
	bool			allowOverflow;	// if false, generate error when the message is overflowed
	bool			overflowed;		// set true if buffer size failed (with allowOverflow set)
	bool			hasChanged;		// Hack
	
	mutable uint64	tempValue;
	
private:
	bool			CheckOverflow( int numBits );
	byte* 			GetByteSpace( int length );
};

/*
========================
idBitMsg::InitWrite
========================
*/
ID_INLINE void idBitMsg::InitWrite( byte* data, int length )
{
	writeData = data;
	readData = data;
	maxSize = length;
	curSize = 0;
	
	writeBit = 0;
	readCount = 0;
	readBit = 0;
	allowOverflow = false;
	overflowed = false;
	
	tempValue = 0;
}

/*
========================
idBitMsg::InitRead
========================
*/
ID_INLINE void idBitMsg::InitRead( const byte* data, int length )
{
	writeData = NULL;
	readData = data;
	maxSize = length;
	curSize = length;
	
	writeBit = 0;
	readCount = 0;
	readBit = 0;
	allowOverflow = false;
	overflowed = false;
	
	tempValue = 0;
}

/*
========================
idBitMsg::GetWriteData
========================
*/
ID_INLINE byte* idBitMsg::GetWriteData()
{
	return writeData;
}

/*
========================
idBitMsg::GetReadData
========================
*/
ID_INLINE const byte* idBitMsg::GetReadData() const
{
	return readData;
}

/*
========================
idBitMsg::GetMaxSize
========================
*/
ID_INLINE int idBitMsg::GetMaxSize() const
{
	return maxSize;
}

/*
========================
idBitMsg::SetAllowOverflow
========================
*/
ID_INLINE void idBitMsg::SetAllowOverflow( bool set )
{
	allowOverflow = set;
}

/*
========================
idBitMsg::IsOverflowed
========================
*/
ID_INLINE bool idBitMsg::IsOverflowed() const
{
	return overflowed;
}

/*
========================
idBitMsg::GetSize
========================
*/
ID_INLINE int idBitMsg::GetSize() const
{
	return curSize + ( writeBit != 0 );
}

/*
========================
idBitMsg::SetSize
========================
*/
ID_INLINE void idBitMsg::SetSize( int size )
{
	assert( writeBit == 0 );
	
	if( size > maxSize )
	{
		curSize = maxSize;
	}
	else
	{
		curSize = size;
	}
}

/*
========================
idBitMsg::GetWriteBit
========================
*/
ID_INLINE int idBitMsg::GetWriteBit() const
{
	return writeBit;
}

/*
========================
idBitMsg::SetWriteBit
========================
*/
ID_INLINE void idBitMsg::SetWriteBit( int bit )
{
	// see idBitMsg::WriteByteAlign
	assert( false );
	writeBit = bit & 7;
	if( writeBit )
	{
		writeData[curSize - 1] &= ( 1 << writeBit ) - 1;
	}
}

/*
========================
idBitMsg::GetNumBitsWritten
========================
*/
ID_INLINE int idBitMsg::GetNumBitsWritten() const
{
	return ( curSize << 3 ) + writeBit;
}

/*
========================
idBitMsg::GetRemainingSpace
========================
*/
ID_INLINE int idBitMsg::GetRemainingSpace() const
{
	return maxSize - GetSize();
}

/*
========================
idBitMsg::GetRemainingWriteBits
========================
*/
ID_INLINE int idBitMsg::GetRemainingWriteBits() const
{
	return ( maxSize << 3 ) - GetNumBitsWritten();
}

/*
========================
idBitMsg::SaveWriteState
========================
*/
ID_INLINE void idBitMsg::SaveWriteState( int& s, int& b, uint64& t ) const
{
	s = curSize;
	b = writeBit;
	t = tempValue;
}

/*
========================
idBitMsg::RestoreWriteState
========================
*/
ID_INLINE void idBitMsg::RestoreWriteState( int s, int b, uint64 t )
{
	curSize = s;
	writeBit = b & 7;
	if( writeBit )
	{
		writeData[curSize] &= ( 1 << writeBit ) - 1;
	}
	tempValue = t;
}

/*
========================
idBitMsg::GetReadCount
========================
*/
ID_INLINE int idBitMsg::GetReadCount() const
{
	return readCount;
}

/*
========================
idBitMsg::SetReadCount
========================
*/
ID_INLINE void idBitMsg::SetReadCount( int bytes )
{
	readCount = bytes;
}

/*
========================
idBitMsg::GetReadBit
========================
*/
ID_INLINE int idBitMsg::GetReadBit() const
{
	return readBit;
}

/*
========================
idBitMsg::SetReadBit
========================
*/
ID_INLINE void idBitMsg::SetReadBit( int bit )
{
	readBit = bit & 7;
}

/*
========================
idBitMsg::GetNumBitsRead
========================
*/
ID_INLINE int idBitMsg::GetNumBitsRead() const
{
	return ( ( readCount << 3 ) - ( ( 8 - readBit ) & 7 ) );
}

/*
========================
idBitMsg::GetRemainingData
========================
*/
ID_INLINE int idBitMsg::GetRemainingData() const
{
	assert( writeBit == 0 );
	return curSize - readCount;
}

/*
========================
idBitMsg::GetRemainingReadBits
========================
*/
ID_INLINE int idBitMsg::GetRemainingReadBits() const
{
	assert( writeBit == 0 );
	return ( curSize << 3 ) - GetNumBitsRead();
}

/*
========================
idBitMsg::SaveReadState
========================
*/
ID_INLINE void idBitMsg::SaveReadState( int& c, int& b ) const
{
	assert( writeBit == 0 );
	c = readCount;
	b = readBit;
}

/*
========================
idBitMsg::RestoreReadState
========================
*/
ID_INLINE void idBitMsg::RestoreReadState( int c, int b )
{
	assert( writeBit == 0 );
	readCount = c;
	readBit = b & 7;
}

/*
========================
idBitMsg::BeginWriting
========================
*/
ID_INLINE void idBitMsg::BeginWriting()
{
	curSize = 0;
	overflowed = false;
	writeBit = 0;
	tempValue = 0;
}

/*
========================
idBitMsg::WriteByteAlign
========================
*/
ID_INLINE void idBitMsg::WriteByteAlign()
{
	// it is important that no uninitialized data slips in the msg stream,
	// because we use memcmp to decide if entities have changed and wether we should transmit them
	// this function has the potential to leave uninitialized bits into the stream,
	// however idBitMsg::WriteBits is properly initializing the byte to 0 so hopefully we are still safe
	// adding this extra check just in case
	curSize += writeBit != 0;
	assert( writeBit == 0 || ( ( writeData[curSize - 1] >> writeBit ) == 0 ) ); // had to early out writeBit == 0 because when writeBit == 0 writeData[curSize - 1] may be the previous byte written and trigger false positives
	writeBit = 0;
	tempValue = 0;
}

/*
========================
idBitMsg::WriteBool
========================
*/
ID_INLINE void idBitMsg::WriteBool( bool c )
{
	WriteBits( c, 1 );
}

/*
========================
idBitMsg::WriteChar
========================
*/
ID_INLINE void idBitMsg::WriteChar( int8 c )
{
	WriteBits( c, -8 );
}

/*
========================
idBitMsg::WriteByte
========================
*/
ID_INLINE void idBitMsg::WriteByte( uint8 c )
{
	WriteBits( c, 8 );
}

/*
========================
idBitMsg::WriteShort
========================
*/
ID_INLINE void idBitMsg::WriteShort( int16 c )
{
	WriteBits( c, -16 );
}

/*
========================
idBitMsg::WriteUShort
========================
*/
ID_INLINE void idBitMsg::WriteUShort( uint16 c )
{
	WriteBits( c, 16 );
}

/*
========================
idBitMsg::WriteLong
========================
*/
ID_INLINE void idBitMsg::WriteLong( int32 c )
{
	WriteBits( c, 32 );
}

/*
========================
idBitMsg::WriteLongLong
========================
*/
ID_INLINE void idBitMsg::WriteLongLong( int64 c )
{
	int a = c;
	int b = c >> 32;
	WriteBits( a, 32 );
	WriteBits( b, 32 );
}

/*
========================
idBitMsg::WriteFloat
========================
*/
ID_INLINE void idBitMsg::WriteFloat( float f )
{
	WriteBits( *reinterpret_cast<int*>( &f ), 32 );
}

/*
========================
idBitMsg::WriteFloat
========================
*/
ID_INLINE void idBitMsg::WriteFloat( float f, int exponentBits, int mantissaBits )
{
	int bits = idMath::FloatToBits( f, exponentBits, mantissaBits );
	WriteBits( bits, 1 + exponentBits + mantissaBits );
}

/*
========================
idBitMsg::WriteAngle8
========================
*/
ID_INLINE void idBitMsg::WriteAngle8( float f )
{
	WriteByte( ANGLE2BYTE( f ) );
}

/*
========================
idBitMsg::WriteAngle16
========================
*/
ID_INLINE void idBitMsg::WriteAngle16( float f )
{
	WriteShort( ANGLE2SHORT( f ) );
}

/*
========================
idBitMsg::WriteDir
========================
*/
ID_INLINE void idBitMsg::WriteDir( const idVec3& dir, int numBits )
{
	WriteBits( DirToBits( dir, numBits ), numBits );
}

/*
========================
idBitMsg::BeginReading
========================
*/
ID_INLINE void idBitMsg::BeginReading() const
{
	readCount = 0;
	readBit = 0;
	
	writeBit = 0;
	tempValue = 0;
}

/*
========================
idBitMsg::ReadByteAlign
========================
*/
ID_INLINE void idBitMsg::ReadByteAlign() const
{
	readBit = 0;
}

/*
========================
idBitMsg::ReadBool
========================
*/
ID_INLINE bool idBitMsg::ReadBool() const
{
	return ( ReadBits( 1 ) == 1 ) ? true : false;
}

/*
========================
idBitMsg::ReadChar
========================
*/
ID_INLINE int idBitMsg::ReadChar() const
{
	return ( signed char )ReadBits( -8 );
}

/*
========================
idBitMsg::ReadByte
========================
*/
ID_INLINE int idBitMsg::ReadByte() const
{
	return ( unsigned char )ReadBits( 8 );
}

/*
========================
idBitMsg::ReadShort
========================
*/
ID_INLINE int idBitMsg::ReadShort() const
{
	return ( short )ReadBits( -16 );
}

/*
========================
idBitMsg::ReadUShort
========================
*/
ID_INLINE int idBitMsg::ReadUShort() const
{
	return ( unsigned short )ReadBits( 16 );
}

/*
========================
idBitMsg::ReadLong
========================
*/
ID_INLINE int idBitMsg::ReadLong() const
{
	return ReadBits( 32 );
}

/*
========================
idBitMsg::ReadLongLong
========================
*/
ID_INLINE int64 idBitMsg::ReadLongLong() const
{
	int64 a = ReadBits( 32 );
	int64 b = ReadBits( 32 );
	int64 c = ( 0x00000000ffffffff & a ) | ( b << 32 );
	return c;
}

/*
========================
idBitMsg::ReadFloat
========================
*/
ID_INLINE float idBitMsg::ReadFloat() const
{
	float value;
	*reinterpret_cast<int*>( &value ) = ReadBits( 32 );
	return value;
}

/*
========================
idBitMsg::ReadFloat
========================
*/
ID_INLINE float idBitMsg::ReadFloat( int exponentBits, int mantissaBits ) const
{
	int bits = ReadBits( 1 + exponentBits + mantissaBits );
	return idMath::BitsToFloat( bits, exponentBits, mantissaBits );
}

/*
========================
idBitMsg::ReadAngle8
========================
*/
ID_INLINE float idBitMsg::ReadAngle8() const
{
	return BYTE2ANGLE( ReadByte() );
}

/*
========================
idBitMsg::ReadAngle16
========================
*/
ID_INLINE float idBitMsg::ReadAngle16() const
{
	return SHORT2ANGLE( ReadShort() );
}

/*
========================
idBitMsg::ReadDir
========================
*/
ID_INLINE idVec3 idBitMsg::ReadDir( int numBits ) const
{
	return BitsToDir( ReadBits( numBits ), numBits );
}

/*
========================
idBitMsg::WriteQuantizedFloat
========================
*/
template< int _max_, int _numBits_ >
ID_INLINE void idBitMsg::WriteQuantizedFloat( float value )
{
	enum { storeMax = ( 1 << ( _numBits_ - 1 ) ) - 1 };
	if( _max_ > storeMax )
	{
		// Scaling down (scale should be < 1)
		const float scale = ( float )storeMax / ( float )_max_;
		WriteBits( idMath::ClampInt( -storeMax, storeMax, idMath::Ftoi( value * scale ) ), -_numBits_ );
	}
	else
	{
		// Scaling up (scale should be >= 1) (Preserve whole numbers when possible)
		enum { scale = storeMax / _max_ };
		WriteBits( idMath::ClampInt( -storeMax, storeMax, idMath::Ftoi( value * scale ) ), -_numBits_ );
	}
}

/*
========================
idBitMsg::WriteQuantizedUFloat
========================
*/
template< int _max_, int _numBits_ >
ID_INLINE void idBitMsg::WriteQuantizedUFloat( float value )
{
	enum { storeMax = ( 1 << _numBits_ ) - 1 };
	if( _max_ > storeMax )
	{
		// Scaling down (scale should be < 1)
		const float scale = ( float )storeMax / ( float )_max_;
		WriteBits( idMath::ClampInt( 0, storeMax, idMath::Ftoi( value * scale ) ), _numBits_ );
	}
	else
	{
		// Scaling up (scale should be >= 1) (Preserve whole numbers when possible)
		enum { scale = storeMax / _max_ };
		WriteBits( idMath::ClampInt( 0, storeMax, idMath::Ftoi( value * scale ) ), _numBits_ );
	}
}

/*
========================
idBitMsg::ReadQuantizedFloat
========================
*/
template< int _max_, int _numBits_ >
ID_INLINE float idBitMsg::ReadQuantizedFloat() const
{
	enum { storeMax = ( 1 << ( _numBits_ - 1 ) ) - 1 };
	if( _max_ > storeMax )
	{
		// Scaling down (scale should be < 1)
		const float invScale = ( float )_max_ / ( float )storeMax;
		return ( float )ReadBits( -_numBits_ ) * invScale;
	}
	else
	{
		// Scaling up (scale should be >= 1) (Preserve whole numbers when possible)
		// Scale will be a whole number.
		// We use a float to get rid of (potential divide by zero) which is handled above, but the compiler is dumb
		const float scale = storeMax / _max_;
		const float invScale = 1.0f / scale;
		return ( float )ReadBits( -_numBits_ ) * invScale;
	}
}

/*
========================
idBitMsg::ReadQuantizedUFloat
========================
*/
template< int _max_, int _numBits_ >
float idBitMsg::ReadQuantizedUFloat() const
{
	enum { storeMax = ( 1 << _numBits_ ) - 1 };
	if( _max_ > storeMax )
	{
		// Scaling down (scale should be < 1)
		const float invScale = ( float )_max_ / ( float )storeMax;
		return ( float )ReadBits( _numBits_ ) * invScale;
	}
	else
	{
		// Scaling up (scale should be >= 1) (Preserve whole numbers when possible)
		// Scale will be a whole number.
		// We use a float to get rid of (potential divide by zero) which is handled above, but the compiler is dumb
		const float scale = storeMax / _max_;
		const float invScale = 1.0f / scale;
		return ( float )ReadBits( _numBits_ ) * invScale;
	}
}

/*
================
WriteFloatArray
Writes all the values from the array to the bit message.
================
*/
template< class _arrayType_ >
void WriteFloatArray( idBitMsg& message, const _arrayType_ & sourceArray )
{
	for( int i = 0; i < idTupleSize< _arrayType_ >::value; ++i )
	{
		message.WriteFloat( sourceArray[i] );
	}
}

/*
================
WriteFloatArrayDelta
Writes _num_ values from the array to the bit message.
================
*/
template< class _arrayType_ >
void WriteDeltaFloatArray( idBitMsg& message, const _arrayType_ & oldArray, const _arrayType_ & newArray )
{
	for( int i = 0; i < idTupleSize< _arrayType_ >::value; ++i )
	{
		message.WriteDeltaFloat( oldArray[i], newArray[i] );
	}
}

/*
================
ReadFloatArray
Reads _num_ values from the array to the bit message.
================
*/
template< class _arrayType_ >
_arrayType_ ReadFloatArray( const idBitMsg& message )
{
	_arrayType_ result;
	
	for( int i = 0; i < idTupleSize< _arrayType_ >::value; ++i )
	{
		result[i] = message.ReadFloat();
	}
	
	return result;
}

/*
================
ReadDeltaFloatArray
Reads _num_ values from the array to the bit message.
================
*/
template< class _arrayType_ >
_arrayType_ ReadDeltaFloatArray( const idBitMsg& message, const _arrayType_ & oldArray )
{
	_arrayType_ result;
	
	for( int i = 0; i < idTupleSize< _arrayType_ >::value; ++i )
	{
		result[i] = message.ReadDeltaFloat( oldArray[i] );
	}
	
	return result;
}

#endif /* !__BITMSG_H__ */