source-engine/vphysics/convert.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//=============================================================================//
#include <stdio.h>
#include "convert.h"
#include "ivp_cache_object.hxx"
#include "coordsize.h"

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"

#if 1
// game is in inches
vphysics_units_t g_PhysicsUnits = 
{ 
	METERS_PER_INCH, //float		unitScaleMeters;			// factor that converts game units to meters
	1.0f / METERS_PER_INCH, //float		unitScaleMetersInv;		// factor that converts meters to game units
	0.25f,			// float		globalCollisionTolerance;	// global collision tolerance in game units
	DIST_EPSILON,	// float		collisionSweepEpsilon;		// collision sweep tests clip at this, must be the same as engine's DIST_EPSILON
	1.0f/256.0f,	// float		collisionSweepIncrementalEpsilon;	// near-zero test for incremental steps in collision sweep tests
};
#else
// game is in meters
vphysics_units_t g_PhysicsUnits = 
{ 
	1.0f,			//float		unitScaleMeters;			// factor that converts game units to meters
	1.0f,			//float		unitScaleMetersInv;			// factor that converts meters to game units
	0.01f,			// float		globalCollisionTolerance;	// global collision tolerance in game units
	0.01f,			// float		collisionSweepEpsilon;		// collision sweep tests clip at this, must be the same as engine's DIST_EPSILON
	1e-4f,			// float		collisionSweepIncrementalEpsilon;	// near-zero test for incremental steps in collision sweep tests
};
#endif

//-----------------------------------------------------------------------------
// HL to IVP conversions
//-----------------------------------------------------------------------------

void ConvertBoxToIVP( const Vector &mins, const Vector &maxs, Vector &outmins, Vector &outmaxs )
{
	float tmpZ;

	tmpZ = mins.y;
	outmins.y = -HL2IVP(mins.z);
	outmins.z = HL2IVP(tmpZ);
	outmins.x = HL2IVP(mins.x);
	tmpZ = maxs.y;
	outmaxs.y = -HL2IVP(maxs.z);
	outmaxs.z = HL2IVP(tmpZ);
	outmaxs.x = HL2IVP(maxs.x);

	tmpZ = outmaxs.y;
	outmaxs.y = outmins.y;
	outmins.y = tmpZ;
}


void ConvertMatrixToIVP( const matrix3x4_t& matrix, IVP_U_Matrix &out )
{
	Vector forward, left, up;

	forward.x = matrix[0][0];
	forward.y = matrix[1][0];
	forward.z = matrix[2][0];

	left.x = matrix[0][1];
	left.y = matrix[1][1];
	left.z = matrix[2][1];

	up.x = matrix[0][2];
	up.y = matrix[1][2];
	up.z = matrix[2][2];

	up = -up;

	IVP_U_Float_Point ivpForward, ivpLeft, ivpUp;

	ConvertDirectionToIVP( forward, ivpForward );
	ConvertDirectionToIVP( left, ivpLeft );
	ConvertDirectionToIVP( up, ivpUp );

	out.set_col( IVP_INDEX_X, &ivpForward );
	out.set_col( IVP_INDEX_Z, &ivpLeft );
	out.set_col( IVP_INDEX_Y, &ivpUp );

	out.vv.k[0] = HL2IVP(matrix[0][3]);
	out.vv.k[1] = -HL2IVP(matrix[2][3]);
	out.vv.k[2] = HL2IVP(matrix[1][3]);
}


void ConvertRotationToIVP( const QAngle& angles, IVP_U_Matrix3 &out )
{
	Vector forward, right, up;
	IVP_U_Float_Point ivpForward, ivpLeft, ivpUp;
	
	AngleVectors( angles, &forward, &right, &up );
	// now this is left
	right = -right;

	up = -up;
	
	ConvertDirectionToIVP( forward, ivpForward );
	ConvertDirectionToIVP( right, ivpLeft );
	ConvertDirectionToIVP( up, ivpUp );
	
	out.set_col( IVP_INDEX_X, &ivpForward );
	out.set_col( IVP_INDEX_Z, &ivpLeft );
	out.set_col( IVP_INDEX_Y, &ivpUp );
}

void ConvertRotationToIVP( const QAngle& angles, IVP_U_Quat &out )
{
	IVP_U_Matrix3 tmp;
	ConvertRotationToIVP( angles, tmp );
	out.set_quaternion( &tmp );
}

//-----------------------------------------------------------------------------
// IVP to HL conversions
//-----------------------------------------------------------------------------

void ConvertMatrixToHL( const IVP_U_Matrix &in, matrix3x4_t& output )
{
#if 1
	// copy the row vectors over, swapping z & -y.  Also, negate output z
	output[0][0] = in.get_elem(0, 0);
	output[0][2] = -in.get_elem(0, 1);
	output[0][1] = in.get_elem(0, 2);

	output[1][0] = in.get_elem(2, 0);
	output[1][2] = -in.get_elem(2, 1);
	output[1][1] = in.get_elem(2, 2);

	output[2][0] = -in.get_elem(1, 0);
	output[2][2] = in.get_elem(1, 1);
	output[2][1] = -in.get_elem(1, 2);

#else

	// this code is conceptually simpler, but the above is smaller/faster
	Vector forward, left, up;
	IVP_U_Float_Point out;

	in.get_col( IVP_INDEX_X, &out );
	ConvertDirectionToHL( out, forward );
	in.get_col( IVP_INDEX_Z, &out );
	ConvertDirectionToHL( out, left);
	in.get_col( IVP_INDEX_Y, &out );
	ConvertDirectionToHL( out, up );
	up = -up;

	output[0][0] = forward.x;
	output[1][0] = forward.y;
	output[2][0] = forward.z;

	output[0][1] = left.x;
	output[1][1] = left.y;
	output[2][1] = left.z;

	output[0][2] = up.x;
	output[1][2] = up.y;
	output[2][2] = up.z;
#endif
	output[0][3] = IVP2HL(in.vv.k[0]);
	output[1][3] = IVP2HL(in.vv.k[2]);
	output[2][3] = -IVP2HL(in.vv.k[1]);
}


void ConvertRotationToHL( const IVP_U_Matrix3 &in, QAngle& angles )
{
	IVP_U_Float_Point out;
	Vector forward, right, up;

	in.get_col( IVP_INDEX_X, &out );
	ConvertDirectionToHL( out, forward );
	in.get_col( IVP_INDEX_Z, &out );
	ConvertDirectionToHL( out, right );
	in.get_col( IVP_INDEX_Y, &out );
	ConvertDirectionToHL( out, up );

	float xyDist = sqrt( forward[0] * forward[0] + forward[1] * forward[1] );
	
	// enough here to get angles?
	if ( xyDist > 0.001 )
	{
		// (yaw)	y = ATAN( forward.y, forward.x );		-- in our space, forward is the X axis
		angles[1] = RAD2DEG( atan2( forward[1], forward[0] ) );

		// (pitch)	x = ATAN( -forward.z, sqrt(forward.x*forward.x+forward.y*forward.y) );
		angles[0] = RAD2DEG( atan2( -forward[2], xyDist ) );

		// (roll)	z = ATAN( -right.z, up.z );
		angles[2] = RAD2DEG( atan2( -right[2], up[2] ) ) + 180;
	}
	else	// forward is mostly Z, gimbal lock
	{
		// (yaw)	y = ATAN( -right.x, right.y );		-- forward is mostly z, so use right for yaw
		angles[1] = RAD2DEG( atan2( right[0], -right[1] ) );

		// (pitch)	x = ATAN( -forward.z, sqrt(forward.x*forward.x+forward.y*forward.y) );
		angles[0] = RAD2DEG( atan2( -forward[2], xyDist ) );

		// Assume no roll in this case as one degree of freedom has been lost (i.e. yaw == roll)
		angles[2] = 180;
	}
}


void ConvertRotationToHL( const IVP_U_Quat &in, QAngle& angles )
{
	IVP_U_Matrix3 tmp;
	in.set_matrix( &tmp );
	ConvertRotationToHL( tmp, angles );
}

// utiltiy code
void TransformIVPToLocal( IVP_U_Point &point, IVP_Real_Object *pObject, bool translate )
{
	IVP_U_Point tmp = point;
	TransformIVPToLocal( tmp, point, pObject, translate );
}

void TransformLocalToIVP( IVP_U_Point &point, IVP_Real_Object *pObject, bool translate )
{
	IVP_U_Point tmp = point;
	TransformLocalToIVP( tmp, point, pObject, translate );
}


// UNDONE: use IVP_Cache_Object instead?  Measure perf differences.
#define USE_CACHE_OBJECT	0


//-----------------------------------------------------------------------------
// Purpose: This is ONLY for use by the routines below.  It's not reentrant!!!
//			No threads or recursive calls!
//-----------------------------------------------------------------------------
#if USE_CACHE_OBJECT
#else
static const IVP_U_Matrix *GetTmpObjectMatrix( IVP_Real_Object *pObject )
{
	static IVP_U_Matrix coreShiftMatrix;
	const IVP_U_Matrix *pOut = pObject->get_core()->get_m_world_f_core_PSI();

	if ( !pObject->flags.shift_core_f_object_is_zero )
	{
		coreShiftMatrix.set_matrix( pOut );
		coreShiftMatrix.vmult4( pObject->get_shift_core_f_object(), &coreShiftMatrix.vv );
		return &coreShiftMatrix;
	}
	return pOut;
}
#endif

void TransformIVPToLocal( const IVP_U_Point &pointIn, IVP_U_Point &pointOut, IVP_Real_Object *pObject, bool translate )
{
#if USE_CACHE_OBJECT
	IVP_Cache_Object *cache = pObject->get_cache_object_no_lock();

	if ( translate )
	{
		cache->transform_position_to_object_coords( &pointIn, &pointOut );
	}
	else
	{
		cache->transform_vector_to_object_coords( &pointIn, &pointOut );
	}
#else
	const IVP_U_Matrix *pMatrix = GetTmpObjectMatrix( pObject );
	if ( translate )
	{
		pMatrix->inline_vimult4( &pointIn, &pointOut );
	}
	else
	{
		pMatrix->inline_vimult3( &pointIn, &pointOut );
	}
#endif
}


void TransformLocalToIVP( const IVP_U_Point &pointIn, IVP_U_Point &pointOut, IVP_Real_Object *pObject, bool translate )
{
#if USE_CACHE_OBJECT
	IVP_Cache_Object *cache = pObject->get_cache_object_no_lock();

	if ( translate )
	{
		IVP_U_Float_Point floatPointIn;
		floatPointIn.set( &pointIn );
		cache->transform_position_to_world_coords( &floatPointIn, &pointOut );
	}
	else
	{
		cache->transform_vector_to_world_coords( &pointIn, &pointOut );
	}
#else
	const IVP_U_Matrix *pMatrix = GetTmpObjectMatrix( pObject );

	if ( translate )
	{
		pMatrix->inline_vmult4( &pointIn, &pointOut );
	}
	else
	{
		pMatrix->inline_vmult3( &pointIn, &pointOut );
	}
#endif
}

void TransformLocalToIVP( const IVP_U_Float_Point &pointIn, IVP_U_Point &pointOut, IVP_Real_Object *pObject, bool translate )
{
#if USE_CACHE_OBJECT
	IVP_Cache_Object *cache = pObject->get_cache_object_no_lock();

	if ( translate )
	{
		cache->transform_position_to_world_coords( &pointIn, &pointOut );
	}
	else
	{
		IVP_U_Point doublePointIn;
		doublePointIn.set( &pointIn );
		cache->transform_vector_to_world_coords( &doublePointIn, &pointOut );
	}
#else
	const IVP_U_Matrix *pMatrix = GetTmpObjectMatrix( pObject );
	IVP_U_Float_Point out;

	if ( translate )
	{
		pMatrix->inline_vmult4( &pointIn, &out );
	}
	else
	{
		pMatrix->inline_vmult3( &pointIn, &out );
	}
	pointOut.set( &out );
#endif
}

void TransformLocalToIVP( const IVP_U_Float_Point &pointIn, IVP_U_Float_Point &pointOut, IVP_Real_Object *pObject, bool translate )
{
	IVP_U_Point tmpOut;
	TransformLocalToIVP( pointIn, tmpOut, pObject, translate );
	pointOut.set( &tmpOut );
}

static char axisMap[] = {0,2,1,3};

int ConvertCoordinateAxisToIVP( int axisIndex )
{
	return axisIndex < 4 ? axisMap[axisIndex] : 0;
}

int ConvertCoordinateAxisToHL( int axisIndex )
{
	return axisIndex < 4 ? axisMap[axisIndex] : 0;
}