{

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

{

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;

{

return (( m_usSolidFlags & FSOLID_FORCE_WORLD_ALIGNED ) == 0 ) &&

( m_nSolidType != SOLID_BBOX ) && ( m_nSolidType != SOLID_NONE );

{

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;

}