proportionally reduco volume after threshold

Author: malytomas

sources/include/cage-engine/scene.h

@@ -137,6 +137,7 @@ namespace cage
 	struct CAGE_ENGINE_API ListenerComponent
 	{
 		uint32 maxSounds = 100;
+		Real maxGainThreshold = Real::Infinity(); // all sounds will have proportionally reduced gain when the sum of effective gains reaches this threshold
 		Real gain = 1; // linear amplitude multiplier
 	};
 }

sources/include/cage-engine/soundsQueue.h

@@ -19,6 +19,7 @@ namespace cage
 	{
 	public:
 		uint32 maxActiveSounds = 100;
+		Real maxGainThreshold = Real::Infinity(); // all sounds will have proportionally reduced gain when the sum of effective gains reaches this threshold
 		Real gain = 1; // linear amplitude multiplier
 
 		void play(Holder<Sound> sound, const SoundEventConfig &cfg = {});

sources/include/cage-engine/soundsVoices.h

@@ -27,7 +27,8 @@ namespace cage
 	public:
 		Quat orientation;
 		Vec3 position;
-		uint32 maxActiveVoices = 100;
+		uint32 maxActiveSounds = 100;
+		Real maxGainThreshold = Real::Infinity(); // all sounds will have proportionally reduced gain when the sum of effective gains reaches this threshold
 		Real gain = 1; // linear amplitude multiplier
 
 		Holder<Voice> newVoice();

sources/libengine/sound/effectiveGain.h

@@ -0,0 +1,55 @@
+#include <algorithm>
+#include <vector>
+
+#include <cage-core/math.h>
+
+namespace cage
+{
+	namespace
+	{
+		template<class T>
+		struct Dereferencer : private Immovable
+		{
+			T *data = nullptr;
+			CAGE_FORCE_INLINE Dereferencer(T *d) : data(d) {}
+			CAGE_FORCE_INLINE Dereferencer(T &d) : data(&d) {}
+			CAGE_FORCE_INLINE T *operator->() const { return data; }
+		};
+
+		template<class This, class K, class T = Dereferencer<std::remove_pointer_t<K>>>
+		void updateEffectiveGains(const This *ths, std::vector<K> &active)
+		{
+			// sort by priority
+			std::sort(active.begin(), active.end(), [](const T a, const T b) -> bool { return std::pair(a->priority, a->effectiveGain) > std::pair(b->priority, b->effectiveGain); });
+			for (uint32 i = ths->maxActiveSounds; i < active.size(); i++)
+				Dereferencer(active[i])->effectiveGain = 0;
+
+			/*
+			{ // fade-out sounds close to limit
+				const uint32 s = max(ths->maxActiveSounds * 70 / 100, 2u);
+				const Real f = 1.0 / (ths->maxActiveSounds - s + 1);
+				for (uint32 i = s; i < active.size(); i++)
+					Dereferencer(active[i])->effectiveGain *= saturate(1 - (i - s + 1) * f);
+			}
+			*/
+
+			// total gain reduction
+			if (ths->maxGainThreshold != Real::Infinity())
+			{
+				Real sum;
+				for (T a : active)
+					sum += a->effectiveGain;
+				if (sum > ths->maxGainThreshold)
+				{
+					const Real f = sqrt(ths->maxGainThreshold / sum);
+					for (T a : active)
+						a->effectiveGain *= f;
+				}
+			}
+
+			// apply this gain
+			for (T a : active)
+				a->effectiveGain *= ths->gain;
+		}
+	}
+}

sources/libengine/sound/soundsQueue.cpp

@@ -1,7 +1,5 @@
-#include <algorithm>
 #include <atomic>
 #include <variant>
-#include <vector>
 
 #include <cage-core/assetsOnDemand.h>
 #include <cage-core/audioChannelsConverter.h>
@@ -10,6 +8,8 @@
 #include <cage-engine/sound.h>
 #include <cage-engine/soundsQueue.h>
 
+#include "effectiveGain.h"
+
 namespace cage
 {
 	namespace
@@ -107,14 +107,14 @@ namespace cage
 					remaining.store(rem, std::memory_order_relaxed);
 				}
 
-				// update effective gains
+				if (active.empty())
+					return;
+
+				// reset effective gains
 				for (Event &a : active)
-					a.effectiveGain = a.gain * this->gain;
+					a.effectiveGain = a.gain;
 
-				// sort by priority
-				std::sort(active.begin(), active.end(), [](const Event &a, const Event &b) -> bool { return std::pair(a.priority, a.effectiveGain) > std::pair(b.priority, b.effectiveGain); });
-				for (uint32 i = maxActiveSounds; i < active.size(); i++)
-					active[i].effectiveGain = 0;
+				updateEffectiveGains(this, active);
 			}
 
 			void processEvent(Event &v, const SoundCallbackData &data)
@@ -161,6 +161,7 @@ namespace cage
 			{
 				CAGE_ASSERT(data.buffer.size() == data.frames * data.channels);
 				CAGE_ASSERT(gain.valid() && gain >= 0 && gain.finite());
+				CAGE_ASSERT(maxGainThreshold.valid() && maxGainThreshold >= 0);
 				detail::memset(data.buffer.data(), 0, data.buffer.size() * sizeof(float));
 
 				if (purging)

sources/libengine/sound/soundsVoices.cpp

@@ -1,12 +1,11 @@
-#include <algorithm>
-#include <vector>
-
 #include <cage-core/audioChannelsConverter.h>
 #include <cage-core/audioDirectionalConverter.h>
 #include <cage-core/sampleRateConverter.h>
 #include <cage-engine/sound.h>
 #include <cage-engine/soundsVoices.h>
 
+#include "effectiveGain.h"
+
 namespace cage
 {
 	namespace
@@ -21,7 +20,7 @@ namespace cage
 
 			VoiceImpl(VoicesMixerImpl *mixer);
 			~VoiceImpl();
-			void updateGain();
+			void resetGain();
 		};
 
 		class VoicesMixerImpl : public VoicesMixer
@@ -44,14 +43,11 @@ namespace cage
 
 			void updateVoices()
 			{
-				// update effective gains
+				// reset effective gains
 				for (VoiceImpl *v : voices)
-					v->updateGain();
+					v->resetGain();
 
-				// sort by priority
-				std::sort(voices.begin(), voices.end(), [](const VoiceImpl *a, const VoiceImpl *b) -> bool { return std::pair(a->priority, a->effectiveGain) > std::pair(b->priority, b->effectiveGain); });
-				for (uint32 i = maxActiveVoices; i < voices.size(); i++)
-					voices[i]->effectiveGain = 0;
+				updateEffectiveGains(this, voices);
 			}
 
 			void processVoice(VoiceImpl &v, const SoundCallbackData &data)
@@ -148,6 +144,7 @@ namespace cage
 			{
 				CAGE_ASSERT(data.buffer.size() == data.frames * data.channels);
 				CAGE_ASSERT(gain.valid() && gain >= 0 && gain.finite());
+				CAGE_ASSERT(maxGainThreshold.valid() && maxGainThreshold >= 0);
 				CAGE_ASSERT(position.valid() && orientation.valid());
 				detail::memset(data.buffer.data(), 0, data.buffer.size() * sizeof(float));
 
@@ -184,7 +181,7 @@ namespace cage
 			}
 		}
 
-		void VoiceImpl::updateGain()
+		void VoiceImpl::resetGain()
 		{
 			Real att = 1;
 			if (position.valid())
@@ -208,7 +205,7 @@ namespace cage
 				}
 			}
 			CAGE_ASSERT(valid(att) && att >= 0 && att <= 1 + 1e-7);
-			effectiveGain = gain * mixer->gain * att;
+			effectiveGain = gain * att;
 			CAGE_ASSERT(valid(effectiveGain) && effectiveGain >= 0 && effectiveGain.finite());
 		}
 	}

sources/libsimple/sound.cpp

@@ -170,7 +170,8 @@ namespace cage
 					const Transform t = interpolate(e.transformHistory, e.transform, interFactor);
 					l.mixer->orientation = t.orientation;
 					l.mixer->position = t.position;
-					l.mixer->maxActiveVoices = e.listener.maxSounds;
+					l.mixer->maxActiveSounds = e.listener.maxSounds;
+					l.mixer->maxGainThreshold = e.listener.maxGainThreshold;
 					l.mixer->gain = e.listener.gain;
 				}