audio/trommelkiste
2
0
Fork 0
mirror of https://codeberg.org/armin/trommelkiste.git synced 2026-09-01 04:10:46 +02:00
Code Issues Projects Releases Packages Wiki Activity
trommelkiste/Source/PluginProcessor.cpp

841 lines
29 KiB
C++
Raw Blame History

#include "PluginProcessor.h"
#include "PluginEditor.h"
#include <BinaryData.h>
#include <SampleLibrary.h>
using namespace juce;
TrommelkisteProcessor::TrommelkisteProcessor()
: AudioProcessor(BusesProperties()
.withOutput("Output", juce::AudioChannelSet::stereo(), true)),
apvts(*this, nullptr, "Parameters", createParameterLayout())
{
formatManager.registerBasicFormats();
scanSamples();
loadKit(0);
}
TrommelkisteProcessor::~TrommelkisteProcessor() {}
std::optional<juce::String> TrommelkisteProcessor::getNameForMidiNoteNumber(int note, int)
{
static const char* names[] = {"BD", "RS", "SN", "CL", "CH", "PH", "OH", "RD", "LT", "MT"};
int t = note - BASE_NOTE;
if (t >= 0 && t < NUM_TRACKS)
return juce::String(names[t]);
return std::nullopt;
}
void TrommelkisteProcessor::prepareToPlay(double sr, int)
{
currentSampleRate = sr;
juce::dsp::ProcessSpec spec;
spec.sampleRate = sr;
spec.maximumBlockSize = 512;
spec.numChannels = 2;
reverb.prepare(spec);
reverbParams.roomSize = 0.5f;
reverbParams.damping = 0.5f;
reverbParams.wetLevel = 0.33f;
reverbParams.dryLevel = 0.8f;
reverbParams.width = 1.0f;
reverbParams.freezeMode = 0.0f;
reverb.setParameters(reverbParams);
const int delaySamples = DELAY_BUFFER_SECONDS * (int)sr;
delayBuffer.setSize(2, delaySamples);
delayBuffer.clear();
delayWritePos = 0;
}
void TrommelkisteProcessor::releaseResources() {}
void TrommelkisteProcessor::processBlock(juce::AudioBuffer<float>& buffer, juce::MidiBuffer& midi)
{
juce::ScopedNoDenormals nd;
const int numSamples = buffer.getNumSamples();
buffer.clear();
for (int i = 0; i < NUM_TRACKS; ++i)
trackActive[i] = false;
// Shuffle: add ghost notes (bar-quantized)
const float globalShuffleAmt = apvts.getRawParameterValue("global_shuffleAmount")->load();
const float globalGroove = apvts.getRawParameterValue("global_groove")->load();
const int shuffleDivIdx = (int)apvts.getRawParameterValue("global_shuffleDiv")->load();
// 0=OFF, 1=every 4 bars, 2=every 8, 3=every 16, 4=every 32
static constexpr int shuffleDivBars[] = { 0, 4, 8, 16, 32 };
const int divBars = shuffleDivBars[juce::jlimit(0, 4, shuffleDivIdx)];
// Try to get transport info from play head
bool hasTransport = false;
int64_t currentBar = 0;
double ppq = 0.0;
double bpm = 120.0;
if (auto* ph = getPlayHead())
{
auto info = ph->getPosition();
if (info.hasValue() && info->getPpqPosition().hasValue())
{
hasTransport = true;
ppq = *info->getPpqPosition();
if (info->getBpm().hasValue())
bpm = *info->getBpm();
double beatsPerBar = 4.0;
if (info->getTimeSignature().hasValue())
beatsPerBar = (double)(*info->getTimeSignature()).numerator;
currentBar = (int64_t)(ppq / beatsPerBar);
}
}
const bool barAllowed = (divBars == 0) || !hasTransport || (currentBar % divBars == 0);
// 16th note grid quantization (DAW shuffle is reflected in PPQ)
const double ppqPerSample = bpm / (60.0 * currentSampleRate);
const double sixteenthPpq = 0.25;
auto nextGridPpq = [&](double fromPpq) -> double {
return std::ceil((fromPpq + 0.0001) / sixteenthPpq) * sixteenthPpq;
};
// Process pending shuffle events
for (int i = numPendingShuffle - 1; i >= 0; --i)
{
pendingShuffle[i].delaySamples -= numSamples;
if (pendingShuffle[i].delaySamples <= 0)
{
handleNoteOn(pendingShuffle[i].trackIndex, pendingShuffle[i].velocity);
pendingShuffle[i] = pendingShuffle[--numPendingShuffle];
}
}
std::uniform_real_distribution<float> dist(0.0f, 1.0f);
for (const auto metadata : midi)
{
auto msg = metadata.getMessage();
if (msg.isNoteOn())
{
int t = msg.getNoteNumber() - BASE_NOTE;
if (t >= 0 && t < NUM_TRACKS)
{
handleNoteOn(t, msg.getFloatVelocity());
lastTriggeredTrack = t;
const float shuffleAmt = apvts.getRawParameterValue(
"t" + juce::String(t) + "_shuffle")->load();
const float effShuffle = shuffleAmt * globalShuffleAmt;
if (effShuffle > 0.0f && barAllowed)
{
int numEvents = juce::jmax(1, (int)(effShuffle * 3.0f + 0.5f));
numEvents = std::uniform_int_distribution<int>(0, numEvents)(rng);
for (int e = 0; e < numEvents; ++e)
{
float vel = msg.getFloatVelocity() * (0.3f + dist(rng) * 0.7f) * effShuffle;
int stepsAhead = std::uniform_int_distribution<int>(1, 4)(rng);
double gridPpq = nextGridPpq(ppq) + stepsAhead * sixteenthPpq;
int delay = juce::jmax(1, (int)((gridPpq - ppq) / ppqPerSample));
if (numPendingShuffle < MAX_PENDING_SHUFFLE)
pendingShuffle[numPendingShuffle++] = { t, vel, delay };
}
}
}
}
else if (msg.isNoteOff())
{
int t = msg.getNoteNumber() - BASE_NOTE;
if (t >= 0 && t < NUM_TRACKS)
handleNoteOff(t);
}
}
auto* outL = buffer.getWritePointer(0);
auto* outR = buffer.getNumChannels() > 1 ? buffer.getWritePointer(1) : nullptr;
// Temporary send buffers
juce::AudioBuffer<float> delaySend(2, numSamples);
juce::AudioBuffer<float> reverbSend(2, numSamples);
delaySend.clear();
reverbSend.clear();
for (auto& v : voices)
{
if (!v.active)
continue;
const int ti = v.trackIndex;
trackActive[ti] = true;
auto& track = tracks[ti];
const juce::SpinLock::ScopedLockType sl(track.lock);
const int bufLen = track.buffer.getNumSamples();
if (bufLen == 0)
{
v.active = false;
continue;
}
const juce::String p = "t" + juce::String(ti) + "_";
const float level = apvts.getRawParameterValue(p + "level")->load();
const float length = apvts.getRawParameterValue(p + "length")->load();
const float velAmt = apvts.getRawParameterValue(p + "velocity")->load();
const float pitchSemitones = apvts.getRawParameterValue(p + "pitch")->load();
const float toneHz = apvts.getRawParameterValue(p + "tone")->load();
const float pan = apvts.getRawParameterValue(p + "pan")->load();
const bool decayGate = apvts.getRawParameterValue(p + "decay")->load() > 0.5f;
const float delaySendAmt = apvts.getRawParameterValue(p + "delaySend")->load();
const float reverbSendAmt = apvts.getRawParameterValue(p + "reverbSend")->load();
const float ringModAmt = apvts.getRawParameterValue(p + "ringMod")->load();
const float destructionAmt = apvts.getRawParameterValue(p + "destruction")->load();
float pitchRatio = std::pow(2.0f, pitchSemitones / 12.0f)
* (float)track.fileSampleRate / (float)currentSampleRate;
const float maxSamples = length * (float)currentSampleRate;
const float toneA = (toneHz < 19000.0f)
? std::exp(-2.0f * juce::MathConstants<float>::pi * toneHz / (float)currentSampleRate)
: 0.0f;
const float effVel = 1.0f - velAmt + velAmt * v.noteVelocity;
const float gain = level * effVel;
const float panAngle = (pan + 1.0f) * 0.25f * juce::MathConstants<float>::pi;
const float panL = std::cos(panAngle) * juce::Decibels::decibelsToGain(-3.0f);
const float panR = std::sin(panAngle) * juce::Decibels::decibelsToGain(-3.0f);
const float* sData = track.buffer.getReadPointer(0);
const bool hasR = track.buffer.getNumChannels() > 1;
const float* sDataR = hasR ? track.buffer.getReadPointer(1) : nullptr;
const float globalRingFreq = apvts.getRawParameterValue("global_ringFreq")->load();
const float globalDestr = apvts.getRawParameterValue("global_destruction")->load();
const float ringModInc = 2.0f * juce::MathConstants<float>::pi * globalRingFreq / (float)currentSampleRate;
for (int s = 0; s < numSamples; ++s)
{
if (!v.active)
break;
float env = 1.0f;
if (!decayGate)
{
env = 1.0f - (float)v.samplesPlayed / maxSamples;
if (env <= 0.0f) { v.active = false; break; }
}
else
{
if (v.samplesPlayed >= (int)maxSamples) { v.active = false; break; }
}
int pos0 = (int)v.position;
if (pos0 >= bufLen) { v.active = false; break; }
const float frac = v.position - (float)pos0;
int pos1 = pos0 + 1;
if (pos1 >= bufLen) pos1 = bufLen - 1;
float smplL = sData[pos0] + (sData[pos1] - sData[pos0]) * frac;
float smplR = hasR ? (sDataR[pos0] + (sDataR[pos1] - sDataR[pos0]) * frac) : smplL;
if (toneA > 0.0f)
{
v.filterStateL = (1.0f - toneA) * smplL + toneA * v.filterStateL;
smplL = v.filterStateL;
v.filterStateR = (1.0f - toneA) * smplR + toneA * v.filterStateR;
smplR = v.filterStateR;
}
// Ring modulation
if (ringModAmt > 0.0f)
{
float mod = std::sin(v.ringModPhase);
smplL = smplL * (1.0f - ringModAmt + ringModAmt * mod);
smplR = smplR * (1.0f - ringModAmt + ringModAmt * mod);
v.ringModPhase += ringModInc;
if (v.ringModPhase >= 2.0f * juce::MathConstants<float>::pi)
v.ringModPhase -= 2.0f * juce::MathConstants<float>::pi;
}
// Destruction (soft clip + bitcrush)
const float effDestr = juce::jmin(1.0f, destructionAmt + globalDestr);
if (effDestr > 0.0f)
{
float drive = 1.0f + effDestr * 19.0f;
smplL = std::tanh(smplL * drive);
smplR = std::tanh(smplR * drive);
float bits = juce::jmax(2.0f, 16.0f - effDestr * 14.0f);
float levels = std::pow(2.0f, bits);
smplL = std::round(smplL * levels) / levels;
smplR = std::round(smplR * levels) / levels;
}
smplL *= env * gain;
smplR *= env * gain;
outL[s] += smplL * panL;
if (outR)
outR[s] += smplR * panR;
// Send to effects
delaySend.addSample(0, s, smplL * delaySendAmt);
delaySend.addSample(1, s, smplR * delaySendAmt);
reverbSend.addSample(0, s, smplL * reverbSendAmt);
reverbSend.addSample(1, s, smplR * reverbSendAmt);
v.position += pitchRatio;
++v.samplesPlayed;
if (v.position >= (float)bufLen)
v.active = false;
}
}
// Read master effect levels
const float masterDelayMix = apvts.getRawParameterValue("master_delay")->load();
const float masterReverbMix = apvts.getRawParameterValue("master_reverb")->load();
// Delay sync
const int delaySyncDiv = (int)apvts.getRawParameterValue("delay_syncDiv")->load();
float delayTimeSec = 0.45f; // default free-running delay time
if (delaySyncDiv >= 1 && delaySyncDiv <= 8)
{
double bpm = 120.0;
if (auto* ph = getPlayHead())
{
auto info = ph->getPosition();
if (info.hasValue() && info->getBpm().hasValue())
bpm = *info->getBpm();
}
double beats = delaySyncDiv * 0.25;
delayTimeSec = (float)(beats * 60.0 / bpm);
}
// Process delay
const int delaySamples = delayBuffer.getNumSamples();
auto* delL = delayBuffer.getWritePointer(0);
auto* delR = delayBuffer.getNumChannels() > 1
? delayBuffer.getWritePointer(1) : nullptr;
const float feedback = 0.4f;
const float delayMix = 0.3f;
const int delayTimeSamples = (int)(delayTimeSec * currentSampleRate);
for (int s = 0; s < numSamples; ++s)
{
const int readPos = (delayWritePos - delayTimeSamples + delaySamples)
% delaySamples;
const float delOutL = delL[readPos];
const float delOutR = delR ? delR[readPos] : delOutL;
delL[delayWritePos] = delaySend.getSample(0, s) + delOutL * feedback;
if (delR)
delR[delayWritePos] = delaySend.getSample(1, s) + delOutR * feedback;
outL[s] += delOutL * delayMix * masterDelayMix;
if (outR)
outR[s] += delOutR * delayMix * masterDelayMix;
delayWritePos = (delayWritePos + 1) % delaySamples;
}
// Process reverb
juce::dsp::AudioBlock<float> reverbBlock(reverbSend);
juce::dsp::ProcessContextReplacing<float> reverbCtx(reverbBlock);
reverb.process(reverbCtx);
for (int s = 0; s < numSamples; ++s)
{
outL[s] += reverbSend.getSample(0, s) * masterReverbMix;
if (outR)
outR[s] += reverbSend.getSample(1, s) * masterReverbMix;
}
// Master volume & pan
const float masterVol = apvts.getRawParameterValue("master_volume")->load();
const float masterPan = apvts.getRawParameterValue("master_pan")->load();
const float mPanAngle = (masterPan + 1.0f) * 0.25f * MathConstants<float>::pi;
const float mPanL = std::cos(mPanAngle) * Decibels::decibelsToGain(-3.0f);
const float mPanR = std::sin(mPanAngle) * Decibels::decibelsToGain(-3.0f);
for (int s = 0; s < numSamples; ++s)
{
float tmpL = outL[s] * mPanL * masterVol;
float tmpR = outR ? outR[s] * mPanR * masterVol : tmpL;
outL[s] = tmpL;
if (outR)
outR[s] = tmpR;
}
float peak = 0.0f;
for (int s = 0; s < numSamples; ++s)
{
float a = std::abs(outL[s]);
if (outR)
a = jmax(a, std::abs(outR[s]));
if (a > peak)
peak = a;
}
outputLevel.store(peak, std::memory_order_relaxed);
}
int TrommelkisteProcessor::findFreeVoice(int trackIndex)
{
for (int i = 0; i < MAX_VOICES; ++i)
if (!voices[i].active)
return i;
int oldest = 0, bestAge = -1;
for (int i = 0; i < MAX_VOICES; ++i)
{
if (voices[i].trackIndex == trackIndex && voices[i].samplesPlayed > bestAge)
{
bestAge = voices[i].samplesPlayed;
oldest = i;
}
}
if (bestAge >= 0)
return oldest;
oldest = 0;
bestAge = -1;
for (int i = 0; i < MAX_VOICES; ++i)
{
if (voices[i].samplesPlayed > bestAge)
{
bestAge = voices[i].samplesPlayed;
oldest = i;
}
}
return oldest;
}
void TrommelkisteProcessor::handleNoteOn(int trackIndex, float velocity)
{
int idx = findFreeVoice(trackIndex);
auto& v = voices[idx];
v.active = true;
v.trackIndex = trackIndex;
v.position = 0.0f;
v.samplesPlayed = 0;
v.filterStateL = 0.0f;
v.filterStateR = 0.0f;
v.noteVelocity = velocity;
}
void TrommelkisteProcessor::handleNoteOff(int trackIndex)
{
for (auto& v : voices)
{
if (v.active && v.trackIndex == trackIndex)
{
const bool decayGate = apvts.getRawParameterValue(
"t" + juce::String(trackIndex) + "_decay")->load() > 0.5f;
if (decayGate)
v.active = false;
}
}
}
void TrommelkisteProcessor::loadSample(int trackIndex, const juce::File& file)
{
if (trackIndex < 0 || trackIndex >= NUM_TRACKS)
return;
std::unique_ptr<juce::AudioFormatReader> reader(formatManager.createReaderFor(file));
if (reader == nullptr)
return;
juce::AudioBuffer<float> newBuf(reader->numChannels, (int)reader->lengthInSamples);
reader->read(&newBuf, 0, (int)reader->lengthInSamples, 0, true, true);
{
const juce::SpinLock::ScopedLockType sl(tracks[trackIndex].lock);
tracks[trackIndex].buffer = std::move(newBuf);
tracks[trackIndex].fileSampleRate = (int)reader->sampleRate;
tracks[trackIndex].filePath = file.getFullPathName();
}
}
void TrommelkisteProcessor::clearSample(int trackIndex)
{
if (trackIndex < 0 || trackIndex >= NUM_TRACKS)
return;
const juce::SpinLock::ScopedLockType sl(tracks[trackIndex].lock);
tracks[trackIndex].buffer.setSize(1, 0);
tracks[trackIndex].filePath = "";
}
static void readAudioFromBuffer(juce::AudioFormatManager& fmtMgr,
juce::AudioBuffer<float>& dest,
int& destSampleRate,
const char* data, int size)
{
auto memStream = std::make_unique<juce::MemoryInputStream>(data, size, false);
std::unique_ptr<juce::AudioFormatReader> reader(fmtMgr.createReaderFor(std::move(memStream)));
if (reader == nullptr)
return;
dest.setSize((int)reader->numChannels, (int)reader->lengthInSamples);
reader->read(&dest, 0, (int)reader->lengthInSamples, 0, true, true);
destSampleRate = (int)reader->sampleRate;
}
// ── Sample library ─────────────────────────────────────────────
static bool matchesPrefix(const juce::String& name, const juce::String& prefix)
{
return name.toUpperCase().startsWith(prefix.toUpperCase());
}
void TrommelkisteProcessor::scanSamples()
{
static const char* prefixes[][8] = {
{ "BT", nullptr }, // 0 BD
{ "RIM", nullptr }, // 1 RS
{ "ST", "STAT", nullptr }, // 2 SN
{ "HANDCLP", nullptr }, // 3 CL
{ "HHCD", nullptr }, // 4 CH
{ "CLOP", nullptr }, // 5 PH
{ "HHOD", nullptr }, // 6 OH
{ "RIDE", nullptr }, // 7 RD
{ "LT", nullptr }, // 8 LT
{ "MT", nullptr }, // 9 MT
};
for (int t = 0; t < NUM_TRACKS; ++t)
{
trackSamples[t].clear();
currentSampleIndex[t] = -1;
}
for (int i = 0; i < numEmbeddedSamples; ++i)
{
const auto& es = embeddedSamples[i];
juce::String name(es.name);
for (int t = 0; t < NUM_TRACKS; ++t)
{
for (int p = 0; prefixes[t][p] != nullptr; ++p)
{
if (matchesPrefix(name, prefixes[t][p]))
{
SampleRef ref;
ref.name = name;
ref.data = es.data;
ref.dataSize = es.size;
trackSamples[t].add(ref);
break;
}
}
}
}
struct SampleRefSorter
{
int compareElements(const SampleRef& a, const SampleRef& b) const { return a.name.compare(b.name); }
};
SampleRefSorter sorter;
for (int t = 0; t < NUM_TRACKS; ++t)
trackSamples[t].sort(sorter);
}
void TrommelkisteProcessor::loadSampleByIndex(int trackIndex, int sampleIndex)
{
if (trackIndex < 0 || trackIndex >= NUM_TRACKS)
return;
if (sampleIndex < 0 || sampleIndex >= trackSamples[trackIndex].size())
return;
currentSampleIndex[trackIndex] = sampleIndex;
const auto& ref = trackSamples[trackIndex][sampleIndex];
if (ref.data != nullptr && ref.dataSize > 0)
{
const juce::SpinLock::ScopedLockType sl(tracks[trackIndex].lock);
readAudioFromBuffer(formatManager, tracks[trackIndex].buffer,
tracks[trackIndex].fileSampleRate,
ref.data, ref.dataSize);
tracks[trackIndex].filePath = "";
}
else if (ref.file.existsAsFile())
{
loadSample(trackIndex, ref.file);
}
}
void TrommelkisteProcessor::nextSample(int trackIndex)
{
if (trackIndex < 0 || trackIndex >= NUM_TRACKS)
return;
const int n = trackSamples[trackIndex].size();
if (n == 0) return;
int idx = currentSampleIndex[trackIndex] + 1;
if (idx >= n) idx = 0;
loadSampleByIndex(trackIndex, idx);
}
void TrommelkisteProcessor::prevSample(int trackIndex)
{
if (trackIndex < 0 || trackIndex >= NUM_TRACKS)
return;
const int n = trackSamples[trackIndex].size();
if (n == 0) return;
int idx = currentSampleIndex[trackIndex] - 1;
if (idx < 0) idx = n - 1;
loadSampleByIndex(trackIndex, idx);
}
// ── Kit / Preset system ───────────────────────────────────────
static const TrommelkisteProcessor::Kit kits[] = {
{ "Classic", {
"BT0AADA", "RIM63", "ST0T0SA", "HANDCLP2", "HHCD6",
"CLOP2", "HHOD6", "RIDED6", "LT0DA", "MT0DA" } },
{ "Punchy", {
"BT7A0D3", "RIM127", "ST7T7S3", "HANDCLP1", "HHCD2",
"CLOP1", "HHOD2", "RIDED2", "LT7D3", "MT7D3" } },
{ "Soft", {
"BT0A0DA", "RIM63", "ST0T0S7", "HANDCLP2", "HHCD8",
"CLOP4", "HHOD8", "RIDED8", "LT0D7", "MT0D7" } },
{ "Raw", {
"BTAAADA", "RIM127", "STATASA", "HANDCLP1", "HHCDA",
"CLOP3", "HHODA", "RIDEDA", "LTADA", "MTADA" } },
};
const TrommelkisteProcessor::Kit* TrommelkisteProcessor::getKitList() { return kits; }
int TrommelkisteProcessor::getNumKits() const { return 4; }
juce::String TrommelkisteProcessor::getCurrentKitName() const
{
if (currentKitIndex >= 0 && currentKitIndex < getNumKits())
return kits[currentKitIndex].name;
return {};
}
void TrommelkisteProcessor::loadKit(int index)
{
if (index < 0 || index >= getNumKits())
return;
currentKitIndex = index;
const auto& kit = kits[index];
for (int t = 0; t < NUM_TRACKS; ++t)
{
if (kit.samples[t] == nullptr || kit.samples[t][0] == '\0')
{
currentSampleIndex[t] = -1;
clearSample(t);
continue;
}
juce::String target(kit.samples[t]);
int found = -1;
for (int s = 0; s < trackSamples[t].size(); ++s)
{
if (trackSamples[t][s].name.equalsIgnoreCase(target))
{
found = s;
break;
}
}
if (found >= 0)
loadSampleByIndex(t, found);
else
clearSample(t);
}
}
void TrommelkisteProcessor::nextKit()
{
int idx = currentKitIndex + 1;
if (idx >= getNumKits()) idx = 0;
loadKit(idx);
}
void TrommelkisteProcessor::prevKit()
{
int idx = currentKitIndex - 1;
if (idx < 0) idx = getNumKits() - 1;
loadKit(idx);
}
juce::AudioProcessorEditor* TrommelkisteProcessor::createEditor()
{
return new TrommelkisteEditor(*this);
}
void TrommelkisteProcessor::getStateInformation(juce::MemoryBlock& destData)
{
auto state = apvts.copyState();
state.setProperty("kitIndex", currentKitIndex, nullptr);
juce::ValueTree samples("Samples");
for (int i = 0; i < NUM_TRACKS; ++i)
{
juce::ValueTree tr("Track" + juce::String(i));
tr.setProperty("path", tracks[i].filePath, nullptr);
tr.setProperty("sampleIndex", currentSampleIndex[i], nullptr);
if (currentSampleIndex[i] >= 0 && currentSampleIndex[i] < trackSamples[i].size())
tr.setProperty("sampleName", trackSamples[i][currentSampleIndex[i]].name, nullptr);
samples.appendChild(tr, nullptr);
}
state.appendChild(samples, nullptr);
std::unique_ptr<juce::XmlElement> xml(state.createXml());
copyXmlToBinary(*xml, destData);
}
void TrommelkisteProcessor::setStateInformation(const void* data, int sizeInBytes)
{
std::unique_ptr<juce::XmlElement> xml(getXmlFromBinary(data, sizeInBytes));
if (xml == nullptr)
return;
auto state = juce::ValueTree::fromXml(*xml);
apvts.replaceState(state);
currentKitIndex = (int)state.getProperty("kitIndex", 0);
auto samples = state.getChildWithName("Samples");
if (samples.isValid())
{
for (int i = 0; i < NUM_TRACKS; ++i)
{
auto tr = samples.getChildWithName("Track" + juce::String(i));
if (!tr.isValid())
continue;
auto path = tr.getProperty("path", "").toString();
auto sampleName = tr.getProperty("sampleName", "").toString();
if (path.isNotEmpty())
{
loadSample(i, juce::File(path));
currentSampleIndex[i] = (int)tr.getProperty("sampleIndex", -1);
}
else if (sampleName.isNotEmpty())
{
int found = -1;
for (int s = 0; s < trackSamples[i].size(); ++s)
{
if (trackSamples[i][s].name.equalsIgnoreCase(sampleName))
{
found = s;
break;
}
}
if (found >= 0)
loadSampleByIndex(i, found);
}
}
}
}
juce::AudioProcessorValueTreeState::ParameterLayout TrommelkisteProcessor::createParameterLayout()
{
AudioProcessorValueTreeState::ParameterLayout layout;
for (int i = 0; i < NUM_TRACKS; ++i)
{
const String p = "t" + String(i) + "_";
const String tn = "T" + String(i + 1) + " ";
layout.add(std::make_unique<AudioParameterFloat>(
p + "level", tn + "Level",
NormalisableRange<float>(0.0f, 1.0f), 0.8f));
layout.add(std::make_unique<AudioParameterFloat>(
p + "length", tn + "Length",
NormalisableRange<float>(0.01f, 2.0f, 0.001f, 0.45f), 0.5f));
layout.add(std::make_unique<AudioParameterFloat>(
p + "velocity", tn + "Velocity",
NormalisableRange<float>(0.0f, 1.0f), 1.0f));
layout.add(std::make_unique<AudioParameterFloat>(
p + "pitch", tn + "Pitch",
NormalisableRange<float>(-12.0f, 12.0f, 0.1f), 0.0f));
layout.add(std::make_unique<AudioParameterFloat>(
p + "tone", tn + "Tone",
NormalisableRange<float>(20.0f, 20000.0f, 1.0f, 0.25f), 20000.0f));
layout.add(std::make_unique<AudioParameterFloat>(
p + "pan", tn + "Pan",
NormalisableRange<float>(-1.0f, 1.0f), 0.0f));
layout.add(std::make_unique<AudioParameterBool>(
p + "decay", tn + "Decay", false));
layout.add(std::make_unique<AudioParameterFloat>(
p + "delaySend", tn + "Delay",
NormalisableRange<float>(0.0f, 1.0f), 0.0f));
layout.add(std::make_unique<AudioParameterFloat>(
p + "reverbSend", tn + "Reverb",
NormalisableRange<float>(0.0f, 1.0f), 0.0f));
layout.add(std::make_unique<AudioParameterFloat>(
p + "ringMod", tn + "RingMod",
NormalisableRange<float>(0.0f, 1.0f), 0.0f));
layout.add(std::make_unique<AudioParameterFloat>(
p + "destruction", tn + "Destr",
NormalisableRange<float>(0.0f, 1.0f), 0.0f));
layout.add(std::make_unique<AudioParameterFloat>(
p + "shuffle", tn + "Shuffle",
NormalisableRange<float>(0.0f, 1.0f), 0.0f));
}
// Global controls
layout.add(std::make_unique<AudioParameterFloat>(
"master_volume", "Master Volume",
NormalisableRange<float>(0.0f, 1.2f, 0.01f), 1.0f));
layout.add(std::make_unique<AudioParameterFloat>(
"master_pan", "Master Pan",
NormalisableRange<float>(-1.0f, 1.0f, 0.01f), 0.0f));
layout.add(std::make_unique<AudioParameterFloat>(
"master_delay", "Master Delay",
NormalisableRange<float>(0.0f, 1.0f, 0.01f), 1.0f));
layout.add(std::make_unique<AudioParameterFloat>(
"master_reverb", "Master Reverb",
NormalisableRange<float>(0.0f, 1.0f, 0.01f), 1.0f));
layout.add(std::make_unique<AudioParameterFloat>(
"delay_syncDiv", "Delay Sync",
NormalisableRange<float>(0.0f, 8.0f, 1.0f), 0.0f));
layout.add(std::make_unique<AudioParameterFloat>(
"global_shuffleAmount", "Shuffle Amt",
NormalisableRange<float>(0.0f, 1.0f, 0.01f), 0.0f));
layout.add(std::make_unique<AudioParameterFloat>(
"global_groove", "Groove",
NormalisableRange<float>(0.0f, 1.0f, 0.01f), 0.0f));
layout.add(std::make_unique<AudioParameterFloat>(
"global_shuffleDiv", "Shuffle Div",
NormalisableRange<float>(0.0f, 4.0f, 1.0f), 0.0f));
layout.add(std::make_unique<AudioParameterFloat>(
"global_ringFreq", "Ring Freq",
NormalisableRange<float>(20.0f, 2000.0f, 1.0f, 0.3f), 80.0f));
layout.add(std::make_unique<AudioParameterFloat>(
"global_destruction", "Destruction",
NormalisableRange<float>(0.0f, 1.0f), 0.0f));
return layout;
}
AudioProcessor* JUCE_CALLTYPE createPluginFilter()
{
return new TrommelkisteProcessor();
}
Reference in a new issue View git blame Copy permalink