DOOM-3-BFG/neo/framework/Serializer.h

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

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 __SERIALIZER_H__
#define __SERIALIZER_H__

#define SERIALIZE_BOOL( ser, x )			( ( x ) = ser.SerializeBoolNonRef( x ) )
#define SERIALIZE_ENUM( ser, x, type, max ) ( ( x ) = (type)ser.SerializeUMaxNonRef( x, max ) )
#define SERIALIZE_CVAR_FLOAT( ser, cvar )	{ float a = cvar.GetFloat(); ser.Serialize( a ); cvar.SetFloat( a ); }
#define SERIALIZE_CVAR_INT( ser, cvar )		{ int a = cvar.GetInteger(); ser.Serialize( a ); cvar.SetInteger( a ); }
#define SERIALIZE_CVAR_BOOL( ser, cvar )	{ bool a = cvar.GetBool(); SERIALIZE_BOOL( ser, a ); cvar.SetBool( a ); }

#define SERIALIZE_MATX( ser, var )				\
{												\
	int rows = var.GetNumRows();				\
	int cols = var.GetNumColumns();				\
	ser.Serialize( rows );						\
	ser.Serialize( cols );						\
	if ( ser.IsReading() ) {					\
		var.SetSize( rows, cols );				\
	}											\
	for ( int y = 0; y < rows; y++ ) {			\
		for ( int x = 0; x < rows; x++ ) {		\
			ser.Serialize( var[x][y] );			\
		}										\
	}											\
}												\

#define SERIALIZE_VECX( ser, var )				\
{												\
	int size = var.GetSize();					\
	ser.Serialize( size );						\
	if ( ser.IsReading() ) {					\
		var.SetSize( size );					\
	}											\
	for ( int x = 0; x < size; x++ ) {			\
		ser.Serialize( var[x] );				\
	}											\
}												\

#define SERIALIZE_JOINT( ser, var )				\
{												\
	uint16 jointIndex = ( var == NULL_JOINT_INDEX ) ? 65535 : var;	\
	ser.Serialize( jointIndex );					\
	var = ( jointIndex == 65535 ) ? NULL_JOINT_INDEX : (jointIndex_t)jointIndex; \
}												\

//#define ENABLE_SERIALIZE_CHECKPOINTS
//#define SERIALIZE_SANITYCHECK
//#define SERIALIZE_NO_QUANT

#define SERIALIZE_CHECKPOINT( ser )			\
	ser.SerializeCheckpoint( __FILE__, __LINE__ );

/*
========================
idSerializer
========================
*/
class idSerializer {
public:
	idSerializer( idBitMsg & msg_, bool writing_) : msg( &msg_ ), writing( writing_ )
#ifdef SERIALIZE_SANITYCHECK
	,magic( 0 ) 
#endif
	{ }

	bool	IsReading() { return !writing; }
	bool	IsWriting() { return writing; }

	// SerializeRange - minSize through maxSize inclusive of all possible values
	void	SerializeRange( int & value, int minSize, int maxSize ) {	// Supports signed types
		SanityCheck();
		if ( writing ) {
			msg->WriteBits( value - minSize, idMath::BitsForInteger( maxSize-minSize ) );
		} else {
			value = minSize + msg->ReadBits( idMath::BitsForInteger( maxSize-minSize ) );
		}
		assert( value >= minSize && value <= maxSize );
	}

	// SerializeUMax - maxSize inclusive, unsigned
	void	SerializeUMax( int & value, int maxSize ) {					// Unsigned only
		SanityCheck();
		if ( writing ) {
			msg->WriteBits( value, idMath::BitsForInteger( maxSize ) );
		} else {
			value = msg->ReadBits( idMath::BitsForInteger( maxSize ) );
		}
		assert( value <= maxSize );
	}

	// SerializeUMaxNonRef - maxSize inclusive, unsigned, no reference
	int	SerializeUMaxNonRef( int value, int maxSize ) {					// Unsigned only
		SanityCheck();
		if ( writing ) {
			msg->WriteBits(value, idMath::BitsForInteger( maxSize ) );
		} else {
			value = msg->ReadBits( idMath::BitsForInteger( maxSize ) );
		}
		assert( value <= maxSize );
		return value;
	}

	//void SerializeBitMsg( idBitMsg & inOutMsg, int numBytes ) { SanityCheck(); if ( writing ) { msg->WriteBitMsg( inOutMsg, numBytes ); } else { msg->ReadBitMsg( inOutMsg, numBytes ); } }

	// this is still needed to compile Rage code
	void	SerializeBytes( void * bytes, int numBytes ) { SanityCheck(); for ( int i = 0 ; i < numBytes ; i++ ) { Serialize( ((uint8 *)bytes)[i] ); } };

	bool	SerializeBoolNonRef( bool value )	{ SanityCheck(); if ( writing ) { msg->WriteBool(value); }		else { value = msg->ReadBool(); } return value; }		// We return a value so we can support bit fields (can't pass by reference)
	

#ifdef SERIALIZE_NO_QUANT
	template< int _max_, int _numBits_ >
	void	SerializeQ( idVec3 & value ) { Serialize( value ); }
	template< int _max_, int _numBits_ >
	void	SerializeQ( float & value ) { Serialize( value ); }
	template< int _max_, int _numBits_ >
	void	SerializeUQ( float & value ) { Serialize( value ); }
	void	SerializeQ( idMat3 & axis, int bits = 15 ) { Serialize( axis ); }
#else
	// SerializeQ - Quantizes a float to a variable number of bits (assumes signed, uses simple quantization)
	template< int _max_, int _numBits_ >
	void	SerializeQ( idVec3 & value ) { SanityCheck(); if ( writing ) { msg->WriteQuantizedVector< idVec3, _max_, _numBits_ >( value ); }	else { msg->ReadQuantizedVector< idVec3, _max_, _numBits_ >( value ); } }
	template< int _max_, int _numBits_ >
	void	SerializeQ( float & value ) { SanityCheck(); if ( writing ) { msg->WriteQuantizedFloat< _max_, _numBits_ >( value ); }		else { value = msg->ReadQuantizedFloat< _max_, _numBits_ >(); } }
	template< int _max_, int _numBits_ >
	void	SerializeUQ( float & value ) { SanityCheck(); if ( writing ) { msg->WriteQuantizedUFloat< _max_, _numBits_ >( value ); }	else { value = msg->ReadQuantizedUFloat< _max_, _numBits_ >(); } }
	void	SerializeQ( idMat3 & axis, int bits = 15 );		// Default to 15 bits per component, which has almost unnoticeable quantization
#endif

	void	Serialize( idMat3 & axis);			// Raw 3x3 matrix serialize
	void	SerializeC( idMat3 & axis);			// Uses compressed quaternion
	
	template< typename _type_ >  
	void	SerializeListElement( const idList<_type_* > & list, const _type_ *&element );

	void	SerializePacked(int & original);
	void	SerializeSPacked(int & original);

	void	SerializeString( char * s, int bufferSize )	{ SanityCheck(); if ( writing ) { msg->WriteString(s); } else { msg->ReadString( s, bufferSize ); } }
	//void	SerializeString( idAtomicString & s )		{ SanityCheck(); if ( writing ) { msg->WriteString(s); } else { idStr temp; msg->ReadString( temp ); s.Set( temp ); } }
	void	SerializeString( idStr & s )				{ SanityCheck(); if ( writing ) { msg->WriteString(s); } else { msg->ReadString( s ); } }
	//void	SerializeString( idStrId & s )				{ SanityCheck(); if ( writing ) { msg->WriteString(s.GetKey()); } else { idStr key; msg->ReadString( key ); s.Set( key );} }

	void	SerializeDelta( int32 & value, const int32 & base ) { SanityCheck(); if ( writing ) { msg->WriteDeltaLong( base, value ); } else { value = msg->ReadDeltaLong( base ); } }
	void	SerializeDelta( int16 & value, const int16 & base ) { SanityCheck(); if ( writing ) { msg->WriteDeltaShort( base, value ); } else { value = msg->ReadDeltaShort( base ); } }
	void	SerializeDelta( int8 & value, const int8 & base ) { SanityCheck(); if ( writing ) { msg->WriteDeltaChar( base, value ); } else { value = msg->ReadDeltaChar( base ); } }

	void	SerializeDelta( uint16 & value, const uint16 & base ) { SanityCheck(); if ( writing ) { msg->WriteDeltaUShort( base, value ); } else { value = msg->ReadDeltaUShort( base ); } }
	void	SerializeDelta( uint8 & value, const uint8 & base ) { SanityCheck(); if ( writing ) { msg->WriteDeltaByte( base, value ); } else { value = msg->ReadDeltaByte( base ); } }

	void	SerializeDelta( float & value, const float & base ) { SanityCheck(); if ( writing ) { msg->WriteDeltaFloat( base, value ); } else { value = msg->ReadDeltaFloat( base ); } }


	// Common types, no compression
	void	Serialize( int64 & value )		{ SanityCheck(); if ( writing ) { msg->WriteLongLong(value); }		else { value = msg->ReadLongLong(); } }
	void	Serialize( uint64 & value )		{ SanityCheck(); if ( writing ) { msg->WriteLongLong(value); }		else { value = msg->ReadLongLong(); } }
	void	Serialize( int32 & value )		{ SanityCheck(); if ( writing ) { msg->WriteLong(value); }			else { value = msg->ReadLong(); } }
	void	Serialize( uint32 & value )		{ SanityCheck(); if ( writing ) { msg->WriteLong(value); }			else { value = msg->ReadLong(); } }
	void	Serialize( int16 & value )		{ SanityCheck(); if ( writing ) { msg->WriteShort(value); }			else { value = msg->ReadShort(); } }
	void	Serialize( uint16 & value )		{ SanityCheck(); if ( writing ) { msg->WriteUShort(value); }		else { value = msg->ReadUShort(); } }
	void	Serialize( uint8 & value )		{ SanityCheck(); if ( writing ) { msg->WriteByte(value); }			else { value = msg->ReadByte(); } }
	void	Serialize( int8 & value )		{ SanityCheck(); if ( writing ) { msg->WriteChar(value); }			else { value = msg->ReadChar(); } }
	void	Serialize( bool & value )		{ SanityCheck(); if ( writing ) { msg->WriteByte(value?1:0); }		else { value = msg->ReadByte() != 0; } }
	void	Serialize( float & value )		{ SanityCheck(); if ( writing ) { msg->WriteFloat(value); }			else { value = msg->ReadFloat(); } }
	void	Serialize( idRandom2 & value )	{ SanityCheck(); if ( writing ) { msg->WriteLong(value.GetSeed()); } else { value.SetSeed( msg->ReadLong() ); } }
	void	Serialize( idVec3 & value )		{ SanityCheck(); if ( writing ) { msg->WriteVectorFloat(value); }	else { msg->ReadVectorFloat(value); } }
	void	Serialize( idVec2 & value )		{ SanityCheck(); if ( writing ) { msg->WriteVectorFloat(value); }	else { msg->ReadVectorFloat(value); } }
	void	Serialize( idVec6 & value )		{ SanityCheck(); if ( writing ) { msg->WriteVectorFloat(value); }	else { msg->ReadVectorFloat(value); } }
	void	Serialize( idVec4 & value )		{ SanityCheck(); if ( writing ) { msg->WriteVectorFloat(value); }	else { msg->ReadVectorFloat(value); } }

	// serialize an angle, normalized to between 0 to 360 and quantized to 16 bits
	void	SerializeAngle( float & value ) {
				SanityCheck(); 
				if ( writing ) {
					float nAngle = idMath::AngleNormalize360( value );
					assert( nAngle >= 0.0f ); // should never get a negative angle
					uint16 sAngle = nAngle * ( 65536.0f / 360.0f );
					msg->WriteUShort( sAngle );
				} else {
					uint16 sAngle = msg->ReadUShort();
					value = sAngle * ( 360.0f / 65536.0f );
				}

			}

	//void	Serialize( degrees_t & value )	{ 
	//			SanityCheck(); 
	//			float angle = value.Get();
	//			Serialize( angle );
	//			value.Set( angle );
	//		}
	//void	SerializeAngle( degrees_t & value )	{ 
	//			SanityCheck(); 
	//			float angle = value.Get();
	//			SerializeAngle( angle );
	//			value.Set( angle );
	//		}
	//void	Serialize( radians_t & value ) { 
	//			SanityCheck();
	//			// convert to degrees
	//			degrees_t d( value.Get() * idMath::M_RAD2DEG );
	//			Serialize( d );
	//			if ( !writing ) {
	//				// if reading, get the value we read in degrees and convert back to radians
	//				value.Set( d.Get() * idMath::M_DEG2RAD );
	//			}
	//		}
	//void	SerializeAngle( radians_t & value ) { 
	//			SanityCheck();
	//			// convert to degrees
	//			degrees_t d( value.Get() * idMath::M_RAD2DEG );
	//			// serialize as normalized degrees between 0 - 360
	//			SerializeAngle( d );
	//			if ( !writing ) {
	//				// if reading, get the value we read in degrees and convert back to radians
	//				value.Set( d.Get() * idMath::M_DEG2RAD );
	//			}
	//		}
	//
	//void	Serialize( idColor & value ) {
	//	Serialize( value.r );
	//	Serialize( value.g );
	//	Serialize( value.b );
	//	Serialize( value.a );
	//}
	
	void	SanityCheck() {
#ifdef SERIALIZE_SANITYCHECK
		if ( writing ) {
			msg->WriteUShort( 0xCCCC );
			msg->WriteUShort( magic );
		} else {
			int cccc = msg->ReadUShort();
			int m = msg->ReadUShort();
			assert( cccc == 0xCCCC );
			assert( m == magic );
			// For release builds
			if ( cccc != 0xCCCC ) {
				idLib::Error( "idSerializer::SanityCheck - cccc != 0xCCCC" );
			}
			if ( m != magic ) {
				idLib::Error( "idSerializer::SanityCheck - m != magic" );
			}
		}
		magic++;
#endif
	}

	void SerializeCheckpoint( const char * file, int line ) {
#ifdef ENABLE_SERIALIZE_CHECKPOINTS
		const uint32 tagValue = 0xABADF00D;
		uint32 tag = tagValue;
		Serialize( tag );
		if ( tag != tagValue ) {
			idLib::Error( "SERIALIZE_CHECKPOINT: tag != tagValue (file: %s - line: %i)", file, line );
		}
#endif
	}

	idBitMsg &	GetMsg() { return *msg; }

private:
	bool		writing;
	idBitMsg *	msg;
#ifdef SERIALIZE_SANITYCHECK
	int			magic;
#endif
};

class idSerializerScopedBlock {
public:
	idSerializerScopedBlock( idSerializer &ser_, int maxSizeBytes_ ) {
		ser = &ser_;
		maxSizeBytes = maxSizeBytes_;
	
		startByte = ser->IsReading() ? ser->GetMsg().GetReadCount() : ser->GetMsg().GetSize();
		startWriteBits = ser->GetMsg().GetWriteBit();
	}

	~idSerializerScopedBlock() {
	
		// Serialize remaining bits
		while ( ser->GetMsg().GetWriteBit() != startWriteBits ) {
			ser->SerializeBoolNonRef( false );
		}
	
		// Verify we didn't go over
		int endByte = ser->IsReading() ? ser->GetMsg().GetReadCount() : ser->GetMsg().GetSize();
		int sizeBytes = endByte - startByte;
		if ( !verify( sizeBytes <= maxSizeBytes ) ) {
			idLib::Warning( "idSerializerScopedBlock went over maxSize (%d > %d)", sizeBytes, maxSizeBytes );
			return;
		}

		// Serialize remaining bytes
		uint8 b=0;
		while ( sizeBytes < maxSizeBytes ) {
			ser->Serialize( b );
			sizeBytes++;
		}

		int finalSize = ( ( ser->IsReading() ? ser->GetMsg().GetReadCount() : ser->GetMsg().GetSize() ) - startByte );
		verify( maxSizeBytes == finalSize );
	}

private:
	idSerializer * ser;
	int maxSizeBytes;
	
	int startByte;
	int startWriteBits;
};




/*
========================
idSerializer::SerializeQ
========================
*/
#ifndef SERIALIZE_NO_QUANT
ID_INLINE void idSerializer::SerializeQ( idMat3 &axis, int bits ) {
	SanityCheck();

	const float scale = ( ( 1 << ( bits - 1 ) ) - 1 );
	if ( IsWriting() ) {
		idQuat quat = axis.ToQuat();

		int maxIndex = 0;
		for ( unsigned int i = 1; i < 4; i++ ) {
			if ( idMath::Fabs( quat[i] ) > idMath::Fabs( quat[maxIndex] ) ) {
				maxIndex = i;
			}
		}

		msg->WriteBits( maxIndex, 2 );

		idVec3 out;

		if ( quat[maxIndex] < 0.0f ) {
			out.x = -quat[( maxIndex + 1 ) & 3];
			out.y = -quat[( maxIndex + 2 ) & 3];
			out.z = -quat[( maxIndex + 3 ) & 3];
		} else {
			out.x = quat[( maxIndex + 1 ) & 3];
			out.y = quat[( maxIndex + 2 ) & 3];
			out.z = quat[( maxIndex + 3 ) & 3];
		}
		msg->WriteBits( idMath::Ftoi( out.x * scale ), -bits);
		msg->WriteBits( idMath::Ftoi( out.y * scale ), -bits);
		msg->WriteBits( idMath::Ftoi( out.z * scale ), -bits);
	
	} else if ( IsReading() ) {
		idQuat quat;
		idVec3 in;

		int maxIndex = msg->ReadBits(2);

		in.x = (float)msg->ReadBits(-bits) / scale;
		in.y = (float)msg->ReadBits(-bits) / scale;
		in.z = (float)msg->ReadBits(-bits) / scale;

		quat[( maxIndex + 1 ) & 3] = in.x;
		quat[( maxIndex + 2 ) & 3] = in.y;
		quat[( maxIndex + 3 ) & 3] = in.z;

		quat[maxIndex] = idMath::Sqrt( idMath::Fabs( 1.0f - in.x * in.x - in.y * in.y - in.z * in.z ) );

		axis = quat.ToMat3();
	}
}
#endif

/*
========================
idSerializer::Serialize
========================
*/
ID_INLINE void idSerializer::Serialize( idMat3 & axis ) {
	SanityCheck();

	Serialize( axis[0] );
	Serialize( axis[1] );
	Serialize( axis[2] );
}

/*
========================
idSerializer::SerializeC
========================
*/
ID_INLINE void idSerializer::SerializeC( idMat3 & axis ) {
	SanityCheck();

	if ( IsWriting() ) {
		idCQuat cquat = axis.ToCQuat();

		Serialize( cquat.x );
		Serialize( cquat.y );
		Serialize( cquat.z );
	} else if ( IsReading() ) {
		idCQuat cquat;

		Serialize( cquat.x );
		Serialize( cquat.y );
		Serialize( cquat.z );

		axis = cquat.ToMat3();
	}
}

/*
========================
idSerializer::SerializeListElement
========================
*/
template< typename _type_ >  
ID_INLINE void idSerializer::SerializeListElement( const idList<_type_* > & list, const _type_ *&element ) {
	SanityCheck();

	if ( IsWriting() ) {
		int index = list.FindIndex( const_cast<_type_ *>(element) );
		assert( index >= 0 );
		SerializePacked( index );
	} else if ( IsReading() ) {
		int index = 0;
		SerializePacked( index );
		element = list[index];
	}
}

/*
========================
idSerializer::SerializePacked
Writes out 7 bits at a time, using every 8th bit to signify more bits exist

NOTE - Signed values work with this function, but take up more bytes
Use SerializeSPacked if you anticipate lots of negative values 
========================
*/
ID_INLINE void idSerializer::SerializePacked(int & original) {
	SanityCheck();

	if ( IsWriting() ) {
		uint32 value = original;

		while ( true ) {
			uint8 byte = value & 0x7F;
			value >>= 7;
			byte |= value ? 0x80 : 0;
			msg->WriteByte( byte );		// Emit byte
			if ( value == 0 ) {
				break;
			}
		}
	} else {
		uint8 byte = 0x80;
		uint32 value = 0;
		int32 shift = 0;

		while ( byte & 0x80 && shift < 32 ) {
			byte = msg->ReadByte();
			value |= (byte & 0x7F) << shift;
			shift += 7;
		}

		original = value;
	}
}

/*
========================
idSerializer::SerializeSPacked
Writes out 7 bits at a time, using every 8th bit to signify more bits exist

NOTE - An extra bit of the first byte is used to store the sign
(this function supports negative values, but will use 2 bytes for values greater than 63)
========================
*/
ID_INLINE void idSerializer::SerializeSPacked(int & value) {
	SanityCheck();

	if ( IsWriting() ) {

		uint32 uvalue = idMath::Abs( value );

		// Write the first byte specifically to handle the sign bit
		uint8 byte = uvalue & 0x3f;
		byte |= value < 0 ? 0x40 : 0;
		uvalue >>= 6;
		byte |= uvalue > 0 ? 0x80 : 0;

		msg->WriteByte( byte );

		while ( uvalue > 0 ) {
			uint8 byte2 = uvalue & 0x7F;
			uvalue >>= 7;
			byte2 |= uvalue ? 0x80 : 0;
			msg->WriteByte( byte2 );		// Emit byte
		}
	} else {
		// Load the first byte specifically to handle the sign bit
		uint8 byte		= msg->ReadByte();
		uint32 uvalue	= byte & 0x3f;
		bool sgn		= (byte & 0x40) ? true : false;
		int32 shift		= 6;
		
		while ( byte & 0x80 && shift < 32 ) {
			byte = msg->ReadByte();		// Read byte
			uvalue |= (byte & 0x7F) << shift;
			shift += 7;
		}

		value = sgn ? -((int)uvalue) : uvalue;
	}
}

#endif