1

game/server/physconstraint_sounds.h

@@ -0,0 +1,291 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Data types used inside constraints for the purpose of playing sounds
+//			during movement.
+//
+//=============================================================================//
+
+#ifndef PHYSCONSTRAINT_SOUNDS_H
+#define PHYSCONSTRAINT_SOUNDS_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+
+#include <mathlib/ssemath.h>
+#include "soundenvelope.h"
+
+
+/** \brief Class to store a sampled history of velocity for an object -- used for certain sound calculations
+
+Although this contains only one sample for now, it exists as an interface 
+so as to make simpler the possibility of moving to a ring buffer 
+implementation in the future. 
+
+The "sample rate" variable is not nominal: it should be used to specify 
+the ClientThink() interval. 
+
+Be sure to use the beginSampling() function for the first sample, and 
+addSample() thereafter: this will be relevant and necessary for a ring
+buffer implementation (which will have to perform certain initialization).
+*/
+class VelocitySampler
+{	
+public:
+	/*
+	enum
+	{
+	HISTORY_DEPTH_LOG	= 3, // < log-base-2 of the sampler's array depth
+	HISTORY_DEPTH		= (1 << VELOCITY_SAMPLER_HISTORY_DEPTH_LOG),
+	};
+	*/
+
+	/// Return the internally stored sample rate.
+	inline float getSampleRate() 
+	{
+		return m_fIdealSampleRate;
+	}
+
+
+	/// Store off the first recorded sample for the given object.
+	inline void BeginSampling(const Vector &relativeVelocity);
+
+	/// Record a sample. Do this LAST, after calling hasReversed() et al.
+	inline void AddSample(const Vector &relativeVelocity);
+
+	/// Using the sample history, determine if the object has reversed direction
+	/// with at least the given acceleration (in units/sec^2).
+	int HasReversed(const Vector &relativeVelocity, const float thresholdAcceleration[], const unsigned short numThresholds);
+
+	/// Call this in spawn(). (Not a constructor because those are difficult to use in entities.)
+	void Initialize(float samplerate);
+
+
+	/// A convenience function for extracting the linear velocity of one object relative to another.
+	inline static Vector GetRelativeVelocity(IPhysicsObject *pObj,	IPhysicsObject *pReferenceFrame);
+
+	/// A convenience function for extracting the angular velocity of one object relative to another.
+	inline static Vector GetRelativeAngularVelocity(IPhysicsObject *pObj,	IPhysicsObject *pReferenceFrame);
+
+
+protected:
+	Vector m_prevSample;
+	float m_fPrevSampleTime;
+
+	float m_fIdealSampleRate;
+
+};
+
+struct SimpleConstraintSoundProfile
+{
+	// define the indices of the sound points:
+	enum
+	{
+		kMIN_THRESHOLD, ///< below this no sound is played
+		kMIN_FULL,      ///< at this velocity sound is at its loudest
+
+		kHIGHWATER,	///< high water mark for this enum
+	} eKeypoints;
+
+	float m_keyPoints[kHIGHWATER];
+
+	/// Number of entries in the reversal sound array 
+	enum { kREVERSAL_SOUND_ARRAY_SIZE = 3 };
+
+	/// Acceleration threshold for playing the hard-reverse sound. Divided into sections.
+	/// Below the 0th threshold no sound will play.
+	float m_reversalSoundThresholds[kREVERSAL_SOUND_ARRAY_SIZE]; 
+
+	/// Get volume for given velocity [0..1]
+	float GetVolume(float inVel);
+};
+
+float SimpleConstraintSoundProfile::GetVolume(float inVel)
+{
+	// clamped lerp on 0-1
+	if (inVel <= m_keyPoints[kMIN_THRESHOLD])
+	{
+		return 0;
+	}
+	else if (inVel >= m_keyPoints[kMIN_FULL])
+	{
+		return 1;
+	}
+	else	// lerp...
+	{
+		return (inVel - m_keyPoints[kMIN_THRESHOLD])/(m_keyPoints[kMIN_FULL] - m_keyPoints[kMIN_THRESHOLD]);
+	}
+}
+
+class CPhysConstraint;
+/** This class encapsulates the data and behavior necessary for a constraint to play sounds.
+
+	For the moment I have no easy means of populating this from an entity's datadesc.
+	You should explicitly fill out the fields with eg
+
+	DEFINE_KEYFIELD( m_soundInfo.m_soundProfile.m_keyPoints[SimpleConstraintSoundProfile::kMIN_THRESHOLD] , FIELD_FLOAT, "minSoundThreshold" ),
+	DEFINE_KEYFIELD( m_soundInfo.m_soundProfile.m_keyPoints[SimpleConstraintSoundProfile::kMIN_FULL] , FIELD_FLOAT, "maxSoundThreshold" ),
+	DEFINE_KEYFIELD( m_soundInfo.m_iszTravelSoundFwd, FIELD_SOUNDNAME, "slidesoundfwd" ),
+	DEFINE_KEYFIELD( m_soundInfo.m_iszTravelSoundBack, FIELD_SOUNDNAME, "slidesoundback" ),
+	DEFINE_KEYFIELD( m_soundInfo.m_iszReversalSound, FIELD_SOUNDNAME, "reversalsound" ),
+	DEFINE_KEYFIELD( m_soundInfo.m_soundProfile.m_reversalSoundThreshold , FIELD_FLOAT, "reversalsoundthreshold" ),
+
+ */
+class ConstraintSoundInfo
+{
+public:
+	// no ctor.
+	// dtor
+	~ConstraintSoundInfo();
+
+	/// Call from the constraint's Activate()
+	void OnActivate( CPhysConstraint *pOuter );
+
+	/// Constraint should have a think function that calls this. It should pass in relative velocity
+	/// between child and parent. (This need not be linear velocity; it may be angular.)
+	void OnThink( CPhysConstraint *pOuter, const Vector &relativeVelocity );
+
+	/// This is how often the think function should be run:
+	inline float getThinkRate() const { return 0.09f; }
+
+	/// Call this before the first call to OnThink()
+	void StartThinking( CPhysConstraint *pOuter, const Vector &relativeVelocity, const Vector &forwardVector );
+
+	/// Call this if you intend to stop calling OnThink():
+	void StopThinking( CPhysConstraint *pOuter );
+
+	/// Call from owner's Precache().
+	void OnPrecache( CPhysConstraint *pOuter );
+
+
+	VelocitySampler m_vSampler;
+	SimpleConstraintSoundProfile m_soundProfile;
+
+	Vector m_forwardAxis; ///< velocity in this direction is forward. The opposite direction is backward.
+
+	string_t m_iszTravelSoundFwd,m_iszTravelSoundBack;			// Path/filename of WAV file to play.
+	CSoundPatch		*m_pTravelSound;
+	bool			m_bPlayTravelSound;
+
+	string_t m_iszReversalSounds[SimpleConstraintSoundProfile::kREVERSAL_SOUND_ARRAY_SIZE];			// Path/filename of WAV files to play -- one per entry in threshold.
+	// CSoundPatch		*m_pReversalSound;
+	bool			m_bPlayReversalSound;
+
+protected:
+	/// Maintain consistency of internal datastructures on start
+	void ValidateInternals( CPhysConstraint *pOuter );
+
+	/// Stop playing any active sounds.
+	void DeleteAllSounds();
+};
+
+
+/////////////// INLINE FUNCTIONS
+	
+
+/// compute the relative velocity between an object and its parent. Just a convenience.
+Vector VelocitySampler::GetRelativeVelocity( IPhysicsObject *pObj, IPhysicsObject *pReferenceFrame )
+{
+	Vector childVelocity, parentVelocity;
+	pObj->GetImplicitVelocity( &childVelocity, NULL );
+	pReferenceFrame->GetImplicitVelocity(&parentVelocity, NULL);
+
+	return (childVelocity - parentVelocity);
+}
+
+
+Vector VelocitySampler::GetRelativeAngularVelocity( IPhysicsObject *pObj, IPhysicsObject *pReferenceFrame )
+{
+	Assert(pObj);
+
+	if ( pReferenceFrame )
+	{
+		Vector childVelocityLocal, parentVelocityLocal, childVelocityWorld, parentVelocityWorld;
+		pObj->GetImplicitVelocity( NULL, &childVelocityLocal );
+		pObj->LocalToWorldVector( &childVelocityWorld, childVelocityLocal );
+		pReferenceFrame->GetImplicitVelocity( NULL, &parentVelocityLocal );
+		pObj->LocalToWorldVector( &parentVelocityWorld, parentVelocityLocal );
+
+		return (childVelocityWorld - parentVelocityWorld);
+	}
+	else
+	{
+		Vector childVelocityLocal, childVelocityWorld;
+		pObj->GetImplicitVelocity( NULL, &childVelocityLocal );
+		pObj->LocalToWorldVector( &childVelocityWorld, childVelocityLocal );
+
+		return (childVelocityWorld);
+	}
+}
+
+/************************************************************************/
+// This function is nominal -- it's here as an interface because in the 
+// future there will need to be special initialization for the first entry
+// in a ring buffer. (I made a test implementation of this, then reverted it
+// later; this is not an arbitrary assumption.)
+/************************************************************************/
+/// Store off the first recorded sample for the given object.
+void VelocitySampler::BeginSampling(const Vector &relativeVelocity)
+{
+	return AddSample(relativeVelocity);
+}
+
+// Record a sample for the given object
+void VelocitySampler::AddSample(const Vector &relativeVelocity)
+{
+	m_prevSample = relativeVelocity;
+	m_fPrevSampleTime = gpGlobals->curtime;
+}
+
+
+
+/* // abandoned -- too complicated, no way to set from keyfields
+#pragma warning(push)
+#pragma warning( disable:4201 ) // C4201: nonstandard extension used: nameless struct/union
+/// Stores information used for playing sounds based on 
+/// constraint movement
+class ConstraintSoundProfile
+{
+public:
+/// Defines a point in the sound profile: volume and pitch for the sound to play.
+/// Implicit crossfading between two sounds. Used to map velocity to a sound profile.
+struct SoundInfoTuple
+{
+float minVelocity;
+union {
+struct{
+float volume1,pitch1; //< volume and pitch of sound 1
+float volume2,pitch2; //< volume and pitch of sound 2
+};
+fltx4 m_as4;
+};
+
+inline SoundInfoTuple(float _minVelocity, float _volume1, float _pitch1, float _volume2, float _pitch2) :
+minVelocity(_minVelocity), volume1(_volume1), pitch1(_pitch1), volume2(_volume2), pitch2(_pitch2) 
+{}
+};
+
+ConstraintSoundProfile(const SoundInfoTuple *soundTable, unsigned int tableSize) 
+: m_pSoundInfos(soundTable), m_numSoundInfos(tableSize) 
+{}
+
+
+protected:
+
+/// A table of sound info structs
+const SoundInfoTuple * const m_pSoundInfos;
+/// Size of the table
+const unsigned int m_numSoundInfos;
+};
+
+static ConstraintSoundProfile::SoundInfoTuple CSDebugProfileTable[] =
+{
+ConstraintSoundProfile::SoundInfoTuple(12,0,0,0,0),
+ConstraintSoundProfile::SoundInfoTuple(24,0,0,0,0),
+
+};
+#pragma warning(pop)
+*/
+
+
+#endif