//-----------------------------------------------------------------------------
// Sets the solid flags
//-----------------------------------------------------------------------------
void CCollisionProperty::SetSolidFlags( int flags )
{
int oldFlags = m_usSolidFlags;
m_usSolidFlags = (unsigned short)(flags & 0xFFFF);
if ( oldFlags == m_usSolidFlags )
return;
// These two flags, if changed, can produce different surrounding bounds
if ( (oldFlags & (FSOLID_FORCE_WORLD_ALIGNED | FSOLID_USE_TRIGGER_BOUNDS)) !=
(m_usSolidFlags & (FSOLID_FORCE_WORLD_ALIGNED | FSOLID_USE_TRIGGER_BOUNDS)) )
{
MarkSurroundingBoundsDirty();
}
if ( (oldFlags & (FSOLID_NOT_SOLID|FSOLID_TRIGGER)) != (m_usSolidFlags & (FSOLID_NOT_SOLID|FSOLID_TRIGGER)) )
{
m_pOuter->CollisionRulesChanged();
}
#ifndef CLIENT_DLL
if ( (oldFlags & (FSOLID_NOT_SOLID | FSOLID_TRIGGER)) != (m_usSolidFlags & (FSOLID_NOT_SOLID | FSOLID_TRIGGER)) )
{
UpdateServerPartitionMask( );
CheckForUntouch();
}
#endif
}
//-----------------------------------------------------------------------------
// Sets the solid type
//-----------------------------------------------------------------------------
void CCollisionProperty::SetSolid( SolidType_t val )
{
if ( m_nSolidType == val )
return;
#ifndef CLIENT_DLL
bool bWasNotSolid = IsSolid();
#endif
MarkSurroundingBoundsDirty();
// OBB is not yet implemented
if ( val == SOLID_BSP )
{
if ( GetOuter()->GetMoveParent() )
{
if ( GetOuter()->GetRootMoveParent()->GetSolid() != SOLID_BSP )
{
// must be SOLID_VPHYSICS because parent might rotate
val = SOLID_VPHYSICS;
}
}
#ifndef CLIENT_DLL
// UNDONE: This should be fine in the client DLL too. Move GetAllChildren() into shared code.
// If the root of the hierarchy is SOLID_BSP, then assume that the designer
// wants the collisions to rotate with this hierarchy so that the player can
// move while riding the hierarchy.
if ( !GetOuter()->GetMoveParent() )
{
// NOTE: This assumes things don't change back from SOLID_BSP
// NOTE: This is 100% true for HL2 - need to support removing the flag to support changing from SOLID_BSP
CUtlVector<CBaseEntity *> list;
GetAllChildren( GetOuter(), list );
for ( int i = list.Count()-1; i>=0; --i )
{
list[i]->AddSolidFlags( FSOLID_ROOT_PARENT_ALIGNED );
}
}
#endif
}
m_nSolidType = val;
#ifndef CLIENT_DLL
m_pOuter->CollisionRulesChanged();
UpdateServerPartitionMask( );
if ( bWasNotSolid != IsSolid() )
{
CheckForUntouch();
}
#endif
}
//-----------------------------------------------------------------------------
// Sets the collision bounds + the size
//-----------------------------------------------------------------------------
void CCollisionProperty::SetCollisionBounds( const Vector &mins, const Vector &maxs )
{
if ( ( m_vecMinsPreScaled != mins ) || ( m_vecMaxsPreScaled != maxs ) )
{
m_vecMinsPreScaled = mins;
m_vecMaxsPreScaled = maxs;
}
bool bDirty = false;
// Check if it's a scaled model
CBaseAnimating *pAnim = GetOuter()->GetBaseAnimating();
if ( pAnim && pAnim->GetModelScale() != 1.0f )
{
// Do the scaling
Vector vecNewMins = mins * pAnim->GetModelScale();
Vector vecNewMaxs = maxs * pAnim->GetModelScale();
if ( ( m_vecMins != vecNewMins ) || ( m_vecMaxs != vecNewMaxs ) )
{
m_vecMins = vecNewMins;
m_vecMaxs = vecNewMaxs;
bDirty = true;
}
}
else
{
// No scaling needed!
if ( ( m_vecMins != mins ) || ( m_vecMaxs != maxs ) )
{
m_vecMins = mins;
m_vecMaxs = maxs;
bDirty = true;
}
}
if ( bDirty )
{
//ASSERT_COORD( m_vecMins.Get() );
//ASSERT_COORD( m_vecMaxs.Get() );
Vector vecSize;
VectorSubtract( m_vecMaxs, m_vecMins, vecSize );
m_flRadius = vecSize.Length() * 0.5f;
MarkSurroundingBoundsDirty();
}
}
//-----------------------------------------------------------------------------
// Sets the collision bounds + the size
//-----------------------------------------------------------------------------
void CCollisionProperty::SetCollisionBounds( const Vector& mins, const Vector &maxs )
{
if ( (m_vecMins == mins) && (m_vecMaxs == maxs) )
return;
m_vecMins = mins;
m_vecMaxs = maxs;
//ASSERT_COORD( mins );
//ASSERT_COORD( maxs );
Vector vecSize;
VectorSubtract( maxs, mins, vecSize );
m_flRadius = vecSize.Length() * 0.5f;
MarkSurroundingBoundsDirty();
}
//-----------------------------------------------------------------------------
// Sets the method by which the surrounding collision bounds is set
//-----------------------------------------------------------------------------
void CCollisionProperty::SetSurroundingBoundsType( SurroundingBoundsType_t type, const Vector *pMins, const Vector *pMaxs )
{
m_nSurroundType = type;
if (type != USE_SPECIFIED_BOUNDS)
{
Assert( !pMins && !pMaxs );
MarkSurroundingBoundsDirty();
}
else
{
Assert( pMins && pMaxs );
m_vecSpecifiedSurroundingMinsPreScaled = *pMins;
m_vecSpecifiedSurroundingMaxsPreScaled = *pMaxs;
// Check if it's a scaled model
CBaseAnimating *pAnim = GetOuter()->GetBaseAnimating();
if ( pAnim && pAnim->GetModelScale() != 1.0f )
{
// Do the scaling
Vector vecNewMins = *pMins * pAnim->GetModelScale();
Vector vecNewMaxs = *pMaxs * pAnim->GetModelScale();
m_vecSpecifiedSurroundingMins = vecNewMins;
m_vecSpecifiedSurroundingMaxs = vecNewMaxs;
m_vecSurroundingMins = vecNewMins;
m_vecSurroundingMaxs = vecNewMaxs;
}
else
{
// No scaling needed!
m_vecSpecifiedSurroundingMins = *pMins;
m_vecSpecifiedSurroundingMaxs = *pMaxs;
m_vecSurroundingMins = *pMins;
m_vecSurroundingMaxs = *pMaxs;
}
ASSERT_COORD( m_vecSurroundingMins );
ASSERT_COORD( m_vecSurroundingMaxs );
}
}
//-----------------------------------------------------------------------------
// Sets the method by which the surrounding collision bounds is set
//-----------------------------------------------------------------------------
void CCollisionProperty::SetSurroundingBoundsType( SurroundingBoundsType_t type, const Vector *pMins, const Vector *pMaxs )
{
m_nSurroundType = type;
if (type != USE_SPECIFIED_BOUNDS)
{
Assert( !pMins && !pMaxs );
MarkSurroundingBoundsDirty();
}
else
{
Assert( pMins && pMaxs );
m_vecSpecifiedSurroundingMins = *pMins;
m_vecSpecifiedSurroundingMaxs = *pMaxs;
m_vecSurroundingMins = *pMins;
m_vecSurroundingMaxs = *pMaxs;
ASSERT_COORD( m_vecSurroundingMins );
ASSERT_COORD( m_vecSurroundingMaxs );
}
}
