doom3-bfg/neo/idlib/Swap.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 __SWAP_H__
#define __SWAP_H__

/*
================================================================================================
Contains the Swap class, for CrossPlatform endian conversion.

works 
================================================================================================
*/

/*
========================
IsPointer
========================
*/
template< typename type >
bool IsPointer( type ) {
	return false;
}

/*
========================
IsPointer
========================
*/
template< typename type >
bool IsPointer( type * ) {
	return true;
}

/*
================================================
The *Swap* static template class, idSwap, is used by the SwapClass template class for 
performing EndianSwapping.
================================================
*/
class idSwap {
public:
	//#define SwapBytes( x, y )		(x) ^= (y) ^= (x) ^= (y)
	#define SwapBytes( x, y )		{ byte t = (x); (x) = (y); (y) = t; }

	template<class type> static void Little( type &c ) {
		// byte swapping pointers is pointless because we should never store pointers on disk
		assert( !IsPointer( c ) );

	}

	template<class type> static void Big( type &c ) {
		// byte swapping pointers is pointless because we should never store pointers on disk
		assert( !IsPointer( c ) );

			if ( sizeof( type ) == 1 ) {
			} else if ( sizeof( type ) == 2 ) {
				byte *b = (byte *)&c;
				SwapBytes( b[0], b[1] );
			} else if ( sizeof( type ) == 4 ) {
				byte *b = (byte *)&c;
				SwapBytes( b[0], b[3] );
				SwapBytes( b[1], b[2] );
			} else if ( sizeof( type ) == 8 ) {
				byte * b = (byte *)&c;
				SwapBytes( b[0], b[7] );
				SwapBytes( b[1], b[6]);
				SwapBytes( b[2], b[5] );
				SwapBytes( b[3], b[4] );
			} else {
				assert( false );
			}
	}

	template<class type> static void LittleArray( type *c, int count ) {
	}

	template<class type> static void BigArray( type *c, int count ) {
		for ( int i = 0; i < count; i++ ) {
			Big( c[i] );
		}
	}

	static void SixtetsForInt( byte *out, int src ) {
			byte *b = (byte *)&src;
			out[0] = ( b[0] & 0xfc ) >> 2;
			out[1] = ( ( b[0] & 0x3 ) << 4 ) + ( ( b[1] & 0xf0 ) >> 4 );
			out[2] = ( ( b[1] & 0xf ) << 2 ) + ( ( b[2] & 0xc0 ) >> 6 );
			out[3] = b[2] & 0x3f;
	}

	static int IntForSixtets( byte *in ) {
			int ret = 0;
			byte *b = (byte *)&ret;
			b[0] |= in[0] << 2;
			b[0] |= ( in[1] & 0x30 ) >> 4;
			b[1] |= ( in[1] & 0xf ) << 4;
			b[1] |= ( in[2] & 0x3c ) >> 2;
			b[2] |= ( in[2] & 0x3 ) << 6;
			b[2] |= in[3];
			return ret;
	}

public:		// specializations
#ifndef ID_SWAP_LITE // avoid dependency avalanche for SPU code
#define SWAP_VECTOR( x ) \
	static void Little( x &c ) { LittleArray( c.ToFloatPtr(), c.GetDimension() ); } \
	static void Big( x &c ) {    BigArray( c.ToFloatPtr(), c.GetDimension() ); }

	SWAP_VECTOR( idVec2 );
	SWAP_VECTOR( idVec3 );
	SWAP_VECTOR( idVec4 );
	SWAP_VECTOR( idVec5 );
	SWAP_VECTOR( idVec6 );
	SWAP_VECTOR( idMat2 );
	SWAP_VECTOR( idMat3 );
	SWAP_VECTOR( idMat4 );
	SWAP_VECTOR( idMat5 );
	SWAP_VECTOR( idMat6 );
	SWAP_VECTOR( idPlane );
	SWAP_VECTOR( idQuat );
	SWAP_VECTOR( idCQuat );
	SWAP_VECTOR( idAngles );
	SWAP_VECTOR( idBounds );

	static void Little( idDrawVert &v ) {
			Little( v.xyz );
			LittleArray( v.st, 2 );
			LittleArray( v.normal, 4 );
			LittleArray( v.tangent, 4 );
			LittleArray( v.color, 4 );
	}
	static void Big( idDrawVert &v ) {
			Big( v.xyz );
			BigArray( v.st, 2 );
			BigArray( v.normal, 4 );
			BigArray( v.tangent, 4 );
			BigArray( v.color, 4 );
	}
#endif
};

/*
================================================
idSwapClass is a template class for performing EndianSwapping.
================================================
*/
template<class classType>
class idSwapClass {
public:
	idSwapClass() {
		#ifdef _DEBUG
			size = 0;
		#endif
	}
	~idSwapClass() {
		#ifdef _DEBUG
			assert( size == sizeof( classType ) );
		#endif
	}

	template<class type> void Little( type &c ) {
		idSwap::Little( c );
		#ifdef _DEBUG
			size += sizeof( type );
		#endif
	}

	template<class type> void Big( type &c ) {
		idSwap::Big( c );
		#ifdef _DEBUG
			size += sizeof( type );
		#endif
	}

	template<class type> void LittleArray( type *c, int count ) {
		idSwap::LittleArray( c, count );
		#ifdef _DEBUG
			size += count * sizeof( type );
		#endif
	}

	template<class type> void BigArray( type *c, int count ) {
		idSwap::BigArray( c, count );
		#ifdef _DEBUG
			size += count * sizeof( type );
		#endif
	}

#ifdef _DEBUG
private:
	int size;
#endif
};

	#define BIG32(v) ((((uint32)(v)) >> 24) | (((uint32)(v) & 0x00FF0000) >> 8) | (((uint32)(v) & 0x0000FF00) << 8) | ((uint32)(v) << 24))
	#define BIG16(v) ((((uint16)(v)) >> 8) | ((uint16)(v) << 8))

#endif // !__SWAP_H__