initial

game/server/portal/physicsshadowclone.h

@@ -0,0 +1,148 @@
+//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Clones a physics object by use of shadows
+//
+// $NoKeywords: $
+//=============================================================================//
+
+#ifndef PHYSICSSHADOWCLONE_H
+#define PHYSICSSHADOWCLONE_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "vphysics_interface.h"
+#include "BaseEntity.h"
+#include "baseanimating.h"
+
+class CPhysicsShadowClone;
+
+struct PhysicsObjectCloneLink_t
+{
+	IPhysicsObject *pSource;
+	IPhysicsShadowController *pShadowController;
+	IPhysicsObject *pClone;
+};
+
+struct CPhysicsShadowCloneLL
+{
+	CPhysicsShadowClone *pClone;
+	CPhysicsShadowCloneLL *pNext;
+};
+
+#define FVPHYSICS_IS_SHADOWCLONE 0x4000
+
+class CPhysicsShadowClone : public CBaseAnimating
+{
+	DECLARE_CLASS( CPhysicsShadowClone, CBaseAnimating );
+
+private:
+	EHANDLE			m_hClonedEntity; //the entity we're supposed to be cloning the physics of
+	VMatrix			m_matrixShadowTransform; //all cloned coordinates and angles will be run through this matrix before being applied
+	VMatrix			m_matrixShadowTransform_Inverse;
+	
+	CUtlVector<PhysicsObjectCloneLink_t> m_CloneLinks; //keeps track of which of our physics objects are linked to the source's objects
+	bool			m_bShadowTransformIsIdentity; //the shadow transform doesn't update often, so we can cache this
+	bool			m_bImmovable; //cloning a track train or door, something that doesn't really work on a force-based level
+	bool			m_bInAssumedSyncState;
+
+	void			FullSyncClonedPhysicsObjects( bool bTeleport );
+	void			SyncEntity( bool bPullChanges );
+
+	IPhysicsEnvironment *m_pOwnerPhysEnvironment; //clones exist because of multi-environment situations
+
+
+public:
+	CPhysicsShadowClone( void );
+	virtual ~CPhysicsShadowClone( void );
+	
+	bool			m_bShouldUpSync;
+	DBG_CODE_NOSCOPE( const char *m_szDebugMarker; );
+
+	//do the thing with the stuff, you know, the one that goes WooooWooooWooooWooooWoooo
+	virtual void	Spawn( void );
+
+	//crush, kill, DESTROY!!!!!
+	void			Free( void );
+
+	//syncs to the source entity in every way possible, assumed sync does some rudimentary tests to see if the object is in sync, and if so, skips the update
+	void			FullSync( bool bAllowAssumedSync = false );
+
+	//syncs just the physics objects, bPullChanges should be true when this clone should match it's source, false when it should force differences onto the source entity
+	void			PartialSync( bool bPullChanges );
+
+	//virtual bool CreateVPhysics( void );
+	virtual void	VPhysicsDestroyObject( void );
+	virtual int		VPhysicsGetObjectList( IPhysicsObject **pList, int listMax );
+	virtual int		ObjectCaps( void );
+	virtual void	UpdateOnRemove( void );
+
+
+
+	//routing to the source entity for cloning goodness
+	virtual	bool	ShouldCollide( int collisionGroup, int contentsMask ) const;
+
+	//avoid blocking traces that are supposed to hit our source entity
+	virtual bool	TestCollision( const Ray_t &ray, unsigned int fContentsMask, trace_t& tr );
+
+
+
+
+	//is this clone occupying the exact same space as the object it's cloning?
+	inline bool		IsUntransformedClone( void ) const { return m_bShadowTransformIsIdentity; };
+	void			SetCloneTransformationMatrix( const matrix3x4_t &matTransform );
+
+	inline bool		IsInAssumedSyncState( void ) const { return m_bInAssumedSyncState; }
+	inline IPhysicsEnvironment *GetOwnerEnvironment( void ) const { return m_pOwnerPhysEnvironment; }
+
+	//what entity are we cloning?
+	void			SetClonedEntity( EHANDLE hEntToClone );
+	EHANDLE			GetClonedEntity( void );
+
+
+	virtual void	VPhysicsCollision( int index, gamevcollisionevent_t *pEvent );
+
+	//damage relays to source entity if anything ever hits the clone
+	virtual bool	PassesDamageFilter( const CTakeDamageInfo &info );
+	virtual bool	CanBeHitByMeleeAttack( CBaseEntity *pAttacker );
+	virtual int		OnTakeDamage( const CTakeDamageInfo &info );
+	virtual int		TakeHealth( float flHealth, int bitsDamageType );
+	virtual void	Event_Killed( const CTakeDamageInfo &info );
+
+
+	static CPhysicsShadowClone *CreateShadowClone( IPhysicsEnvironment *pInPhysicsEnvironment, EHANDLE hEntToClone, const char *szDebugMarker, const matrix3x4_t *pTransformationMatrix = NULL );
+
+	//given a physics object that is part of this clone, tells you which physics object in the source
+	IPhysicsObject *TranslatePhysicsToClonedEnt( const IPhysicsObject *pPhysics );
+
+	static bool IsShadowClone( const CBaseEntity *pEntity );
+	static CPhysicsShadowCloneLL *GetClonesOfEntity( const CBaseEntity *pEntity );
+	static void FullSyncAllClones( void );
+
+	static CUtlVector<CPhysicsShadowClone *> const &g_ShadowCloneList;
+
+	friend void DrawDebugOverlayForShadowClone( CPhysicsShadowClone *pClone );
+
+	//only really necessary to call for entities that create custom collideables.
+	static void NotifyDestroy( IPhysicsObject *pDestroyingPhys, CBaseEntity *pOwningEntity = NULL ); //passing in the original owner entity just makes the search faster
+	static void NotifyDestroy( CPhysCollide *pDestroyingCollide, CBaseEntity *pOwningEntity = NULL ); //passing in the original owner entity just makes the search faster
+
+private:
+	void DestroyClonedPhys( IPhysicsObject *pPhys );
+	void DestroyClonedCollideable( CPhysCollide *pCollide );
+};
+
+
+
+class CTraceFilterTranslateClones : public CTraceFilter //give it another filter, and it'll translate shadow clones into their source entity for tests
+{
+	ITraceFilter *m_pActualFilter; //the filter that tests should be forwarded to after translating clones
+
+public:
+	CTraceFilterTranslateClones( ITraceFilter *pOtherFilter ) : m_pActualFilter(pOtherFilter) {};
+	virtual bool ShouldHitEntity( IHandleEntity *pEntity, int contentsMask );
+	virtual TraceType_t	GetTraceType() const;
+};
+
+#endif //#ifndef PHYSICSSHADOWCLONE_H