diff options
Diffstat (limited to 'vphysics/convert.h')
| -rw-r--r-- | vphysics/convert.h | 279 |
1 files changed, 279 insertions, 0 deletions
diff --git a/vphysics/convert.h b/vphysics/convert.h new file mode 100644 index 0000000..8ae7561 --- /dev/null +++ b/vphysics/convert.h @@ -0,0 +1,279 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: +// +// $NoKeywords: $ +//=============================================================================// + +#ifndef CONVERT_H +#define CONVERT_H +#pragma once + +#include "mathlib/vector.h" +#include "mathlib/mathlib.h" +#include "ivp_physics.hxx" +struct cplane_t; +#include "vphysics_interface.h" + +// UNDONE: Remove all conversion/scaling +// Convert our units (inches) to IVP units (meters) +struct vphysics_units_t +{ + float unitScaleMeters; // factor that converts game units to meters + float unitScaleMetersInv; // factor that converts meters to game units + float globalCollisionTolerance; // global collision tolerance in game units + float collisionSweepEpsilon; // collision sweep tests clip at this, must be the same as engine's DIST_EPSILON + float collisionSweepIncrementalEpsilon; // near-zero test for incremental steps in collision sweep tests +}; + +extern vphysics_units_t g_PhysicsUnits; + +#define HL2IVP_FACTOR g_PhysicsUnits.unitScaleMeters +#define IVP2HL(x) (float)(x * (g_PhysicsUnits.unitScaleMetersInv)) +#define HL2IVP(x) (double)(x * HL2IVP_FACTOR) + +// Convert HL engine units to IVP units +inline void ConvertPositionToIVP( const Vector &in, IVP_U_Float_Point &out ) +{ + float tmpZ; + + tmpZ = in[1]; + + out.k[0] = HL2IVP(in[0]); + out.k[1] = -HL2IVP(in[2]); + out.k[2] = HL2IVP(tmpZ); +} + +inline void ConvertPositionToIVP( const Vector &in, IVP_U_Point &out ) +{ + float tmpZ; + + tmpZ = in[1]; + + out.k[0] = HL2IVP(in[0]); + out.k[1] = -HL2IVP(in[2]); + out.k[2] = HL2IVP(tmpZ); +} + +inline void ConvertPositionToIVP( const Vector &in, IVP_U_Float_Point3 &out ) +{ + float tmpZ; + + tmpZ = in[1]; + + out.k[0] = HL2IVP(in[0]); + out.k[1] = -HL2IVP(in[2]); + out.k[2] = HL2IVP(tmpZ); +} + +inline void ConvertPositionToIVP( float &x, float &y, float &z ) +{ + float tmpZ; + + tmpZ = y; + y = -HL2IVP(z); + z = HL2IVP(tmpZ); + x = HL2IVP(x); +} + +inline void ConvertDirectionToIVP( const Vector &in, IVP_U_Float_Point &out ) +{ + float tmpZ; + + tmpZ = in[1]; + + out.k[0] = in[0]; + out.k[1] = -in[2]; + out.k[2] = tmpZ; +} + + +inline void ConvertDirectionToIVP( const Vector &in, IVP_U_Point &out ) +{ + float tmpZ; + + tmpZ = in[1]; + + out.k[0] = in[0]; + out.k[1] = -in[2]; + out.k[2] = tmpZ; +} + + +// forces are handled the same as positions & velocities (scaled by distance conversion factor) +#define ConvertForceImpulseToIVP ConvertPositionToIVP +#define ConvertForceImpulseToHL ConvertPositionToHL + +inline float ConvertAngleToIVP( float angleIn ) +{ + return DEG2RAD(angleIn); +} + +inline void ConvertAngularImpulseToIVP( const AngularImpulse &in, IVP_U_Float_Point &out ) +{ + float tmpZ; + + tmpZ = in[1]; + + out.k[0] = DEG2RAD(in[0]); + out.k[1] = -DEG2RAD(in[2]); + out.k[2] = DEG2RAD(tmpZ); +} + + +inline float ConvertDistanceToIVP( float distance ) +{ + return HL2IVP( distance ); +} + +inline void ConvertPlaneToIVP( const Vector &pNormal, float dist, IVP_U_Hesse &plane ) +{ + ConvertDirectionToIVP( pNormal, (IVP_U_Point &)plane ); + // HL stores planes as Ax + By + Cz = D + // IVP stores them as Ax + BY + Cz + D = 0 + plane.hesse_val = -ConvertDistanceToIVP( dist ); +} + + +inline void ConvertPlaneToIVP( const Vector &pNormal, float dist, IVP_U_Float_Hesse &plane ) +{ + ConvertDirectionToIVP( pNormal, (IVP_U_Float_Point &)plane ); + // HL stores planes as Ax + By + Cz = D + // IVP stores them as Ax + BY + Cz + D = 0 + plane.hesse_val = -ConvertDistanceToIVP( dist ); +} + +inline float ConvertDensityToIVP( float density ) +{ + return density; +} + +// in convert.cpp +extern void ConvertMatrixToIVP( const matrix3x4_t& matrix, IVP_U_Matrix &out ); +extern void ConvertRotationToIVP( const QAngle &angles, IVP_U_Matrix3 &out ); +extern void ConvertRotationToIVP( const QAngle& angles, IVP_U_Quat &out ); +extern void ConvertBoxToIVP( const Vector &mins, const Vector &maxs, Vector &outmins, Vector &outmaxs ); +extern int ConvertCoordinateAxisToIVP( int axisIndex ); +extern int ConvertCoordinateAxisToHL( int axisIndex ); + +// IVP to HL conversions +inline void ConvertPositionToHL( const IVP_U_Point &point, Vector& out ) +{ + float tmpY = IVP2HL(point.k[2]); + out[2] = -IVP2HL(point.k[1]); + out[1] = tmpY; + out[0] = IVP2HL(point.k[0]); +} + +inline void ConvertPositionToHL( const IVP_U_Float_Point &point, Vector& out ) +{ + float tmpY = IVP2HL(point.k[2]); + out[2] = -IVP2HL(point.k[1]); + out[1] = tmpY; + out[0] = IVP2HL(point.k[0]); +} + +inline void ConvertPositionToHL( const IVP_U_Float_Point3 &point, Vector& out ) +{ + float tmpY = IVP2HL(point.k[2]); + out[2] = -IVP2HL(point.k[1]); + out[1] = tmpY; + out[0] = IVP2HL(point.k[0]); +} + +inline void ConvertDirectionToHL( const IVP_U_Point &point, Vector& out ) +{ + float tmpY = point.k[2]; + out[2] = -point.k[1]; + out[1] = tmpY; + out[0] = point.k[0]; +} + + +inline void ConvertDirectionToHL( const IVP_U_Float_Point &point, Vector& out ) +{ + float tmpY = point.k[2]; + out[2] = -point.k[1]; + out[1] = tmpY; + out[0] = point.k[0]; +} + + +inline float ConvertAngleToHL( float angleIn ) +{ + return RAD2DEG(angleIn); +} + +inline void ConvertAngularImpulseToHL( const IVP_U_Float_Point &point, AngularImpulse &out ) +{ + float tmpY = point.k[2]; + out[2] = -RAD2DEG(point.k[1]); + out[1] = RAD2DEG(tmpY); + out[0] = RAD2DEG(point.k[0]); +} + +inline float ConvertDistanceToHL( float distance ) +{ + return IVP2HL( distance ); +} + + +// NOTE: Converts in place +inline void ConvertPlaneToHL( cplane_t &plane ) +{ + IVP_U_Float_Hesse tmp(plane.normal.x, plane.normal.y, plane.normal.z, -plane.dist); + ConvertDirectionToHL( (IVP_U_Float_Point &)tmp, plane.normal ); + // HL stores planes as Ax + By + Cz = D + // IVP stores them as Ax + BY + Cz + D = 0 + plane.dist = -ConvertDistanceToHL( tmp.hesse_val ); +} + +inline void ConvertPlaneToHL( const IVP_U_Float_Hesse &plane, Vector *pNormalOut, float *pDistOut ) +{ + if ( pNormalOut ) + { + ConvertDirectionToHL( plane, *pNormalOut ); + } + // HL stores planes as Ax + By + Cz = D + // IVP stores them as Ax + BY + Cz + D = 0 + if ( pDistOut ) + { + *pDistOut = -ConvertDistanceToHL( plane.hesse_val ); + } +} + +inline float ConvertVolumeToHL( float volume ) +{ + float factor = IVP2HL(1.0); + factor = (factor * factor * factor); + return factor * volume; +} + +#define INSQR_PER_METERSQR (1.f / (METERS_PER_INCH*METERS_PER_INCH)) +inline float ConvertEnergyToHL( float energy ) +{ + return energy * INSQR_PER_METERSQR; +} + +inline void IVP_Float_PointAbs( IVP_U_Float_Point &out, const IVP_U_Float_Point &in ) +{ + out.k[0] = fabsf( in.k[0] ); + out.k[1] = fabsf( in.k[1] ); + out.k[2] = fabsf( in.k[2] ); +} + +// convert.cpp +extern void ConvertRotationToHL( const IVP_U_Matrix3 &in, QAngle &angles ); +extern void ConvertMatrixToHL( const IVP_U_Matrix &in, matrix3x4_t& output ); +extern void ConvertRotationToHL( const IVP_U_Quat &in, QAngle& angles ); + +extern void TransformIVPToLocal( IVP_U_Point &pointInOut, IVP_Real_Object *pObject, bool translate ); +extern void TransformLocalToIVP( IVP_U_Point &pointInOut, IVP_Real_Object *pObject, bool translate ); + +extern void TransformIVPToLocal( const IVP_U_Point &pointIn, IVP_U_Point &pointOut, IVP_Real_Object *pObject, bool translate ); +extern void TransformLocalToIVP( const IVP_U_Point &pointIn, IVP_U_Point &pointOut, IVP_Real_Object *pObject, bool translate ); + +extern void TransformLocalToIVP( const IVP_U_Float_Point &pointIn, IVP_U_Point &pointOut, IVP_Real_Object *pObject, bool translate ); +extern void TransformLocalToIVP( const IVP_U_Float_Point &pointIn, IVP_U_Float_Point &pointOut, IVP_Real_Object *pObject, bool translate ); + +#endif // CONVERT_H |