1HEADmaster

1 files changed, 395 insertions, 0 deletions

diff --git a/public/soundinfo.h b/public/soundinfo.h
new file mode 100644
index 0000000..ba0583e
--- /dev/null
+++ b/public/soundinfo.h
@@ -0,0 +1,395 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================//
+
+#ifndef SOUNDINFO_H
+#define SOUNDINFO_H
+
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "bitbuf.h"
+#include "const.h"
+#include "soundflags.h"
+#include "coordsize.h"
+#include "mathlib/vector.h"
+
+
+#define WRITE_DELTA_UINT( name, length )	\
+	if ( name == delta->name )		\
+		buffer.WriteOneBit(0);		\
+	else					\
+	{					\
+		buffer.WriteOneBit(1);		\
+		buffer.WriteUBitLong( name, length ); \
+	}
+
+#define READ_DELTA_UINT( name, length )			\
+	if ( buffer.ReadOneBit() != 0 )			\
+	{ name = buffer.ReadUBitLong( length ); }\
+	else { name = delta->name; }
+
+#define WRITE_DELTA_SINT( name, length )	\
+	if ( name == delta->name )		\
+		buffer.WriteOneBit(0);		\
+	else					\
+	{					\
+		buffer.WriteOneBit(1);		\
+		buffer.WriteSBitLong( name, length ); \
+	}
+
+#define WRITE_DELTA_SINT_SCALE( name, scale, length )	\
+	if ( name == delta->name )		\
+	buffer.WriteOneBit(0);		\
+	else					\
+	{					\
+	buffer.WriteOneBit(1);		\
+	buffer.WriteSBitLong( name / scale, length ); \
+	}
+
+#define READ_DELTA_SINT( name, length )			\
+	if ( buffer.ReadOneBit() != 0 )			\
+	{ name = buffer.ReadSBitLong( length ); }	\
+	else { name = delta->name; }
+
+#define READ_DELTA_SINT_SCALE( name, scale, length )			\
+	if ( buffer.ReadOneBit() != 0 )			\
+	{ name = scale * buffer.ReadSBitLong( length ); }	\
+	else { name = delta->name; }
+
+#define SOUND_SEQNUMBER_BITS	10
+#define SOUND_SEQNUMBER_MASK	( (1<<SOUND_SEQNUMBER_BITS) - 1 )
+
+// offset sound delay encoding by 60ms since we encode negative sound delays with less precision
+// This means any negative sound delay greater than -100ms will get encoded at full precision
+#define SOUND_DELAY_OFFSET					(0.100f)
+
+#pragma pack(4)
+//-----------------------------------------------------------------------------
+struct SoundInfo_t
+{
+	int				nSequenceNumber;
+	int				nEntityIndex;
+	int				nChannel;
+	const char		*pszName;		// UNDONE: Make this a FilenameHandle_t to avoid bugs with arrays of these
+	Vector			vOrigin;
+	Vector			vDirection;
+	float			fVolume;
+	soundlevel_t	Soundlevel;
+	bool			bLooping;
+	int				nPitch;
+	int				nSpecialDSP;
+	Vector			vListenerOrigin;
+	int				nFlags;
+	int 			nSoundNum;
+	float			fDelay;
+	bool			bIsSentence;
+	bool			bIsAmbient;
+	int				nSpeakerEntity;
+	
+	//---------------------------------
+	
+	SoundInfo_t()
+	{
+		SetDefault();
+	}
+
+	void Set(int newEntity, int newChannel, const char *pszNewName, const Vector &newOrigin, const Vector& newDirection, 
+			float newVolume, soundlevel_t newSoundLevel, bool newLooping, int newPitch, const Vector &vecListenerOrigin, int speakerentity )
+	{
+		nEntityIndex = newEntity;
+		nChannel = newChannel;
+		pszName = pszNewName;
+		vOrigin = newOrigin;
+		vDirection = newDirection;
+		fVolume = newVolume;
+		Soundlevel = newSoundLevel;
+		bLooping = newLooping;
+		nPitch = newPitch;
+		vListenerOrigin = vecListenerOrigin;
+		nSpeakerEntity = speakerentity;
+	}
+
+	void SetDefault()
+	{
+		fDelay = DEFAULT_SOUND_PACKET_DELAY;
+		fVolume = DEFAULT_SOUND_PACKET_VOLUME;
+		Soundlevel = SNDLVL_NORM;
+		nPitch = DEFAULT_SOUND_PACKET_PITCH;
+		nSpecialDSP = 0;
+
+		nEntityIndex = 0;
+		nSpeakerEntity = -1;
+		nChannel = CHAN_STATIC;
+		nSoundNum = 0;
+		nFlags = 0;
+		nSequenceNumber = 0;
+
+		pszName = NULL;
+	
+		bLooping = false;
+		bIsSentence = false;
+		bIsAmbient = false;
+		
+		vOrigin.Init();
+		vDirection.Init();
+		vListenerOrigin.Init();
+	}
+
+	void ClearStopFields()
+	{
+		fVolume = 0;
+		Soundlevel = SNDLVL_NONE;
+		nPitch = PITCH_NORM;
+		nSpecialDSP = 0;
+		pszName = NULL;
+		fDelay = 0.0f;
+		nSequenceNumber = 0;
+
+		vOrigin.Init();
+		nSpeakerEntity = -1;
+	}
+
+	// this cries for Send/RecvTables:
+	void WriteDelta( SoundInfo_t *delta, bf_write &buffer)
+	{
+		if ( nEntityIndex == delta->nEntityIndex )
+		{
+			buffer.WriteOneBit( 0 );
+		}
+		else
+		{
+			buffer.WriteOneBit( 1 );
+		
+			if ( nEntityIndex <= 31)
+			{
+				buffer.WriteOneBit( 1 );
+				buffer.WriteUBitLong( nEntityIndex, 5 );
+			}
+			else
+			{
+				buffer.WriteOneBit( 0 );
+				buffer.WriteUBitLong( nEntityIndex, MAX_EDICT_BITS );
+			}
+		}
+
+		WRITE_DELTA_UINT( nSoundNum, MAX_SOUND_INDEX_BITS );
+
+		WRITE_DELTA_UINT( nFlags, SND_FLAG_BITS_ENCODE );
+
+		WRITE_DELTA_UINT( nChannel, 3 );
+
+		buffer.WriteOneBit( bIsAmbient?1:0 );
+		buffer.WriteOneBit( bIsSentence?1:0 ); // NOTE: SND_STOP behavior is different depending on this flag
+
+		if ( nFlags != SND_STOP )
+		{
+			if ( nSequenceNumber == delta->nSequenceNumber )
+			{
+				// didn't change, most often case
+				buffer.WriteOneBit( 1 );
+			}
+			else if ( nSequenceNumber == (delta->nSequenceNumber+1) )
+			{
+				// increased by one
+				buffer.WriteOneBit( 0 );
+				buffer.WriteOneBit( 1 );
+			}
+			else
+			{
+				// send full seqnr
+				buffer.WriteUBitLong( 0, 2 ); // 2 zero bits
+				buffer.WriteUBitLong( nSequenceNumber, SOUND_SEQNUMBER_BITS ); 
+			}
+						
+			if ( fVolume == delta->fVolume )
+			{
+				buffer.WriteOneBit( 0 );
+			}
+			else
+			{
+				buffer.WriteOneBit( 1 );
+				buffer.WriteUBitLong( (unsigned int)(fVolume*127.0f), 7 );
+			}
+
+			WRITE_DELTA_UINT( Soundlevel, MAX_SNDLVL_BITS );
+
+			WRITE_DELTA_UINT( nPitch, 8 );
+
+			WRITE_DELTA_UINT( nSpecialDSP, 8 );
+
+			if ( fDelay == delta->fDelay )
+			{
+				buffer.WriteOneBit( 0 );
+			}
+			else
+			{
+				buffer.WriteOneBit( 1 );
+
+				// skipahead works in 10 ms increments
+				// bias results so that we only incur the precision loss on relatively large skipaheads
+				fDelay += SOUND_DELAY_OFFSET;
+
+				// Convert to msecs
+				int iDelay = fDelay * 1000.0f;
+
+				iDelay = clamp( iDelay, (int)(-10 * MAX_SOUND_DELAY_MSEC), (int)(MAX_SOUND_DELAY_MSEC) );
+
+				if ( iDelay < 0 )
+				{
+					iDelay /=10;	
+				}
+				
+				buffer.WriteSBitLong( iDelay , MAX_SOUND_DELAY_MSEC_ENCODE_BITS );
+			}
+
+			// don't transmit sounds with high precision
+			WRITE_DELTA_SINT_SCALE( vOrigin.x, 8.0f, COORD_INTEGER_BITS - 2 );
+			WRITE_DELTA_SINT_SCALE( vOrigin.y, 8.0f, COORD_INTEGER_BITS - 2  );
+			WRITE_DELTA_SINT_SCALE( vOrigin.z, 8.0f, COORD_INTEGER_BITS - 2 );
+
+			WRITE_DELTA_SINT( nSpeakerEntity, MAX_EDICT_BITS + 1 );
+		}
+		else
+		{
+			ClearStopFields();
+		}
+	};
+
+	void ReadDelta( SoundInfo_t *delta, bf_read &buffer, int nProtoVersion )
+	{
+		if ( !buffer.ReadOneBit() )
+		{
+			nEntityIndex = delta->nEntityIndex;
+		}
+		else
+		{
+			if ( buffer.ReadOneBit() )
+			{
+				nEntityIndex = buffer.ReadUBitLong( 5 );
+			}
+			else
+			{
+				nEntityIndex = buffer.ReadUBitLong( MAX_EDICT_BITS );
+			}
+		}
+
+		if ( nProtoVersion > 22 )
+		{	
+			READ_DELTA_UINT( nSoundNum, MAX_SOUND_INDEX_BITS );
+		}
+		else
+		{
+			READ_DELTA_UINT( nSoundNum, 13 );
+		}
+
+		if ( nProtoVersion > 18 )
+		{
+			READ_DELTA_UINT( nFlags, SND_FLAG_BITS_ENCODE );
+		}
+		else
+		{
+			// There was 9 flag bits for version 18 and below (prior to Halloween 2011)
+			READ_DELTA_UINT( nFlags, 9 );
+		}
+
+		READ_DELTA_UINT( nChannel, 3 );
+
+		bIsAmbient = buffer.ReadOneBit() != 0;
+		bIsSentence = buffer.ReadOneBit() != 0; // NOTE: SND_STOP behavior is different depending on this flag
+
+		if ( nFlags != SND_STOP )
+		{
+			if ( buffer.ReadOneBit() != 0 )
+			{
+				nSequenceNumber = delta->nSequenceNumber;
+			}
+			else if ( buffer.ReadOneBit() != 0 )
+			{
+				nSequenceNumber = delta->nSequenceNumber + 1;
+			}
+			else
+			{
+				nSequenceNumber = buffer.ReadUBitLong( SOUND_SEQNUMBER_BITS );
+			}
+				
+			if ( buffer.ReadOneBit() != 0 )
+			{
+				fVolume = (float)buffer.ReadUBitLong( 7 )/127.0f;
+			}
+			else
+			{
+				fVolume = delta->fVolume;
+			}
+
+			if ( buffer.ReadOneBit() != 0 )
+			{
+				Soundlevel = (soundlevel_t)buffer.ReadUBitLong( MAX_SNDLVL_BITS );
+			}
+			else
+			{
+				Soundlevel = delta->Soundlevel;
+			}
+
+			READ_DELTA_UINT( nPitch, 8 );
+
+			if ( nProtoVersion > 21 )
+			{
+				// These bit weren't written in version 19 and below
+				READ_DELTA_UINT( nSpecialDSP, 8 );
+			}
+
+			if ( buffer.ReadOneBit() != 0 )
+			{
+				// Up to 4096 msec delay
+				fDelay = (float)buffer.ReadSBitLong( MAX_SOUND_DELAY_MSEC_ENCODE_BITS ) / 1000.0f; ;
+				
+				if ( fDelay < 0 )
+				{
+					fDelay *= 10.0f;
+				}
+				// bias results so that we only incur the precision loss on relatively large skipaheads
+				fDelay -= SOUND_DELAY_OFFSET;
+			}
+			else
+			{
+				fDelay = delta->fDelay;
+			}
+
+			READ_DELTA_SINT_SCALE( vOrigin.x, 8.0f, COORD_INTEGER_BITS - 2 );
+			READ_DELTA_SINT_SCALE( vOrigin.y, 8.0f, COORD_INTEGER_BITS - 2 );
+			READ_DELTA_SINT_SCALE( vOrigin.z, 8.0f, COORD_INTEGER_BITS - 2 );
+
+			READ_DELTA_SINT( nSpeakerEntity, MAX_EDICT_BITS + 1 );
+		}
+		else
+		{
+			ClearStopFields();
+		}
+	}
+};
+
+struct SpatializationInfo_t
+{
+	typedef enum
+	{
+		SI_INCREATION = 0,
+		SI_INSPATIALIZATION
+	} SPATIALIZATIONTYPE;
+
+	// Inputs
+	SPATIALIZATIONTYPE	type;
+	// Info about the sound, channel, origin, direction, etc.
+	SoundInfo_t			info;
+
+	// Requested Outputs ( NULL == not requested )
+	Vector				*pOrigin;
+	QAngle				*pAngles;
+	float				*pflRadius;
+};
+#pragma pack()
+
+#endif // SOUNDINFO_H