[Binaural] Minor refactoring

Author: ardgzrivero

3dti_Toolkit/BinauralSpatializer/Listener.cpp

@@ -35,8 +35,8 @@ namespace Binaural
      listenerHeadRadius{_listenerHeadRadius},
 	 listenerILDAttenutationDB{ ILDATTENUATION },
 	 enableDirectionality {false, false},	 
-	 anechoicDirectionalityAttenuation{0.0f, 0.0f},	 
-	 reverbDirectionalityAttenuation{ 0.0f, 0.0f }	 
+	 anechoicDirectionalityLinearAttenuation{0.0f, 0.0f},	 
+	 reverbDirectionalityLinearAttenuation{ 0.0f, 0.0f }	 
     {				
 		std::unique_ptr<CHRTF> a(new CHRTF(this));		// HRTF of listener
 		listenerHRTF = std::move(a);	
@@ -222,53 +222,53 @@ namespace Binaural
 		}
 		if (ear == Common::T_ear::LEFT)
 		{
-			anechoicDirectionalityAttenuation.left = std::pow(10, _directionalityAttenuation / 20);
-			reverbDirectionalityAttenuation.left = CalculateReverbDirectionalityAttenuation(_directionalityAttenuation);
+			anechoicDirectionalityLinearAttenuation.left = std::pow(10, _directionalityAttenuation / 20);
+			reverbDirectionalityLinearAttenuation.left = CalculateReverbDirectionalityLinearAttenuation(_directionalityAttenuation);
 		}
 		if (ear == Common::T_ear::RIGHT)
 		{
-			anechoicDirectionalityAttenuation.right = std::pow(10, _directionalityAttenuation / 20);
-			reverbDirectionalityAttenuation.right = CalculateReverbDirectionalityAttenuation(_directionalityAttenuation);
+			anechoicDirectionalityLinearAttenuation.right = std::pow(10, _directionalityAttenuation / 20);
+			reverbDirectionalityLinearAttenuation.right = CalculateReverbDirectionalityLinearAttenuation(_directionalityAttenuation);
 		}
 	}
 
 	float CListener::GetAnechoicDirectionalityAttenuation_dB(Common::T_ear ear) const 
 	{ 
 		if (ear == Common::T_ear::LEFT)
-			return 20 * std::log(anechoicDirectionalityAttenuation.left);
+			return 20 * std::log(anechoicDirectionalityLinearAttenuation.left);
 		if (ear == Common::T_ear::RIGHT)
-			return 20 * std::log(anechoicDirectionalityAttenuation.right);
+			return 20 * std::log(anechoicDirectionalityLinearAttenuation.right);
 		return -1.0f;
 	}
 
 	float CListener::GetAnechoicDirectionalityLinearAttenuation(Common::T_ear ear) const
 	{
 		if (ear == Common::T_ear::LEFT)
-			return anechoicDirectionalityAttenuation.left;
+			return anechoicDirectionalityLinearAttenuation.left;
 		if (ear == Common::T_ear::RIGHT)
-			return anechoicDirectionalityAttenuation.right;
+			return anechoicDirectionalityLinearAttenuation.right;
 		return -1.0f;
 	}
 
 	float CListener::GetReverbDirectionalityAttenuation_dB(Common::T_ear ear) const 
 	{ 
 		if (ear == Common::T_ear::LEFT)			
-			return 20 * std::log(reverbDirectionalityAttenuation.left); 
+			return 20 * std::log(reverbDirectionalityLinearAttenuation.left); 
 		if (ear == Common::T_ear::RIGHT)
-			return 20 * std::log(reverbDirectionalityAttenuation.right);
+			return 20 * std::log(reverbDirectionalityLinearAttenuation.right);
 		return -1.0f;
 	}								
 
 	float CListener::GetReverbDirectionalityLinearAttenuation(Common::T_ear ear) const
 	{
 		if (ear == Common::T_ear::LEFT)
-			return reverbDirectionalityAttenuation.left;
+			return reverbDirectionalityLinearAttenuation.left;
 		if (ear == Common::T_ear::RIGHT)
-			return reverbDirectionalityAttenuation.right;
+			return reverbDirectionalityLinearAttenuation.right;
 		return -1.0f;
 	}
 
-	float CListener::CalculateReverbDirectionalityAttenuation(float directionalityExtend_dB)
+	float CListener::CalculateReverbDirectionalityLinearAttenuation(float directionalityExtend_dB)
 	{
 
 		float angle_rad = 0;

3dti_Toolkit/BinauralSpatializer/Listener.h

@@ -217,7 +217,7 @@ class CHRTF;
 		float CalculateDirectionalityLinearAttenuation(float directionalityExtend, float angleToForwardAxis_rad);
 
 		// Calculates reverb directionality linear attenuation
-		float CalculateReverbDirectionalityAttenuation(float directionalityExtend_dB);
+		float CalculateReverbDirectionalityLinearAttenuation(float directionalityExtend_dB);
 
 		// Reset HRTF 
 		void ResetHRTF();
@@ -238,8 +238,8 @@ class CHRTF;
 
 		float listenerILDAttenutationDB;			// Attenuation to apply when the ILD is in use (HighPerformance)
 
-		Common::CEarPair<float> anechoicDirectionalityAttenuation;  // Max value for directionality attenuation in dBs for each channel
-		Common::CEarPair<float> reverbDirectionalityAttenuation;    // Max value for directionality attenuation in dBs for each channel				
+		Common::CEarPair<float> anechoicDirectionalityLinearAttenuation;  // Max value for directionality attenuation in dBs for each channel
+		Common::CEarPair<float> reverbDirectionalityLinearAttenuation;    // Max value for directionality attenuation in dBs for each channel				
 		Common::CEarPair<bool>	enableDirectionality;				// True when current settings for directionality will be applied to each channel (left or right)		
 
 		friend class CHRTF;							//Friend Class definition