1HEADmaster

1 files changed, 287 insertions, 0 deletions

diff --git a/vphysics/physics_object.h b/vphysics/physics_object.h
new file mode 100644
index 0000000..a1c6f5e
--- /dev/null
+++ b/vphysics/physics_object.h
@@ -0,0 +1,287 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef PHYSICS_OBJECT_H
+#define PHYSICS_OBJECT_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "vphysics_interface.h"
+
+class IVP_Real_Object;
+class IVP_Environment;
+class IVP_U_Float_Point;
+class IVP_SurfaceManager;
+class IVP_Controller;
+class CPhysicsEnvironment;
+struct vphysics_save_cphysicsobject_t
+{
+	const CPhysCollide *pCollide;
+	const char *pName;
+	float	sphereRadius;
+
+	bool	isStatic;
+	bool	collisionEnabled;
+	bool	gravityEnabled;
+	bool	dragEnabled;
+	bool	motionEnabled;
+	bool	isAsleep;
+	bool	isTrigger;
+	bool	asleepSinceCreation;		// has this been asleep since creation?
+	bool	hasTouchedDynamic;
+	bool	hasShadowController;
+	short	collideType;
+	unsigned short	gameIndex;
+	int		hingeAxis;
+	int		materialIndex;
+	float	mass;
+	Vector	rotInertia;
+	float	speedDamping;
+	float	rotSpeedDamping;
+	Vector	massCenterOverride;
+
+	unsigned int	callbacks;
+	unsigned int	gameFlags;
+
+	unsigned int	contentsMask;
+
+	float			volume;
+	float			dragCoefficient;
+	float			angDragCoefficient;
+	IPhysicsShadowController	*pShadow;
+	//bool			m_shadowTempGravityDisable;
+
+	Vector			origin;
+	QAngle			angles;
+	Vector			velocity;
+	AngularImpulse	angVelocity;
+
+	DECLARE_SIMPLE_DATADESC();
+};
+
+enum
+{
+	OBJ_AWAKE = 0,			// awake, simulating
+	OBJ_STARTSLEEP = 1,		// going to sleep, but not queried yet
+	OBJ_SLEEP = 2,			// sleeping, no state changes since last query
+};
+
+
+class CPhysicsObject : public IPhysicsObject
+{
+public:
+	CPhysicsObject( void );
+	virtual ~CPhysicsObject( void );
+
+	void			Init( const CPhysCollide *pCollisionModel, IVP_Real_Object *pObject, int materialIndex, float volume, float drag, float angDrag );
+
+	// IPhysicsObject functions
+	bool			IsStatic() const;
+	bool			IsAsleep() const;
+	bool			IsTrigger() const;
+	bool			IsFluid() const;
+	bool			IsHinged() const { return (m_hingedAxis != 0) ? true : false; }
+	bool			IsCollisionEnabled() const;
+	bool			IsGravityEnabled() const;
+	bool			IsDragEnabled() const;
+	bool			IsMotionEnabled() const;
+	bool			IsMoveable() const;
+	bool			IsAttachedToConstraint( bool bExternalOnly ) const;
+
+
+	void			EnableCollisions( bool enable );
+	// Enable / disable gravity for this object
+	void			EnableGravity( bool enable );
+	// Enable / disable air friction / drag for this object
+	void			EnableDrag( bool enable );
+	void			EnableMotion( bool enable );
+
+	void			SetGameData( void *pAppData );
+	void			*GetGameData( void ) const;
+	void			SetCallbackFlags( unsigned short callbackflags );
+	unsigned short	GetCallbackFlags( void ) const;
+	void			SetGameFlags( unsigned short userFlags );
+	unsigned short	GetGameFlags( void ) const;
+	void			SetGameIndex( unsigned short gameIndex );
+	unsigned short	GetGameIndex( void ) const;
+
+	void			Wake();
+	void			Sleep();
+	void			RecheckCollisionFilter();
+	void			RecheckContactPoints();
+
+	void			SetMass( float mass );
+	float			GetMass( void ) const;
+	float			GetInvMass( void ) const;
+	void			SetInertia( const Vector &inertia );
+	Vector			GetInertia( void ) const;
+	Vector			GetInvInertia( void ) const;
+
+	void			GetDamping( float *speed, float *rot ) const;
+	void			SetDamping( const float *speed, const float *rot );
+	void			SetDragCoefficient( float *pDrag, float *pAngularDrag );
+	void			SetBuoyancyRatio( float ratio );
+	int				GetMaterialIndex() const { return GetMaterialIndexInternal(); }
+	void			SetMaterialIndex( int materialIndex );
+	inline int		GetMaterialIndexInternal( void ) const { return m_materialIndex; }
+
+	unsigned int	GetContents() const { return m_contentsMask; }
+	void			SetContents( unsigned int contents );
+
+	float			GetSphereRadius() const;
+	Vector			GetMassCenterLocalSpace() const;
+	float			GetEnergy() const;
+
+	void			SetPosition( const Vector &worldPosition, const QAngle &angles, bool isTeleport = false );
+	void			SetPositionMatrix( const matrix3x4_t& matrix, bool isTeleport = false  );
+	void			GetPosition( Vector *worldPosition, QAngle *angles ) const;
+	void			GetPositionMatrix( matrix3x4_t *positionMatrix ) const;
+
+	void			SetVelocity( const Vector *velocity, const AngularImpulse *angularVelocity );
+	void			SetVelocityInstantaneous( const Vector *velocity, const AngularImpulse *angularVelocity );
+	void			AddVelocity( const Vector *velocity, const AngularImpulse *angularVelocity );
+	void			GetVelocity( Vector *velocity, AngularImpulse *angularVelocity ) const;
+	void			GetImplicitVelocity( Vector *velocity, AngularImpulse *angularVelocity ) const;
+	void			GetVelocityAtPoint( const Vector &worldPosition, Vector *pVelocity ) const;
+
+	void			LocalToWorld( Vector *worldPosition, const Vector &localPosition ) const;
+	void			WorldToLocal( Vector *localPosition, const Vector &worldPosition ) const;
+	void			LocalToWorldVector( Vector *worldVector, const Vector &localVector ) const;
+	void			WorldToLocalVector( Vector *localVector, const Vector &worldVector ) const;
+
+	void			ApplyForceCenter( const Vector &forceVector );
+	void			ApplyForceOffset( const Vector &forceVector, const Vector &worldPosition );
+	void			ApplyTorqueCenter( const AngularImpulse & );
+	void			CalculateForceOffset( const Vector &forceVector, const Vector &worldPosition, Vector *centerForce, AngularImpulse *centerTorque ) const;
+	void			CalculateVelocityOffset( const Vector &forceVector, const Vector &worldPosition, Vector *centerVelocity, AngularImpulse *centerAngularVelocity ) const;
+	float			CalculateLinearDrag( const Vector &unitDirection ) const;
+	float			CalculateAngularDrag( const Vector &objectSpaceRotationAxis ) const;
+
+	bool			GetContactPoint( Vector *contactPoint, IPhysicsObject **contactObject ) const;
+	void			SetShadow( float maxSpeed, float maxAngularSpeed, bool allowPhysicsMovement, bool allowPhysicsRotation );
+	void			UpdateShadow( const Vector &targetPosition, const QAngle &targetAngles, bool tempDisableGravity, float timeOffset );
+	void			RemoveShadowController();
+	int				GetShadowPosition( Vector *position, QAngle *angles ) const;
+	IPhysicsShadowController *GetShadowController( void ) const;
+	float			ComputeShadowControl( const hlshadowcontrol_params_t &params, float secondsToArrival, float dt );
+
+	const CPhysCollide	*GetCollide( void ) const;
+	char const		*GetName() const;
+
+	float			GetDragInDirection( const IVP_U_Float_Point &dir ) const;
+	float			GetAngularDragInDirection( const IVP_U_Float_Point &angVelocity ) const;
+	void			BecomeTrigger();
+	void			RemoveTrigger();
+	void			BecomeHinged( int localAxis );
+	void			RemoveHinged();
+
+	IPhysicsFrictionSnapshot *CreateFrictionSnapshot();
+	void			DestroyFrictionSnapshot( IPhysicsFrictionSnapshot *pSnapshot );
+
+	void			OutputDebugInfo() const;
+
+	// local functions
+	inline	IVP_Real_Object *GetObject( void ) const { return m_pObject; }
+	inline int		CallbackFlags( void ) const { return m_callbacks; }
+	inline void		AddCallbackFlags( unsigned short flags ) { m_callbacks |= flags; }
+	inline void		RemoveCallbackFlags( unsigned short flags ) { m_callbacks &= ~flags; }
+	inline bool		HasTouchedDynamic();
+	inline void		SetTouchedDynamic();
+	void			NotifySleep( void );
+	void			NotifyWake( void );
+	int				GetSleepState( void ) const { return m_sleepState; }
+	inline void		ForceSilentDelete() { m_forceSilentDelete = true; }
+
+	inline int		GetActiveIndex( void ) const { return m_activeIndex; }
+	inline void		SetActiveIndex( int index ) { m_activeIndex = index; }
+	inline float	GetBuoyancyRatio( void ) const { return m_buoyancyRatio; }
+	// returns true if the mass center is set to the default for the collision model
+	bool			IsMassCenterAtDefault() const;
+
+	// is this object simulated, or controlled by game logic?
+	bool			IsControlledByGame() const;
+
+	IVP_SurfaceManager *GetSurfaceManager( void ) const;
+
+	void			WriteToTemplate( vphysics_save_cphysicsobject_t &objectTemplate );
+	void			InitFromTemplate( CPhysicsEnvironment *pEnvironment, void *pGameData, const vphysics_save_cphysicsobject_t &objectTemplate );
+
+	CPhysicsEnvironment	*GetVPhysicsEnvironment();
+	const CPhysicsEnvironment	*GetVPhysicsEnvironment() const;
+
+private:
+	// NOTE: Local to vphysics, used to save/restore shadow controller
+	void			RestoreShadowController( IPhysicsShadowController *pShadowController );
+	friend bool		RestorePhysicsObject( const physrestoreparams_t &params, CPhysicsObject **ppObject );
+
+	bool			IsControlling( const IVP_Controller *pController ) const;
+	float			GetVolume() const;
+	void			SetVolume( float volume );
+	
+	// the mass has changed, recompute the drag information
+	void			RecomputeDragBases();
+
+	void			ClampVelocity();
+
+	// NOTE: If m_pGameData is not the first member, the constructor debug code must be modified
+	void			*m_pGameData;
+	IVP_Real_Object	*m_pObject;
+	const CPhysCollide *m_pCollide;
+	IPhysicsShadowController	*m_pShadow;
+
+	Vector			m_dragBasis;
+	Vector			m_angDragBasis;
+
+	// these 5 should pack into a short
+	// pack new bools here
+	bool			m_shadowTempGravityDisable : 5;
+	bool			m_hasTouchedDynamic : 1;
+	bool			m_asleepSinceCreation : 1;
+	bool			m_forceSilentDelete : 1;
+	unsigned char	m_sleepState : 2;
+	unsigned char	m_hingedAxis : 3;
+	unsigned char	m_collideType : 3;
+	unsigned short	m_gameIndex;
+
+private:
+	unsigned short	m_materialIndex;
+	unsigned short	m_activeIndex;
+
+	unsigned short	m_callbacks;
+	unsigned short	m_gameFlags;
+	unsigned int	m_contentsMask;
+	
+	float			m_volume;
+	float			m_buoyancyRatio;
+	float			m_dragCoefficient;
+	float			m_angDragCoefficient;
+
+	friend CPhysicsObject *CreatePhysicsObject( CPhysicsEnvironment *pEnvironment, const CPhysCollide *pCollisionModel, int materialIndex, const Vector &position, const QAngle& angles, objectparams_t *pParams, bool isStatic );
+	friend bool CPhysicsEnvironment::TransferObject( IPhysicsObject *pObject, IPhysicsEnvironment *pDestinationEnvironment ); //need direct access to m_pShadow for Portal mod's physics object transfer system
+};
+
+// If you haven't ever touched a dynamic object, there's no need to search for contacting objects to 
+// wakeup when you are deleted.  So cache a bit here when contacts are generated
+inline bool CPhysicsObject::HasTouchedDynamic()
+{
+	return m_hasTouchedDynamic;
+}
+
+inline void CPhysicsObject::SetTouchedDynamic()
+{
+	m_hasTouchedDynamic = true;
+}
+
+extern CPhysicsObject *CreatePhysicsObject( CPhysicsEnvironment *pEnvironment, const CPhysCollide *pCollisionModel, int materialIndex, const Vector &position, const QAngle &angles, objectparams_t *pParams, bool isStatic );
+extern CPhysicsObject *CreatePhysicsSphere( CPhysicsEnvironment *pEnvironment, float radius, int materialIndex, const Vector &position, const QAngle &angles, objectparams_t *pParams, bool isStatic );
+extern void PostRestorePhysicsObject();
+extern IPhysicsObject *CreateObjectFromBuffer( CPhysicsEnvironment *pEnvironment, void *pGameData, unsigned char *pBuffer, unsigned int bufferSize, bool enableCollisions );
+extern IPhysicsObject *CreateObjectFromBuffer_UseExistingMemory( CPhysicsEnvironment *pEnvironment, void *pGameData, unsigned char *pBuffer, unsigned int bufferSize, CPhysicsObject *pExistingMemory );
+
+#endif // PHYSICS_OBJECT_H