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

935 lines
29 KiB
C++
Raw Blame History

#include "amuse/amuse.hpp"
#include "amuse/BooBackend.hpp"
#include "boo/boo.hpp"
#include "logvisor/logvisor.hpp"
#include <map>
#define EMITTER_TEST 0
static logvisor::Module Log("amuseplay");
struct AppCallback;
struct EventCallback : boo::IWindowCallback {
AppCallback& m_app;
bool m_tracking = false;
public:
void charKeyDown(unsigned long charCode, boo::EModifierKey mods, bool isRepeat) override;
void charKeyUp(unsigned long charCode, boo::EModifierKey mods) override;
void specialKeyDown(boo::ESpecialKey key, boo::EModifierKey mods, bool isRepeat) override;
void specialKeyUp(boo::ESpecialKey key, boo::EModifierKey mods) override;
void resized(const boo::SWindowRect&, bool) override {}
void mouseDown(const boo::SWindowCoord&, boo::EMouseButton, boo::EModifierKey) override;
void mouseUp(const boo::SWindowCoord&, boo::EMouseButton, boo::EModifierKey) override;
void mouseMove(const boo::SWindowCoord& coord) override;
EventCallback(AppCallback& app) : m_app(app) {}
};
struct AppCallback : boo::IApplicationCallback {
int m_argc;
const boo::SystemChar** m_argv;
/* Boo window and events */
EventCallback m_eventRec;
boo::DeferredWindowEvents<EventCallback> m_events;
std::shared_ptr<boo::IWindow> m_win;
/* Amuse engine */
std::unique_ptr<amuse::BooBackendVoiceAllocator> m_booBackend;
std::unique_ptr<amuse::Engine> m_engine;
int m_groupId = -1;
bool m_sfxGroup;
/* Song playback selection */
int m_setupId = -1;
int m_chanId = 0;
int8_t m_octave = 4;
int8_t m_velocity = 64;
amuse::ObjToken<amuse::Sequencer> m_seq;
amuse::ContainerRegistry::SongData* m_arrData = nullptr;
/* SFX playback selection */
int m_sfxId = -1;
amuse::ObjToken<amuse::Voice> m_vox;
size_t m_lastVoxCount = 0;
int8_t m_lastChanProg = -1;
/* Control state */
float m_volume = 0.8f;
float m_modulation = 0.f;
float m_pitchBend = 0.f;
bool m_updateDisp = false;
bool m_running = true;
bool m_wantsNext = false;
bool m_wantsPrev = false;
bool m_breakout = false;
int m_panicCount = 0;
#if EMITTER_TEST
amuse::Vector3f m_pos = {};
amuse::Vector3f m_dir = {0.f, 0.f, 0.f};
amuse::Vector3f m_listenerDir = {0.f, 40.f, 0.f};
std::shared_ptr<amuse::Emitter> m_emitter;
std::shared_ptr<amuse::Listener> m_listener;
#endif
void UpdateSongDisplay() {
size_t voxCount = 0;
int program = 0;
if (m_seq) {
voxCount = m_seq->getVoiceCount();
program = m_seq->getChanProgram(m_chanId);
}
fmt::print(fmt(
"\r "
"\r {} Setup {}, Chan {}, Prog {}, Octave: {}, Vel: {}, VOL: {}%\r"),
voxCount, m_setupId, m_chanId, program, m_octave, m_velocity, int(std::rint(m_volume * 100)));
fflush(stdout);
}
void SelectSong(int setupId) {
m_setupId = setupId;
if (m_seq) {
m_seq->stopSong(0.f, true);
m_seq->kill();
}
m_seq = m_engine->seqPlay(m_groupId, setupId, nullptr);
m_engine->setVolume(m_volume);
if (m_arrData)
m_seq->playSong(m_arrData->m_data.get(), false);
UpdateSongDisplay();
}
void SongLoop(const amuse::SongGroupIndex& index) {
fmt::print(fmt(
"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░\n"
"░░░ ████ ████ ┃ ████ ████ ████ ┃ ████ ████ ░░░\n"
"░░░ ████ ████ ┃ ████ ████ ████ ┃ ████ ████ ░░░\n"
"░░░ ▌W▐█ ▌E▐█ ┃ ▌T▐█ ▌Y▐█ ▌U▐█ ┃ ▌O▐█ ▌P▐█ ░░░\n"
"░░░ │ │ ┃ │ │ │ ┃ │ │ ░░░\n"
"░░░ A │ S │ D ┃ F │ G │ H │ J ┃ K │ L │ ; ░░░\n"
"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░\n"
"<left/right>: cycle MIDI setup, <up/down>: volume, <space>: PANIC\n"
"<tab>: sustain pedal, <window-Y>: pitch wheel, <window-X>: mod wheel\n"
"<Z/X>: octave, <C/V>: velocity, <B/N>: channel, <,/.>: program, <Q>: quit\n"));
std::map<amuse::SongId, std::array<amuse::SongGroupIndex::MIDISetup, 16>> sortEntries(index.m_midiSetups.cbegin(),
index.m_midiSetups.cend());
auto setupIt = sortEntries.cbegin();
if (setupIt != sortEntries.cend()) {
if (m_setupId == -1)
SelectSong(setupIt->first.id);
else {
while (setupIt != sortEntries.cend() && setupIt->first != m_setupId)
++setupIt;
if (setupIt == sortEntries.cend())
setupIt = sortEntries.cbegin();
SelectSong(setupIt->first.id);
}
}
while (m_running) {
m_events.dispatchEvents();
if (m_wantsNext) {
m_wantsNext = false;
auto nextIt = setupIt;
++nextIt;
if (nextIt != sortEntries.cend()) {
++setupIt;
SelectSong(setupIt->first.id);
m_updateDisp = false;
}
}
if (m_wantsPrev) {
m_wantsPrev = false;
if (setupIt != sortEntries.cbegin()) {
--setupIt;
SelectSong(setupIt->first.id);
m_updateDisp = false;
}
}
if (m_seq && m_panicCount) {
if (m_panicCount > 1) {
m_seq->allOff(true);
m_panicCount = 0;
} else
m_seq->allOff(false);
m_updateDisp = true;
}
if (m_updateDisp) {
m_updateDisp = false;
UpdateSongDisplay();
}
m_win->waitForRetrace();
size_t voxCount;
int8_t progId;
if (m_seq) {
voxCount = m_seq->getVoiceCount();
progId = m_seq->getChanProgram(m_chanId);
} else {
voxCount = 0;
progId = -1;
}
if (m_lastVoxCount != voxCount || m_lastChanProg != progId) {
m_lastVoxCount = voxCount;
m_lastChanProg = progId;
UpdateSongDisplay();
}
if (m_breakout) {
m_breakout = false;
m_seq->allOff(true);
m_seq.reset();
break;
}
}
}
void UpdateSFXDisplay() {
bool playing = m_vox && m_vox->state() == amuse::VoiceState::Playing;
#if EMITTER_TEST
printf(
"\r "
"\r %c SFX %d, VOL: %d%% POS: (%f,%f)\r",
playing ? '>' : ' ', m_sfxId, int(std::rint(m_volume * 100)), m_pos[0], m_pos[1]);
#else
fmt::print(fmt(
"\r "
"\r {:c} SFX {}, VOL: {}%\r"),
playing ? '>' : ' ', m_sfxId, int(std::rint(m_volume * 100)));
#endif
fflush(stdout);
}
void SelectSFX(int sfxId) {
m_sfxId = sfxId;
bool playing = m_vox && m_vox->state() == amuse::VoiceState::Playing;
if (playing) {
#if EMITTER_TEST
if (m_emitter)
m_emitter->getVoice()->keyOff();
m_emitter = m_engine->addEmitter(m_pos, m_dir, 100.f, 0.f, m_sfxId, 0.f, 1.f, true);
m_vox = m_emitter->getVoice();
#else
m_vox->keyOff();
m_vox = m_engine->fxStart(m_sfxId, m_volume, 0.f);
#endif
}
UpdateSFXDisplay();
}
void SFXLoop(const amuse::SFXGroupIndex& index) {
fmt::print(fmt("<space>: keyon/keyoff, <left/right>: cycle SFX, <up/down>: volume, <Q>: quit\n"));
m_seq = m_engine->seqPlay(m_groupId, 0, nullptr);
std::map<amuse::SFXId, amuse::SFXGroupIndex::SFXEntry> sortEntries(index.m_sfxEntries.cbegin(),
index.m_sfxEntries.cend());
auto sfxIt = sortEntries.cbegin();
if (sfxIt != sortEntries.cend())
SelectSFX(sfxIt->first.id);
#if EMITTER_TEST
float emitterTheta = 0.f;
float zeroVec[3] = {};
float heading[3] = {0.f, 1.f, 0.f};
float up[3] = {0.f, 0.f, 1.f};
m_listener = m_engine->addListener(zeroVec, m_listenerDir, heading, up, 5.f, 5.f, 1000.f, 1.f);
#endif
while (m_running) {
#if EMITTER_TEST
// float dist = std::sin(emitterTheta * 0.25f);
m_pos[0] = std::cos(emitterTheta) * 5.f;
m_pos[1] = std::sin(emitterTheta) * 5.f;
if (m_emitter)
m_emitter->setVectors(m_pos, m_dir);
emitterTheta += 1.f / 60.f;
m_updateDisp = true;
#endif
m_events.dispatchEvents();
if (m_wantsNext) {
m_wantsNext = false;
auto nextIt = sfxIt;
++nextIt;
if (nextIt != sortEntries.cend()) {
++sfxIt;
SelectSFX(sfxIt->first.id);
m_updateDisp = false;
}
}
if (m_wantsPrev) {
m_wantsPrev = false;
if (sfxIt != sortEntries.cbegin()) {
--sfxIt;
SelectSFX(sfxIt->first.id);
m_updateDisp = false;
}
}
if (m_updateDisp) {
m_updateDisp = false;
UpdateSFXDisplay();
}
m_win->waitForRetrace();
if (m_vox && m_vox->state() == amuse::VoiceState::Dead) {
m_vox.reset();
#if EMITTER_TEST
m_emitter.reset();
#endif
UpdateSFXDisplay();
}
if (m_breakout) {
m_breakout = false;
m_vox.reset();
#if EMITTER_TEST
m_emitter.reset();
#endif
m_seq->allOff(true);
m_seq.reset();
break;
}
}
#if EMITTER_TEST
m_engine->removeListener(m_listener.get());
m_listener.reset();
#endif
}
void charKeyDownRepeat(unsigned long charCode) {
charCode = tolower(charCode);
if (m_seq && m_chanId != -1) {
switch (charCode) {
case 'z':
m_octave = std::clamp(-1, m_octave - 1, 8);
m_updateDisp = true;
break;
case 'x':
m_octave = std::clamp(-1, m_octave + 1, 8);
m_updateDisp = true;
break;
case 'c':
m_velocity = std::clamp(0, m_velocity - 1, 127);
m_updateDisp = true;
break;
case 'v':
m_velocity = std::clamp(0, m_velocity + 1, 127);
m_updateDisp = true;
break;
case 'b':
m_chanId = std::clamp(0, m_chanId - 1, 15);
m_updateDisp = true;
break;
case 'n':
m_chanId = std::clamp(0, m_chanId + 1, 15);
m_updateDisp = true;
break;
case ',':
m_seq->prevChanProgram(m_chanId);
m_updateDisp = true;
break;
case '.':
m_seq->nextChanProgram(m_chanId);
m_updateDisp = true;
break;
default:
break;
}
}
}
void charKeyDown(unsigned long charCode) {
charCode = tolower(charCode);
if (charCode == 'q') {
m_running = false;
return;
}
if (m_sfxGroup) {
switch (charCode) {
case ' ':
if (m_seq)
m_seq->allOff(true);
if (m_vox && m_vox->state() == amuse::VoiceState::Playing)
m_vox->keyOff();
else if (m_sfxId != -1) {
#if EMITTER_TEST
m_emitter = m_engine->addEmitter(m_pos, m_dir, 100.f, 0.f, m_sfxId, 0.f, 1.f, true);
m_vox = m_emitter->getVoice();
#else
m_vox = m_engine->fxStart(m_sfxId, m_volume, 0.f);
#endif
}
m_updateDisp = true;
break;
default:
break;
}
} else if (m_seq && m_chanId != -1) {
bool setPanic = false;
switch (charCode) {
case ' ':
++m_panicCount;
setPanic = true;
break;
case 'z':
m_octave = std::clamp(-1, m_octave - 1, 8);
m_updateDisp = true;
break;
case 'x':
m_octave = std::clamp(-1, m_octave + 1, 8);
m_updateDisp = true;
break;
case 'c':
m_velocity = std::clamp(0, m_velocity - 1, 127);
m_updateDisp = true;
break;
case 'v':
m_velocity = std::clamp(0, m_velocity + 1, 127);
m_updateDisp = true;
break;
case 'b':
m_chanId = std::clamp(0, m_chanId - 1, 15);
m_updateDisp = true;
break;
case 'n':
m_chanId = std::clamp(0, m_chanId + 1, 15);
m_updateDisp = true;
break;
case ',':
m_seq->prevChanProgram(m_chanId);
m_updateDisp = true;
break;
case '.':
m_seq->nextChanProgram(m_chanId);
m_updateDisp = true;
break;
case '\t':
m_seq->setCtrlValue(m_chanId, 64, 127);
break;
case 'a':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12, m_velocity);
break;
case 'w':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 1, m_velocity);
break;
case 's':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 2, m_velocity);
break;
case 'e':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 3, m_velocity);
break;
case 'd':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 4, m_velocity);
break;
case 'f':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 5, m_velocity);
break;
case 't':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 6, m_velocity);
break;
case 'g':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 7, m_velocity);
break;
case 'y':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 8, m_velocity);
break;
case 'h':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 9, m_velocity);
break;
case 'u':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 10, m_velocity);
break;
case 'j':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 11, m_velocity);
break;
case 'k':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 12, m_velocity);
break;
case 'o':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 13, m_velocity);
break;
case 'l':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 14, m_velocity);
break;
case 'p':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 15, m_velocity);
break;
case ';':
case ':':
m_seq->keyOn(m_chanId, (m_octave + 1) * 12 + 16, m_velocity);
break;
default:
break;
}
if (!setPanic)
m_panicCount = 0;
}
}
void charKeyUp(unsigned long charCode) {
charCode = tolower(charCode);
if (!m_sfxGroup && m_chanId != -1) {
switch (charCode) {
case '\t':
m_seq->setCtrlValue(m_chanId, 64, 0);
break;
case 'a':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12, m_velocity);
break;
case 'w':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 1, m_velocity);
break;
case 's':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 2, m_velocity);
break;
case 'e':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 3, m_velocity);
break;
case 'd':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 4, m_velocity);
break;
case 'f':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 5, m_velocity);
break;
case 't':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 6, m_velocity);
break;
case 'g':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 7, m_velocity);
break;
case 'y':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 8, m_velocity);
break;
case 'h':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 9, m_velocity);
break;
case 'u':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 10, m_velocity);
break;
case 'j':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 11, m_velocity);
break;
case 'k':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 12, m_velocity);
break;
case 'o':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 13, m_velocity);
break;
case 'l':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 14, m_velocity);
break;
case 'p':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 15, m_velocity);
break;
case ';':
case ':':
m_seq->keyOff(m_chanId, (m_octave + 1) * 12 + 16, m_velocity);
break;
default:
break;
}
}
}
int appMain(boo::IApplication* app) override {
/* Event window */
m_win = app->newWindow(_SYS_STR("amuseplay"));
m_win->setCallback(&m_events);
m_win->setWindowFrame(100, 100, 100, 100);
m_win->setStyle(~boo::EWindowStyle::Resize);
m_win->showWindow();
boo::ObjToken<boo::ITextureR> tex;
m_win->getMainContextDataFactory()->commitTransaction([&](boo::IGraphicsDataFactory::Context& ctx) {
tex = ctx.newRenderTexture(100, 100, boo::TextureClampMode::Repeat, 1, 0);
return true;
} BooTrace);
boo::IGraphicsCommandQueue* q = m_win->getCommandQueue();
q->setRenderTarget(tex);
q->clearTarget();
q->resolveDisplay(tex);
q->execute();
/* Load data */
if (m_argc < 2) {
Log.report(logvisor::Error, fmt("needs group path argument"));
return 1;
}
amuse::ContainerRegistry::Type cType = amuse::ContainerRegistry::DetectContainerType(m_argv[1]);
if (cType == amuse::ContainerRegistry::Type::Invalid) {
Log.report(logvisor::Error, fmt("invalid/no data at path argument"));
return 1;
}
Log.report(logvisor::Info, fmt(_SYS_STR("Found '%s' Audio Group data")), amuse::ContainerRegistry::TypeToName(cType));
std::vector<std::pair<amuse::SystemString, amuse::IntrusiveAudioGroupData>> data =
amuse::ContainerRegistry::LoadContainer(m_argv[1]);
if (data.empty()) {
Log.report(logvisor::Error, fmt("invalid/no data at path argument"));
return 1;
}
std::list<amuse::AudioGroupProject> m_projs;
std::map<amuse::GroupId, std::pair<std::pair<amuse::SystemString, amuse::IntrusiveAudioGroupData>*,
amuse::ObjToken<amuse::SongGroupIndex>>>
allSongGroups;
std::map<amuse::GroupId, std::pair<std::pair<amuse::SystemString, amuse::IntrusiveAudioGroupData>*,
amuse::ObjToken<amuse::SFXGroupIndex>>>
allSFXGroups;
size_t totalGroups = 0;
for (auto& grp : data) {
/* Load project to assemble group list */
m_projs.push_back(amuse::AudioGroupProject::CreateAudioGroupProject(grp.second));
amuse::AudioGroupProject& proj = m_projs.back();
totalGroups += proj.sfxGroups().size() + proj.songGroups().size();
for (auto it = proj.songGroups().begin(); it != proj.songGroups().end(); ++it)
allSongGroups[it->first] = std::make_pair(&grp, it->second);
for (auto it = proj.sfxGroups().begin(); it != proj.sfxGroups().end(); ++it)
allSFXGroups[it->first] = std::make_pair(&grp, it->second);
}
while (m_running) {
m_groupId = -1;
m_setupId = -1;
/* Attempt loading song */
std::vector<std::pair<amuse::SystemString, amuse::ContainerRegistry::SongData>> songs;
if (m_argc > 2)
songs = amuse::ContainerRegistry::LoadSongs(m_argv[2]);
else
songs = amuse::ContainerRegistry::LoadSongs(m_argv[1]);
if (songs.size()) {
bool play = true;
if (m_argc <= 2) {
bool prompt = true;
while (true) {
if (prompt) {
fmt::print(fmt("Play Song? (Y/N): "));
prompt = false;
}
char userSel;
if (scanf("%c", &userSel) <= 0 || userSel == '\n')
continue;
userSel = tolower(userSel);
if (userSel == 'n')
play = false;
else if (userSel != 'y') {
prompt = true;
continue;
}
break;
}
}
if (play) {
/* Get song selection from user */
if (songs.size() > 1) {
/* Ask user to specify which song */
fmt::print(fmt("Multiple Songs discovered:\n"));
int idx = 0;
for (const auto& pair : songs) {
const amuse::ContainerRegistry::SongData& sngData = pair.second;
int16_t grpId = sngData.m_groupId;
int16_t setupId = sngData.m_setupId;
if (sngData.m_groupId == -1 && sngData.m_setupId != -1) {
for (const auto& pair : allSongGroups) {
for (const auto& setup : pair.second.second->m_midiSetups) {
if (setup.first == sngData.m_setupId) {
grpId = pair.first.id;
break;
}
}
if (grpId != -1)
break;
}
}
fmt::print(fmt(_SYS_STR(" {} {} (Group {}, Setup {})\n")), idx++, pair.first, grpId, setupId);
}
int userSel = 0;
fmt::print(fmt("Enter Song Number: "));
if (scanf("%d", &userSel) <= 0) {
Log.report(logvisor::Error, fmt("unable to parse prompt"));
return 1;
}
if (userSel < songs.size()) {
m_arrData = &songs[userSel].second;
m_groupId = m_arrData->m_groupId;
m_setupId = m_arrData->m_setupId;
} else {
Log.report(logvisor::Error, fmt("unable to find Song {}"), userSel);
return 1;
}
} else if (songs.size() == 1) {
m_arrData = &songs[0].second;
m_groupId = m_arrData->m_groupId;
m_setupId = m_arrData->m_setupId;
}
}
}
/* Get group selection via setup search */
if (m_groupId == -1 && m_setupId != -1) {
for (const auto& pair : allSongGroups) {
for (const auto& setup : pair.second.second->m_midiSetups) {
if (setup.first == m_setupId) {
m_groupId = pair.first.id;
break;
}
}
if (m_groupId != -1)
break;
}
}
/* Get group selection via user */
if (m_groupId != -1) {
if (allSongGroups.find(m_groupId) != allSongGroups.end())
m_sfxGroup = false;
else if (allSFXGroups.find(m_groupId) != allSFXGroups.end())
m_sfxGroup = true;
else {
Log.report(logvisor::Error, fmt("unable to find Group {}"), m_groupId);
return 1;
}
} else if (totalGroups > 1) {
/* Ask user to specify which group in project */
fmt::print(fmt("Multiple Audio Groups discovered:\n"));
for (const auto& pair : allSFXGroups) {
fmt::print(fmt(_SYS_STR(" {} {} (SFXGroup) {} sfx-entries\n")), pair.first,
pair.second.first->first, pair.second.second->m_sfxEntries.size());
}
for (const auto& pair : allSongGroups) {
fmt::print(fmt(_SYS_STR(" {} {} (SongGroup) {} normal-pages, {} drum-pages, {} MIDI-setups\n")),
pair.first, pair.second.first->first, pair.second.second->m_normPages.size(),
pair.second.second->m_drumPages.size(), pair.second.second->m_midiSetups.size());
}
int userSel = 0;
fmt::print(fmt("Enter Group Number: "));
if (scanf("%d", &userSel) <= 0) {
Log.report(logvisor::Error, fmt("unable to parse prompt"));
return 1;
}
if (allSongGroups.find(userSel) != allSongGroups.end()) {
m_groupId = userSel;
m_sfxGroup = false;
} else if (allSFXGroups.find(userSel) != allSFXGroups.end()) {
m_groupId = userSel;
m_sfxGroup = true;
} else {
Log.report(logvisor::Error, fmt("unable to find Group {}"), userSel);
return 1;
}
} else if (totalGroups == 1) {
/* Load one and only group */
if (allSongGroups.size()) {
const auto& pair = *allSongGroups.cbegin();
m_groupId = pair.first.id;
m_sfxGroup = false;
} else {
const auto& pair = *allSFXGroups.cbegin();
m_groupId = pair.first.id;
m_sfxGroup = true;
}
} else {
Log.report(logvisor::Error, fmt("empty project"));
return 1;
}
/* Make final group selection */
amuse::IntrusiveAudioGroupData* selData = nullptr;
amuse::ObjToken<amuse::SongGroupIndex> songIndex;
amuse::ObjToken<amuse::SFXGroupIndex> sfxIndex;
auto songSearch = allSongGroups.find(m_groupId);
if (songSearch != allSongGroups.end()) {
selData = &songSearch->second.first->second;
songIndex = songSearch->second.second;
} else {
auto sfxSearch = allSFXGroups.find(m_groupId);
if (sfxSearch != allSFXGroups.end()) {
selData = &sfxSearch->second.first->second;
sfxIndex = sfxSearch->second.second;
}
}
if (!selData) {
Log.report(logvisor::Error, fmt("unable to select audio group data"));
return 1;
}
/* Build voice engine */
std::unique_ptr<boo::IAudioVoiceEngine> voxEngine = boo::NewAudioVoiceEngine();
m_booBackend.reset(new amuse::BooBackendVoiceAllocator(*voxEngine));
m_engine.reset(new amuse::Engine(*m_booBackend, amuse::AmplitudeMode::PerSample));
/* Load group into engine */
const amuse::AudioGroup* group = m_engine->addAudioGroup(*selData);
if (!group) {
Log.report(logvisor::Error, fmt("unable to add audio group"));
return 1;
}
/* Enter playback loop */
if (m_sfxGroup)
SFXLoop(*sfxIndex);
else
SongLoop(*songIndex);
m_vox.reset();
m_seq.reset();
m_engine.reset();
m_booBackend.reset();
fmt::print(fmt("\n\n"));
}
return 0;
}
void appQuitting(boo::IApplication*) override { m_running = false; }
AppCallback(int argc, const boo::SystemChar** argv)
: m_argc(argc), m_argv(argv), m_eventRec(*this), m_events(m_eventRec) {}
};
void EventCallback::charKeyDown(unsigned long charCode, boo::EModifierKey mods, bool isRepeat) {
if (isRepeat)
m_app.charKeyDownRepeat(charCode);
else
m_app.charKeyDown(charCode);
}
void EventCallback::charKeyUp(unsigned long charCode, boo::EModifierKey mods) { m_app.charKeyUp(charCode); }
void EventCallback::specialKeyDown(boo::ESpecialKey key, boo::EModifierKey mods, bool isRepeat) {
switch (key) {
case boo::ESpecialKey::Left:
m_app.m_wantsPrev = true;
break;
case boo::ESpecialKey::Right:
m_app.m_wantsNext = true;
break;
case boo::ESpecialKey::Up:
if (m_app.m_volume < 1.f)
m_app.m_volume = std::clamp(0.f, m_app.m_volume + 0.05f, 1.f);
m_app.m_engine->setVolume(m_app.m_volume);
m_app.m_updateDisp = true;
break;
case boo::ESpecialKey::Down:
if (m_app.m_volume > 0.f)
m_app.m_volume = std::clamp(0.f, m_app.m_volume - 0.05f, 1.f);
m_app.m_engine->setVolume(m_app.m_volume);
m_app.m_updateDisp = true;
break;
case boo::ESpecialKey::Esc:
m_app.m_breakout = true;
break;
default:
break;
}
}
void EventCallback::specialKeyUp(boo::ESpecialKey key, boo::EModifierKey mods) {}
void EventCallback::mouseDown(const boo::SWindowCoord& coord, boo::EMouseButton, boo::EModifierKey) {
m_tracking = true;
m_app.m_pitchBend = std::clamp(-1.f, coord.norm[1] * 2.f - 1.f, 1.f);
if (m_app.m_vox)
m_app.m_vox->setPitchWheel(m_app.m_pitchBend);
if (m_app.m_seq && m_app.m_chanId != -1)
m_app.m_seq->setPitchWheel(m_app.m_chanId, m_app.m_pitchBend);
}
void EventCallback::mouseUp(const boo::SWindowCoord&, boo::EMouseButton, boo::EModifierKey) {
m_tracking = false;
m_app.m_pitchBend = 0.f;
if (m_app.m_vox)
m_app.m_vox->setPitchWheel(m_app.m_pitchBend);
if (m_app.m_seq && m_app.m_chanId != -1)
m_app.m_seq->setPitchWheel(m_app.m_chanId, m_app.m_pitchBend);
}
void EventCallback::mouseMove(const boo::SWindowCoord& coord) {
if (m_tracking) {
m_app.m_modulation = std::clamp(0.f, coord.norm[0], 1.f);
if (m_app.m_vox)
m_app.m_vox->setCtrlValue(1, m_app.m_modulation * 127.f);
if (m_app.m_seq && m_app.m_chanId != -1)
m_app.m_seq->setCtrlValue(m_app.m_chanId, 1, m_app.m_modulation * 127.f);
m_app.m_pitchBend = std::clamp(-1.f, coord.norm[1] * 2.f - 1.f, 1.f);
if (m_app.m_vox)
m_app.m_vox->setPitchWheel(m_app.m_pitchBend);
if (m_app.m_seq && m_app.m_chanId != -1)
m_app.m_seq->setPitchWheel(m_app.m_chanId, m_app.m_pitchBend);
}
}
#if _WIN32
int wmain(int argc, const boo::SystemChar** argv)
#else
int main(int argc, const boo::SystemChar** argv)
#endif
{
logvisor::RegisterConsoleLogger();
logvisor::RegisterStandardExceptions();
AppCallback app(argc, argv);
int ret = boo::ApplicationRun(boo::IApplication::EPlatformType::Auto, app, _SYS_STR("amuseplay"),
_SYS_STR("Amuse Player"), argc, argv, {}, 1, 1, false);
fmt::print(fmt("IM DYING!!\n"));
return ret;
}
#if _WIN32
#include <shellapi.h>
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR lpCmdLine, int) {
int argc = 0;
const boo::SystemChar** argv;
if (lpCmdLine[0])
argv = (const wchar_t**)(CommandLineToArgvW(lpCmdLine, &argc));
static boo::SystemChar selfPath[1024];
GetModuleFileNameW(nullptr, selfPath, 1024);
static const boo::SystemChar* booArgv[32] = {};
booArgv[0] = selfPath;
for (int i = 0; i < argc; ++i)
booArgv[i + 1] = argv[i];
logvisor::CreateWin32Console();
SetConsoleOutputCP(65001);
return wmain(argc + 1, booArgv);
}
#endif
Reference in New Issue View Git Blame Copy Permalink