Display Mod Encoder Values with Popup, Update Value Ranges in Menu's, Update Midi CC Value Range, Bug Fix for Midi CC Assignment in Automation Overview

docs/community_features.md

@@ -38,6 +38,12 @@ Here is a list of general improvements that have been made, ordered from newest
 #### 3.7 - Mod Wheel
 - ([#512]) Incoming mod wheel on non-MPE synths now maps to y axis
 
+#### 3.8 - Visual Feedback on Value Changes with Mod Encoders and Increased Resolution for Value's in Menu's
+- ([#636]) Changing parameter values with Mod (Gold) Encoders now displays a pop-up with the current value of the Parameter. The Menu's for Parameters and Patch Cables have also been adjusted to show the same value range as displayed with the Mod Encoders.
+	- This allows for better fine-tuning of values. 
+	- The value range displayed is 0-128 for non-MIDI parameters and 0-127 for MIDI parameters.
+	- Note: In the Menu, if you wish to scroll through the parameter value range faster at an accelerated rate of +/- 5, hold Shift while turning the Select Encoder.
+
 ## 4. New Features Added
 
 Here is a list of features that have been added to the firmware as a list, grouped by category:
@@ -390,4 +396,5 @@ This list includes all preprocessor switches that can alter firmware behaviour a
 [#368]: https://github.com/SynthstromAudible/DelugeFirmware/pull/368
 [#395]: https://github.com/SynthstromAudible/DelugeFirmware/pull/395
 [#512]: https://github.com/SynthstromAudible/DelugeFirmware/pull/512
+[#636]: https://github.com/SynthstromAudible/DelugeFirmware/pull/636
 [Automation View Documentation]: https://github.com/SynthstromAudible/DelugeFirmware/blob/release/1.0/docs/features/automation_view.md

src/definitions_cxx.hpp

@@ -356,7 +356,23 @@ constexpr int32_t kNumPatchSources = static_cast<int32_t>(kLastPatchSource);
 constexpr PatchSource kFirstLocalSource = PatchSource::ENVELOPE_0;
 //constexpr PatchSource kFirstUnchangeableSource = PatchSource::VELOCITY;
 
-//Automation Instrument Clip View constants
+//Menu Min Max Values
+
+//regular menu range e.g. 0 - 50 or 0 - 128
+constexpr int32_t kMaxMenuValue = 128;
+constexpr int32_t kMinMenuValue = 0;
+constexpr int32_t kMidMenuValue = kMinMenuValue + ((kMaxMenuValue - kMinMenuValue) / 2);
+
+//pan menu range e.g. -32 to +32 or -64 to +64
+constexpr int32_t kMaxMenuPanValue = kMaxMenuValue / 2;
+constexpr int32_t kMinMenuPanValue = -1 * kMaxMenuPanValue;
+
+//patch cable menu range e.g. -50 to 50 or -128 to +128
+constexpr int32_t kMaxMenuPatchCableValue = kMaxMenuValue * 100;
+constexpr int32_t kMinMenuPatchCableValue = -1 * kMaxMenuPatchCableValue;
+//
+
+//Automation View constants
 constexpr int32_t kNoSelection = 255;
 constexpr int32_t kNumNonKitAffectEntireParamsForAutomation = 55;
 constexpr int32_t kNumKitAffectEntireParamsForAutomation = 24;

src/deluge/gui/menu_item/arpeggiator/midi_cv/gate.h

@@ -27,13 +27,13 @@ class Gate final : public Integer {
 	void readCurrentValue() override {
 		auto* current_clip = static_cast<InstrumentClip*>(currentSong->currentClip);
 		int64_t arp_gate = (int64_t)current_clip->arpeggiatorGate + 2147483648;
-		this->setValue((arp_gate * 50 + 2147483648) >> 32);
+		this->setValue((arp_gate * kMaxMenuValue + 2147483648) >> 32);
 	}
 	void writeCurrentValue() override {
 		(static_cast<InstrumentClip*>(currentSong->currentClip))->arpeggiatorGate =
 		    (uint32_t)this->getValue() * 85899345 - 2147483648;
 	}
-	[[nodiscard]] int32_t getMaxValue() const override { return 50; }
+	[[nodiscard]] int32_t getMaxValue() const override { return kMaxMenuValue; }
 	bool isRelevant(Sound* sound, int32_t whichThing) override { return soundEditor.editingCVOrMIDIClip(); }
 };
 } // namespace deluge::gui::menu_item::arpeggiator::midi_cv

src/deluge/gui/menu_item/arpeggiator/midi_cv/rate.h

@@ -26,20 +26,21 @@ class Rate final : public Integer {
 	using Integer::Integer;
 	void readCurrentValue() override {
 		this->setValue(
-		    (((int64_t)(static_cast<InstrumentClip*>(currentSong->currentClip))->arpeggiatorRate + 2147483648) * 50
+		    (((int64_t)(static_cast<InstrumentClip*>(currentSong->currentClip))->arpeggiatorRate + 2147483648)
+		         * kMaxMenuValue
 		     + 2147483648)
 		    >> 32);
 	}
 	void writeCurrentValue() override {
-		if (this->getValue() == 25) {
+		if (this->getValue() == kMidMenuValue) {
 			(static_cast<InstrumentClip*>(currentSong->currentClip))->arpeggiatorRate = 0;
 		}
 		else {
 			(static_cast<InstrumentClip*>(currentSong->currentClip))->arpeggiatorRate =
 			    (uint32_t)this->getValue() * 85899345 - 2147483648;
 		}
 	}
-	[[nodiscard]] int32_t getMaxValue() const override { return 50; }
+	[[nodiscard]] int32_t getMaxValue() const override { return kMaxMenuValue; }
 	bool isRelevant(Sound* sound, int32_t whichThing) override { return soundEditor.editingCVOrMIDIClip(); }
 };
 } // namespace deluge::gui::menu_item::arpeggiator::midi_cv

src/deluge/gui/menu_item/audio_clip/attack.h

@@ -27,13 +27,14 @@ class Attack final : public Integer {
 
 	void readCurrentValue() override {
 		this->setValue(
-		    (((int64_t)(static_cast<AudioClip*>(currentSong->currentClip))->attack + 2147483648) * 50 + 2147483648)
+		    (((int64_t)(static_cast<AudioClip*>(currentSong->currentClip))->attack + 2147483648) * kMaxMenuValue
+		     + 2147483648)
 		    >> 32);
 	}
 	void writeCurrentValue() override {
 		(static_cast<AudioClip*>(currentSong->currentClip))->attack =
 		    (uint32_t)this->getValue() * 85899345 - 2147483648;
 	}
-	[[nodiscard]] int32_t getMaxValue() const override { return 50; }
+	[[nodiscard]] int32_t getMaxValue() const override { return kMaxMenuValue; }
 };
 } // namespace deluge::gui::menu_item::audio_clip

src/deluge/gui/menu_item/audio_clip/hpf_freq.h

@@ -25,7 +25,7 @@ class HPFFreq final : public UnpatchedParam {
 
 	// 7SEG ONLY
 	void drawValue() override {
-		if (this->getValue() == 0) {
+		if (this->getValue() == kMinMenuValue) {
 			display->setText(l10n::get(l10n::String::STRING_FOR_DISABLED));
 		}
 		else {

src/deluge/gui/menu_item/audio_clip/lpf_freq.h

@@ -25,7 +25,7 @@ class LPFFreq final : public UnpatchedParam {
 
 	// 7Seg ONLY
 	void drawValue() override {
-		if (this->getValue() == 50) {
+		if (this->getValue() == kMaxMenuValue) {
 			display->setText(l10n::get(l10n::String::STRING_FOR_DISABLED));
 		}
 		else {

src/deluge/gui/menu_item/filter/hpf_freq.h

@@ -27,7 +27,7 @@ class HPFFreq final : public patched_param::IntegerNonFM {
 
 	// 7Seg ONLY
 	void drawValue() override {
-		if (this->getValue() == 0
+		if (this->getValue() == kMinMenuValue
 		    && !soundEditor.currentParamManager->getPatchCableSet()->doesParamHaveSomethingPatchedToIt(
 		        ::Param::Local::HPF_FREQ)) {
 			display->setText(l10n::get(l10n::String::STRING_FOR_DISABLED));

src/deluge/gui/menu_item/filter/lpf_freq.h

@@ -26,7 +26,7 @@ class LPFFreq final : public patched_param::IntegerNonFM {
 
 	// 7Seg ONLY
 	void drawValue() override {
-		if (this->getValue() == 50
+		if (this->getValue() == kMaxMenuValue
 		    && !soundEditor.currentParamManager->getPatchCableSet()->doesParamHaveSomethingPatchedToIt(
 		        ::Param::Local::LPF_FREQ)) {
 			display->setText(l10n::get(l10n::String::STRING_FOR_DISABLED));

src/deluge/gui/menu_item/midi/default_velocity_to_level.h

@@ -24,12 +24,13 @@ namespace deluge::gui::menu_item::midi {
 class DefaultVelocityToLevel final : public IntegerWithOff {
 public:
 	using IntegerWithOff::IntegerWithOff;
-	[[nodiscard]] int32_t getMaxValue() const override { return 50; }
+	[[nodiscard]] int32_t getMaxValue() const override { return kMaxMenuValue; }
 	void readCurrentValue() override {
-		this->setValue(((int64_t)soundEditor.currentMIDIDevice->defaultVelocityToLevel * 50 + 536870912) >> 30);
+		this->setValue(((int64_t)soundEditor.currentMIDIDevice->defaultVelocityToLevel * kMaxMenuValue + 536870912)
+		               >> 30);
 	}
 	void writeCurrentValue() override {
-		soundEditor.currentMIDIDevice->defaultVelocityToLevel = this->getValue() * 21474836;
+		soundEditor.currentMIDIDevice->defaultVelocityToLevel = this->getValue() * (2147483648 / (kMaxMenuValue * 2));
 		currentSong->grabVelocityToLevelFromMIDIDeviceAndSetupPatchingForEverything(soundEditor.currentMIDIDevice);
 		MIDIDeviceManager::anyChangesToSave = true;
 	}

src/deluge/gui/menu_item/osc/pulse_width.h

@@ -29,11 +29,22 @@ class PulseWidth final : public menu_item::source::PatchedParam, public Formatte
 
 	[[nodiscard]] std::string_view getTitle() const override { return FormattedTitle::title(); }
 
-	int32_t getFinalValue() override { return (uint32_t)this->getValue() * (85899345 >> 1); }
+	int32_t getFinalValue() override {
+		if (this->getValue() == kMaxMenuValue) {
+			return 2147483647;
+		}
+		else if (this->getValue() == kMinMenuValue) {
+			return 0;
+		}
+		else {
+			return (uint32_t)this->getValue() * (2147483648 / kMidMenuValue) >> 1;
+		}
+	}
 
 	void readCurrentValue() override {
 		this->setValue(
-		    ((int64_t)soundEditor.currentParamManager->getPatchedParamSet()->getValue(getP()) * 100 + 2147483648)
+		    ((int64_t)soundEditor.currentParamManager->getPatchedParamSet()->getValue(getP()) * (kMaxMenuValue * 2)
+		     + 2147483648)
 		    >> 32);
 	}
 

src/deluge/gui/menu_item/param.h

@@ -28,8 +28,8 @@ namespace deluge::gui::menu_item {
 class Param {
 public:
 	Param(int32_t newP = 0) : p(newP) {}
-	[[nodiscard]] virtual int32_t getMaxValue() const { return 50; }
-	[[nodiscard]] virtual int32_t getMinValue() const { return 0; }
+	[[nodiscard]] virtual int32_t getMaxValue() const { return kMaxMenuValue; }
+	[[nodiscard]] virtual int32_t getMinValue() const { return kMinMenuValue; }
 	virtual uint8_t getP() { return p; };
 	MenuItem* selectButtonPress();
 	virtual ModelStackWithAutoParam* getModelStack(void* memory) = 0;

src/deluge/gui/menu_item/patch_cable_strength.cpp

@@ -112,7 +112,7 @@ void PatchCableStrength::renderOLED() {
 
 	char buffer[12];
 	if (preferBarDrawing) {
-		int32_t rounded = (this->getValue() + 50 * (this->getValue() > 0 ? 1 : -1)) / 100;
+		int32_t rounded = this->getValue() / 100;
 		intToString(rounded, buffer, 1);
 		deluge::hid::display::OLED::drawStringAlignRight(
 		    buffer, extraY + OLED_MAIN_TOPMOST_PIXEL + 4 + destinationDescriptor.isJustAParam(),
@@ -152,7 +152,7 @@ void PatchCableStrength::readCurrentValue() {
 		int32_t paramValue = patchCableSet->patchCables[c].param.getCurrentValue();
 		// the internal values are stored in the range -(2^30) to 2^30.
 		// rescale them to the range -5000 to 5000 and round to nearest.
-		this->setValue(((int64_t)paramValue * 5000 + (1 << 29)) >> 30);
+		this->setValue(((int64_t)paramValue * kMaxMenuPatchCableValue + (1 << 29)) >> 30);
 	}
 }
 
@@ -175,8 +175,9 @@ void PatchCableStrength::writeCurrentValue() {
 		return;
 	}
 
-	// rescale from 5000 to 2**30. The magic constant is ((2^30)/5000), shifted 32 bits for precision ((1<<(30+32))/5000)
-	int32_t finalValue = ((int64_t)922337203685477 * this->getValue()) >> 32;
+	//rescale from 5000 to 2^30. The magic constant is ((2^30)/5000), shifted 32 bits for precision ((1<<(30+32))/5000)
+	int64_t magicConstant = (922337203685477 * 5000) / kMaxMenuPatchCableValue;
+	int32_t finalValue = (magicConstant * this->getValue()) >> 32;
 	modelStackWithParam->autoParam->setCurrentValueInResponseToUserInput(finalValue, modelStackWithParam);
 }
 

src/deluge/gui/menu_item/patch_cable_strength.h

@@ -27,8 +27,8 @@ class PatchCableStrength : public Decimal, public MenuItemWithCCLearning {
 	void beginSession(MenuItem* navigatedBackwardFrom) final;
 	void readCurrentValue() final;
 	void writeCurrentValue() override;
-	[[nodiscard]] int32_t getMinValue() const final { return -5000; }
-	[[nodiscard]] int32_t getMaxValue() const final { return 5000; }
+	[[nodiscard]] int32_t getMinValue() const final { return kMinMenuPatchCableValue; }
+	[[nodiscard]] int32_t getMaxValue() const final { return kMaxMenuPatchCableValue; }
 	[[nodiscard]] int32_t getNumDecimalPlaces() const final { return 2; }
 	virtual int32_t getDefaultEditPos() { return 2; }
 	MenuPermission checkPermissionToBeginSession(Sound* sound, int32_t whichThing, MultiRange** currentRange) override;

src/deluge/gui/menu_item/patch_cables.cpp

@@ -79,7 +79,7 @@ void PatchCables::renderOptions() {
 		}
 
 		int32_t param_value = cable->param.getCurrentValue();
-		int32_t level = ((int64_t)param_value * 5000 + (1 << 29)) >> 30;
+		int32_t level = ((int64_t)param_value * kMaxMenuPatchCableValue + (1 << 29)) >> 30;
 
 		floatToString((float)level / 100, buf + off + 5, 2, 2);
 		//fmt::vformat_to_n(buf + off + 5, 5, "{:4}", fmt::make_format_args();

src/deluge/gui/menu_item/patched_param/integer.cpp

@@ -21,9 +21,10 @@
 
 namespace deluge::gui::menu_item::patched_param {
 void Integer::readCurrentValue() {
-	this->setValue((((int64_t)soundEditor.currentParamManager->getPatchedParamSet()->getValue(getP()) + 2147483648) * 50
-	                + 2147483648)
-	               >> 32);
+	this->setValue(
+	    (((int64_t)soundEditor.currentParamManager->getPatchedParamSet()->getValue(getP()) + 2147483648) * kMaxMenuValue
+	     + 2147483648)
+	    >> 32);
 }
 
 void Integer::writeCurrentValue() {
@@ -35,10 +36,15 @@ void Integer::writeCurrentValue() {
 }
 
 int32_t Integer::getFinalValue() {
-	if (this->getValue() == 25) {
-		return 0;
+	if (this->getValue() == kMaxMenuValue) {
+		return 2147483647;
+	}
+	else if (this->getValue() == kMinMenuValue) {
+		return -2147483648;
+	}
+	else {
+		return (uint32_t)this->getValue() * (2147483648 / kMidMenuValue) - 2147483648;
 	}
-	return (uint32_t)this->getValue() * 85899345 - 2147483648;
 }
 
 } // namespace deluge::gui::menu_item::patched_param

src/deluge/gui/menu_item/patched_param/pan.cpp

@@ -47,17 +47,21 @@ void Pan::drawValue() {
 }
 
 int32_t Pan::getFinalValue() {
-	if (this->getValue() == 32) {
+	if (this->getValue() == kMaxMenuPanValue) {
 		return 2147483647;
 	}
-	if (this->getValue() == -32) {
+	else if (this->getValue() == kMinMenuPanValue) {
 		return -2147483648;
 	}
-	return ((int32_t)this->getValue() * 33554432 * 2);
+	else {
+		return ((int32_t)this->getValue() * (2147483648 / (kMaxMenuPanValue * 2)) * 2);
+	}
 }
 
 void Pan::readCurrentValue() {
-	this->setValue(((int64_t)soundEditor.currentParamManager->getPatchedParamSet()->getValue(getP()) * 64 + 2147483648)
-	               >> 32);
+	this->setValue(
+	    ((int64_t)soundEditor.currentParamManager->getPatchedParamSet()->getValue(getP()) * (kMaxMenuPanValue * 2)
+	     + 2147483648)
+	    >> 32);
 }
 } // namespace deluge::gui::menu_item::patched_param

src/deluge/gui/menu_item/patched_param/pan.h

@@ -24,8 +24,8 @@ class Pan : public Integer {
 	void drawValue() override;
 
 protected:
-	[[nodiscard]] int32_t getMaxValue() const override { return 32; }
-	[[nodiscard]] int32_t getMinValue() const override { return -32; }
+	[[nodiscard]] int32_t getMaxValue() const override { return kMaxMenuPanValue; }
+	[[nodiscard]] int32_t getMinValue() const override { return kMinMenuPanValue; }
 	int32_t getFinalValue() override;
 	void readCurrentValue() override;
 };

src/deluge/gui/menu_item/reverb/compressor/shape.h

@@ -26,13 +26,13 @@ class Shape final : public Integer {
 public:
 	using Integer::Integer;
 	void readCurrentValue() override {
-		this->setValue((((int64_t)AudioEngine::reverbCompressorShape + 2147483648) * 50 + 2147483648) >> 32);
+		this->setValue((((int64_t)AudioEngine::reverbCompressorShape + 2147483648) * kMaxMenuValue + 2147483648) >> 32);
 	}
 	void writeCurrentValue() override {
 		AudioEngine::reverbCompressorShape = (uint32_t)this->getValue() * 85899345 - 2147483648;
 		AudioEngine::mustUpdateReverbParamsBeforeNextRender = true;
 	}
-	[[nodiscard]] int32_t getMaxValue() const override { return 50; }
+	[[nodiscard]] int32_t getMaxValue() const override { return kMaxMenuValue; }
 	bool isRelevant(Sound* sound, int32_t whichThing) override { return (AudioEngine::reverbCompressorVolume >= 0); }
 };
 } // namespace deluge::gui::menu_item::reverb::compressor

src/deluge/gui/menu_item/reverb/compressor/volume.h

@@ -30,7 +30,7 @@ class Volume final : public Integer {
 		AudioEngine::reverbCompressorVolume = this->getValue() * 21474836;
 		AudioEngine::mustUpdateReverbParamsBeforeNextRender = true;
 	}
-	[[nodiscard]] int32_t getMaxValue() const override { return 50; }
+	[[nodiscard]] int32_t getMaxValue() const override { return kMaxMenuValue; }
 	[[nodiscard]] int32_t getMinValue() const override { return -1; }
 
 	void drawValue() override {

src/deluge/gui/menu_item/reverb/dampening.h

@@ -25,8 +25,8 @@ namespace deluge::gui::menu_item::reverb {
 class Dampening final : public Integer {
 public:
 	using Integer::Integer;
-	void readCurrentValue() override { this->setValue(std::round(AudioEngine::reverb.getdamp() * 50)); }
-	void writeCurrentValue() override { AudioEngine::reverb.setdamp((float)this->getValue() / 50); }
-	[[nodiscard]] int32_t getMaxValue() const override { return 50; }
+	void readCurrentValue() override { this->setValue(std::round(AudioEngine::reverb.getdamp() * kMaxMenuValue)); }
+	void writeCurrentValue() override { AudioEngine::reverb.setdamp((float)this->getValue() / kMaxMenuValue); }
+	[[nodiscard]] int32_t getMaxValue() const override { return kMaxMenuValue; }
 };
 } // namespace deluge::gui::menu_item::reverb

src/deluge/gui/menu_item/reverb/pan.h

@@ -43,8 +43,10 @@ class Pan final : public Integer {
 
 	void writeCurrentValue() override { AudioEngine::reverbPan = ((int32_t)this->getValue() * 33554432); }
 
-	void readCurrentValue() override { this->setValue(((int64_t)AudioEngine::reverbPan * 128 + 2147483648) >> 32); }
-	[[nodiscard]] int32_t getMaxValue() const override { return 32; }
-	[[nodiscard]] int32_t getMinValue() const override { return -32; }
+	void readCurrentValue() override {
+		this->setValue(((int64_t)AudioEngine::reverbPan * (kMaxMenuPanValue * 4) + 2147483648) >> 32);
+	}
+	[[nodiscard]] int32_t getMaxValue() const override { return kMaxMenuPanValue; }
+	[[nodiscard]] int32_t getMinValue() const override { return kMinMenuPanValue; }
 };
 } // namespace deluge::gui::menu_item::reverb

src/deluge/gui/menu_item/reverb/room_size.h

@@ -25,8 +25,8 @@ namespace deluge::gui::menu_item::reverb {
 class RoomSize final : public Integer {
 public:
 	using Integer::Integer;
-	void readCurrentValue() override { this->setValue(std::round(AudioEngine::reverb.getroomsize() * 50)); }
-	void writeCurrentValue() override { AudioEngine::reverb.setroomsize((float)this->getValue() / 50); }
-	[[nodiscard]] int32_t getMaxValue() const override { return 50; }
+	void readCurrentValue() override { this->setValue(std::round(AudioEngine::reverb.getroomsize() * kMaxMenuValue)); }
+	void writeCurrentValue() override { AudioEngine::reverb.setroomsize((float)this->getValue() / kMaxMenuValue); }
+	[[nodiscard]] int32_t getMaxValue() const override { return kMaxMenuValue; }
 };
 } // namespace deluge::gui::menu_item::reverb

src/deluge/gui/menu_item/reverb/width.h

@@ -25,8 +25,8 @@ namespace deluge::gui::menu_item::reverb {
 class Width final : public Integer {
 public:
 	using Integer::Integer;
-	void readCurrentValue() override { this->setValue(std::round(AudioEngine::reverb.getwidth() * 50)); }
-	void writeCurrentValue() override { AudioEngine::reverb.setwidth((float)this->getValue() / 50); }
-	[[nodiscard]] int32_t getMaxValue() const override { return 50; }
+	void readCurrentValue() override { this->setValue(std::round(AudioEngine::reverb.getwidth() * kMaxMenuValue)); }
+	void writeCurrentValue() override { AudioEngine::reverb.setwidth((float)this->getValue() / kMaxMenuValue); }
+	[[nodiscard]] int32_t getMaxValue() const override { return kMaxMenuValue; }
 };
 } // namespace deluge::gui::menu_item::reverb