trnr/tlib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove old triplex classes

Browse Source
This commit is contained in:
Chris
2025-10-13 17:30:40 +02:00
parent f4502eb699
commit 6fb32fbcf6
5 changed files with 0 additions and 870 deletions
Download Patch File Download Diff File Expand all files Collapse all files

239
synth/tx_envelope.h
View File

@@ -1,239 +0,0 @@
#pragma once
#include <array>
#include <cmath>
namespace trnr {
enum env_state {
idle = 0,
attack1,
attack2,
hold,
decay1,
decay2,
sustain,
release1,
release2
};
class tx_envelope {
public:
env_state state = idle;
float attack1_rate = 0;
float attack1_level = 0;
float attack2_rate = 0;
float hold_rate = 0;
float decay1_rate = 0;
float decay1_level = 0;
float decay2_rate = 0;
float sustain_level = 0;
float release1_rate = 0;
float release1_level = 0;
float release2_rate = 0;
bool skip_sustain = false;
tx_envelope(bool _retrigger = false)
: retrigger {_retrigger}
{
}
float process_sample(bool gate, bool trigger) { return process_sample<float>(gate, trigger, 0, 0); }
template <typename t_sample>
float process_sample(bool gate, bool trigger, t_sample _attack_mod, t_sample _decay_mod)
{
size_t attack_mid_x1 = ms_to_samples(attack1_rate + (float)_attack_mod);
size_t attack_mid_x2 = ms_to_samples(attack2_rate + (float)_attack_mod);
size_t hold_samp = ms_to_samples(hold_rate);
size_t decay_mid_x1 = ms_to_samples(decay1_rate + (float)_decay_mod);
size_t decay_mid_x2 = ms_to_samples(decay2_rate + (float)_decay_mod);
size_t release_mid_x1 = ms_to_samples(release1_rate + (float)_decay_mod);
size_t release_mid_x2 = ms_to_samples(release2_rate + (float)_decay_mod);
// if note on is triggered, transition to attack phase
if (trigger) {
if (retrigger) start_level = 0.f;
else start_level = level;
phase = 0;
state = attack1;
}
// attack 1st half
if (state == attack1) {
// while in attack phase
if (phase < attack_mid_x1) {
level = lerp(0, start_level, (float)attack_mid_x1, attack1_level, (float)phase);
phase += 1;
}
// reset phase if parameter was changed
if (phase > attack_mid_x1) { phase = attack_mid_x1; }
// if attack phase is done, transition to decay phase
if (phase == attack_mid_x1) {
state = attack2;
phase = 0;
}
}
// attack 2nd half
if (state == attack2) {
// while in attack phase
if (phase < attack_mid_x2) {
level = lerp(0, attack1_level, (float)attack_mid_x2, 1, (float)phase);
phase += 1;
}
// reset phase if parameter was changed
if (phase > attack_mid_x2) { phase = attack_mid_x2; }
// if attack phase is done, transition to decay phase
if (phase == attack_mid_x2) {
state = hold;
phase = 0;
}
}
// hold
if (state == hold) {
if (phase < hold_samp) {
level = 1.0;
phase += 1;
}
if (phase > hold_samp) { phase = hold_samp; }
if (phase == hold_samp) {
state = decay1;
phase = 0;
}
}
// decay 1st half
if (state == decay1) {
// while in decay phase
if (phase < decay_mid_x1) {
level = lerp(0, 1, (float)decay_mid_x1, decay1_level, (float)phase);
phase += 1;
}
// reset phase if parameter was changed
if (phase > decay_mid_x1) { phase = decay_mid_x1; }
// if decay phase is done, transition to sustain phase
if (phase == decay_mid_x1) {
state = decay2;
phase = 0;
}
}
// decay 2nd half
if (state == decay2) {
// while in decay phase
if (phase < decay_mid_x2) {
level = lerp(0, decay1_level, (float)decay_mid_x2, sustain_level, (float)phase);
phase += 1;
}
// reset phase if parameter was changed
if (phase > decay_mid_x2) { phase = decay_mid_x2; }
// if decay phase is done, transition to sustain phase
if (phase == decay_mid_x2) {
state = sustain;
phase = 0;
level = sustain_level;
}
}
// while sustain phase: if note off is triggered, transition to release phase
if (state == sustain && (!gate || skip_sustain)) {
state = release1;
level = sustain_level;
}
// release 1st half
if (state == release1) {
// while in release phase
if (phase < release_mid_x1) {
level = lerp(0, sustain_level, (float)release_mid_x1, release1_level, (float)phase);
phase += 1;
}
// reset phase if parameter was changed
if (phase > release_mid_x1) { phase = release_mid_x1; }
// transition to 2nd release half
if (phase == release_mid_x1) {
phase = 0;
state = release2;
}
}
// release 2nd half
if (state == release2) {
// while in release phase
if (phase < release_mid_x2) {
level = lerp(0, release1_level, (float)release_mid_x2, 0, (float)phase);
phase += 1;
}
// reset phase if parameter was changed
if (phase > release_mid_x2) { phase = release_mid_x2; }
// reset
if (phase == release_mid_x2) {
phase = 0;
state = idle;
level = 0;
}
}
return smooth(level);
}
bool is_busy() { return state != 0; }
void set_samplerate(double sampleRate) { this->samplerate = sampleRate; }
// converts the x/y coordinates of the envelope points as a list for graphical representation.
std::array<float, 18> calc_coordinates(float _max_attack, float _max_decay, float _max_release)
{
auto scale = [](float _value, float _max) { return powf(_value / _max, 0.25) * _max; };
float a_x = 0;
float a_y = 0;
float b_x = scale(attack1_rate, _max_attack / 2);
float b_y = attack1_level;
float c_x = b_x + scale(attack2_rate, _max_attack / 2);
float c_y = 1;
float d_x = c_x + hold_rate;
float d_y = 1;
float e_x = d_x + scale(decay1_rate, _max_decay / 2);
float e_y = decay1_level;
float f_x = e_x + scale(decay2_rate, _max_decay / 2);
float f_y = sustain_level;
float g_x = _max_attack + _max_decay;
float g_y = sustain_level;
float h_x = g_x + scale(release1_rate, _max_decay / 2);
float h_y = release1_level;
float i_x = h_x + scale(release2_rate, _max_decay / 2);
float i_y = 0;
float total = _max_attack + _max_decay + _max_release;
return {a_x, a_y, b_x / total, b_y, c_x / total, c_y, d_x / total, d_y, e_x / total, e_y,
f_x / total, f_y, g_x / total, g_y, h_x / total, h_y, i_x / total, i_y};
}
private:
double samplerate = 44100.;
size_t phase = 0;
float level = 0.f;
float start_level = 0.f;
float h1 = 0.f;
float h2 = 0.f;
float h3 = 0.f;
bool retrigger;
float lerp(float x1, float y1, float x2, float y2, float x) { return y1 + (((x - x1) * (y2 - y1)) / (x2 - x1)); }
float smooth(float sample)
{
h3 = h2;
h2 = h1;
h1 = sample;
return (h1 + h2 + h3) / 3.f;
}
size_t ms_to_samples(float ms) { return static_cast<size_t>(ms * samplerate / 1000.f); }
};
} // namespace trnr

40
synth/tx_operator.h
View File

@@ -1,40 +0,0 @@
#pragma once
#include "tx_envelope.h"
#include "tx_sineosc.h"
namespace trnr {
class tx_operator {
public:
tx_operator()
: ratio {1}
, amplitude {1.0f}
{
}
tx_envelope envelope;
tx_sineosc oscillator;
float ratio;
float amplitude;
float process_sample(const bool& gate, const bool& trigger, const float& frequency, const float& velocity,
const float& pm = 0)
{
float env = envelope.process_sample(gate, trigger);
// drifts and sounds better!
if (envelope.is_busy()) {
double osc = oscillator.process_sample(trigger, frequency, pm);
return osc * env * velocity;
} else {
return 0.;
}
}
void set_samplerate(double samplerate)
{
this->envelope.set_samplerate(samplerate);
this->oscillator.set_samplerate(samplerate);
}
};
} // namespace trnr

89
synth/tx_parameter_mapping.h
View File

@@ -1,89 +0,0 @@
#include <cmath>
namespace trnr {
enum tx_parameter {
BIT_RESOLUTION = 0,
FEEDBACKOSC_PHASE_RESOLUTION,
FEEDBACK,
ALGORITHM,
PITCH_ENVELOPE_AMOUNT,
PITCH_ENVELOPE_SKIP_SUSTAIN,
PITCH_ENVELOPE_ATTACK1_RATE,
PITCH_ENVELOPE_ATTACK1_LEVEL,
PITCH_ENVELOPE_ATTACK2_RATE,
PITCH_ENVELOPE_HOLD_RATE,
PITCH_ENVELOPE_DECAY1_RATE,
PITCH_ENVELOPE_DECAY1_LEVEL,
PITCH_ENVELOPE_DECAY2_RATE,
PITCH_ENVELOPE_SUSTAIN_LEVEL,
PITCH_ENVELOPE_RELEASE1_RATE,
PITCH_ENVELOPE_RELEASE1_LEVEL,
PITCH_ENVELOPE_RELEASE2_RATE,
OP1_RATIO,
OP1_AMPLITUDE,
OP1_PHASE_RESOLUTION,
OP1_ENVELOPE_SKIP_SUSTAIN,
OP1_ENVELOPE_ATTACK1_RATE,
OP1_ENVELOPE_ATTACK1_LEVEL,
OP1_ENVELOPE_ATTACK2_RATE,
OP1_ENVELOPE_HOLD_RATE,
OP1_ENVELOPE_DECAY1_RATE,
OP1_ENVELOPE_DECAY1_LEVEL,
OP1_ENVELOPE_DECAY2_RATE,
OP1_ENVELOPE_SUSTAIN_LEVEL,
OP1_ENVELOPE_RELEASE1_RATE,
OP1_ENVELOPE_RELEASE1_LEVEL,
OP1_ENVELOPE_RELEASE2_RATE,
OP2_RATIO,
OP2_AMPLITUDE,
OP2_PHASE_RESOLUTION,
OP2_ENVELOPE_SKIP_SUSTAIN,
OP2_ENVELOPE_ATTACK1_RATE,
OP2_ENVELOPE_ATTACK1_LEVEL,
OP2_ENVELOPE_ATTACK2_RATE,
OP2_ENVELOPE_HOLD_RATE,
OP2_ENVELOPE_DECAY1_RATE,
OP2_ENVELOPE_DECAY1_LEVEL,
OP2_ENVELOPE_DECAY2_RATE,
OP2_ENVELOPE_SUSTAIN_LEVEL,
OP2_ENVELOPE_RELEASE1_RATE,
OP2_ENVELOPE_RELEASE1_LEVEL,
OP2_ENVELOPE_RELEASE2_RATE,
OP3_RATIO,
OP3_AMPLITUDE,
OP3_PHASE_RESOLUTION,
OP3_ENVELOPE_SKIP_SUSTAIN,
OP3_ENVELOPE_ATTACK1_RATE,
OP3_ENVELOPE_ATTACK1_LEVEL,
OP3_ENVELOPE_ATTACK2_RATE,
OP3_ENVELOPE_HOLD_RATE,
OP3_ENVELOPE_DECAY1_RATE,
OP3_ENVELOPE_DECAY1_LEVEL,
OP3_ENVELOPE_DECAY2_RATE,
OP3_ENVELOPE_SUSTAIN_LEVEL,
OP3_ENVELOPE_RELEASE1_RATE,
OP3_ENVELOPE_RELEASE1_LEVEL,
OP3_ENVELOPE_RELEASE2_RATE,
};
struct tx_parameter_mapping {
float range_min;
float range_max;
float exponent;
tx_parameter parameter;
tx_parameter_mapping(float _range_min, float _range_max, float _exponent, tx_parameter _parameter)
: range_min(_range_min), range_max(_range_max), exponent(_exponent), parameter(_parameter)
{}
float apply(float _input) const
{
if (range_min == range_max && exponent == 1.f) return _input;
return powf(_input, exponent) * (range_max - range_min) + range_min;
}
};
}

101
synth/tx_sineosc.h
View File

@@ -1,101 +0,0 @@
#pragma once
#include <cmath>
#include <random>
namespace trnr {
class tx_sineosc {
public:
bool phase_reset;
tx_sineosc()
: samplerate {44100}
, phase_resolution {16.f}
, phase {0.}
, history {0.}
, phase_reset {false}
{
randomize_phase();
}
void set_phase_resolution(float res) { phase_resolution = powf(2, res); }
float process_sample(bool trigger, float frequency, float phase_modulation = 0.f)
{
if (trigger) {
if (phase_reset) phase = 0.f;
else randomize_phase();
}
float lookup_phase = phase + phase_modulation;
wrap(lookup_phase);
phase += frequency / samplerate;
wrap(phase);
redux(lookup_phase);
float output = sine(lookup_phase * 4096.);
filter(output);
return output;
}
void set_samplerate(double _samplerate) { this->samplerate = _samplerate; }
void randomize_phase()
{
std::random_device random;
std::mt19937 gen(random());
std::uniform_real_distribution<> dis(0.0, 1.0);
phase = dis(gen);
}
private:
double samplerate;
float phase_resolution;
float phase;
float history;
float sine(float x)
{
// x is scaled 0<=x<4096
const float a = -0.40319426317E-08;
const float b = 0.21683205691E+03;
const float c = 0.28463350538E-04;
const float d = -0.30774648337E-02;
float y;
bool negate = false;
if (x > 2048) {
negate = true;
x -= 2048;
}
if (x > 1024) x = 2048 - x;
y = (a + x) / (b + c * x * x) + d * x;
if (negate) return (float)(-y);
else return (float)y;
}
float wrap(float& phase)
{
while (phase < 0.) phase += 1.;
while (phase >= 1.) phase -= 1.;
return phase;
}
float filter(float& value)
{
value = 0.5 * (value + history);
history = value;
return value;
}
float redux(float& value)
{
value = static_cast<int>(value * phase_resolution) / phase_resolution;
return value;
}
};
} // namespace trnr

401
synth/tx_voice.h
View File

@@ -1,401 +0,0 @@
#pragma once
#include "../util/audio_math.h"
#include "audio_buffer.h"
#include "ivoice.h"
#include "tx_envelope.h"
#include "tx_operator.h"
#include "tx_parameter_mapping.h"
#include "tx_sineosc.h"
#include <vector>
namespace trnr {
template <typename t_sample>
class tx_voice : public ivoice<t_sample> {
public:
tx_voice()
: algorithm {0}
, pitch_env_amt {0.f}
, feedback_amt {0.f}
, bit_resolution(12.f)
{
}
bool gate = false;
bool trigger = false;
int midi_note = 0;
float velocity = 1.f;
float additional_pitch_mod = 0.f; // modulates pitch in frequency
int algorithm;
float pitch_env_amt;
float feedback_amt;
float bit_resolution;
tx_sineosc feedback_osc;
tx_envelope pitch_env;
tx_operator op1;
tx_operator op2;
tx_operator op3;
void note_on(int _note, float _velocity) override
{
this->gate = true;
this->trigger = true;
midi_note = _note;
velocity = _velocity;
}
void note_off() override { this->gate = false; }
// modulates the pitch in semitones
void modulate_pitch(float _pitch) override { this->pitch_mod = _pitch; }
void process_samples(t_sample** _outputs, int _start_index, int _block_size,
std::vector<audio_buffer<t_sample>> _modulators = {}) override
{
float frequency = midi_to_frequency(midi_note + pitch_mod + additional_pitch_mod);
for (int s = _start_index; s < _start_index + _block_size; s++) {
float pitch_env_signal = pitch_env.process_sample(gate, trigger) * pitch_env_amt;
float pitched_freq = frequency + pitch_env_signal;
float output = 0.f;
// mix operator signals according to selected algorithm
switch (algorithm) {
case 0:
output = calc_algo1(pitched_freq);
break;
case 1:
output = calc_algo2(pitched_freq);
break;
case 2:
output = calc_algo3(pitched_freq);
break;
case 3:
output = calc_algo4(pitched_freq);
break;
default:
output = calc_algo1(pitched_freq);
break;
}
// reset trigger
trigger = false;
redux(output, bit_resolution);
_outputs[0][s] += output / 3.;
_outputs[1][s] = _outputs[0][s];
}
}
bool is_busy() override
{
return gate || op1.envelope.is_busy() || op2.envelope.is_busy() || op3.envelope.is_busy();
}
void set_samplerate(double samplerate) override
{
pitch_env.set_samplerate(samplerate);
feedback_osc.set_samplerate(samplerate);
op1.set_samplerate(samplerate);
op2.set_samplerate(samplerate);
op3.set_samplerate(samplerate);
}
void set_phase_reset(bool phase_reset)
{
op1.oscillator.phase_reset = phase_reset;
op2.oscillator.phase_reset = phase_reset;
op3.oscillator.phase_reset = phase_reset;
feedback_osc.phase_reset = phase_reset;
}
void update_parameters(float _value, const std::vector<tx_parameter_mapping>& _mappings)
{
for (const tx_parameter_mapping& mapping : _mappings) {
float normalized = mapping.apply(_value);
map_parameter(mapping, normalized);
}
}
private:
const float MOD_INDEX_COEFF = 4.f;
float pitch_mod = 0.f; // modulates pitch in semi-tones
float calc_algo1(const float frequency)
{
float fb_freq = frequency * op3.ratio;
float fb_mod_index = (feedback_amt * MOD_INDEX_COEFF);
float fb_signal = feedback_osc.process_sample(trigger, fb_freq) * fb_mod_index;
float op3_Freq = frequency * op3.ratio;
float op3_mod_index = (op3.amplitude * MOD_INDEX_COEFF);
float op3_signal = op3.process_sample(gate, trigger, op3_Freq, velocity, fb_signal) * op3_mod_index;
float op2_freq = frequency * op2.ratio;
float op2_mod_index = (op2.amplitude * MOD_INDEX_COEFF);
float op2_signal = op2.process_sample(gate, trigger, op2_freq, velocity, op3_signal) * op2_mod_index;
float op1_freq = frequency * op1.ratio;
return op1.process_sample(gate, trigger, op1_freq, velocity, op2_signal) * op1.amplitude;
}
float calc_algo2(const float frequency)
{
float fb_freq = frequency * op3.ratio;
float fb_mod_index = (feedback_amt * MOD_INDEX_COEFF);
float fb_signal = feedback_osc.process_sample(trigger, fb_freq) * fb_mod_index;
float op3_freq = frequency * op3.ratio;
float op3_signal = op3.process_sample(gate, trigger, op3_freq, velocity, fb_signal) * op3.amplitude;
float op2_freq = frequency * op2.ratio;
float op2_mod_index = (op2.amplitude * MOD_INDEX_COEFF);
float op2_signal = op2.process_sample(gate, trigger, op2_freq, velocity) * op2_mod_index;
float op1_freq = frequency * op1.ratio;
float op1_signal = op1.process_sample(gate, trigger, op1_freq, velocity, op2_signal) * op1.amplitude;
return op1_signal + op3_signal;
}
float calc_algo3(const float frequency)
{
float fb_freq = frequency * op3.ratio;
float fb_mod_index = (feedback_amt * MOD_INDEX_COEFF);
float fb_signal = feedback_osc.process_sample(trigger, fb_freq) * fb_mod_index;
float op3_freq = frequency * op3.ratio;
float op3_signal = op3.process_sample(gate, trigger, op3_freq, velocity, fb_signal) * op3.amplitude;
float op2_freq = frequency * op2.ratio;
float op2_signal = op2.process_sample(gate, trigger, op2_freq, velocity) * op2.amplitude;
float op1_freq = frequency * op1.ratio;
float op1_signal = op1.process_sample(gate, trigger, op1_freq, velocity) * op1.amplitude;
return op1_signal + op2_signal + op3_signal;
}
float calc_algo4(const float frequency)
{
float fb_freq = frequency * op3.ratio;
float fb_mod_index = (feedback_amt * MOD_INDEX_COEFF);
float fb_signal = feedback_osc.process_sample(trigger, fb_freq) * fb_mod_index;
float op3_freq = frequency * op3.ratio;
float op3_mod_index = (op3.amplitude * MOD_INDEX_COEFF);
float op3_signal = op3.process_sample(gate, trigger, op3_freq, velocity, fb_signal) * op3_mod_index;
float op2_freq = frequency * op2.ratio;
float op2_mod_index = (op2.amplitude * MOD_INDEX_COEFF);
float op2_signal = op2.process_sample(gate, trigger, op2_freq, velocity) * op2_mod_index;
float op1_freq = frequency * op1.ratio;
return op1.process_sample(gate, trigger, op1_freq, velocity, op2_signal + op3_signal) * op1.amplitude;
}
float redux(float& value, float resolution)
{
float res = powf(2, resolution);
value = roundf(value * res) / res;
return value;
}
void map_parameter(const tx_parameter_mapping& _mapping, const float _value)
{
switch (_mapping.parameter) {
case tx_parameter::BIT_RESOLUTION:
bit_resolution = _value;
break;
case tx_parameter::FEEDBACKOSC_PHASE_RESOLUTION:
feedback_osc.set_phase_resolution(_value);
break;
case tx_parameter::FEEDBACK:
feedback_amt = _value;
break;
case tx_parameter::ALGORITHM:
algorithm = _value;
break;
case tx_parameter::PITCH_ENVELOPE_AMOUNT:
pitch_env_amt = _value;
break;
case tx_parameter::PITCH_ENVELOPE_SKIP_SUSTAIN:
pitch_env.skip_sustain = _value;
break;
case tx_parameter::PITCH_ENVELOPE_ATTACK1_RATE:
pitch_env.attack1_rate = _value;
break;
case tx_parameter::PITCH_ENVELOPE_ATTACK1_LEVEL:
pitch_env.attack1_level = _value;
break;
case tx_parameter::PITCH_ENVELOPE_ATTACK2_RATE:
pitch_env.attack2_rate = _value;
break;
case tx_parameter::PITCH_ENVELOPE_HOLD_RATE:
pitch_env.hold_rate = _value;
break;
case tx_parameter::PITCH_ENVELOPE_DECAY1_RATE:
pitch_env.decay1_rate = _value;
break;
case tx_parameter::PITCH_ENVELOPE_DECAY1_LEVEL:
pitch_env.decay1_level = _value;
break;
case tx_parameter::PITCH_ENVELOPE_DECAY2_RATE:
pitch_env.decay2_rate = _value;
break;
case tx_parameter::PITCH_ENVELOPE_SUSTAIN_LEVEL:
pitch_env.sustain_level = _value;
break;
case tx_parameter::PITCH_ENVELOPE_RELEASE1_RATE:
pitch_env.release1_rate = _value;
break;
case tx_parameter::PITCH_ENVELOPE_RELEASE1_LEVEL:
pitch_env.release1_level = _value;
break;
case tx_parameter::PITCH_ENVELOPE_RELEASE2_RATE:
pitch_env.release2_rate = _value;
break;
case tx_parameter::OP1_RATIO:
op1.ratio = _value;
break;
case tx_parameter::OP1_AMPLITUDE:
op1.amplitude = _value;
break;
case tx_parameter::OP1_PHASE_RESOLUTION:
op1.oscillator.set_phase_resolution(_value);
break;
case tx_parameter::OP1_ENVELOPE_SKIP_SUSTAIN:
op1.envelope.skip_sustain = _value;
break;
case tx_parameter::OP1_ENVELOPE_ATTACK1_RATE:
op1.envelope.attack1_rate = _value;
break;
case tx_parameter::OP1_ENVELOPE_ATTACK1_LEVEL:
op1.envelope.attack1_level = _value;
break;
case tx_parameter::OP1_ENVELOPE_ATTACK2_RATE:
op1.envelope.attack2_rate = _value;
break;
case tx_parameter::OP1_ENVELOPE_HOLD_RATE:
op1.envelope.hold_rate = _value;
break;
case tx_parameter::OP1_ENVELOPE_DECAY1_RATE:
op1.envelope.decay1_rate = _value;
break;
case tx_parameter::OP1_ENVELOPE_DECAY1_LEVEL:
op1.envelope.decay1_level = _value;
break;
case tx_parameter::OP1_ENVELOPE_DECAY2_RATE:
op1.envelope.decay2_rate = _value;
break;
case tx_parameter::OP1_ENVELOPE_SUSTAIN_LEVEL:
op1.envelope.sustain_level = _value;
break;
case tx_parameter::OP1_ENVELOPE_RELEASE1_RATE:
op1.envelope.release1_rate = _value;
break;
case tx_parameter::OP1_ENVELOPE_RELEASE1_LEVEL:
op1.envelope.release1_level = _value;
break;
case tx_parameter::OP1_ENVELOPE_RELEASE2_RATE:
op1.envelope.release2_rate = _value;
break;
case tx_parameter::OP2_RATIO:
op2.ratio = _value;
break;
case tx_parameter::OP2_AMPLITUDE:
op2.amplitude = _value;
break;
case tx_parameter::OP2_PHASE_RESOLUTION:
op2.oscillator.set_phase_resolution(_value);
break;
case tx_parameter::OP2_ENVELOPE_SKIP_SUSTAIN:
op2.envelope.skip_sustain = _value;
break;
case tx_parameter::OP2_ENVELOPE_ATTACK1_RATE:
op2.envelope.attack1_rate = _value;
break;
case tx_parameter::OP2_ENVELOPE_ATTACK1_LEVEL:
op2.envelope.attack1_level = _value;
break;
case tx_parameter::OP2_ENVELOPE_ATTACK2_RATE:
op2.envelope.attack2_rate = _value;
break;
case tx_parameter::OP2_ENVELOPE_HOLD_RATE:
op2.envelope.hold_rate = _value;
break;
case tx_parameter::OP2_ENVELOPE_DECAY1_RATE:
op2.envelope.decay1_rate = _value;
break;
case tx_parameter::OP2_ENVELOPE_DECAY1_LEVEL:
op2.envelope.decay1_level = _value;
break;
case tx_parameter::OP2_ENVELOPE_DECAY2_RATE:
op2.envelope.decay2_rate = _value;
break;
case tx_parameter::OP2_ENVELOPE_SUSTAIN_LEVEL:
op2.envelope.sustain_level = _value;
break;
case tx_parameter::OP2_ENVELOPE_RELEASE1_RATE:
op2.envelope.release1_rate = _value;
break;
case tx_parameter::OP2_ENVELOPE_RELEASE1_LEVEL:
op2.envelope.release1_level = _value;
break;
case tx_parameter::OP2_ENVELOPE_RELEASE2_RATE:
op2.envelope.release2_rate = _value;
break;
case tx_parameter::OP3_RATIO:
op3.ratio = _value;
break;
case tx_parameter::OP3_AMPLITUDE:
op3.amplitude = _value;
break;
case tx_parameter::OP3_PHASE_RESOLUTION:
op3.oscillator.set_phase_resolution(_value);
break;
case tx_parameter::OP3_ENVELOPE_SKIP_SUSTAIN:
op3.envelope.skip_sustain = _value;
break;
case tx_parameter::OP3_ENVELOPE_ATTACK1_RATE:
op3.envelope.attack1_rate = _value;
break;
case tx_parameter::OP3_ENVELOPE_ATTACK1_LEVEL:
op3.envelope.attack1_level = _value;
break;
case tx_parameter::OP3_ENVELOPE_ATTACK2_RATE:
op3.envelope.attack2_rate = _value;
break;
case tx_parameter::OP3_ENVELOPE_HOLD_RATE:
op3.envelope.hold_rate = _value;
break;
case tx_parameter::OP3_ENVELOPE_DECAY1_RATE:
op3.envelope.decay1_rate = _value;
break;
case tx_parameter::OP3_ENVELOPE_DECAY1_LEVEL:
op3.envelope.decay1_level = _value;
break;
case tx_parameter::OP3_ENVELOPE_DECAY2_RATE:
op3.envelope.decay2_rate = _value;
break;
case tx_parameter::OP3_ENVELOPE_SUSTAIN_LEVEL:
op3.envelope.sustain_level = _value;
break;
case tx_parameter::OP3_ENVELOPE_RELEASE1_RATE:
op3.envelope.release1_rate = _value;
break;
case tx_parameter::OP3_ENVELOPE_RELEASE1_LEVEL:
op3.envelope.release1_level = _value;
break;
case tx_parameter::OP3_ENVELOPE_RELEASE2_RATE:
op3.envelope.release2_rate = _value;
break;
}
}
};
} // namespace trnr