//-----------------------------------------------------------------------------
// Transform from DME to engine coordinates
//-----------------------------------------------------------------------------
void CDmeMDL::EngineToDmeMatrix( matrix3x4_t& engineToDme )
{
VMatrix rotation, rotationZ;
MatrixBuildRotationAboutAxis( rotation, Vector( 1, 0, 0 ), -90 );
MatrixBuildRotationAboutAxis( rotationZ, Vector( 0, 1, 0 ), -90 );
ConcatTransforms( rotationZ.As3x4(), rotation.As3x4(), engineToDme );
}
//-----------------------------------------------------------------------------
// Purpose: Builds the matrix for a counterclockwise rotation about an arbitrary axis.
//
// | ax2 + (1 - ax2)cosQ axay(1 - cosQ) - azsinQ azax(1 - cosQ) + aysinQ |
// Ra(Q) = | axay(1 - cosQ) + azsinQ ay2 + (1 - ay2)cosQ ayaz(1 - cosQ) - axsinQ |
// | azax(1 - cosQ) - aysinQ ayaz(1 - cosQ) + axsinQ az2 + (1 - az2)cosQ |
//
// Input : mat -
// vAxisOrRot -
// angle -
//-----------------------------------------------------------------------------
void MatrixBuildRotationAboutAxis( VMatrix &dst, const Vector &vAxisOfRot, float angleDegrees )
{
MatrixBuildRotationAboutAxis( vAxisOfRot, angleDegrees, dst.As3x4() );
dst[3][0] = 0;
dst[3][1] = 0;
dst[3][2] = 0;
dst[3][3] = 1;
}
//-----------------------------------------------------------------------------
// Sets up the camera
//-----------------------------------------------------------------------------
void CRenderManager::SetupCameraRenderState( )
{
CCameraProperty *pCamera = g_pWorldManager->GetLocalPlayer()->m_pCameraProperty;
matrix3x4_t cameraToWorld;
AngleMatrix( pCamera->m_Angles, pCamera->m_Origin, cameraToWorld );
matrix3x4_t matRotate;
matrix3x4_t matRotateZ;
MatrixBuildRotationAboutAxis( Vector(0,0,1), -90, matRotateZ );
MatrixMultiply( cameraToWorld, matRotateZ, matRotate );
matrix3x4_t matRotateX;
MatrixBuildRotationAboutAxis( Vector(1,0,0), 90, matRotateX );
MatrixMultiply( matRotate, matRotateX, matRotate );
matrix3x4_t view;
MatrixInvert( matRotate, view );
CMatRenderContextPtr pRenderContext( g_pMaterialSystem );
pRenderContext->MatrixMode( MATERIAL_VIEW );
pRenderContext->LoadMatrix( view );
}
//-----------------------------------------------------------------------------
// Builds a rotation matrix that rotates one direction vector into another
//-----------------------------------------------------------------------------
void MatrixBuildRotation( VMatrix &dst, const Vector& initialDirection, const Vector& finalDirection )
{
float angle = DotProduct( initialDirection, finalDirection );
assert( IsFinite(angle) );
Vector axis;
// No rotation required
if (angle - 1.0 > -1e-3)
{
// parallel case
MatrixSetIdentity(dst);
return;
}
else if (angle + 1.0 < 1e-3)
{
// antiparallel case, pick any axis in the plane
// perpendicular to the final direction. Choose the direction (x,y,z)
// which has the minimum component of the final direction, use that
// as an initial guess, then subtract out the component which is
// parallel to the final direction
int idx = 0;
if (FloatMakePositive(finalDirection[1]) < FloatMakePositive(finalDirection[idx]))
idx = 1;
if (FloatMakePositive(finalDirection[2]) < FloatMakePositive(finalDirection[idx]))
idx = 2;
axis.Init( 0, 0, 0 );
axis[idx] = 1.0f;
VectorMA( axis, -DotProduct( axis, finalDirection ), finalDirection, axis );
VectorNormalize(axis);
angle = 180.0f;
}
else
{
CrossProduct( initialDirection, finalDirection, axis );
VectorNormalize( axis );
angle = acos(angle) * 180 / M_PI;
}
MatrixBuildRotationAboutAxis( dst, axis, angle );
#ifdef _DEBUG
Vector test;
Vector3DMultiply( dst, initialDirection, test );
test -= finalDirection;
assert( test.LengthSqr() < 1e-3 );
#endif
}
//-----------------------------------------------------------------------------
// Computes the position of the canister
//-----------------------------------------------------------------------------
void CEnvHeadcrabCanisterShared::GetPositionAtTime( float flTime, Vector &vecPosition, QAngle &vecAngles )
{
float flDeltaTime = flTime - m_flLaunchTime;
if ( flDeltaTime > m_flFlightTime )
{
flDeltaTime = m_flFlightTime;
}
VMatrix initToWorld;
if ( m_bLaunchedFromWithinWorld || m_bInSkybox )
{
VectorMA( m_vecStartPosition, flDeltaTime * m_flHorizSpeed, m_vecParabolaDirection, vecPosition );
vecPosition.z += m_flInitialZSpeed * flDeltaTime + 0.5f * m_flZAcceleration * flDeltaTime * flDeltaTime;
Vector vecLeft;
CrossProduct( m_vecParabolaDirection, Vector( 0, 0, 1 ), vecLeft );
Vector vecForward;
VectorMultiply( m_vecParabolaDirection, -1.0f, vecForward );
vecForward.z = -(m_flInitialZSpeed + m_flZAcceleration * flDeltaTime) / m_flHorizSpeed; // This is -dz/dx.
VectorNormalize( vecForward );
Vector vecUp;
CrossProduct( vecForward, vecLeft, vecUp );
initToWorld.SetBasisVectors( vecForward, vecLeft, vecUp );
}
else
{
flDeltaTime -= m_flWorldEnterTime;
Vector vecVelocity;
VectorMultiply( m_vecDirection, m_flFlightSpeed, vecVelocity );
VectorMA( m_vecEnterWorldPosition, flDeltaTime, vecVelocity, vecPosition );
MatrixFromAngles( m_vecStartAngles.Get(), initToWorld );
}
VMatrix rotation;
MatrixBuildRotationAboutAxis( rotation, Vector( 1, 0, 0 ), flDeltaTime * ROTATION_SPEED );
VMatrix newAngles;
MatrixMultiply( initToWorld, rotation, newAngles );
MatrixToAngles( newAngles, vecAngles );
}
void CBaseHelicopter::DoWashPushOnAirboat( CBaseEntity *pAirboat,
const Vector &vecWashToAirboat, float flWashAmount )
{
// For the airboat, simply produce a small roll and a push outwards.
// But don't produce a roll if we're too rolled in that direction already.
// Get the actual up direction vector
Vector vecUp;
pAirboat->GetVectors( NULL, NULL, &vecUp );
if ( vecUp.z < MAX_AIRBOAT_ROLL_COSANGLE )
return;
// Compute roll direction so that we get pushed down on the side where the rotor wash is.
Vector vecRollNormal;
CrossProduct( vecWashToAirboat, Vector( 0, 0, 1 ), vecRollNormal );
// Project it into the plane of the roll normal
VectorMA( vecUp, -DotProduct( vecUp, vecRollNormal ), vecRollNormal, vecUp );
VectorNormalize( vecUp );
// Compute a vector which is the max direction we can roll given the roll constraint
Vector vecExtremeUp;
VMatrix rot;
MatrixBuildRotationAboutAxis( rot, vecRollNormal, MAX_AIRBOAT_ROLL_ANGLE );
MatrixGetColumn( rot, 2, &vecExtremeUp );
// Find the angle between how vertical we are and how vertical we should be
float flCosDelta = DotProduct( vecExtremeUp, vecUp );
float flDelta = acos(flCosDelta) * 180.0f / M_PI;
flDelta = clamp( flDelta, 0.0f, MAX_AIRBOAT_ROLL_ANGLE );
flDelta = SimpleSplineRemapVal( flDelta, 0.0f, MAX_AIRBOAT_ROLL_ANGLE, 0.0f, 1.0f );
float flForce = 12.0f * flWashAmount * flDelta;
Vector vecWashOrigin;
Vector vecForce;
VectorMultiply( Vector( 0, 0, -1 ), flForce, vecForce );
VectorMA( pAirboat->GetAbsOrigin(), -200.0f, vecWashToAirboat, vecWashOrigin );
pAirboat->VPhysicsTakeDamage( CTakeDamageInfo( this, this, vecForce, vecWashOrigin, flWashAmount, DMG_BLAST ) );
}
void CMatrixRotateProxy::OnBind( void *pC_BaseEntity )
{
VMatrix mat;
Vector axis( 0, 0, 1 );
if (m_pAxisVar)
{
m_pAxisVar->GetVecValue( axis.Base(), 3 );
if (VectorNormalize( axis ) < 1e-3)
{
axis.Init( 0, 0, 1 );
}
}
MatrixBuildRotationAboutAxis( mat, axis, m_Angle.GetFloat() );
m_pResult->SetMatrixValue( mat );
if ( ToolsEnabled() )
{
ToolFramework_RecordMaterialParams( GetMaterial() );
}
}
//-----------------------------------------------------------------------------
// Read in worldcraft data...
//-----------------------------------------------------------------------------
bool CVGuiScreen::KeyValue( const char *szKeyName, const char *szValue )
{
//!! temp hack, until worldcraft is fixed
// strip the # tokens from (duplicate) key names
char *s = (char *)strchr( szKeyName, '#' );
if ( s )
{
*s = '\0';
}
if ( FStrEq( szKeyName, "panelname" ))
{
SetPanelName( szValue );
return true;
}
// NOTE: Have to do these separate because they set two values instead of one
if( FStrEq( szKeyName, "angles" ) )
{
Assert( GetMoveParent() == NULL );
QAngle angles;
UTIL_StringToVector( angles.Base(), szValue );
// Because the vgui screen basis is strange (z is front, y is up, x is right)
// we need to rotate the typical basis before applying it
VMatrix mat, rotation, tmp;
MatrixFromAngles( angles, mat );
MatrixBuildRotationAboutAxis( rotation, Vector( 0, 1, 0 ), 90 );
MatrixMultiply( mat, rotation, tmp );
MatrixBuildRotateZ( rotation, 90 );
MatrixMultiply( tmp, rotation, mat );
MatrixToAngles( mat, angles );
SetAbsAngles( angles );
return true;
}
return BaseClass::KeyValue( szKeyName, szValue );
}
void CWeaponIFMSteadyCam::UpdateRelativeOrientation()
{
if ( m_bIsLocked )
return;
if ( m_bInDirectMode )
{
UpdateDirectRelativeOrientation();
return;
}
if ( ( m_vecViewOffset.x == 0.0f ) && ( m_vecViewOffset.y == 0.0f ) )
return;
// Compute a player to steadycam matrix
VMatrix steadyCamToPlayer;
MatrixFromAngles( m_angRelativeAngles, steadyCamToPlayer );
MatrixSetColumn( steadyCamToPlayer, 3, m_vecRelativePosition );
Vector vecCurrentForward;
MatrixGetColumn( steadyCamToPlayer, 0, &vecCurrentForward );
// Create a ray in steadycam space
float flMaxD = 1.0f / tan( M_PI * m_flFOV / 360.0f );
// Remap offsets into normalized space
float flViewX = m_vecViewOffset.x / ( 384 / 2 );
float flViewY = m_vecViewOffset.y / ( 288 / 2 );
flViewX *= flMaxD * ifm_steadycam_mousefactor.GetFloat();
flViewY *= flMaxD * ifm_steadycam_mousefactor.GetFloat();
Vector vecSelectionDir( 1.0f, -flViewX, -flViewY );
VectorNormalize( vecSelectionDir );
// Rotate the ray into player coordinates
Vector vecDesiredDirection;
Vector3DMultiply( steadyCamToPlayer, vecSelectionDir, vecDesiredDirection );
float flDot = DotProduct( vecDesiredDirection, vecCurrentForward );
flDot = clamp( flDot, -1.0f, 1.0f );
float flAngle = 180.0f * acos( flDot ) / M_PI;
if ( flAngle < 1e-3 )
{
matrix3x4_t mat;
MatrixFromForwardDirection( vecDesiredDirection, mat );
MatrixAngles( mat, m_angRelativeAngles );
return;
}
Vector vecAxis;
CrossProduct( vecCurrentForward, vecDesiredDirection, vecAxis );
VectorNormalize( vecAxis );
float flRotateRate = ifm_steadycam_rotaterate.GetFloat();
if ( flRotateRate < 1.0f )
{
flRotateRate = 1.0f;
}
float flRateFactor = flAngle / flRotateRate;
flRateFactor *= flRateFactor * flRateFactor;
float flRate = flRateFactor * 30.0f;
float flMaxAngle = gpGlobals->frametime * flRate;
flAngle = clamp( flAngle, 0.0f, flMaxAngle );
Vector vecNewForard;
VMatrix rotation;
MatrixBuildRotationAboutAxis( rotation, vecAxis, flAngle );
Vector3DMultiply( rotation, vecCurrentForward, vecNewForard );
matrix3x4_t mat;
MatrixFromForwardDirection( vecNewForard, mat );
MatrixAngles( mat, m_angRelativeAngles );
Assert( m_angRelativeAngles.IsValid() );
}
static int vmatrix_MatrixBuildRotationAboutAxis (lua_State *L) {
MatrixBuildRotationAboutAxis(luaL_checkvmatrix(L, 1), luaL_checkvector(L, 2), luaL_checknumber(L, 3));
return 0;
}
