/* * Copyright (C) 2018-2023 Rerrah * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ #include "instruments_manager.hpp" #include #include #include #include #include #include #include "instrument.hpp" #include "note.hpp" #include "utils.hpp" namespace { // Constant const FMEnvelopeParameter ENV_FM_PARAMS[] = { FMEnvelopeParameter::AL, FMEnvelopeParameter::FB, FMEnvelopeParameter::AR1, FMEnvelopeParameter::DR1, FMEnvelopeParameter::SR1, FMEnvelopeParameter::RR1, FMEnvelopeParameter::SL1, FMEnvelopeParameter::TL1, FMEnvelopeParameter::KS1, FMEnvelopeParameter::ML1, FMEnvelopeParameter::DT1, FMEnvelopeParameter::AR2, FMEnvelopeParameter::DR2, FMEnvelopeParameter::SR2, FMEnvelopeParameter::RR2, FMEnvelopeParameter::SL2, FMEnvelopeParameter::TL2, FMEnvelopeParameter::KS2, FMEnvelopeParameter::ML2, FMEnvelopeParameter::DT2, FMEnvelopeParameter::AR3, FMEnvelopeParameter::DR3, FMEnvelopeParameter::SR3, FMEnvelopeParameter::RR3, FMEnvelopeParameter::SL3, FMEnvelopeParameter::TL3, FMEnvelopeParameter::KS3, FMEnvelopeParameter::ML3, FMEnvelopeParameter::DT3, FMEnvelopeParameter::AR4, FMEnvelopeParameter::DR4, FMEnvelopeParameter::SR4, FMEnvelopeParameter::RR4, FMEnvelopeParameter::SL4, FMEnvelopeParameter::TL4, FMEnvelopeParameter::KS4, FMEnvelopeParameter::ML4, FMEnvelopeParameter::DT4 }; const FMOperatorType FM_OP_TYPES[] = { FMOperatorType::All, FMOperatorType::Op1, FMOperatorType::Op2, FMOperatorType::Op3, FMOperatorType::Op4 }; // Property initialization helper inline auto makeEnvelopeFMSharedPtr(int n) { return std::make_shared(n); } inline auto makeLFOFMSharedPtr(int n) { return std::make_shared(n); } inline auto makeOperatorSequenceFMSharedPtr(int n) { return std::make_shared>(n, SequenceType::PlainSequence, FMOperatorSequenceUnit(0), FMOperatorSequenceUnit()); } inline auto makeArpeggioSharedPtr(int n) { return std::make_shared>(n, SequenceType::AbsoluteSequence, ArpeggioUnit(Note::DEFAULT_NOTE_NUM), ArpeggioUnit()); } inline auto makePitchSharedPtr(int n) { return std::make_shared>(n, SequenceType::AbsoluteSequence, PitchUnit(SEQ_PITCH_CENTER), PitchUnit()); } inline auto makePanSharedPtr(int n) { return std::make_shared>(n, SequenceType::AbsoluteSequence, PanUnit(PanType::CENTER), PanUnit()); } inline auto makeWaveformSSGSharedPtr(int n) { return std::make_shared>(n, SequenceType::PlainSequence, SSGWaveformUnit::makeOnlyDataUnit(SSGWaveformType::SQUARE), SSGWaveformUnit()); } inline auto makeToneNoiseSSGSharedPtr(int n) { return std::make_shared>(n, SequenceType::PlainSequence, SSGToneNoiseUnit(0), SSGToneNoiseUnit()); } inline auto makeEnvelopeSSGSharedPtr(int n) { return std::make_shared>(n, SequenceType::PlainSequence, SSGEnvelopeUnit::makeOnlyDataUnit(15), SSGEnvelopeUnit(), 15); } inline auto makeSampleADPCMSharedPtr(int n) { return std::make_shared(n); } inline auto makeEnvelopeADPCMSharedPtr(int n) { return std::make_shared>(n, SequenceType::PlainSequence, ADPCMEnvelopeUnit(255), ADPCMEnvelopeUnit(), 127); } // Utility functor template struct IsUsed { using ArgType = typename std::add_const::type::const_reference; bool operator()(ArgType prop) const { return prop->isUserInstrument(); } }; template struct IsEdited { using ArgType = typename std::add_const::type::const_reference; bool operator()(ArgType prop) const { return prop->isEdited(); } }; template struct IsUsedOrEdited { using ArgType = typename std::add_const::type::const_reference; bool operator()(ArgType prop) const { return (prop->isUserInstrument() || prop->isEdited()); } }; // Common process for properties template int cloneProperty(propArray& aryRef, int srcNum) { // Must find an unused property since the count of used properties <= the count of instruments auto&& it = std::find_if_not(aryRef.begin(), aryRef.end(), IsUsed()); int cloneNum = std::distance(aryRef.begin(), it); *it = aryRef.at(static_cast(srcNum))->clone(); (*it)->setNumber(cloneNum); return cloneNum; } template int findFirstAssignableProperty(propArray& aryRef, bool regardingUnedited, int startOffs = 0) { std::function cond; if (regardingUnedited) cond = IsUsedOrEdited(); else cond = IsUsed(); auto&& it = std::find_if_not(aryRef.cbegin() + startOffs, aryRef.cend(), cond); if (it == aryRef.cend()) return -1; if (!regardingUnedited) (*it)->clearParameters(); return std::distance(aryRef.cbegin(), it); } } InstrumentsManager::InstrumentsManager(bool unedited) : regardingUnedited_(unedited) { clearAll(); } void InstrumentsManager::addInstrument(int instNum, InstrumentType type, const std::string& name) { if (instNum < 0 || static_cast(insts_.size()) <= instNum) return; switch (type) { case InstrumentType::FM: { auto fm = new InstrumentFM(instNum, name, this); int envNum = findFirstAssignableEnvelopeFM(); if (envNum == -1) envNum = static_cast(envFM_.size()) - 1; fm->setEnvelopeNumber(envNum); envFM_.at(static_cast(envNum))->registerUserInstrument(instNum); int lfoNum = findFirstAssignableLFOFM(); if (lfoNum == -1) lfoNum = static_cast(lfoFM_.size()) - 1; fm->setLFONumber(lfoNum); fm->setLFOEnabled(false); for (auto param : ENV_FM_PARAMS) { int opSeqNum = findFirstAssignableOperatorSequenceFM(param); if (opSeqNum == -1) opSeqNum = static_cast(opSeqFM_.at(param).size()) - 1; fm->setOperatorSequenceNumber(param, opSeqNum); fm->setOperatorSequenceEnabled(param, false); } int arpNum = findFirstAssignableArpeggioFM(); if (arpNum == -1) arpNum = static_cast(arpFM_.size()) - 1; int ptNum = findFirstAssignablePitchFM(); if (ptNum == -1) ptNum = static_cast(ptFM_.size()) - 1; for (auto type : FM_OP_TYPES) { fm->setArpeggioNumber(type, arpNum); fm->setArpeggioEnabled(type, false); fm->setPitchNumber(type, ptNum); fm->setPitchEnabled(type, false); } int panNum = findFirstAssignablePanFM(); if (panNum == -1) panNum = static_cast(panFM_.size()) - 1; fm->setPanNumber(panNum); fm->setPanEnabled(false); insts_.at(static_cast(instNum)).reset(fm); break; } case InstrumentType::SSG: { auto ssg = new InstrumentSSG(instNum, name, this); int wfNum = findFirstAssignableWaveformSSG(); if (wfNum == -1) wfNum = static_cast(wfSSG_.size()) - 1; ssg->setWaveformNumber(wfNum); ssg->setWaveformEnabled(false); int tnNum = findFirstAssignableToneNoiseSSG(); if (tnNum == -1) tnNum = static_cast(tnSSG_.size()) - 1; ssg->setToneNoiseNumber(tnNum); ssg->setToneNoiseEnabled(false); int envNum = findFirstAssignableEnvelopeSSG(); if (envNum == -1) envNum = static_cast(envSSG_.size()) - 1; ssg->setEnvelopeNumber(envNum); ssg->setEnvelopeEnabled(false); int arpNum = findFirstAssignableArpeggioSSG(); if (arpNum == -1) arpNum = static_cast(arpSSG_.size()) - 1; ssg->setArpeggioNumber(arpNum); ssg->setArpeggioEnabled(false); int ptNum = findFirstAssignablePitchSSG(); if (ptNum == -1) ptNum = static_cast(ptSSG_.size()) - 1; ssg->setPitchNumber(ptNum); ssg->setPitchEnabled(false); insts_.at(static_cast(instNum)).reset(ssg); break; } case InstrumentType::ADPCM: { auto adpcm = new InstrumentADPCM(instNum, name, this); int sampNum = findFirstAssignableSampleADPCM(); if (sampNum == -1) sampNum = static_cast(sampADPCM_.size()) - 1; adpcm->setSampleNumber(sampNum); sampADPCM_.at(static_cast(sampNum))->registerUserInstrument(instNum); int envNum = findFirstAssignableEnvelopeADPCM(); if (envNum == -1) envNum = static_cast(envADPCM_.size()) - 1; adpcm->setEnvelopeNumber(envNum); adpcm->setEnvelopeEnabled(false); int arpNum = findFirstAssignableArpeggioADPCM(); if (arpNum == -1) arpNum = static_cast(arpADPCM_.size()) - 1; adpcm->setArpeggioNumber(arpNum); adpcm->setArpeggioEnabled(false); int ptNum = findFirstAssignablePitchADPCM(); if (ptNum == -1) ptNum = static_cast(ptADPCM_.size()) - 1; adpcm->setPitchNumber(ptNum); adpcm->setPitchEnabled(false); int panNum = findFirstAssignablePanADPCM(); if (panNum == -1) panNum = static_cast(panADPCM_.size()) - 1; adpcm->setPanNumber(panNum); adpcm->setPanEnabled(false); insts_.at(static_cast(instNum)).reset(adpcm); break; } case InstrumentType::Drumkit: { insts_.at(static_cast(instNum)).reset(new InstrumentDrumkit(instNum, name, this)); break; } default: throw std::invalid_argument("invalid instrument type"); } } void InstrumentsManager::addInstrument(AbstractInstrument* newInstPtr) { int num = newInstPtr->getNumber(); std::shared_ptr& inst = insts_.at(static_cast(num)); inst.reset(newInstPtr); switch (inst->getType()) { case InstrumentType::FM: { auto fm = std::dynamic_pointer_cast(inst); envFM_.at(static_cast(fm->getEnvelopeNumber()))->registerUserInstrument(num); if (fm->getLFOEnabled()) lfoFM_.at(static_cast(fm->getLFONumber()))->registerUserInstrument(num); for (auto p : ENV_FM_PARAMS) { if (fm->getOperatorSequenceEnabled(p)) opSeqFM_.at(p).at(static_cast(fm->getOperatorSequenceNumber(p))) ->registerUserInstrument(num); } for (auto t : FM_OP_TYPES) { if (fm->getArpeggioEnabled(t)) arpFM_.at(static_cast(fm->getArpeggioNumber(t)))->registerUserInstrument(num); if (fm->getPitchEnabled(t)) ptFM_.at(static_cast(fm->getPitchNumber(t)))->registerUserInstrument(num); } if (fm->getPanEnabled()) panFM_.at(static_cast(fm->getPanNumber()))->registerUserInstrument(num); break; } case InstrumentType::SSG: { auto ssg = std::dynamic_pointer_cast(inst); if (ssg->getWaveformEnabled()) wfSSG_.at(static_cast(ssg->getWaveformNumber()))->registerUserInstrument(num); if (ssg->getToneNoiseEnabled()) tnSSG_.at(static_cast(ssg->getToneNoiseNumber()))->registerUserInstrument(num); if (ssg->getEnvelopeEnabled()) envSSG_.at(static_cast(ssg->getEnvelopeNumber()))->registerUserInstrument(num); if (ssg->getArpeggioEnabled()) arpSSG_.at(static_cast(ssg->getArpeggioNumber()))->registerUserInstrument(num); if (ssg->getPitchEnabled()) ptSSG_.at(static_cast(ssg->getPitchNumber()))->registerUserInstrument(num); break; } case InstrumentType::ADPCM: { auto adpcm = std::dynamic_pointer_cast(inst); sampADPCM_.at(static_cast(adpcm->getSampleNumber()))->registerUserInstrument(num); if (adpcm->getEnvelopeEnabled()) envADPCM_.at(static_cast(adpcm->getEnvelopeNumber()))->registerUserInstrument(num); if (adpcm->getArpeggioEnabled()) arpADPCM_.at(static_cast(adpcm->getArpeggioNumber()))->registerUserInstrument(num); if (adpcm->getPitchEnabled()) ptADPCM_.at(static_cast(adpcm->getPitchNumber()))->registerUserInstrument(num); if (adpcm->getPanEnabled()) panADPCM_.at(static_cast(adpcm->getPanNumber()))->registerUserInstrument(num); break; } case InstrumentType::Drumkit: { auto kit = std::dynamic_pointer_cast(inst); for (const auto& key : kit->getAssignedKeys()) { sampADPCM_.at(static_cast(kit->getSampleNumber(key)))->registerUserInstrument(num); } break; } default: throw std::invalid_argument("invalid instrument type"); } } std::unique_ptr InstrumentsManager::removeInstrument(int instNum) { std::shared_ptr& inst = insts_.at(static_cast(instNum)); switch (inst->getType()) { case InstrumentType::FM: { auto fm = std::dynamic_pointer_cast(inst); envFM_.at(static_cast(fm->getEnvelopeNumber()))->deregisterUserInstrument(instNum); if (fm->getLFOEnabled()) lfoFM_.at(static_cast(fm->getLFONumber()))->deregisterUserInstrument(instNum); for (auto p : ENV_FM_PARAMS) { if (fm->getOperatorSequenceEnabled(p)) opSeqFM_.at(p).at(static_cast(fm->getOperatorSequenceNumber(p))) ->deregisterUserInstrument(instNum); } for (auto t : FM_OP_TYPES) { if (fm->getArpeggioEnabled(t)) arpFM_.at(static_cast(fm->getArpeggioNumber(t)))->deregisterUserInstrument(instNum); if (fm->getPitchEnabled(t)) ptFM_.at(static_cast(fm->getPitchNumber(t)))->deregisterUserInstrument(instNum); } if (fm->getPanEnabled()) panFM_.at(static_cast(fm->getPanNumber()))->deregisterUserInstrument(instNum); break; } case InstrumentType::SSG: { auto ssg = std::dynamic_pointer_cast(inst); if (ssg->getWaveformEnabled()) wfSSG_.at(static_cast(ssg->getWaveformNumber()))->deregisterUserInstrument(instNum); if (ssg->getToneNoiseEnabled()) tnSSG_.at(static_cast(ssg->getToneNoiseNumber()))->deregisterUserInstrument(instNum); if (ssg->getEnvelopeEnabled()) envSSG_.at(static_cast(ssg->getEnvelopeNumber()))->deregisterUserInstrument(instNum); if (ssg->getArpeggioEnabled()) arpSSG_.at(static_cast(ssg->getArpeggioNumber()))->deregisterUserInstrument(instNum); if (ssg->getPitchEnabled()) ptSSG_.at(static_cast(ssg->getPitchNumber()))->deregisterUserInstrument(instNum); break; } case InstrumentType::ADPCM: { auto adpcm = std::dynamic_pointer_cast(inst); sampADPCM_.at(static_cast(adpcm->getSampleNumber()))->deregisterUserInstrument(instNum); if (adpcm->getEnvelopeEnabled()) envADPCM_.at(static_cast(adpcm->getEnvelopeNumber()))->deregisterUserInstrument(instNum); if (adpcm->getArpeggioEnabled()) arpADPCM_.at(static_cast(adpcm->getArpeggioNumber()))->deregisterUserInstrument(instNum); if (adpcm->getPitchEnabled()) ptADPCM_.at(static_cast(adpcm->getPitchNumber()))->deregisterUserInstrument(instNum); if (adpcm->getPanEnabled()) panADPCM_.at(static_cast(adpcm->getPanNumber()))->deregisterUserInstrument(instNum); break; } case InstrumentType::Drumkit: { auto kit = std::dynamic_pointer_cast(inst); for (const int& key : kit->getAssignedKeys()) { sampADPCM_.at(static_cast(kit->getSampleNumber(key)))->deregisterUserInstrument(instNum); } break; } default: throw std::invalid_argument("invalid instrument type"); } std::unique_ptr clone(inst->clone()); inst.reset(); return clone; } void InstrumentsManager::cloneInstrument(int cloneInstNum, int refInstNum) { std::shared_ptr& refInst = insts_.at(static_cast(refInstNum)); addInstrument(cloneInstNum, refInst->getType(), refInst->getName()); switch (refInst->getType()) { case InstrumentType::FM: { auto refFm = std::dynamic_pointer_cast(refInst); auto cloneFm = std::dynamic_pointer_cast(insts_.at(static_cast(cloneInstNum))); setInstrumentFMEnvelope(cloneInstNum, refFm->getEnvelopeNumber()); setInstrumentFMLFO(cloneInstNum, refFm->getLFONumber()); if (refFm->getLFOEnabled()) setInstrumentFMLFOEnabled(cloneInstNum, true); for (auto p : ENV_FM_PARAMS) { setInstrumentFMOperatorSequence(cloneInstNum, p, refFm->getOperatorSequenceNumber(p)); if (refFm->getOperatorSequenceEnabled(p)) setInstrumentFMOperatorSequenceEnabled(cloneInstNum, p, true); } for (auto t : FM_OP_TYPES) { setInstrumentFMArpeggio(cloneInstNum, t, refFm->getArpeggioNumber(t)); if (refFm->getArpeggioEnabled(t)) setInstrumentFMArpeggioEnabled(cloneInstNum, t, true); setInstrumentFMPitch(cloneInstNum, t, refFm->getPitchNumber(t)); if (refFm->getPitchEnabled(t)) setInstrumentFMPitchEnabled(cloneInstNum, t, true); setInstrumentFMEnvelopeResetEnabled(cloneInstNum, t, refFm->getEnvelopeResetEnabled(t)); } break; } case InstrumentType::SSG: { auto refSsg = std::dynamic_pointer_cast(refInst); auto cloneSsg = std::dynamic_pointer_cast(insts_.at(static_cast(cloneInstNum))); setInstrumentSSGWaveform(cloneInstNum, refSsg->getWaveformNumber()); if (refSsg->getWaveformEnabled()) setInstrumentSSGWaveformEnabled(cloneInstNum, true); setInstrumentSSGToneNoise(cloneInstNum, refSsg->getToneNoiseNumber()); if (refSsg->getToneNoiseEnabled()) setInstrumentSSGToneNoiseEnabled(cloneInstNum, true); setInstrumentSSGEnvelope(cloneInstNum, refSsg->getEnvelopeNumber()); if (refSsg->getEnvelopeEnabled()) setInstrumentSSGEnvelopeEnabled(cloneInstNum, true); setInstrumentSSGArpeggio(cloneInstNum, refSsg->getArpeggioNumber()); if (refSsg->getArpeggioEnabled()) setInstrumentSSGArpeggioEnabled(cloneInstNum, true); setInstrumentSSGPitch(cloneInstNum, refSsg->getPitchNumber()); if (refSsg->getPitchEnabled()) setInstrumentSSGPitchEnabled(cloneInstNum, true); break; } case InstrumentType::ADPCM: { auto refAdpcm = std::dynamic_pointer_cast(refInst); auto cloneAdpcm = std::dynamic_pointer_cast(insts_.at(static_cast(cloneInstNum))); setInstrumentADPCMSample(cloneInstNum, refAdpcm->getSampleNumber()); setInstrumentADPCMEnvelope(cloneInstNum, refAdpcm->getEnvelopeNumber()); if (refAdpcm->getEnvelopeEnabled()) setInstrumentADPCMEnvelopeEnabled(cloneInstNum, true); setInstrumentADPCMArpeggio(cloneInstNum, refAdpcm->getArpeggioNumber()); if (refAdpcm->getArpeggioEnabled()) setInstrumentADPCMArpeggioEnabled(cloneInstNum, true); setInstrumentADPCMPitch(cloneInstNum, refAdpcm->getPitchNumber()); if (refAdpcm->getPitchEnabled()) setInstrumentADPCMPitchEnabled(cloneInstNum, true); break; } case InstrumentType::Drumkit: { auto refKit = std::dynamic_pointer_cast(refInst); auto cloneKit = std::dynamic_pointer_cast(insts_.at(static_cast(cloneInstNum))); for (const int& key : refKit->getAssignedKeys()) { setInstrumentDrumkitSamples(cloneInstNum, key, refKit->getSampleNumber(key)); setInstrumentDrumkitPitch(cloneInstNum, key, refKit->getPitch(key)); setInstrumentDrumkitPan(cloneInstNum, key, refKit->getPan(key)); } break; } default: throw std::invalid_argument("invalid instrument type"); } } void InstrumentsManager::deepCloneInstrument(int cloneInstNum, int refInstNum) { std::shared_ptr& refInst = insts_.at(static_cast(refInstNum)); addInstrument(cloneInstNum, refInst->getType(), refInst->getName()); switch (refInst->getType()) { case InstrumentType::FM: { auto refFm = std::dynamic_pointer_cast(refInst); auto cloneFm = std::dynamic_pointer_cast(insts_.at(static_cast(cloneInstNum))); envFM_[static_cast(cloneFm->getEnvelopeNumber())]->deregisterUserInstrument(cloneInstNum); // Remove temporary number int envNum = cloneProperty(envFM_, refFm->getEnvelopeNumber()); cloneFm->setEnvelopeNumber(envNum); envFM_[static_cast(envNum)]->registerUserInstrument(cloneInstNum); if (refFm->getLFOEnabled()) { cloneFm->setLFOEnabled(true); int lfoNum = cloneProperty(lfoFM_, refFm->getLFONumber()); cloneFm->setLFONumber(lfoNum); lfoFM_[static_cast(lfoNum)]->registerUserInstrument(cloneInstNum); } for (auto envParam : ENV_FM_PARAMS) { if (refFm->getOperatorSequenceEnabled(envParam)) { cloneFm->setOperatorSequenceEnabled(envParam, true); int opSeqNum = cloneProperty(opSeqFM_.at(envParam), refFm->getOperatorSequenceNumber(envParam)); cloneFm->setOperatorSequenceNumber(envParam, opSeqNum); opSeqFM_.at(envParam)[static_cast(opSeqNum)]->registerUserInstrument(cloneInstNum); } } std::unordered_map arpCloneMap; for (auto opType : FM_OP_TYPES) { if (refFm->getArpeggioEnabled(opType)) { cloneFm->setArpeggioEnabled(opType, true); int srcNum = refFm->getArpeggioNumber(opType); if (!arpCloneMap.count(srcNum)) { arpCloneMap[srcNum] = cloneProperty(arpFM_, srcNum); } cloneFm->setArpeggioNumber(opType, arpCloneMap[srcNum]); arpFM_[static_cast(arpCloneMap[srcNum])]->registerUserInstrument(cloneInstNum); } } std::unordered_map ptCloneMap; for (auto opType : FM_OP_TYPES) { if (refFm->getPitchEnabled(opType)) { cloneFm->setPitchEnabled(opType, true); int srcNum = refFm->getPitchNumber(opType); if (!ptCloneMap.count(srcNum)) { ptCloneMap[srcNum] = cloneProperty(ptFM_, srcNum); } cloneFm->setPitchNumber(opType, ptCloneMap[srcNum]); ptFM_[static_cast(ptCloneMap[srcNum])]->registerUserInstrument(cloneInstNum); } } if (refFm->getPanEnabled()) { cloneFm->setPanEnabled(true); int panNum = cloneProperty(panFM_, refFm->getPanNumber()); cloneFm->setPanNumber(panNum); panFM_[static_cast(panNum)]->registerUserInstrument(cloneInstNum); } for (auto t : FM_OP_TYPES) setInstrumentFMEnvelopeResetEnabled(cloneInstNum, t, refFm->getEnvelopeResetEnabled(t)); break; } case InstrumentType::SSG: { auto refSsg = std::dynamic_pointer_cast(refInst); auto cloneSsg = std::dynamic_pointer_cast(insts_.at(static_cast(cloneInstNum))); if (refSsg->getWaveformEnabled()) { cloneSsg->setWaveformEnabled(true); int wfNum = cloneProperty(wfSSG_, refSsg->getWaveformNumber()); cloneSsg->setWaveformNumber(wfNum); wfSSG_[static_cast(wfNum)]->registerUserInstrument(cloneInstNum); } if (refSsg->getToneNoiseEnabled()) { cloneSsg->setToneNoiseEnabled(true); int tnNum = cloneProperty(tnSSG_, refSsg->getToneNoiseNumber()); cloneSsg->setToneNoiseNumber(tnNum); tnSSG_[static_cast(tnNum)]->registerUserInstrument(cloneInstNum); } if (refSsg->getEnvelopeEnabled()) { cloneSsg->setEnvelopeEnabled(true); int envNum = cloneProperty(envSSG_, refSsg->getEnvelopeNumber()); cloneSsg->setEnvelopeNumber(envNum); envSSG_[static_cast(envNum)]->registerUserInstrument(cloneInstNum); } if (refSsg->getArpeggioEnabled()) { cloneSsg->setArpeggioEnabled(true); int arpNum = cloneProperty(arpSSG_, refSsg->getArpeggioNumber()); cloneSsg->setArpeggioNumber(arpNum); arpSSG_[static_cast(arpNum)]->registerUserInstrument(cloneInstNum); } if (refSsg->getPitchEnabled()) { cloneSsg->setPitchEnabled(true); int ptNum = cloneProperty(ptSSG_, refSsg->getPitchNumber()); cloneSsg->setPitchNumber(ptNum); ptSSG_[static_cast(ptNum)]->registerUserInstrument(cloneInstNum); } break; } case InstrumentType::ADPCM: { auto refAdpcm = std::dynamic_pointer_cast(refInst); auto cloneAdpcm = std::dynamic_pointer_cast(insts_.at(static_cast(cloneInstNum))); sampADPCM_[static_cast(cloneAdpcm->getSampleNumber())]->deregisterUserInstrument(cloneInstNum); // Remove temporary number int sampNum = cloneProperty(sampADPCM_, refAdpcm->getSampleNumber()); cloneAdpcm->setSampleNumber(sampNum); sampADPCM_[static_cast(sampNum)]->registerUserInstrument(cloneInstNum); if (refAdpcm->getEnvelopeEnabled()) { cloneAdpcm->setEnvelopeEnabled(true); int envNum = cloneProperty(envADPCM_, refAdpcm->getEnvelopeNumber()); cloneAdpcm->setEnvelopeNumber(envNum); envADPCM_[static_cast(envNum)]->registerUserInstrument(cloneInstNum); } if (refAdpcm->getArpeggioEnabled()) { cloneAdpcm->setArpeggioEnabled(true); int arpNum = cloneProperty(arpADPCM_, refAdpcm->getArpeggioNumber()); cloneAdpcm->setArpeggioNumber(arpNum); arpADPCM_[static_cast(arpNum)]->registerUserInstrument(cloneInstNum); } if (refAdpcm->getPitchEnabled()) { cloneAdpcm->setPitchEnabled(true); int ptNum = cloneProperty(ptADPCM_, refAdpcm->getPitchNumber()); cloneAdpcm->setPitchNumber(ptNum); ptADPCM_[static_cast(ptNum)]->registerUserInstrument(cloneInstNum); } if (refAdpcm->getPanEnabled()) { cloneAdpcm->setPanEnabled(true); int panNum = cloneProperty(panADPCM_, refAdpcm->getPanNumber()); cloneAdpcm->setPanNumber(panNum); panADPCM_[static_cast(panNum)]->registerUserInstrument(cloneInstNum); } break; } case InstrumentType::Drumkit: { auto refKit = std::dynamic_pointer_cast(refInst); auto cloneKit = std::dynamic_pointer_cast(insts_.at(static_cast(cloneInstNum))); std::unordered_map sampCloneMap; for (const int& key : refKit->getAssignedKeys()) { int srcNum = refKit->getSampleNumber(key); if (!sampCloneMap.count(srcNum)) sampCloneMap[srcNum] = cloneProperty(sampADPCM_, srcNum); cloneKit->setSampleNumber(key, sampCloneMap[srcNum]); sampADPCM_[static_cast(sampCloneMap[srcNum])]->registerUserInstrument(cloneInstNum); setInstrumentDrumkitPitch(cloneInstNum, key, refKit->getPitch(key)); setInstrumentDrumkitPan(cloneInstNum, key, refKit->getPan(key)); } break; } default: throw std::invalid_argument("invalid instrument type"); } } void InstrumentsManager::swapInstruments(int inst1Num, int inst2Num) { std::unique_ptr inst1 = removeInstrument(inst1Num); std::unique_ptr inst2 = removeInstrument(inst2Num); inst1->setNumber(inst2Num); inst2->setNumber(inst1Num); addInstrument(inst1.release()); addInstrument(inst2.release()); } /// [Return] instrument shared pointer or nullptr std::shared_ptr InstrumentsManager::getInstrumentSharedPtr(int instNum) { if (0 <= instNum && instNum < static_cast(insts_.size())) return insts_[static_cast(instNum)]; else return std::shared_ptr(); } void InstrumentsManager::clearAll() { for (auto p : ENV_FM_PARAMS) { opSeqFM_.emplace(p, std::array>, 128>()); } for (size_t i = 0; i < 128; ++i) { insts_[i].reset(); envFM_[i] = makeEnvelopeFMSharedPtr(i); lfoFM_[i] = makeLFOFMSharedPtr(i); for (auto& p : opSeqFM_) p.second[i] = makeOperatorSequenceFMSharedPtr(i); arpFM_[i] = makeArpeggioSharedPtr(i); ptFM_[i] = makePitchSharedPtr(i); panFM_[i] = makePanSharedPtr(i); wfSSG_[i] = makeWaveformSSGSharedPtr(i); tnSSG_[i] = makeToneNoiseSSGSharedPtr(i); envSSG_[i] = makeEnvelopeSSGSharedPtr(i); arpSSG_[i] = makeArpeggioSharedPtr(i); ptSSG_[i] = makePitchSharedPtr(i); sampADPCM_[i] = makeSampleADPCMSharedPtr(i); envADPCM_[i] = makeEnvelopeADPCMSharedPtr(i); arpADPCM_[i] = makeArpeggioSharedPtr(i); ptADPCM_[i] = makePitchSharedPtr(i); panADPCM_[i] = makePanSharedPtr(i); } } std::vector InstrumentsManager::getInstrumentIndices() const { return utils::findIndicesIf(insts_, [](decltype(insts_)::const_reference inst) { return inst; }); } void InstrumentsManager::setInstrumentName(int instNum, const std::string& name) { insts_.at(static_cast(instNum))->setName(name); } std::string InstrumentsManager::getInstrumentName(int instNum) const { return insts_.at(static_cast(instNum))->getName(); } std::vector InstrumentsManager::getInstrumentNameList() const { using InstRef = decltype(insts_)::const_reference; return utils::transformIf(insts_, [](InstRef inst) { return inst; }, [](InstRef inst) { return inst->getName(); }); } void InstrumentsManager::clearUnusedInstrumentProperties() { for (size_t i = 0; i < 128; ++i) { if (!envFM_[i]->isUserInstrument()) envFM_[i] = makeEnvelopeFMSharedPtr(i); if (!lfoFM_[i]->isUserInstrument()) lfoFM_[i] = makeLFOFMSharedPtr(i); for (auto& p : opSeqFM_) { if (!p.second[i]->isUserInstrument()) p.second[i] = makeOperatorSequenceFMSharedPtr(i); } if (!arpFM_[i]->isUserInstrument()) arpFM_[i] = makeArpeggioSharedPtr(i); if (!ptFM_[i]->isUserInstrument()) ptFM_[i] = makePitchSharedPtr(i); if (!panFM_[i]->isUserInstrument()) panFM_[i] = makePanSharedPtr(i); if (!wfSSG_[i]->isUserInstrument()) wfSSG_[i] = makeWaveformSSGSharedPtr(i); if (!tnSSG_[i]->isUserInstrument()) tnSSG_[i] = makeToneNoiseSSGSharedPtr(i); if (!envSSG_[i]->isUserInstrument()) envSSG_[i] = makeEnvelopeSSGSharedPtr(i); if (!arpSSG_[i]->isUserInstrument()) arpSSG_[i] = makeArpeggioSharedPtr(i); if (!ptSSG_[i]->isUserInstrument()) ptSSG_[i] = makePitchSharedPtr(i); if (!sampADPCM_[i]->isUserInstrument()) sampADPCM_[i] = makeSampleADPCMSharedPtr(i); if (!envADPCM_[i]->isUserInstrument()) envADPCM_[i] = makeEnvelopeADPCMSharedPtr(i); if (!arpADPCM_[i]->isUserInstrument()) arpADPCM_[i] = makeArpeggioSharedPtr(i); if (!ptADPCM_[i]->isUserInstrument()) ptADPCM_[i] = makePitchSharedPtr(i); if (!panADPCM_[i]->isUserInstrument()) panADPCM_[i] = makePanSharedPtr(i); } } /// [Return] /// -1: no free instrument /// else: first free instrument number int InstrumentsManager::findFirstFreeInstrument() const { auto&& it = std::find_if_not(insts_.cbegin(), insts_.cend(), [](const std::shared_ptr& inst) { return inst; }); return (it == insts_.cend() ? -1 : std::distance(insts_.cbegin(), it)); } std::unordered_map InstrumentsManager::getDuplicateInstrumentMap() const { std::unordered_map dupMap; std::vector idcs = getInstrumentIndices(); static const std::unordered_map, std::shared_ptr) const> eqCheck = { { InstrumentType::FM, &InstrumentsManager::equalPropertiesFM }, { InstrumentType::SSG, &InstrumentsManager::equalPropertiesSSG }, { InstrumentType::ADPCM, &InstrumentsManager::equalPropertiesADPCM }, { InstrumentType::Drumkit, &InstrumentsManager::equalPropertiesDrumkit } }; for (size_t i = 0; i < idcs.size(); ++i) { int baseIdx = idcs[i]; std::shared_ptr base = insts_[baseIdx]; for (size_t j = i + 1; j < idcs.size();) { int tgtIdx = idcs[j]; std::shared_ptr tgt = insts_[tgtIdx]; if (base->getType() == tgt->getType() && (this->*eqCheck.at(base->getType()))(base, tgt)) { dupMap[tgtIdx] = baseIdx; idcs.erase(idcs.begin() + j); continue; } ++j; } } return dupMap; } //----- FM methods ----- void InstrumentsManager::setInstrumentFMEnvelope(int instNum, int envNum) { auto fm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); envFM_.at(static_cast(fm->getEnvelopeNumber()))->deregisterUserInstrument(instNum); envFM_.at(static_cast(envNum))->registerUserInstrument(instNum); fm->setEnvelopeNumber(envNum); } int InstrumentsManager::getInstrumentFMEnvelope(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getEnvelopeNumber(); } void InstrumentsManager::setEnvelopeFMParameter(int envNum, FMEnvelopeParameter param, int value) { envFM_.at(static_cast(envNum))->setParameterValue(param, value); } int InstrumentsManager::getEnvelopeFMParameter(int envNum, FMEnvelopeParameter param) const { return envFM_.at(static_cast(envNum))->getParameterValue(param); } void InstrumentsManager::setEnvelopeFMOperatorEnabled(int envNum, int opNum, bool enabled) { envFM_.at(static_cast(envNum))->setOperatorEnabled(opNum, enabled); } bool InstrumentsManager::getEnvelopeFMOperatorEnabled(int envNum, int opNum) const { return envFM_.at(static_cast(envNum))->getOperatorEnabled(opNum); } std::multiset InstrumentsManager::getEnvelopeFMUsers(int envNum) const { return envFM_.at(static_cast(envNum))->getUserInstruments(); } std::vector InstrumentsManager::getEnvelopeFMEntriedIndices() const { return utils::findIndicesIf(envFM_, IsEdited()); } int InstrumentsManager::findFirstAssignableEnvelopeFM() const { return findFirstAssignableProperty(envFM_, regardingUnedited_); } void InstrumentsManager::setInstrumentFMLFOEnabled(int instNum, bool enabled) { auto fm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); fm->setLFOEnabled(enabled); if (enabled) lfoFM_.at(static_cast(fm->getLFONumber()))->registerUserInstrument(instNum); else lfoFM_.at(static_cast(fm->getLFONumber()))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentFMLFOEnabled(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getLFOEnabled(); } void InstrumentsManager::setInstrumentFMLFO(int instNum, int lfoNum) { auto fm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (fm->getLFOEnabled()) { lfoFM_.at(static_cast(fm->getLFONumber()))->deregisterUserInstrument(instNum); lfoFM_.at(static_cast(lfoNum))->registerUserInstrument(instNum); } fm->setLFONumber(lfoNum); } int InstrumentsManager::getInstrumentFMLFO(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getLFONumber(); } void InstrumentsManager::setLFOFMParameter(int lfoNum, FMLFOParameter param, int value) { lfoFM_.at(static_cast(lfoNum))->setParameterValue(param, value); } int InstrumentsManager::getLFOFMparameter(int lfoNum, FMLFOParameter param) const { return lfoFM_.at(static_cast(lfoNum))->getParameterValue(param); } std::multiset InstrumentsManager::getLFOFMUsers(int lfoNum) const { return lfoFM_.at(static_cast(lfoNum))->getUserInstruments(); } std::vector InstrumentsManager::getLFOFMEntriedIndices() const { return utils::findIndicesIf(lfoFM_, IsEdited()); } int InstrumentsManager::findFirstAssignableLFOFM() const { return findFirstAssignableProperty(lfoFM_, regardingUnedited_); } void InstrumentsManager::setInstrumentFMOperatorSequenceEnabled(int instNum, FMEnvelopeParameter param, bool enabled) { auto fm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); fm->setOperatorSequenceEnabled(param, enabled); if (enabled) opSeqFM_.at(param).at(static_cast(fm->getOperatorSequenceNumber(param)))->registerUserInstrument(instNum); else opSeqFM_.at(param).at(static_cast(fm->getOperatorSequenceNumber(param)))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentFMOperatorSequenceEnabled(int instNum, FMEnvelopeParameter param) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getOperatorSequenceEnabled(param); } void InstrumentsManager::setInstrumentFMOperatorSequence(int instNum, FMEnvelopeParameter param, int opSeqNum) { auto fm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (fm->getOperatorSequenceEnabled(param)) { opSeqFM_.at(param).at(static_cast(fm->getOperatorSequenceNumber(param)))->deregisterUserInstrument(instNum); opSeqFM_.at(param).at(static_cast(opSeqNum))->registerUserInstrument(instNum); } fm->setOperatorSequenceNumber(param, opSeqNum); } int InstrumentsManager::getInstrumentFMOperatorSequence(int instNum, FMEnvelopeParameter param) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getOperatorSequenceNumber(param); } void InstrumentsManager::addOperatorSequenceFMSequenceData(FMEnvelopeParameter param, int opSeqNum, int data) { opSeqFM_.at(param).at(static_cast(opSeqNum))->addSequenceUnit(FMOperatorSequenceUnit(data)); } void InstrumentsManager::removeOperatorSequenceFMSequenceData(FMEnvelopeParameter param, int opSeqNum) { opSeqFM_.at(param).at(static_cast(opSeqNum))->removeSequenceUnit(); } void InstrumentsManager::setOperatorSequenceFMSequenceData(FMEnvelopeParameter param, int opSeqNum, int cnt, int data) { opSeqFM_.at(param).at(static_cast(opSeqNum))->setSequenceUnit(cnt, FMOperatorSequenceUnit(data)); } std::vector InstrumentsManager::getOperatorSequenceFMSequence(FMEnvelopeParameter param, int opSeqNum) { return opSeqFM_.at(param).at(static_cast(opSeqNum))->getSequence(); } void InstrumentsManager::addOperatorSequenceFMLoop(FMEnvelopeParameter param, int opSeqNum, const InstrumentSequenceLoop& loop) { opSeqFM_.at(param).at(static_cast(opSeqNum))->addLoop(loop); } void InstrumentsManager::removeOperatorSequenceFMLoop(FMEnvelopeParameter param, int opSeqNum, int begin, int end) { opSeqFM_.at(param).at(static_cast(opSeqNum))->removeLoop(begin, end); } void InstrumentsManager::changeOperatorSequenceFMLoop(FMEnvelopeParameter param, int opSeqNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { opSeqFM_.at(param).at(static_cast(opSeqNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearOperatorSequenceFMLoops(FMEnvelopeParameter param, int opSeqNum) { opSeqFM_.at(param).at(static_cast(opSeqNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getOperatorSequenceFMLoopRoot(FMEnvelopeParameter param, int opSeqNum) const { return opSeqFM_.at(param).at(static_cast(opSeqNum))->getLoopRoot(); } void InstrumentsManager::setOperatorSequenceFMRelease(FMEnvelopeParameter param, int opSeqNum, const InstrumentSequenceRelease& release) { opSeqFM_.at(param).at(static_cast(opSeqNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getOperatorSequenceFMRelease(FMEnvelopeParameter param, int opSeqNum) const { return opSeqFM_.at(param).at(static_cast(opSeqNum))->getRelease(); } FMOperatorSequenceIter InstrumentsManager::getOperatorSequenceFMIterator(FMEnvelopeParameter param, int opSeqNum) const { return opSeqFM_.at(param).at(static_cast(opSeqNum))->getIterator(); } std::multiset InstrumentsManager::getOperatorSequenceFMUsers(FMEnvelopeParameter param, int opSeqNum) const { return opSeqFM_.at(param).at(static_cast(opSeqNum))->getUserInstruments(); } std::vector InstrumentsManager::getOperatorSequenceFMEntriedIndices(FMEnvelopeParameter param) const { return utils::findIndicesIf(opSeqFM_.at(param), IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignableOperatorSequenceFM(FMEnvelopeParameter param) const { return findFirstAssignableProperty(opSeqFM_.at(param), regardingUnedited_); } void InstrumentsManager::setInstrumentFMArpeggioEnabled(int instNum, FMOperatorType op, bool enabled) { auto fm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); fm->setArpeggioEnabled(op, enabled); if (enabled) arpFM_.at(static_cast(fm->getArpeggioNumber(op)))->registerUserInstrument(instNum); else arpFM_.at(static_cast(fm->getArpeggioNumber(op)))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentFMArpeggioEnabled(int instNum, FMOperatorType op) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getArpeggioEnabled(op); } void InstrumentsManager::setInstrumentFMArpeggio(int instNum, FMOperatorType op, int arpNum) { auto fm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (fm->getArpeggioEnabled(op)) { arpFM_.at(static_cast(fm->getArpeggioNumber(op)))->deregisterUserInstrument(instNum); arpFM_.at(static_cast(arpNum))->registerUserInstrument(instNum); } fm->setArpeggioNumber(op, arpNum); } int InstrumentsManager::getInstrumentFMArpeggio(int instNum, FMOperatorType op) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getArpeggioNumber(op); } void InstrumentsManager::setArpeggioFMType(int arpNum, SequenceType type) { arpFM_.at(static_cast(arpNum))->setType(type); } SequenceType InstrumentsManager::getArpeggioFMType(int arpNum) const { return arpFM_.at(static_cast(arpNum))->getType(); } void InstrumentsManager::addArpeggioFMSequenceData(int arpNum, int data) { arpFM_.at(static_cast(arpNum))->addSequenceUnit(ArpeggioUnit(data)); } void InstrumentsManager::removeArpeggioFMSequenceData(int arpNum) { arpFM_.at(static_cast(arpNum))->removeSequenceUnit(); } void InstrumentsManager::setArpeggioFMSequenceData(int arpNum, int cnt, int data) { arpFM_.at(static_cast(arpNum))->setSequenceUnit(cnt, ArpeggioUnit(data)); } std::vector InstrumentsManager::getArpeggioFMSequence(int arpNum) { return arpFM_.at(static_cast(arpNum))->getSequence(); } void InstrumentsManager::addArpeggioFMLoop(int arpNum, const InstrumentSequenceLoop& loop) { arpFM_.at(static_cast(arpNum))->addLoop(loop); } void InstrumentsManager::removeArpeggioFMLoop(int arpNum, int begin, int end) { arpFM_.at(static_cast(arpNum))->removeLoop(begin, end); } void InstrumentsManager::changeArpeggioFMLoop(int arpNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { arpFM_.at(static_cast(arpNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearArpeggioFMLoops(int arpNum) { arpFM_.at(static_cast(arpNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getArpeggioFMLoopRoot(int arpNum) const { return arpFM_.at(static_cast(arpNum))->getLoopRoot(); } void InstrumentsManager::setArpeggioFMRelease(int arpNum, const InstrumentSequenceRelease& release) { arpFM_.at(static_cast(arpNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getArpeggioFMRelease(int arpNum) const { return arpFM_.at(static_cast(arpNum))->getRelease(); } ArpeggioIter InstrumentsManager::getArpeggioFMIterator(int arpNum) const { return arpFM_.at(static_cast(arpNum))->getIterator(); } std::multiset InstrumentsManager::getArpeggioFMUsers(int arpNum) const { return arpFM_.at(static_cast(arpNum))->getUserInstruments(); } std::vector InstrumentsManager::getArpeggioFMEntriedIndices() const { return utils::findIndicesIf(arpFM_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignableArpeggioFM() const { return findFirstAssignableProperty(arpFM_, regardingUnedited_); } void InstrumentsManager::setInstrumentFMPitchEnabled(int instNum, FMOperatorType op, bool enabled) { auto fm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); fm->setPitchEnabled(op, enabled); if (enabled) ptFM_.at(static_cast(fm->getPitchNumber(op)))->registerUserInstrument(instNum); else ptFM_.at(static_cast(fm->getPitchNumber(op)))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentFMPitchEnabled(int instNum, FMOperatorType op) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getPitchEnabled(op); } void InstrumentsManager::setInstrumentFMPitch(int instNum, FMOperatorType op, int ptNum) { auto fm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (fm->getPitchEnabled(op)) { ptFM_.at(static_cast(fm->getPitchNumber(op)))->deregisterUserInstrument(instNum); ptFM_.at(static_cast(ptNum))->registerUserInstrument(instNum); } fm->setPitchNumber(op, ptNum); } int InstrumentsManager::getInstrumentFMPitch(int instNum, FMOperatorType op) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getPitchNumber(op); } void InstrumentsManager::setPitchFMType(int ptNum, SequenceType type) { ptFM_.at(static_cast(ptNum))->setType(type); } SequenceType InstrumentsManager::getPitchFMType(int ptNum) const { return ptFM_.at(static_cast(ptNum))->getType(); } void InstrumentsManager::addPitchFMSequenceData(int ptNum, int data) { ptFM_.at(static_cast(ptNum))->addSequenceUnit(PitchUnit(data)); } void InstrumentsManager::removePitchFMSequenceData(int ptNum) { ptFM_.at(static_cast(ptNum))->removeSequenceUnit(); } void InstrumentsManager::setPitchFMSequenceData(int ptNum, int cnt, int data) { ptFM_.at(static_cast(ptNum))->setSequenceUnit(cnt, PitchUnit(data)); } std::vector InstrumentsManager::getPitchFMSequence(int ptNum) { return ptFM_.at(static_cast(ptNum))->getSequence(); } void InstrumentsManager::addPitchFMLoop(int ptNum, const InstrumentSequenceLoop& loop) { ptFM_.at(static_cast(ptNum))->addLoop(loop); } void InstrumentsManager::removePitchFMLoop(int ptNum, int begin, int end) { ptFM_.at(static_cast(ptNum))->removeLoop(begin, end); } void InstrumentsManager::changePitchFMLoop(int ptNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { ptFM_.at(static_cast(ptNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearPitchFMLoops(int ptNum) { ptFM_.at(static_cast(ptNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getPitchFMLoopRoot(int ptNum) const { return ptFM_.at(static_cast(ptNum))->getLoopRoot(); } void InstrumentsManager::setPitchFMRelease(int ptNum, const InstrumentSequenceRelease& release) { ptFM_.at(static_cast(ptNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getPitchFMRelease(int ptNum) const { return ptFM_.at(static_cast(ptNum))->getRelease(); } PitchIter InstrumentsManager::getPitchFMIterator(int ptNum) const { return ptFM_.at(static_cast(ptNum))->getIterator(); } std::multiset InstrumentsManager::getPitchFMUsers(int ptNum) const { return ptFM_.at(static_cast(ptNum))->getUserInstruments(); } std::vector InstrumentsManager::getPitchFMEntriedIndices() const { return utils::findIndicesIf(ptFM_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignablePitchFM() const { return findFirstAssignableProperty(ptFM_, regardingUnedited_); } void InstrumentsManager::setInstrumentFMPanEnabled(int instNum, bool enabled) { auto fm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); fm->setPanEnabled(enabled); if (enabled) panFM_.at(static_cast(fm->getPanNumber()))->registerUserInstrument(instNum); else panFM_.at(static_cast(fm->getPanNumber()))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentFMPanEnabled(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getPanEnabled(); } void InstrumentsManager::setInstrumentFMPan(int instNum, int panNum) { auto fm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (fm->getPanEnabled()) { panFM_.at(static_cast(fm->getPanNumber()))->deregisterUserInstrument(instNum); panFM_.at(static_cast(panNum))->registerUserInstrument(instNum); } fm->setPanNumber(panNum); } int InstrumentsManager::getInstrumentFMPan(int instNum) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getPanNumber(); } void InstrumentsManager::addPanFMSequenceData(int panNum, int data) { panFM_.at(static_cast(panNum))->addSequenceUnit(PanUnit(data)); } void InstrumentsManager::removePanFMSequenceData(int panNum) { panFM_.at(static_cast(panNum))->removeSequenceUnit(); } void InstrumentsManager::setPanFMSequenceData(int panNum, int cnt, int data) { panFM_.at(static_cast(panNum))->setSequenceUnit(cnt, PanUnit(data)); } std::vector InstrumentsManager::getPanFMSequence(int panNum) { return panFM_.at(static_cast(panNum))->getSequence(); } void InstrumentsManager::addPanFMLoop(int panNum, const InstrumentSequenceLoop& loop) { panFM_.at(static_cast(panNum))->addLoop(loop); } void InstrumentsManager::removePanFMLoop(int panNum, int begin, int end) { panFM_.at(static_cast(panNum))->removeLoop(begin, end); } void InstrumentsManager::changePanFMLoop(int panNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { panFM_.at(static_cast(panNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearPanFMLoops(int panNum) { panFM_.at(static_cast(panNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getPanFMLoopRoot(int panNum) const { return panFM_.at(static_cast(panNum))->getLoopRoot(); } void InstrumentsManager::setPanFMRelease(int panNum, const InstrumentSequenceRelease& release) { panFM_.at(static_cast(panNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getPanFMRelease(int panNum) const { return panFM_.at(static_cast(panNum))->getRelease(); } PanIter InstrumentsManager::getPanFMIterator(int panNum) const { return panFM_.at(static_cast(panNum))->getIterator(); } std::multiset InstrumentsManager::getPanFMUsers(int panNum) const { return panFM_.at(static_cast(panNum))->getUserInstruments(); } std::vector InstrumentsManager::getPanFMEntriedIndices() const { return utils::findIndicesIf(panFM_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignablePanFM() const { return findFirstAssignableProperty(panFM_, regardingUnedited_); } void InstrumentsManager::setInstrumentFMEnvelopeResetEnabled(int instNum, FMOperatorType op, bool enabled) { std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->setEnvelopeResetEnabled(op, enabled); } bool InstrumentsManager::equalPropertiesFM(std::shared_ptr a, std::shared_ptr b) const { auto aFm = std::dynamic_pointer_cast(a); auto bFm = std::dynamic_pointer_cast(b); if (*envFM_[aFm->getEnvelopeNumber()] != *envFM_[bFm->getEnvelopeNumber()]) return false; if (aFm->getLFOEnabled() != bFm->getLFOEnabled()) return false; if (aFm->getLFOEnabled() && *lfoFM_[aFm->getLFONumber()] != *lfoFM_[bFm->getLFONumber()]) return false; for (auto& pair : opSeqFM_) { if (aFm->getOperatorSequenceEnabled(pair.first) != bFm->getOperatorSequenceEnabled(pair.first)) return false; if (aFm->getOperatorSequenceEnabled(pair.first) && *pair.second[aFm->getOperatorSequenceNumber(pair.first)] != *pair.second[bFm->getOperatorSequenceNumber(pair.first)]) return false; } for (auto& type : FM_OP_TYPES) { if (aFm->getArpeggioEnabled(type) != bFm->getArpeggioEnabled(type)) return false; if (aFm->getArpeggioEnabled(type) && *arpFM_[aFm->getArpeggioNumber(type)] != *arpFM_[bFm->getArpeggioNumber(type)]) return false; if (aFm->getPitchEnabled(type) != bFm->getPitchEnabled(type)) return false; if (aFm->getPitchEnabled(type) && *ptFM_[aFm->getPitchNumber(type)] != *ptFM_[bFm->getPitchNumber(type)]) return false; if (aFm->getEnvelopeResetEnabled(type) != bFm->getEnvelopeResetEnabled(type)) return false; } if (aFm->getPanEnabled() && *panFM_[aFm->getPanNumber()] != *panFM_[bFm->getPanNumber()]) return false; return true; } //----- SSG methods ----- void InstrumentsManager::setInstrumentSSGWaveformEnabled(int instNum, bool enabled) { auto ssg = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); ssg->setWaveformEnabled(enabled); if (enabled) wfSSG_.at(static_cast(ssg->getWaveformNumber()))->registerUserInstrument(instNum); else wfSSG_.at(static_cast(ssg->getWaveformNumber()))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentSSGWaveformEnabled(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getWaveformEnabled(); } void InstrumentsManager::setInstrumentSSGWaveform(int instNum, int wfNum) { auto ssg = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (ssg->getWaveformEnabled()) { wfSSG_.at(static_cast(ssg->getWaveformNumber()))->deregisterUserInstrument(instNum); wfSSG_.at(static_cast(wfNum))->registerUserInstrument(instNum); } ssg->setWaveformNumber(wfNum); } int InstrumentsManager::getInstrumentSSGWaveform(int instNum) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getWaveformNumber(); } void InstrumentsManager::addWaveformSSGSequenceData(int wfNum, const SSGWaveformUnit& data) { wfSSG_.at(static_cast(wfNum))->addSequenceUnit(data); } void InstrumentsManager::removeWaveformSSGSequenceData(int wfNum) { wfSSG_.at(static_cast(wfNum))->removeSequenceUnit(); } void InstrumentsManager::setWaveformSSGSequenceData(int wfNum, int cnt, const SSGWaveformUnit& data) { wfSSG_.at(static_cast(wfNum))->setSequenceUnit(cnt, data); } std::vector InstrumentsManager::getWaveformSSGSequence(int wfNum) { return wfSSG_.at(static_cast(wfNum))->getSequence(); } void InstrumentsManager::addWaveformSSGLoop(int wfNum, const InstrumentSequenceLoop& loop) { wfSSG_.at(static_cast(wfNum))->addLoop(loop); } void InstrumentsManager::removeWaveformSSGLoop(int wfNum, int begin, int end) { wfSSG_.at(static_cast(wfNum))->removeLoop(begin, end); } void InstrumentsManager::changeWaveformSSGLoop(int wfNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { wfSSG_.at(static_cast(wfNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearWaveformSSGLoops(int wfNum) { wfSSG_.at(static_cast(wfNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getWaveformSSGLoopRoot(int wfNum) const { return wfSSG_.at(static_cast(wfNum))->getLoopRoot(); } void InstrumentsManager::setWaveformSSGRelease(int wfNum, const InstrumentSequenceRelease& release) { wfSSG_.at(static_cast(wfNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getWaveformSSGRelease(int wfNum) const { return wfSSG_.at(static_cast(wfNum))->getRelease(); } SSGWaveformIter InstrumentsManager::getWaveformSSGIterator(int wfNum) const { return wfSSG_.at(static_cast(wfNum))->getIterator(); } std::multiset InstrumentsManager::getWaveformSSGUsers(int wfNum) const { return wfSSG_.at(static_cast(wfNum))->getUserInstruments(); } std::vector InstrumentsManager::getWaveformSSGEntriedIndices() const { return utils::findIndicesIf(wfSSG_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignableWaveformSSG() const { return findFirstAssignableProperty(wfSSG_, regardingUnedited_); } void InstrumentsManager::setInstrumentSSGToneNoiseEnabled(int instNum, bool enabled) { auto ssg = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); ssg->setToneNoiseEnabled(enabled); if (enabled) tnSSG_.at(static_cast(ssg->getToneNoiseNumber()))->registerUserInstrument(instNum); else tnSSG_.at(static_cast(ssg->getToneNoiseNumber()))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentSSGToneNoiseEnabled(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getToneNoiseEnabled(); } void InstrumentsManager::setInstrumentSSGToneNoise(int instNum, int tnNum) { auto ssg = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (ssg->getToneNoiseEnabled()) { tnSSG_.at(static_cast(ssg->getToneNoiseNumber()))->deregisterUserInstrument(instNum); tnSSG_.at(static_cast(tnNum))->registerUserInstrument(instNum); } ssg->setToneNoiseNumber(tnNum); } int InstrumentsManager::getInstrumentSSGToneNoise(int instNum) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getToneNoiseNumber(); } void InstrumentsManager::addToneNoiseSSGSequenceData(int tnNum, int data) { tnSSG_.at(static_cast(tnNum))->addSequenceUnit(SSGToneNoiseUnit(data)); } void InstrumentsManager::removeToneNoiseSSGSequenceData(int tnNum) { tnSSG_.at(static_cast(tnNum))->removeSequenceUnit(); } void InstrumentsManager::setToneNoiseSSGSequenceData(int tnNum, int cnt, int data) { tnSSG_.at(static_cast(tnNum))->setSequenceUnit(cnt, SSGToneNoiseUnit(data)); } std::vector InstrumentsManager::getToneNoiseSSGSequence(int tnNum) { return tnSSG_.at(static_cast(tnNum))->getSequence(); } void InstrumentsManager::addToneNoiseSSGLoop(int tnNum, const InstrumentSequenceLoop& loop) { tnSSG_.at(static_cast(tnNum))->addLoop(loop); } void InstrumentsManager::removeToneNoiseSSGLoop(int tnNum, int begin, int end) { tnSSG_.at(static_cast(tnNum))->removeLoop(begin, end); } void InstrumentsManager::changeToneNoiseSSGLoop(int tnNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { tnSSG_.at(static_cast(tnNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearToneNoiseSSGLoops(int tnNum) { tnSSG_.at(static_cast(tnNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getToneNoiseSSGLoopRoot(int tnNum) const { return tnSSG_.at(static_cast(tnNum))->getLoopRoot(); } void InstrumentsManager::setToneNoiseSSGRelease(int tnNum, const InstrumentSequenceRelease& release) { tnSSG_.at(static_cast(tnNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getToneNoiseSSGRelease(int tnNum) const { return tnSSG_.at(static_cast(tnNum))->getRelease(); } SSGToneNoiseIter InstrumentsManager::getToneNoiseSSGIterator(int tnNum) const { return tnSSG_.at(static_cast(tnNum))->getIterator(); } std::multiset InstrumentsManager::getToneNoiseSSGUsers(int tnNum) const { return tnSSG_.at(static_cast(tnNum))->getUserInstruments(); } std::vector InstrumentsManager::getToneNoiseSSGEntriedIndices() const { return utils::findIndicesIf(tnSSG_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignableToneNoiseSSG() const { return findFirstAssignableProperty(tnSSG_, regardingUnedited_); } void InstrumentsManager::setInstrumentSSGEnvelopeEnabled(int instNum, bool enabled) { auto ssg = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); ssg->setEnvelopeEnabled(enabled); if (enabled) envSSG_.at(static_cast(ssg->getEnvelopeNumber()))->registerUserInstrument(instNum); else envSSG_.at(static_cast(ssg->getEnvelopeNumber()))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentSSGEnvelopeEnabled(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getEnvelopeEnabled(); } void InstrumentsManager::setInstrumentSSGEnvelope(int instNum, int envNum) { auto ssg = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (ssg->getEnvelopeEnabled()) { envSSG_.at(static_cast(ssg->getEnvelopeNumber()))->deregisterUserInstrument(instNum); envSSG_.at(static_cast(envNum))->registerUserInstrument(instNum); } ssg->setEnvelopeNumber(envNum); } int InstrumentsManager::getInstrumentSSGEnvelope(int instNum) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getEnvelopeNumber(); } void InstrumentsManager::addEnvelopeSSGSequenceData(int envNum, const SSGEnvelopeUnit& data) { envSSG_.at(static_cast(envNum))->addSequenceUnit(data); } void InstrumentsManager::removeEnvelopeSSGSequenceData(int envNum) { envSSG_.at(static_cast(envNum))->removeSequenceUnit(); } void InstrumentsManager::setEnvelopeSSGSequenceData(int envNum, int cnt, const SSGEnvelopeUnit& data) { envSSG_.at(static_cast(envNum))->setSequenceUnit(cnt, data); } std::vector InstrumentsManager::getEnvelopeSSGSequence(int envNum) { return envSSG_.at(static_cast(envNum))->getSequence(); } void InstrumentsManager::addEnvelopeSSGLoop(int envNum, const InstrumentSequenceLoop& loop) { envSSG_.at(static_cast(envNum))->addLoop(loop); } void InstrumentsManager::removeEnvelopeSSGLoop(int envNum, int begin, int end) { envSSG_.at(static_cast(envNum))->removeLoop(begin, end); } void InstrumentsManager::changeEnvelopeSSGLoop(int envNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { envSSG_.at(static_cast(envNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearEnvelopeSSGLoops(int envNum) { envSSG_.at(static_cast(envNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getEnvelopeSSGLoopRoot(int envNum) const { return envSSG_.at(static_cast(envNum))->getLoopRoot(); } void InstrumentsManager::setEnvelopeSSGRelease(int envNum, const InstrumentSequenceRelease& release) { envSSG_.at(static_cast(envNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getEnvelopeSSGRelease(int envNum) const { return envSSG_.at(static_cast(envNum))->getRelease(); } SSGEnvelopeIter InstrumentsManager::getEnvelopeSSGIterator(int envNum) const { return envSSG_.at(static_cast(envNum))->getIterator(); } std::multiset InstrumentsManager::getEnvelopeSSGUsers(int envNum) const { return envSSG_.at(static_cast(envNum))->getUserInstruments(); } std::vector InstrumentsManager::getEnvelopeSSGEntriedIndices() const { return utils::findIndicesIf(envSSG_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignableEnvelopeSSG() const { return findFirstAssignableProperty(envSSG_, regardingUnedited_); } void InstrumentsManager::setInstrumentSSGArpeggioEnabled(int instNum, bool enabled) { auto ssg = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); ssg->setArpeggioEnabled(enabled); if (enabled) arpSSG_.at(static_cast(ssg->getArpeggioNumber()))->registerUserInstrument(instNum); else arpSSG_.at(static_cast(ssg->getArpeggioNumber()))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentSSGArpeggioEnabled(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getArpeggioEnabled(); } void InstrumentsManager::setInstrumentSSGArpeggio(int instNum, int arpNum) { auto ssg = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (ssg->getArpeggioEnabled()) { arpSSG_.at(static_cast(ssg->getArpeggioNumber()))->deregisterUserInstrument(instNum); arpSSG_.at(static_cast(arpNum))->registerUserInstrument(instNum); } ssg->setArpeggioNumber(arpNum); } int InstrumentsManager::getInstrumentSSGArpeggio(int instNum) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getArpeggioNumber(); } void InstrumentsManager::setArpeggioSSGType(int arpNum, SequenceType type) { arpSSG_.at(static_cast(arpNum))->setType(type); } SequenceType InstrumentsManager::getArpeggioSSGType(int arpNum) const { return arpSSG_.at(static_cast(arpNum))->getType(); } void InstrumentsManager::addArpeggioSSGSequenceData(int arpNum, int data) { arpSSG_.at(static_cast(arpNum))->addSequenceUnit(ArpeggioUnit(data)); } void InstrumentsManager::removeArpeggioSSGSequenceData(int arpNum) { arpSSG_.at(static_cast(arpNum))->removeSequenceUnit(); } void InstrumentsManager::setArpeggioSSGSequenceData(int arpNum, int cnt, int data) { arpSSG_.at(static_cast(arpNum))->setSequenceUnit(cnt, ArpeggioUnit(data)); } std::vector InstrumentsManager::getArpeggioSSGSequence(int arpNum) { return arpSSG_.at(static_cast(arpNum))->getSequence(); } void InstrumentsManager::addArpeggioSSGLoop(int arpNum, const InstrumentSequenceLoop& loop) { arpSSG_.at(static_cast(arpNum))->addLoop(loop); } void InstrumentsManager::removeArpeggioSSGLoop(int arpNum, int begin, int end) { arpSSG_.at(static_cast(arpNum))->removeLoop(begin, end); } void InstrumentsManager::changeArpeggioSSGLoop(int arpNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { arpSSG_.at(static_cast(arpNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearArpeggioSSGLoops(int arpNum) { arpSSG_.at(static_cast(arpNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getArpeggioSSGLoopRoot(int arpNum) const { return arpSSG_.at(static_cast(arpNum))->getLoopRoot(); } void InstrumentsManager::setArpeggioSSGRelease(int arpNum, const InstrumentSequenceRelease& release) { arpSSG_.at(static_cast(arpNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getArpeggioSSGRelease(int arpNum) const { return arpSSG_.at(static_cast(arpNum))->getRelease(); } ArpeggioIter InstrumentsManager::getArpeggioSSGIterator(int arpNum) const { return arpSSG_.at(static_cast(arpNum))->getIterator(); } std::multiset InstrumentsManager::getArpeggioSSGUsers(int arpNum) const { return arpSSG_.at(static_cast(arpNum))->getUserInstruments(); } std::vector InstrumentsManager::getArpeggioSSGEntriedIndices() const { return utils::findIndicesIf(arpSSG_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignableArpeggioSSG() const { return findFirstAssignableProperty(arpSSG_, regardingUnedited_); } void InstrumentsManager::setInstrumentSSGPitchEnabled(int instNum, bool enabled) { auto ssg = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); ssg->setPitchEnabled(enabled); if (enabled) ptSSG_.at(static_cast(ssg->getPitchNumber()))->registerUserInstrument(instNum); else ptSSG_.at(static_cast(ssg->getPitchNumber()))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentSSGPitchEnabled(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getPitchEnabled(); } void InstrumentsManager::setInstrumentSSGPitch(int instNum, int ptNum) { auto ssg = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (ssg->getPitchEnabled()) { ptSSG_.at(static_cast(ssg->getPitchNumber()))->deregisterUserInstrument(instNum); ptSSG_.at(static_cast(ptNum))->registerUserInstrument(instNum); } ssg->setPitchNumber(ptNum); } int InstrumentsManager::getInstrumentSSGPitch(int instNum) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getPitchNumber(); } void InstrumentsManager::setPitchSSGType(int ptNum, SequenceType type) { ptSSG_.at(static_cast(ptNum))->setType(type); } SequenceType InstrumentsManager::getPitchSSGType(int ptNum) const { return ptSSG_.at(static_cast(ptNum))->getType(); } void InstrumentsManager::addPitchSSGSequenceData(int ptNum, int data) { ptSSG_.at(static_cast(ptNum))->addSequenceUnit(PitchUnit(data)); } void InstrumentsManager::removePitchSSGSequenceData(int ptNum) { ptSSG_.at(static_cast(ptNum))->removeSequenceUnit(); } void InstrumentsManager::setPitchSSGSequenceData(int ptNum, int cnt, int data) { ptSSG_.at(static_cast(ptNum))->setSequenceUnit(cnt, PitchUnit(data)); } std::vector InstrumentsManager::getPitchSSGSequence(int ptNum) { return ptSSG_.at(static_cast(ptNum))->getSequence(); } void InstrumentsManager::addPitchSSGLoop(int ptNum, const InstrumentSequenceLoop& loop) { ptSSG_.at(static_cast(ptNum))->addLoop(loop); } void InstrumentsManager::removePitchSSGLoop(int ptNum, int begin, int end) { ptSSG_.at(static_cast(ptNum))->removeLoop(begin, end); } void InstrumentsManager::changePitchSSGLoop(int ptNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { ptSSG_.at(static_cast(ptNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearPitchSSGLoops(int ptNum) { ptSSG_.at(static_cast(ptNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getPitchSSGLoopRoot(int ptNum) const { return ptSSG_.at(static_cast(ptNum))->getLoopRoot(); } void InstrumentsManager::setPitchSSGRelease(int ptNum, const InstrumentSequenceRelease& release) { ptSSG_.at(static_cast(ptNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getPitchSSGRelease(int ptNum) const { return ptSSG_.at(static_cast(ptNum))->getRelease(); } PitchIter InstrumentsManager::getPitchSSGIterator(int ptNum) const { return ptSSG_.at(static_cast(ptNum))->getIterator(); } std::multiset InstrumentsManager::getPitchSSGUsers(int ptNum) const { return ptSSG_.at(static_cast(ptNum))->getUserInstruments(); } std::vector InstrumentsManager::getPitchSSGEntriedIndices() const { return utils::findIndicesIf(ptSSG_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignablePitchSSG() const { return findFirstAssignableProperty(ptSSG_, regardingUnedited_); } bool InstrumentsManager::equalPropertiesSSG(std::shared_ptr a, std::shared_ptr b) const { auto aSsg = std::dynamic_pointer_cast(a); auto bSsg = std::dynamic_pointer_cast(b); if (aSsg->getWaveformEnabled() != bSsg->getWaveformEnabled()) return false; if (aSsg->getWaveformEnabled() && *wfSSG_[aSsg->getWaveformNumber()] != *wfSSG_[bSsg->getWaveformNumber()]) return false; if (aSsg->getToneNoiseEnabled() != bSsg->getToneNoiseEnabled()) return false; if (aSsg->getToneNoiseEnabled() && *tnSSG_[aSsg->getToneNoiseNumber()] != *tnSSG_[bSsg->getToneNoiseNumber()]) return false; if (aSsg->getEnvelopeEnabled() != bSsg->getEnvelopeEnabled()) return false; if (aSsg->getEnvelopeEnabled() && *envSSG_[aSsg->getEnvelopeNumber()] != *envSSG_[bSsg->getEnvelopeNumber()]) return false; if (aSsg->getArpeggioEnabled() != bSsg->getArpeggioEnabled()) return false; if (aSsg->getArpeggioEnabled() && *arpSSG_[aSsg->getArpeggioNumber()] != *arpSSG_[bSsg->getArpeggioNumber()]) return false; if (aSsg->getPitchEnabled() != bSsg->getPitchEnabled()) return false; if (aSsg->getPitchEnabled() && *ptSSG_[aSsg->getPitchNumber()] != *ptSSG_[bSsg->getPitchNumber()]) return false; return true; } //----- ADPCM methods ----- void InstrumentsManager::setInstrumentADPCMSample(int instNum, int sampNum) { auto adpcm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); sampADPCM_.at(static_cast(adpcm->getSampleNumber()))->deregisterUserInstrument(instNum); sampADPCM_.at(static_cast(sampNum))->registerUserInstrument(instNum); adpcm->setSampleNumber(sampNum); } int InstrumentsManager::getInstrumentADPCMSample(int instNum) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getSampleNumber(); } void InstrumentsManager::setSampleADPCMRootKeyNumber(int sampNum, int n) { sampADPCM_.at(static_cast(sampNum))->setRootKeyNumber(n); } int InstrumentsManager::getSampleADPCMRootKeyNumber(int sampNum) const { return sampADPCM_.at(static_cast(sampNum))->getRootKeyNumber(); } void InstrumentsManager::setSampleADPCMRootDeltaN(int sampNum, int dn) { sampADPCM_.at(static_cast(sampNum))->setRootDeltaN(dn); } int InstrumentsManager::getSampleADPCMRootDeltaN(int sampNum) const { return sampADPCM_.at(static_cast(sampNum))->getRootDeltaN(); } void InstrumentsManager::setSampleADPCMRepeatEnabled(int sampNum, bool enabled) { sampADPCM_.at(static_cast(sampNum))->setRepeatEnabled(enabled); } bool InstrumentsManager::isSampleADPCMRepeatable(int sampNum) const { return sampADPCM_.at(static_cast(sampNum))->isRepeatable(); } bool InstrumentsManager::setSampleADPCMRepeatrange(int sampNum, const SampleRepeatRange& range) { return sampADPCM_.at(static_cast(sampNum))->setRepeatRange(range); } SampleRepeatFlag InstrumentsManager::getSampleADPCMRepeatFlag(int sampNum) const { return sampADPCM_.at(static_cast(sampNum))->getRepeatFlag(); } SampleRepeatRange InstrumentsManager::getSampleADPCMRepeatRange(int sampNum) const { return sampADPCM_.at(static_cast(sampNum))->getRepeatRange(); } void InstrumentsManager::storeSampleADPCMRawSample(int sampNum, const std::vector& sample) { sampADPCM_.at(static_cast(sampNum))->storeSample(sample); } void InstrumentsManager::storeSampleADPCMRawSample(int sampNum, std::vector&& sample) { sampADPCM_.at(static_cast(sampNum))->storeSample(sample); } void InstrumentsManager::clearSampleADPCMRawSample(int sampNum) { sampADPCM_.at(static_cast(sampNum))->clearSample(); } std::vector InstrumentsManager::getSampleADPCMRawSample(int sampNum) const { return sampADPCM_.at(static_cast(sampNum))->getSamples(); } void InstrumentsManager::setSampleADPCMStartAddress(int sampNum, size_t addr) { sampADPCM_.at(static_cast(sampNum))->setStartAddress(addr); } size_t InstrumentsManager::getSampleADPCMStartAddress(int sampNum) const { return sampADPCM_.at(static_cast(sampNum))->getStartAddress(); } void InstrumentsManager::setSampleADPCMStopAddress(int sampNum, size_t addr) { sampADPCM_.at(static_cast(sampNum))->setStopAddress(addr); } size_t InstrumentsManager::getSampleADPCMStopAddress(int sampNum) const { return sampADPCM_.at(static_cast(sampNum))->getStopAddress(); } std::multiset InstrumentsManager::getSampleADPCMUsers(int sampNum) const { return sampADPCM_.at(static_cast(sampNum))->getUserInstruments(); } std::vector InstrumentsManager::getSampleADPCMEntriedIndices() const { return utils::findIndicesIf(sampADPCM_, IsEdited()); } std::vector InstrumentsManager::getSampleADPCMValidIndices() const { return utils::findIndicesIf(sampADPCM_, IsUsedOrEdited()); } void InstrumentsManager::clearUnusedSamplesADPCM() { for (size_t i = 0; i < 128; ++i) { if (!sampADPCM_[i]->isUserInstrument()) sampADPCM_[i] = std::make_shared(i); } } int InstrumentsManager::findFirstAssignableSampleADPCM(int startIndex) const { return findFirstAssignableProperty(sampADPCM_, regardingUnedited_, startIndex); } void InstrumentsManager::setInstrumentADPCMEnvelopeEnabled(int instNum, bool enabled) { auto adpcm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); adpcm->setEnvelopeEnabled(enabled); if (enabled) envADPCM_.at(static_cast(adpcm->getEnvelopeNumber()))->registerUserInstrument(instNum); else envADPCM_.at(static_cast(adpcm->getEnvelopeNumber()))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentADPCMEnvelopeEnabled(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getEnvelopeEnabled(); } void InstrumentsManager::setInstrumentADPCMEnvelope(int instNum, int envNum) { auto adpcm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (adpcm->getEnvelopeEnabled()) { envADPCM_.at(static_cast(adpcm->getEnvelopeNumber()))->deregisterUserInstrument(instNum); envADPCM_.at(static_cast(envNum))->registerUserInstrument(instNum); } adpcm->setEnvelopeNumber(envNum); } int InstrumentsManager::getInstrumentADPCMEnvelope(int instNum) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getEnvelopeNumber(); } void InstrumentsManager::addEnvelopeADPCMSequenceData(int envNum, int data) { envADPCM_.at(static_cast(envNum))->addSequenceUnit(ADPCMEnvelopeUnit(data)); } void InstrumentsManager::removeEnvelopeADPCMSequenceData(int envNum) { envADPCM_.at(static_cast(envNum))->removeSequenceUnit(); } void InstrumentsManager::setEnvelopeADPCMSequenceData(int envNum, int cnt, int data) { envADPCM_.at(static_cast(envNum))->setSequenceUnit(cnt, ADPCMEnvelopeUnit(data)); } std::vector InstrumentsManager::getEnvelopeADPCMSequence(int envNum) { return envADPCM_.at(static_cast(envNum))->getSequence(); } void InstrumentsManager::addEnvelopeADPCMLoop(int envNum, const InstrumentSequenceLoop& loop) { envADPCM_.at(static_cast(envNum))->addLoop(loop); } void InstrumentsManager::removeEnvelopeADPCMLoop(int envNum, int begin, int end) { envADPCM_.at(static_cast(envNum))->removeLoop(begin, end); } void InstrumentsManager::changeEnvelopeADPCMLoop(int envNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { envADPCM_.at(static_cast(envNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearEnvelopeADPCMLoops(int envNum) { envADPCM_.at(static_cast(envNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getEnvelopeADPCMLoopRoot(int envNum) const { return envADPCM_.at(static_cast(envNum))->getLoopRoot(); } void InstrumentsManager::setEnvelopeADPCMRelease(int envNum, const InstrumentSequenceRelease& release) { envADPCM_.at(static_cast(envNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getEnvelopeADPCMRelease(int envNum) const { return envADPCM_.at(static_cast(envNum))->getRelease(); } ADPCMEnvelopeIter InstrumentsManager::getEnvelopeADPCMIterator(int envNum) const { return envADPCM_.at(static_cast(envNum))->getIterator(); } std::multiset InstrumentsManager::getEnvelopeADPCMUsers(int envNum) const { return envADPCM_.at(static_cast(envNum))->getUserInstruments(); } std::vector InstrumentsManager::getEnvelopeADPCMEntriedIndices() const { return utils::findIndicesIf(envADPCM_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignableEnvelopeADPCM() const { return findFirstAssignableProperty(envADPCM_, regardingUnedited_); } void InstrumentsManager::setInstrumentADPCMArpeggioEnabled(int instNum, bool enabled) { auto adpcm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); adpcm->setArpeggioEnabled(enabled); if (enabled) arpADPCM_.at(static_cast(adpcm->getArpeggioNumber()))->registerUserInstrument(instNum); else arpADPCM_.at(static_cast(adpcm->getArpeggioNumber()))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentADPCMArpeggioEnabled(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getArpeggioEnabled(); } void InstrumentsManager::setInstrumentADPCMArpeggio(int instNum, int arpNum) { auto adpcm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (adpcm->getArpeggioEnabled()) { arpADPCM_.at(static_cast(adpcm->getArpeggioNumber()))->deregisterUserInstrument(instNum); arpADPCM_.at(static_cast(arpNum))->registerUserInstrument(instNum); } adpcm->setArpeggioNumber(arpNum); } int InstrumentsManager::getInstrumentADPCMArpeggio(int instNum) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getArpeggioNumber(); } void InstrumentsManager::setArpeggioADPCMType(int arpNum, SequenceType type) { arpADPCM_.at(static_cast(arpNum))->setType(type); } SequenceType InstrumentsManager::getArpeggioADPCMType(int arpNum) const { return arpADPCM_.at(static_cast(arpNum))->getType(); } void InstrumentsManager::addArpeggioADPCMSequenceData(int arpNum, int data) { arpADPCM_.at(static_cast(arpNum))->addSequenceUnit(ArpeggioUnit(data)); } void InstrumentsManager::removeArpeggioADPCMSequenceData(int arpNum) { arpADPCM_.at(static_cast(arpNum))->removeSequenceUnit(); } void InstrumentsManager::setArpeggioADPCMSequenceData(int arpNum, int cnt, int data) { arpADPCM_.at(static_cast(arpNum))->setSequenceUnit(cnt, ArpeggioUnit(data)); } std::vector InstrumentsManager::getArpeggioADPCMSequence(int arpNum) { return arpADPCM_.at(static_cast(arpNum))->getSequence(); } void InstrumentsManager::addArpeggioADPCMLoop(int arpNum, const InstrumentSequenceLoop& loop) { arpADPCM_.at(static_cast(arpNum))->addLoop(loop); } void InstrumentsManager::removeArpeggioADPCMLoop(int arpNum, int begin, int end) { arpADPCM_.at(static_cast(arpNum))->removeLoop(begin, end); } void InstrumentsManager::changeArpeggioADPCMLoop(int arpNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { arpADPCM_.at(static_cast(arpNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearArpeggioADPCMLoops(int arpNum) { arpADPCM_.at(static_cast(arpNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getArpeggioADPCMLoopRoot(int arpNum) const { return arpADPCM_.at(static_cast(arpNum))->getLoopRoot(); } void InstrumentsManager::setArpeggioADPCMRelease(int arpNum, const InstrumentSequenceRelease& release) { arpADPCM_.at(static_cast(arpNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getArpeggioADPCMRelease(int arpNum) const { return arpADPCM_.at(static_cast(arpNum))->getRelease(); } ArpeggioIter InstrumentsManager::getArpeggioADPCMIterator(int arpNum) const { return arpADPCM_.at(static_cast(arpNum))->getIterator(); } std::multiset InstrumentsManager::getArpeggioADPCMUsers(int arpNum) const { return arpADPCM_.at(static_cast(arpNum))->getUserInstruments(); } std::vector InstrumentsManager::getArpeggioADPCMEntriedIndices() const { return utils::findIndicesIf(arpADPCM_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignableArpeggioADPCM() const { return findFirstAssignableProperty(arpADPCM_, regardingUnedited_); } void InstrumentsManager::setInstrumentADPCMPitchEnabled(int instNum, bool enabled) { auto adpcm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); adpcm->setPitchEnabled(enabled); if (enabled) ptADPCM_.at(static_cast(adpcm->getPitchNumber()))->registerUserInstrument(instNum); else ptADPCM_.at(static_cast(adpcm->getPitchNumber()))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentADPCMPitchEnabled(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getPitchEnabled(); } void InstrumentsManager::setInstrumentADPCMPitch(int instNum, int ptNum) { auto adpcm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (adpcm->getPitchEnabled()) { ptADPCM_.at(static_cast(adpcm->getPitchNumber()))->deregisterUserInstrument(instNum); ptADPCM_.at(static_cast(ptNum))->registerUserInstrument(instNum); } adpcm->setPitchNumber(ptNum); } int InstrumentsManager::getInstrumentADPCMPitch(int instNum) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getPitchNumber(); } void InstrumentsManager::setPitchADPCMType(int ptNum, SequenceType type) { ptADPCM_.at(static_cast(ptNum))->setType(type); } SequenceType InstrumentsManager::getPitchADPCMType(int ptNum) const { return ptADPCM_.at(static_cast(ptNum))->getType(); } void InstrumentsManager::addPitchADPCMSequenceData(int ptNum, int data) { ptADPCM_.at(static_cast(ptNum))->addSequenceUnit(PitchUnit(data)); } void InstrumentsManager::removePitchADPCMSequenceData(int ptNum) { ptADPCM_.at(static_cast(ptNum))->removeSequenceUnit(); } void InstrumentsManager::setPitchADPCMSequenceData(int ptNum, int cnt, int data) { ptADPCM_.at(static_cast(ptNum))->setSequenceUnit(cnt, PitchUnit(data)); } std::vector InstrumentsManager::getPitchADPCMSequence(int ptNum) { return ptADPCM_.at(static_cast(ptNum))->getSequence(); } void InstrumentsManager::addPitchADPCMLoop(int ptNum, const InstrumentSequenceLoop& loop) { ptADPCM_.at(static_cast(ptNum))->addLoop(loop); } void InstrumentsManager::removePitchADPCMLoop(int ptNum, int begin, int end) { ptADPCM_.at(static_cast(ptNum))->removeLoop(begin, end); } void InstrumentsManager::changePitchADPCMLoop(int ptNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { ptADPCM_.at(static_cast(ptNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearPitchADPCMLoops(int ptNum) { ptADPCM_.at(static_cast(ptNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getPitchADPCMLoopRoot(int ptNum) const { return ptADPCM_.at(static_cast(ptNum))->getLoopRoot(); } void InstrumentsManager::setPitchADPCMRelease(int ptNum, const InstrumentSequenceRelease& release) { ptADPCM_.at(static_cast(ptNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getPitchADPCMRelease(int ptNum) const { return ptADPCM_.at(static_cast(ptNum))->getRelease(); } PitchIter InstrumentsManager::getPitchADPCMIterator(int ptNum) const { return ptADPCM_.at(static_cast(ptNum))->getIterator(); } std::multiset InstrumentsManager::getPitchADPCMUsers(int ptNum) const { return ptADPCM_.at(static_cast(ptNum))->getUserInstruments(); } std::vector InstrumentsManager::getPitchADPCMEntriedIndices() const { return utils::findIndicesIf(ptADPCM_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignablePitchADPCM() const { return findFirstAssignableProperty(ptADPCM_, regardingUnedited_); } void InstrumentsManager::setInstrumentADPCMPanEnabled(int instNum, bool enabled) { auto adpcm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); adpcm->setPanEnabled(enabled); if (enabled) panADPCM_.at(static_cast(adpcm->getPanNumber()))->registerUserInstrument(instNum); else panADPCM_.at(static_cast(adpcm->getPanNumber()))->deregisterUserInstrument(instNum); } bool InstrumentsManager::getInstrumentADPCMPanEnabled(int instNum) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getPanEnabled(); } void InstrumentsManager::setInstrumentADPCMPan(int instNum, int panNum) { auto adpcm = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (adpcm->getPanEnabled()) { panADPCM_.at(static_cast(adpcm->getPanNumber()))->deregisterUserInstrument(instNum); panADPCM_.at(static_cast(panNum))->registerUserInstrument(instNum); } adpcm->setPanNumber(panNum); } int InstrumentsManager::getInstrumentADPCMPan(int instNum) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getPanNumber(); } void InstrumentsManager::addPanADPCMSequenceData(int panNum, int data) { panADPCM_.at(static_cast(panNum))->addSequenceUnit(PanUnit(data)); } void InstrumentsManager::removePanADPCMSequenceData(int panNum) { panADPCM_.at(static_cast(panNum))->removeSequenceUnit(); } void InstrumentsManager::setPanADPCMSequenceData(int panNum, int cnt, int data) { panADPCM_.at(static_cast(panNum))->setSequenceUnit(cnt, PanUnit(data)); } std::vector InstrumentsManager::getPanADPCMSequence(int panNum) { return panADPCM_.at(static_cast(panNum))->getSequence(); } void InstrumentsManager::addPanADPCMLoop(int panNum, const InstrumentSequenceLoop& loop) { panADPCM_.at(static_cast(panNum))->addLoop(loop); } void InstrumentsManager::removePanADPCMLoop(int panNum, int begin, int end) { panADPCM_.at(static_cast(panNum))->removeLoop(begin, end); } void InstrumentsManager::changePanADPCMLoop(int panNum, int prevBegin, int prevEnd, const InstrumentSequenceLoop& loop) { panADPCM_.at(static_cast(panNum))->changeLoop(prevBegin, prevEnd, loop); } void InstrumentsManager::clearPanADPCMLoops(int panNum) { panADPCM_.at(static_cast(panNum))->clearLoops(); } InstrumentSequenceLoopRoot InstrumentsManager::getPanADPCMLoopRoot(int panNum) const { return panADPCM_.at(static_cast(panNum))->getLoopRoot(); } void InstrumentsManager::setPanADPCMRelease(int panNum, const InstrumentSequenceRelease& release) { panADPCM_.at(static_cast(panNum))->setRelease(release); } InstrumentSequenceRelease InstrumentsManager::getPanADPCMRelease(int panNum) const { return panADPCM_.at(static_cast(panNum))->getRelease(); } PanIter InstrumentsManager::getPanADPCMIterator(int panNum) const { return panADPCM_.at(static_cast(panNum))->getIterator(); } std::multiset InstrumentsManager::getPanADPCMUsers(int panNum) const { return panADPCM_.at(static_cast(panNum))->getUserInstruments(); } std::vector InstrumentsManager::getPanADPCMEntriedIndices() const { return utils::findIndicesIf(panADPCM_, IsUsedOrEdited()); } int InstrumentsManager::findFirstAssignablePanADPCM() const { return findFirstAssignableProperty(panADPCM_, regardingUnedited_); } bool InstrumentsManager::equalPropertiesADPCM(std::shared_ptr a, std::shared_ptr b) const { auto aAdpcm = std::dynamic_pointer_cast(a); auto bAdpcm = std::dynamic_pointer_cast(b); if (*sampADPCM_[aAdpcm->getSampleNumber()] != *sampADPCM_[bAdpcm->getSampleNumber()]) return false; if (aAdpcm->getEnvelopeEnabled() != bAdpcm->getEnvelopeEnabled()) return false; if (aAdpcm->getEnvelopeEnabled() && *envADPCM_[aAdpcm->getEnvelopeNumber()] != *envADPCM_[bAdpcm->getEnvelopeNumber()]) return false; if (aAdpcm->getArpeggioEnabled() != bAdpcm->getArpeggioEnabled()) return false; if (aAdpcm->getArpeggioEnabled() && *arpADPCM_[aAdpcm->getArpeggioNumber()] != *arpADPCM_[bAdpcm->getArpeggioNumber()]) return false; if (aAdpcm->getPitchEnabled() != bAdpcm->getPitchEnabled()) return false; if (aAdpcm->getPitchEnabled() && *ptADPCM_[aAdpcm->getPitchNumber()] != *ptADPCM_[bAdpcm->getPitchNumber()]) return false; if (aAdpcm->getPanEnabled() && *panADPCM_[aAdpcm->getPanNumber()] != *panADPCM_[bAdpcm->getPanNumber()]) return false; return true; } //----- Drumkit methods ----- void InstrumentsManager::setInstrumentDrumkitSamplesEnabled(int instNum, int key, bool enabled) { auto kit = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); if (enabled) { kit->setSampleEnabled(key, true); sampADPCM_.at(static_cast(kit->getSampleNumber(key)))->registerUserInstrument(instNum); } else { sampADPCM_.at(static_cast(kit->getSampleNumber(key)))->deregisterUserInstrument(instNum); kit->setSampleEnabled(key, false); } } bool InstrumentsManager::getInstrumentDrumkitSamplesEnabled(int instNum, int key) const { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getSampleEnabled(key); } void InstrumentsManager::setInstrumentDrumkitSamples(int instNum, int key, int sampNum) { auto kit = std::dynamic_pointer_cast(insts_.at(static_cast(instNum))); sampADPCM_.at(static_cast(kit->getSampleNumber(key)))->deregisterUserInstrument(instNum); sampADPCM_.at(static_cast(sampNum))->registerUserInstrument(instNum); kit->setSampleNumber(key, sampNum); } int InstrumentsManager::getInstrumentDrumkitSamples(int instNum, int key) { return std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->getSampleNumber(key); } void InstrumentsManager::setInstrumentDrumkitPitch(int instNum, int key, int pitch) { std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->setPitch(key, pitch); } void InstrumentsManager::setInstrumentDrumkitPan(int instNum, int key, int pan) { std::dynamic_pointer_cast(insts_.at(static_cast(instNum)))->setPan(key, pan); } bool InstrumentsManager::equalPropertiesDrumkit(std::shared_ptr a, std::shared_ptr b) const { auto aKit = std::dynamic_pointer_cast(a); auto bKit = std::dynamic_pointer_cast(b); std::vector aKeys = aKit->getAssignedKeys(); std::vector bKeys = bKit->getAssignedKeys(); if (aKeys.size() != bKeys.size()) return false; std::sort(aKeys.begin(), aKeys.end()); std::sort(bKeys.begin(), bKeys.end()); if (!std::includes(aKeys.cbegin(), aKeys.cend(), bKeys.cbegin(), bKeys.cend())) return false; for (const int& key : aKeys) { if (*sampADPCM_[aKit->getSampleNumber(key)] != *sampADPCM_[bKit->getSampleNumber(key)]) return false; if (aKit->getPitch(key) != bKit->getPitch(key)) return false; if (aKit->getPan(key) != bKit->getPan(key)) return false; } return true; }