AxioDL
/
amuse
mirror of https://github.com/AxioDL/amuse.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
amuse/lib/SoundMacroState.cpp

3171 lines
83 KiB
C++
Raw Blame History

#include "amuse/SoundMacroState.hpp"
#include "amuse/Voice.hpp"
#include "amuse/Engine.hpp"
#include "amuse/Common.hpp"
#include "amuse/AudioGroup.hpp"
#include "amuse/AudioGroupPool.hpp"
#include <cstring>
using namespace std::literals;
/* C++17 will error out if an offsetof cannot be computed, so ignore this warning */
#pragma GCC diagnostic ignored "-Winvalid-offsetof"
/* Squelch Win32 macro pollution >.< */
#undef SendMessage
#undef GetMessage
namespace amuse
{
void SoundMacroState::Evaluator::addComponent(uint8_t midiCtrl, float scale, Combine combine, VarType varType)
{
m_comps.push_back({midiCtrl, scale, combine, varType});
}
float SoundMacroState::Evaluator::evaluate(double time, const Voice& vox, const SoundMacroState& st) const
{
float value = 0.f;
/* Iterate each component */
for (auto it = m_comps.cbegin(); it != m_comps.cend(); ++it)
{
const Component& comp = *it;
float thisValue = 0.f;
/* Load selected data */
if (comp.m_varType == VarType::Ctrl)
{
switch (comp.m_midiCtrl)
{
case 128:
/* Pitchbend */
thisValue = vox.getPitchWheel();
break;
case 129:
/* Aftertouch */
thisValue = vox.getAftertouch() * (2.f / 127.f);
break;
case 130:
/* LFO1 */
if (vox.m_lfoPeriods[0])
thisValue = std::sin(time / vox.m_lfoPeriods[0] * 2.f * M_PIF);
break;
case 131:
/* LFO2 */
if (vox.m_lfoPeriods[1])
thisValue = std::sin(time / vox.m_lfoPeriods[1] * 2.f * M_PIF);
break;
case 132:
/* Surround panning */
thisValue = vox.m_curSpan;
break;
case 133:
/* Macro-starting key */
thisValue = st.m_initKey;
break;
case 134:
/* Macro-starting velocity */
thisValue = st.m_initVel;
break;
case 135:
/* Time since macro-start (ms) */
thisValue = clamp(0.f, float(st.m_execTime * 1000.f), 16383.f);
break;
default:
if (comp.m_midiCtrl == 10) /* Centered pan computation */
thisValue = vox.getCtrlValue(comp.m_midiCtrl) * (2.f / 127.f) - 1.f;
else
thisValue = vox.getCtrlValue(comp.m_midiCtrl) * (2.f / 127.f);
break;
}
}
else if (comp.m_varType == VarType::Var)
thisValue = st.m_variables[comp.m_midiCtrl & 0x1f];
/* Apply scale */
thisValue *= comp.m_scale;
/* Combine */
if (it != m_comps.cbegin())
{
switch (comp.m_combine)
{
case Combine::Add:
value += thisValue;
break;
case Combine::Mult:
value *= thisValue;
break;
default:
value = thisValue;
break;
}
}
else
value = thisValue;
}
return value;
}
void SoundMacroState::initialize(ObjectId id, const SoundMacro* macro, int step)
{
initialize(id, macro, step, 1000.f, 0, 0, 0);
}
void SoundMacroState::initialize(ObjectId id, const SoundMacro* macro, int step, double ticksPerSec,
uint8_t midiKey, uint8_t midiVel, uint8_t midiMod)
{
m_ticksPerSec = ticksPerSec;
m_initKey = midiKey;
m_initVel = midiVel;
m_initMod = midiMod;
m_curVel = midiVel;
m_curMod = midiMod;
m_curPitch = midiKey * 100;
m_pc.clear();
m_pc.emplace_back(id, macro, macro->assertPC(step));
m_inWait = false;
m_execTime = 0.f;
m_keyoff = false;
m_sampleEnd = false;
m_loopCountdown = -1;
m_lastPlayMacroVid = -1;
m_useAdsrControllers = false;
m_portamentoMode = SoundMacro::CmdPortamento::PortState::MIDIControlled;
m_portamentoTime = 0.5f;
}
template <class T, std::enable_if_t<!std::is_enum_v<T>, int> = 0>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType()
{ return SoundMacro::CmdIntrospection::Field::Type::Invalid; }
template <class T, std::enable_if_t<std::is_enum_v<T>, int> = 0>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType()
{ return SoundMacro::CmdIntrospection::Field::Type::Choice; }
template <>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType<bool>()
{ return SoundMacro::CmdIntrospection::Field::Type::Bool; }
template <>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType<atInt8>()
{ return SoundMacro::CmdIntrospection::Field::Type::Int8; }
template <>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType<atUint8>()
{ return SoundMacro::CmdIntrospection::Field::Type::UInt8; }
template <>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType<atInt16>()
{ return SoundMacro::CmdIntrospection::Field::Type::Int16; }
template <>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType<atUint16>()
{ return SoundMacro::CmdIntrospection::Field::Type::UInt16; }
template <>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType<atInt32>()
{ return SoundMacro::CmdIntrospection::Field::Type::Int32; }
template <>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType<atUint32>()
{ return SoundMacro::CmdIntrospection::Field::Type::UInt32; }
template <>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType<SoundMacroIdDNA<athena::Little>>()
{ return SoundMacro::CmdIntrospection::Field::Type::SoundMacroId; }
template <>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType<TableIdDNA<athena::Little>>()
{ return SoundMacro::CmdIntrospection::Field::Type::TableId; }
template <>
constexpr SoundMacro::CmdIntrospection::Field::Type GetFieldType<SampleIdDNA<athena::Little>>()
{ return SoundMacro::CmdIntrospection::Field::Type::SampleId; }
#define FIELD_HEAD(tp, var) GetFieldType<decltype(var)>(), offsetof(tp, var)
const SoundMacro::CmdIntrospection SoundMacro::CmdEnd::Introspective =
{
"End"sv,
"End of the macro. This always appears at the end of a given SoundMacro."sv,
};
bool SoundMacro::CmdEnd::Do(SoundMacroState& st, Voice& vox) const
{
st._setPC(-1);
return true;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdStop::Introspective =
{
"Stop"sv,
"Stops the macro at any point."sv,
};
bool SoundMacro::CmdStop::Do(SoundMacroState& st, Voice& vox) const
{
st._setPC(-1);
return true;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSplitKey::Introspective =
{
"Split Key"sv,
"Conditionally branches macro execution based on MIDI key."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSplitKey, key),
"Key"sv,
0, 127, 60
},
{
FIELD_HEAD(SoundMacro::CmdSplitKey, macro),
"SoundMacro"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdSplitKey, macroStep),
"SoundMacro Step"sv,
0, 65535, 0
}
}
};
bool SoundMacro::CmdSplitKey::Do(SoundMacroState& st, Voice& vox) const
{
if (st.m_initKey >= key)
{
/* Do Branch */
if (macro.id == std::get<0>(st.m_pc.back()))
st._setPC(macroStep);
else
vox.loadMacroObject(macro.id, macroStep, st.m_ticksPerSec, st.m_initKey, st.m_initVel, st.m_initMod);
}
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSplitVel::Introspective =
{
"Split Velocity"sv,
"Conditionally branches macro execution based on velocity."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSplitVel, velocity),
"Key"sv,
0, 127, 100
},
{
FIELD_HEAD(SoundMacro::CmdSplitVel, macro),
"SoundMacro"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdSplitVel, macroStep),
"SoundMacro Step"sv,
0, 65535, 0
}
}
};
bool SoundMacro::CmdSplitVel::Do(SoundMacroState& st, Voice& vox) const
{
if (st.m_curVel >= velocity)
{
/* Do Branch */
if (macro.id == std::get<0>(st.m_pc.back()))
st._setPC(macroStep);
else
vox.loadMacroObject(macro.id, macroStep, st.m_ticksPerSec, st.m_initKey, st.m_initVel, st.m_initMod);
}
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdWaitTicks::Introspective =
{
"Wait Ticks"sv,
"Suspend SoundMacro execution for specified length of time. Value of 65535 "
"will wait indefinitely, relying on KeyOff or Sample End to signal stop."sv,
{
{
FIELD_HEAD(SoundMacro::CmdWaitTicks, keyOff),
"KeyOff"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdWaitTicks, random),
"Random"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdWaitTicks, sampleEnd),
"Sample End"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdWaitTicks, absolute),
"Absolute"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdWaitTicks, msSwitch),
"Use Millisec"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdWaitTicks, ticksOrMs),
"Ticks/Millisec"sv,
0, 65535, 96
}
}
};
bool SoundMacro::CmdWaitTicks::Do(SoundMacroState& st, Voice& vox) const
{
/* Set wait state */
if (ticksOrMs >= 0)
{
float q = msSwitch ? 1000.f : st.m_ticksPerSec;
float secTime = ticksOrMs / q;
/* Randomize at the proper resolution */
if (random)
secTime = std::fmod(vox.getEngine().nextRandom() / q, secTime);
if (absolute)
{
if (secTime <= st.m_execTime)
return false;
st.m_waitCountdown = secTime - st.m_execTime;
}
else
st.m_waitCountdown = secTime;
st.m_indefiniteWait = false;
}
else
st.m_indefiniteWait = true;
st.m_inWait = true;
st.m_keyoffWait = keyOff;
st.m_sampleEndWait = sampleEnd;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdLoop::Introspective =
{
"Loop"sv,
"Branch to specified location in a loop for a specified number of Times. "
"65535 will cause an endless loop, relying on KeyOff or Sample End to signal stop."sv,
{
{
FIELD_HEAD(SoundMacro::CmdLoop, keyOff),
"KeyOff"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdLoop, random),
"Random"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdLoop, sampleEnd),
"Sample End"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdLoop, macroStep),
"SoundMacro Step"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdLoop, times),
"Times"sv,
0, 65535, 0
}
}
};
bool SoundMacro::CmdLoop::Do(SoundMacroState& st, Voice& vox) const
{
if ((keyOff && st.m_keyoff) || (sampleEnd && st.m_sampleEnd))
{
/* Break out of loop */
st.m_loopCountdown = -1;
return false;
}
uint32_t useTimes = times;
if (random)
useTimes = vox.getEngine().nextRandom() % times;
if (st.m_loopCountdown == -1 && useTimes != -1)
st.m_loopCountdown = useTimes;
if (st.m_loopCountdown > 0)
{
/* Loop back to step */
--st.m_loopCountdown;
st._setPC(macroStep);
}
else /* Break out of loop */
st.m_loopCountdown = -1;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdGoto::Introspective =
{
"Goto"sv,
"Unconditional branch to specified SoundMacro location."sv,
{
{
FIELD_HEAD(SoundMacro::CmdGoto, macro),
"SoundMacro"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdGoto, macroStep),
"SoundMacro Step"sv,
0, 65535, 0
}
}
};
bool SoundMacro::CmdGoto::Do(SoundMacroState& st, Voice& vox) const
{
/* Do Branch */
if (macro.id == std::get<0>(st.m_pc.back()))
st._setPC(macroStep);
else
vox.loadMacroObject(macro.id, macroStep, st.m_ticksPerSec, st.m_initKey, st.m_initVel, st.m_initMod);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdWaitMs::Introspective =
{
"Wait Millisec"sv,
"Suspend SoundMacro execution for specified length of time. Value of 65535 "
"will wait indefinitely, relying on KeyOff or Sample End to signal stop."sv,
{
{
FIELD_HEAD(SoundMacro::CmdWaitMs, keyOff),
"KeyOff"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdWaitMs, random),
"Random"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdWaitMs, sampleEnd),
"Sample End"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdWaitMs, absolute),
"Absolute"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdWaitMs, ms),
"Ticks/Millisec"sv,
0, 65535, 96
}
}
};
bool SoundMacro::CmdWaitMs::Do(SoundMacroState& st, Voice& vox) const
{
/* Set wait state */
if (ms >= 0)
{
float secTime = ms / 1000.f;
/* Randomize at the proper resolution */
if (random)
secTime = std::fmod(vox.getEngine().nextRandom() / 1000.f, secTime);
if (absolute)
{
if (secTime <= st.m_execTime)
return false;
st.m_waitCountdown = secTime - st.m_execTime;
}
else
st.m_waitCountdown = secTime;
st.m_indefiniteWait = false;
}
else
st.m_indefiniteWait = true;
st.m_inWait = true;
st.m_keyoffWait = keyOff;
st.m_sampleEndWait = sampleEnd;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPlayMacro::Introspective =
{
"Play Macro"sv,
"Play a SoundMacro in parallel to this one. Add Note is added to the "
"current SoundMacro note to evaluate the new note."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPlayMacro, addNote),
"Add Note"sv,
-128, 127, 0
},
{
FIELD_HEAD(SoundMacro::CmdPlayMacro, macro),
"SoundMacro"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdPlayMacro, macroStep),
"SoundMacro Step"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdPlayMacro, priority),
"Priority"sv,
0, 127, 50
},
{
FIELD_HEAD(SoundMacro::CmdPlayMacro, maxVoices),
"Max Voices"sv,
0, 255, 255
}
}
};
bool SoundMacro::CmdPlayMacro::Do(SoundMacroState& st, Voice& vox) const
{
std::shared_ptr<Voice> sibVox = vox.startChildMacro(addNote, macro.id, macroStep);
if (sibVox)
st.m_lastPlayMacroVid = sibVox->vid();
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSendKeyOff::Introspective =
{
"Send Keyoff"sv,
"Send keyoff to voice specified by VID stored in a variable or the last started voice."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSendKeyOff, variable),
"Variable"sv,
0, 31, 0
},
{
FIELD_HEAD(SoundMacro::CmdSendKeyOff, lastStarted),
"Last Started"sv,
0, 1, 0
}
}
};
bool SoundMacro::CmdSendKeyOff::Do(SoundMacroState& st, Voice& vox) const
{
if (lastStarted)
{
if (st.m_lastPlayMacroVid != -1)
{
std::shared_ptr<Voice> otherVox = vox.getEngine().findVoice(st.m_lastPlayMacroVid);
if (otherVox)
otherVox->keyOff();
}
}
else
{
std::shared_ptr<Voice> otherVox = vox.getEngine().findVoice(st.m_variables[variable & 0x1f]);
if (otherVox)
otherVox->keyOff();
}
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSplitMod::Introspective =
{
"Split Mod"sv,
"Conditionally branch if mod wheel is greater than or equal to specified value."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSplitMod, modValue),
"Mod Value"sv,
0, 127, 64
},
{
FIELD_HEAD(SoundMacro::CmdSplitMod, macro),
"SoundMacro"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdSplitMod, macroStep),
"SoundMacro Step"sv,
0, 65535, 0
}
}
};
bool SoundMacro::CmdSplitMod::Do(SoundMacroState& st, Voice& vox) const
{
if (st.m_curMod >= modValue)
{
/* Do Branch */
if (macro.id == std::get<0>(st.m_pc.back()))
st._setPC(macroStep);
else
vox.loadMacroObject(macro.id, macroStep, st.m_ticksPerSec, st.m_initKey, st.m_initVel, st.m_initMod);
}
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPianoPan::Introspective =
{
"Piano Pan"sv,
"Gives piano-like sounds a natural-sounding stereo spread. The current key delta "
"from Center Key is scaled with Scale and biased with Center Pan to evaluate panning."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPianoPan, scale),
"Scale"sv,
0, 127, 127
},
{
FIELD_HEAD(SoundMacro::CmdPianoPan, centerKey),
"Center Key"sv,
0, 127, 36
},
{
FIELD_HEAD(SoundMacro::CmdPianoPan, centerPan),
"Center Pan"sv,
0, 127, 64
}
}
};
bool SoundMacro::CmdPianoPan::Do(SoundMacroState& st, Voice& vox) const
{
int32_t pan = int32_t(st.m_initKey - centerKey) * scale / 127 + centerPan;
pan = std::max(-127, std::min(127, pan));
vox.setPan(pan / 127.f);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSetAdsr::Introspective =
{
"Set ADSR"sv,
"Specify ADSR envelope using a pool object. DLS mode must match setting in ADSR."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSetAdsr, table),
"ADSR"sv,
0, 16383, 0
},
{
FIELD_HEAD(SoundMacro::CmdSetAdsr, dlsMode),
"DLS Mode"sv,
0, 1, 0
}
}
};
bool SoundMacro::CmdSetAdsr::Do(SoundMacroState& st, Voice& vox) const
{
vox.setAdsr(table.id, dlsMode);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdScaleVolume::Introspective =
{
"Scale Volume"sv,
"Calculates volume by scaling and biasing velocity. "
"The result may be passed through an optional Curve."sv,
{
{
FIELD_HEAD(SoundMacro::CmdScaleVolume, scale),
"Scale"sv,
0, 127, 127
},
{
FIELD_HEAD(SoundMacro::CmdScaleVolume, add),
"Add"sv,
0, 127, 0
},
{
FIELD_HEAD(SoundMacro::CmdScaleVolume, table),
"Curve"sv,
0, 16383, 0
},
{
FIELD_HEAD(SoundMacro::CmdScaleVolume, originalVol),
"Original Vol"sv,
0, 1, 1
}
}
};
bool SoundMacro::CmdScaleVolume::Do(SoundMacroState& st, Voice& vox) const
{
int32_t eval = int32_t(originalVol ? st.m_initVel : st.m_curVel) * scale / 127 + add;
eval = clamp(0, eval, 127);
if (table.id != 0)
{
const Curve* curveData = vox.getAudioGroup().getPool().tableAsCurves(table.id);
if (curveData)
{
vox.m_curVol = curveData->data.at(eval) / 127.f;
return false;
}
}
vox.m_curVol = eval / 127.f;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPanning::Introspective =
{
"Panning"sv,
"Start pan-sweep from Pan Position offset by Width over specified time period."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPanning, panPosition),
"Pan Position"sv,
0, 127, 64
},
{
FIELD_HEAD(SoundMacro::CmdPanning, timeMs),
"Time Millisec"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdPanning, width),
"Width"sv,
-128, 127, 0
}
}
};
bool SoundMacro::CmdPanning::Do(SoundMacroState& st, Voice& vox) const
{
vox.startPanning(timeMs / 1000.0, panPosition, width);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdEnvelope::Introspective =
{
"Envelope"sv,
"Start a velocity envelope by fading the current velocity to the one "
"evaluated by Scale and Add. The result is optionally transformed with a Curve object."sv,
{
{
FIELD_HEAD(SoundMacro::CmdEnvelope, scale),
"Scale"sv,
0, 127, 0
},
{
FIELD_HEAD(SoundMacro::CmdEnvelope, add),
"Add"sv,
0, 127, 0
},
{
FIELD_HEAD(SoundMacro::CmdEnvelope, table),
"Curve"sv,
0, 16383, 0
},
{
FIELD_HEAD(SoundMacro::CmdEnvelope, msSwitch),
"Use Millisec"sv,
0, 1, 1
},
{
FIELD_HEAD(SoundMacro::CmdEnvelope, ticksOrMs),
"Ticks/Millisec"sv,
0, 65535, 500
}
}
};
bool SoundMacro::CmdEnvelope::Do(SoundMacroState& st, Voice& vox) const
{
double q = msSwitch ? 1000.0 : st.m_ticksPerSec;
double secTime = ticksOrMs / q;
int32_t eval = int32_t(st.m_curVel) * scale / 127 + add;
eval = clamp(0, eval, 127);
const Curve* curveData;
if (table.id != 0)
curveData = vox.getAudioGroup().getPool().tableAsCurves(table.id);
else
curveData = nullptr;
vox.startEnvelope(secTime, eval, curveData);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdStartSample::Introspective =
{
"Start Sample"sv,
"Start a Sample playing on the voice. An Offset in samples may be applied. "
"This offset may be scaled with the current velocity."sv,
{
{
FIELD_HEAD(SoundMacro::CmdStartSample, sample),
"Sample"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdStartSample, mode),
"Velocity Scale"sv,
0, 2, 0,
{
"No Scale"sv,
"Negative"sv,
"Positive"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdStartSample, offset),
"Offset"sv,
0, 0xffffff, 0
}
}
};
bool SoundMacro::CmdStartSample::Do(SoundMacroState& st, Voice& vox) const
{
uint32_t useOffset = offset;
switch (mode)
{
case Mode::Negative:
useOffset = offset * (127 - st.m_curVel) / 127;
break;
case Mode::Positive:
useOffset = offset * st.m_curVel / 127;
break;
default:
break;
}
vox.startSample(sample.id, useOffset);
vox.setPitchKey(st.m_curPitch);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdStopSample::Introspective =
{
"Stop Sample"sv,
"Stops the sample playing on the voice."sv
};
bool SoundMacro::CmdStopSample::Do(SoundMacroState& st, Voice& vox) const
{
vox.stopSample();
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdKeyOff::Introspective =
{
"KeyOff"sv,
"Sends a KeyOff to the current voice."sv
};
bool SoundMacro::CmdKeyOff::Do(SoundMacroState& st, Voice& vox) const
{
vox._macroKeyOff();
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSplitRnd::Introspective =
{
"Split Rnd"sv,
"Conditionally branch if a random value is greater than or equal to RND. "
"A lower RND will cause a higher probability of branching."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSplitRnd, rnd),
"RND"sv,
0, 255, 128
},
{
FIELD_HEAD(SoundMacro::CmdSplitRnd, macro),
"SoundMacro"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdSplitRnd, macroStep),
"SoundMacro Step"sv,
0, 65535, 0
},
}
};
bool SoundMacro::CmdSplitRnd::Do(SoundMacroState& st, Voice& vox) const
{
if (rnd <= vox.getEngine().nextRandom() % 256)
{
/* Do branch */
if (macro.id == std::get<0>(st.m_pc.back()))
st._setPC(macroStep);
else
vox.loadMacroObject(macro.id, macroStep, st.m_ticksPerSec, st.m_initKey, st.m_initVel, st.m_initMod);
}
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdFadeIn::Introspective =
{
"Fade In"sv,
"Start a velocity envelope by fading from silence to the velocity "
"evaluated by Scale and Add. The result is optionally transformed with a Curve object."sv,
{
{
FIELD_HEAD(SoundMacro::CmdFadeIn, scale),
"Scale"sv,
0, 127, 0
},
{
FIELD_HEAD(SoundMacro::CmdFadeIn, add),
"Add"sv,
0, 127, 0
},
{
FIELD_HEAD(SoundMacro::CmdFadeIn, table),
"Curve"sv,
0, 16383, 0
},
{
FIELD_HEAD(SoundMacro::CmdFadeIn, msSwitch),
"Use Millisec"sv,
0, 1, 1
},
{
FIELD_HEAD(SoundMacro::CmdFadeIn, ticksOrMs),
"Ticks/Millisec"sv,
0, 65535, 500
}
}
};
bool SoundMacro::CmdFadeIn::Do(SoundMacroState& st, Voice& vox) const
{
float q = msSwitch ? 1000.f : st.m_ticksPerSec;
float secTime = ticksOrMs / q;
int32_t eval = int32_t(st.m_curVel) * scale / 127 + add;
eval = clamp(0, eval, 127);
const Curve* curveData;
if (table.id != 0)
curveData = vox.getAudioGroup().getPool().tableAsCurves(table.id);
else
curveData = nullptr;
vox.startFadeIn(secTime, eval, curveData);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSpanning::Introspective =
{
"Spanning"sv,
"Start span-sweep from Span Position offset by Width over specified time period."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSpanning, spanPosition),
"Span Position"sv,
0, 127, 64
},
{
FIELD_HEAD(SoundMacro::CmdSpanning, timeMs),
"Time Millisec"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdSpanning, width),
"Width"sv,
-128, 127, 0
}
}
};
bool SoundMacro::CmdSpanning::Do(SoundMacroState& st, Voice& vox) const
{
vox.startSpanning(timeMs / 1000.0, spanPosition, width);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSetAdsrCtrl::Introspective =
{
"Set ADSR Ctrl"sv,
"Bind MIDI controls to ADSR parameters."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSetAdsrCtrl, attack),
"Attack Ctrl"sv,
0, 127, 0
},
{
FIELD_HEAD(SoundMacro::CmdSetAdsrCtrl, decay),
"Decay Ctrl"sv,
0, 127, 0
},
{
FIELD_HEAD(SoundMacro::CmdSetAdsrCtrl, sustain),
"Sustain Ctrl"sv,
0, 127, 0
},
{
FIELD_HEAD(SoundMacro::CmdSetAdsrCtrl, release),
"Release Ctrl"sv,
0, 127, 0
},
}
};
bool SoundMacro::CmdSetAdsrCtrl::Do(SoundMacroState& st, Voice& vox) const
{
st.m_useAdsrControllers = true;
st.m_midiAttack = attack;
st.m_midiDecay = decay;
st.m_midiSustain = sustain;
st.m_midiRelease = release;
/* Bootstrap ADSR defaults here */
if (!vox.getCtrlValue(st.m_midiSustain))
{
vox.setCtrlValue(st.m_midiAttack, 10);
vox.setCtrlValue(st.m_midiSustain, 127);
vox.setCtrlValue(st.m_midiRelease, 10);
}
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdRndNote::Introspective =
{
"Random Note"sv,
"Sets random pitch between Note Lo and Note Hi, biased by Detune in cents. "
"If Free is set, the note will not snap to key steps."sv,
{
{
FIELD_HEAD(SoundMacro::CmdRndNote, noteLo),
"Note Lo"sv,
-127, 127, 48
},
{
FIELD_HEAD(SoundMacro::CmdRndNote, detune),
"Detune"sv,
0, 99, 0
},
{
FIELD_HEAD(SoundMacro::CmdRndNote, noteHi),
"Note Hi"sv,
-127, 127, 72
},
{
FIELD_HEAD(SoundMacro::CmdRndNote, fixedFree),
"Free"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdRndNote, absRel),
"Absolute"sv,
0, 1, 0
}
}
};
bool SoundMacro::CmdRndNote::Do(SoundMacroState& st, Voice& vox) const
{
int32_t useNoteLo = noteLo;
int32_t useNoteHi = noteHi;
if (absRel)
{
useNoteLo = st.m_initKey - noteLo;
useNoteHi = noteLo + noteHi;
}
useNoteLo *= 100;
useNoteHi *= 100;
if (useNoteHi == useNoteLo)
st.m_curPitch = useNoteHi;
else
st.m_curPitch = (vox.getEngine().nextRandom() % (useNoteHi - useNoteLo)) + useNoteLo;
if (!fixedFree)
st.m_curPitch = st.m_curPitch / 100 * 100 + detune;
vox.setPitchKey(st.m_curPitch);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdAddNote::Introspective =
{
"Add Note"sv,
"Sets new pitch by adding Add, biased by Detune in cents. "
"The time parameters behave like a WAIT command when non-zero."sv,
{
{
FIELD_HEAD(SoundMacro::CmdAddNote, add),
"Add"sv,
-128, 127, 0
},
{
FIELD_HEAD(SoundMacro::CmdAddNote, detune),
"Detune"sv,
-99, 99, 0
},
{
FIELD_HEAD(SoundMacro::CmdAddNote, originalKey),
"Original Key"sv,
0, 1, 1
},
{
FIELD_HEAD(SoundMacro::CmdAddNote, msSwitch),
"Use Millisec"sv,
0, 1, 1
},
{
FIELD_HEAD(SoundMacro::CmdAddNote, ticksOrMs),
"Ticks/Millisec"sv,
0, 65535, 0
}
}
};
bool SoundMacro::CmdAddNote::Do(SoundMacroState& st, Voice& vox) const
{
st.m_curPitch += add * 100 + detune;
/* Set wait state */
if (msSwitch)
{
float q = msSwitch ? 1000.f : st.m_ticksPerSec;
float secTime = ticksOrMs / q;
st.m_waitCountdown = secTime;
st.m_inWait = true;
}
vox.setPitchKey(st.m_curPitch);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSetNote::Introspective =
{
"Set Note"sv,
"Sets new pitch to Key, biased by Detune in cents. "
"The time parameters behave like a WAIT command when non-zero."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSetNote, key),
"Key"sv,
0, 127, 60
},
{
FIELD_HEAD(SoundMacro::CmdSetNote, detune),
"Detune"sv,
-99, 99, 0
},
{
FIELD_HEAD(SoundMacro::CmdSetNote, msSwitch),
"Use Millisec"sv,
0, 1, 1
},
{
FIELD_HEAD(SoundMacro::CmdSetNote, ticksOrMs),
"Ticks/Millisec"sv,
0, 65535, 0
}
}
};
bool SoundMacro::CmdSetNote::Do(SoundMacroState& st, Voice& vox) const
{
st.m_curPitch = key * 100 + detune;
/* Set wait state */
if (ticksOrMs)
{
float q = msSwitch ? 1000.f : st.m_ticksPerSec;
float secTime = ticksOrMs / q;
st.m_waitCountdown = secTime;
st.m_inWait = true;
}
vox.setPitchKey(st.m_curPitch);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdLastNote::Introspective =
{
"Last Note"sv,
"Sets new pitch by adding Add to last played MIDI note, biased by Detune in cents. "
"The time parameters behave like a WAIT command when non-zero."sv,
{
{
FIELD_HEAD(SoundMacro::CmdLastNote, add),
"Key"sv,
-128, 127, 0
},
{
FIELD_HEAD(SoundMacro::CmdLastNote, detune),
"Detune"sv,
-99, 99, 0
},
{
FIELD_HEAD(SoundMacro::CmdLastNote, msSwitch),
"Use Millisec"sv,
0, 1, 1
},
{
FIELD_HEAD(SoundMacro::CmdLastNote, ticksOrMs),
"Ticks/Millisec"sv,
0, 65535, 0
}
}
};
bool SoundMacro::CmdLastNote::Do(SoundMacroState& st, Voice& vox) const
{
st.m_curPitch = (add + vox.getLastNote()) * 100 + detune;
/* Set wait state */
if (msSwitch)
{
float q = msSwitch ? 1000.f : st.m_ticksPerSec;
float secTime = ticksOrMs / q;
st.m_waitCountdown = secTime;
st.m_inWait = true;
}
vox.setPitchKey(st.m_curPitch);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPortamento::Introspective =
{
"Portamento"sv,
"Setup portamento mode for this voice."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPortamento, portState),
"Port. State"sv,
0, 2, 1,
{
"Enable"sv,
"Disable"sv,
"MIDI Controlled"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdPortamento, portType),
"Port. Type"sv,
0, 1, 0,
{
"Last Pressed"sv,
"Always"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdPortamento, msSwitch),
"Use Millisec"sv,
0, 1, 1
},
{
FIELD_HEAD(SoundMacro::CmdPortamento, ticksOrMs),
"Ticks/Millisec"sv,
0, 65535, 0
}
}
};
bool SoundMacro::CmdPortamento::Do(SoundMacroState& st, Voice& vox) const
{
st.m_portamentoMode = portState;
st.m_portamentoType = portType;
float q = msSwitch ? 1000.f : st.m_ticksPerSec;
st.m_portamentoTime = ticksOrMs / q;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdVibrato::Introspective =
{
"Vibrato"sv,
"Setup vibrato mode for this voice. Voice pitch will be "
"modulated using the Level magnitude or the modwheel."sv,
{
{
FIELD_HEAD(SoundMacro::CmdVibrato, levelNote),
"Level Note"sv,
-127, 127, 0,
},
{
FIELD_HEAD(SoundMacro::CmdVibrato, levelFine),
"Level Fine"sv,
-99, 99, 15,
},
{
FIELD_HEAD(SoundMacro::CmdVibrato, modwheelFlag),
"Use Modwheel"sv,
0, 1, 1
},
{
FIELD_HEAD(SoundMacro::CmdVibrato, msSwitch),
"Use Millisec"sv,
0, 1, 1
},
{
FIELD_HEAD(SoundMacro::CmdVibrato, ticksOrMs),
"Ticks/Millisec"sv,
0, 65535, 250
}
}
};
bool SoundMacro::CmdVibrato::Do(SoundMacroState& st, Voice& vox) const
{
float q = msSwitch ? 1000.f : st.m_ticksPerSec;
vox.setVibrato(levelNote * 100 + levelFine, modwheelFlag, ticksOrMs / q);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPitchSweep1::Introspective =
{
"Pitch Sweep 1"sv,
"Setup pitch sweep 1 for this voice. Voice pitch will accumulate Add for Times frames. "
"If the time values are non-zero, this command also functions as a WAIT."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPitchSweep1, times),
"Level Note"sv,
0, 127, 100,
},
{
FIELD_HEAD(SoundMacro::CmdPitchSweep1, add),
"Level Fine"sv,
-32768, 32767, 100,
},
{
FIELD_HEAD(SoundMacro::CmdPitchSweep1, msSwitch),
"Use Millisec"sv,
0, 1, 1
},
{
FIELD_HEAD(SoundMacro::CmdPitchSweep1, ticksOrMs),
"Ticks/Millisec"sv,
0, 65535, 1000
}
}
};
bool SoundMacro::CmdPitchSweep1::Do(SoundMacroState& st, Voice& vox) const
{
/* Set wait state */
if (msSwitch)
{
float q = msSwitch ? 1000.f : st.m_ticksPerSec;
float secTime = ticksOrMs / q;
st.m_waitCountdown = secTime;
st.m_inWait = true;
}
vox.setPitchSweep1(times, add);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPitchSweep2::Introspective =
{
"Pitch Sweep 2"sv,
"Setup pitch sweep 2 for this voice. Voice pitch will accumulate Add for Times frames. "
"If the time values are non-zero, this command also functions as a WAIT."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPitchSweep2, times),
"Level Note"sv,
0, 127, 100,
},
{
FIELD_HEAD(SoundMacro::CmdPitchSweep2, add),
"Level Fine"sv,
-32768, 32767, 100,
},
{
FIELD_HEAD(SoundMacro::CmdPitchSweep2, msSwitch),
"Use Millisec"sv,
0, 1, 1
},
{
FIELD_HEAD(SoundMacro::CmdPitchSweep2, ticksOrMs),
"Ticks/Millisec"sv,
0, 65535, 1000
}
}
};
bool SoundMacro::CmdPitchSweep2::Do(SoundMacroState& st, Voice& vox) const
{
/* Set wait state */
if (msSwitch)
{
float q = msSwitch ? 1000.f : st.m_ticksPerSec;
float secTime = ticksOrMs / q;
st.m_waitCountdown = secTime;
st.m_inWait = true;
}
vox.setPitchSweep2(times, add);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSetPitch::Introspective =
{
"Set Pitch"sv,
"Set the playback sample rate directly."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSetPitch, hz.val),
"Hz"sv,
0, 0xffffff, 22050,
},
{
FIELD_HEAD(SoundMacro::CmdSetPitch, fine),
"Level Fine"sv,
0, 65535, 0,
}
}
};
bool SoundMacro::CmdSetPitch::Do(SoundMacroState& st, Voice& vox) const
{
vox.setPitchFrequency(hz, fine);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSetPitchAdsr::Introspective =
{
"Set Pitch ADSR"sv,
"Define the pitch ADSR from a pool object. The pitch range is "
"specified using Note and Cents parameters."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSetPitchAdsr, table),
"ADSR"sv,
0, 16383, 0,
},
{
FIELD_HEAD(SoundMacro::CmdSetPitchAdsr, keys),
"Note range"sv,
-128, 127, 0,
},
{
FIELD_HEAD(SoundMacro::CmdSetPitchAdsr, cents),
"Cents range"sv,
-99, 99, 0,
}
}
};
bool SoundMacro::CmdSetPitchAdsr::Do(SoundMacroState& st, Voice& vox) const
{
vox.setPitchAdsr(table.id, keys * 100 + cents);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdScaleVolumeDLS::Introspective =
{
"Scale Volume DLS"sv,
"Sets new volume by scaling the velocity. A value of 4096 == 100%."sv,
{
{
FIELD_HEAD(SoundMacro::CmdScaleVolumeDLS, scale),
"Scale"sv,
0, 16383, 4096,
},
{
FIELD_HEAD(SoundMacro::CmdScaleVolumeDLS, originalVol),
"Original Vol"sv,
0, 1, 1,
}
}
};
bool SoundMacro::CmdScaleVolumeDLS::Do(SoundMacroState& st, Voice& vox) const
{
vox.m_curVol = int32_t(originalVol ? st.m_initVel : st.m_curVel) * scale / 4096.f / 127.f;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdMod2Vibrange::Introspective =
{
"Mod 2 Vibrange"sv,
"Values used to scale the modwheel control for vibrato."sv,
{
{
FIELD_HEAD(SoundMacro::CmdMod2Vibrange, keys),
"Key range"sv,
0, 16383, 4096,
},
{
FIELD_HEAD(SoundMacro::CmdMod2Vibrange, cents),
"Cent range"sv,
0, 1, 1,
}
}
};
bool SoundMacro::CmdMod2Vibrange::Do(SoundMacroState& st, Voice& vox) const
{
vox.setMod2VibratoRange(keys * 100 + cents);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSetupTremolo::Introspective =
{
"Setup Tremolo"sv,
"Setup tremolo effect. Must be combined with Tremolo Select to connect "
"with a configured LFO. A value of 4096 == 100%."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSetupTremolo, scale),
"Scale"sv,
0, 16383, 8192,
},
{
FIELD_HEAD(SoundMacro::CmdSetupTremolo, modwAddScale),
"Modw. add scale"sv,
0, 16383, 0,
}
}
};
bool SoundMacro::CmdSetupTremolo::Do(SoundMacroState& st, Voice& vox) const
{
vox.setTremolo(scale / 4096.f, scale / 4096.f);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdReturn::Introspective =
{
"Return"sv,
"Branch to after last Go Subroutine command and pop call stack."sv
};
bool SoundMacro::CmdReturn::Do(SoundMacroState& st, Voice& vox) const
{
if (st.m_pc.size() > 1)
{
st.m_pc.pop_back();
vox._setObjectId(std::get<0>(st.m_pc.back()));
}
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdGoSub::Introspective =
{
"Go Subroutine"sv,
"Push location onto call stack and branch to specified location."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSplitRnd, macro),
"SoundMacro"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdSplitRnd, macroStep),
"SoundMacro Step"sv,
0, 65535, 0
},
}
};
bool SoundMacro::CmdGoSub::Do(SoundMacroState& st, Voice& vox) const
{
if (macro.id == std::get<0>(st.m_pc.back()))
st.m_pc.emplace_back(std::get<0>(st.m_pc.back()), std::get<1>(st.m_pc.back()),
std::get<1>(st.m_pc.back())->assertPC(macroStep));
else
vox.loadMacroObject(macro.id, macroStep, st.m_ticksPerSec, st.m_initKey, st.m_initVel, st.m_initMod, true);
vox._setObjectId(std::get<0>(st.m_pc.back()));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdTrapEvent::Introspective =
{
"Trap Event"sv,
"Register event-based branch to a specified location."sv,
{
{
FIELD_HEAD(SoundMacro::CmdTrapEvent, event),
"Event"sv,
0, 2, 0,
{
"Key Off"sv,
"Sample End"sv,
"Message Recv"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdTrapEvent, macro),
"SoundMacro"sv,
0, 65535, 0
},
{
FIELD_HEAD(SoundMacro::CmdTrapEvent, macroStep),
"SoundMacro Step"sv,
0, 65535, 0
},
}
};
bool SoundMacro::CmdTrapEvent::Do(SoundMacroState& st, Voice& vox) const
{
switch (event)
{
case EventType::KeyOff:
vox.m_keyoffTrap.macroId = macro.id;
vox.m_keyoffTrap.macroStep = macroStep;
break;
case EventType::SampleEnd:
vox.m_sampleEndTrap.macroId = macro.id;
vox.m_sampleEndTrap.macroStep = macroStep;
break;
case EventType::MessageRecv:
vox.m_messageTrap.macroId = macro.id;
vox.m_messageTrap.macroStep = macroStep;
break;
default:
break;
}
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdUntrapEvent::Introspective =
{
"Untrap Event"sv,
"Unregister event-based branch."sv,
{
{
FIELD_HEAD(SoundMacro::CmdUntrapEvent, event),
"Event"sv,
0, 2, 0,
{
"Key Off"sv,
"Sample End"sv,
"Message Recv"sv
}
}
}
};
bool SoundMacro::CmdUntrapEvent::Do(SoundMacroState& st, Voice& vox) const
{
switch (event)
{
case CmdTrapEvent::EventType::KeyOff:
vox.m_keyoffTrap.macroId = 0xffff;
vox.m_keyoffTrap.macroStep = 0xffff;
break;
case CmdTrapEvent::EventType::SampleEnd:
vox.m_sampleEndTrap.macroId = 0xffff;
vox.m_sampleEndTrap.macroStep = 0xffff;
break;
case CmdTrapEvent::EventType::MessageRecv:
vox.m_messageTrap.macroId = 0xffff;
vox.m_messageTrap.macroStep = 0xffff;
break;
default:
break;
}
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSendMessage::Introspective =
{
"Send Message"sv,
"Send message to SoundMacro or Voice referenced in a variable. "
"The message value is retrieved from a variable."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSendMessage, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdSendMessage, macro),
"SoundMacro"sv,
1, 16383, 1
},
{
FIELD_HEAD(SoundMacro::CmdSendMessage, voiceVar),
"Voice Var"sv,
0, 31, 0
},
{
FIELD_HEAD(SoundMacro::CmdSendMessage, valueVar),
"Value Var"sv,
0, 31, 0
},
}
};
bool SoundMacro::CmdSendMessage::Do(SoundMacroState& st, Voice& vox) const
{
if (isVar)
{
std::shared_ptr<Voice> findVox = vox.getEngine().findVoice(st.m_variables[voiceVar & 0x1f]);
if (findVox)
findVox->message(st.m_variables[valueVar & 0x1f]);
}
else
vox.getEngine().sendMacroMessage(macro.id, st.m_variables[valueVar & 0x1f]);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdGetMessage::Introspective =
{
"Get Message"sv,
"Get voice's latest received message and store its value in Variable."sv,
{
{
FIELD_HEAD(SoundMacro::CmdGetMessage, variable),
"Variable"sv,
0, 31, 0
}
}
};
bool SoundMacro::CmdGetMessage::Do(SoundMacroState& st, Voice& vox) const
{
st.m_variables[variable & 0x1f] = vox.m_latestMessage;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdGetVid::Introspective =
{
"Get VID"sv,
"Get ID of current voice or last voice started by Play Macro command and store in Variable."sv,
{
{
FIELD_HEAD(SoundMacro::CmdGetVid, variable),
"Variable"sv,
0, 31, 0
},
{
FIELD_HEAD(SoundMacro::CmdGetVid, playMacro),
"Play Macro"sv,
0, 1, 1
}
}
};
bool SoundMacro::CmdGetVid::Do(SoundMacroState& st, Voice& vox) const
{
st.m_variables[variable & 0x1f] = playMacro ? st.m_lastPlayMacroVid : vox.vid();
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdAddAgeCount::Introspective =
{
"Add Age Count"sv,
"Adds a value to the current voice's age counter."sv,
{
{
FIELD_HEAD(SoundMacro::CmdAddAgeCount, add),
"Add"sv,
-32768, 32767, -30000
}
}
};
bool SoundMacro::CmdAddAgeCount::Do(SoundMacroState& st, Voice& vox) const
{
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSetAgeCount::Introspective =
{
"Set Age Count"sv,
"Set a value into the current voice's age counter."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSetAgeCount, counter),
"Counter"sv,
0, 65535, 0
}
}
};
bool SoundMacro::CmdSetAgeCount::Do(SoundMacroState& st, Voice& vox) const
{
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSendFlag::Introspective =
{
"Send Flag"sv,
"Send a flag value to the host application."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSendFlag, flagId),
"Flag ID"sv,
0, 15, 0
},
{
FIELD_HEAD(SoundMacro::CmdSendFlag, value),
"Value"sv,
0, 255, 255
}
}
};
bool SoundMacro::CmdSendFlag::Do(SoundMacroState& st, Voice& vox) const
{
/* TODO: figure out a good API */
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPitchWheelR::Introspective =
{
"Pitch Wheel Range"sv,
"Specifies the number of note steps for the range of the pitch wheel."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPitchWheelR, rangeUp),
"Range Up"sv,
0, 127, 2
},
{
FIELD_HEAD(SoundMacro::CmdPitchWheelR, rangeDown),
"Range Down"sv,
0, 127, 2
}
}
};
bool SoundMacro::CmdPitchWheelR::Do(SoundMacroState& st, Voice& vox) const
{
vox.setPitchWheelRange(rangeUp, rangeDown);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSetPriority::Introspective =
{
"Set Priority"sv,
"Sets the priority of the current voice."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSetPriority, prio),
"Priority"sv,
0, 254, 50
}
}
};
bool SoundMacro::CmdSetPriority::Do(SoundMacroState& st, Voice& vox) const
{
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdAddPriority::Introspective =
{
"Add Priority"sv,
"Adds to the priority of the current voice."sv,
{
{
FIELD_HEAD(SoundMacro::CmdAddPriority, prio),
"Priority"sv,
-255, 255, 1
}
}
};
bool SoundMacro::CmdAddPriority::Do(SoundMacroState& st, Voice& vox) const
{
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdAgeCntSpeed::Introspective =
{
"Age Count Speed"sv,
"Sets the speed the current voice's age counter is decremented."sv,
{
{
FIELD_HEAD(SoundMacro::CmdAgeCntSpeed, time),
"Millisec"sv,
0, 16777215, 1080000
}
}
};
bool SoundMacro::CmdAgeCntSpeed::Do(SoundMacroState& st, Voice& vox) const
{
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdAgeCntVel::Introspective =
{
"Age Count Velocity"sv,
"Sets the current voice's age counter by scaling the velocity."sv,
{
{
FIELD_HEAD(SoundMacro::CmdAgeCntVel, ageBase),
"Base"sv,
0, 65535, 60000
},
{
FIELD_HEAD(SoundMacro::CmdAgeCntVel, ageScale),
"Scale"sv,
0, 65535, 127
}
}
};
bool SoundMacro::CmdAgeCntVel::Do(SoundMacroState& st, Voice& vox) const
{
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdVolSelect::Introspective =
{
"Volume Select"sv,
"Appends an evaluator component for computing the voice's volume."sv,
{
{
FIELD_HEAD(SoundMacro::CmdVolSelect, midiControl),
"MIDI Control"sv,
0, 132, 7
},
{
FIELD_HEAD(SoundMacro::CmdVolSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdVolSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdVolSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdVolSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdVolSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_volumeSel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPanSelect::Introspective =
{
"Pan Select"sv,
"Appends an evaluator component for computing the voice's pan."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPanSelect, midiControl),
"MIDI Control"sv,
0, 132, 10
},
{
FIELD_HEAD(SoundMacro::CmdPanSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdPanSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdPanSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdPanSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdPanSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_panSel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPitchWheelSelect::Introspective =
{
"Pitch Wheel Select"sv,
"Appends an evaluator component for computing the voice's pitch wheel."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPitchWheelSelect, midiControl),
"MIDI Control"sv,
0, 132, 128
},
{
FIELD_HEAD(SoundMacro::CmdPitchWheelSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdPitchWheelSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdPitchWheelSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdPitchWheelSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdPitchWheelSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_pitchWheelSel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdModWheelSelect::Introspective =
{
"Mod Wheel Select"sv,
"Appends an evaluator component for computing the voice's mod wheel."sv,
{
{
FIELD_HEAD(SoundMacro::CmdModWheelSelect, midiControl),
"MIDI Control"sv,
0, 132, 1
},
{
FIELD_HEAD(SoundMacro::CmdModWheelSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdModWheelSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdModWheelSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdModWheelSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdModWheelSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_modWheelSel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPedalSelect::Introspective =
{
"Pedal Select"sv,
"Appends an evaluator component for computing the voice's pedal."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPedalSelect, midiControl),
"MIDI Control"sv,
0, 132, 1
},
{
FIELD_HEAD(SoundMacro::CmdPedalSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdPedalSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdPedalSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdPedalSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdPedalSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_pedalSel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPortamentoSelect::Introspective =
{
"Portamento Select"sv,
"Appends an evaluator component for computing the voice's portamento."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPortamentoSelect, midiControl),
"MIDI Control"sv,
0, 132, 1
},
{
FIELD_HEAD(SoundMacro::CmdPortamentoSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdPortamentoSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdPortamentoSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdPortamentoSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdPortamentoSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_portamentoSel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdReverbSelect::Introspective =
{
"Reverb Select"sv,
"Appends an evaluator component for computing the voice's reverb."sv,
{
{
FIELD_HEAD(SoundMacro::CmdReverbSelect, midiControl),
"MIDI Control"sv,
0, 132, 1
},
{
FIELD_HEAD(SoundMacro::CmdReverbSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdReverbSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdReverbSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdReverbSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdReverbSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_reverbSel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSpanSelect::Introspective =
{
"Span Select"sv,
"Appends an evaluator component for computing the voice's span."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSpanSelect, midiControl),
"MIDI Control"sv,
0, 132, 19
},
{
FIELD_HEAD(SoundMacro::CmdSpanSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdSpanSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdSpanSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdSpanSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdSpanSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_spanSel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdDopplerSelect::Introspective =
{
"Doppler Select"sv,
"Appends an evaluator component for computing the voice's doppler."sv,
{
{
FIELD_HEAD(SoundMacro::CmdDopplerSelect, midiControl),
"MIDI Control"sv,
0, 132, 132
},
{
FIELD_HEAD(SoundMacro::CmdDopplerSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdDopplerSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdDopplerSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdDopplerSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdDopplerSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_dopplerSel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdTremoloSelect::Introspective =
{
"Tremolo Select"sv,
"Appends an evaluator component for computing the voice's tremolo."sv,
{
{
FIELD_HEAD(SoundMacro::CmdTremoloSelect, midiControl),
"MIDI Control"sv,
0, 132, 1
},
{
FIELD_HEAD(SoundMacro::CmdTremoloSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdTremoloSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdTremoloSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdTremoloSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdTremoloSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_tremoloSel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPreASelect::Introspective =
{
"PreA Select"sv,
"Appends an evaluator component for computing the voice's pre-AUXA."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPreASelect, midiControl),
"MIDI Control"sv,
0, 132, 1
},
{
FIELD_HEAD(SoundMacro::CmdPreASelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdPreASelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdPreASelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdPreASelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdPreASelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_preAuxASel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPreBSelect::Introspective =
{
"PreB Select"sv,
"Appends an evaluator component for computing the voice's pre-AUXB."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPreBSelect, midiControl),
"MIDI Control"sv,
0, 132, 1
},
{
FIELD_HEAD(SoundMacro::CmdPreBSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdPreBSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdPreBSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdPreBSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdPreBSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_preAuxBSel.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdPostBSelect::Introspective =
{
"PostB Select"sv,
"Appends an evaluator component for computing the voice's post-AUXB."sv,
{
{
FIELD_HEAD(SoundMacro::CmdPostBSelect, midiControl),
"MIDI Control"sv,
0, 132, 1
},
{
FIELD_HEAD(SoundMacro::CmdPostBSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdPostBSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdPostBSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdPostBSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
}
}
};
bool SoundMacro::CmdPostBSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_postAuxB.addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdAuxAFXSelect::Introspective =
{
"AuxA FX Select"sv,
"Appends an evaluator component for computing the AUXA Parameter."sv,
{
{
FIELD_HEAD(SoundMacro::CmdAuxAFXSelect, midiControl),
"MIDI Control"sv,
0, 132, 1
},
{
FIELD_HEAD(SoundMacro::CmdAuxAFXSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdAuxAFXSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdAuxAFXSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdAuxAFXSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
},
{
FIELD_HEAD(SoundMacro::CmdAuxAFXSelect, paramIndex),
"Param Index"sv,
0, 2, 0
}
}
};
bool SoundMacro::CmdAuxAFXSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_auxAFxSel[std::min(paramIndex, atUint8(3))].
addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdAuxBFXSelect::Introspective =
{
"AuxB FX Select"sv,
"Appends an evaluator component for computing the AUXB Parameter."sv,
{
{
FIELD_HEAD(SoundMacro::CmdAuxBFXSelect, midiControl),
"MIDI Control"sv,
0, 132, 1
},
{
FIELD_HEAD(SoundMacro::CmdAuxBFXSelect, scalingPercentage),
"Scale Percentage"sv,
-10000, 10000, 100
},
{
FIELD_HEAD(SoundMacro::CmdAuxBFXSelect, combine),
"Combine Mode"sv,
0, 2, 0,
{
"Set"sv,
"Add"sv,
"Mult"sv
}
},
{
FIELD_HEAD(SoundMacro::CmdAuxBFXSelect, isVar),
"Is Var"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdAuxBFXSelect, fineScaling),
"Fine Scaling"sv,
-100, 100, 0
},
{
FIELD_HEAD(SoundMacro::CmdAuxBFXSelect, paramIndex),
"Param Index"sv,
0, 2, 0
}
}
};
bool SoundMacro::CmdAuxBFXSelect::Do(SoundMacroState& st, Voice& vox) const
{
st.m_auxBFxSel[std::min(paramIndex, atUint8(3))].
addComponent(midiControl, (scalingPercentage + fineScaling / 100.f) / 100.f,
SoundMacroState::Evaluator::Combine(combine),
SoundMacroState::Evaluator::VarType(isVar));
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSetupLFO::Introspective =
{
"Setup LFO"sv,
"Configures voice's LFO period in milliseconds."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSetupLFO, lfoNumber),
"LFO Number"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdSetupLFO, periodInMs),
"Period"sv,
-10000, 10000, 100
}
}
};
bool SoundMacro::CmdSetupLFO::Do(SoundMacroState& st, Voice& vox) const
{
if (lfoNumber == 0)
vox.setLFO1Period(periodInMs / 1000.f);
else if (lfoNumber == 1)
vox.setLFO2Period(periodInMs / 1000.f);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdModeSelect::Introspective =
{
"Mode Select"sv,
"Sets operating modes for current voice."sv,
{
{
FIELD_HEAD(SoundMacro::CmdModeSelect, dlsVol),
"DLS Vol"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdModeSelect, itd),
"ITD"sv,
0, 1, 0
}
}
};
bool SoundMacro::CmdModeSelect::Do(SoundMacroState& st, Voice& vox) const
{
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSetKeygroup::Introspective =
{
"Set Keygroup"sv,
"Selects keygroup for current voice."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSetKeygroup, group),
"Group"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdSetKeygroup, killNow),
"Kill now"sv,
0, 1, 0
}
}
};
bool SoundMacro::CmdSetKeygroup::Do(SoundMacroState& st, Voice& vox) const
{
vox.setKeygroup(0);
if (group)
{
vox.getEngine().killKeygroup(group, killNow);
vox.setKeygroup(group);
}
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSRCmodeSelect::Introspective =
{
"SRC Mode Select"sv,
"Sets operating modes for sample rate converter."sv,
{
{
FIELD_HEAD(SoundMacro::CmdSRCmodeSelect, srcType),
"SRC Type"sv,
0, 2, 0
},
{
FIELD_HEAD(SoundMacro::CmdSRCmodeSelect, type0SrcFilter),
"Type 0 SRC Filter"sv,
0, 2, 1
}
}
};
bool SoundMacro::CmdSRCmodeSelect::Do(SoundMacroState& st, Voice& vox) const
{
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdAddVars::Introspective =
{
"Add Vars"sv,
"A = B + C"sv,
{
{
FIELD_HEAD(SoundMacro::CmdAddVars, varCtrlA),
"Use Ctrl A"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdAddVars, a),
"A"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdAddVars, varCtrlB),
"Use Ctrl B"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdAddVars, b),
"B"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdAddVars, varCtrlC),
"Use Ctrl C"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdAddVars, c),
"C"sv,
0, 255, 0
},
}
};
bool SoundMacro::CmdAddVars::Do(SoundMacroState& st, Voice& vox) const
{
int32_t useB, useC;
if (varCtrlB)
useB = vox.getCtrlValue(b);
else
useB = st.m_variables[b & 0x1f];
if (varCtrlC)
useC = vox.getCtrlValue(c);
else
useC = st.m_variables[c & 0x1f];
if (varCtrlA)
vox.setCtrlValue(a, useB + useC);
else
st.m_variables[a & 0x1f] = useB + useC;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSubVars::Introspective =
{
"Sub Vars"sv,
"A = B - C"sv,
{
{
FIELD_HEAD(SoundMacro::CmdSubVars, varCtrlA),
"Use Ctrl A"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdSubVars, a),
"A"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdSubVars, varCtrlB),
"Use Ctrl B"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdSubVars, b),
"B"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdSubVars, varCtrlC),
"Use Ctrl C"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdSubVars, c),
"C"sv,
0, 255, 0
},
}
};
bool SoundMacro::CmdSubVars::Do(SoundMacroState& st, Voice& vox) const
{
int32_t useB, useC;
if (varCtrlB)
useB = vox.getCtrlValue(b);
else
useB = st.m_variables[b & 0x1f];
if (varCtrlC)
useC = vox.getCtrlValue(c);
else
useC = st.m_variables[c & 0x1f];
if (varCtrlA)
vox.setCtrlValue(a, useB - useC);
else
st.m_variables[a & 0x1f] = useB - useC;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdMulVars::Introspective =
{
"Mul Vars"sv,
"A = B * C"sv,
{
{
FIELD_HEAD(SoundMacro::CmdMulVars, varCtrlA),
"Use Ctrl A"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdMulVars, a),
"A"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdMulVars, varCtrlB),
"Use Ctrl B"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdMulVars, b),
"B"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdMulVars, varCtrlC),
"Use Ctrl C"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdMulVars, c),
"C"sv,
0, 255, 0
},
}
};
bool SoundMacro::CmdMulVars::Do(SoundMacroState& st, Voice& vox) const
{
int32_t useB, useC;
if (varCtrlB)
useB = vox.getCtrlValue(b);
else
useB = st.m_variables[b & 0x1f];
if (varCtrlC)
useC = vox.getCtrlValue(c);
else
useC = st.m_variables[c & 0x1f];
if (varCtrlA)
vox.setCtrlValue(a, useB * useC);
else
st.m_variables[a & 0x1f] = useB * useC;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdDivVars::Introspective =
{
"Div Vars"sv,
"A = B / C"sv,
{
{
FIELD_HEAD(SoundMacro::CmdDivVars, varCtrlA),
"Use Ctrl A"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdDivVars, a),
"A"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdDivVars, varCtrlB),
"Use Ctrl B"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdDivVars, b),
"B"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdDivVars, varCtrlC),
"Use Ctrl C"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdDivVars, c),
"C"sv,
0, 255, 0
},
}
};
bool SoundMacro::CmdDivVars::Do(SoundMacroState& st, Voice& vox) const
{
int32_t useB, useC;
if (varCtrlB)
useB = vox.getCtrlValue(b);
else
useB = st.m_variables[b & 0x1f];
if (varCtrlC)
useC = vox.getCtrlValue(c);
else
useC = st.m_variables[c & 0x1f];
if (varCtrlA)
vox.setCtrlValue(a, useB / useC);
else
st.m_variables[a & 0x1f] = useB / useC;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdAddIVars::Introspective =
{
"Add Imm Vars"sv,
"A = B + Immediate"sv,
{
{
FIELD_HEAD(SoundMacro::CmdAddIVars, varCtrlA),
"Use Ctrl A"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdAddIVars, a),
"A"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdAddIVars, varCtrlB),
"Use Ctrl B"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdAddIVars, b),
"B"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdAddIVars, imm),
"Immediate"sv,
-32768, 32767, 0
},
}
};
bool SoundMacro::CmdAddIVars::Do(SoundMacroState& st, Voice& vox) const
{
int32_t useB;
if (varCtrlB)
useB = vox.getCtrlValue(b);
else
useB = st.m_variables[b & 0x1f];
if (varCtrlA)
vox.setCtrlValue(a, useB + imm);
else
st.m_variables[a & 0x1f] = useB + imm;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdSetVar::Introspective =
{
"Set Var"sv,
"A = Immediate"sv,
{
{
FIELD_HEAD(SoundMacro::CmdSetVar, varCtrlA),
"Use Ctrl A"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdSetVar, a),
"A"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdSetVar, imm),
"Immediate"sv,
-32768, 32767, 0
},
}
};
bool SoundMacro::CmdSetVar::Do(SoundMacroState& st, Voice& vox) const
{
if (varCtrlA)
vox.setCtrlValue(a, imm);
else
st.m_variables[a & 0x1f] = imm;
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdIfEqual::Introspective =
{
"If Equal"sv,
"Branches to specified step if A == B."sv,
{
{
FIELD_HEAD(SoundMacro::CmdIfEqual, varCtrlA),
"Use Ctrl A"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdIfEqual, a),
"A"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdIfEqual, varCtrlB),
"Use Ctrl B"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdIfEqual, b),
"B"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdIfEqual, notEq),
"Not"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdIfEqual, macroStep),
"SoundMacro Step"sv,
0, 65535, 0
},
}
};
bool SoundMacro::CmdIfEqual::Do(SoundMacroState& st, Voice& vox) const
{
int32_t useA, useB;
if (varCtrlA)
useA = vox.getCtrlValue(a);
else
useA = st.m_variables[a & 0x1f];
if (varCtrlB)
useB = vox.getCtrlValue(b);
else
useB = st.m_variables[b & 0x1f];
if ((useA == useB) ^ notEq)
st._setPC(macroStep);
return false;
}
const SoundMacro::CmdIntrospection SoundMacro::CmdIfLess::Introspective =
{
"If Less"sv,
"Branches to specified step if A < B."sv,
{
{
FIELD_HEAD(SoundMacro::CmdIfLess, varCtrlA),
"Use Ctrl A"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdIfLess, a),
"A"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdIfLess, varCtrlB),
"Use Ctrl B"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdIfLess, b),
"B"sv,
0, 255, 0
},
{
FIELD_HEAD(SoundMacro::CmdIfLess, notLt),
"Not"sv,
0, 1, 0
},
{
FIELD_HEAD(SoundMacro::CmdIfLess, macroStep),
"SoundMacro Step"sv,
0, 65535, 0
},
}
};
bool SoundMacro::CmdIfLess::Do(SoundMacroState& st, Voice& vox) const
{
int32_t useA, useB;
if (varCtrlA)
useA = vox.getCtrlValue(a);
else
useA = st.m_variables[a & 0x1f];
if (varCtrlB)
useB = vox.getCtrlValue(b);
else
useB = st.m_variables[b & 0x1f];
if ((useA < useB) ^ notLt)
st._setPC(macroStep);
return false;
}
bool SoundMacroState::advance(Voice& vox, double dt)
{
/* Nothing if uninitialized or finished */
if (m_pc.empty() || std::get<1>(m_pc.back()) == nullptr || std::get<2>(m_pc.back()) == -1)
return true;
/* Loop through as many commands as we can for this time period */
while (true)
{
/* Advance wait timer if active, returning if waiting */
if (m_inWait)
{
if (m_keyoffWait && m_keyoff)
m_inWait = false;
else if (m_sampleEndWait && m_sampleEnd)
m_inWait = false;
else if (!m_indefiniteWait)
{
m_waitCountdown -= dt;
if (m_waitCountdown < 0.f)
m_inWait = false;
}
if (m_inWait)
{
m_execTime += dt;
return false;
}
}
/* Load next command based on counter */
const SoundMacro::ICmd& cmd = std::get<1>(m_pc.back())->getCmd(std::get<2>(m_pc.back())++);
/* Perform function of command */
if (cmd.Do(*this, vox))
return true;
}
m_execTime += dt;
return false;
}
void SoundMacroState::keyoffNotify(Voice& vox) { m_keyoff = true; }
void SoundMacroState::sampleEndNotify(Voice& vox) { m_sampleEnd = true; }
}
Reference in New Issue View Git Blame Copy Permalink