Allow axis to control volume actions

FabioZumbi12 · FabioZumbi12 · commit c93d3b17f6fe · 2026-03-02T19:11:54.000-03:00
diff --git a/data/locale/en-US.ini b/data/locale/en-US.ini
@@ -17,7 +17,11 @@ JoypadToOBS.Field.Multiplier="Scale"
 JoypadToOBS.Field.UseCurrentScene="Use current scene"
 JoypadToOBS.Field.AllowAboveDb="Allow above 0 dB"
 JoypadToOBS.Field.AxisValue="Axis value"
-JoypadToOBS.Field.AxisThreshold="Axis threshold"
+JoypadToOBS.Field.AxisThreshold="Axis deadzone"
+JoypadToOBS.Field.AxisMinPerSecond="Min triggers per second"
+JoypadToOBS.Field.AxisMaxPerSecond="Max triggers per second"
+JoypadToOBS.Field.AxisActivationMin="Min activation"
+JoypadToOBS.Field.AxisActivationMax="Max activation"
 JoypadToOBS.Field.AxisBothDirections="Use both directions (+/-)"
 JoypadToOBS.Field.AxisMinValue="Axis min"
 JoypadToOBS.Field.AxisMaxValue="Axis max"
diff --git a/data/locale/pt-BR.ini b/data/locale/pt-BR.ini
@@ -17,7 +17,11 @@ JoypadToOBS.Field.Multiplier="Escala"
 JoypadToOBS.Field.UseCurrentScene="Usar cena atual"
 JoypadToOBS.Field.AllowAboveDb="Permitir acima de 0 dB"
 JoypadToOBS.Field.AxisValue="Valor do eixo"
-JoypadToOBS.Field.AxisThreshold="Limiar do eixo"
+JoypadToOBS.Field.AxisThreshold="Zona morta do eixo"
+JoypadToOBS.Field.AxisMinPerSecond="Acionamento mínimo por segundo"
+JoypadToOBS.Field.AxisMaxPerSecond="Acionamento máximo por segundo"
+JoypadToOBS.Field.AxisActivationMin="Acionamento mínimo"
+JoypadToOBS.Field.AxisActivationMax="Acionamento máximo"
 JoypadToOBS.Field.AxisBothDirections="Usar ambas direções (+/-)"
 JoypadToOBS.Field.AxisMinValue="Mínimo do eixo"
 JoypadToOBS.Field.AxisMaxValue="Máximo do eixo"
diff --git a/data/locale/pt-PT.ini b/data/locale/pt-PT.ini
@@ -17,7 +17,11 @@ JoypadToOBS.Field.Multiplier="Escala"
 JoypadToOBS.Field.UseCurrentScene="Usar cena atual"
 JoypadToOBS.Field.AllowAboveDb="Permitir acima de 0 dB"
 JoypadToOBS.Field.AxisValue="Valor do eixo"
-JoypadToOBS.Field.AxisThreshold="Limiar do eixo"
+JoypadToOBS.Field.AxisThreshold="Zona morta do eixo"
+JoypadToOBS.Field.AxisMinPerSecond="Acionamento mínimo por segundo"
+JoypadToOBS.Field.AxisMaxPerSecond="Acionamento máximo por segundo"
+JoypadToOBS.Field.AxisActivationMin="Acionamento mínimo"
+JoypadToOBS.Field.AxisActivationMax="Acionamento máximo"
 JoypadToOBS.Field.AxisBothDirections="Usar ambas direções (+/-)"
 JoypadToOBS.Field.AxisMinValue="Mínimo do eixo"
 JoypadToOBS.Field.AxisMaxValue="Máximo do eixo"
diff --git a/src/joypad-actions.cpp b/src/joypad-actions.cpp
@@ -208,22 +208,22 @@ void JoypadActionEngine::Execute(const JoypadBinding &binding)
 		if (!source) {
 			return;
 		}
-		float current_mul = obs_source_get_volume(source);
-		float next_mul = current_mul + (float)binding.volume_value;
-		if (next_mul < 0.0f) {
-			next_mul = 0.0f;
+		const float current_mul = obs_source_get_volume(source);
+		float current_db = mul_to_db(current_mul);
+		if (current_db < kMinDb) {
+			current_db = kMinDb;
 		}
-		if (!binding.allow_above_unity && next_mul > 1.0f) {
-			next_mul = 1.0f;
+		float next_db = current_db + (float)binding.volume_value;
+		if (!binding.allow_above_unity && next_db > 0.0f) {
+			next_db = 0.0f;
 		}
-		float min_mul = db_to_mul(kMinDb);
-		float max_mul = db_to_mul(kMaxDb);
-		if (next_mul < min_mul) {
-			next_mul = min_mul;
+		if (next_db < kMinDb) {
+			next_db = kMinDb;
 		}
-		if (next_mul > max_mul) {
-			next_mul = max_mul;
+		if (next_db > kMaxDb) {
+			next_db = kMaxDb;
 		}
+		const float next_mul = db_to_mul(next_db);
 		if (std::fabs(current_mul - next_mul) > kVolumeEpsilon) {
 			obs_source_set_volume(source, next_mul);
 		}
diff --git a/src/joypad-config.cpp b/src/joypad-config.cpp
@@ -132,7 +132,25 @@ static void load_binding_from_data(JoypadBinding &binding, obs_data_t *data)
 	binding.axis_threshold = obs_data_get_double(data, "axis_threshold");
 	bool axis_threshold_set = obs_data_get_bool(data, "axis_threshold_set");
 	if (!axis_threshold_set) {
-		binding.axis_threshold = 0.5;
+		binding.axis_threshold = 0.10;
+	}
+	binding.axis_min_per_second = obs_data_get_double(data, "axis_min_per_second");
+	if (!obs_data_has_user_value(data, "axis_min_per_second")) {
+		// Backward compatibility with older configs.
+		double legacy_min = obs_data_get_double(data, "axis_activation_min");
+		binding.axis_min_per_second = legacy_min > 0.0 ? legacy_min * 10.0 : 2.5;
+	}
+	binding.axis_max_per_second = obs_data_get_double(data, "axis_max_per_second");
+	if (!obs_data_has_user_value(data, "axis_max_per_second")) {
+		// Backward compatibility with older configs.
+		double legacy_max = obs_data_get_double(data, "axis_activation_max");
+		binding.axis_max_per_second = legacy_max > 0.0 ? legacy_max * 10.0 : 20.0;
+	}
+	binding.axis_threshold = std::clamp(binding.axis_threshold, 0.0, 0.95);
+	binding.axis_min_per_second = std::clamp(binding.axis_min_per_second, 1.0, 60.0);
+	binding.axis_max_per_second = std::clamp(binding.axis_max_per_second, 1.0, 60.0);
+	if (binding.axis_max_per_second < binding.axis_min_per_second) {
+		binding.axis_max_per_second = binding.axis_min_per_second;
 	}
 	binding.axis_interval_ms = (int)obs_data_get_int(data, "axis_interval_ms");
 	if (binding.axis_interval_ms <= 0) {
@@ -187,6 +205,8 @@ static void save_binding_to_data(const JoypadBinding &binding, obs_data_t *data)
 		obs_data_set_bool(data, "axis_inverted", binding.axis_inverted);
 		obs_data_set_double(data, "axis_threshold", binding.axis_threshold);
 		obs_data_set_bool(data, "axis_threshold_set", true);
+		obs_data_set_double(data, "axis_min_per_second", binding.axis_min_per_second);
+		obs_data_set_double(data, "axis_max_per_second", binding.axis_max_per_second);
 		obs_data_set_int(data, "axis_interval_ms", binding.axis_interval_ms);
 		obs_data_set_double(data, "axis_min_value", binding.axis_min_value);
 		obs_data_set_double(data, "axis_max_value", binding.axis_max_value);
@@ -903,8 +923,8 @@ std::vector<JoypadBinding> JoypadConfigStore::FindMatchingBindings(const JoypadE
 				}
 			}
 
-			const double threshold_on = binding.axis_threshold;
-			const double threshold_off = binding.axis_threshold * 0.4;
+			const double threshold_on = std::clamp(binding.axis_threshold, 0.0, 0.95);
+			const double threshold_off = threshold_on * 0.4;
 			std::string axis_key = event.device_id + ":" + std::to_string(binding.axis_index) + ":" +
 					       std::to_string((int)binding.axis_direction) + ":" +
 					       (binding.axis_inverted ? "1" : "0");
@@ -924,13 +944,18 @@ std::vector<JoypadBinding> JoypadConfigStore::FindMatchingBindings(const JoypadE
 			}
 			if (binding.action == JoypadActionType::AdjustSourceVolume) {
 				double sign = value >= 0.0 ? 1.0 : -1.0;
-				double intensity = std::clamp(abs_value, 0.0, 1.0);
-				binding.volume_value = std::fabs(binding.volume_value) * intensity * sign;
+				binding.volume_value = std::fabs(binding.volume_value) * sign;
 			}
 			const bool is_continuous_axis_action =
-				(binding.action == JoypadActionType::SetSourceVolumePercent) ||
-				(binding.action == JoypadActionType::AdjustSourceVolume);
-			if (!is_continuous_axis_action && binding.axis_interval_ms > 0) {
+				(binding.action == JoypadActionType::SetSourceVolumePercent);
+			if (!is_continuous_axis_action) {
+				const double min_rate = std::clamp(binding.axis_min_per_second, 1.0, 60.0);
+				const double max_rate = std::clamp(binding.axis_max_per_second, min_rate, 60.0);
+				double intensity =
+					std::clamp((abs_value - threshold_on) / (1.0 - threshold_on), 0.0, 1.0);
+				double rate = min_rate + (max_rate - min_rate) * intensity;
+				int dynamic_interval_ms = (int)std::round(1000.0 / std::max(rate, 0.001));
+				dynamic_interval_ms = std::max(dynamic_interval_ms, 1);
 				std::string interval_key;
 				if (binding.uid > 0) {
 					interval_key = std::to_string((long long)binding.uid);
@@ -944,7 +969,7 @@ std::vector<JoypadBinding> JoypadConfigStore::FindMatchingBindings(const JoypadE
 					const auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
 								     now - it_last->second)
 								     .count();
-					if (elapsed < binding.axis_interval_ms) {
+					if (elapsed < dynamic_interval_ms) {
 						continue;
 					}
 				}
diff --git a/src/joypad-config.h b/src/joypad-config.h
@@ -82,9 +82,11 @@ struct JoypadBinding {
 	int button = -1;
 	JoypadInputType input_type = JoypadInputType::Button;
 	int axis_index = -1;
-	JoypadAxisDirection axis_direction = JoypadAxisDirection::Positive;
+	JoypadAxisDirection axis_direction = JoypadAxisDirection::Both;
 	bool axis_inverted = false;
-	double axis_threshold = 0.5;
+	double axis_threshold = 0.10;
+	double axis_min_per_second = 2.5;
+	double axis_max_per_second = 20.0;
 	int axis_interval_ms = 150;
 	double axis_min_value = 0.0;
 	double axis_max_value = 1024.0;
diff --git a/src/joypad-input.cpp b/src/joypad-input.cpp
@@ -48,6 +48,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>
 
 namespace {
 constexpr int kMaxTrackedAxes = 8;
+constexpr double kAxisContinuousHoldThreshold = 0.01;
 
 #ifdef _WIN32
 struct DiControllerInfo {
@@ -927,13 +928,15 @@ bool JoypadInputManager::BeginLearn(std::function<void(const JoypadEvent &)> han
 		return false;
 	}
 	learn_handler_ = std::move(handler);
+	learn_active_.store(true, std::memory_order_release);
 	return true;
 }
 
 void JoypadInputManager::CancelLearn()
 {
 	std::lock_guard<std::mutex> lock(handler_mutex_);
 	learn_handler_ = nullptr;
+	learn_active_.store(false, std::memory_order_release);
 }
 
 void JoypadInputManager::MarkDeviceDisconnected(DeviceState &state)
@@ -1057,7 +1060,9 @@ void JoypadInputManager::PollLoop()
 						continue;
 					}
 					double prev_raw = state.last_axes[i];
-					if (std::fabs(raw - prev_raw) < 0.000001) {
+					const bool hold_active = std::fabs(normalized) >= kAxisContinuousHoldThreshold;
+					const bool learning_active = learn_active_.load(std::memory_order_acquire);
+					if (std::fabs(raw - prev_raw) < 0.000001 && (!hold_active || learning_active)) {
 						continue;
 					}
 					if (it != axis_last_trigger_.end() &&
@@ -1132,7 +1137,11 @@ void JoypadInputManager::PollLoop()
 							continue;
 						}
 						double prev = state.last_axes[axis_index];
-						if (raw == prev) {
+						const bool hold_active = std::fabs(value) >=
+									 kAxisContinuousHoldThreshold;
+						const bool learning_active =
+							learn_active_.load(std::memory_order_acquire);
+						if (raw == prev && (!hold_active || learning_active)) {
 							continue;
 						}
 						if (it != axis_last_trigger_.end() &&
@@ -1436,7 +1445,11 @@ void JoypadInputManager::PollLoop()
 						if (init_only) {
 							return;
 						}
-						if (raw == prev) {
+						const bool hold_active = std::fabs(norm) >=
+									 kAxisContinuousHoldThreshold;
+						const bool learning_active =
+							self->learn_active_.load(std::memory_order_acquire);
+						if (raw == prev && (!hold_active || learning_active)) {
 							return;
 						}
 						if (it != self->axis_last_trigger_.end() &&
@@ -1510,6 +1523,7 @@ void JoypadInputManager::DispatchEvent(const JoypadEvent &event)
 		}
 		if (learn_handler_) {
 			learn_handler_ = nullptr;
+			learn_active_.store(false, std::memory_order_release);
 		}
 	}
 
@@ -1543,6 +1557,7 @@ void JoypadInputManager::DispatchAxisAbsolute(const JoypadEvent &event)
 		}
 		if (learn_handler_) {
 			learn_handler_ = nullptr;
+			learn_active_.store(false, std::memory_order_release);
 		}
 	}
 	if (learn_handler) {
diff --git a/src/joypad-input.h b/src/joypad-input.h
@@ -93,6 +93,7 @@ class JoypadInputManager {
 	std::mutex handler_mutex_;
 	std::function<void(const JoypadEvent &)> on_button_pressed_;
 	std::function<void(const JoypadEvent &)> learn_handler_;
+	std::atomic<bool> learn_active_{false};
 	struct AxisHandlerEntry {
 		int id = 0;
 		std::function<void(const JoypadEvent &)> handler;
diff --git a/src/joypad-ui.cpp b/src/joypad-ui.cpp

Original file line number	Diff line number	Diff line change
`@@ -48,6 +48,7 @@ with this program. If not, see <https://www.gnu.org/licenses/>`
`48`	`48`
`49`	`49`	`namespace {`
`50`	`50`	`constexpr int kMaxTrackedAxes = 8;`
	`51`	`+constexpr double kAxisContinuousHoldThreshold = 0.01;`
`51`	`52`
`52`	`53`	`#ifdef _WIN32`
`53`	`54`	`struct DiControllerInfo {`
`@@ -927,13 +928,15 @@ bool JoypadInputManager::BeginLearn(std::function<void(const JoypadEvent &)> han`
`927`	`928`	`return false;`
`928`	`929`	`}`
`929`	`930`	`learn_handler_ = std::move(handler);`
	`931`	`+ learn_active_.store(true, std::memory_order_release);`
`930`	`932`	`return true;`
`931`	`933`	`}`
`932`	`934`
`933`	`935`	`void JoypadInputManager::CancelLearn()`
`934`	`936`	`{`
`935`	`937`	`std::lock_guard<std::mutex> lock(handler_mutex_);`
`936`	`938`	`learn_handler_ = nullptr;`
	`939`	`+ learn_active_.store(false, std::memory_order_release);`
`937`	`940`	`}`
`938`	`941`
`939`	`942`	`void JoypadInputManager::MarkDeviceDisconnected(DeviceState &state)`
`@@ -1057,7 +1060,9 @@ void JoypadInputManager::PollLoop()`
`1057`	`1060`	`continue;`
`1058`	`1061`	`}`
`1059`	`1062`	`double prev_raw = state.last_axes[i];`
`1060`		`- if (std::fabs(raw - prev_raw) < 0.000001) {`
	`1063`	`+ const bool hold_active = std::fabs(normalized) >= kAxisContinuousHoldThreshold;`
	`1064`	`+ const bool learning_active = learn_active_.load(std::memory_order_acquire);`
	`1065`	`+ if (std::fabs(raw - prev_raw) < 0.000001 && (!hold_active \|\| learning_active)) {`
`1061`	`1066`	`continue;`
`1062`	`1067`	`}`
`1063`	`1068`	`if (it != axis_last_trigger_.end() &&`
`@@ -1132,7 +1137,11 @@ void JoypadInputManager::PollLoop()`
`1132`	`1137`	`continue;`
`1133`	`1138`	`}`
`1134`	`1139`	`double prev = state.last_axes[axis_index];`
`1135`		`- if (raw == prev) {`
	`1140`	`+ const bool hold_active = std::fabs(value) >=`
	`1141`	`+ kAxisContinuousHoldThreshold;`
	`1142`	`+ const bool learning_active =`
	`1143`	`+ learn_active_.load(std::memory_order_acquire);`
	`1144`	`+ if (raw == prev && (!hold_active \|\| learning_active)) {`
`1136`	`1145`	`continue;`
`1137`	`1146`	`}`
`1138`	`1147`	`if (it != axis_last_trigger_.end() &&`
`@@ -1436,7 +1445,11 @@ void JoypadInputManager::PollLoop()`
`1436`	`1445`	`if (init_only) {`
`1437`	`1446`	`return;`
`1438`	`1447`	`}`
`1439`		`- if (raw == prev) {`
	`1448`	`+ const bool hold_active = std::fabs(norm) >=`
	`1449`	`+ kAxisContinuousHoldThreshold;`
	`1450`	`+ const bool learning_active =`
	`1451`	`+ self->learn_active_.load(std::memory_order_acquire);`
	`1452`	`+ if (raw == prev && (!hold_active \|\| learning_active)) {`
`1440`	`1453`	`return;`
`1441`	`1454`	`}`
`1442`	`1455`	`if (it != self->axis_last_trigger_.end() &&`
`@@ -1510,6 +1523,7 @@ void JoypadInputManager::DispatchEvent(const JoypadEvent &event)`
`1510`	`1523`	`}`
`1511`	`1524`	`if (learn_handler_) {`
`1512`	`1525`	`learn_handler_ = nullptr;`
	`1526`	`+ learn_active_.store(false, std::memory_order_release);`
`1513`	`1527`	`}`
`1514`	`1528`	`}`
`1515`	`1529`
`@@ -1543,6 +1557,7 @@ void JoypadInputManager::DispatchAxisAbsolute(const JoypadEvent &event)`
`1543`	`1557`	`}`
`1544`	`1558`	`if (learn_handler_) {`
`1545`	`1559`	`learn_handler_ = nullptr;`
	`1560`	`+ learn_active_.store(false, std::memory_order_release);`
`1546`	`1561`	`}`
`1547`	`1562`	`}`
`1548`	`1563`	`if (learn_handler) {`