Exposed IEngineSound in engine_c

- Removed _EngineServer.index_of_edict() and
_EngineServer.edict_of_index(). Use conversions_c functions instead.
- Fixed passing a subclass of IRecipientFilter to a function that
requires a IRecipientFilter instance by exposing IRecipientFilter

Author: Ayuto

src/core/modules/engine/engine1/engine_wrap_python.h

@@ -25,24 +25,12 @@
 */
 
 #include "eiface.h"
+#include "engine/IEngineSound.h"
 
 template<class T>
 void IVEngineServer_Visitor(T cls)
 {
 	cls
-		.def("index_of_edict",
-			&IVEngineServer::IndexOfEdict,
-			"Returns the edict's index",
-			args("edict")
-		)
-
-		.def("edict_of_index",
-			&IVEngineServer::PEntityOfEntIndex,
-			"Returns the corresponding edict for the given index.",
-			args("index"),
-			reference_existing_object_policy()
-		)
-
 		.def("user_message_begin",
 			&IVEngineServer::UserMessageBegin,
 			"Begins a user message from the server to the client .dll.",
@@ -81,3 +69,21 @@ void IVEngineServer_Visitor(T cls)
 		*/
 	;
 }
+
+inline void IEngineSound_EmitSound(IEngineSound* pEngineSound, IRecipientFilter& filter, int iEntIndex, int iChannel, const char *pSample, 
+		float flVolume, float flAttenuation, int iFlags = 0, int iPitch = PITCH_NORM, const Vector *pOrigin = NULL, const Vector *pDirection = NULL,
+		tuple origins = tuple(), bool bUpdatePositions = true, float soundtime = 0.0f, int speakerentity = -1)
+{
+	CUtlVector< Vector >* pUtlVecOrigins = NULL;
+	for(int i=0; i < len(origins); i++)
+	{
+		pUtlVecOrigins->AddToTail(extract<Vector>(origins[i]));
+	}
+
+	pEngineSound->EmitSound(filter, iEntIndex, iChannel, pSample, flVolume, flAttenuation, iFlags, iPitch, 0, pOrigin, pDirection, pUtlVecOrigins, bUpdatePositions, soundtime, speakerentity);
+}
+
+template<class T>
+void IEngineSound_Visitor(T cls)
+{
+}

src/core/modules/engine/engine2/engine_wrap_python.h

@@ -27,4 +27,9 @@
 template<class T>
 void IVEngineServer_Visitor(T cls)
 {
+}
+
+template<class T>
+void IEngineSound_Visitor(T cls)
+{
 }

src/core/modules/engine/engine3/engine_wrap_python.h

@@ -27,6 +27,7 @@
 #include "eiface.h"
 #include "ispsharedmemory.h"
 #include "modules/usermessage/usermessage.h"
+#include "engine/IEngineSound.h"
 
 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(get_single_player_shared_memory_space_overload, GetSinglePlayerSharedMemorySpace, 1, 2);
 
@@ -247,3 +248,28 @@ void IVEngineServer_Visitor(T cls)
 		*/
 	;
 }
+
+inline void IEngineSound_EmitSound(IEngineSound* pEngineSound, IRecipientFilter& filter, int iEntIndex, int iChannel, const char *pSample, 
+		float flVolume, float flAttenuation, int iFlags = 0, int iPitch = PITCH_NORM, const Vector *pOrigin = NULL, const Vector *pDirection = NULL,
+		tuple origins = tuple(), bool bUpdatePositions = true, float soundtime = 0.0f, int speakerentity = -1)
+{
+	CUtlVector< Vector >* pUtlVecOrigins = NULL;
+	for(int i=0; i < len(origins); i++)
+	{
+		pUtlVecOrigins->AddToTail(extract<Vector>(origins[i]));
+	}
+
+	pEngineSound->EmitSound(filter, iEntIndex, iChannel, pSample, -1, pSample, flVolume, flAttenuation, 0, iFlags, iPitch, pOrigin, pDirection, pUtlVecOrigins, bUpdatePositions, soundtime, speakerentity);
+}
+
+template<class T>
+void IEngineSound_Visitor(T cls)
+{
+	cls
+		.def("is_looping_sound",
+			&IEngineSound::IsLoopingSound,
+			args("sample"),
+			"Returns True if the given sample is looping."
+		)
+	;
+}

src/core/modules/engine/engine_wrap_python.cpp

@@ -44,20 +44,24 @@
 #include "steam/steamclientpublic.h"
 #include "inetchannelinfo.h"
 #include "eiface.h"
+#include "engine/IEngineSound.h"
 
 #include ENGINE_INCLUDE_PATH(engine_wrap_python.h)
 
 
 extern IVEngineServer* engine;
+extern IEngineSound* enginesound;
 
 //---------------------------------------------------------------------------------
 // Exposes the engine module.
 //---------------------------------------------------------------------------------
 void export_engine_interface();
+void export_engine_sound();
 
 DECLARE_SP_MODULE(engine_c)
 {
 	export_engine_interface();
+	export_engine_sound();
 }
 
 
@@ -700,8 +704,6 @@ void export_engine_interface()
 		)
 
 		// OB specific methods
-		.NOT_IMPLEMENTED("index_of_edict")
-		.NOT_IMPLEMENTED("edict_of_index")
 		.NOT_IMPLEMENTED("user_message_begin")
 		.NOT_IMPLEMENTED("get_time")
 		.NOT_IMPLEMENTED("multiplayer_end_game")
@@ -754,3 +756,126 @@ void export_engine_interface()
 
 	scope().attr("EngineServer") = object(ptr(engine));
 }
+
+
+//---------------------------------------------------------------------------------
+// Exposes IEngineSound.
+//---------------------------------------------------------------------------------
+// Overloads
+BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(precache_sound_overload, PrecacheSound, 1, 3);
+BOOST_PYTHON_FUNCTION_OVERLOADS(emit_sound_overload, IEngineSound_EmitSound, 7, 15);
+
+void export_engine_sound()
+{
+	// Call engine specific implementation function
+	IEngineSound_Visitor(
+
+	class_<IEngineSound, boost::noncopyable>("_EngineSound", no_init)
+
+		.def("precache_sound",
+			&IEngineSound::PrecacheSound,
+			precache_sound_overload(
+				args("sample", "preload", "is_ui_sound"),
+				"Precaches a particular sample."
+			)
+		)
+
+		.def("is_sound_precached",
+			&IEngineSound::IsSoundPrecached,
+			args("sample"),
+			"Returns True if the given sound is precached."
+		)
+
+		.def("prefetch_sound",
+			&IEngineSound::PrefetchSound,
+			args("sample"),
+			"Prefetches a sample."
+		)
+
+		.def("get_sound_duration",
+			&IEngineSound::GetSoundDuration,
+			args("sample"),
+			"Returns the sound duration."
+		)
+
+		.def("emit_sound",
+			&IEngineSound_EmitSound,
+			emit_sound_overload(
+				args("filter", "entity_index", "channel", "sample", "volume", "attenuation", "flags", "pitch", "origin", "direction", "origins", "update_positions", "sound_time", "speaker_entity"),
+				"Emits a sound from an entity."
+			)
+		)
+
+		// TODO: Can we use IVEngineServer::SentenceNameFromIndex() and then call IEngineSound::EmitSound()?
+		.NOT_IMPLEMENTED("emit_sentence_by_index")
+
+		.def("stop_sound",
+			&IEngineSound::StopSound,
+			args("entity_index", "channel", "sample"),
+			"Stops a sound from being emitted from an entity."
+		)
+
+		// TODO: StopAllSounds, SetRoomType, SetPlayerDSP. Are they really just client only?
+
+		.def("get_dist_gain_from_sound_level",
+			&IEngineSound::GetDistGainFromSoundLevel,
+			args("sound_level", "distance"),
+			"Returns the distance gain value from a sound level"
+		)
+
+		// Only available for CS:GO
+		.NOT_IMPLEMENTED("is_looping_sound")
+
+	); // IEngineSound_Visitor
+
+	scope().attr("EngineSound") = object(ptr(enginesound));
+
+	// Channels
+	enum_<int>("Channels")
+		.value("REPLACE", CHAN_REPLACE)
+		.value("AUTO", CHAN_AUTO)
+		.value("WEAPON", CHAN_WEAPON)
+		.value("VOICE", CHAN_VOICE)
+		.value("ITEM", CHAN_ITEM)
+		.value("BODY", CHAN_BODY)
+		.value("STREAM", CHAN_STREAM)
+		.value("STATIC", CHAN_STATIC)
+		.value("VOICE_BASE", CHAN_VOICE_BASE)
+		.value("USER_BASE", CHAN_USER_BASE)
+	;
+
+	// Common volume values
+	scope().attr("VOL_NORM") = VOL_NORM;
+
+	// Common attenuation values
+	scope().attr("ATTN_NONE") = ATTN_NONE;
+	scope().attr("ATTN_NORM") = ATTN_NORM;
+	scope().attr("ATTN_IDLE") = ATTN_IDLE;
+	scope().attr("ATTN_STATIC") = ATTN_STATIC;
+	scope().attr("ATTN_RICOCHET") = ATTN_RICOCHET;
+	scope().attr("ATTN_GUNFIRE") = ATTN_GUNFIRE;
+	scope().attr("MAX_ATTENUATION") = MAX_ATTENUATION;
+
+	// Flags for iFlags fields
+	enum_<SoundFlags_t>("SoundFlags")
+		.value("NOFLAGS", SND_NOFLAGS)
+		.value("CHANGE_VOL", SND_CHANGE_VOL)
+		.value("CHANGE_PITCH", SND_CHANGE_PITCH)
+		.value("STOP", SND_STOP)
+		.value("SPAWNING", SND_SPAWNING)
+		.value("DELAY", SND_DELAY)
+		.value("STOP_LOOPING", SND_STOP_LOOPING)
+		.value("SPEAKER", SND_SPEAKER)
+		.value("SHOULDPAUSE", SND_SHOULDPAUSE)
+		.value("IGNORE_PHONEMES", SND_IGNORE_PHONEMES)
+		.value("IGNORE_NAME", SND_IGNORE_NAME)
+	;
+
+	// Common pitch values
+	scope().attr("PITCH_NORM") = PITCH_NORM;
+	scope().attr("PITCH_LOW") = PITCH_LOW;
+	scope().attr("PITCH_HIGH") = PITCH_HIGH;
+
+	scope().attr("SOUND_FROM_LOCAL_PLAYER") = SOUND_FROM_LOCAL_PLAYER;
+	scope().attr("SOUND_FROM_WORLD") = SOUND_FROM_WORLD;
+}

src/core/modules/recipientfilter/recipientfilter_wrap_python.cpp

@@ -48,29 +48,31 @@ DECLARE_SP_MODULE(recipientfilter_c)
 //-----------------------------------------------------------------------------
 void export_mrecipientfilter()
 {
-	// TODO: Rename class
-	class_<MRecipientFilter, boost::noncopyable>("CMRecipientFilter")
+	class_<IRecipientFilter, boost::noncopyable>("_RecipientFilter", no_init)
 		.def("is_reliable",
-			&MRecipientFilter::IsReliable,
+			&IRecipientFilter::IsReliable,
 			"Whether this recipient filter will be network reliable (sent in-order)"
 		)
 
 		.def("is_init_message",
-			&MRecipientFilter::IsInitMessage,
+			&IRecipientFilter::IsInitMessage,
 			"Whether the message has been initialised?"
 		)
 
 		.def("get_recipient_count",
-			&MRecipientFilter::GetRecipientCount,
+			&IRecipientFilter::GetRecipientCount,
 			"Obtain the amount of clients in this filter"
 		)
 
 		.def("get_recipient_index",
-			&MRecipientFilter::GetRecipientIndex,
+			&IRecipientFilter::GetRecipientIndex,
 			"Obtains the player index at the slot in the filter",
 			args("slot")
 		)
+	;
 
+	// TODO: Rename class
+	class_<MRecipientFilter, bases<IRecipientFilter>, boost::noncopyable >("CMRecipientFilter")
 		.def("add_all_players",
 			&MRecipientFilter::AddAllPlayers,
 			"Adds all the players on the server to the filter"