Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

503 lines
17 KiB

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================//
#ifndef COLLISIONPROPERTY_H
#define COLLISIONPROPERTY_H
#ifdef _WIN32
#pragma once
#endif
#include "networkvar.h"
#include "engine/ICollideable.h"
#include "mathlib/vector.h"
#include "ispatialpartition.h"
//-----------------------------------------------------------------------------
// Forward declarations
//-----------------------------------------------------------------------------
class CBaseEntity;
class IHandleEntity;
class QAngle;
class Vector;
struct Ray_t;
class IPhysicsObject;
//-----------------------------------------------------------------------------
// Force spatial partition updates (to avoid threading problems caused by lazy update)
//-----------------------------------------------------------------------------
void UpdateDirtySpatialPartitionEntities();
//-----------------------------------------------------------------------------
// Specifies how to compute the surrounding box
//-----------------------------------------------------------------------------
enum SurroundingBoundsType_t
{
USE_OBB_COLLISION_BOUNDS = 0,
USE_BEST_COLLISION_BOUNDS, // Always use the best bounds (most expensive)
USE_HITBOXES,
USE_SPECIFIED_BOUNDS,
USE_GAME_CODE,
USE_ROTATION_EXPANDED_BOUNDS,
USE_COLLISION_BOUNDS_NEVER_VPHYSICS,
SURROUNDING_TYPE_BIT_COUNT = 3
};
//-----------------------------------------------------------------------------
// Encapsulates collision representation for an entity
//-----------------------------------------------------------------------------
class CCollisionProperty : public ICollideable
{
DECLARE_CLASS_NOBASE( CCollisionProperty );
DECLARE_EMBEDDED_NETWORKVAR();
DECLARE_PREDICTABLE();
#ifdef GAME_DLL
DECLARE_DATADESC();
#endif
public:
CCollisionProperty();
~CCollisionProperty();
void Init( CBaseEntity *pEntity );
// Methods of ICollideable
virtual IHandleEntity *GetEntityHandle();
virtual const Vector& OBBMinsPreScaled() const { return m_vecMinsPreScaled.Get(); }
virtual const Vector& OBBMaxsPreScaled() const { return m_vecMaxsPreScaled.Get(); }
virtual const Vector& OBBMins() const { return m_vecMins.Get(); }
virtual const Vector& OBBMaxs() const { return m_vecMaxs.Get(); }
virtual void WorldSpaceTriggerBounds( Vector *pVecWorldMins, Vector *pVecWorldMaxs ) const;
virtual bool TestCollision( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr );
virtual bool TestHitboxes( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr );
virtual int GetCollisionModelIndex();
virtual const model_t* GetCollisionModel();
virtual const Vector& GetCollisionOrigin() const;
virtual const QAngle& GetCollisionAngles() const;
virtual const matrix3x4_t& CollisionToWorldTransform() const;
virtual SolidType_t GetSolid() const;
virtual int GetSolidFlags() const;
virtual IClientUnknown* GetIClientUnknown();
virtual int GetCollisionGroup() const;
virtual void WorldSpaceSurroundingBounds( Vector *pVecMins, Vector *pVecMaxs );
virtual bool ShouldTouchTrigger( int triggerSolidFlags ) const;
virtual const matrix3x4_t *GetRootParentToWorldTransform() const;
public:
// Spatial partition management
void CreatePartitionHandle();
void DestroyPartitionHandle();
unsigned short GetPartitionHandle() const;
// Marks the spatial partition dirty
void MarkPartitionHandleDirty();
// Sets the collision bounds + the size (OBB)
void SetCollisionBounds( const Vector& mins, const Vector &maxs );
// Rebuilds the scaled bounds from the pre-scaled bounds after a model's scale has changed
void RefreshScaledCollisionBounds( void );
// Sets special trigger bounds. The bloat amount indicates how much bigger the
// trigger bounds should be beyond the bounds set in SetCollisionBounds
// This method will also set the FSOLID flag FSOLID_USE_TRIGGER_BOUNDS
void UseTriggerBounds( bool bEnable, float flBloat = 0.0f );
// Sets the method by which the surrounding collision bounds is set
// You must pass in values for mins + maxs if you select the USE_SPECIFIED_BOUNDS type.
void SetSurroundingBoundsType( SurroundingBoundsType_t type, const Vector *pMins = NULL, const Vector *pMaxs = NULL );
// Sets the solid type (which type of collision representation)
void SetSolid( SolidType_t val );
// Methods related to size. The OBB here is measured in CollisionSpace
// (specified by GetCollisionToWorld)
const Vector& OBBSize( ) const;
// Returns a radius (or the square of the radius) of a sphere
// *centered at the world space center* bounding the collision representation
// of the entity. NOTE: The world space center *may* move when the entity rotates.
float BoundingRadius() const;
float BoundingRadius2D() const;
// Returns the center of the OBB in collision space
const Vector & OBBCenter( ) const;
// center point of entity measured in world space
// NOTE: This point *may* move when the entity moves depending on
// which solid type is being used.
const Vector & WorldSpaceCenter( ) const;
// Methods related to solid flags
void ClearSolidFlags( void );
void RemoveSolidFlags( int flags );
void AddSolidFlags( int flags );
bool IsSolidFlagSet( int flagMask ) const;
void SetSolidFlags( int flags );
bool IsSolid() const;
// Updates the spatial partition
void UpdatePartition( );
// Are the bounds defined in entity space?
bool IsBoundsDefinedInEntitySpace() const;
// Transforms a point in OBB space to world space
const Vector & CollisionToWorldSpace( const Vector &in, Vector *pResult ) const;
// Transforms a point in world space to OBB space
const Vector & WorldToCollisionSpace( const Vector &in, Vector *pResult ) const;
// Transforms a direction in world space to OBB space
const Vector & WorldDirectionToCollisionSpace( const Vector &in, Vector *pResult ) const;
// Selects a random point in the bounds given the normalized 0-1 bounds
void RandomPointInBounds( const Vector &vecNormalizedMins, const Vector &vecNormalizedMaxs, Vector *pPoint) const;
// Is a worldspace point within the bounds of the OBB?
bool IsPointInBounds( const Vector &vecWorldPt ) const;
// Computes a bounding box in world space surrounding the collision bounds
void WorldSpaceAABB( Vector *pWorldMins, Vector *pWorldMaxs ) const;
// Get the collision space mins directly
const Vector & CollisionSpaceMins( void ) const;
// Get the collision space maxs directly
const Vector & CollisionSpaceMaxs( void ) const;
// Computes a "normalized" point (range 0,0,0 - 1,1,1) in collision space
// Useful for things like getting a point 75% of the way along z on the OBB, for example
const Vector & NormalizedToCollisionSpace( const Vector &in, Vector *pResult ) const;
// Computes a "normalized" point (range 0,0,0 - 1,1,1) in world space
const Vector & NormalizedToWorldSpace( const Vector &in, Vector *pResult ) const;
// Transforms a point in world space to normalized space
const Vector & WorldToNormalizedSpace( const Vector &in, Vector *pResult ) const;
// Transforms a point in collision space to normalized space
const Vector & CollisionToNormalizedSpace( const Vector &in, Vector *pResult ) const;
// Computes the nearest point in the OBB to a point specified in world space
void CalcNearestPoint( const Vector &vecWorldPt, Vector *pVecNearestWorldPt ) const;
// Computes the distance from a point in world space to the OBB
float CalcDistanceFromPoint( const Vector &vecWorldPt ) const;
// Does a rotation make us need to recompute the surrounding box?
bool DoesRotationInvalidateSurroundingBox( ) const;
// Does VPhysicsUpdate make us need to recompute the surrounding box?
bool DoesVPhysicsInvalidateSurroundingBox( ) const;
// Marks the entity has having a dirty surrounding box
void MarkSurroundingBoundsDirty();
// Compute the largest dot product of the OBB and the specified direction vector
float ComputeSupportMap( const Vector &vecDirection ) const;
private:
// Transforms an AABB measured in collision space to a box that surrounds it in world space
void CollisionAABBToWorldAABB( const Vector &entityMins, const Vector &entityMaxs, Vector *pWorldMins, Vector *pWorldMaxs ) const;
// Expand trigger bounds..
void ComputeVPhysicsSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs );
// Expand trigger bounds..
bool ComputeHitboxSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs );
bool ComputeEntitySpaceHitboxSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs );
// Computes the surrounding collision bounds based on whatever algorithm we want...
void ComputeCollisionSurroundingBox( bool bUseVPhysics, Vector *pVecWorldMins, Vector *pVecWorldMaxs );
// Computes the surrounding collision bounds from the the OBB (not vphysics)
void ComputeRotationExpandedBounds( Vector *pVecWorldMins, Vector *pVecWorldMaxs );
// Computes the surrounding collision bounds based on whatever algorithm we want...
void ComputeSurroundingBox( Vector *pVecWorldMins, Vector *pVecWorldMaxs );
// Check for untouch
void CheckForUntouch();
// Updates the spatial partition
void UpdateServerPartitionMask( );
// Outer
CBaseEntity *GetOuter();
const CBaseEntity *GetOuter() const;
private:
CBaseEntity *m_pOuter;
CNetworkVector( m_vecMinsPreScaled );
CNetworkVector( m_vecMaxsPreScaled );
CNetworkVector( m_vecMins );
CNetworkVector( m_vecMaxs );
float m_flRadius;
CNetworkVar( unsigned short, m_usSolidFlags );
// Spatial partition
SpatialPartitionHandle_t m_Partition;
CNetworkVar( unsigned char, m_nSurroundType );
// One of the SOLID_ defines. Use GetSolid/SetSolid.
CNetworkVar( unsigned char, m_nSolidType );
CNetworkVar( unsigned char , m_triggerBloat );
// SUCKY: We didn't use to have to store this previously
// but storing it here means that we can network it + avoid a ton of
// client-side mismatch problems
CNetworkVector( m_vecSpecifiedSurroundingMinsPreScaled );
CNetworkVector( m_vecSpecifiedSurroundingMaxsPreScaled );
CNetworkVector( m_vecSpecifiedSurroundingMins );
CNetworkVector( m_vecSpecifiedSurroundingMaxs );
// Cached off world-aligned surrounding bounds
#if 0
short m_surroundingMins[3];
short m_surroundingMaxs[3];
#else
Vector m_vecSurroundingMins;
Vector m_vecSurroundingMaxs;
#endif
// pointer to the entity's physics object (vphysics.dll)
//IPhysicsObject *m_pPhysicsObject;
friend class CBaseEntity;
};
//-----------------------------------------------------------------------------
// For networking this bad boy
//-----------------------------------------------------------------------------
#ifdef CLIENT_DLL
EXTERN_RECV_TABLE( DT_CollisionProperty );
#else
EXTERN_SEND_TABLE( DT_CollisionProperty );
#endif
//-----------------------------------------------------------------------------
// Inline methods
//-----------------------------------------------------------------------------
inline CBaseEntity *CCollisionProperty::GetOuter()
{
return m_pOuter;
}
inline const CBaseEntity *CCollisionProperty::GetOuter() const
{
return m_pOuter;
}
//-----------------------------------------------------------------------------
// Spatial partition
//-----------------------------------------------------------------------------
inline unsigned short CCollisionProperty::GetPartitionHandle() const
{
return m_Partition;
}
//-----------------------------------------------------------------------------
// Methods related to size
//-----------------------------------------------------------------------------
inline const Vector& CCollisionProperty::OBBSize( ) const
{
// NOTE: Could precache this, but it's not used that often..
Vector &temp = AllocTempVector();
VectorSubtract( m_vecMaxs, m_vecMins, temp );
return temp;
}
//-----------------------------------------------------------------------------
// Bounding radius size
//-----------------------------------------------------------------------------
inline float CCollisionProperty::BoundingRadius() const
{
return m_flRadius;
}
//-----------------------------------------------------------------------------
// Methods relating to solid flags
//-----------------------------------------------------------------------------
inline bool CCollisionProperty::IsBoundsDefinedInEntitySpace() const
{
return (( m_usSolidFlags & FSOLID_FORCE_WORLD_ALIGNED ) == 0 ) &&
( m_nSolidType != SOLID_BBOX ) && ( m_nSolidType != SOLID_NONE );
}
inline void CCollisionProperty::ClearSolidFlags( void )
{
SetSolidFlags( 0 );
}
inline void CCollisionProperty::RemoveSolidFlags( int flags )
{
SetSolidFlags( m_usSolidFlags & ~flags );
}
inline void CCollisionProperty::AddSolidFlags( int flags )
{
SetSolidFlags( m_usSolidFlags | flags );
}
inline int CCollisionProperty::GetSolidFlags( void ) const
{
return m_usSolidFlags;
}
inline bool CCollisionProperty::IsSolidFlagSet( int flagMask ) const
{
return (m_usSolidFlags & flagMask) != 0;
}
inline bool CCollisionProperty::IsSolid() const
{
return ::IsSolid( (SolidType_t)(unsigned char)m_nSolidType, m_usSolidFlags );
}
//-----------------------------------------------------------------------------
// Returns the center in OBB space
//-----------------------------------------------------------------------------
inline const Vector& CCollisionProperty::OBBCenter( ) const
{
Vector &vecResult = AllocTempVector();
VectorLerp( m_vecMins, m_vecMaxs, 0.5f, vecResult );
return vecResult;
}
//-----------------------------------------------------------------------------
// center point of entity
//-----------------------------------------------------------------------------
inline const Vector &CCollisionProperty::WorldSpaceCenter( ) const
{
Vector &vecResult = AllocTempVector();
CollisionToWorldSpace( OBBCenter(), &vecResult );
return vecResult;
}
//-----------------------------------------------------------------------------
// Transforms a point in OBB space to world space
//-----------------------------------------------------------------------------
inline const Vector &CCollisionProperty::CollisionToWorldSpace( const Vector &in, Vector *pResult ) const
{
// Makes sure we don't re-use the same temp twice
if ( !IsBoundsDefinedInEntitySpace() || ( GetCollisionAngles() == vec3_angle ) )
{
VectorAdd( in, GetCollisionOrigin(), *pResult );
}
else
{
VectorTransform( in, CollisionToWorldTransform(), *pResult );
}
return *pResult;
}
//-----------------------------------------------------------------------------
// Transforms a point in world space to OBB space
//-----------------------------------------------------------------------------
inline const Vector &CCollisionProperty::WorldToCollisionSpace( const Vector &in, Vector *pResult ) const
{
if ( !IsBoundsDefinedInEntitySpace() || ( GetCollisionAngles() == vec3_angle ) )
{
VectorSubtract( in, GetCollisionOrigin(), *pResult );
}
else
{
VectorITransform( in, CollisionToWorldTransform(), *pResult );
}
return *pResult;
}
//-----------------------------------------------------------------------------
// Transforms a direction in world space to OBB space
//-----------------------------------------------------------------------------
inline const Vector & CCollisionProperty::WorldDirectionToCollisionSpace( const Vector &in, Vector *pResult ) const
{
if ( !IsBoundsDefinedInEntitySpace() || ( GetCollisionAngles() == vec3_angle ) )
{
*pResult = in;
}
else
{
VectorIRotate( in, CollisionToWorldTransform(), *pResult );
}
return *pResult;
}
//-----------------------------------------------------------------------------
// Computes a bounding box in world space surrounding the collision bounds
//-----------------------------------------------------------------------------
inline void CCollisionProperty::WorldSpaceAABB( Vector *pWorldMins, Vector *pWorldMaxs ) const
{
CollisionAABBToWorldAABB( m_vecMins, m_vecMaxs, pWorldMins, pWorldMaxs );
}
// Get the collision space mins directly
inline const Vector & CCollisionProperty::CollisionSpaceMins( void ) const
{
return m_vecMins;
}
// Get the collision space maxs directly
inline const Vector & CCollisionProperty::CollisionSpaceMaxs( void ) const
{
return m_vecMaxs;
}
//-----------------------------------------------------------------------------
// Does a rotation make us need to recompute the surrounding box?
//-----------------------------------------------------------------------------
inline bool CCollisionProperty::DoesRotationInvalidateSurroundingBox( ) const
{
if ( IsSolidFlagSet(FSOLID_ROOT_PARENT_ALIGNED) )
return true;
switch ( m_nSurroundType )
{
case USE_COLLISION_BOUNDS_NEVER_VPHYSICS:
case USE_OBB_COLLISION_BOUNDS:
case USE_BEST_COLLISION_BOUNDS:
return IsBoundsDefinedInEntitySpace();
// In the case of game code, we don't really know, so we have to assume it does
case USE_HITBOXES:
case USE_GAME_CODE:
return true;
case USE_ROTATION_EXPANDED_BOUNDS:
case USE_SPECIFIED_BOUNDS:
return false;
default:
Assert(0);
return true;
}
}
#endif // COLLISIONPROPERTY_H