//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// adnan
// want to add an angles modifier key
bool CGravControllerPoint::UpdateObject( CBasePlayer *pPlayer, CBaseEntity *pEntity )
{
IPhysicsObject *pPhysics = GetPhysObjFromPhysicsBone( pEntity, m_attachedPhysicsBone );
if ( !pEntity || !pPhysics )
{
return false;
}
#ifdef ARGG
// adnan
// if we've been rotating it, set it to its proper new angles (change m_attachedAnglesPlayerSpace while modifier)
//Pickup_GetRotatedCarryAngles( pEntity, pPlayer, pPlayer->EntityToWorldTransform(), angles );
// added the ... && (mousedx | mousedy) so we dont have to calculate if no mouse movement
// UPDATE: m_vecRotatedCarryAngles has become a temp variable... can be cleaned up by using actual temp vars
#ifdef CLIENT_DLL
if( m_bHasRotatedCarryAngles && (pPlayer->m_pCurrentCommand->mousedx || pPlayer->m_pCurrentCommand->mousedy) )
#else
if( m_bHasRotatedCarryAngles && (pPlayer->GetCurrentCommand()->mousedx || pPlayer->GetCurrentCommand()->mousedy) )
#endif
{
// method II: relative orientation
VMatrix vDeltaRotation, vCurrentRotation, vNewRotation;
MatrixFromAngles( m_targetRotation, vCurrentRotation );
#ifdef CLIENT_DLL
m_vecRotatedCarryAngles[YAW] = pPlayer->m_pCurrentCommand->mousedx*0.05;
m_vecRotatedCarryAngles[PITCH] = pPlayer->m_pCurrentCommand->mousedy*-0.05;
#else
m_vecRotatedCarryAngles[YAW] = pPlayer->GetCurrentCommand()->mousedx*0.05;
m_vecRotatedCarryAngles[PITCH] = pPlayer->GetCurrentCommand()->mousedy*-0.05;
#endif
m_vecRotatedCarryAngles[ROLL] = 0;
MatrixFromAngles( m_vecRotatedCarryAngles, vDeltaRotation );
MatrixMultiply(vDeltaRotation, vCurrentRotation, vNewRotation);
MatrixToAngles( vNewRotation, m_targetRotation );
}
// end adnan
#endif
SetTargetPosition( m_targetPosition, m_targetRotation );
return true;
}
//-----------------------------------------------------------------------------
// 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 );
}
//-----------------------------------------------------------------------------
// 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 );
}
//-----------------------------------------------------------------------------
// Compute orientation matrix:
//-----------------------------------------------------------------------------
void CShieldEffect::ComputeOrientationMatrix()
{
// Generate the orientation matrix from theta and phi...
// X = forward direction, Y - left direction
Vector forward, left, up;
forward.x = cos(m_Theta) * sin(m_Phi);
forward.y = sin(m_Theta) * sin(m_Phi);
forward.z = cos(m_Phi);
left.x = -forward.y;
left.y = forward.x;
left.z = 0;
if ( VectorNormalize(left) == 0.0f )
left.Init( 0.0f, 1.0f, 0.0f );
CrossProduct( forward, left, up );
m_Orientation.SetBasisVectors( forward, left, up );
// Turn the current matrix into angles...
MatrixToAngles( m_Orientation, m_CurrentAngles );
}
//-----------------------------------------------------------------------------
// Purpose: Spawn the entities I contain
// Input : &vecOrigin -
// &vecAngles -
// pEntities -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CPointTemplate::CreateInstance( const Vector &vecOrigin, const QAngle &vecAngles, CUtlVector<CBaseEntity*> *pEntities )
{
// Go through all our templated map data and spawn all the entities in it
int iTemplates = m_hTemplates.Count();
if ( !iTemplates )
{
Msg("CreateInstance called on a point_template that has no templates: %s\n", STRING(GetEntityName()) );
return false;
}
// Tell the template system we're about to start a new template
Templates_StartUniqueInstance();
int i;
for ( i = 0; i < iTemplates; i++ )
{
CBaseEntity *pEntity = NULL;
char *pMapData;
int iTemplateIndex = m_hTemplates[i].iTemplateIndex;
// Some templates have Entity I/O connecting the entities within the template.
// Unique versions of these templates need to be created whenever they're instanced.
if ( Templates_IndexRequiresEntityIOFixup( iTemplateIndex ) )
{
// This template requires instancing.
// Create a new mapdata block and ask the template system to fill it in with
// a unique version (with fixed Entity I/O connections).
pMapData = Templates_GetEntityIOFixedMapData( iTemplateIndex );
}
else
{
// Use the unmodified mapdata
pMapData = (char*)STRING( Templates_FindByIndex( iTemplateIndex ) );
}
// Create the entity from the mapdata
MapEntity_ParseEntity( pEntity, pMapData, NULL );
if ( pEntity == NULL )
{
Msg("Failed to initialize templated entity with mapdata: %s\n", pMapData );
return false;
}
// Get a matrix that'll convert from world to the new local space
VMatrix matNewTemplateToWorld, matStoredLocalToWorld;
matNewTemplateToWorld.SetupMatrixOrgAngles( vecOrigin, vecAngles );
MatrixMultiply( matNewTemplateToWorld, m_hTemplates[i].matEntityToTemplate, matStoredLocalToWorld );
// Get the world origin & angles from the stored local coordinates
Vector vecNewOrigin;
QAngle vecNewAngles;
vecNewOrigin = matStoredLocalToWorld.GetTranslation();
MatrixToAngles( matStoredLocalToWorld, vecNewAngles );
// Set its origin & angles
pEntity->SetAbsOrigin( vecNewOrigin );
pEntity->SetAbsAngles( vecNewAngles );
if ( DispatchSpawn( pEntity ) >= 0 )
{
pEntities->AddToTail( pEntity );
}
}
// Now hookup entity heirarchy within the template
int iCount = pEntities->Count();
for ( i = 0; i < iCount; i++ )
{
CBaseEntity *pEntity = (*pEntities)[i];
if ( pEntity && pEntity->m_iParent != NULL_STRING )
{
CBaseEntity *pParent = gEntList.FindEntityByName(NULL, pEntity->m_iParent, NULL);
if ( pParent && (pParent->edict() != NULL) )
{
pEntity->SetParent( pParent );
}
}
}
return true;
}
static void PlaceDetail( DetailModel_t const& model, const Vector& pt, const Vector& normal )
{
// But only place it on the surface if it meets the angle constraints...
float cosAngle = normal.z;
// Never emit if the angle's too steep
if (cosAngle < model.m_MaxCosAngle)
return;
// If it's between min + max, flip a coin...
if (cosAngle < model.m_MinCosAngle)
{
float probability = (cosAngle - model.m_MaxCosAngle) /
(model.m_MinCosAngle - model.m_MaxCosAngle);
float t = rand() / (float)RAND_MAX;
if (t > probability)
return;
}
// Compute the orientation of the detail
QAngle angles;
if (model.m_Flags & MODELFLAG_UPRIGHT)
{
// If it's upright, we just select a random yaw
angles.Init( 0, 360.0f * rand() / (float)RAND_MAX, 0.0f );
}
else
{
// It's not upright, so it must conform to the ground. Choose
// a random orientation based on the surface normal
Vector zaxis;
VectorCopy( normal, zaxis );
// Choose any two arbitrary axes which are perpendicular to the normal
Vector xaxis( 1, 0, 0 );
if (fabs(xaxis.Dot(zaxis)) - 1.0 > -1e-3)
xaxis.Init( 0, 1, 0 );
Vector yaxis;
CrossProduct( zaxis, xaxis, yaxis );
CrossProduct( yaxis, zaxis, xaxis );
VMatrix matrix;
matrix.SetBasisVectors( xaxis, yaxis, zaxis );
float rotAngle = 360.0f * rand() / (float)RAND_MAX;
VMatrix rot = SetupMatrixAxisRot( Vector( 0, 0, 1 ), rotAngle );
matrix = matrix * rot;
MatrixToAngles( matrix, angles );
}
// FIXME: We may also want a purely random rotation too
// Insert an element into the object dictionary if it aint there...
switch ( model.m_Type )
{
case DETAIL_PROP_TYPE_MODEL:
AddDetailToLump( model.m_ModelName.String(), pt, angles, model.m_Orientation );
break;
case DETAIL_PROP_TYPE_SPRITE:
{
float flScale = 1.0f;
if ( model.m_flRandomScaleStdDev != 0.0f )
{
flScale = fabs( RandomGaussianFloat( 1.0f, model.m_flRandomScaleStdDev ) );
}
AddDetailSpriteToLump( pt, angles, model.m_Orientation, model.m_Pos, model.m_Tex, flScale );
}
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Spawn the entities I contain
// Input : &vecOrigin -
// &vecAngles -
// pEntities -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CPointTemplate::CreateInstance( const Vector &vecOrigin, const QAngle &vecAngles, CUtlVector<CBaseEntity*> *pEntities )
{
// Go through all our templated map data and spawn all the entities in it
int iTemplates = m_hTemplates.Count();
if ( !iTemplates )
{
Msg("CreateInstance called on a point_template that has no templates: %s\n", STRING(GetEntityName()) );
return false;
}
// Tell the template system we're about to start a new template
Templates_StartUniqueInstance();
HierarchicalSpawn_t *pSpawnList = (HierarchicalSpawn_t*)stackalloc( iTemplates * sizeof(HierarchicalSpawn_t) );
int i;
for ( i = 0; i < iTemplates; i++ )
{
CBaseEntity *pEntity = NULL;
char *pMapData;
int iTemplateIndex = m_hTemplates[i].iTemplateIndex;
// Some templates have Entity I/O connecting the entities within the template.
// Unique versions of these templates need to be created whenever they're instanced.
if ( AllowNameFixup() && Templates_IndexRequiresEntityIOFixup( iTemplateIndex ) )
{
// This template requires instancing.
// Create a new mapdata block and ask the template system to fill it in with
// a unique version (with fixed Entity I/O connections).
pMapData = Templates_GetEntityIOFixedMapData( iTemplateIndex );
}
else
{
// Use the unmodified mapdata
pMapData = (char*)STRING( Templates_FindByIndex( iTemplateIndex ) );
}
// Create the entity from the mapdata
MapEntity_ParseEntity( pEntity, pMapData, NULL );
if ( pEntity == NULL )
{
Msg("Failed to initialize templated entity with mapdata: %s\n", pMapData );
return false;
}
// Get a matrix that'll convert from world to the new local space
VMatrix matNewTemplateToWorld, matStoredLocalToWorld;
matNewTemplateToWorld.SetupMatrixOrgAngles( vecOrigin, vecAngles );
MatrixMultiply( matNewTemplateToWorld, m_hTemplates[i].matEntityToTemplate, matStoredLocalToWorld );
// Get the world origin & angles from the stored local coordinates
Vector vecNewOrigin;
QAngle vecNewAngles;
vecNewOrigin = matStoredLocalToWorld.GetTranslation();
MatrixToAngles( matStoredLocalToWorld, vecNewAngles );
// Set its origin & angles
pEntity->SetAbsOrigin( vecNewOrigin );
pEntity->SetAbsAngles( vecNewAngles );
pSpawnList[i].m_pEntity = pEntity;
pSpawnList[i].m_nDepth = 0;
}
SpawnHierarchicalList( iTemplates, pSpawnList, true );
for ( i = 0; i < iTemplates; ++i )
{
if ( pSpawnList[i].m_pEntity )
{
pEntities->AddToTail( pSpawnList[i].m_pEntity );
}
}
return true;
}
static int vmatrix_MatrixToAngles (lua_State *L) {
MatrixToAngles(luaL_checkvmatrix(L, 1), luaL_checkangle(L, 2));
return 0;
}
